feat(search): Elasticsearch searcher (name+content) and oo search (#37)

Reviewed-on: #24

.env.example

@@ -25,3 +25,19 @@ ONLYOFFICE_PROJECT_ID=33
 # cmd/office TUI — optional Document Server for DOCX→HTML preview:
 # ONLYOFFICE_DOCS_URL=https://docs.example.com
 # ONLYOFFICE_DOCS_SECRET=
+
+# MinIO download fallback for the portal's stale AWS S3 consumer (older
+# Documents folders). When the portal redirects to amazonaws.com with access
+# key "minio" (403 InvalidAccessKeyId), files are fetched from the local MinIO
+# store instead. Without a key/secret the fallback is disabled.
+# MINIO_ENDPOINT=http://192.168.188.10:9000
+# MINIO_BUCKET=office
+# MINIO_ACCESS_KEY=
+# MINIO_SECRET_KEY=
+
+# oo search — direct Elasticsearch access for name + content search. ES lives
+# inside the OnlyOffice VM on localhost:9200; expose it with an SSH tunnel
+# (see docs/elasticsearch.md). ONLYOFFICE_ES_INDEX defaults to files_file.
+# ONLYOFFICE_ES_URL=http://127.0.0.1:9200
+# ONLYOFFICE_ES_INDEX=files_file
+# ONLYOFFICE_TENANT=

.github/FUNDING.yml

@@ -0,0 +1,6 @@
+github: eSlider
+ko_fi: eslider
+liberapay: eslider
+patreon: eslider
+custom:
+  - https://polar.sh/eslider

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.15.0"
+  ".": "0.17.0"
 }

AGENTS.md

@@ -9,16 +9,17 @@ Canonical Go client for OnlyOffice Workspace (Projects + Calendar + CRM) and the
   - `request.go` — `Request`, `Query`, `Time`, `Token`, `MetaResponse`, `Permissions`.
   - `auth.go` — `Authenticate`, `AuthenticateContext`, `InvalidateToken`, `Auth`, token lifecycle.
   - `http.go` — transport + DRY response decoders (`ResponseArray`/`ResponseObject`/`postFormObject`/`putFormObject`/`deleteObject`).
