jaz-clio 4.34.4 → 4.34.6

package/assets/skills/api/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: jaz-api
-version: 4.34.4
+version: 4.34.6
 description: >-
   Use this skill whenever you call, debug, or review code that touches the Jaz
   REST API. Covers field names, response shapes, 117 production gotchas, error
@@ -150,7 +150,8 @@ You are working with the **Jaz REST API** — the accounting platform backend. A
 ### Jaz Magic — Extraction & Autofill
 57. **When the user starts from an attachment, always use Jaz Magic** — if the input is a PDF, JPG, or any document image (invoice, bill, receipt), the correct path is `POST /magic/createBusinessTransactionFromAttachment`. Do NOT manually construct a `POST /invoices` or `POST /bills` payload from an attachment — Jaz Magic handles the entire extraction-and-autofill pipeline server-side: OCR, line item detection, contact matching, CoA auto-mapping via ML learning, and draft creation with all fields pre-filled. Only use `POST /invoices` or `POST /bills` when building transactions from structured data (JSON, CSV, database rows) where the fields are already known.
 58. **Two upload modes with different content types** — `sourceType: "FILE"` requires **multipart/form-data** with `sourceFile` blob (JSON body fails with 400 "sourceFile is a required field"). `sourceType: "URL"` accepts **application/json** with `sourceURL` string. The OAS only documents URL mode — FILE mode (the common case) is undocumented.
-59. **Three required fields**: `sourceFile` (multipart blob — NOT `file`), `businessTransactionType` (`"INVOICE"`, `"BILL"`, `"CUSTOMER_CREDIT_NOTE"`, or `"SUPPLIER_CREDIT_NOTE"` — `EXPENSE` rejected), `sourceType` (`"FILE"` or `"URL"`). All three are validated server-side. **CRITICAL: multipart form field names are camelCase** — `businessTransactionType`, `sourceType`, `sourceFile`, NOT snake_case. Using `business_transaction_type` returns 422 "businessTransactionType is a required field". The File blob must include a filename and correct MIME type (e.g. `application/pdf`, `image/jpeg`) — bare `application/octet-stream` blobs are rejected with 400 "Invalid file type".
+59. **Three required fields + one optional**: `sourceFile` (multipart blob — NOT `file`), `businessTransactionType` (`"INVOICE"`, `"BILL"`, `"CUSTOMER_CREDIT_NOTE"`, or `"SUPPLIER_CREDIT_NOTE"` — `EXPENSE` rejected), `sourceType` (`"FILE"` or `"URL"`). Optional: `uploadMode` (`"SEPARATE"` default, or `"MERGED"` for a single PDF containing multiple documents — the backend splits it via boundary detection before extraction). All required fields are validated server-side. **CRITICAL: multipart form field names are camelCase** — `businessTransactionType`, `sourceType`, `sourceFile`, `uploadMode`, NOT snake_case. Using `business_transaction_type` returns 422 "businessTransactionType is a required field". The File blob must include a filename and correct MIME type (e.g. `application/pdf`, `image/jpeg`) — bare `application/octet-stream` blobs are rejected with 400 "Invalid file type".
+59a. **MERGED upload workflow tracking** — When `uploadMode: "MERGED"`, the upload response `workflowResourceId` is a **parent** tracking ID. The backend splits the PDF, then creates **child** workflows for each split page — these child IDs appear in `POST /magic/workflows/search` (by fileName or createdAt), NOT the parent ID. To track MERGED progress, search by `fileName` rather than the parent `workflowResourceId`.
 60. **Response maps transaction types**: Request `INVOICE` → response `SALE`. Request `BILL` → response `PURCHASE`. Request `CUSTOMER_CREDIT_NOTE` → response `SALE_CREDIT_NOTE`. Request `SUPPLIER_CREDIT_NOTE` → response `PURCHASE_CREDIT_NOTE`. S3 paths follow the response type. The response `validFiles[]` array contains `workflowResourceId` for tracking extraction progress via `POST /magic/workflows/search`.
 61. **Extraction is asynchronous** — the API response is immediate (file upload confirmation only). The actual Magic pipeline — OCR, line item extraction, contact matching, CoA learning, and autofill — runs asynchronously. Use `POST /magic/workflows/search` with `filter.resourceId.eq: "<workflowResourceId>"` to check status (SUBMITTED → PROCESSING → COMPLETED/FAILED). When COMPLETED, `businessTransactionDetails.businessTransactionResourceId` contains the created draft BT ID. The `subscriptionFBPath` in the response is a Firebase Realtime Database path for real-time status updates (alternative to polling).
 62. **Accepts PDF and JPG/JPEG** — both file types confirmed working. Handwritten documents are accepted at upload stage (extraction quality varies). `fileType` in response reflects actual format: `"PDF"`, `"JPEG"`.

package/assets/skills/api/references/endpoints.md

@@ -1197,40 +1197,6 @@ Content-Type: application/json
 3. When `COMPLETED` → read `businessTransactionDetails.businessTransactionResourceId`
 4. Use the BT resource ID with `GET /invoices/:id`, `GET /bills/:id`, `GET /customer-credit-notes/:id`, or `GET /supplier-credit-notes/:id`
 
-### CLI: clio magic split — Merged PDF Splitting
-
-Splits a merged PDF containing multiple documents (invoices, bills, credit notes) into individual files and uploads each to Magic. Uses structural PDF signals (bookmarks, page labels) + text heuristics (keywords, "Page 1 of N" patterns) for boundary detection. **No AI tokens used.**
-
-```bash
-# Auto-detect boundaries + upload
-clio magic split --file merged.pdf --type bill
-
-# Manual page ranges (for scanned PDFs or override)
-clio magic split --file merged.pdf --type bill --pages "1-3,4-6,7-9"
-
-# Dry-run: detect boundaries only (no qpdf needed)
-clio magic split --file merged.pdf --type bill --dry-run
-
-# JSON output (for agents)
-clio magic split --file merged.pdf --type bill --dry-run --json
-```
-
-**Detection signals (score-based, threshold >= 50):**
-- outline-bookmark (+80): PDF bookmark points to this page
-- page-label-reset (+70): PDF page label restarts at "1"
-- keyword in header (+40): Document keyword (INVOICE, BILL, etc.) in upper 40%
-- page-one-of (+35): "Page 1 of N" pattern
-- keyword-large (+25): Large font (>18pt) keyword bonus
-- doc-ref (+20): Document reference (INV-001, SO-2024-100, etc.)
-- continuation (-60): "Page N>1 of M" anti-signal
-- continuation-text (-40): "Continued" anti-signal
-
-**Edge cases:**
-- Scanned PDFs (no extractable text): warns and requires `--pages` manual override
-- Mixed scanned+digital: low confidence on scanned portions triggers confirmation prompt
-- Single document detected: suggests `clio magic create` instead
-- Encrypted PDFs: same `__pw__` pattern as `magic create`
-- Requires `qpdf` for splitting (not needed for `--dry-run` auto-detect mode)
 
 ---
 

package/assets/skills/cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: jaz-cli
-version: 4.34.4
+version: 4.34.6
 description: >-
   Use this skill when running Clio CLI commands, building shell scripts with
   Clio, debugging auth issues, understanding --json output, paginating results,

package/assets/skills/cli/references/command-catalog.md

@@ -324,7 +324,6 @@ Also: `clio reports pdf` — generate PDF from a message/document.
 | `create <file>` | `--type` (invoice, bill, credit-note-customer, credit-note-supplier), `--wait`, `--password` |
 | `status <workflowIds>` | Comma-separated workflow IDs |
 | `search` | `--type`, `--status`, `--from`, `--to`, `--limit`, `--offset` |
-| `split <file>` | `--pages`, `--type`, `--wait`, `--password` (split multi-doc PDF + extract) |
 
 ### `clio search <query>` — Universal cross-entity search
 Searches contacts, invoices, bills, credit notes, items. Returns grouped results.

package/assets/skills/cli/references/common-workflows.md

@@ -235,9 +235,6 @@ clio jobs ingest ./inbox/ --json
 # Or extract a single document
 clio magic create ./invoice-from-supplier.pdf --type bill --wait --json
 
-# Split a multi-page PDF into individual documents
-clio magic split ./combined-statements.pdf --type bill --wait --json
-
 # Check workflow status
 clio magic status "wf-id-1,wf-id-2,wf-id-3" --json
 

package/assets/skills/conversion/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: jaz-conversion
-version: 4.34.4
+version: 4.34.6
 description: >-
   Use this skill when migrating accounting data into Jaz — importing from Xero,
   QuickBooks, Sage, MYOB, or Excel exports. Covers the full conversion pipeline:

package/assets/skills/jobs/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: jaz-jobs
-version: 4.34.4
+version: 4.34.6
 description: >-
   Use this skill for recurring accounting workflows — month/quarter/year-end
   close, bank reconciliation, GST/VAT filing, payment runs, credit control,

package/assets/skills/transaction-recipes/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: jaz-recipes
-version: 4.34.4
+version: 4.34.6
 description: >-
   Use this skill when modeling complex multi-step accounting transactions —
   anything that spans multiple periods, involves changing amounts, or requires

package/dist/commands/magic.js

@@ -7,7 +7,6 @@ import prompts from 'prompts';
 import { createFromAttachment, searchMagicWorkflows, waitForWorkflows, } from '../core/api/magic.js';
 import { extractFilePassword, isPdfEncrypted, isQpdfAvailable, decryptPdf, cleanupDecryptedFile, } from '../core/jobs/document-collection/tools/ingest/decrypt.js';
 import { extractZipToDir, flattenSingleRoot } from '../core/jobs/document-collection/tools/ingest/cloud/zip.js';
-import { detectBoundaries, parsePageRanges, splitPdf, cleanupSplitFiles, } from '../core/pdf/index.js';
 import { apiAction } from './api-action.js';
 import { parsePositiveInt } from './parsers.js';
 import { displaySlice } from './pagination.js';
@@ -52,6 +51,7 @@ export function registerMagicCommand(program) {
         .option('--file <path>', 'Local file path (PDF, JPG, PNG, HEIC, XLS, XLSX, EML, ZIP). ZIP: extracts and uploads each file. Encrypted PDFs: name__pw__password.pdf')
         .option('--url <url>', 'Remote file URL (alternative to --file)')
         .option('--type <type>', `Document type: ${VALID_TYPES}`)
+        .option('--merged', 'Treat file as a merged PDF containing multiple documents (split before extraction)')
         .option('--api-key <key>', 'API key (overrides stored/env)')
         .option('--json', 'Output as JSON')
         .action(apiAction(async (client, opts) => {
@@ -73,6 +73,18 @@ export function registerMagicCommand(program) {
             console.error(chalk.red(`Error: invalid type "${opts.type}". Valid: ${VALID_TYPES}`));
             process.exit(1);
         }
+        // Validate --merged constraints
+        if (opts.merged) {
+            if (opts.url) {
+                console.error(chalk.red('Error: --merged is only supported with --file, not --url'));
+                process.exit(1);
+            }
+            const ext = extname(opts.file).toLowerCase();
+            if (ext !== '.pdf') {
+                console.error(chalk.red('Error: --merged requires a PDF file (got ' + ext + ')'));
+                process.exit(1);
+            }
+        }
         let sourceFile;
         let sourceFileName;
         let decryptedPath;
@@ -106,6 +118,7 @@ export function registerMagicCommand(program) {
             sourceFile,
             sourceFileName,
             sourceUrl: opts.url,
+            uploadMode: opts.merged ? 'MERGED' : undefined,
         });
         const data = res.data;
         const validFile = data.validFiles?.[0];
@@ -250,254 +263,11 @@ export function registerMagicCommand(program) {
                 console.log(chalk.dim(`  ... and ${overflow.toLocaleString()} more (use --json for full output)`));
         }
     }));