-  - `projects.go`, `tasks.go`, `users.go`, `calendar.go`, `crm.go`, `files.go`, `mails.go`, `invoices.go` — typed / untyped domain methods. **`files.go`** — CRM opportunity upload plus **project/task Documents**. **`mails.go`** — OnlyOffice Workspace Mail. **`invoices.go`** — CRM invoices, PDF regen/cleanup, status. Association rules: [`docs/crm-associations.md`](docs/crm-associations.md).
+  - `projects.go`, `tasks.go`, `users.go`, `calendar.go`, `crm.go`, `files.go`, `files_webdav.go`, `files_stem.go`, `retry.go`, `mails.go`, `invoices.go` — typed / untyped domain methods. **`files.go`** — CRM opportunity upload plus **project/task Documents** (`UpdateFile`, `UploadToFolderReplacing`). **`files_webdav.go`** — Documents module by id (`ListDavFolder`, `MoveDavItems`/`CopyDavItems` with per-operation error surfacing, `ListFileOps`). **`retry.go`** — `DoRetry`: deterministic linear backoff (no jitter) on 429/502/503/504; every bulk tool routes API calls through it. **`mails.go`** — OnlyOffice Workspace Mail. **`invoices.go`** — CRM invoices, PDF regen/cleanup, status. Association rules: [`docs/crm-associations.md`](docs/crm-associations.md).
   - Pure stdlib + `google/go-querystring`; no UI, no dotenv.
 - **CLI — `cmd/oo/` as `package main`.** Cobra wrapper that loads `.env` via `godotenv` at startup. **Subject-based command tree** mirroring [`tea`](https://gitea.com/gitea/tea):
   - `main.go` — entry point (docstring lists the command tree).
   - `common.go` — `rootCmd`, `newOO`, `printTable`/`printObject`, `--output table|json` flag.
-  - `calendar.go`, `projects.go`, `projects_files.go`, `tasks.go`, `tasks_files.go`, `users.go`, `contacts.go`, `opportunities.go`, `cases.go`, `crm_tasks.go`, `mails.go`, `invoices.go` — one file per subject (or per subject facet), each registers in `init()`.
+  - `calendar.go`, `projects.go`, `projects_files.go`, `tasks.go`, `tasks_files.go`, `users.go`, `contacts.go`, `opportunities.go`, `cases.go`, `crm.go`, `crm_tasks.go`, `catalog.go`, `docs.go`, `dav.go`, `mails.go`, `invoices.go` — one file per subject (or per subject facet), each registers in `init()`. `dav.go` exposes the Documents module by id (`oo dav ls|move|copy|mkdir|rename-file|rename-folder|download|fileops`).
   - CLI-only deps (`spf13/cobra`, `joho/godotenv`) stay out of the library.
 - **TUI — `cmd/office/` as `package main`.** Bubble Tea three-pane browser (module tree, selectable list, markdown preview). Reuses `cmd/internal/bootstrap` for env/auth and the root `onlyoffice` library for all API calls. UI logic in `cmd/office/ui/`; preview/formatting in `cmd/office/preview/`; list loaders in `cmd/office/fetch/`.
   - **List table (`DataTable`)** — `cmd/office/ui/table*.go`. Column layout policies live in `cmd/office/model/table_layout.go` (`TableFlexLayoutFor`); cell rendering uses the bubbles/table inline pattern in `table_render.go` (`renderTableCell`, `padANSIWidth`). See `.cursor/skills/office-tui-table/SKILL.md` before changing center-pane tables.
 - **Shared bootstrap — `cmd/internal/bootstrap/`.** `LoadEnv()` + `NewClient(ctx)` extracted from `oo`; both binaries import it.
+- **Bulk Documents tools — `cmd/ooscan/`, `cmd/pdfamount/`, `cmd/kontoblatt/`, `cmd/kontolink/`.** Single-purpose binaries (folder index, PDF amounts, Kontoblatt summary/linking). Pace requests, route API calls through `DoRetry`; usage in README.
 - **Personal ops tooling** (disk inventory, dossier→CRM sync, SearXNG) lives in private [`eSlider/oo-workspace`](https://git.produktor.io/eSlider/oo-workspace) (`oow`), not in this public tree.
 
 ## Rules
@@ -27,8 +28,8 @@ Canonical Go client for OnlyOffice Workspace (Projects + Calendar + CRM) and the
 - New endpoints go into the library first; CLI commands are thin wrappers.
 - Prefer `ResponseObject` / `postFormObject` / `putFormObject` / `deleteObject` over hand-rolled `json.Unmarshal(responseField(...))` blocks — they exist for DRY, use them.
 - Domain split is by file, **not** by subpackage. Don't introduce `internal/` or `pkg/*` subpackages inside the library — it flattens the `*Client` call surface for a reason.
-- CLI commands follow **subject → verb** structure (`oo <subject> <verb>`), never `oo <verb>-<subject>`. Add new commands to the existing subject file if one fits; create a new `cmd/oo/<subject>.go` for a genuinely new domain.
-- **Documents for agents:** prefer Markdown in git; OnlyOffice UI is weak for `.md`/`.txt`. Use `oo docs put-md` (md→docx) and `oo docs put-txt` (txt→docx, preserves line breaks). `oo projects files dedupe PROJECT_ID` reports/removes duplicate stem|ext copies (`--apply`, `--cross`).
+- CLI commands follow **subject → verb** structure (`oo <subject> <verb>`), never `oo <verb>-<subject>`. Add new commands to the existing subject file if one fits; create a new `cmd/oo/<subject>.go` for a genuinely new domain. The subject→verb tree in `cmd/oo/main.go` and the README table are documentation — update them with the code.
+- **Documents for agents:** prefer Markdown in git; OnlyOffice UI is weak for `.md`/`.txt`. Use `oo docs put-md` (md→docx) and `oo docs put-txt` (txt→docx, preserves line breaks). All upload paths default to **upsert** by `stem|ext` (`--replace`, default true); `--no-replace` fails on conflict; `--allow-duplicate` opts into raw OO append. `oo projects files dedupe PROJECT_ID` reports/removes duplicate stem|ext copies (`--apply`, `--cross`; includes project root folder).
 - Every table output goes through `printTable(headers, rows)`; every single-object through `printObject(v)`. Do not `fmt.Println` rows ad-hoc or the `--output json` flag breaks for that command.
 - No secrets in the repo; use `.env` (gitignored). Commit `.env.example` only.
 - Follow SemVer on tags; this repo is tagged at GitHub under `git@github.com:eSlider/go-onlyoffice.git`.

CHANGELOG.md

@@ -6,6 +6,26 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## Unreleased
 
+## [0.17.0](https://github.com/eSlider/go-onlyoffice/compare/v0.16.0...v0.17.0) (2026-08-31)
+
+
+### Features
+
+* **mailsync:** FetchMailFolder — integration-layer walk for ETL consumers ([35f0cb8](https://github.com/eSlider/go-onlyoffice/commit/35f0cb8d20076244141065c07e203e633bc3612a))
+
+
+### Bug Fixes
+
+* **files:** upsert uploads by default and dedupe project root ([24ca144](https://github.com/eSlider/go-onlyoffice/commit/24ca144b22abc5d056a5fd1ed9a1887f26a79d15))
+
+## [0.16.0](https://github.com/eSlider/go-onlyoffice/compare/v0.15.0...v0.16.0) (2026-08-30)
+
+### Features
+
+* **docs:** `put-xlsx` — multi-sheet бюджеты с named inputs, SUM/AVG/MIN
+  формулами, cross-sheet ссылками и cell comments (`internal/xlspipe`,
+  excelize) ([68445b0](https://github.com/eSlider/go-onlyoffice/commit/68445b0))
+
 ### Added
 
 * **docs:** CRM association graph and OO quirks (`docs/crm-associations.md`)

README.md

@@ -503,6 +503,29 @@ type Task struct {
 |---|---|
 | `GetUsers()` | List all users with profiles |
 
+### Documents Files
+
+| Method | Description |
+|---|---|
+| `ListDavFolder(ctx, id)` | List a Documents folder (`@root` for virtual sections) |
+| `ListDavSections(ctx)` | Virtual sections (Documents, Projects, …) |
+| `CreateDavFolder(ctx, parentID, title)` | Create a subfolder |
+| `RenameDavFolder(ctx, id, title)` / `RenameDavFile(ctx, id, title)` | Rename folder / file |
+| `DownloadFile(ctx, id, dst)` / `DownloadDavFile(ctx, id, w)` | Download file bytes |
+| `UploadDavFile(ctx, folderID, fileName, src)` | Upload from a reader |
+| `UploadToFolder(ctx, folderID, localPath)` | Upload a local file into a folder |
+| `UploadToFolderReplacing(ctx, folderID, localPath)` | Upsert by `stem\|ext`; returns replaced ids |
+| `UpdateFile(ctx, fileID, localPath)` | New version of an existing file (same id, no copy) |
+| `MoveDavItems(ctx, folderIDs, fileIDs, dest)` | Move (`resolveType=Skip`); per-operation errors surfaced, not silent nil |
+| `CopyDavItems(ctx, folderIDs, fileIDs, dest)` | Copy (`conflictResolveType=Skip`); errors surfaced |
+| `MoveFiles(ctx, destFolderID, fileIDs)` | Move with `resolveType=Skip` + `holdResult`; errors surfaced |
+| `ListFileOps(ctx)` | Active file operations (move/copy status polling) |
+| `FolderFiles(ctx, folderID)` | Flat file list of a folder (stem helpers) |
+| `DeleteFilesByStem(ctx, folderID, stem)` | Remove `stem\|ext` copies |
+| `DoRetry(ctx, policy, fn)` | Deterministic linear backoff (N·Base, no jitter) on 429/502/503/504 |
+| `DefaultRetryPolicy()` | 5 attempts, 1s·2s·3s·4s waits, 30s cap |
+| `Transient(err)` | True for retriable OnlyOffice answers |
+
 ### Helper Types
 
 | Type | Description |
@@ -622,6 +645,8 @@ oo docs convert ./note.docx               # → note.md
 oo docs ocr ./scan.jpg --md ./scan.md     # searchable PDF + markdown
 oo docs hocr ./scan.jpg --lang spa --md ./scan.hocr.md --yaml ./scan.yml
 oo docs put-md 7 ./OO-HONDA-7-INDEX.md --folder 490
+oo docs put-txt 7 ./notes.txt --folder 490
+oo docs put-xlsx 7 ./table.xlsx --folder 490
 oo docs as-md 2815 --to ./parte.md        # download OO file as MD (OCR if needed)
 oo docs as-md 307 --hocr --lang spa       # OO download via go-hocr structure
 oo projects files put-md 7 ./note.md      # alias
@@ -631,21 +656,84 @@ oo tasks files upload 208 ./notes.pdf
 oo tasks files detach 208 12345
 ```
 
+### Documents module (`oo dav`)
+
+Direct access to the Documents module by folder/file id — the same calls that
+back `oo-webdav` and the project/task file commands. `move` sends
+`resolveType=Skip` + `holdResult=true`: without those params the legacy
+`fileops/move` endpoint answers 200 without moving anything, and the library
+surfaces such per-operation errors instead of a silent nil
+(`MoveDavItems` / `CopyDavItems` / `MoveFiles`).
+
+```bash
+oo dav ls 659
+oo dav ls @root                       # virtual sections (Documents, Projects, …)
+oo dav mkdir 659 "2026 inbox"
+oo dav move 659 22881 22882           # DEST_FOLDER_ID FILE_ID…
+oo dav move 659 22881 --folders 670   # move folders along with files
+oo dav copy 659 22881
+oo dav rename-file 22881 invoice-v2.pdf
+oo dav rename-folder 671 o2-archive
+oo dav download 22881 --to ./copy.pdf # default path: ./<server title>
+oo dav fileops                        # active move/copy operations (status polling)
+```
+
+### Search (`oo search`)
+
+Full-text search over the Documents index. The REST endpoint
+`/api/2.0/files/@search/{query}` only searches file names in the database, so
+`oo search` talks to the OnlyOffice **Elasticsearch** directly (index
+`files_file`). Name search is default; `--content` also matches extracted
+document text (`document.attachment.content`, Office formats only).
+See [`docs/elasticsearch.md`](docs/elasticsearch.md) for the tunnel setup.
+
+```bash
+oo search "Rechnung"                          # names only
+oo search "Mahngebühr" --content              # names + document text
+oo search "Rechnung" --folder 649 --limit 50
+oo search "Rechnung" --json                   # shorthand for -o json
+```
+
+Requires `ONLYOFFICE_ES_URL` (plus optional `ONLYOFFICE_ES_INDEX`,
+`ONLYOFFICE_TENANT`).
+
+### Bulk tools (`cmd/`)
+
+Small single-purpose binaries for bulk Documents work. All of them pace
+requests and retry transient OnlyOffice answers (429/502/503/504) with a
+deterministic linear backoff — no jitter, same waits on every run
+(see `DoRetry` below). Build with `go build ./cmd/<tool>`.
+
+```bash
+ooscan 659                             # recursive index → TSV: file_id, folder_id, path, title
+ooscan 659 666 > oo-index.tsv          # several roots into one index
+pdfamount 671                          # "Zu zahlender Betrag" per PDF → TSV: file_id, title, amount
+kontoblatt 3906 ./kontoblatt.xlsx      # summary (Gegenkonto/Monat) uploaded next to source
+kontolink IN.xlsx oo-index.tsv OUT.xlsx [FILE_ID] [AMOUNTS_TSV]
+# kontolink writes DocEditor links into the Link column: Beleg → supplier+month
+# → amount+date (5th arg = pdfamount output); with FILE_ID it updates the
+# source file in place, else uploads an "(links)" copy next to it.
+```
+
 | Subject | Verbs |
 |---|---|
 | `calendar` | `list`, `events`, `add`, `delete` |
-| `projects` | `list`, `get`, `milestones`, `create`, `update`, `delete`, **`files`** (`list`, `upload`, `download`, `rename`, `delete`) |
+| `projects` | `list`, `get`, `milestones`, `milestone-create`, `create`, `update`, `delete`, `contacts` (`add`, `remove`), `link-authors`, `link-git`, **`files`** (`list`, `upload`, `download`, `rename`, `delete`, `dedupe`, `as-md`, `put-md`, `put-txt`, `put-xlsx`) |
 | `tasks` | `list`, `get`, `create`, `update`, `delete`, `subtask add`, **`files`** (`list`, `upload`, `detach`) |
 | `users` | `list`, `self` (alias: `oo whoami`) |
-| `contacts` | `list`, `get`, `delete`, `info-add`, `merge`, `dedupe-info` |
+| `contacts` | `list`, `get`, `delete`, `info-add`, `merge`, `dedupe-info`, `tags`, `tag-add`, `tag-create`, `tag-remove` |
 | `persons` | `list`, `create`, `delete`, `dedupe` |
 | `companies` | `list`, `create`, `delete`, `dedupe`, `dedupe-persons` |
-| `opportunities` | `list`, `get`, `create`, `delete`, `stages`, `member-add`, `dedupe`, `dedupe-members`, `fix-titles` |
+| `opportunities` | `list`, `get`, `create`, `update`, `delete`, `stages`, `member-add`, `dedupe`, `dedupe-members`, `fix-titles` |
 | `invoices` | `list`, `get`, `create`, `update`, `pdf`, `pdf-cleanup`, `status`, `delete`, `items …` |
 | `crm` | `cleanup` |
-| `mails` | `accounts`, `folders`, `list`, `get`, `draft`, `attach`, `draft-invoice`, `delete` |
+| `mails` | `accounts`, `folders`, `list`, `get`, `download-attachment`, `draft`, `attach`, `draft-invoice`, `send`, `delete` |
 | `cases` | `list`, `create`, `delete`, `member-add` |
-| `crm-tasks` | `list`, `create`, `delete`, `categories` |
+| `crm-tasks` | `list`, `create`, `delete`, `categories`, `reassign-self` |
+| `docs` | `tools`, `convert`, `optimize`, `ocr`, `hocr`, `as-md`, `put-md`, `put-txt`, `put-xlsx` |
+| `catalog` | `match`, `merge`, `apply`, `scan-contacts`, `scan-projects`, `scan-thunderbird` |
+| `dav` | `ls`, `move`, `copy`, `mkdir`, `rename-file`, `rename-folder`, `download`, `fileops` |
+| `search` | `QUERY` (`--content`, `--folder ID`, `--limit N`, `--json`) |
 
 The CLI reads only `.env` from the current working directory (godotenv is a
 CLI-only concern — the library itself never loads dotfiles).

cmd/kontoblatt/main.go

@@ -0,0 +1,220 @@
+// Command kontoblatt builds a summary ("сводная таблица") of a Kontoblatt XLSX
+// (Datum, Gegenkonto, Buchungstext, Beleg, Soll, Haben, Bemerkung) and uploads
+// it back to the same OnlyOffice folder as the source file.
+//
+// Usage: kontoblatt <FILE_ID> <LOCAL_XLSX>
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	onlyoffice "github.com/eslider/go-onlyoffice"
+	"github.com/xuri/excelize/v2"
+)
+
+type agg struct {
+	count   int
+	soll    float64
+	haben   float64
+	reFehlt int
+}
+
+type rec struct {
+	date, month, konto, text string
+	soll, haben              float64
+	reFehlt                  bool
+}
+
+var dateRe = regexp.MustCompile(`^\d{2}\.\d{2}\.\d{4}$`)
+
+func parseAmount(s string) float64 {
+	s = strings.TrimSpace(s)
+	s = strings.ReplaceAll(s, "€", "")
+	s = strings.ReplaceAll(s, " ", "")
+	s = strings.ReplaceAll(s, ",", "") // German thousands separator
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return 0
+	}
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return 0
+	}
+	return v
+}
+
+func cell(row []string, i int) string {
+	if i < len(row) {
+		return strings.TrimSpace(row[i])
+	}
+	return ""
+}
+
+func main() {
+	if len(os.Args) < 3 {
+		fmt.Fprintln(os.Stderr, "usage: kontoblatt <FILE_ID> <LOCAL_XLSX>")
+		os.Exit(2)
+	}
+	fileID, path := os.Args[1], os.Args[2]
+	ctx := context.Background()
+
+	f, err := excelize.OpenFile(path)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+
+	var recs []rec
+	for _, sh := range f.GetSheetList() {
+		rows, err := f.GetRows(sh)
+		if err != nil {
+			continue
+		}
+		for _, r := range rows {
+			d := cell(r, 0)
+			if !dateRe.MatchString(d) {
+				continue
+			}
+			text := cell(r, 2)
+			recs = append(recs, rec{
+				date:    d,
+				month:   d[3:10],
+				konto:   cell(r, 1),
+				text:    text,
+				soll:    parseAmount(cell(r, 4)),
+				haben:   parseAmount(cell(r, 5)),
+				reFehlt: strings.Contains(strings.ToUpper(text), "FEHLT"),
+			})
+		}
+	}
+
+	byKonto := map[string]*agg{}
+	byMonth := map[string]*agg{}
+	getK := func(k string) *agg {
+		if byKonto[k] == nil {
+			byKonto[k] = &agg{}
+		}
+		return byKonto[k]
+	}
+	getM := func(k string) *agg {
+		if byMonth[k] == nil {
+			byMonth[k] = &agg{}
+		}
+		return byMonth[k]
+	}
+	var tot agg
+	for _, r := range recs {
+		k := getK(r.konto)
+		k.count++
+		k.soll += r.soll
+		k.haben += r.haben
+		if r.reFehlt {
+			k.reFehlt++
+		}
+		m := getM(r.month)
+		m.count++
+		m.soll += r.soll
+		m.haben += r.haben
+		if r.reFehlt {
+			m.reFehlt++
+		}
+		tot.count++
+		tot.soll += r.soll
+		tot.haben += r.haben
+		if r.reFehlt {
+			tot.reFehlt++
+		}
+	}
+
+	out := excelize.NewFile()
+	defer out.Close()
+	writeSheet(out, "Nach Gegenkonto", "Gegenkonto", byKonto, tot)
+	writeSheet(out, "Nach Monat", "Monat", byMonth, tot)
+	outPath := "/tmp/opencode/kontoblatt-zusammenfassung.xlsx"
+	if err := out.SaveAs(outPath); err != nil {
+		panic(err)
+	}
+
+	// upload next to the source file
+	creds := onlyoffice.GetEnvironmentCredentials()
+	c := onlyoffice.NewClient(creds)
+	var src *onlyoffice.FileEntry
+	if derr := onlyoffice.DoRetry(ctx, onlyoffice.DefaultRetryPolicy(), func() error {
+		var err error
+		src, err = c.GetFile(ctx, fileID)
+		return err
+	}); derr != nil {
+		panic(derr)
+	}
+	folder := ""
+	if src.FolderID != nil {
+		folder = src.FolderID.String()
+	}
+	title := ""
+	if src.Title != nil {
+		title = *src.Title
+	}
+	fmt.Printf("source: id=%s title=%q folder=%s\n", fileID, title, folder)
+
+	name := "Kontoblatt-1591-2025-Zusammenfassung.xlsx"
+	tmp := "/tmp/opencode/" + name
+	data, _ := os.ReadFile(outPath)
+	if err := os.WriteFile(tmp, data, 0o600); err != nil {
+		panic(err)
+	}
+	var entry *onlyoffice.FileEntry
+	if derr := onlyoffice.DoRetry(ctx, onlyoffice.DefaultRetryPolicy(), func() error {
+		var err error
+		entry, _, err = c.UploadToFolderReplacing(ctx, folder, tmp)
+		return err
+	}); derr != nil {
+		panic(derr)
+	}
+	fmt.Printf("uploaded: %s -> folder %s (id %v)\n", name, folder, entry.ID)
+
+	// print the summary
+	printAgg("Nach Gegenkonto", byKonto, tot)
+	printAgg("Nach Monat", byMonth, tot)
+}
+
+func writeSheet(f *excelize.File, sheet, key string, m map[string]*agg, tot agg) {
+	f.NewSheet(sheet)
+	rows := [][]any{{key, "Anzahl", "Soll", "Haben", "Saldo", `davon "fehlt"`}}
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		a := m[k]
+		rows = append(rows, []any{k, a.count, a.soll, a.haben, a.soll - a.haben, a.reFehlt})
+	}
+	rows = append(rows, []any{"GESAMT", tot.count, tot.soll, tot.haben, tot.soll - tot.haben, tot.reFehlt})
+	for i, row := range rows {
+		for j, v := range row {
+			cellRef, _ := excelize.CoordinatesToCellName(j+1, i+1)
+			_ = f.SetCellValue(sheet, cellRef, v)
+		}
+	}
+}
+
+func printAgg(title string, m map[string]*agg, tot agg) {
+	fmt.Printf("\n== %s ==\n", title)
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	fmt.Printf("%-12s %6s %12s %12s %12s %7s\n", "key", "count", "soll", "haben", "saldo", "fehlt")
+	for _, k := range keys {
+		a := m[k]
+		fmt.Printf("%-12s %6d %12.2f %12.2f %12.2f %7d\n", k, a.count, a.soll, a.haben, a.soll-a.haben, a.reFehlt)
+	}
+	fmt.Printf("%-12s %6d %12.2f %12.2f %12.2f %7d\n", "GESAMT", tot.count, tot.soll, tot.haben, tot.soll-tot.haben, tot.reFehlt)
+}

cmd/kontolink/main.go

@@ -0,0 +1,478 @@
+// Command kontolink fills the "Link" column of a Kontoblatt ("ungeklärte
+// Posten") XLSX by matching each row to an OnlyOffice document.
+//
+// Strategy (deterministic, conservative — no LLM):
+//  1. Beleg token (letters/digits from the "Beleg" column) appears in the file
+//     title; among candidates prefer (a) the row's month, (b) real invoices over
+//     copies/dupes, and require the result to be unique;
+//  2. else supplier + row month + "rechnung", again unique.
+//
+// A file is linked at most once (rows already carrying a link are kept and their
+// file counts as used). Ambiguous rows are left UNLINKED for manual review.
+//
+// Usage: kontolink <IN_XLSX> <INDEX_TSV> <OUT_XLSX>
+package main
+
+import (
+	"context"
+
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	onlyoffice "github.com/eslider/go-onlyoffice"
+	"github.com/xuri/excelize/v2"
+)
+
+var (
+	dateRe = regexp.MustCompile(`^\d{2}\.\d{2}\.\d{4}$`)
+	nonAln = regexp.MustCompile(`[^0-9a-z]+`)
+	fileID = regexp.MustCompile(`fileid=(\d+)`)
+)
+
+func parseDay(s string) (time.Time, bool) {
+	t, err := time.Parse("02.01.2006", strings.TrimSpace(s))
+	return t, err == nil
+}
+
+func titleDay(title string) (time.Time, bool) {
+	if len(title) >= 10 {
+		if t, err := time.Parse("2006-01-02", title[:10]); err == nil {
+			return t, true
+		}
+	}
+	return time.Time{}, false
+}
+
+// nearest picks the candidate whose title date is closest to rd. Ties and
+// undated candidates (when >1) are rejected.
+func nearest(cands []entry, rd time.Time) (entry, bool) {
+	if len(cands) == 1 {
+		return cands[0], true
+	}
+	best, bestD, tie := -1, 0.0, false
+	for i, e := range cands {
+		td, ok := titleDay(e.title)
+		if !ok {
+			continue
+		}
+		d := td.Sub(rd).Hours() / 24
+		if d < 0 {
+			d = -d
+		}
+		if best < 0 || d < bestD {
+			best, bestD, tie = i, d, false
+		} else if d == bestD {
+			tie = true
+		}
+	}
+	if best < 0 || tie {
+		return entry{}, false
+	}
+	return cands[best], true
+}
+
+const linkPrefix = "https://office.pro-dukt.de/Products/Files/DocEditor.aspx?fileid="
+
+type entry struct {
+	id, path, title, norm string
+}
+
+func norm(s string) string { return nonAln.ReplaceAllString(strings.ToLower(s), "") }
+
+func main() {
+	if len(os.Args) < 4 {
+		fmt.Fprintln(os.Stderr, "usage: kontolink <IN_XLSX> <INDEX_TSV> <OUT_XLSX>")
+		os.Exit(2)
+	}
+	in, idxPath, out := os.Args[1], os.Args[2], os.Args[3]
+
+	idxRaw, err := os.ReadFile(idxPath)
+	if err != nil {
+		panic(err)
+	}
+	var entries []entry
+	for _, line := range strings.Split(string(idxRaw), "\n") {
+		parts := strings.Split(line, "\t")
+		if len(parts) < 4 || parts[0] == "" {
+			continue
+		}
+		entries = append(entries, entry{id: parts[0], path: parts[2], title: parts[3], norm: norm(parts[3])})
+	}
+
+	f, err := excelize.OpenFile(in)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	sheet := f.GetSheetList()[0]
+	rows, err := f.GetRows(sheet)
+	if err != nil {
+		panic(err)
+	}
+
+	// optional 5th arg: amounts TSV "file_id\ttitle\tamount" (see cmd/pdfamount)
+	var amts []amtEntry
+	if len(os.Args) >= 6 && os.Args[5] != "" {
+		amts = loadAmounts(os.Args[5])
+	}
+
+	used := map[string]bool{}
+	for _, r := range rows {
+		if m := fileID.FindStringSubmatch(cell(r, 7)); m != nil {
+			used[m[1]] = true
+		}
+	}
+
+	var linked, byBeleg, bySupplier, byAmount, unmatched, ambiguous int
+	for i, r := range rows {
+		if i == 0 || !dateRe.MatchString(cell(r, 0)) || strings.TrimSpace(cell(r, 7)) != "" {
+			continue
+		}
+		beleg := norm(cell(r, 3))
+		supplier := supplierNorm(cell(r, 2))
+		month := monthYear(cell(r, 0))
+		rd, _ := parseDay(cell(r, 0))
+
+		e, kind, ok := pick(entries, used, beleg, supplier, month, rd)
+		if !ok {
+			if ae, aok := amountPick(amts, used, supplier, rowAmount(r), rd); aok {
+				e, kind, ok = entry{id: ae.id, title: ae.title}, "amount", true
+			}
+		}
+		if !ok {
+			if beleg != "" {
+				ambiguous++
+			} else {
+				unmatched++
+			}
+			continue
+		}
+		ref, _ := excelize.CoordinatesToCellName(8, i+1)
+		if err := f.SetCellValue(sheet, ref, linkPrefix+e.id); err != nil {
+			panic(err)
+		}
+		used[e.id] = true
+		linked++
+		switch kind {
+		case "beleg":
+			byBeleg++
+		case "supplier":
+			bySupplier++
+		case "amount":
+			byAmount++
+		}
+		fmt.Printf("row %3d  %-30s -> %s  [%s]\n", i+1, cell(r, 2), e.title, kind)
+	}
+
+	if err := f.SaveAs(out); err != nil {
+		panic(err)
+	}
+	fmt.Printf("\nlinked=%d (beleg=%d, supplier=%d, amount=%d), ambiguous=%d, no-candidate=%d\n",
+		linked, byBeleg, bySupplier, byAmount, ambiguous, unmatched)
+
+	// Optional 4th arg: source OnlyOffice file id. Try to update it in place;
+	// if it is locked (OnlyOffice 500), upload a "(links)" copy next to it.
+	if len(os.Args) >= 5 && os.Args[4] != "" {
+		c := onlyoffice.NewClient(onlyoffice.GetEnvironmentCredentials())
+		ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+		defer cancel()
+		var src *onlyoffice.FileEntry
+		if derr := onlyoffice.DoRetry(ctx, onlyoffice.DefaultRetryPolicy(), func() error {
+			var err error
+			src, err = c.GetFile(ctx, os.Args[4])
+			return err
+		}); derr != nil {
+			panic(derr)
+		}
+		folder, title := "", ""
+		if src.FolderID != nil {
+			folder = src.FolderID.String()
+		}
+		if src.Title != nil {
+			title = *src.Title
+		}
+		uderr := onlyoffice.DoRetry(ctx, onlyoffice.DefaultRetryPolicy(), func() error {
+			_, err := c.UpdateFile(ctx, os.Args[4], out)
+			return err
+		})
+		if uderr == nil {
+			fmt.Printf("updated file %s in place\n", os.Args[4])
+			return
+		}
+		fmt.Printf("in-place update failed (locked?); uploading a copy to folder %s\n", folder)
+		ext := filepath.Ext(title)
+		name := strings.TrimSuffix(title, ext) + " (links)" + ext
+		tmp := filepath.Join(os.TempDir(), name)
+		data, _ := os.ReadFile(out)
+		if err := os.WriteFile(tmp, data, 0o600); err != nil {
+			panic(err)
+		}
+		if derr := onlyoffice.DoRetry(ctx, onlyoffice.DefaultRetryPolicy(), func() error {
+			_, _, err := c.UploadToFolderReplacing(ctx, folder, tmp)
+			return err
+		}); derr != nil {
+			panic(derr)
+		}
+		fmt.Printf("uploaded copy: %s -> folder %s\n", name, folder)
+	}
+}
+
+func cell(r []string, i int) string {
+	if i < len(r) {
+		return strings.TrimSpace(r[i])
+	}
+	return ""
+}
+
+func supplierNorm(s string) string {
+	s = strings.ToUpper(s)
+	if i := strings.Index(s, ","); i >= 0 {
+		s = s[:i]
+	}
+	for _, w := range []string{"RE FEHLT", "GS FEHLT", "WOFR", "WOFÜR"} {
+		s = strings.ReplaceAll(s, w, "")
+	}
+	return norm(s)
+}
+
+func monthYear(date string) string {
+	if len(date) == 10 {
+		return date[6:10] + "-" + date[3:5]
+	}
+	return ""
+}
+
+// pick returns an unused candidate. Beleg match wins; supplier+month is a
+// fallback. When several candidates qualify, the one closest in time to the row
+// date wins; a tie is rejected (ambiguous) rather than guessed.
+func pick(entries []entry, used map[string]bool, beleg, supplier, month string, rd time.Time) (entry, string, bool) {
+	free := func(e entry) bool { return !used[e.id] }
+
+	if len(beleg) >= 5 {
+		var inMonth []entry
+		for _, e := range entries {
+			if free(e) && belegMatches(e.norm, beleg) &&
+				(month == "" || strings.Contains(e.title, month)) {
+				inMonth = append(inMonth, e)
+			}
+		}
+		if supplier != "" {
+			var s []entry
+			for _, e := range inMonth {
+				if strings.Contains(e.norm, supplier) {
+					s = append(s, e)
+				}
+			}
+			if len(s) > 0 {
+				inMonth = s
+			}
+		}
+		inMonth = topRank(inMonth)
+		if e, ok := nearest(inMonth, rd); ok {
+			return e, "beleg", true
+		}
+		// A Beleg is present but no file carries it: do NOT fall back to a
+		// supplier guess (that links the wrong invoice).
+		return entry{}, "", false
+	}
+
+	if supplier != "" && month != "" {
+		var c []entry
+		for _, e := range entries {
+			if free(e) && strings.Contains(e.norm, supplier) &&
+				strings.Contains(e.title, month) && strings.Contains(e.norm, "rechnung") {
+				c = append(c, e)
+			}
+		}
+		c = topRank(c)
+		if e, ok := nearest(c, rd); ok {
+			return e, "supplier", true
+		}
+	}
+	return entry{}, "", false
+}
+
+// topRank keeps only the highest-ranked candidates (real invoice over copy /
+// dupe / op), so a tie with a duplicate does not mask the real file.
+func topRank(cands []entry) []entry {
+	if len(cands) < 2 {
+		return cands
+	}
+	best := 0
+	for _, e := range cands {
+		if rank(e) > best {
+			best = rank(e)
+		}
+	}
+	out := cands[:0]
+	for _, e := range cands {
+		if rank(e) == best {
+			out = append(out, e)
+		}
+	}
+	return out
+}
+
+func rank(e entry) int {
+	s := 0
+	if strings.Contains(e.path, "/2025") || strings.Contains(e.path, "/2024") {
+		s += 4
+	}
+	if strings.Contains(e.norm, "rechnung") {
+		s += 2
+	}
+	if strings.Contains(e.norm, "dupe") || strings.Contains(e.norm, "copy") ||
+		strings.Contains(e.norm, "op") {
+		s--
+	}
+	return s
+}
+
+// belegMatches reports whether a Beleg identifies the file: the whole normalized
+// Beleg appears, or (for long numeric Belege, e.g. "24/641393110") an 8-digit
+// window of its longest digit run appears.
+func belegMatches(titleNorm, beleg string) bool {
+	if strings.Contains(titleNorm, beleg) {
+		return true
+	}
+	run := longestDigitRun(beleg)
+	for i := 0; i+8 <= len(run); i++ {
+		if strings.Contains(titleNorm, run[i:i+8]) {
+			return true
+		}
+	}
+	return false
+}
+
+func longestDigitRun(s string) string {
+	var best, cur strings.Builder
+	for _, r := range s {
+		if r >= '0' && r <= '9' {
+			cur.WriteRune(r)
+			if cur.Len() > best.Len() {
+				best.Reset()
+				best.WriteString(cur.String())
+			}
+		} else {
+			cur.Reset()
+		}
+	}
+	return best.String()
+}
+
+type amtEntry struct {
+	id      string
+	title   string
+	norm    string
+	amount  float64
+	date    time.Time
+	hasDate bool
+}
+
+func loadAmounts(path string) []amtEntry {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return nil
+	}
+	var out []amtEntry
+	for _, line := range strings.Split(string(raw), "\n") {
+		p := strings.Split(line, "\t")
+		if len(p) < 3 {
+			continue
+		}
+		v, err := strconv.ParseFloat(strings.TrimSpace(p[2]), 64)
+		if err != nil {
+			continue
+		}
+		e := amtEntry{id: p[0], title: p[1], norm: norm(p[1]), amount: v}
+		if len(p[1]) >= 10 {
+			if t, err := time.Parse("2006-01-02", p[1][:10]); err == nil {
+				e.date, e.hasDate = t, true
+			}
+		}
+		out = append(out, e)
+	}
+	return out
+}
+
+func rowAmount(r []string) float64 {
+	if v := parseAmount(cell(r, 4)); v != 0 {
+		return v
+	}
+	return parseAmount(cell(r, 5))
+}
+
+func parseAmount(s string) float64 {
+	s = strings.ReplaceAll(s, "€", "")
+	s = strings.ReplaceAll(s, " ", "")
+	s = strings.ReplaceAll(s, ",", ".")
+	if s == "" {
+		return 0
+	}
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return 0
+	}
+	return v
+}
+
+// amountPick matches a row to an O2 invoice by amount + nearest date. Scoped to
+// Telefonica/O2 rows and O2 files, so it cannot cross-link other suppliers.
+func amountPick(amts []amtEntry, used map[string]bool, supplier string, amt float64, rd time.Time) (amtEntry, bool) {
+	if amt <= 0 || len(amts) == 0 {
+		return amtEntry{}, false
+	}
+	if !strings.Contains(supplier, "telefonica") && !strings.Contains(supplier, "o2") {
+		return amtEntry{}, false
+	}
+	var cands []amtEntry
+	for _, a := range amts {
+		if used[a.id] || !strings.Contains(a.norm, "o2") {
+			continue
+		}
+		d := a.amount - amt
+		if d < 0 {
+			d = -d
+		}
+		if d > 0.005 {
+			continue
+		}
+		if a.hasDate && !rd.IsZero() {
+			days := a.date.Sub(rd).Hours() / 24
+			if days < 0 {
+				days = -days
+			}
+			if days > 75 {
+				continue
+			}
+		}
+		cands = append(cands, a)
+	}
+	if len(cands) == 1 {
+		return cands[0], true
+	}
+	best, bestD, tie := -1, 0.0, false
+	for i, a := range cands {
+		if !a.hasDate {
+			continue
+		}
+		d := a.date.Sub(rd).Hours() / 24
+		if d < 0 {
+			d = -d
+		}
+		if best < 0 || d < bestD {
+			best, bestD, tie = i, d, false
+		} else if d == bestD {
+			tie = true
+		}
+	}
+	if best < 0 || tie {
+		return amtEntry{}, false
+	}
+	return cands[best], true
+}

cmd/oo/dav.go

@@ -0,0 +1,291 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	onlyoffice "github.com/eslider/go-onlyoffice"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	rootCmd.AddCommand(davCmd())
+}
+
+// davCmd exposes the Documents module through the same Dav calls that back
+// oo-webdav (ListDavFolder / MoveDavItems / CopyDavItems / DownloadDavFile).
+// MoveDavItems sends resolveType=Skip + holdResult=true, which the legacy
+// fileops/move call without those params silently ignores (200 without move).
+func davCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "dav",
+		Short: "Documents module by folder/file id (oo-webdav proven path)",
+	}
+	cmd.AddCommand(davLsCmd())
+	cmd.AddCommand(davMoveCmd())
+	cmd.AddCommand(davCopyCmd())
+	cmd.AddCommand(davMkdirCmd())
+	cmd.AddCommand(davRenameFileCmd())
+	cmd.AddCommand(davRenameFolderCmd())
+	cmd.AddCommand(davDownloadCmd())
+	cmd.AddCommand(davFileOpsCmd())
+	return cmd
+}
+
+func davLsCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "ls FOLDER_ID",
+		Short: "List a Documents folder (@root for virtual sections)",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			ctx := cmd.Context()
+			if args[0] == "@root" {
+				sections, err := c.ListDavSections(ctx)
+				if err != nil {
+					return err
+				}
+				rows := make([]map[string]any, 0, len(sections))
+				for _, s := range sections {
+					rows = append(rows, map[string]any{
+						"id":           s.ID,
+						"title":        s.Title,
+						"filesCount":   s.FilesCount,
+						"foldersCount": s.FoldersCount,
+					})
+				}
+				printTable([]string{"id", "title", "filesCount", "foldersCount"}, rows)
+				return nil
+			}
+			l, err := c.ListDavFolder(ctx, args[0])
+			if err != nil {
+				return err
+			}
+			if outputFormat == "json" {
+				folders := make([]map[string]any, 0, len(l.Folders))
+				for _, f := range l.Folders {
+					folders = append(folders, map[string]any{
+						"id":           f.ID,
+						"title":        f.Title,
+						"filesCount":   f.FilesCount,
+						"foldersCount": f.FoldersCount,
+					})
+				}
+				files := make([]map[string]any, 0, len(l.Files))
+				for _, f := range l.Files {
+					files = append(files, map[string]any{
+						"id":      f.ID,
+						"title":   f.Title,
+						"size":    f.Size,
+						"updated": f.Updated,
+					})
+				}
+				printObject(map[string]any{"folders": folders, "files": files})
+				return nil
+			}
+			if len(l.Folders) > 0 {
+				frows := make([]map[string]any, 0, len(l.Folders))
+				for _, f := range l.Folders {
+					frows = append(frows, map[string]any{
+						"id":           f.ID,
+						"title":        f.Title,
+						"filesCount":   f.FilesCount,
+						"foldersCount": f.FoldersCount,
+					})
+				}
+				if outputFormat == "table" {
+					fmt.Println("folders:")
+				}
+				printTable([]string{"id", "title", "filesCount", "foldersCount"}, frows)
+			}
+			rows := make([]map[string]any, 0, len(l.Files))
+			for _, f := range l.Files {
+				rows = append(rows, map[string]any{
+					"id":      f.ID,
+					"title":   f.Title,
+					"size":    f.Size,
+					"updated": f.Updated,
+				})
+			}
+			if outputFormat == "table" {
+				fmt.Println("files:")
+			}
+			printTable([]string{"id", "title", "size", "updated"}, rows)
+			return nil
+		},
+	}
+	return cmd
+}
+
+func davMoveCmd() *cobra.Command {
+	var folderIDs []string
+	cmd := &cobra.Command{
+		Use:   "move DEST_FOLDER_ID FILE_ID [FILE_ID...]",
+		Short: "Move file(s) into a Documents folder (resolveType=Skip, holdResult)",
+		Args:  cobra.MinimumNArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			if err := c.MoveDavItems(cmd.Context(), folderIDs, args[1:], args[0]); err != nil {
+				return err
+			}
+			printObject(map[string]any{"moved_files": args[1:], "moved_folders": folderIDs, "dest": args[0]})
+			return nil
+		},
+	}
+	cmd.Flags().StringSliceVar(&folderIDs, "folders", nil, "folder ids to move along with the files")
+	return cmd
+}
+
+func davCopyCmd() *cobra.Command {
+	var folderIDs []string
+	cmd := &cobra.Command{
+		Use:   "copy DEST_FOLDER_ID FILE_ID [FILE_ID...]",
+		Short: "Copy file(s) into a Documents folder (conflictResolveType=Skip)",
+		Args:  cobra.MinimumNArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			if err := c.CopyDavItems(cmd.Context(), folderIDs, args[1:], args[0]); err != nil {
+				return err
+			}
+			printObject(map[string]any{"copied_files": args[1:], "copied_folders": folderIDs, "dest": args[0]})
+			return nil
+		},
+	}
+	cmd.Flags().StringSliceVar(&folderIDs, "folders", nil, "folder ids to copy along with the files")
+	return cmd
+}
+
+func davMkdirCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "mkdir PARENT_FOLDER_ID TITLE",
+		Short: "Create a subfolder in Documents",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			f, err := c.CreateDavFolder(cmd.Context(), args[0], args[1])
+			if err != nil {
+				return err
+			}
+			printObject(map[string]any{"id": f.ID, "title": f.Title, "parent": args[0]})
+			return nil
+		},
+	}
+}
+
+func davRenameFileCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "rename-file FILE_ID NEW_TITLE",
+		Short: "Rename a Documents file (include extension in NEW_TITLE)",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			if err := c.RenameDavFile(cmd.Context(), args[0], args[1]); err != nil {
+				return err
+			}
+			printObject(map[string]any{"id": args[0], "title": args[1]})
+			return nil
+		},
+	}
+}
+
+func davRenameFolderCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "rename-folder FOLDER_ID NEW_TITLE",
+		Short: "Rename a Documents folder",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			if err := c.RenameDavFolder(cmd.Context(), args[0], args[1]); err != nil {
+				return err
+			}
+			printObject(map[string]any{"id": args[0], "title": args[1]})
+			return nil
+		},
+	}
+}
+
+func davDownloadCmd() *cobra.Command {
+	var to string
+	cmd := &cobra.Command{
+		Use:   "download FILE_ID",
+		Short: "Download Documents file bytes (default path: ./<title>)",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			ctx := cmd.Context()
+			f, err := c.GetFile(ctx, args[0])
+			if err != nil {
+				return err
+			}
+			path := to
+			if path == "" {
+				path = onlyoffice.SafeLocalFileName(onlyoffice.FileEntryTitle(f))
+			}
+			out, err := os.Create(path)
+			if err != nil {
+				return err
+			}
+			defer out.Close()
+			n, err := c.DownloadDavFile(ctx, args[0], out)
+			if err != nil {
+				_ = os.Remove(path)
+				return err
+			}
+			printObject(map[string]any{"path": path, "bytes": n})
+			return nil
+		},
+	}
+	cmd.Flags().StringVar(&to, "to", "", "output path (default: ./<server title>)")
+	return cmd
+}
+
+func davFileOpsCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "fileops",
+		Short: "List active file operations (move/copy status polling)",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			ops, err := c.ListFileOps(cmd.Context())
+			if err != nil {
+				return err
+			}
+			rows := make([]map[string]any, 0, len(ops))
+			for _, op := range ops {
+				rows = append(rows, map[string]any{
+					"id":        fmt.Sprint(op["id"]),
+					"operation": fmt.Sprint(op["operation"]),
+					"progress":  fmt.Sprint(op["progress"]),
+					"finished":  fmt.Sprint(op["finished"]),
+					"error":     fmt.Sprint(op["error"]),
+				})
+			}
+			printTable([]string{"id", "operation", "progress", "finished", "error"}, rows)
+			return nil
+		},
+	}
+}

cmd/oo/docs.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -8,6 +9,7 @@ import (
 
 	onlyoffice "github.com/eslider/go-onlyoffice"
 	"github.com/eslider/go-onlyoffice/internal/docpipe"
+	"github.com/eslider/go-onlyoffice/internal/xlspipe"
 	"github.com/spf13/cobra"
 )
 
@@ -24,6 +26,7 @@ func docsCmd() *cobra.Command {
 OnlyOffice Documents UI is poor for .md/.txt — keep sources in git, store .docx in OO.
 Upload Markdown as DOCX:  oo docs put-md PROJECT_ID file.md
 Upload plain text:        oo docs put-txt PROJECT_ID file.txt  (preserves line breaks)
+Upload/generate XLSX:     oo docs put-xlsx PROJECT_ID [--template cutover-portugal | FILE.xlsx]
 Read an OO file as MD:    oo docs as-md FILE_ID
 OCR a scan locally:       oo docs ocr scan.pdf --md out.md
 Structured OCR (hOCR→MD): oo docs hocr scan.jpg --md out.md --yaml out.yml`,
@@ -35,6 +38,7 @@ Structured OCR (hOCR→MD): oo docs hocr scan.jpg --md out.md --yaml out.yml`,
 	cmd.AddCommand(docsAsMDCmd())
 	cmd.AddCommand(docsPutMDCmd())
 	cmd.AddCommand(docsPutTxtCmd())
+	cmd.AddCommand(docsPutXlsxCmd())
 	cmd.AddCommand(docsToolsCmd())
 	return cmd
 }
@@ -122,11 +126,11 @@ text overlays that break OnlyOffice DocEditor. Skips OCR; rewrites via gs pdfwri
 			}
 			outChars, _ := t.PDFTextLayerChars(out)
 			printObject(map[string]any{
-				"in":              in,
-				"pdf":             out,
-				"text_chars_in":   chars,
-				"text_chars_out":  outChars,
-				"note":            "native text layer preserved; no OCR overlay",
+				"in":             in,
+				"pdf":            out,
+				"text_chars_in":  chars,
+				"text_chars_out": outChars,
+				"note":           "native text layer preserved; no OCR overlay",
 			})
 			return nil
 		},
@@ -420,44 +424,28 @@ func docsPutMDCmd() *cobra.Command {
 				}
 			}
 			ctx := cmd.Context()
-			var ent *onlyoffice.FileEntry
-			var deleted []int
-			if folderID != "" {
-				if replace {
-					ent, deleted, err = c.UploadToFolderReplacing(ctx, folderID, docxPath)
-				} else {
-					ent, err = c.UploadToFolder(ctx, folderID, docxPath)
-				}
-				if err != nil {
-					return err
-				}
-				obj := map[string]any{
-					"project_id": pid,
-					"folder_id":  folderID,
-					"md":         mdPath,
-					"uploaded":   fileEntryToMap(ent),
-				}
-				if len(deleted) > 0 {
-					obj["replaced_file_ids"] = deleted
-				}
-				printObject(obj)
-				return nil
-			}
-			ent, err = c.UploadProjectFile(ctx, pid, docxPath)
+			ent, deleted, err := uploadProjectDoc(ctx, c, pid, docxPath, folderID, replace)
 			if err != nil {
 				return err
 			}
-			printObject(map[string]any{
+			obj := map[string]any{
 				"project_id": pid,
 				"md":         mdPath,
 				"uploaded":   fileEntryToMap(ent),
-			})
+			}
+			if folderID != "" {
+				obj["folder_id"] = folderID
+			}
+			if len(deleted) > 0 {
+				obj["replaced_file_ids"] = deleted
+			}
+			printObject(obj)
 			return nil
 		},
 	}
 	cmd.Flags().StringVar(&folderID, "folder", "", "Documents folder id (default: project root)")
 	cmd.Flags().StringVar(&keepLocalDOCX, "keep-docx", "", "also write the generated DOCX to this local path")
-	cmd.Flags().BoolVar(&replace, "replace", true, "delete same-stem files in folder before upload (put-md upsert)")
+	cmd.Flags().BoolVar(&replace, "replace", true, "replace same stem|ext before upload (default); false = fail if name taken")
 	return cmd
 }
 
@@ -500,43 +488,147 @@ func docsPutTxtCmd() *cobra.Command {
 				}
 			}
 			ctx := cmd.Context()
-			var ent *onlyoffice.FileEntry
-			var deleted []int
-			if folderID != "" {
-				if replace {
-					ent, deleted, err = c.UploadToFolderReplacing(ctx, folderID, docxPath)
-				} else {
-					ent, err = c.UploadToFolder(ctx, folderID, docxPath)
-				}
-				if err != nil {
-					return err
-				}
-				obj := map[string]any{
-					"project_id": pid,
-					"txt":        txtPath,
-					"folder_id":  folderID,
-					"uploaded":   fileEntryToMap(ent),
-				}
-				if len(deleted) > 0 {
-					obj["replaced_file_ids"] = deleted
-				}
-				printObject(obj)
-				return nil
-			}
-			ent, err = c.UploadProjectFile(ctx, pid, docxPath)
+			ent, deleted, err := uploadProjectDoc(ctx, c, pid, docxPath, folderID, replace)
 			if err != nil {
 				return err
 			}
-			printObject(map[string]any{
+			obj := map[string]any{
 				"project_id": pid,
 				"txt":        txtPath,
 				"uploaded":   fileEntryToMap(ent),
-			})
+			}
+			if folderID != "" {
+				obj["folder_id"] = folderID
+			}
+			if len(deleted) > 0 {
+				obj["replaced_file_ids"] = deleted
+			}
+			printObject(obj)
 			return nil
 		},
 	}
 	cmd.Flags().StringVar(&folderID, "folder", "", "Documents folder id (default: project root)")
 	cmd.Flags().StringVar(&keepLocalDOCX, "keep-docx", "", "also write the generated DOCX to this local path")
-	cmd.Flags().BoolVar(&replace, "replace", true, "delete same-stem files in folder before upload (put-txt upsert)")
+	cmd.Flags().BoolVar(&replace, "replace", true, "replace same stem|ext before upload (default); false = fail if name taken")
 	return cmd
 }
+
+func docsPutXlsxCmd() *cobra.Command {
+	var folderID, template, title, keepLocal string
+	var replace bool
+	cmd := &cobra.Command{
+		Use:   "put-xlsx PROJECT_ID [LOCAL_XLSX]",
+		Short: "Upload or generate an XLSX workbook into a project (excelize templates with formulas)",
+		Long: `Spreadsheets live in OnlyOffice — not in git. Generate multi-sheet workbooks with
+formulas (SUM/AVG, cross-sheet refs, named inputs) via --template, or upload an existing .xlsx.
+
+  oo docs put-xlsx 218 --template cutover-portugal
+  oo docs put-xlsx 218 --template cutover-portugal --title 2026-08-28-cutover-budget.xlsx
+  oo docs put-xlsx 218 ./my.xlsx`,
+		Args: cobra.RangeArgs(1, 2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			pid := args[0]
+			c, err := newOO(cmd)
+			if err != nil {
+				return err
+			}
+			dir, err := os.MkdirTemp("", "oo-docs-put-xlsx-*")
+			if err != nil {
+				return err
+			}
+			defer os.RemoveAll(dir)
+
+			var xlsxPath string
+			var srcLabel string
+			switch {
+			case template != "":
+				wb, err := xlspipe.BuildTemplate(template)
+				if err != nil {
+					return err
+				}
+				name := title
+				if name == "" {
+					name = "cutover-budget.xlsx"
+					if template == xlspipe.TemplateCutoverPortugal {
+						name = "2026-08-28-cutover-budget.xlsx"
+					}
+				}
+				if !strings.HasSuffix(strings.ToLower(name), ".xlsx") {
+					name += ".xlsx"
+				}
+				xlsxPath = filepath.Join(dir, name)
+				if err := xlspipe.Save(wb, xlsxPath); err != nil {
+					wb.Close()
+					return err
+				}
+				wb.Close()
+				srcLabel = "template:" + template
+			case len(args) == 2:
+				xlsxPath = args[1]
+				if docpipe.Ext(xlsxPath) != ".xlsx" {
+					return fmt.Errorf("expected .xlsx, got %s", docpipe.Ext(xlsxPath))
+				}
+				srcLabel = xlsxPath
+			default:
+				return fmt.Errorf("pass LOCAL_XLSX or --template")
+			}
+
+			if keepLocal != "" {
+				b, err := os.ReadFile(xlsxPath)
+				if err != nil {
+					return err
+				}
+				if err := docpipe.EnsureDir(keepLocal); err != nil {
+					return err
+				}
+				if err := os.WriteFile(keepLocal, b, 0o644); err != nil {
+					return err
+				}
+			}
+
+			ctx := cmd.Context()
+			ent, deleted, err := uploadProjectDoc(ctx, c, pid, xlsxPath, folderID, replace)
+			if err != nil {
+				return err
+			}
+			obj := map[string]any{
+				"project_id": pid,
+				"source":     srcLabel,
+				"uploaded":   fileEntryToMap(ent),
+			}
+			if folderID != "" {
+				obj["folder_id"] = folderID
+			}
+			if len(deleted) > 0 {
+				obj["replaced_file_ids"] = deleted
+			}
+			printObject(obj)
+			return nil
+		},
+	}
+	cmd.Flags().StringVar(&folderID, "folder", "", "Documents folder id (default: project root)")
+	cmd.Flags().StringVar(&template, "template", "", "built-in workbook template (cutover-portugal)")
+	cmd.Flags().StringVar(&title, "title", "", "upload file name when using --template")
+	cmd.Flags().StringVar(&keepLocal, "keep-xlsx", "", "also write generated/uploaded bytes to this local path")
+	cmd.Flags().BoolVar(&replace, "replace", true, "replace same stem|ext before upload (default); false = fail if name taken")
+	return cmd
+}
+
+// uploadProjectDoc upserts (--replace, default) or no-clobbers into project/folder Documents.
+func uploadProjectDoc(ctx context.Context, c *onlyoffice.Client, pid, localPath, folderID string, replace bool) (*onlyoffice.FileEntry, []int, error) {
+	if folderID != "" {
+		if replace {
+			return c.UploadToFolderReplacing(ctx, folderID, localPath)
+		}
+		if err := c.AssertNoFileConflict(ctx, folderID, localPath); err != nil {
+			return nil, nil, err
+		}
+		ent, err := c.UploadToFolder(ctx, folderID, localPath)
+		return ent, nil, err
+	}
+	if replace {
+		return c.UploadProjectFileReplacing(ctx, pid, localPath)
+	}
+	ent, err := c.UploadProjectFileNoClobber(ctx, pid, localPath)
+	return ent, nil, err
+}

cmd/oo/main.go

@@ -3,19 +3,22 @@
 // Command tree is subject-based (mirrors the library split and the `tea` CLI):
 //
 //	oo calendar      list | events | add | delete
-//	oo projects      list | get | milestones | create | update | delete | files (list|upload|download|rename|delete|as-md|put-md)
+//	oo projects      list | get | milestones | milestone-create | create | update | delete | contacts (add|remove) | link-authors | link-git | files (list|upload|download|rename|delete|dedupe|as-md|put-md|put-txt|put-xlsx)
 //	oo tasks         list | get | create | update | delete | subtask add | files (list|upload|detach)
 //	oo users         list | self            (alias: oo whoami)
-//	oo contacts      list | get | delete | info-add | merge | dedupe-info
+//	oo contacts      list | get | delete | info-add | merge | dedupe-info | tags | tag-add | tag-create | tag-remove
 //	oo persons       list | create | delete | dedupe
 //	oo companies     list | create | delete | dedupe | dedupe-persons
-//	oo opportunities list | get | create | delete | stages | member-add | dedupe | dedupe-members | fix-titles
+//	oo opportunities list | get | create | update | delete | stages | member-add | dedupe | dedupe-members | fix-titles
 //	oo cases         list | create | delete | member-add
-//	oo crm-tasks     list | create | delete | categories
+//	oo crm-tasks     list | create | delete | categories | reassign-self
 //	oo crm           cleanup
-//	oo mails         accounts | folders | list | get | download-attachment | draft | attach | draft-invoice | delete
+//	oo mails         accounts | folders | list | get | download-attachment | draft | attach | draft-invoice | send | delete
 //	oo invoices      list | get | create | update | pdf | pdf-cleanup | status | delete | items …
-//	oo docs          tools | convert | ocr | as-md | put-md
+//	oo docs          tools | convert | optimize | ocr | hocr | as-md | put-md | put-txt | put-xlsx
+//	oo catalog       match | merge | apply | scan-contacts | scan-projects | scan-thunderbird
+//	oo dav           ls | move | copy | mkdir | rename-file | rename-folder | download | fileops
+//	oo search        QUERY [--content] [--folder ID] [--limit N] [--json]
 //
 // CRM association rules: docs/crm-associations.md
 //

cmd/oo/projects_files.go

@@ -29,6 +29,7 @@ func projectFilesCmd() *cobra.Command {
 	cmd.AddCommand(aliasDocsAsMD())
 	cmd.AddCommand(aliasDocsPutMD())
 	cmd.AddCommand(aliasDocsPutTxt())
+	cmd.AddCommand(aliasDocsPutXlsx())
 	return cmd
 }
 
@@ -53,6 +54,13 @@ func aliasDocsPutTxt() *cobra.Command {
 	return c
 }
 
+func aliasDocsPutXlsx() *cobra.Command {
+	c := docsPutXlsxCmd()
+	c.Use = "put-xlsx PROJECT_ID [LOCAL_XLSX]"
+	c.Short = "Alias of `oo docs put-xlsx` — generate/upload XLSX with formulas"
+	return c
+}
+
 func prjFilesListCmd() *cobra.Command {
 	var showFolders bool
 	cmd := &cobra.Command{
@@ -75,8 +83,8 @@ func prjFilesListCmd() *cobra.Command {
 						continue
 					}
 					frows = append(frows, map[string]any{
-						"id":            folderIDStr(f),
-						"title":       derefString(f.Title),
+						"id":           folderIDStr(f),
+						"title":        derefString(f.Title),
 						"filesCount":   derefInt(f.FilesCount),
 						"foldersCount": derefInt(f.FoldersCount),
 					})
@@ -99,10 +107,13 @@ func prjFilesListCmd() *cobra.Command {
 }
 
 func prjFilesUploadCmd() *cobra.Command {
-	return &cobra.Command{
+	var replace, allowDuplicate bool
+	cmd := &cobra.Command{
 		Use:   "upload PROJECT_ID LOCAL_PATH [LOCAL_PATH...]",
-		Short: "Upload file(s) into the project's Documents folder",
-		Args:  cobra.MinimumNArgs(2),
+		Short: "Upload file(s) into the project's Documents folder (upsert by stem|ext)",
+		Long: `Default: replace an existing file with the same logical name (stem|ext), like cp overwrite.
+Pass --no-replace to fail when the name is taken; --allow-duplicate to always create a new file id.`,
+		Args: cobra.MinimumNArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			c, err := newOO(cmd)
 			if err != nil {
@@ -110,15 +121,31 @@ func prjFilesUploadCmd() *cobra.Command {
 			}
 			pid := args[0]
 			for _, p := range args[1:] {
-				entry, err := c.UploadProjectFile(cmd.Context(), pid, p)
+				var entry *onlyoffice.FileEntry
+				var deleted []int
+				switch {
+				case allowDuplicate:
+					entry, err = c.UploadProjectFile(cmd.Context(), pid, p)
+				case replace:
+					entry, deleted, err = c.UploadProjectFileReplacing(cmd.Context(), pid, p)
+				default:
+					entry, err = c.UploadProjectFileNoClobber(cmd.Context(), pid, p)
+				}
 				if err != nil {
 					return err
 				}
-				printObject(fileEntryToMap(entry))
+				obj := fileEntryToMap(entry)
+				if len(deleted) > 0 {
+					obj["replaced_file_ids"] = deleted
+				}
+				printObject(obj)
 			}
 			return nil
 		},
 	}
+	cmd.Flags().BoolVar(&replace, "replace", true, "replace same stem|ext in project folder (default)")
+	cmd.Flags().BoolVar(&allowDuplicate, "allow-duplicate", false, "always create a new file even when the name exists")
+	return cmd
 }
 
 func prjFilesDownloadCmd() *cobra.Command {

cmd/oo/search.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	onlyoffice "github.com/eslider/go-onlyoffice"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	rootCmd.AddCommand(searchCmd())
+}
+
+// searchCmd queries the OnlyOffice Elasticsearch index directly. The REST
+// /api/2.0/files/@search endpoint only searches file names in the database;
+// content search needs ES (see docs/elasticsearch.md).
+func searchCmd() *cobra.Command {
+	var (
+		content bool
+		folder  string
+		limit   int
+		asJSON  bool
+	)
+	cmd := &cobra.Command{
+		Use:   "search QUERY",
+		Short: "Full-text search over documents by name, optionally by content (Elasticsearch)",
+		Long: "Search the OnlyOffice Documents index.\n\n" +
+			"By default only file names are matched. With --content the query also\n" +
+			"matches extracted document text (document.attachment.content); this covers\n" +
+			"Office formats (docx/xlsx/pptx) and is slower.\n\n" +
+			"Requires ONLYOFFICE_ES_URL (and optionally ONLYOFFICE_ES_INDEX,\n" +
+			"ONLYOFFICE_TENANT). See docs/elasticsearch.md for the tunnel setup.",
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if asJSON {
+				outputFormat = "json"
+			}
+			es, err := onlyoffice.NewESSearcher(onlyoffice.ESConfigFromEnv())
+			if err != nil {
+				return err
+			}
+			hits, err := es.Search(cmd.Context(), onlyoffice.SearchQuery{
+				Text:      args[0],
+				InContent: content,
+				FolderID:  folder,
+				Limit:     limit,
+			})
+			if err != nil {
+				return err
+			}
+			rows := make([]map[string]any, 0, len(hits))
+			for _, h := range hits {
+				rows = append(rows, map[string]any{
+					"id":        h.ID,
+					"title":     h.Title,
+					"folder":    h.ParentID,
+					"score":     h.Score,
+					"highlight": h.Highlight,
+				})
+			}
+			if outputFormat == "json" {
+				printJSON(rows)
+				return nil
+			}
+			printTable([]string{"id", "title", "folder", "score", "highlight"}, rows)
+			return nil
+		},
+	}
+	cmd.Flags().BoolVar(&content, "content", false, "also match extracted document content")
+	cmd.Flags().StringVar(&folder, "folder", "", "limit to a Documents folder id")
+	cmd.Flags().IntVar(&limit, "limit", 20, "maximum number of results")
+	cmd.Flags().BoolVar(&asJSON, "json", false, "shorthand for --output json")
+	return cmd
+}

cmd/oo/search_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestSearchCommandRegisteredWithFlags(t *testing.T) {
+	cmd, _, err := rootCmd.Find([]string{"search"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cmd.Name() != "search" {
+		t.Fatalf("search resolved to %q", cmd.Name())
+	}
+	for _, name := range []string{"content", "folder", "limit", "json"} {
+		if cmd.Flags().Lookup(name) == nil {
+			t.Errorf("search: missing --%s flag", name)
+		}
+	}
+	if got := cmd.Flags().Lookup("limit").DefValue; got != "20" {
+		t.Errorf("--limit default = %q, want 20", got)
+	}
+}
+
+func TestSearchWithoutESURLIsClearError(t *testing.T) {
+	clearEnv(t, "ONLYOFFICE_ES_URL", "ONLYOFFICE_ES_INDEX", "ONLYOFFICE_TENANT")
+	errBuf := &bytes.Buffer{}
+	rootCmd.SetErr(errBuf)
+	rootCmd.SetOut(&bytes.Buffer{})
+	rootCmd.SetArgs([]string{"search", "Rechnung"})
+	t.Cleanup(func() {
+		rootCmd.SetArgs(nil)
+		rootCmd.SetOut(nil)
+		rootCmd.SetErr(nil)
+	})
+
+	err := rootCmd.Execute()
+	if err == nil {
+		t.Fatal("expected error without ONLYOFFICE_ES_URL")
+	}
+	if !strings.Contains(err.Error(), "ONLYOFFICE_ES_URL") {
+		t.Fatalf("error %q missing ONLYOFFICE_ES_URL", err.Error())
+	}
+}

cmd/ooscan/main.go

@@ -0,0 +1,50 @@
+// Command ooscan recursively lists OnlyOffice Documents folders into a TSV
+// index: file_id, folder_id, path, title.
+//
+// Usage: ooscan <FOLDER_ID> [<FOLDER_ID>...]
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"time"
+
+	onlyoffice "github.com/eslider/go-onlyoffice"
+)
+
+func main() {
+	ctx := context.Background()
+	c := onlyoffice.NewClient(onlyoffice.GetEnvironmentCredentials())
+	seen := map[string]bool{}
+	for _, root := range os.Args[1:] {
+		walk(ctx, c, root, "", 0, seen)
+	}
+}
+
+func walk(ctx context.Context, c *onlyoffice.Client, folderID, path string, depth int, seen map[string]bool) {
+	if depth > 8 || seen[folderID] {
+		return
+	}
+	seen[folderID] = true
+	// Throttle: OnlyOffice rate-limits (429) and the host must not be flooded.
+	time.Sleep(350 * time.Millisecond)
+	ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
+	defer cancel()
+	var l *onlyoffice.DavListing
+	derr := onlyoffice.DoRetry(ctx, onlyoffice.DefaultRetryPolicy(), func() error {
+		var err error
+		l, err = c.ListDavFolder(ctx, folderID)
+		return err
+	})
+	if derr != nil {
+		fmt.Fprintf(os.Stderr, "list %s (%s): %v\n", path, folderID, derr)
+		return
+	}
+	for _, f := range l.Files {
+		fmt.Printf("%s\t%s\t%s\t%s\n", f.ID, folderID, path, f.Title)
+	}
+	for _, sub := range l.Folders {
+		walk(ctx, c, sub.ID, path+"/"+sub.Title, depth+1, seen)
+	}
+}

cmd/pdfamount/main.go

@@ -0,0 +1,124 @@
+// Command pdfamount walks a Documents folder, downloads matching PDFs and
+// extracts the payable amount, printing "file_id\ttitle\tamount".
+//
+// Usage: pdfamount <FOLDER_ID> [TITLE_FILTER_REGEX]
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	onlyoffice "github.com/eslider/go-onlyoffice"
+)
+
+var amountRe = regexp.MustCompile(`(?i)(zu zahlender betrag|rechnungsbetrag)\s*[:\s]*([0-9][0-9.]*,[0-9]{2})`)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, "usage: pdfamount <FOLDER_ID> [TITLE_FILTER_REGEX]")
+		os.Exit(2)
+	}
+	folder := os.Args[1]
+	filter := regexp.MustCompile(`(?i)rechnung`)
+	if len(os.Args) >= 3 {
+		filter = regexp.MustCompile(os.Args[2])
+	}
+	ctx := context.Background()
+	c := onlyoffice.NewClient(onlyoffice.GetEnvironmentCredentials())
+
+	files := listAll(ctx, c, folder)
+	for _, f := range files {
+		if !filter.MatchString(f.title) {
+			continue
+		}
+		if !strings.HasSuffix(strings.ToLower(f.title), ".pdf") {
+			continue
+		}
+		amount, err := pdfAmount(ctx, c, f.id)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%s: %v\n", f.title, err)
+			continue
+		}
+		if amount == "" {
+			continue
+		}
+		fmt.Printf("%s\t%s\t%s\n", f.id, f.title, amount)
+	}
+}
+
+type file struct{ id, title string }
+
+func listAll(ctx context.Context, c *onlyoffice.Client, folder string) []file {
+	seen := map[string]bool{}
+	var out []file
+	var walk func(string)
+	walk = func(id string) {
+		if seen[id] {
+			return
+		}
+		seen[id] = true
+		time.Sleep(300 * time.Millisecond)
+		l, err := c.ListDavFolder(ctx, id)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "list %s: %v\n", id, err)
+			return
+		}
+		for _, f := range l.Files {
+			out = append(out, file{f.ID, f.Title})
+		}
+		for _, sub := range l.Folders {
+			walk(sub.ID)
+		}
+	}
+	walk(folder)
+	return out
+}
+
+func pdfAmount(ctx context.Context, c *onlyoffice.Client, id string) (string, error) {
+	time.Sleep(time.Second)
+	tmp, err := os.CreateTemp("", "pdf-*.pdf")
+	if err != nil {
+		return "", err
+	}
+	defer os.Remove(tmp.Name())
+	derr := onlyoffice.DoRetry(ctx, onlyoffice.DefaultRetryPolicy(), func() error {
+		_ = tmp.Truncate(0)
+		_, _ = tmp.Seek(0, 0)
+		_, err := c.DownloadFile(ctx, id, tmp)
+		return err
+	})
+	if derr != nil {
+		tmp.Close()
+		return "", derr
+	}
+	tmp.Close()
+	var buf bytes.Buffer
+	cmd := exec.CommandContext(ctx, "pdftotext", "-layout", tmp.Name(), "-")
+	cmd.Stdout = &buf
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+	m := amountRe.FindStringSubmatch(buf.String())
+	if m == nil {
+		return "", nil
+	}
+	return parseDe(m[2]), nil
+}
+
+// parseDe turns "1.234,56" into 1234.56.
+func parseDe(s string) string {
+	s = strings.ReplaceAll(s, ".", "")
+	s = strings.ReplaceAll(s, ",", ".")
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return s
+	}
+	return strconv.FormatFloat(v, 'f', 2, 64)
+}

crm.go

@@ -15,10 +15,15 @@ import (
 )
 
 // ListContacts returns a page of CRM contacts and the total count.
+// sortBy=id is always set: OnlyOffice filter.json without an explicit sort
+// order is non-deterministic on large contact sets, so a paged walk
+// (ListAllContacts, ListContactsByTag, FindCompany, FindPerson) can skip or
+// duplicate contacts across page boundaries.
 func (c *Client) ListContacts(ctx context.Context, count, startIndex int, search string) ([]map[string]any, int, error) {
 	q := url.Values{}
 	q.Set("count", strconv.Itoa(count))
 	q.Set("startIndex", strconv.Itoa(startIndex))
+	q.Set("sortBy", "id")
 	if search != "" {
 		q.Set("filterValue", search)
 	}
@@ -243,6 +248,24 @@ func (c *Client) DeleteContact(ctx context.Context, contactID string) (map[strin
 	return c.deleteObject(ctx, fmt.Sprintf("/api/2.0/crm/contact/%s.json", url.PathEscape(contactID)))
 }
 
+// UpdateContactName renames a CRM company contact displayName.
+// Uses the company endpoint (person names go through /crm/contact/person/{id}).
+func (c *Client) UpdateContactName(ctx context.Context, contactID, newName string) (map[string]any, error) {
+	body := map[string]any{
+		"displayName": newName,
+		"companyName": newName,
+		"isCompany":   true,
+	}
+	out, err := c.putJSONObject(ctx, fmt.Sprintf("/api/2.0/crm/contact/company/%s.json", url.PathEscape(contactID)), body)
+	if err != nil {
+		return out, err
+	}
+	if fresh, gerr := c.GetContact(ctx, contactID); gerr == nil && fresh != nil {
+		out = fresh
+	}
+	return out, nil
+}
+
 // ListContactTags returns all CRM contact tags (title + relativeItemsCount).
 func (c *Client) ListContactTags(ctx context.Context) ([]map[string]any, error) {
 	return c.ResponseArray(ctx, "/api/2.0/crm/contact/tag.json")
@@ -288,6 +311,7 @@ func (c *Client) ListContactsByTag(ctx context.Context, tagName string, count, s
 	q.Set("count", strconv.Itoa(count))
 	q.Set("startIndex", strconv.Itoa(startIndex))
 	q.Set("tags", tagName)
+	q.Set("sortBy", "id")
 	raw, err := c.getJSON(ctx, "/api/2.0/crm/contact/filter.json?"+q.Encode())
 	if err != nil {
 		return nil, 0, err
@@ -717,6 +741,11 @@ func (c *Client) DeleteCRMTask(ctx context.Context, id string) (map[string]any,
 	return c.deleteObject(ctx, fmt.Sprintf("/api/2.0/crm/task/%s.json", url.PathEscape(id)))
 }
 
+// CloseCRMTask closes (completes) a CRM task via the task close endpoint.
+func (c *Client) CloseCRMTask(ctx context.Context, id string) (map[string]any, error) {
+	return c.putFormObject(ctx, fmt.Sprintf("/api/2.0/crm/task/%s/close.json", url.PathEscape(id)), url.Values{})
+}
+
 // ListTaskCategories returns CRM task categories.
 func (c *Client) ListTaskCategories(ctx context.Context) ([]map[string]any, error) {
 	return c.ResponseArray(ctx, "/api/2.0/crm/task/category.json")

docs/elasticsearch.md

@@ -0,0 +1,125 @@
+---
+type: reference
+status: current
+related:
+  - README.md
+  - file_es.go
+---
+
+# Elasticsearch — полнотекстовый поиск OnlyOffice
+
+## Что это
+
+Полнотекстовый поиск OnlyOffice Workspace работает на **Elasticsearch**.
+Клиент на сервере — NEST. Индекс — имя таблицы.
+
+Для файлов индекс `files_file`:
+
+| поле | тип | смысл |
+|------|-----|-------|
+| `id` | integer | id файла (тот же, что в REST/Documents) |
+| `title` | text (`whitespacecustom`) | имя файла |
+| `tenantId` | integer | тенант (портал) |
+| `folders` | nested | список папок: `folderId` (строка), `id`, `tenantId` |
+| `document.attachment.content` | text (`document`) | извлеченный текст (ingest-attachment) |
+| `document.attachment.content_type` | text | MIME |
+
+Важно:
+- Живой сервер — **Elasticsearch 7.16.3**, кластер `elasticsearch`.
+- REST `GET /api/2.0/files/@search/{query}` ищет **только по имени в БД**
+  (`fileDao.Search`), ES не задействует. Для поиска по содержимому нужен
+  прямой ES — это и делает `oo search`.
+- `title` analyzer `whitespacecustom` режет по пробелам и lower-case. Полное
+  имя файла — один токен (`Rechnung-4711.pdf`), поэтому поиск по имени ищет
+  слово целиком, а не подстроку.
+- `document.attachment.content` заполняется **только для Office-форматов**
+  (docx / xlsx / pptx). У PDF/txt, залитых через API, контент не извлекается.
+- Индексация асинхронная (TeamLabSvc) — файл появляется в ES не мгновенно.
+
+## Доступ
+
+ES слушает `127.0.0.1:9200` **внутри** VM OnlyOffice. Снаружи порт закрыт,
+SSH в VM открыт на хосте как `127.0.0.1:32` (контейнер `onlyoffice-v2`,
+QEMU). Схема — SSH-туннель.
+
+```bash
+# из корня go-onlyoffice (ключ и хост — как в infra-доках)
+ssh -f -N -o ControlMaster=no -o ControlPath=none \
+    -p 32 -i ~/.ssh/id_ed25519 \
+    -L 9200:127.0.0.1:9200 root@127.0.0.1
+
+curl -s http://127.0.0.1:9200/ | head            # tagline + version
+curl -s 'http://127.0.0.1:9200/_cat/indices?h=index,docs.count'
+```
+
+`-o ControlMaster=no -o ControlPath=none` обязательны: иначе forward уходит
+в persistent master-соединение из `~/.ssh/config` и порт остаётся занят.
+
+Проверить, что туннель жив:
+
+```bash
+curl -s http://127.0.0.1:9200/files_file/_count
+```
+
+## Переменные
+
+| env | default | смысл |
+|-----|---------|-------|
+| `ONLYOFFICE_ES_URL` | — (обязателен) | `scheme://host:port` ES |
+| `ONLYOFFICE_ES_INDEX` | `files_file` | индекс |
+| `ONLYOFFICE_TENANT` | пусто (все) | фильтр `tenantId` |
+
+Имена — в [`.env.example`](../.env.example). Секретов нет: ES без пароля.
+
+## CLI
+
+```bash
+ONLYOFFICE_ES_URL=http://127.0.0.1:9200 oo search "Rechnung"
+ONLYOFFICE_ES_URL=http://127.0.0.1:9200 oo search "Mahngebühr" --content
+oo search "Rechnung" --folder 649 --limit 50 --json
+```
+
+Флаги: `--content` (искать и по тексту), `--folder ID` (папка
+`folders.folderId`), `--limit N` (по умолчанию 20, максимум 200),
+`--json` = `-o json`.
+
+## Библиотека
+
+`file_es.go` — `ESSearcher` (`Name() = "elasticsearch"`), прямой ES REST на
+stdlib `net/http`:
+
+```go
+es, _ := onlyoffice.NewESSearcher(onlyoffice.ESConfigFromEnv())
+hits, _ := es.Search(ctx, onlyoffice.SearchQuery{
+    Text: "Rechnung", InContent: true, Limit: 20,
+})
+```
+
+Запрос: `multi_match` по `title^2` (+ `document.attachment.content` при
+`InContent`), фильтры `tenantId` и `folders.folderId`, `_source`
+id/title/folders, `highlight` для фрагмента. Ответ → `[]SearchHit` (модель из
+эпика #34; пока объявлена в `file_es.go`, переедет в `file_core.go` с F1 #35).
+
+## Тесты
+
+```bash
+# unit — чистые builders/парсеры, без сети
+go test ./ -run ES
+
+# integration — нужен ONLYOFFICE_ES_URL (+ креды REST для залива)
+set -a; . .env; set +a
+ONLYOFFICE_ES_URL=http://127.0.0.1:9200 ONLYOFFICE_TENANT=1 \
+  go test -tags=integration -run TestIntegrationESSearch -v .
+```
+
+Интеграционный тест заливает временный xlsx (в имени и в ячейке — уникальные
+токены), ждёт индексации, проверяет поиск по имени и по содержимому, затем
+удаляет проект.
+
+## Грабли
+
+- `locale`/версия ES: 7.16.3, `_search` совместим с REST 7.x.
+- ES без auth и слушает только localhost — туннель обязателен.
+- Фильтр `tenantId` сузит выдачу; без него видны документы всех тенантов.
+- Поиск по содержимому PDF, залитых через API, не работает (нет
+  `attachment.content`) — только Office-форматы.

file_es.go

@@ -0,0 +1,329 @@
+package onlyoffice
+
+// Elasticsearch backend of the unified file client (epic #34, F3 #37).
+//
+// OnlyOffice full-text search runs on Elasticsearch (index `files_file`, NEST
+// client on the server). The REST endpoint GET /api/2.0/files/@search/{query}
+// only searches file names in the database, so content search needs a direct
+// ES query. The live server is Elasticsearch 7.16.3; the request shape below
+// is plain REST and stays stdlib-only, matching the repo's no-extra-deps rule.
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Canonical file/search model (epic #34, F1 #35). Declared here because F1 is
+// not merged yet; move to file_core.go and drop these when it lands. Keep the
+// shape identical to the contract in #35.
+type (
+	// Kind distinguishes a file from a folder.
+	Kind int
+	// Entry is a canonical file/folder record.
+	Entry struct {
+		ID       string
+		ParentID string
+		Title    string
+		Kind     Kind
+		Size     int64
+		MIME     string
+		Created  time.Time
+		Modified time.Time
+		Version  int
+		Provider string
+	}
+	// SearchQuery is a backend-agnostic search request.
+	SearchQuery struct {
+		Text       string
+		InContent  bool
+		FolderID   string
+		Extensions []string
+		Limit      int
+	}
+	// SearchHit is a search result entry plus its relevance data.
+	SearchHit struct {
+		Entry
+		Score     float64
+		Highlight string
+		Path      []string
+	}
+	// Searcher searches a document store by name and optionally content.
+	Searcher interface {
+		Search(ctx context.Context, q SearchQuery) ([]SearchHit, error)
+		Name() string
+	}
+)
+
+// Kind values (epic #34).
+const (
+	File Kind = iota
+	Folder
+)
+
+const (
+	defaultESIndex    = "files_file"
+	defaultESLimit    = 20
+	maxESLimit        = 200
+	maxESResponseSize = 8 << 20
+)
+
+// ESConfig configures the direct Elasticsearch searcher.
+type ESConfig struct {
+	URL    string // scheme://host:port of the ES HTTP endpoint
+	Index  string // index name, default files_file
+	Tenant string // tenantId filter, empty means all tenants
+}
+
+// ESConfigFromEnv reads ONLYOFFICE_ES_URL, ONLYOFFICE_ES_INDEX (default
+// files_file) and ONLYOFFICE_TENANT. The library never loads dotfiles — the
+// CLI does that.
+func ESConfigFromEnv() ESConfig {
+	return ESConfig{
+		URL:    strings.TrimRight(strings.TrimSpace(os.Getenv("ONLYOFFICE_ES_URL")), "/"),
+		Index:  firstNonEmpty(os.Getenv("ONLYOFFICE_ES_INDEX"), defaultESIndex),
+		Tenant: strings.TrimSpace(os.Getenv("ONLYOFFICE_TENANT")),
+	}
+}
+
+// ESSearcher queries OnlyOffice's Elasticsearch index directly for file name
+// and document content.
+type ESSearcher struct {
+	cfg  ESConfig
+	http *http.Client
+}
+
+// NewESSearcher returns a searcher for the OnlyOffice Elasticsearch index.
+// The URL is required; an empty index falls back to files_file.
+func NewESSearcher(cfg ESConfig) (*ESSearcher, error) {
+	if strings.TrimSpace(cfg.URL) == "" {
+		return nil, fmt.Errorf("onlyoffice: elasticsearch URL is empty (set ONLYOFFICE_ES_URL)")
+	}
+	cfg.URL = strings.TrimRight(cfg.URL, "/")
+	if cfg.Index == "" {
+		cfg.Index = defaultESIndex
+	}
+	return &ESSearcher{cfg: cfg, http: &http.Client{Timeout: 30 * time.Second}}, nil
+}
+
+// Name implements Searcher.
+func (s *ESSearcher) Name() string { return "elasticsearch" }
+
+// Search runs a multi_match over title (and, when q.InContent is set,
+// document.attachment.content), filtered by tenant and optional folder.
+func (s *ESSearcher) Search(ctx context.Context, q SearchQuery) ([]SearchHit, error) {
+	q.Text = strings.TrimSpace(q.Text)
+	if q.Text == "" {
+		return nil, fmt.Errorf("onlyoffice: empty search query")
+	}
+	body, err := json.Marshal(esSearchRequest(q, s.cfg.Tenant))
+	if err != nil {
+		return nil, fmt.Errorf("onlyoffice: build elasticsearch query: %w", err)
+	}
+	endpoint := s.cfg.URL + "/" + s.cfg.Index + "/_search"
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("onlyoffice: elasticsearch search: %w", err)
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(io.LimitReader(resp.Body, maxESResponseSize))
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode >= 400 {
+		return nil, fmt.Errorf("onlyoffice: elasticsearch search: %d %s", resp.StatusCode, truncate(string(raw), 400))
+	}
+	return parseESSearchResponse(raw)
+}
+
+// esSearchRequest builds the ES query body. Pure, so it is unit-tested.
+func esSearchRequest(q SearchQuery, tenant string) esRequest {
+	limit := q.Limit
+	if limit <= 0 {
+		limit = defaultESLimit
+	}
+	if limit > maxESLimit {
+		limit = maxESLimit
+	}
+	fields := []string{"title^2"}
+	if q.InContent {
+		fields = append(fields, "document.attachment.content")
+	}
+	must := []esClause{{MultiMatch: &esMultiMatch{Query: q.Text, Fields: fields}}}
+
+	var filter []esClause
+	if t := strings.TrimSpace(tenant); t != "" {
+		filter = append(filter, esClause{Term: map[string]any{"tenantId": numericOrString(t)}})
+	}
+	if f := strings.TrimSpace(q.FolderID); f != "" {
+		filter = append(filter, esClause{Term: map[string]any{"folders.folderId": f}})
+	}
+	for _, ext := range normalizeExtensions(q.Extensions) {
+		filter = append(filter, esClause{Wildcard: map[string]any{"title": "*." + ext}})
+	}
+
+	highlightFields := map[string]struct{}{"title": {}}
+	if q.InContent {
+		highlightFields["document.attachment.content"] = struct{}{}
+	}
+	return esRequest{
+		Size:      limit,
+		Source:    []string{"id", "title", "folders"},
+		Query:     esQuery{Bool: esBool{Must: must, Filter: filter}},
+		Highlight: esHighlight{PreTags: []string{"<em>"}, PostTags: []string{"</em>"}, Fields: highlightFields},
+	}
+}
+
+// normalizeExtensions lowercases, trims leading dots and drops empties.
+func normalizeExtensions(exts []string) []string {
+	out := make([]string, 0, len(exts))
+	seen := map[string]bool{}
+	for _, e := range exts {
+		e = strings.ToLower(strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(e), ".")))
+		if e == "" || seen[e] {
+			continue
+		}
+		seen[e] = true
+		out = append(out, e)
+	}
+	return out
+}
+
+// numericOrString keeps an integer-looking filter value numeric (tenantId is
+// a long) and leaves anything else as a string (folderId is a text token).
+func numericOrString(s string) any {
+	if n, err := strconv.ParseInt(s, 10, 64); err == nil {
+		return n
+	}
+	return s
+}
+
+// esRequest is the subset of the ES query DSL this client emits.
+type esRequest struct {
+	Size      int         `json:"size"`
+	Source    []string    `json:"_source"`
+	Query     esQuery     `json:"query"`
+	Highlight esHighlight `json:"highlight"`
+}
+
+type esQuery struct {
+	Bool esBool `json:"bool"`
+}
+
+type esBool struct {
+	Must   []esClause `json:"must,omitempty"`
+	Filter []esClause `json:"filter,omitempty"`
+}
+
+type esClause struct {
+	MultiMatch *esMultiMatch  `json:"multi_match,omitempty"`
+	Term       map[string]any `json:"term,omitempty"`
+	Wildcard   map[string]any `json:"wildcard,omitempty"`
+}
+
+type esMultiMatch struct {
+	Query  string   `json:"query"`
+	Fields []string `json:"fields"`
+}
+
+type esHighlight struct {
+	PreTags  []string            `json:"pre_tags,omitempty"`
+	PostTags []string            `json:"post_tags,omitempty"`
+	Fields   map[string]struct{} `json:"fields"`
+}
+
+// esResponse is the subset of an ES search response we consume.
+type esResponse struct {
+	Took int `json:"took"`
+	Hits struct {
+		Total struct {
+			Value    int    `json:"value"`
+			Relation string `json:"relation"`
+		} `json:"total"`
+		Hits []esResponseHit `json:"hits"`
+	} `json:"hits"`
+}
+
+type esResponseHit struct {
+	ID     string  `json:"_id"`
+	Score  float64 `json:"_score"`
+	Source struct {
+		ID      int    `json:"id"`
+		Title   string `json:"title"`
+		Folders []struct {
+			FolderID string `json:"folderId"`
+			ID       int    `json:"id"`
+		} `json:"folders"`
+	} `json:"_source"`
+	Highlight map[string][]string `json:"highlight"`
+}
+
+// parseESSearchResponse converts an ES search response into SearchHit values.
+// Pure, so it is unit-tested.
+func parseESSearchResponse(raw []byte) ([]SearchHit, error) {
+	var r esResponse
+	if err := json.Unmarshal(raw, &r); err != nil {
+		return nil, fmt.Errorf("onlyoffice: decode elasticsearch response: %w", err)
+	}
+	hits := make([]SearchHit, 0, len(r.Hits.Hits))
+	for _, h := range r.Hits.Hits {
+		id := strconv.Itoa(h.Source.ID)
+		if h.Source.ID == 0 {
+			id = h.ID
+		}
+		var parent string
+		path := make([]string, 0, len(h.Source.Folders))
+		for i, f := range h.Source.Folders {
+			path = append(path, f.FolderID)
+			if i == 0 {
+				parent = f.FolderID
+			}
+		}
+		hits = append(hits, SearchHit{
+			Entry: Entry{
+				ID:       id,
+				ParentID: parent,
+				Title:    h.Source.Title,
+				Kind:     File,
+				Provider: "elasticsearch",
+			},
+			Score:     h.Score,
+			Highlight: esHighlightText(h.Highlight),
+			Path:      path,
+		})
+	}
+	return hits, nil
+}
+
+var esHighlightTag = regexp.MustCompile(`</?em[^>]*>`)
+
+// esHighlightText flattens a highlight map into one plain-text snippet,
+// preferring the content fragment over the title.
+func esHighlightText(hl map[string][]string) string {
+	for _, key := range []string{"document.attachment.content", "title"} {
+		frags := hl[key]
+		if len(frags) == 0 {
+			continue
+		}
+		clean := make([]string, 0, len(frags))
+		for _, f := range frags {
+			clean = append(clean, esHighlightTag.ReplaceAllString(f, ""))
+		}
+		return strings.Join(clean, " … ")
+	}
+	return ""
+}

file_es_integration_test.go

@@ -0,0 +1,135 @@
+//go:build integration
+
+package onlyoffice
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xuri/excelize/v2"
+)
+
+// TestIntegrationESSearch uploads a throwaway workbook and verifies that the
+// direct Elasticsearch search finds it by file name and by content.
+//
+// The content index (document.attachment.content) is only populated for Office
+// formats (docx/xlsx/pptx), so the fixture is an xlsx whose cell carries a
+// unique token. Requires ONLYOFFICE_ES_URL (a reachable ES endpoint — in the
+// current setup a tunnel to the ES inside the OnlyOffice VM, see
+// docs/elasticsearch.md) plus the regular REST credentials for the upload.
+// Skips when either is missing.
+func TestIntegrationESSearch(t *testing.T) {
+	esURL := strings.TrimSpace(os.Getenv("ONLYOFFICE_ES_URL"))
+	if esURL == "" {
+		t.Skip("ONLYOFFICE_ES_URL not set — skipping Elasticsearch integration test")
+	}
+	c := liveClient(t)
+	t.Cleanup(func() { cleanupTestProjects(t, c) })
+
+	stamp := time.Now().UTC().Format("20060102-150405")
+	nameToken := "goesname" + stamp
+	contentToken := "goescontent" + stamp
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+
+	project, err := c.CreateProject(NewProjectRequest{
+		Title:       testProjectPrefix + "es-" + stamp,
+		Description: "go-onlyoffice elasticsearch integration",
+	})
+	if err != nil {
+		t.Fatalf("CreateProject: %v", err)
+	}
+	if project.ID == nil {
+		t.Fatal("created project without id")
+	}
+	pid := strconv.Itoa(*project.ID)
+
+	title := nameToken + ".xlsx"
+	localPath := filepath.Join(t.TempDir(), title)
+	book := excelize.NewFile()
+	if err := book.SetCellValue("Sheet1", "A1", "OnlyOffice Elasticsearch content fixture "+contentToken); err != nil {
+		t.Fatalf("SetCellValue: %v", err)
+	}
+	if err := book.SaveAs(localPath); err != nil {
+		t.Fatalf("SaveAs: %v", err)
+	}
+
+	entry, err := c.UploadProjectFile(ctx, pid, localPath)
+	if err != nil {
+		t.Fatalf("UploadProjectFile: %v", err)
+	}
+	fileID := strconv.Itoa(int(FileEntryNumericID(entry)))
+	if fileID == "0" {
+		t.Fatalf("upload returned no file id: %+v", entry)
+	}
+
+	es, err := NewESSearcher(ESConfig{
+		URL:    esURL,
+		Index:  os.Getenv("ONLYOFFICE_ES_INDEX"),
+		Tenant: os.Getenv("ONLYOFFICE_TENANT"),
+	})
+	if err != nil {
+		t.Fatalf("NewESSearcher: %v", err)
+	}
+
+	// Indexing is asynchronous on the server; poll until the file shows up.
+	// The server's title analyzer splits on whitespace, so the name query is
+	// the full file name token (including extension), as a user would type it.
+	nameHit := waitForHit(t, ctx, es, SearchQuery{Text: title}, fileID)
+	if nameHit.Title != title {
+		t.Errorf("name hit title = %q, want %q", nameHit.Title, title)
+	}
+	contentHit := waitForHit(t, ctx, es, SearchQuery{Text: contentToken, InContent: true}, fileID)
+	if contentHit.Highlight == "" {
+		t.Error("content hit has no highlight fragment")
+	}
+	if !strings.Contains(contentHit.Title, nameToken) {
+		t.Errorf("content hit title = %q, want the uploaded workbook", contentHit.Title)
+	}
+
+	// The content token is absent from the title, so a name-only search must
+	// not return the file — this proves the content field is really queried.
+	if hits := searchQuiet(t, es, SearchQuery{Text: contentToken}); len(hits) != 0 {
+		t.Errorf("name-only search for content token returned %d hits, want 0", len(hits))
+	}
+}
+
+// waitForHit polls ES until the file with fileID appears and returns that hit.
+func waitForHit(t *testing.T, ctx context.Context, s *ESSearcher, q SearchQuery, fileID string) SearchHit {
+	t.Helper()
+	var lastErr error
+	for {
+		hits, err := s.Search(ctx, q)
+		if err != nil {
+			lastErr = err
+		} else {
+			for _, h := range hits {
+				if h.ID == fileID {
+					return h
+				}
+			}
+		}
+		select {
+		case <-ctx.Done():
+			t.Fatalf("search %q: file %s not indexed in time (last err: %v)", q.Text, fileID, lastErr)
+		case <-time.After(3 * time.Second):
+		}
+	}
+}
+
+func searchQuiet(t *testing.T, s *ESSearcher, q SearchQuery) []SearchHit {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	hits, err := s.Search(ctx, q)
+	if err != nil {
+		t.Fatalf("Search(%q): %v", q.Text, err)
+	}
+	return hits
+}

file_es_test.go

@@ -0,0 +1,188 @@
+package onlyoffice
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+func TestESSearchRequestNameOnly(t *testing.T) {
+	got := esSearchRequest(SearchQuery{Text: "Rechnung"}, "1")
+	if got.Size != defaultESLimit {
+		t.Errorf("size = %d, want %d", got.Size, defaultESLimit)
+	}
+	if !reflect.DeepEqual(got.Source, []string{"id", "title", "folders"}) {
+		t.Errorf("_source = %v", got.Source)
+	}
+	if len(got.Query.Bool.Must) != 1 || got.Query.Bool.Must[0].MultiMatch == nil {
+		t.Fatalf("must = %+v, want one multi_match", got.Query.Bool.Must)
+	}
+	mm := got.Query.Bool.Must[0].MultiMatch
+	if mm.Query != "Rechnung" {
+		t.Errorf("query = %q", mm.Query)
+	}
+	if !reflect.DeepEqual(mm.Fields, []string{"title^2"}) {
+		t.Errorf("fields = %v, want title only", mm.Fields)
+	}
+	if _, ok := got.Highlight.Fields["document.attachment.content"]; ok {
+		t.Error("content highlight present without InContent")
+	}
+	if _, ok := got.Highlight.Fields["title"]; !ok {
+		t.Error("title highlight missing")
+	}
+	if len(got.Query.Bool.Filter) != 1 || got.Query.Bool.Filter[0].Term["tenantId"] != int64(1) {
+		t.Errorf("tenant filter = %+v, want numeric tenantId=1", got.Query.Bool.Filter)
+	}
+}
+
+func TestESSearchRequestContentFields(t *testing.T) {
+	got := esSearchRequest(SearchQuery{Text: "Mahnung", InContent: true}, "")
+	mm := got.Query.Bool.Must[0].MultiMatch
+	want := []string{"title^2", "document.attachment.content"}
+	if !reflect.DeepEqual(mm.Fields, want) {
+		t.Errorf("fields = %v, want %v", mm.Fields, want)
+	}
+	if _, ok := got.Highlight.Fields["document.attachment.content"]; !ok {
+		t.Error("content highlight missing with InContent")
+	}
+	if len(got.Query.Bool.Filter) != 0 {
+		t.Errorf("filter = %+v, want none without tenant/folder", got.Query.Bool.Filter)
+	}
+}
+
+func TestESSearchRequestFiltersAndLimit(t *testing.T) {
+	got := esSearchRequest(SearchQuery{
+		Text:       "Storchen",
+		FolderID:   "649",
+		Extensions: []string{".PDF", "pdf", "docx"},
+		Limit:      999,
+	}, "42")
+	if got.Size != maxESLimit {
+		t.Errorf("size = %d, want cap %d", got.Size, maxESLimit)
+	}
+	var tenant, folder, wildcards int
+	for _, f := range got.Query.Bool.Filter {
+		switch {
+		case f.Term != nil && f.Term["tenantId"] != nil:
+			tenant++
+		case f.Term != nil && f.Term["folders.folderId"] != nil:
+			folder++
+			if f.Term["folders.folderId"] != "649" {
+				t.Errorf("folder filter = %+v", f.Term)
+			}
+		case f.Wildcard != nil:
+			wildcards++
+		}
+	}
+	if tenant != 1 || folder != 1 {
+		t.Errorf("term filters tenant=%d folder=%d, want 1 each", tenant, folder)
+	}
+	if wildcards != 2 {
+		t.Errorf("wildcard filters = %d, want deduped PDF+docx", wildcards)
+	}
+}
+
+func TestESSearchRequestRejectsEmptyTextAtSearch(t *testing.T) {
+	s, err := NewESSearcher(ESConfig{URL: "http://localhost:9200"})
+	if err != nil {
+		t.Fatalf("NewESSearcher: %v", err)
+	}
+	if _, err := s.Search(t.Context(), SearchQuery{Text: "  "}); err == nil {
+		t.Error("empty query: want error")
+	}
+}
+
+func TestNewESSearcherRequiresURL(t *testing.T) {
+	if _, err := NewESSearcher(ESConfig{}); err == nil {
+		t.Error("empty URL: want error")
+	}
+	s, err := NewESSearcher(ESConfig{URL: "http://es:9200/"})
+	if err != nil {
+		t.Fatalf("NewESSearcher: %v", err)
+	}
+	if s.cfg.Index != defaultESIndex {
+		t.Errorf("index = %q, want %q", s.cfg.Index, defaultESIndex)
+	}
+	if s.cfg.URL != "http://es:9200" {
+		t.Errorf("url = %q, want trimmed", s.cfg.URL)
+	}
+	if s.Name() != "elasticsearch" {
+		t.Errorf("Name() = %q", s.Name())
+	}
+}
+
+func TestNormalizeExtensions(t *testing.T) {
+	got := normalizeExtensions([]string{" .PDF ", "pdf", "", "xlsx"})
+	want := []string{"pdf", "xlsx"}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("normalizeExtensions = %v, want %v", got, want)
+	}
+}
+
+func TestParseESSearchResponse(t *testing.T) {
+	raw := []byte(`{
+	  "took": 12,
+	  "hits": {
+	    "total": {"value": 2, "relation": "eq"},
+	    "hits": [
+	      {
+	        "_id": "2395",
+	        "_score": 7.31,
+	        "_source": {"id": 2395, "title": "Rechnung-4711.pdf",
+	          "folders": [{"folderId": "438", "id": 0}, {"folderId": "11", "id": 0}]},
+	        "highlight": {
+	          "title": ["<em>Rechnung</em>-4711.pdf"],
+	          "document.attachment.content": ["… Zahlung der <em>Rechnung</em> …"]
+	        }
+	      },
+	      {
+	        "_id": "2318",
+	        "_score": 6.02,
+	        "_source": {"id": 2318, "title": "Mahnung.pdf", "folders": []},
+	        "highlight": {"title": ["<em>Mahnung</em>.pdf"]}
+	      }
+	    ]
+	  }
+	}`)
+	hits, err := parseESSearchResponse(raw)
+	if err != nil {
+		t.Fatalf("parseESSearchResponse: %v", err)
+	}
+	if len(hits) != 2 {
+		t.Fatalf("hits = %d, want 2", len(hits))
+	}
+	h0 := hits[0]
+	if h0.ID != "2395" || h0.Title != "Rechnung-4711.pdf" || h0.Kind != File {
+		t.Errorf("hit0 entry = %+v", h0.Entry)
+	}
+	if h0.ParentID != "438" || !reflect.DeepEqual(h0.Path, []string{"438", "11"}) {
+		t.Errorf("hit0 path = %v parent = %q", h0.Path, h0.ParentID)
+	}
+	if h0.Score != 7.31 {
+		t.Errorf("hit0 score = %v", h0.Score)
+	}
+	if h0.Highlight != "… Zahlung der Rechnung …" {
+		t.Errorf("hit0 highlight = %q, want content fragment", h0.Highlight)
+	}
+	if hits[1].Highlight != "Mahnung.pdf" {
+		t.Errorf("hit1 highlight = %q, want title without tags", hits[1].Highlight)
+	}
+	if hits[1].ParentID != "" || len(hits[1].Path) != 0 {
+		t.Errorf("hit1 path = %v", hits[1].Path)
+	}
+}
+
+func TestESSearchRequestJSONShape(t *testing.T) {
+	got := esSearchRequest(SearchQuery{Text: "Rechnung", InContent: true}, "1")
+	b, err := json.Marshal(got)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	var back map[string]any
+	if err := json.Unmarshal(b, &back); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if _, ok := back["query"].(map[string]any)["bool"]; !ok {
+		t.Errorf("query.bool missing: %s", b)
+	}
+}

files.go

@@ -237,6 +237,15 @@ func (c *Client) UploadProjectFile(ctx context.Context, projectID, localPath str
 	return decodeResponseFileEntry(raw)
 }
 
+// UploadProjectFileReplacing upserts by stem|ext in the project Documents folder.
+func (c *Client) UploadProjectFileReplacing(ctx context.Context, projectID, localPath string) (*FileEntry, []int, error) {
+	folderID, err := c.projectFolderID(ctx, projectID)
+	if err != nil {
+		return nil, nil, err
+	}
+	return c.UploadToFolderReplacing(ctx, folderID, localPath)
+}
+
 // GetFile returns file metadata including viewUrl for download.
 func (c *Client) GetFile(ctx context.Context, fileID string) (*FileEntry, error) {
 	if fileID == "" {
@@ -312,11 +321,21 @@ func (c *Client) MoveFiles(ctx context.Context, destFolderID int, fileIDs []int)
 		"folderIds":    []int{},
 		"fileIds":      fileIDs,
 		"destFolderId": destFolderID,
+		"resolveType":  "Skip",
+		"holdResult":   true,
 	}
 	out, err := c.putJSONObject(ctx, "/api/2.0/files/fileops/move.json", body)
 	if err != nil {
 		out, err = c.putJSONObject(ctx, "/api/2.0/files/fileops/move", body)
 	}
+	if err != nil {
+		return nil, err
+	}
+	if raw, merr := json.Marshal(out); merr == nil {
+		if ferr := fileopsError(raw); ferr != nil {
+			return nil, ferr
+		}
+	}
 	return out, err
 }
 
@@ -337,6 +356,35 @@ func (c *Client) UploadToFolder(ctx context.Context, folderID, localPath string)
 	return decodeResponseFileEntry(raw)
 }
 
+// UpdateFile uploads a new version of an existing file (same id, name and
+// folder). It does not delete and does not create a second file.
+//
+// The Documents API method is PUT /api/2.0/files/{id}/update; POST is kept as
+// a fallback for older servers. The path is tried with and without .json.
+func (c *Client) UpdateFile(ctx context.Context, fileID, localPath string) (*FileEntry, error) {
+	if fileID == "" || localPath == "" {
+		return nil, fmt.Errorf("file id and local path are required")
+	}
+	base := fmt.Sprintf("/api/2.0/files/%s/update", url.PathEscape(fileID))
+	attempts := []struct {
+		method, path string
+	}{
+		{http.MethodPut, base},
+		{http.MethodPut, base + ".json"},
+		{http.MethodPost, base},
+		{http.MethodPost, base + ".json"},
+	}
+	var lastErr error
+	for _, a := range attempts {
+		raw, err := c.uploadMultipartMethod(ctx, a.method, a.path, "file", localPath)
+		if err == nil {
+			return decodeResponseFileEntry(raw)
+		}
+		lastErr = err
+	}
+	return nil, lastErr
+}
+
 // FileFolderID returns the parent folder id string for a file entry, if known.
 func FileFolderID(f *FileEntry) string {
 	if f == nil || f.FolderID == nil {
@@ -346,36 +394,15 @@ func FileFolderID(f *FileEntry) string {
 }
 
 // DownloadFile streams file bytes from the file's viewUrl using the same auth
-// as API calls. Writes into dst.
+// as API calls. Writes into dst. When the portal serves the file from its stale
+// AWS S3 consumer, the bytes are fetched from the local MinIO store instead
+// (see storage_fallback.go).
 func (c *Client) DownloadFile(ctx context.Context, fileID string, dst io.Writer) (int64, error) {
 	f, err := c.GetFile(ctx, fileID)
 	if err != nil {
 		return 0, err
 	}
-	if f.ViewURL == nil || *f.ViewURL == "" {
-		return 0, fmt.Errorf("file %s has no viewUrl", fileID)
-	}
-	downloadURL := c.resolveAPIURL(*f.ViewURL)
-	auth, err := c.authHeader()
-	if err != nil {
-		return 0, err
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
-	if err != nil {
-		return 0, err
-	}
-	req.Header.Set("Authorization", auth)
-	resp, err := c.client.Do(req)
-	if err != nil {
-		return 0, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		b, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
-		return 0, fmt.Errorf("GET viewUrl: %d %s", resp.StatusCode, truncate(string(b), 400))
-	}
-	n, err := io.Copy(dst, resp.Body)
-	return n, err
+	return c.downloadFileEntry(ctx, f, dst)
 }
 
 func (c *Client) resolveAPIURL(ref string) string {

files_dedupe.go

@@ -2,6 +2,7 @@ package onlyoffice
 
 import (
 	"context"
+	"encoding/json"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -310,25 +311,70 @@ func (c *Client) DeleteFilesByDedupKey(ctx context.Context, folderID, stem, ext
 	return ids, nil
 }
 
+// mergeProjectRootForDedupe includes projectFolder files in dedupe scans. OO often lists
+// root documents only in pf.Files while pf.Folders is empty.
+func mergeProjectRootForDedupe(rootID string, folders []*FolderEntry, filesByFolder map[string][]*FileEntry, rootFiles []*FileEntry) ([]*FolderEntry, map[string][]*FileEntry) {
+	if rootID == "" {
+		return folders, filesByFolder
+	}
+	if filesByFolder == nil {
+		filesByFolder = map[string][]*FileEntry{}
+	}
+	for _, folder := range folders {
+		if folder != nil && folder.ID != nil && folder.ID.String() == rootID {
+			if len(rootFiles) > 0 {
+				filesByFolder[rootID] = rootFiles
+			}
+			return folders, filesByFolder
+		}
+	}
+	if len(rootFiles) == 0 {
+		return folders, filesByFolder
+	}
+	id := json.Number(rootID)
+	title := "(project root)"
+	folders = append(folders, &FolderEntry{ID: &id, Title: &title})
+	filesByFolder[rootID] = rootFiles
+	return folders, filesByFolder
+}
+
 // DedupeProject scans project folders and optionally deletes duplicates.
 func (c *Client) DedupeProject(ctx context.Context, projectID string, opts DedupOptions, apply bool) ([]DedupGroup, []int, error) {
 	pf, err := c.GetProjectFiles(ctx, projectID)
 	if err != nil {
 		return nil, nil, err
 	}
-	filesByFolder := make(map[string][]*FileEntry, len(pf.Folders))
+	rootID, err := c.projectFolderID(ctx, projectID)
+	if err != nil {
+		return nil, nil, err
+	}
+	var rootFiles []*FileEntry
+	if rootID != "" {
+		rootFiles, err = c.FolderFiles(ctx, rootID)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	filesByFolder := make(map[string][]*FileEntry, len(pf.Folders)+1)
+	folders := make([]*FolderEntry, 0, len(pf.Folders)+1)
 	for _, folder := range pf.Folders {
 		if folder == nil || folder.ID == nil {
 			continue
 		}
 		fid := folder.ID.String()
-		files, err := c.FolderFiles(ctx, fid)
-		if err != nil {
-			return nil, nil, err
+		if fid == rootID {
+			filesByFolder[fid] = rootFiles
+		} else {
+			files, err := c.FolderFiles(ctx, fid)
+			if err != nil {
+				return nil, nil, err
+			}
+			filesByFolder[fid] = files
 		}
-		filesByFolder[fid] = files
+		folders = append(folders, folder)
 	}
-	groups := FindProjectDuplicates(pf.Folders, filesByFolder, opts)
+	folders, filesByFolder = mergeProjectRootForDedupe(rootID, folders, filesByFolder, rootFiles)
+	groups := FindProjectDuplicates(folders, filesByFolder, opts)
 	if !apply || len(groups) == 0 {
 		return groups, nil, nil
 	}

files_dedupe_test.go

@@ -64,6 +64,26 @@ func TestCrossFolderPrefersNonTrash(t *testing.T) {
 	}
 }
 
+func TestMergeProjectRootForDedupe(t *testing.T) {
+	old := &FileEntry{ID: jsonNum("1"), Title: strPtr("a.docx"), FileExst: strPtr(".docx")}
+	newer := &FileEntry{ID: jsonNum("2"), Title: strPtr("a.docx"), FileExst: strPtr(".docx")}
+	rootFiles := []*FileEntry{old, newer}
+	folders, byFolder := mergeProjectRootForDedupe("489", nil, nil, rootFiles)
+	if len(folders) != 1 || folders[0].ID.String() != "489" {
+		t.Fatalf("folders=%+v", folders)
+	}
+	if len(byFolder["489"]) != 2 {
+		t.Fatalf("root files=%d", len(byFolder["489"]))
+	}
+	groups := findWithinFolderDuplicates([]ProjectFolderFile{
+		{FolderID: "489", FolderTitle: "(project root)", File: old},
+		{FolderID: "489", FolderTitle: "(project root)", File: newer},
+	})
+	if len(groups) != 1 {
+		t.Fatalf("groups=%d", len(groups))
+	}
+}
+
 func TestIsTrashFolderTitle(t *testing.T) {
 	if !IsTrashFolderTitle("_trash-md") {
 		t.Fatal("expected trash")

files_stem.go

@@ -3,10 +3,15 @@ package onlyoffice
 import (
 	"context"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"path/filepath"
 	"strings"
 )
 
+// ErrFileExists is returned when --no-replace / no-clobber upload hits an existing stem|ext.
+var ErrFileExists = errors.New("onlyoffice: file already exists in folder (use replace or delete first)")
+
 // FileEntryStem returns the logical basename without duplicated extensions.
 // OO often stores title="foo.docx" and fileExst=".docx" (UI shows foo.docx.docx).
 func FileEntryStem(f *FileEntry) string {
@@ -116,6 +121,38 @@ func (c *Client) DeleteFilesByStem(ctx context.Context, folderID, stem string) (
 	return ids, nil
 }
 
+// AssertNoFileConflict reports ErrFileExists when localPath stem|ext is already in folderID.
+func (c *Client) AssertNoFileConflict(ctx context.Context, folderID, localPath string) error {
+	files, err := c.FolderFiles(ctx, folderID)
+	if err != nil {
+		return err
+	}
+	stem := UploadStemFromLocal(localPath)
+	ext := UploadExtFromLocal(localPath)
+	matches := FindFilesByDedupKey(files, stem, ext)
+	if len(matches) == 0 {
+		return nil
+	}
+	ids := make([]string, 0, len(matches))
+	for _, f := range matches {
+		ids = append(ids, fmt.Sprintf("%d", FileEntryNumericID(f)))
+	}
+	return fmt.Errorf("%w: %s%s in folder %s (existing file ids: %s)",
+		ErrFileExists, stem, ext, folderID, strings.Join(ids, ", "))
+}
+
+// UploadProjectFileNoClobber uploads only when stem|ext is not already in the project folder.
+func (c *Client) UploadProjectFileNoClobber(ctx context.Context, projectID, localPath string) (*FileEntry, error) {
+	folderID, err := c.projectFolderID(ctx, projectID)
+	if err != nil {
+		return nil, err
+	}
+	if err := c.AssertNoFileConflict(ctx, folderID, localPath); err != nil {
+		return nil, err
+	}
+	return c.UploadProjectFile(ctx, projectID, localPath)
+}
+
 // UploadToFolderReplacing deletes same stem+ext files then uploads localPath.
 func (c *Client) UploadToFolderReplacing(ctx context.Context, folderID, localPath string) (*FileEntry, []int, error) {
 	stem := UploadStemFromLocal(localPath)

files_webdav.go

@@ -144,27 +144,85 @@ func (c *Client) RenameDavFile(ctx context.Context, id, title string) error {
 }
 
 // MoveDavItems moves the given folders and/or files into destFolderID.
+// The fileops API answers 200 with per-operation error strings even when
+// nothing moves (e.g. missing permission), so the response is parsed and the
+// first operation error is returned instead of a silent nil.
 func (c *Client) MoveDavItems(ctx context.Context, folderIDs, fileIDs []string, destFolderID string) error {
-	_, err := c.putJSON(ctx, "/api/2.0/files/fileops/move", map[string]any{
+	raw, err := c.putJSON(ctx, "/api/2.0/files/fileops/move", map[string]any{
 		"folderIds":    nums(folderIDs),
 		"fileIds":      nums(fileIDs),
 		"destFolderId": num(destFolderID),
 		"resolveType":  "Skip",
 		"holdResult":   true,
 	})
-	return err
+	if err != nil {
+		return err
+	}
+	return fileopsError(raw)
 }
 
 // CopyDavItems copies the given folders and/or files into destFolderID.
+// Per-operation errors are surfaced like in MoveDavItems.
 func (c *Client) CopyDavItems(ctx context.Context, folderIDs, fileIDs []string, destFolderID string) error {
-	_, err := c.putJSON(ctx, "/api/2.0/files/fileops/copy", map[string]any{
+	raw, err := c.putJSON(ctx, "/api/2.0/files/fileops/copy", map[string]any{
 		"folderIds":           nums(folderIDs),
 		"fileIds":             nums(fileIDs),
 		"destFolderId":        num(destFolderID),
 		"conflictResolveType": "Skip",
 		"deleteAfter":         true,
 	})
-	return err
+	if err != nil {
+		return err
+	}
+	return fileopsError(raw)
+}
+
+// ListFileOps returns the currently active file operations
+// (GET /api/2.0/files/fileops) for status polling.
+func (c *Client) ListFileOps(ctx context.Context) ([]map[string]any, error) {
+	raw, err := c.getJSON(ctx, "/api/2.0/files/fileops")
+	if err != nil {
+		return nil, err
+	}
+	resp, err := responseField(raw, "response")
+	if err != nil {
+		return nil, err
+	}
+	if len(resp) == 0 || string(resp) == "null" {
+		return nil, nil
+	}
+	var ops []map[string]any
+	if err := json.Unmarshal(resp, &ops); err != nil {
+		return nil, err
+	}
+	return ops, nil
+}
+
+// fileopsError extracts per-operation "error" strings from a fileops/move or
+// fileops/copy envelope. A 200 with error entries means nothing moved.
+func fileopsError(raw json.RawMessage) error {
+	resp, err := responseField(raw, "response")
+	if err != nil {
+		return err
+	}
+	var ops []struct {
+		Error    *string `json:"error"`
+		Finished *bool   `json:"finished"`
+		Progress *int    `json:"progress"`
+	}
+	if err := json.Unmarshal(resp, &ops); err != nil {
+		return nil // not an operations envelope — nothing to report
+	}
+	var errs []string
+	for _, op := range ops {
+		if op.Error != nil && *op.Error != "" {
+			errs = append(errs, *op.Error)
+		}
+	}
+	if len(errs) > 0 {
+		return fmt.Errorf("onlyoffice: fileops: %s", strings.Join(errs, "; "))
+	}
+	return nil
 }
 
 // DeleteDavItems deletes the given folders and/or files.
@@ -201,34 +259,10 @@ func (c *Client) UploadDavFile(ctx context.Context, folderID, fileName string, s
 	return env.Response, nil
 }
 
-// DownloadDavFile streams the file identified by id to w, returning bytes copied.
+// DownloadDavFile streams the file identified by id to w, returning bytes
+// copied. It shares the MinIO stale-S3 fallback with DownloadFile.
 func (c *Client) DownloadDavFile(ctx context.Context, id string, w io.Writer) (int64, error) {
-	file, err := c.GetFile(ctx, id)
-	if err != nil {
-		return 0, err
-	}
-	if file.ViewURL == nil || *file.ViewURL == "" {
-		return 0, fmt.Errorf("onlyoffice: file %s has no viewUrl", id)
-	}
-	u := c.resolveAPIURL(*file.ViewURL)
-	auth, err := c.authHeader()
-	if err != nil {
-		return 0, err
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
-	if err != nil {
-		return 0, err
-	}
-	req.Header.Set("Authorization", auth)
-	resp, err := c.client.Do(req)
-	if err != nil {
-		return 0, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return 0, fmt.Errorf("onlyoffice: download: %d", resp.StatusCode)
-	}
-	return io.Copy(w, resp.Body)
+	return c.DownloadFile(ctx, id, w)
 }
 
 // --- internal helpers -------------------------------------------------------
@@ -376,12 +410,12 @@ func (f *DavFolder) UnmarshalJSON(b []byte) error {
 // UnmarshalJSON decodes a file row, capturing size and timestamps.
 func (f *DavFile) UnmarshalJSON(b []byte) error {
 	var raw struct {
-		ID        *json.Number `json:"id"`
-		Title     *string      `json:"title"`
-		PureSize  *int64       `json:"pureContentLength"`
-		SizeStr   *string      `json:"contentLength"`
-		Updated   *string      `json:"updated"`
-		ViewURL   *string      `json:"viewUrl"`
+		ID       *json.Number `json:"id"`
+		Title    *string      `json:"title"`
+		PureSize *int64       `json:"pureContentLength"`
+		SizeStr  *string      `json:"contentLength"`
+		Updated  *string      `json:"updated"`
+		ViewURL  *string      `json:"viewUrl"`
 	}
 	if err := json.Unmarshal(b, &raw); err != nil {
 		return err

go.mod

@@ -4,6 +4,7 @@ go 1.25.0
 
 require (
 	github.com/JohannesKaufmann/html-to-markdown/v2 v2.5.2
+	github.com/aws/aws-sdk-go-v2 v1.41.1
 	github.com/charmbracelet/bubbles v0.18.0
 	github.com/charmbracelet/bubbletea v0.25.0
 	github.com/charmbracelet/glamour v0.8.0
@@ -17,6 +18,7 @@ require (
 	github.com/mattn/go-runewidth v0.0.15
 	github.com/muesli/termenv v0.16.0
 	github.com/spf13/cobra v1.10.2
+	github.com/xuri/excelize/v2 v2.11.0
 	gopkg.in/yaml.v3 v3.0.1
 	modernc.org/sqlite v1.56.0
 )
@@ -25,6 +27,7 @@ require (
 	github.com/JohannesKaufmann/dom v0.3.1 // indirect
 	github.com/alecthomas/chroma/v2 v2.14.0 // indirect
 	github.com/atotto/clipboard v0.1.4 // indirect
+	github.com/aws/smithy-go v1.24.0 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/aymerick/douceur v0.2.0 // indirect
 	github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect
@@ -42,15 +45,21 @@ require (
 	github.com/muesli/reflow v0.3.0 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/richardlehane/mscfb v1.0.7 // indirect
+	github.com/richardlehane/msoleps v1.0.6 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/spf13/pflag v1.0.9 // indirect
+	github.com/tiendc/go-deepcopy v1.7.2 // indirect
+	github.com/xuri/efp v0.0.1 // indirect
+	github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 // indirect
 	github.com/yuin/goldmark v1.8.2 // indirect
 	github.com/yuin/goldmark-emoji v1.0.3 // indirect
-	golang.org/x/net v0.55.0 // indirect
+	golang.org/x/crypto v0.53.0 // indirect
+	golang.org/x/net v0.56.0 // indirect
 	golang.org/x/sync v0.21.0 // indirect
 	golang.org/x/sys v0.47.0 // indirect
-	golang.org/x/term v0.43.0 // indirect
-	golang.org/x/text v0.37.0 // indirect
+	golang.org/x/term v0.44.0 // indirect
+	golang.org/x/text v0.38.0 // indirect
 	modernc.org/libc v1.74.4 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -10,6 +10,10 @@ github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc
 github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
+github.com/aws/aws-sdk-go-v2 v1.41.1 h1:ABlyEARCDLN034NhxlRUSZr4l71mh+T5KAeGh6cerhU=
+github.com/aws/aws-sdk-go-v2 v1.41.1/go.mod h1:MayyLB8y+buD9hZqkCW3kX1AKq07Y5pXxtgB+rRFhz0=
+github.com/aws/smithy-go v1.24.0 h1:LpilSUItNPFr1eY85RYgTIg5eIEPtvFbskaFcmmIUnk=
+github.com/aws/smithy-go v1.24.0/go.mod h1:LEj2LM3rBRQJxPZTB4KuzZkaZYnZPnvgIhb4pu07mx0=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
 github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
@@ -31,6 +35,8 @@ github.com/charmbracelet/x/exp/golden v0.0.0-20240715153702-9ba8adf781c4/go.mod
 github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY=
 github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
 github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
@@ -84,6 +90,10 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/richardlehane/mscfb v1.0.7 h1:oeoiM0WE79vHwE8RpIYYvIAc8ajTH2mb6UZm55/+EB0=
+github.com/richardlehane/mscfb v1.0.7/go.mod h1:pe0+IUIc0AHh0+teNzBlJCtSyZdFOGgV4ZK9bsoV+Jo=
+github.com/richardlehane/msoleps v1.0.6 h1:9BvkpjvD+iUBalUY4esMwv6uBkfOip/Lzvd93jvR9gg=
+github.com/richardlehane/msoleps v1.0.6/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
 github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
@@ -97,25 +107,39 @@ github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
 github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tiendc/go-deepcopy v1.7.2 h1:Ut2yYR7W9tWjTQitganoIue4UGxZwCcJy3orjrrIj44=
+github.com/tiendc/go-deepcopy v1.7.2/go.mod h1:4bKjNC2r7boYOkD2IOuZpYjmlDdzjbpTRyCx+goBCJQ=
+github.com/xuri/efp v0.0.1 h1:fws5Rv3myXyYni8uwj2qKjVaRP30PdjeYe2Y6FDsCL8=
+github.com/xuri/efp v0.0.1/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI=
+github.com/xuri/excelize/v2 v2.11.0 h1:HxaEFl6sRN2+8J5a8HaKq+0M4FsjBGMnWWtjOCPSG88=
+github.com/xuri/excelize/v2 v2.11.0/go.mod h1:jxFLbzaIwGQ5ufFNvYfUOHqXhfPaNmP14KWfmNz2Uak=
+github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 h1:+C0TIdyyYmzadGaL/HBLbf3WdLgC29pgyhTjAT/0nuE=
+github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9/go.mod h1:WwHg+CVyzlv/TX9xqBFXEZAuxOPxn2k1GNHwG41IIUQ=
 github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
 github.com/yuin/goldmark v1.8.2 h1:kEGpgqJXdgbkhcOgBxkC0X0PmoPG1ZyoZ117rDVp4zE=
 github.com/yuin/goldmark v1.8.2/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
 github.com/yuin/goldmark-emoji v1.0.3 h1:aLRkLHOuBR2czCY4R8olwMjID+tENfhyFDMCRhbIQY4=
 github.com/yuin/goldmark-emoji v1.0.3/go.mod h1:tTkZEbwu5wkPmgTcitqddVxY9osFZiavD+r4AzQrh1U=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
+golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
+golang.org/x/image v0.38.0 h1:5l+q+Y9JDC7mBOMjo4/aPhMDcxEptsX+Tt3GgRQRPuE=
+golang.org/x/image v0.38.0/go.mod h1:/3f6vaXC+6CEanU4KJxbcUZyEePbyKbaLoDOe4ehFYY=
 golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
 golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
-golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8=
-golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww=
+golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
+golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
 golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
 golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
 golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4=
-golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk=
-golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
-golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
+golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc=
+golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y=
+golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
 golang.org/x/tools v0.47.0 h1:7Kn5x/d1svx/PzryTsqeoZN4TZwqeH5pGWjefhLi/1Q=
 golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=

http.go

@@ -346,6 +346,14 @@ func (c *Client) putJSON(ctx context.Context, path string, body any) (json.RawMe
 
 // uploadMultipart posts a single file to path under the given form field name.
 func (c *Client) uploadMultipart(ctx context.Context, path, fieldName, filePath string) (json.RawMessage, error) {
+	return c.uploadMultipartMethod(ctx, http.MethodPost, path, fieldName, filePath)
+}
+
+// uploadMultipartMethod sends a single-file multipart request with the given
+// HTTP method. The OnlyOffice Documents API needs PUT for /update (a new
+// version) and POST for /upload (a new file); sending POST to /update answers
+// 500 on current servers.
+func (c *Client) uploadMultipartMethod(ctx context.Context, method, path, fieldName, filePath string) (json.RawMessage, error) {
 	auth, err := c.authHeader()
 	if err != nil {
 		return nil, err
@@ -368,7 +376,7 @@ func (c *Client) uploadMultipart(ctx context.Context, path, fieldName, filePath
 	if err := mw.Close(); err != nil {
 		return nil, err
 	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL()+path, &buf)
+	req, err := http.NewRequestWithContext(ctx, method, c.baseURL()+path, &buf)
 	if err != nil {
 		return nil, err
 	}

internal/xlspipe/cutover_portugal.go

@@ -0,0 +1,393 @@
+package xlspipe
+
+import (
+	"fmt"
+
+	"github.com/xuri/excelize/v2"
+)
+
+// Sheet names (Russian tabs) for cutover Portugal workbook.
+const (
+	SheetInputs  = "Ввод"
+	SheetDom6    = "Вс 6.09"
+	SheetJue3    = "Чт 3.09"
+	SheetWedHyp  = "Ср гип"
+	SheetSummary = "Сводка"
+)
+
+// CutoverPortugalDefaults holds live FO values (2026-08-28).
+type CutoverPortugalDefaults struct {
+	FerryDom6          float64
+	FerryJue3          float64
+	FerrySuperiorDelta float64
+	HousingLow         float64
+	HousingMid         float64
+	HousingHigh        float64
+	DriveLow           float64
+	DriveMid           float64
+	DriveHigh          float64
+	BoardLow           float64
+	BoardMid           float64
+	BoardHigh          float64
+	FoodLow            float64
+	FoodMid            float64
+	FoodHigh           float64
+	SimLow             float64
+	SimMid             float64
+	SimHigh            float64
+	MonthCap           float64
+	ExtraNightsDom6    float64
+	ExtraNightsJue3    float64
+	ExtraNightsWed     float64
+}
+
+// DefaultCutoverPortugal returns FO live snapshot from portugal track (28.08.2026).
+func DefaultCutoverPortugal() CutoverPortugalDefaults {
+	return CutoverPortugalDefaults{
+		FerryDom6:          457.89,
+		FerryJue3:          484.09,
+		FerrySuperiorDelta: 19.64,
+		HousingLow:         509,
+		HousingMid:         600,
+		HousingHigh:        650,
+		DriveLow:           70,
+		DriveMid:           85,
+		DriveHigh:          100,
+		BoardLow:           40,
+		BoardMid:           60,
+		BoardHigh:          80,
+		FoodLow:            150,
+		FoodMid:            220,
+		FoodHigh:           300,
+		SimLow:             50,
+		SimMid:             100,
+		SimHigh:            150,
+		MonthCap:           2500,
+		ExtraNightsDom6:    0,
+		ExtraNightsJue3:    0,
+		ExtraNightsWed:     4,
+	}
+}
+
+type inputField struct {
+	name    string // defined name (ASCII, for formulas)
+	label   string
+	value   float64
+	note    string
+	comment string
+}
+
+// BuildCutoverPortugalWorkbook creates a multi-sheet cutover budget with Russian labels,
+// cell comments on non-obvious inputs, named ranges, and cross-sheet formulas.
+func BuildCutoverPortugalWorkbook(d CutoverPortugalDefaults) (*excelize.File, error) {
+	f := excelize.NewFile()
+	defaultSheet := f.GetSheetName(0)
+	if err := f.SetSheetName(defaultSheet, SheetInputs); err != nil {
+		f.Close()
+		return nil, err
+	}
+	for _, name := range []string{SheetDom6, SheetJue3, SheetWedHyp, SheetSummary} {
+		if _, err := f.NewSheet(name); err != nil {
+			f.Close()
+			return nil, err
+		}
+	}
+
+	if err := writeInputsSheet(f, d); err != nil {
+		f.Close()
+		return nil, err
+	}
+	scenarios := []struct {
+		sheet, ferry, extra, note string
+	}{
+		{SheetDom6, "ferry_dom6", "extra_nights_dom6", "Живой слот вс 6.09 20:30; заезд в квартиру вт 8.09"},
+		{SheetJue3, "ferry_jue3", "extra_nights_jue3", "Живой чт 3.09; T1a 05–12 если TF-крыша кончается раньше вс"},
+		{SheetWedHyp, "ferry_jue3", "extra_nights_wed", "Гипотеза: ср 2.09 20:00 по тарифу Jue3; заезд пт 4.09"},
+	}
+	for _, sc := range scenarios {
+		if err := writeScenarioSheet(f, sc.sheet, sc.ferry, sc.extra, sc.note); err != nil {
+			f.Close()
+			return nil, err
+		}
+	}
+	if err := writeSummarySheet(f); err != nil {
+		f.Close()
+		return nil, err
+	}
+	f.SetActiveSheet(0)
+	if err := finalizeWorkbook(f); err != nil {
+		f.Close()
+		return nil, err
+	}
+	return f, nil
+}
+
+func writeInputsSheet(f *excelize.File, d CutoverPortugalDefaults) error {
+	if err := setHeaders(f, SheetInputs, "Параметр", "Значение €", "Кратко"); err != nil {
+		return err
+	}
+	fields := []inputField{
+		{
+			name: "ferry_dom6", label: "Паром вс 6.09 (Básica, без residencia)",
+			value: d.FerryDom6, note: "FO live: 2взр+младенец+авто",
+			comment: "Fred Olsen Dom 6.09 20:30 SC→Huelva, прибытие Mar 8 09:00. Butaca Normal/Básica без субсидии канарского residencia (−183€). Меняйте после нового live FO.",
+		},
+		{
+			name: "ferry_jue3", label: "Паром чт 3.09 (Básica, без residencia)",
+			value: d.FerryJue3, note: "FO live Jue 3 20:00",
+			comment: "Прямой рейс 35 ч. Дороже вс на ~26€. Используется также для листа «Ср гип», если своего рейса ср 2.09 нет в продаже.",
+		},
+		{
+			name: "ferry_superior_uplift", label: "Доплата VIP / Butaca Superior",
+			value: d.FerrySuperiorDelta, note: "Superior − Normal (Jue3 live)",
+			comment: "Разница между Superior и Normal на live Jue3 ≈19,64€. На Dom6 Superior в сессии не перевыбирали — оценка по этой дельте. VIP = salón, не каюта.",
+		},
+		{
+			name: "housing_7n_low", label: "Крыша 7 ночей Setúbal — минимум",
+			value: d.HousingLow, note: "Airbnb low band",
+			comment: "Короткая аренда T1a (#11): 08–15.09, 1–2BR с парковкой. Низкая граница live Airbnb Setúbal.",
+		},
+		{
+			name: "housing_7n_mid", label: "Крыша 7 ночей Setúbal — целевой mid",
+			value: d.HousingMid, note: "Цель #11: 500–650€/нед",
+			comment: "Рабочая оценка для брони. Основной столбец mid на листах сценариев.",
+		},
+		{
+			name: "housing_7n_high", label: "Крыша 7 ночей Setúbal — максимум",
+			value: d.HousingHigh, note: "Airbnb high band",
+		},
+		{
+			name: "drive_low", label: "Проезд Huelva → Setúbal — мин",
+			value: d.DriveLow, note: "OSRM ~3,8 ч",
+			comment: "≈342 км: топливо + платные дороги. Низкая/средняя/высокая оценка.",
+		},
+		{name: "drive_mid", label: "Проезд Huelva → Setúbal — mid", value: d.DriveMid},
+		{name: "drive_high", label: "Проезд Huelva → Setúbal — макс", value: d.DriveHigh},
+		{
+			name: "board_low", label: "Еда на пароме — мин",
+			value: d.BoardLow, note: "Меню FO",
+			comment: "Питание на борту (Fred Olsen). George 0–3 обычно бесплатно как пассажир — еда отдельно.",
+		},
+		{name: "board_mid", label: "Еда на пароме — mid", value: d.BoardMid},
+		{name: "board_high", label: "Еда на пароме — макс", value: d.BoardHigh},
+		{
+			name: "food_7d_low", label: "Еда 7 дней в PT — мин",
+			value: d.FoodLow, note: "Готовим в apt",
+			comment: "Первая неделя в Setúbal после парома — продукты, не рестораны.",
+		},
+		{name: "food_7d_mid", label: "Еда 7 дней в PT — mid", value: d.FoodMid},
+		{name: "food_7d_high", label: "Еда 7 дней в PT — макс", value: d.FoodHigh},
+		{
+			name: "sim_low", label: "SIM + документы — мин",
+			value: d.SimLow, note: "Разовые cutover",
+			comment: "eSIM, копии, мелкие госпошлины при cutover. Не включает депозит аренды.",
+		},
+		{name: "sim_mid", label: "SIM + документы — mid", value: d.SimMid},
+		{name: "sim_high", label: "SIM + документы — макс", value: d.SimHigh},
+		{
+			name: "month_cap", label: "Потолок бюджета на месяц (€)",
+			value: d.MonthCap, note: "SoT: 2500€",
+			comment: "Жёсткий потолок Sep из source-of-truth. «Остаток» = потолок − итого mid сценария.",
+		},
+		{
+			name: "extra_nights_dom6", label: "Лишние ночи в PT (вс 6.09)",
+			value: d.ExtraNightsDom6, note: "0 = TF до вс",
+			comment: "Платные ночи в PT до начала 7-дневной крыши. Для Dom6 обычно 0: остаёмся на Тенерифе до вс, заезд вт 8.09.",
+		},
+		{
+			name: "extra_nights_jue3", label: "Лишние ночи в PT (чт 3.09)",
+			value: d.ExtraNightsJue3, note: "0 если TF до вс",
+			comment: "Если крыша TF кончается раньше вс — нужны ночи 05–07.09 до Airbnb. По умолчанию 0.",
+		},
+		{
+			name: "extra_nights_wed", label: "Лишние ночи в PT (ср гип)",
+			value: d.ExtraNightsWed, note: "Гип: заезд пт 4.09",
+			comment: "Гипотетический слот ср 2.09 → заезд пт 4.09 = 4 лишних ночи до типичного 7н блока. Рейса ср в FO нет — тариф как Jue3.",
+		},
+	}
+	for i, fld := range fields {
+		row := i + 2
+		if err := f.SetCellStr(SheetInputs, fmt.Sprintf("A%d", row), fld.label); err != nil {
+			return err
+		}
+		if err := defineInput(f, SheetInputs, fld.name, row, fld.value, fld.note, fld.comment); err != nil {
+			return err
+		}
+	}
+	if err := f.SetCellStr(SheetInputs, "A25", "—"); err != nil {
+		return err
+	}
+	if err := f.SetCellStr(SheetInputs, "B25", "Редактируйте жёлтые ячейки"); err != nil {
+		return err
+	}
+	if err := f.SetCellStr(SheetInputs, "C25", "Формулы на листах сценариев и «Сводка» пересчитаются в OnlyOffice"); err != nil {
+		return err
+	}
+	return styleSheet(f, SheetInputs, SheetInputs)
+}
+
+func writeScenarioSheet(f *excelize.File, sheet, ferryName, extraNightsName, scenarioNote string) error {
+	if err := setHeaders(f, sheet, "Статья", "Мин €", "Mid €", "Макс €", "Пояснение"); err != nil {
+		return err
+	}
+	if err := f.SetCellStr(sheet, "A2", "Паром Básica"); err != nil {
+		return err
+	}
+	for col, ref := range []string{ferryName, ferryName, ferryName} {
+		cell, _ := excelize.CoordinatesToCellName(col+2, 2)
+		if err := f.SetCellFormula(sheet, cell, "="+ref); err != nil {
+			return err
+		}
+	}
+	if err := addCellComment(f, sheet, "A2", "Тариф парома для этого сценария. Берётся с листа «Ввод»."); err != nil {
+		return err
+	}
+	lines := []struct {
+		label                string
+		low, mid, high, note string
+		comment              string
+	}{
+		{"Крыша 7 н Setúbal", "housing_7n_low", "housing_7n_mid", "housing_7n_high", "Airbnb T1a #11", ""},
+		{"Huelva → Setúbal", "drive_low", "drive_mid", "drive_high", "OSRM ~3,8 ч", ""},
+		{"Еда на борту", "board_low", "board_mid", "board_high", "Меню FO", ""},
+		{"Еда 7 д в PT", "food_7d_low", "food_7d_mid", "food_7d_high", "Готовим дома", ""},
+		{"SIM / документы", "sim_low", "sim_mid", "sim_high", "Cutover", ""},
+	}
+	for i, ln := range lines {
+		row := i + 3
+		if err := setFormulaRow(f, sheet, row, ln.label,
+			"="+ln.low, "="+ln.mid, "="+ln.high, ln.note); err != nil {
+			return err
+		}
+	}
+	if err := f.SetCellStr(sheet, "A8", "Итого Básica"); err != nil {
+		return err
+	}
+	for col := 2; col <= 4; col++ {
+		cell, _ := excelize.CoordinatesToCellName(col, 8)
+		colL, _ := excelize.CoordinatesToCellName(col, 2)
+		colH, _ := excelize.CoordinatesToCellName(col, 7)
+		if err := f.SetCellFormula(sheet, cell, fmt.Sprintf("=SUM(%s:%s)", colL, colH)); err != nil {
+			return err
+		}
+	}
+	if err := f.SetCellStr(sheet, "E8", "SUM строк 2–7"); err != nil {
+		return err
+	}
+	if err := setFormulaRow(f, sheet, 9, "Итого Superior",
+		"=B8+ferry_superior_uplift", "=C8+ferry_superior_uplift", "=D8+ferry_superior_uplift",
+		"Básica + VIP"); err != nil {
+		return err
+	}
+	if err := addCellComment(f, sheet, "A9", "Butaca Superior / VIP salón. Доплата с листа «Ввод»."); err != nil {
+		return err
+	}
+	if err := f.SetCellStr(sheet, "A10", "Лишние ночи PT"); err != nil {
+		return err
+	}
+	for col, housing := range []string{"housing_7n_low", "housing_7n_mid", "housing_7n_high"} {
+		cell, _ := excelize.CoordinatesToCellName(col+2, 10)
+		formula := fmt.Sprintf("=%s*%s/7", extraNightsName, housing)
+		if err := f.SetCellFormula(sheet, cell, formula); err != nil {
+			return err
+		}
+	}
+	if err := f.SetCellStr(sheet, "E10", "ночей × (крыша/7)"); err != nil {
+		return err
+	}
+	if err := addCellComment(f, sheet, "A10", "Платное жильё до начала 7-дневной брони. Число ночей — на листе «Ввод» для этого сценария."); err != nil {
+		return err
+	}
+	if err := setFormulaRow(f, sheet, 11, "Итого с ночами",
+		"=B8+B10", "=C8+C10", "=D8+D10", scenarioNote); err != nil {
+		return err
+	}
+	if err := f.SetCellStr(sheet, "A12", "Остаток от потолка"); err != nil {
+		return err
+	}
+	for _, col := range []string{"B", "C", "D"} {
+		if err := f.SetCellFormula(sheet, col+"12", "=month_cap-C11"); err != nil {
+			return err
+		}
+	}
+	if err := f.SetCellStr(sheet, "E12", "потолок − mid итого"); err != nil {
+		return err
+	}
+	if err := addCellComment(f, sheet, "C12", "Сколько остаётся от месячного потолка 2500€ после cutover (mid)."); err != nil {
+		return err
+	}
+	if err := f.SetCellStr(sheet, "A13", "Среднее по строкам"); err != nil {
+		return err
+	}
+	for col := 2; col <= 4; col++ {
+		cell, _ := excelize.CoordinatesToCellName(col, 13)
+		colL, _ := excelize.CoordinatesToCellName(col, 2)
+		colH, _ := excelize.CoordinatesToCellName(col, 7)
+		if err := f.SetCellFormula(sheet, cell, fmt.Sprintf("=AVERAGE(%s:%s)", colL, colH)); err != nil {
+			return err
+		}
+	}
+	if err := f.SetCellStr(sheet, "E13", "AVG статей 2–7"); err != nil {
+		return err
+	}
+	return styleSheet(f, sheet, SheetInputs)
+}
+
+func writeSummarySheet(f *excelize.File) error {
+	if err := setHeaders(f, SheetSummary,
+		"Сценарий", "Básica mid", "Superior mid", "Итого mid", "Остаток", "Δ vs вс"); err != nil {
+		return err
+	}
+	rows := []struct {
+		label, sheet string
+	}{
+		{"Вс 6.09 (live)", SheetDom6},
+		{"Чт 3.09 (live)", SheetJue3},
+		{"Ср 2.09 (гипотеза)", SheetWedHyp},
+	}
+	qs := quoteSheet
+	for i, r := range rows {
+		row := i + 2
+		if err := f.SetCellStr(SheetSummary, fmt.Sprintf("A%d", row), r.label); err != nil {
+			return err
+		}
+		pairs := []struct {
+			col int
+			ref string
+		}{
+			{2, fmt.Sprintf("%s!C8", qs(r.sheet))},
+			{3, fmt.Sprintf("%s!C9", qs(r.sheet))},
+			{4, fmt.Sprintf("%s!C11", qs(r.sheet))},
+			{5, fmt.Sprintf("%s!C12", qs(r.sheet))},
+		}
+		for _, p := range pairs {
+			cell, _ := excelize.CoordinatesToCellName(p.col, row)
+			if err := f.SetCellFormula(SheetSummary, cell, "="+p.ref); err != nil {
+				return err
+			}
+		}
+		cell, _ := excelize.CoordinatesToCellName(6, row)
+		if err := f.SetCellFormula(SheetSummary, cell, fmt.Sprintf("=D%d-$D$2", row)); err != nil {
+			return err
+		}
+	}
+	if err := f.SetCellStr(SheetSummary, "A6", "Потолок месяца"); err != nil {
+		return err
+	}
+	if err := f.SetCellFormula(SheetSummary, "D6", "=month_cap"); err != nil {
+		return err
+	}
+	if err := f.SetCellStr(SheetSummary, "A7", "Лучший итого mid"); err != nil {
+		return err
+	}
+	if err := f.SetCellFormula(SheetSummary, "D7", "=MIN(D2:D4)"); err != nil {
+		return err
+	}
+	if err := f.SetCellStr(SheetSummary, "E7", "MIN по сценариям"); err != nil {
+		return err
+	}
+	if err := addCellComment(f, SheetSummary, "D7", "Минимальный mid «Итого с ночами» среди трёх сценариев. Сейчас обычно вс 6.09."); err != nil {
+		return err
+	}
+	return styleSheet(f, SheetSummary, SheetInputs)
+}

internal/xlspipe/cutover_portugal_test.go

@@ -0,0 +1,68 @@
+package xlspipe
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xuri/excelize/v2"
+)
+
+func parseCalcFloat(s string) (float64, error) {
+	s = strings.ReplaceAll(s, ",", "")
+	s = strings.TrimSpace(s)
+	var val float64
+	_, err := fmt.Sscan(s, &val)
+	return val, err
+}
+
+func TestBuildCutoverPortugalWorkbook_Formulas(t *testing.T) {
+	f, err := BuildCutoverPortugalWorkbook(DefaultCutoverPortugal())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "cutover.xlsx")
+	if err := Save(f, path); err != nil {
+		t.Fatal(err)
+	}
+	st, err := os.Stat(path)
+	if err != nil || st.Size() < 4096 {
+		t.Fatalf("xlsx too small: %v", err)
+	}
+
+	opened, err := excelize.OpenFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer opened.Close()
+
+	cases := []struct {
+		sheet, cell string
+		want        float64
+		tol         float64
+	}{
+		{SheetDom6, "C8", 1522.89, 0.02},
+		{SheetJue3, "C8", 1549.09, 0.02},
+		{SheetWedHyp, "C11", 1891.95, 0.05},
+		{SheetSummary, "D2", 1522.89, 0.02},
+		{SheetSummary, "D7", 1522.89, 0.02},
+	}
+	for _, tc := range cases {
+		got, err := opened.CalcCellValue(tc.sheet, tc.cell)
+		if err != nil {
+			t.Fatalf("%s!%s calc: %v", tc.sheet, tc.cell, err)
+		}
+		val, err := parseCalcFloat(got)
+		if err != nil {
+			t.Fatalf("%s!%s parse %q: %v", tc.sheet, tc.cell, got, err)
+		}
+		if diff := val - tc.want; diff < -tc.tol || diff > tc.tol {
+			t.Fatalf("%s!%s = %v want ~%v", tc.sheet, tc.cell, val, tc.want)
+		}
+	}
+}

internal/xlspipe/template.go

@@ -0,0 +1,26 @@
+package xlspipe
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/xuri/excelize/v2"
+)
+
+// Template names for oo docs put-xlsx --template.
+const (
+	TemplateCutoverPortugal = "cutover-portugal"
+)
+
+// BuildTemplate returns an xlsx workbook for a known template name.
+func BuildTemplate(name string) (*File, error) {
+	switch strings.ToLower(strings.TrimSpace(name)) {
+	case TemplateCutoverPortugal, "portugal-cutover", "cutover":
+		return BuildCutoverPortugalWorkbook(DefaultCutoverPortugal())
+	default:
+		return nil, fmt.Errorf("unknown xlsx template %q (try: %s)", name, TemplateCutoverPortugal)
+	}
+}
+
+// File is an alias so cmd/oo can refer to excelize.File without importing excelize in every handler.
+type File = excelize.File

internal/xlspipe/xlspipe.go

@@ -0,0 +1,135 @@
+package xlspipe
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/xuri/excelize/v2"
+)
+
+const commentAuthor = "oo"
+
+// Save writes the workbook to path (creates parent dirs).
+func Save(f *excelize.File, path string) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return err
+	}
+	return f.SaveAs(path)
+}
+
+// quoteSheet returns an Excel sheet reference safe for formulas ('Name'!A1).
+func quoteSheet(name string) string {
+	return "'" + strings.ReplaceAll(name, "'", "''") + "'"
+}
+
+// defineInput registers a named range on sheet!B{row}, sets value, note, optional comment.
+func defineInput(f *excelize.File, sheet, name string, row int, value float64, note, comment string) error {
+	cell := fmt.Sprintf("B%d", row)
+	if err := f.SetCellFloat(sheet, cell, value, 2, 64); err != nil {
+		return err
+	}
+	if note != "" {
+		if err := f.SetCellStr(sheet, fmt.Sprintf("C%d", row), note); err != nil {
+			return err
+		}
+	}
+	ref := fmt.Sprintf("%s!$B$%d", quoteSheet(sheet), row)
+	if err := f.SetDefinedName(&excelize.DefinedName{Name: name, RefersTo: ref}); err != nil {
+		return err
+	}
+	if comment != "" {
+		return addCellComment(f, sheet, cell, comment)
+	}
+	return nil
+}
+
+func addCellComment(f *excelize.File, sheet, cell, text string) error {
+	return f.AddComment(sheet, excelize.Comment{
+		Cell:   cell,
+		Author: commentAuthor,
+		Text:   text,
+		Width:  280,
+		Height: 120,
+	})
+}
+
+func setHeaders(f *excelize.File, sheet string, headers ...string) error {
+	for i, h := range headers {
+		cell, err := excelize.CoordinatesToCellName(i+1, 1)
+		if err != nil {
+			return err
+		}
+		if err := f.SetCellStr(sheet, cell, h); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func setFormulaRow(f *excelize.File, sheet string, row int, label string, low, mid, high, note string) error {
+	if err := f.SetCellStr(sheet, fmt.Sprintf("A%d", row), label); err != nil {
+		return err
+	}
+	for col, formula := range []string{low, mid, high} {
+		cell, err := excelize.CoordinatesToCellName(col+2, row)
+		if err != nil {
+			return err
+		}
+		if err := f.SetCellFormula(sheet, cell, formula); err != nil {
+			return err
+		}
+	}
+	if note != "" {
+		return f.SetCellStr(sheet, fmt.Sprintf("E%d", row), note)
+	}
+	return nil
+}
+
+func styleSheet(f *excelize.File, sheet, inputsSheet string) error {
+	widths := map[string]float64{"A": 34, "B": 12, "C": 12, "D": 12, "E": 40}
+	for col, w := range widths {
+		if err := f.SetColWidth(sheet, col, col, w); err != nil {
+			return err
+		}
+	}
+	headerStyle, err := f.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true},
+		Fill:      excelize.Fill{Type: "pattern", Color: []string{"#E8F0FE"}, Pattern: 1},
+		Alignment: &excelize.Alignment{Horizontal: "center", WrapText: true},
+	})
+	if err != nil {
+		return err
+	}
+	euroStyle, err := f.NewStyle(&excelize.Style{NumFmt: 4})
+	if err != nil {
+		return err
+	}
+	inputStyle, err := f.NewStyle(&excelize.Style{
+		NumFmt: 4,
+		Fill:   excelize.Fill{Type: "pattern", Color: []string{"#FFF9E6"}, Pattern: 1},
+	})
+	if err != nil {
+		return err
+	}
+	if err := f.SetCellStyle(sheet, "A1", "E1", headerStyle); err != nil {
+		return err
+	}
+	if sheet == inputsSheet {
+		return f.SetCellStyle(sheet, "B2", "B30", inputStyle)
+	}
+	if err := f.SetCellStyle(sheet, "B2", "D20", euroStyle); err != nil {
+		return err
+	}
+	return nil
+}
+
+func finalizeWorkbook(f *excelize.File) error {
+	if err := f.SetCalcProps(&excelize.CalcPropsOptions{FullCalcOnLoad: boolPtr(true)}); err != nil {
+		return err
+	}
+	return f.UpdateLinkedValue()
+}
+
+func boolPtr(v bool) *bool { return &v }

mailsync.go

@@ -0,0 +1,175 @@
+package onlyoffice
+
+// High-level mail folder walk for ETL consumers (2dph brain mail-ingest,
+// cv tools). This is the "integration layer" half of reusing the canonical
+// client instead of private per-project OOClient copies: the caller gets a
+// single hydrated stream instead of hand-rolling list → get → download
+// against the raw API.
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"time"
+)
+
+// MailSyncAttachment is one attachment of a hydrated mail message.
+type MailSyncAttachment struct {
+	ID   string // id accepted by Client.DownloadMailAttachment
+	Name string
+	Size int64
+	Body []byte // non-nil only when MailSyncOptions.FetchBodies is set
+}
+
+// MailSyncMessage is a hydrated mail message for sync pipelines.
+type MailSyncMessage struct {
+	ID             int64
+	Folder         int
+	Subject        string
+	From           string // raw RFC 5322 header value ("Name" <addr>)
+	Date           time.Time
+	IsNew          bool
+	HasAttachments bool
+	Attachments    []MailSyncAttachment
+}
+
+// MailSyncOptions controls FetchMailFolder.
+type MailSyncOptions struct {
+	Limit       int  // max messages to hydrate; 0 = whole folder
+	StartIndex  int  // skip this many messages before collecting
+	FetchBodies bool // eagerly download attachment bytes
+}
+
+// FetchMailFolder walks a mail folder page by page and hydrates every
+// message: list → get → (optionally) download attachments. It is the single
+// entry point sync pipelines need on top of the mail API.
+//
+// Messages are returned in API order (newest first). The folder walk stops
+// at the first empty or short page.
+func (c *Client) FetchMailFolder(ctx context.Context, folderID int, opts MailSyncOptions) ([]MailSyncMessage, error) {
+	if folderID <= 0 {
+		folderID = MailFolderInbox
+	}
+	var out []MailSyncMessage
+	skipped := 0
+	for page := 1; ; page++ {
+		batch, err := c.ResponseArray(ctx,
+			mailMessagesPath(MailMessagesFilter{Folder: folderID}, page, mailMessagesPageSize))
+		if err != nil {
+			return nil, fmt.Errorf("FetchMailFolder: %w", err)
+		}
+		if len(batch) == 0 {
+			break
+		}
+		for _, raw := range batch {
+			if skipped < opts.StartIndex {
+				skipped++
+				continue
+			}
+			msg, err := c.hydrateMailMessage(ctx, raw, opts)
+			if err != nil {
+				return nil, err
+			}
+			out = append(out, *msg)
+			if opts.Limit > 0 && len(out) >= opts.Limit {
+				return out, nil
+			}
+		}
+		if len(batch) < mailMessagesPageSize {
+			break
+		}
+	}
+	return out, nil
+}
+
+// hydrateMailMessage converts one raw API message into a MailSyncMessage,
+// fetching the full record when the list item does not carry the attachment
+// metadata, and downloading bodies when requested.
+func (c *Client) hydrateMailMessage(ctx context.Context, m map[string]any, opts MailSyncOptions) (*MailSyncMessage, error) {
+	msg := &MailSyncMessage{
+		ID:      Int64FromMap(m, "id"),
+		Folder:  int(Int64FromMap(m, "folder")),
+		Subject: stringFromMap(m, "subject"),
+		From:    stringFromMap(m, "from"),
+		IsNew:   boolFromMap(m, "isNew") == "true",
+	}
+	msg.Date = parseMailTime(stringFromMap(m, "date"))
+
+	atts, _ := m["attachments"].([]any)
+	hasFlag := boolFromMap(m, "hasAttachments") == "true"
+	if hasFlag && len(atts) == 0 {
+		// List items may omit the attachment array; pull the full record.
+		full, err := c.GetMailMessage(ctx, strconv.FormatInt(msg.ID, 10))
+		if err != nil {
+			return nil, fmt.Errorf("FetchMailFolder: hydrate message %d: %w", msg.ID, err)
+		}
+		atts, _ = full["attachments"].([]any)
+	}
+	for _, a := range atts {
+		am, ok := a.(map[string]any)
+		if !ok {
+			continue
+		}
+		att := MailSyncAttachment{
+			ID:   mailAttachmentID(am),
+			Name: stringFromMap(am, "fileName"),
+			Size: Int64FromMap(am, "size"),
+		}
+		if att.Name == "" {
+			att.Name = stringFromMap(am, "name")
+		}
+		if att.ID != "" {
+			msg.Attachments = append(msg.Attachments, att)
+		}
+	}
+	msg.HasAttachments = hasFlag || len(msg.Attachments) > 0
+
+	if opts.FetchBodies {
+		for i := range msg.Attachments {
+			body, err := c.DownloadMailAttachment(ctx, msg.Attachments[i].ID)
+			if err != nil {
+				return nil, fmt.Errorf("FetchMailFolder: message %d attachment %q: %w",
+					msg.ID, msg.Attachments[i].Name, err)
+			}
+			msg.Attachments[i].Body = body
+		}
+	}
+	return msg, nil
+}
+
+// mailAttachmentID extracts the download id from an attachment object.
+// OnlyOffice variants use "id", "fileId" or "attachmentId".
+func mailAttachmentID(am map[string]any) string {
+	for _, key := range []string{"id", "fileId", "attachmentId"} {
+		switch v := am[key].(type) {
+		case string:
+			if s := v; s != "" {
+				return s
+			}
+		case float64:
+			if n := int64(v); n != 0 {
+				return strconv.FormatInt(n, 10)
+			}
+		case int64:
+			if v != 0 {
+				return strconv.FormatInt(v, 10)
+			}
+		}
+	}
+	return ""
+}
+
+// parseMailTime accepts the OnlyOffice timestamp shapes seen in the wild:
+// RFC3339 (with any fractional digits) and second-precision local form.
+func parseMailTime(s string) time.Time {
+	if s == "" {
+		return time.Time{}
+	}
+	if t, err := time.Parse(time.RFC3339, s); err == nil {
+		return t
+	}
+	if t, err := time.Parse("2006-01-02T15:04:05", s); err == nil {
+		return t
+	}
+	return time.Time{}
+}

mailsync_test.go

@@ -0,0 +1,137 @@
+package onlyoffice
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+// mailsSyncMock serves a two-page inbox: page 1 has two list items (one
+// reporting hasAttachments but omitting the attachment array, forcing the
+// full-record fetch), page 2 is empty. The full record for message 102
+// carries one attachment whose body is served by download.ashx.
+func newMailSyncTestServer(t *testing.T, msgsPage1 string) *httptest.Server {
+	t.Helper()
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/api/2.0/authentication.json":
+			http.SetCookie(w, &http.Cookie{Name: "sessionid", Value: "abc", Path: "/"})
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"response":{"token":"tok","expires":"2099-01-01T00:00:00.0000000+00:00"}}`))
+
+		case r.URL.Path == "/api/2.0/mail/messages":
+			w.Header().Set("Content-Type", "application/json")
+			if r.URL.Query().Get("page") > "1" {
+				_, _ = w.Write([]byte(`{"response":[]}`))
+				return
+			}
+			_, _ = w.Write([]byte(`{"response":[` + msgsPage1 + `]}`))
+
+		case r.URL.Path == "/api/2.0/mail/messages/102":
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"response":{
+				"id":102,"subject":"Full record","from":"\"A\" <a@b.com>",
+				"date":"2026-08-22T10:15:00+02:00","folder":1,"isNew":false,
+				"hasAttachments":true,
+				"attachments":[{"id":77,"fileName":"report.pdf","size":3}]}}`))
+
+		case r.URL.Path == "/addons/mail/httphandlers/download.ashx":
+			if r.Header.Get("Cookie") == "" {
+				http.Error(w, "missing cookie", http.StatusUnauthorized)
+				return
+			}
+			_, _ = w.Write([]byte("PDF!"))
+
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+}
+
+func TestFetchMailFolderHydratesAndDownloads(t *testing.T) {
+	page1 := `
+		{"id":101,"subject":"Plain","from":"x@y.z","date":"2026-08-21T09:00:00Z",
+		 "folder":1,"isNew":true,"hasAttachments":false},
+		{"id":102,"subject":"With attachment (list item)","from":"a@b.com",
+		 "date":"2026-08-22T10:15:00+02:00","folder":1,"isNew":false,
+		 "hasAttachments":true}
+	`
+	srv := newMailSyncTestServer(t, page1)
+	defer srv.Close()
+
+	c := NewClient(Credentials{Url: srv.URL, User: "u", Password: "p"})
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	msgs, err := c.FetchMailFolder(ctx, MailFolderInbox, MailSyncOptions{FetchBodies: true})
+	if err != nil {
+		t.Fatalf("FetchMailFolder: %v", err)
+	}
+	if len(msgs) != 2 {
+		t.Fatalf("got %d messages, want 2", len(msgs))
+	}
+
+	first := msgs[0]
+	if first.ID != 101 || first.Subject != "Plain" || !first.IsNew {
+		t.Fatalf("first = %+v", first)
+	}
+	if first.Date.IsZero() || first.Date.Year() != 2026 {
+		t.Fatalf("first date = %v", first.Date)
+	}
+	if first.HasAttachments {
+		t.Fatalf("first should have no attachments")
+	}
+
+	second := msgs[1]
+	if !second.HasAttachments || len(second.Attachments) != 1 {
+		t.Fatalf("second attachments = %+v", second.Attachments)
+	}
+	att := second.Attachments[0]
+	if att.ID != "77" || att.Name != "report.pdf" || att.Size != 3 || string(att.Body) != "PDF!" {
+		t.Fatalf("attachment = %+v", att)
+	}
+	if second.Date.Location() == time.UTC && second.Date.Hour() != 8 {
+		t.Fatalf("second date = %v (want +02:00 offset preserved)", second.Date)
+	}
+}
+
+func TestFetchMailFolderLimitAndStartIndex(t *testing.T) {
+	var items []string
+	for i := 1; i <= 5; i++ {
+		items = append(items, `{"id":`+string(rune('0'+i))+`,"subject":"m`+string(rune('0'+i))+`",
+			"from":"x@y.z","date":"2026-08-20T00:00:00Z","folder":1}`)
+	}
+	srv := newMailSyncTestServer(t, strings.Join(items, ","))
+	defer srv.Close()
+
+	c := NewClient(Credentials{Url: srv.URL, User: "u", Password: "p"})
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	got, err := c.FetchMailFolder(ctx, MailFolderInbox, MailSyncOptions{StartIndex: 1, Limit: 2})
+	if err != nil {
+		t.Fatalf("FetchMailFolder: %v", err)
+	}
+	if len(got) != 2 {
+		t.Fatalf("got %d messages, want 2", len(got))
+	}
+	if got[0].ID != 2 || got[1].ID != 3 {
+		t.Fatalf("ids = %d,%d want 2,3", got[0].ID, got[1].ID)
+	}
+}
+
+func TestParseMailTime(t *testing.T) {
+	fractions := "2026-08-22T10:15:00.1234567+02:00"
+	if parseMailTime(fractions).IsZero() {
+		t.Fatalf("RFC3339 with 7-digit fraction failed: %q", fractions)
+	}
+	if parseMailTime("2026-08-22T10:15:00").IsZero() {
+		t.Fatal("second-precision form failed")
+	}
+	if !parseMailTime("").IsZero() || !parseMailTime("garbage").IsZero() {
+		t.Fatal("unparseable input must yield zero time")
+	}
+}

retry.go

@@ -0,0 +1,60 @@
+package onlyoffice
+
+import (
+	"context"
+	"regexp"
+	"time"
+)
+
+// RetryPolicy controls deterministic retries against OnlyOffice: fixed linear
+// backoff without jitter, so repeated runs wait exactly the same schedule.
+// OnlyOffice throttles bulk reads/writes with 429 (and occasional 502/503/504
+// from openresty), so every bulk tool routes API calls through DoRetry.
+type RetryPolicy struct {
+	Attempts int           // total attempts, including the first try
+	Base     time.Duration // wait before retry N is N*Base
+	Max      time.Duration // per-wait cap
+}
+
+// DefaultRetryPolicy retries up to 5 times with 1s, 2s, 3s, 4s waits.
+func DefaultRetryPolicy() RetryPolicy {
+	return RetryPolicy{Attempts: 5, Base: time.Second, Max: 30 * time.Second}
+}
+
+var transientRe = regexp.MustCompile(`:\s*(429|502|503|504)\b`)
+
+// Transient reports whether err looks like a transient OnlyOffice answer
+// (an HTTP 429/502/503/504 surfaced as "...: <code> ...").
+func Transient(err error) bool {
+	if err == nil {
+		return false
+	}
+	return transientRe.MatchString(err.Error())
+}
+
+// DoRetry runs fn until it succeeds, fails non-transiently, or attempts run
+// out. Waits are deterministic: N*Base capped at Max, no jitter.
+func DoRetry(ctx context.Context, p RetryPolicy, fn func() error) error {
+	if p.Attempts < 1 {
+		p.Attempts = 1
+	}
+	var err error
+	for attempt := 1; attempt <= p.Attempts; attempt++ {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		if err = fn(); err == nil || !Transient(err) || attempt == p.Attempts {
+			return err
+		}
+		wait := time.Duration(attempt) * p.Base
+		if wait > p.Max {
+			wait = p.Max
+		}
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(wait):
+		}
+	}
+	return err
+}

storage_fallback.go

@@ -0,0 +1,200 @@
+package onlyoffice
+
+// MinIO download fallback for the portal's stale AWS S3 consumer.
+//
+// On the Fibu EDL portal some older Documents files live in S3/MinIO, but the
+// portal's storage consumer still points at s3.us-east-1.amazonaws.com with
+// access key "minio". Downloads of those files answer 403 InvalidAccessKeyId.
+// The bytes are present in the local MinIO store under a deterministic object
+// key, so the client retries the GET there.
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
+)
+
+const (
+	defaultMinioEndpoint = "http://192.168.188.10:9000"
+	defaultMinioBucket   = "office"
+	minioRegion          = "us-east-1"
+)
+
+// minioObjectKey is the fallback object key layout the portal's S3 consumer
+// writes for Documents files: 00/00/01/files/folder_<folderId>/file_<fileId>/v1/content.pdf.
+// Prefer minioObjectKeyFromURL: the portal stores all files below its storage
+// root folder, which is not the API folderId returned by GetFile.
+func minioObjectKey(fileID, folderID string) string {
+	return "00/00/01/files/folder_" + folderID + "/file_" + fileID + "/v1/content.pdf"
+}
+
+// minioObjectKeyFromURL extracts the object key from an S3 download URL. Path
+// style URLs (bucket as first path segment) have that segment removed; virtual
+// host style URLs are returned as-is. This is authoritative: the portal signs
+// the exact key, so no folder-id guessing is needed.
+func minioObjectKeyFromURL(rawURL, bucket string) (string, bool) {
+	u, err := url.Parse(strings.TrimSpace(rawURL))
+	if err != nil || u.Path == "" {
+		return "", false
+	}
+	segs := strings.Split(strings.Trim(u.Path, "/"), "/")
+	// Path-style URLs carry the bucket as leading segment; the portal's S3
+	// consumer can emit it twice (serviceurl already includes the bucket), so
+	// strip every leading segment equal to the bucket.
+	for len(segs) > 0 && bucket != "" && segs[0] == bucket {
+		segs = segs[1:]
+	}
+	if len(segs) == 0 {
+		return "", false
+	}
+	for _, s := range segs {
+		if s == "" || s == "." || s == ".." {
+			return "", false
+		}
+	}
+	return strings.Join(segs, "/"), true
+}
+
+// isStaleS3Redirect reports whether a download landed on the portal's stale AWS
+// S3 consumer. Such responses either carry an S3 InvalidAccessKeyId XML body or
+// point at amazonaws.com with the "minio" access key id in the query.
+func isStaleS3Redirect(rawURL string, body []byte) bool {
+	if strings.Contains(strings.ToLower(string(body)), "invalidaccesskeyid") {
+		return true
+	}
+	u, err := url.Parse(strings.TrimSpace(rawURL))
+	if err != nil || u.Host == "" {
+		return false
+	}
+	host := strings.ToLower(u.Host)
+	if !strings.Contains(host, "amazonaws.com") {
+		return false
+	}
+	q := strings.ToLower(u.RawQuery)
+	return strings.Contains(q, "accesskeyid=minio") || strings.Contains(q, "x-amz-credential=minio")
+}
+
+// minioConfig is the runtime configuration for the local MinIO fallback.
+type minioConfig struct {
+	Endpoint  string
+	Bucket    string
+	AccessKey string
+	SecretKey string
+}
+
+// loadMinioConfig reads the fallback configuration from the environment.
+// Secrets are never defaulted; without access/secret keys the fallback is off.
+func loadMinioConfig() minioConfig {
+	return minioConfig{
+		Endpoint:  strings.TrimRight(firstNonEmpty(os.Getenv("MINIO_ENDPOINT"), defaultMinioEndpoint), "/"),
+		Bucket:    firstNonEmpty(os.Getenv("MINIO_BUCKET"), defaultMinioBucket),
+		AccessKey: os.Getenv("MINIO_ACCESS_KEY"),
+		SecretKey: os.Getenv("MINIO_SECRET_KEY"),
+	}
+}
+
+// downloadFileEntry downloads f's bytes to dst. It transparently falls back to
+// the local MinIO store when the portal redirects the download to its stale AWS
+// S3 consumer.
+func (c *Client) downloadFileEntry(ctx context.Context, f *FileEntry, dst io.Writer) (int64, error) {
+	if f == nil {
+		return 0, fmt.Errorf("onlyoffice: download: nil file entry")
+	}
+	if f.ViewURL == nil || *f.ViewURL == "" {
+		return 0, fmt.Errorf("onlyoffice: file has no viewUrl")
+	}
+	downloadURL := c.resolveAPIURL(*f.ViewURL)
+	auth, err := c.authHeader()
+	if err != nil {
+		return 0, err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	if err != nil {
+		return 0, err
+	}
+	req.Header.Set("Authorization", auth)
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return 0, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		b, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+		finalURL := downloadURL
+		if resp.Request != nil && resp.Request.URL != nil {
+			finalURL = resp.Request.URL.String()
+		}
+		if isStaleS3Redirect(finalURL, b) {
+			key, ok := minioObjectKeyFromURL(finalURL, loadMinioConfig().Bucket)
+			if !ok {
+				fileID := ""
+				if f.ID != nil {
+					fileID = f.ID.String()
+				}
+				key = minioObjectKey(fileID, FileFolderID(f))
+			}
+			n, merr := c.downloadFromMinio(ctx, key, dst)
+			if merr == nil {
+				return n, nil
+			}
+			return 0, fmt.Errorf("GET viewUrl: %d (stale S3) and minio fallback: %w", resp.StatusCode, merr)
+		}
+		return 0, fmt.Errorf("GET viewUrl: %d %s", resp.StatusCode, truncate(string(b), 400))
+	}
+	return io.Copy(dst, resp.Body)
+}
+
+// downloadFromMinio streams objectKey from the configured MinIO bucket.
+func (c *Client) downloadFromMinio(ctx context.Context, objectKey string, dst io.Writer) (int64, error) {
+	if objectKey == "" {
+		return 0, fmt.Errorf("onlyoffice: minio fallback: empty object key")
+	}
+	cfg := loadMinioConfig()
+	if cfg.AccessKey == "" || cfg.SecretKey == "" {
+		return 0, fmt.Errorf("onlyoffice: minio fallback: MINIO_ACCESS_KEY/MINIO_SECRET_KEY not set")
+	}
+	base, err := url.Parse(cfg.Endpoint)
+	if err != nil || base.Host == "" {
+		return 0, fmt.Errorf("onlyoffice: minio fallback: bad MINIO_ENDPOINT %q", cfg.Endpoint)
+	}
+	u := *base
+	u.Path = "/" + cfg.Bucket + "/" + objectKey
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
+	if err != nil {
+		return 0, err
+	}
+	if err := signMinioRequest(ctx, cfg, req); err != nil {
+		return 0, err
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return 0, fmt.Errorf("onlyoffice: minio fallback: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= 400 {
+		b, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
+		return 0, fmt.Errorf("onlyoffice: minio fallback: %d %s", resp.StatusCode, truncate(string(b), 300))
+	}
+	return io.Copy(dst, resp.Body)
+}
+
+// signMinioRequest signs req with AWS Signature V4 for the S3 service.
+func signMinioRequest(ctx context.Context, cfg minioConfig, req *http.Request) error {
+	sum := sha256.Sum256(nil)
+	creds := aws.Credentials{AccessKeyID: cfg.AccessKey, SecretAccessKey: cfg.SecretKey}
+	if err := v4.NewSigner().SignHTTP(ctx, creds, req, hex.EncodeToString(sum[:]), "s3", minioRegion, time.Now()); err != nil {
+		return fmt.Errorf("onlyoffice: minio fallback: sign: %w", err)
+	}
+	return nil
+}

storage_fallback_integration_test.go

@@ -0,0 +1,45 @@
+//go:build integration
+
+package onlyoffice
+
+import (
+	"context"
+	"io"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestIntegrationMinioFallback downloads known stale-S3 files through the local
+// MinIO fallback. Requires ONLYOFFICE_URL/USER/PASS (as all integration tests),
+// MINIO_ACCESS_KEY/MINIO_SECRET_KEY and MINIO_TEST_FILE_IDS="3785,3859,3666";
+// skips when any of those are missing.
+func TestIntegrationMinioFallback(t *testing.T) {
+	if os.Getenv("MINIO_ACCESS_KEY") == "" || os.Getenv("MINIO_SECRET_KEY") == "" {
+		t.Skip("MINIO_ACCESS_KEY/MINIO_SECRET_KEY not set — skipping integration test")
+	}
+	raw := strings.TrimSpace(os.Getenv("MINIO_TEST_FILE_IDS"))
+	if raw == "" {
+		t.Skip("MINIO_TEST_FILE_IDS not set — skipping integration test")
+	}
+	c := liveClient(t)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	for _, id := range strings.Split(raw, ",") {
+		id = strings.TrimSpace(id)
+		if id == "" {
+			continue
+		}
+		n, err := c.DownloadFile(ctx, id, io.Discard)
+		if err != nil {
+			t.Errorf("DownloadFile(%s): %v", id, err)
+			continue
+		}
+		if n == 0 {
+			t.Errorf("DownloadFile(%s): 0 bytes", id)
+		} else {
+			t.Logf("DownloadFile(%s): %d bytes", id, n)
+		}
+	}
+}

storage_fallback_test.go

@@ -0,0 +1,219 @@
+package onlyoffice
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestMinioObjectKey(t *testing.T) {
+	cases := []struct {
+		fileID   string
+		folderID string
+		want     string
+	}{
+		{"3785", "652", "00/00/01/files/folder_652/file_3785/v1/content.pdf"},
+		{"1", "2", "00/00/01/files/folder_2/file_1/v1/content.pdf"},
+		{"3666", "4000", "00/00/01/files/folder_4000/file_3666/v1/content.pdf"},
+	}
+	for _, tc := range cases {
+		if got := minioObjectKey(tc.fileID, tc.folderID); got != tc.want {
+			t.Errorf("minioObjectKey(%q, %q) = %q, want %q", tc.fileID, tc.folderID, got, tc.want)
+		}
+	}
+}
+
+func TestMinioObjectKeyFromURL(t *testing.T) {
+	cases := []struct {
+		name   string
+		url    string
+		bucket string
+		want   string
+		ok     bool
+	}{
+		{
+			name:   "path style drops bucket segment",
+			url:    "https://s3.us-east-1.amazonaws.com/office/00/00/01/files/folder_4000/file_3785/v1/content.pdf?AWSAccessKeyId=minio",
+			bucket: "office",
+			want:   "00/00/01/files/folder_4000/file_3785/v1/content.pdf",
+			ok:     true,
+		},
+		{
+			name:   "doubled bucket segment (portal serviceurl includes bucket)",
+			url:    "https://s3.us-east-1.amazonaws.com/office/office/00/00/01/files/folder_4000/file_3785/v1/content.pdf?AWSAccessKeyId=minio",
+			bucket: "office",
+			want:   "00/00/01/files/folder_4000/file_3785/v1/content.pdf",
+			ok:     true,
+		},
+		{
+			name:   "virtual host style keeps path",
+			url:    "https://office.s3.us-east-1.amazonaws.com/00/00/01/files/folder_4000/file_3785/v1/content.pdf",
+			bucket: "office",
+			want:   "00/00/01/files/folder_4000/file_3785/v1/content.pdf",
+			ok:     true,
+		},
+		{
+			name:   "foreign first segment kept",
+			url:    "https://example.com/other/file_1/v1/content.pdf",
+			bucket: "office",
+			want:   "other/file_1/v1/content.pdf",
+			ok:     true,
+		},
+		{name: "empty path", url: "https://example.com", bucket: "office", ok: false},
+		{name: "traversal", url: "https://example.com/office/../etc/passwd", bucket: "office", ok: false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got, ok := minioObjectKeyFromURL(tc.url, tc.bucket)
+			if ok != tc.ok || got != tc.want {
+				t.Errorf("minioObjectKeyFromURL(%q, %q) = (%q, %v), want (%q, %v)", tc.url, tc.bucket, got, ok, tc.want, tc.ok)
+			}
+		})
+	}
+}
+
+func TestIsStaleS3Redirect(t *testing.T) {
+	cases := []struct {
+		name string
+		url  string
+		body []byte
+		want bool
+	}{
+		{
+			name: "aws redirect with minio access key",
+			url:  "https://s3.us-east-1.amazonaws.com/office/x/file_1?AWSAccessKeyId=minio&Expires=1",
+			want: true,
+		},
+		{
+			name: "aws redirect with minio x-amz-credential",
+			url:  "https://office.s3.us-east-1.amazonaws.com/00/00/01/files/folder_1/file_1?X-Amz-Credential=minio%2F20260914",
+			want: true,
+		},
+		{
+			name: "invalid access key xml body",
+			url:  "https://portal.internal/download/1",
+			body: []byte(`<?xml version="1.0"?><Error><Code>InvalidAccessKeyId</Code><AWSAccessKeyId>minio</AWSAccessKeyId></Error>`),
+			want: true,
+		},
+		{
+			name: "regular pdf from portal",
+			url:  "https://portal.internal/download/1",
+			body: []byte("%PDF-1.7 data"),
+			want: false,
+		},
+		{
+			name: "aws redirect with foreign key",
+			url:  "https://s3.us-east-1.amazonaws.com/office/x?AWSAccessKeyId=other",
+			want: false,
+		},
+		{
+			name: "amazonaws in path but foreign host",
+			url:  "https://example.com/amazonaws.com/file?AWSAccessKeyId=minio",
+			want: false,
+		},
+		{
+			name: "empty",
+			want: false,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := isStaleS3Redirect(tc.url, tc.body); got != tc.want {
+				t.Errorf("isStaleS3Redirect(%q, %q) = %v, want %v", tc.url, tc.body, got, tc.want)
+			}
+		})
+	}
+}
+
+const staleS3Body = `<?xml version="1.0" encoding="UTF-8"?>` +
+	`<Error><Code>InvalidAccessKeyId</Code>` +
+	`<Message>The AWS Access Key Id you provided does not exist in our records.</Message>` +
+	`<AWSAccessKeyId>minio</AWSAccessKeyId></Error>`
+
+func TestDownloadFileMinioFallback(t *testing.T) {
+	const payload = "PDFDATA-3785"
+
+	portal := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/2.0/files/file/3785.json":
+			w.Header().Set("Content-Type", "application/json")
+			io.WriteString(w, `{"response":{"id":3785,"title":"04.pdf","folderId":655,"viewUrl":"/download/3785"}}`)
+		case "/download/3785":
+			http.Redirect(w, r, "/office/00/00/01/files/folder_4000/file_3785/v1/content.pdf?AWSAccessKeyId=minio", http.StatusTemporaryRedirect)
+		case "/office/00/00/01/files/folder_4000/file_3785/v1/content.pdf":
+			w.WriteHeader(http.StatusForbidden)
+			io.WriteString(w, staleS3Body)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer portal.Close()
+
+	var minioPath, minioAuth string
+	minio := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		minioPath, minioAuth = r.URL.Path, r.Header.Get("Authorization")
+		io.WriteString(w, payload)
+	}))
+	defer minio.Close()
+
+	t.Setenv("MINIO_ENDPOINT", minio.URL)
+	t.Setenv("MINIO_BUCKET", "office")
+	t.Setenv("MINIO_ACCESS_KEY", "testkey")
+	t.Setenv("MINIO_SECRET_KEY", "testsecret")
+
+	c := &Client{
+		client:      portal.Client(),
+		credentials: &Credentials{Url: portal.URL},
+		token:       &Token{Value: "Bearer test", Expires: Time(time.Now().Add(time.Hour))},
+	}
+
+	var buf bytes.Buffer
+	n, err := c.DownloadFile(context.Background(), "3785", &buf)
+	if err != nil {
+		t.Fatalf("DownloadFile: %v", err)
+	}
+	if n != int64(len(payload)) || buf.String() != payload {
+		t.Fatalf("got %d bytes %q, want %d bytes %q", n, buf.String(), len(payload), payload)
+	}
+	if want := "/office/00/00/01/files/folder_4000/file_3785/v1/content.pdf"; minioPath != want {
+		t.Errorf("minio path = %q, want %q", minioPath, want)
+	}
+	if !strings.HasPrefix(minioAuth, "AWS4-HMAC-SHA256") {
+		t.Errorf("minio request not SigV4-signed; Authorization=%q", minioAuth)
+	}
+}
+
+func TestDownloadFileMinioFallbackWithoutCreds(t *testing.T) {
+	portal := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/2.0/files/file/3785.json":
+			io.WriteString(w, `{"response":{"id":3785,"folderId":652,"viewUrl":"/download/3785"}}`)
+		default:
+			w.WriteHeader(http.StatusForbidden)
+			io.WriteString(w, staleS3Body)
+		}
+	}))
+	defer portal.Close()
+
+	t.Setenv("MINIO_ACCESS_KEY", "")
+	t.Setenv("MINIO_SECRET_KEY", "")
+
+	c := &Client{
+		client:      portal.Client(),
+		credentials: &Credentials{Url: portal.URL},
+		token:       &Token{Value: "Bearer test", Expires: Time(time.Now().Add(time.Hour))},
+	}
+
+	_, err := c.DownloadFile(context.Background(), "3785", io.Discard)
+	if err == nil {
+		t.Fatal("expected error without minio credentials")
+	}
+	if !strings.Contains(err.Error(), "MINIO_ACCESS_KEY/MINIO_SECRET_KEY not set") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}