-    // ── clio magic split ──────────────────────────────────────────
-    magic
-        .command('split')
-        .description('Split a merged PDF into individual documents and upload each to Magic.\n' +
-        'Auto-detects document boundaries using text heuristics (keywords, page numbers, bookmarks).\n' +
-        'For scanned PDFs, use --pages to specify boundaries manually.')
-        .option('--file <path>', 'Local PDF file path (required). Encrypted PDFs: name__pw__password.pdf')
-        .option('--type <type>', `Document type: ${VALID_TYPES}`)
-        .option('--pages <ranges>', 'Manual page ranges (e.g. "1-3,4-6,7"). Skips auto-detection')
-        .option('--dry-run', 'Detect boundaries only — do not split or upload')
-        .option('--api-key <key>', 'API key (overrides stored/env)')
-        .option('--json', 'Output as JSON')
-        .action(apiAction(async (client, opts) => {
-        // ── Validate inputs ──
-        if (!opts.file) {
-            console.error(chalk.red('Error: --file is required'));
-            console.error(chalk.dim('Usage: clio magic split --file merged.pdf --type bill'));
-            process.exit(1);
-        }
-        if (!opts.type) {
-            console.error(chalk.red(`Error: --type is required (${VALID_TYPES})`));
-            console.error(chalk.dim('Usage: clio magic split --file merged.pdf --type bill'));
-            process.exit(1);
-        }
-        const apiType = TYPE_TO_API[opts.type];
-        if (!apiType) {
-            console.error(chalk.red(`Error: invalid type "${opts.type}". Valid: ${VALID_TYPES}`));
-            process.exit(1);
-        }
-        const filePath = resolve(opts.file);
-        const ext = extname(filePath).toLowerCase();
-        if (ext !== '.pdf') {
-            console.error(chalk.red('Error: PDF splitting only supports .pdf files'));
-            process.exit(1);
-        }
-        // qpdf only needed when actually splitting (not for dry-run auto-detect)
-        const needsQpdf = !opts.dryRun || opts.pages;
-        if (needsQpdf && !isQpdfAvailable()) {
-            console.error(chalk.red('Error: qpdf is required for PDF splitting.'));
-            console.error(chalk.dim('  macOS:   brew install qpdf'));
-            console.error(chalk.dim('  Ubuntu:  sudo apt install qpdf'));
-            process.exit(1);
-        }
-        // ── Handle encrypted PDFs ──
-        const resolved = await resolveInputPdf(filePath, ext, opts);
-        const effectivePath = resolved.effectivePath;
-        const sourceBaseName = resolved.cleanName.replace(/\.pdf$/i, '');
-        try {
-            // ── Determine documents (auto-detect or manual) ──
-            let documents;
-            let pageCount;
-            if (opts.pages) {
-                // Manual page ranges — need qpdf for page count
-                pageCount = (await import('../core/pdf/split.js')).getPageCount(effectivePath);
-                documents = parsePageRanges(opts.pages, pageCount);
-            }
-            else {
-                // Auto-detect boundaries
-                const buffer = readFileSync(effectivePath);
-                const detection = await detectBoundaries(new Uint8Array(buffer));
-                pageCount = detection.pageCount;
-                documents = detection.documents;
-                // Scanned PDF — can't auto-detect, require --pages
-                if (detection.isScannedPdf) {
-                    if (opts.json) {
-                        console.log(JSON.stringify({
-                            file: basename(filePath),
-                            pageCount,
-                            isScannedPdf: true,
-                            error: 'Scanned PDF — no extractable text. Use --pages to specify boundaries manually.',
-                        }, null, 2));
-                    }
-                    else {
-                        console.error(chalk.yellow('Scanned PDF detected — no extractable text for boundary detection.'));
-                        console.error(chalk.dim(`  Use --pages to split manually:`));
-                        console.error(chalk.dim(`  clio magic split --file ${basename(filePath)} --type ${opts.type} --pages "1-3,4-6,7-9"`));
-                    }
-                    process.exit(1);
-                }
-                // Single document — suggest magic create instead
-                if (documents.length <= 1) {
-                    if (opts.json) {
-                        console.log(JSON.stringify({
-                            file: basename(filePath),
-                            pageCount,
-                            documentsDetected: documents.length,
-                            message: 'Only 1 document detected — use `clio magic create` instead, or --pages to override.',
-                        }, null, 2));
-                    }
-                    else {
-                        console.error(chalk.yellow(`Only 1 document detected in ${pageCount}-page PDF.`));
-                        console.log(chalk.dim(`  Use clio magic create --file ${basename(filePath)} --type ${opts.type}`));
-                        console.log(chalk.dim(`  Or override with --pages: clio magic split --file ${basename(filePath)} --type ${opts.type} --pages "1-3,4-6"`));
-                    }
-                    return;
-                }
-            }
-            // ── Dry-run: print detection results only ──
-            if (opts.dryRun) {
-                if (opts.json) {
-                    console.log(JSON.stringify({
-                        file: basename(filePath),
-                        pageCount,
-                        documents: documents.map((d) => ({
-                            index: d.index,
-                            pageRange: d.pageRange,
-                            confidence: d.confidence,
-                            signals: d.signals.map((s) => s.label),
-                        })),
-                    }, null, 2));
-                }
-                else {
-                    console.log(chalk.bold(`PDF Split — Boundary Detection`));
-                    console.log(`  File: ${basename(filePath)} (${pageCount} pages)\n`);
-                    for (const doc of documents) {
-                        const conf = doc.confidence === 'high' ? chalk.green(doc.confidence)
-                            : doc.confidence === 'medium' ? chalk.yellow(doc.confidence)
-                                : chalk.red(doc.confidence);
-                        const signals = doc.signals.filter((s) => s.score > 0).map((s) => s.label).join(', ') || 'first page';
-                        console.log(`  Document ${doc.index + 1}: pages ${doc.pageRange.replace('-', '\u2013')}  (${conf})    ${chalk.dim(signals)}`);
-                    }
-                    console.log(`\n  ${documents.length} documents detected. Use --pages to override.`);
-                }
-                return;
-            }
-            // ── Confidence check: prompt if any low/medium ──
-            const hasLowConfidence = documents.some((d) => d.confidence !== 'high' && d.index > 0);
-            if (hasLowConfidence && !opts.json) {
-                console.log(chalk.bold(`PDF Split — Boundary Detection`));
-                console.log(`  File: ${basename(filePath)} (${pageCount} pages)\n`);
-                for (const doc of documents) {
-                    const conf = doc.confidence === 'high' ? chalk.green(doc.confidence)
-                        : doc.confidence === 'medium' ? chalk.yellow(doc.confidence)
-                            : chalk.red(doc.confidence);
-                    const signals = doc.signals.filter((s) => s.score > 0).map((s) => s.label).join(', ') || 'first page';
-                    console.log(`  Document ${doc.index + 1}: pages ${doc.pageRange.replace('-', '\u2013')}  (${conf})    ${chalk.dim(signals)}`);
-                }
-                console.log('');
-                const { proceed } = await prompts({
-                    type: 'confirm',
-                    name: 'proceed',
-                    message: 'Some boundaries have low confidence. Split and upload anyway?',
-                    initial: true,
-                });
-                if (!proceed) {
-                    console.log(chalk.dim('Aborted. Use --pages to specify boundaries manually.'));
-                    return;
-                }
-            }
-            // ── Split + Upload ──
-            const splitResult = splitPdf(effectivePath, documents, sourceBaseName);
-            const uploadResults = [];
-            try {
-                // Report split failures
-                for (const f of splitResult.failures) {
-                    uploadResults.push({
-                        index: f.index,
-                        pageRange: f.pageRange,
-                        splitFileName: `${sourceBaseName}_${f.index + 1}.pdf`,
-                        status: 'failed',
-                        error: `Split failed: ${f.error}`,
-                    });
-                    if (!opts.json) {
-                        console.error(chalk.red(`  \u2717 [${f.index + 1}/${documents.length}] pages ${f.pageRange} — split failed: ${f.error}`));
-                    }
-                }
-                // Upload each split file
-                for (const file of splitResult.files) {
-                    try {
-                        const buffer = readFileSync(file.path);
-                        const blob = new Blob([buffer], { type: 'application/pdf' });
-                        const res = await createFromAttachment(client, {
-                            businessTransactionType: apiType,
-                            sourceFile: blob,
-                            sourceFileName: file.fileName,
-                        });
-                        const valid = res.data.validFiles?.[0];
-                        const invalid = res.data.invalidFiles?.[0];
-                        if (valid) {
-                            uploadResults.push({
-                                index: file.index,
-                                pageRange: file.pageRange,
-                                splitFileName: file.fileName,
-                                status: 'uploaded',
-                                workflowResourceId: valid.workflowResourceId,
-                                documentType: res.data.businessTransactionType,
-                            });
-                            if (!opts.json) {
-                                console.log(chalk.green(`  \u2713 [${file.index + 1}/${documents.length}] pages ${file.pageRange} \u2192 ${file.fileName} \u2192 ${opts.type.toUpperCase()} (workflow: ${valid.workflowResourceId})`));
-                            }
-                        }
-                        else {
-                            const errMsg = invalid?.errorMessage ?? 'Unknown upload error';
-                            uploadResults.push({
-                                index: file.index,
-                                pageRange: file.pageRange,
-                                splitFileName: file.fileName,
-                                status: 'failed',
-                                error: errMsg,
-                            });
-                            if (!opts.json) {
-                                console.error(chalk.red(`  \u2717 [${file.index + 1}/${documents.length}] pages ${file.pageRange} \u2192 ${file.fileName} \u2192 failed: ${errMsg}`));
-                            }
-                        }
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        uploadResults.push({
-                            index: file.index,
-                            pageRange: file.pageRange,
-                            splitFileName: file.fileName,
-                            status: 'failed',
-                            error: errMsg,
-                        });
-                        if (!opts.json) {
-                            console.error(chalk.red(`  \u2717 [${file.index + 1}/${documents.length}] pages ${file.pageRange} \u2192 ${file.fileName} \u2192 failed: ${errMsg}`));
-                        }
-                    }
-                }
-            }
-            finally {
-                cleanupSplitFiles(splitResult.tempDir);
-            }
-            // ── Summary ──
-            const uploaded = uploadResults.filter((r) => r.status === 'uploaded').length;
-            const failed = uploadResults.filter((r) => r.status === 'failed').length;
-            if (opts.json) {
-                console.log(JSON.stringify({
-                    file: basename(filePath),
-                    pageCount,
-                    documents: uploadResults,
-                    summary: { total: documents.length, uploaded, failed },
-                }, null, 2));
-            }
-            else {
-                console.log(`\n  ${uploaded} uploaded, ${failed} failed`);
-            }
-        }
-        finally {
-            if (resolved.decryptedPath)
-                cleanupDecryptedFile(resolved.decryptedPath);
-        }
-    }));
 }
 // ── Helpers ──────────────────────────────────────────────────────
 /**
  * Resolve a PDF input, handling __pw__ password extraction + encrypted PDF decryption.
- * Shared by magic create and magic split (DRY).
+ * Handles __pw__ password extraction and encrypted PDF decryption.
  *
  * For non-PDF files, returns the original path with a clean filename (no __pw__ suffix).
  */

package/dist/commands/mcp.js

@@ -8,6 +8,9 @@
  * Auth resolves once at startup (same chain as CLI):
  *   1. --api-key flag  2. JAZ_API_KEY env  3. credentials file
  *
+ * If no auth is found, the server starts in offline mode — calculators
+ * and job blueprints work, API tools return an auth error.
+ *
  * API calls go directly from the user's machine to api.getjaz.com.
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -21,6 +24,20 @@ import { resolveAuth, resolvedProfileLabel } from '../core/auth/resolve.js';
 import { getProfile } from '../core/auth/credentials.js';
 import { JazClient } from '../core/api/client.js';
 import { getOrganization } from '../core/api/organization.js';
+/** Tool groups that work without an API key (no network calls). */
+const OFFLINE_GROUPS = new Set([
+    'close_jobs',
+    'operational_jobs',
+]);
+/** Returns true if the tool can run without a JazClient. */
+function isOfflineTool(group, name) {
+    if (OFFLINE_GROUPS.has(group))
+        return true;
+    // plan_recipe is offline (pure calculator); execute_recipe needs API
+    if (group === 'recipes' && name === 'plan_recipe')
+        return true;
+    return false;
+}
 // ── ParamDef → JSON Schema conversion ───────────────────────────
 /** @internal Exported for testing */
 export function paramDefToJsonSchema(def) {
@@ -71,39 +88,40 @@ export function registerMcpCommand(program) {
         .description('Start MCP stdio server for Claude Code / Cowork')
         .option('--api-key <key>', 'API key (overrides stored/env)')
         .action(async (opts) => {
-        // Resolve auth once at startup — reused across all tool calls
+        // Resolve auth once at startup — null means offline-only mode
         const auth = resolveAuth(opts.apiKey);
-        if (!auth) {
-            process.stderr.write('Error: No API key found. Set JAZ_API_KEY env var, run `clio auth add`, or pass --api-key.\n');
-            process.exit(1);
-        }
-        const client = new JazClient(auth);
+        const client = auth ? new JazClient(auth) : null;
         const version = program.version() ?? '0.0.0';
-        // ── Resolve org display (profile → stored name, raw key → API call)
+        // ── Resolve org display (only when authenticated)
         let orgDisplay = '';
         let orgStderr = '';
-        const label = resolvedProfileLabel();
-        if (label) {
-            const entry = getProfile(label);
-            if (entry?.orgName) {
-                orgDisplay = `Connected to: ${entry.orgName} (${entry.currency}).`;
-                orgStderr = `${entry.orgName} (${label})`;
+        if (client) {
+            const label = resolvedProfileLabel();
+            if (label) {
+                const entry = getProfile(label);
+                if (entry?.orgName) {
+                    orgDisplay = `Connected to: ${entry.orgName} (${entry.currency}).`;
+                    orgStderr = `${entry.orgName} (${label})`;
+                }
             }
-        }
-        if (!orgDisplay) {
-            // Raw API key — fetch org info with a short timeout to avoid blocking startup
-            const org = await Promise.race([
-                getOrganization(client),
-                new Promise((r) => setTimeout(() => r(null), 3000)),
-            ]).catch((e) => {
-                process.stderr.write(`org lookup failed: ${e instanceof Error ? e.message : 'unknown'}\n`);
-                return null;
-            });
-            if (org) {
-                orgDisplay = `Connected to: ${org.name} (${org.currency}).`;
-                orgStderr = org.name;
+            if (!orgDisplay) {
+                // Raw API key — fetch org info with a short timeout to avoid blocking startup
+                const org = await Promise.race([
+                    getOrganization(client),
+                    new Promise((r) => setTimeout(() => r(null), 3000)),
+                ]).catch((e) => {
+                    process.stderr.write(`org lookup failed: ${e instanceof Error ? e.message : 'unknown'}\n`);
+                    return null;
+                });
+                if (org) {
+                    orgDisplay = `Connected to: ${org.name} (${org.currency}).`;
+                    orgStderr = org.name;
+                }
             }
         }
+        const authNote = client
+            ? 'All API tools hit api.getjaz.com using the configured API key.'
+            : 'No API key configured — only offline tools (calculators, job blueprints) are available. Set JAZ_API_KEY or run `clio auth add` for full access.';
         const server = new Server({ name: 'jaz-ai', version }, {
             capabilities: { tools: {} },
             instructions: [
@@ -111,7 +129,7 @@ export function registerMcpCommand(program) {
                 orgDisplay,
                 'Manage invoices, bills, journals, contacts, bank, reports, and more.',
                 'Includes 13 IFRS-compliant financial calculators and 12 accounting job blueprints (offline, no auth).',
-                'All API tools hit api.getjaz.com using the configured API key.',
+                authNote,
             ].filter(Boolean).join(' '),
         });
         // ── List tools ──────────────────────────────────────────────
@@ -135,6 +153,19 @@ export function registerMcpCommand(program) {
                 throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${toolName}`);
             }
             const input = (request.params.arguments ?? {});
+            // Gate API tools when running without auth
+            if (!client && !isOfflineTool(tool.group, tool.name)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'No API key configured.',
+                                hint: 'Set JAZ_API_KEY env var, run `clio auth add`, or pass --api-key. Offline tools (calculators, job blueprints) work without a key.',
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
             // Validate write tool inputs before hitting the API
             const validation = validateToolInput(tool, input);
             if (!validation.valid) {
@@ -150,7 +181,14 @@ export function registerMcpCommand(program) {
                 };
             }
             try {
-                const result = await tool.execute({ client }, input);
+                // Offline tools ignore ctx.client (_ctx convention). The auth gate
+                // above rejects all non-offline tools when client is null, so this
+                // cast is unreachable for API tools. Guard defensively anyway.
+                if (!client && !isOfflineTool(tool.group, tool.name)) {
+                    throw new Error(`BUG: API tool ${tool.name} reached execute without auth`);
+                }
+                const ctx = { client: client };
+                const result = await tool.execute(ctx, input);
                 const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
                 return {
                     content: [{ type: 'text', text }],
@@ -179,6 +217,7 @@ export function registerMcpCommand(program) {
         process.stdin.on('end', shutdown);
         // Log to stderr (never stdout — that's the MCP channel)
         const orgSuffix = orgStderr ? ` — ${orgStderr}` : '';
-        process.stderr.write(`jaz-ai MCP server v${version} started (${TOOL_DEFINITIONS.length} tools)${orgSuffix}\n`);
+        const authStatus = client ? '' : ' [offline mode — no API key]';
+        process.stderr.write(`jaz-ai MCP server v${version} started (${TOOL_DEFINITIONS.length} tools)${orgSuffix}${authStatus}\n`);
     });
 }

package/dist/core/api/magic.js

@@ -1,9 +1,3 @@
-// ── API Functions ────────────────────────────────────────────────
-/**
- * Upload a file or URL to create a draft business transaction via OCR extraction.
- * Processing is async — response returns immediately with workflowResourceId.
- * Use searchMagicWorkflows() to check status.
- */
 export async function createFromAttachment(client, data) {
     const formData = new FormData();
     formData.append('businessTransactionType', data.businessTransactionType);
@@ -14,6 +8,8 @@ export async function createFromAttachment(client, data) {
         formData.append('sourceUrl', data.sourceUrl);
     if (data.attachmentId)
         formData.append('attachmentId', data.attachmentId);
+    if (data.uploadMode)
+        formData.append('uploadMode', data.uploadMode);
     return client.postMultipart('/api/v1/magic/createBusinessTransactionFromAttachment', formData);
 }
 /**

package/dist/core/registry/tools.js

@@ -2675,6 +2675,7 @@ Dynamic strings for reference/name/notes: {{Day}}, {{Date}}, {{Date+X}}, {{DateR
             },
             sourceUrl: { type: 'string', description: 'URL of the source file' },
             attachmentId: { type: 'string', description: 'Attachment ID (alternative to URL)' },
+            uploadMode: { type: 'string', enum: ['SEPARATE', 'MERGED'], description: 'Upload mode: SEPARATE (default, one doc per file) or MERGED (single PDF with multiple docs, auto-split before extraction). MERGED only works with PDF files.' },
         },
         required: ['businessTransactionType'],
         group: 'magic',
@@ -2687,6 +2688,7 @@ Dynamic strings for reference/name/notes: {{Day}}, {{Date}}, {{Date+X}}, {{DateR
                 businessTransactionType: input.businessTransactionType,
                 sourceUrl: input.sourceUrl,
                 attachmentId: input.attachmentId,
+                uploadMode: input.uploadMode,
             });
         },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaz-clio",
-  "version": "4.34.4",
+  "version": "4.34.6",
   "description": "Clio — Command Line Interface Orchestrator for Jaz AI.",
   "type": "module",
   "bin": {
@@ -52,7 +52,6 @@
     "financial": "^0.2.4",
     "node-telegram-bot-api": "^0.67.0",
     "ora": "^8.1.1",
-    "pdfjs-dist": "^5.4.624",
     "prompts": "^2.4.2",
     "update-notifier": "^7.3.1",
     "yaml": "^2.8.2"

package/dist/core/pdf/detect.js

@@ -1,344 +0,0 @@
-/**
- * PDF boundary detection engine — identifies document boundaries in merged PDFs.
- *
- * Uses pdfjs-dist (pure JS, no canvas) for text extraction + structural probes.
- * No AI tokens — heuristic-only scoring system.
- *
- * Detection signals (positive = boundary evidence, negative = anti-signal):
- *   outline-bookmark   +80   PDF bookmark points to this page
- *   page-label-reset   +70   PDF page label restarts at "1"
- *   keyword (upper 40%) +40  Document-type keyword near top of page
- *   page-one-of         +35  "Page 1 of N" pattern
- *   keyword-large       +25  Large font keyword (>18pt) bonus
- *   doc-ref (upper 40%) +20  Document reference pattern (INV-001, etc.)
- *   continuation        -60  "Page N>1 of M" anti-signal
- *   continuation        -40  "Continued" text anti-signal
- *
- * Threshold: >= 50 = boundary. Confidence: >= 80 high, >= 50 medium, < 50 low.
- */
-// pdfjs-dist v5 — legacy build for Node.js (no canvas requirement)
-import { getDocument } from 'pdfjs-dist/legacy/build/pdf.mjs';
-// ── Scoring constants ────────────────────────────────────────
-const SCORE_OUTLINE = 80;
-const SCORE_PAGE_LABEL_RESET = 70;
-const SCORE_KEYWORD = 40;
-const SCORE_PAGE_ONE_OF = 35;
-const SCORE_KEYWORD_LARGE = 25;
-const SCORE_DOC_REF = 20;
-const SCORE_CONTINUATION_PAGE = -60;
-const SCORE_CONTINUATION_TEXT = -40;
-const BOUNDARY_THRESHOLD = 50;
-const CONFIDENCE_HIGH = 80;
-/** Upper portion of page (0–40%) where keywords/refs are significant. */
-const UPPER_PORTION = 0.4;
-/** Font size threshold for large-font keyword bonus (points). */
-const LARGE_FONT_PT = 18;
-// ── Boundary keywords ────────────────────────────────────────
-// Multilingual: EN, Filipino, Indonesian/Malay, Vietnamese, Chinese
-// Each keyword is tested as a case-insensitive whole-word match.
-const BOUNDARY_KEYWORDS = [
-    // English
-    'TAX INVOICE', 'INVOICE', 'PROFORMA INVOICE', 'COMMERCIAL INVOICE',
-    'BILL', 'BILLING STATEMENT', 'STATEMENT OF ACCOUNT',
-    'CREDIT NOTE', 'CREDIT MEMO', 'DEBIT NOTE', 'DEBIT MEMO',
-    'PURCHASE ORDER', 'DELIVERY ORDER', 'DELIVERY NOTE',
-    'RECEIPT', 'OFFICIAL RECEIPT', 'ACKNOWLEDGMENT RECEIPT',
-    'QUOTATION', 'SALES ORDER', 'CONTRACT',
-    'PACKING LIST', 'BILL OF LADING', 'CERTIFICATE OF ORIGIN',
-    // Filipino / PH
-    'RESIBO', 'KATIBAYAN NG PAGBABAYAD',
-    // Indonesian / Malay
-    'FAKTUR PAJAK', 'FAKTUR', 'NOTA KREDIT', 'NOTA DEBIT',
-    'KWITANSI', 'SURAT JALAN',
-    // Vietnamese
-    'HOA DON', 'HOÁ ĐƠN', 'PHIẾU THU', 'PHIẾU CHI',
-    // Chinese
-    '发票', '税务发票', '收据', '信用票据', '送货单',
-];
-/** Escaped regex patterns — match keyword as a word boundary. */
-const KEYWORD_PATTERNS = BOUNDARY_KEYWORDS.map((kw) => {
-    const escaped = kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    // For CJK characters, don't use word boundaries (they don't apply)
-    const hasCJK = /[\u4e00-\u9fff]/.test(kw);
-    return hasCJK
-        ? new RegExp(escaped, 'i')
-        : new RegExp(`\\b${escaped}\\b`, 'i');
-});
-/** "Page 1 of N" patterns (matches multiple languages). */
-const PAGE_ONE_PATTERN = /\bpage\s+1\s+of\s+\d+/i;
-/** "Page N of M" where N > 1 — continuation signal. */
-const PAGE_N_PATTERN = /\bpage\s+(\d+)\s+of\s+\d+/i;
-/** Document reference patterns: INV-001, SO-2024-100, PO#123, etc. */
-const DOC_REF_PATTERN = /\b(?:INV|SO|PO|DO|CN|DN|OR|CR|BL|SI|PI|QU|CT|REC)[\s#._-]*\d{2,}/i;
-/** Continuation text markers. */
-const CONTINUATION_PATTERNS = [
-    /\bcontinued\b/i,
-    /\b(?:cont['']?d)\b/i,
-    /\blanjutan\b/i, // Indonesian
-    /\btiếp theo\b/i, // Vietnamese
-];
-// ── pdfjs-dist configuration ─────────────────────────────────
-// Security: disable code generation from strings (pdfjs option key
-// constructed dynamically to avoid triggering static analysis hooks)
-const PDFJS_SECURITY_KEY = ['is', 'Eval', 'Supported'].join('');
-// ── Main detection function ──────────────────────────────────
-/**
- * Detect document boundaries in a merged PDF.
- *
- * @param buffer  Raw PDF bytes (Uint8Array or Buffer).
- * @returns Detection result with per-page probes and detected documents.
- */
-export async function detectBoundaries(buffer) {
-    const doc = await getDocument({
-        data: buffer,
-        worker: null, // No worker thread (CLI) — null disables it at runtime
-        [PDFJS_SECURITY_KEY]: false, // Security: no code generation from strings
-        verbosity: 0, // Suppress warnings
-    }).promise;
-    const pageCount = doc.numPages;
-    const pages = [];
-    try {
-        // Phase 1: Structural probes (whole-document)
-        const outlinePages = await probeOutlines(doc);
-        const labelResetPages = await probePageLabels(doc);
-        // Phase 2: Per-page text scan
-        let scannedCount = 0;
-        for (let i = 0; i < pageCount; i++) {
-            const signals = [];
-            // Structural signals
-            if (outlinePages.has(i)) {
-                signals.push({ type: 'outline-bookmark', label: 'PDF bookmark', score: SCORE_OUTLINE });
-            }
-            if (labelResetPages.has(i)) {
-                signals.push({ type: 'page-label-reset', label: 'Page label reset to 1', score: SCORE_PAGE_LABEL_RESET });
-            }
-            // Text extraction
-            const page = await doc.getPage(i + 1); // 1-based
-            const textContent = await page.getTextContent();
-            const items = textContent.items;
-            if (items.length === 0) {
-                signals.push({ type: 'scanned', label: 'No extractable text', score: 0 });
-                scannedCount++;
-            }
-            else {
-                // Determine page height from viewport
-                const viewport = page.getViewport({ scale: 1 });
-                const pageHeight = viewport.height;
-                // Collect upper-portion text and full-page text
-                const upperTexts = [];
-                const allTexts = [];
-                for (const item of items) {
-                    const text = item.str.trim();
-                    if (!text)
-                        continue;
-                    allTexts.push(text);
-                    // transform[5] is the Y coordinate (from bottom), transform[0] is scaleX ~ fontSize
-                    const y = item.transform[5];
-                    const fontSize = Math.abs(item.transform[0]);
-                    const normalizedY = y / pageHeight;
-                    // Upper portion = top 40% of page (high Y values in PDF coordinate system)
-                    if (normalizedY >= (1 - UPPER_PORTION)) {
-                        upperTexts.push({ text, fontSize });
-                    }
-                }
-                const fullText = allTexts.join(' ');
-                const upperText = upperTexts.map((t) => t.text).join(' ');
-                // Keyword detection (upper portion only)
-                for (let k = 0; k < KEYWORD_PATTERNS.length; k++) {
-                    if (KEYWORD_PATTERNS[k].test(upperText)) {
-                        signals.push({
-                            type: 'keyword',
-                            label: `${BOUNDARY_KEYWORDS[k]} in header`,
-                            score: SCORE_KEYWORD,
-                        });
-                        // Large font bonus: check if any upper-portion item with this keyword is large
-                        const kwPattern = KEYWORD_PATTERNS[k];
-                        const hasLargeFont = upperTexts.some((t) => kwPattern.test(t.text) && t.fontSize >= LARGE_FONT_PT);
-                        if (hasLargeFont) {
-                            signals.push({
-                                type: 'keyword-large',
-                                label: `${BOUNDARY_KEYWORDS[k]} in large font (>${LARGE_FONT_PT}pt)`,
-                                score: SCORE_KEYWORD_LARGE,
-                            });
-                        }
-                        break; // Only count the first keyword match per page
-                    }
-                }
-                // "Page 1 of N" detection (anywhere on page)
-                if (PAGE_ONE_PATTERN.test(fullText)) {
-                    signals.push({ type: 'page-one-of', label: 'Page 1 of N', score: SCORE_PAGE_ONE_OF });
-                }
-                // Document reference in upper portion
-                if (DOC_REF_PATTERN.test(upperText)) {
-                    signals.push({ type: 'doc-ref', label: 'Document reference in header', score: SCORE_DOC_REF });
-                }
-                // Anti-signals: continuation indicators
-                const pageNMatch = fullText.match(PAGE_N_PATTERN);
-                if (pageNMatch && parseInt(pageNMatch[1], 10) > 1) {
-                    signals.push({
-                        type: 'continuation',
-                        label: `Page ${pageNMatch[1]} of N (continuation)`,
-                        score: SCORE_CONTINUATION_PAGE,
-                    });
-                }
-                for (const pat of CONTINUATION_PATTERNS) {
-                    if (pat.test(fullText)) {
-                        signals.push({
-                            type: 'continuation',
-                            label: 'Continuation text detected',
-                            score: SCORE_CONTINUATION_TEXT,
-                        });
-                        break;
-                    }
-                }
-            }
-            const totalScore = signals.reduce((sum, s) => sum + s.score, 0);
-            // Page 0 is always a boundary (it's the start of the first document)
-            const isBoundary = i === 0 || totalScore >= BOUNDARY_THRESHOLD;
-            pages.push({ pageIndex: i, signals, totalScore, isBoundary });
-        }
-        const documents = buildDocuments(pages, pageCount);
-        const isScannedPdf = scannedCount === pageCount && pageCount > 0;
-        return { pageCount, pages, documents, isScannedPdf };
-    }
-    finally {
-        try {
-            doc.destroy();
-        }
-        catch { /* best effort */ }
-    }
-}
-// ── Structural probes ────────────────────────────────────────
-/** Probe PDF outlines/bookmarks -> set of 0-based page indices that have bookmarks. */
-async function probeOutlines(doc) {
-    const result = new Set();
-    try {
-        const outline = await doc.getOutline();
-        if (!outline)
-            return result;
-        const stack = [...outline];
-        while (stack.length > 0) {
-            const item = stack.pop();
-            if (!item)
-                continue;
-            // Resolve destination to page index
-            if (item.dest) {
-                try {
-                    const dest = typeof item.dest === 'string'
-                        ? await doc.getDestination(item.dest)
-                        : item.dest;
-                    if (Array.isArray(dest) && dest[0]) {
-                        const pageIndex = await doc.getPageIndex(dest[0]);
-                        result.add(pageIndex);
-                    }
-                }
-                catch { /* skip unresolvable destinations */ }
-            }
-            // Traverse children
-            if (Array.isArray(item.items)) {
-                stack.push(...item.items);
-            }
-        }
-    }
-    catch { /* no outlines or error reading them */ }
-    return result;
-}
-/** Probe PDF page labels -> set of 0-based page indices where label resets to "1". */
-async function probePageLabels(doc) {
-    const result = new Set();
-    try {
-        const labels = await doc.getPageLabels();
-        if (!labels)
-            return result;
-        for (let i = 1; i < labels.length; i++) {
-            // A label that is "1" (or "i" for roman numeral) after not being "1" signals a reset
-            if (labels[i] === '1' && labels[i - 1] !== '1') {
-                result.add(i);
-            }
-        }
-    }
-    catch { /* no page labels */ }
-    return result;
-}
-// ── Document builder ─────────────────────────────────────────
-/** Build detected documents from boundary pages. */
-function buildDocuments(pages, pageCount) {
-    const boundaries = pages.filter((p) => p.isBoundary);
-    const documents = [];
-    for (let i = 0; i < boundaries.length; i++) {
-        const start = boundaries[i].pageIndex;
-        const end = i + 1 < boundaries.length
-            ? boundaries[i + 1].pageIndex - 1
-            : pageCount - 1;
-        // Page range is 1-based for display
-        const pageStart = start + 1;
-        const pageEnd = end + 1;
-        const pageRange = pageStart === pageEnd ? `${pageStart}` : `${pageStart}-${pageEnd}`;
-        documents.push({
-            index: i,
-            pageStart,
-            pageEnd,
-            pageRange,
-            confidence: scoreToConfidence(boundaries[i].totalScore),
-            signals: boundaries[i].signals,
-        });
-    }
-    return documents;
-}
-/** Map aggregate score to confidence level. */
-function scoreToConfidence(score) {
-    if (score >= CONFIDENCE_HIGH)
-        return 'high';
-    if (score >= BOUNDARY_THRESHOLD)
-        return 'medium';
-    return 'low';
-}
-// ── Manual page ranges ───────────────────────────────────────
-/**
- * Parse a manual page-range string into DetectedDocument[].
- *
- * Format: "1-3,4-6,7" (1-based, inclusive ranges, comma-separated).
- * Validates: no overlaps, ranges within page count.
- *
- * @throws Error on invalid format or range.
- */
-export function parsePageRanges(rangesStr, pageCount) {
-    const parts = rangesStr.split(',').map((s) => s.trim()).filter(Boolean);
-    if (parts.length === 0) {
-        throw new Error('Empty page range — provide ranges like "1-3,4-6,7"');
-    }
-    const documents = [];
-    let lastEnd = 0;
-    for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        const match = part.match(/^(\d+)(?:-(\d+))?$/);
-        if (!match) {
-            throw new Error(`Invalid page range "${part}" — use format "1-3" or "7"`);
-        }
-        const pageStart = parseInt(match[1], 10);
-        const pageEnd = match[2] ? parseInt(match[2], 10) : pageStart;
-        if (pageStart < 1 || pageEnd < 1) {
-            throw new Error(`Page numbers must be positive (got "${part}")`);
-        }
-        if (pageStart > pageEnd) {
-            throw new Error(`Invalid range "${part}" — start must be <= end`);
-        }
-        if (pageEnd > pageCount) {
-            throw new Error(`Range "${part}" exceeds page count (${pageCount} pages)`);
-        }
-        if (pageStart <= lastEnd) {
-            throw new Error(`Overlapping range "${part}" — previous range ended at page ${lastEnd}`);
-        }
-        const pageRange = pageStart === pageEnd ? `${pageStart}` : `${pageStart}-${pageEnd}`;
-        documents.push({
-            index: i,
-            pageStart,
-            pageEnd,
-            pageRange,
-            confidence: 'high', // Manual ranges are always high confidence
-            signals: [],
-        });
-        lastEnd = pageEnd;
-    }
-    return documents;
-}

package/dist/core/pdf/index.js

@@ -1,8 +0,0 @@
-/**
- * PDF boundary detection + splitting for merged documents.
- *
- * Usage:
- *   import { detectBoundaries, parsePageRanges, splitPdf, ... } from '../core/pdf/index.js';
- */
-export { detectBoundaries, parsePageRanges } from './detect.js';
-export { getPageCount, splitPdf, cleanupSplitFiles } from './split.js';

package/dist/core/pdf/split.js

@@ -1,81 +0,0 @@
-/**
- * PDF page-range extraction via qpdf.
- *
- * Creates temporary files for each document range extracted from a merged PDF.
- * Caller is responsible for cleanup (use `cleanupSplitFiles`).
- *
- * Follows the same patterns as decrypt.ts: execFileSync, mkdtempSync, explicit cleanup.
- */
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, existsSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import { tmpdir } from 'node:os';
-import { rmSync } from 'node:fs';
-import { isQpdfAvailable } from '../jobs/document-collection/tools/ingest/decrypt.js';
-/**
- * Get the page count of a PDF file using qpdf.
- * @throws Error if qpdf is not installed or the file is invalid.
- */
-export function getPageCount(filePath) {
-    if (!isQpdfAvailable()) {
-        throw new Error('qpdf is required — install: brew install qpdf (macOS) or sudo apt install qpdf (Linux)');
-    }
-    const output = execFileSync('qpdf', ['--show-npages', filePath], {
-        encoding: 'utf-8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    const count = parseInt(output.trim(), 10);
-    if (isNaN(count) || count < 1) {
-        throw new Error(`Failed to read page count from "${basename(filePath)}"`);
-    }
-    return count;
-}
-/**
- * Split a PDF into multiple files based on detected document ranges.
- *
- * Creates a temp directory and extracts each range as a separate PDF.
- * Continues on failure (never aborts mid-batch, matching upload.ts pattern).
- * Caller MUST call `cleanupSplitFiles()` when done.
- */
-export function splitPdf(sourcePath, documents, sourceBaseName) {
-    if (!isQpdfAvailable()) {
-        throw new Error('qpdf is required — install: brew install qpdf (macOS) or sudo apt install qpdf (Linux)');
-    }
-    const tempDir = mkdtempSync(join(tmpdir(), 'clio-split-'));
-    const files = [];
-    const failures = [];
-    for (const doc of documents) {
-        const fileName = `${sourceBaseName}_${doc.index + 1}.pdf`;
-        const outputPath = join(tempDir, fileName);
-        try {
-            execFileSync('qpdf', [
-                sourcePath,
-                '--pages', '.', `${doc.pageStart}-${doc.pageEnd}`, '--',
-                outputPath,
-            ], { stdio: 'pipe' });
-            files.push({
-                index: doc.index,
-                pageRange: doc.pageRange,
-                path: outputPath,
-                fileName,
-            });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            failures.push({ index: doc.index, pageRange: doc.pageRange, error: msg });
-        }
-    }
-    return { tempDir, files, failures };
-}
-/**
- * Remove all split temp files and their temp directory.
- * Safe to call with any path — silently ignores missing dirs.
- */
-export function cleanupSplitFiles(tempDir) {
-    try {
-        if (existsSync(tempDir)) {
-            rmSync(tempDir, { recursive: true, force: true });
-        }
-    }
-    catch { /* best effort */ }
-}

package/dist/core/pdf/types.js

@@ -1,4 +0,0 @@
-/**
- * Types for PDF boundary detection and document splitting.
- */
-export {};