@oxygen-agent/cli 1.1014.618 → 1.1014.619

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.1014.618
+Version: 1.1014.619

package/dist/commands/crm.js

@@ -391,6 +391,8 @@ function buildCrmDuplicatesPath(object, options) {
     const params = new URLSearchParams();
     if (options.limit)
         params.set("limit", options.limit);
+    if (options.cursor)
+        params.set("cursor", options.cursor);
     const query = params.toString();
     const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/duplicates`;
     return query ? `${base}?${query}` : base;
@@ -1393,9 +1395,10 @@ export function registerCrmFamily(program, handleAsyncAction) {
         await handleAsyncAction("crm describe", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}${field ? `?attribute=${encodeURIComponent(field)}` : ""}`));
     }))
         .addCommand(new Command("duplicates")
-        .description("List ranked duplicate-candidate record pairs for one CRM object (identity-overlap + fuzzy-label). Read-only.")
+        .description("List ranked duplicate-candidate record pairs for one CRM object (identity-overlap + fuzzy-label), across every record. Read-only.")
         .argument("<object>", "CRM object slug, such as companies or people.")
-        .option("--limit <limit>", "Maximum candidate pairs to return. Defaults to 25, max 100.")
+        .option("--limit <limit>", "Maximum candidate pairs per page. Defaults to 25, max 100.")
+        .option("--cursor <cursor>", "Pagination cursor from a previous page (its nextCursor).")
         .option("--json", "Print a JSON envelope.")
         .action(async (object, options) => {
         await handleAsyncAction("crm duplicates", options, () => requestOxygen(buildCrmDuplicatesPath(object, options)));

package/dist/commands/tables.js

@@ -14,7 +14,7 @@ import { PIPEDRIVE_CATALOG_QUERY_CONTRACT, pipedriveCatalogQueryParams } from "@
 import { TABLE_LIST_QUERY_CONTRACT, tableListQueryParams } from "@oxygen/shared/contracts/table-list";
 import { TABLE_QUERY_GRID_CONTRACT } from "@oxygen/shared/contracts/table-query-grid";
 import { TABLE_QUERY_CLI_DEFAULT_LIMIT, TABLE_QUERY_CLI_DEFAULT_MAX_CHARS, tableQueryRawResultFits, tableQueryRawRecovery } from "@oxygen/shared/contracts/table-query-raw";
-import { MAX_BUFFERED_IMPORT_PARSE_BYTES, assertImportFormatWithinBufferedLimit, inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer } from "@oxygen/shared/file-import";
+import { MAX_BUFFERED_IMPORT_PARSE_BYTES, assertImportFormatWithinBufferedLimit, dropBlankImportCells, inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer } from "@oxygen/shared/file-import";
 import { PUBLIC_WEBHOOK_INGRESS_PER_TARGET_PER_MINUTE } from "@oxygen/shared/plan-band";
 import { MAX_CLI_JSON_BODY_BYTES, PLAN_LIMITS } from "@oxygen/shared/plan-limits";
 import { FILTER_TREE_OPERATORS } from "@oxygen/shared/table-filter-operators";
@@ -608,6 +608,9 @@ async function importRowsFromUrl(table, options) {
     return withImportWaitNextStep({ ...result, background: true, autoBackground: true });
 }
 async function importRows(table, options) {
+    if (options.url && options.skipBlankCells) {
+        throw new OxygenError("invalid_request", "--skip-blank-cells works on --file imports. Download the link and import the file.", { exitCode: 1 });
+    }
     if (options.url)
         return importRowsFromUrl(table, { ...options, url: options.url });
     if (!options.file) {
@@ -661,7 +664,11 @@ async function importRowsFromFile(table, options) {
             sourceHash,
         }, preparedBackgroundTarget));
     }
-    const target = await prepareImportTarget(table, options, parsedRows);
+    const prepared = await prepareImportTarget(table, options, parsedRows);
+    // The foreground writes rows itself: a row without a key leaves that value alone.
+    const target = options.skipBlankCells
+        ? { ...prepared, rows: prepared.rows.map((row) => dropBlankImportCells(row, prepared.upsertKey)) }
+        : prepared;
     let rowCount = 0;
     let insertedCount = 0;
     let updatedCount = 0;
@@ -1022,6 +1029,7 @@ table, options, format, file, context, preparedTarget = null) {
                 : {}),
             ...(target.upsertKey ? { upsert_key: target.upsertKey } : {}),
             ...(target.sourceKeyMap ? { source_key_map: target.sourceKeyMap } : {}),
+            ...(options.skipBlankCells ? { skip_blank_cells: true } : {}),
         },
     });
     emitQueueWaitStderrNote(readRecord(result, "queue_wait"));
@@ -1108,6 +1116,10 @@ async function enqueueImportFile(table, options, format, batchSize, context, pre
             exitCode: 1,
         });
     }
+    if (options.skipBlankCells) {
+        // The multipart import cannot leave blank cells out; failing beats clearing them.
+        throw new OxygenError("skip_blank_cells_unavailable", "--skip-blank-cells needs the staged file upload, which this OXYGEN server has not configured. Add --sync to write the rows from this machine instead.", { exitCode: 1 });
+    }
     const fileBuffer = readFileSync(options.file);
     const filename = basename(options.file);
     const form = new FormData();
@@ -2441,6 +2453,7 @@ export function registerTablesFamily(program, handleAsyncAction, binaryName) {
         .option("--create <name>", "Create a new table with columns inferred from the file before importing.")
         .option("--project <project>", "Project id or slug for --create. Defaults to General.")
         .option("--upsert-key <key>", "Column key used to upsert instead of inserting.")
+        .option("--skip-blank-cells", "Leave a row's existing value where the file's cell is blank instead of clearing it, so a partial update needs one file.")
         .option("--batch-size <n>", `Requested rows per import chunk, not a limit on the file. Defaults to 500; values up to 5000 are accepted, but Oxygen splits writes to at most 500 rows (and smaller for wide rows, about ${formatJsonBodyLimit()} of JSON per request) so they fit request and worker lease budgets.`)
         .option("--background", "Enqueue durable import chunks for the background worker.")
         .option("--sync", `Force foreground import even for files above ${LARGE_IMPORT_BACKGROUND_ROW_THRESHOLD} rows. That threshold picks foreground vs background; it does not cap how many rows a file may hold.`)

package/node_modules/@oxygen/shared/dist/contracts/customer-operations.js

@@ -13,6 +13,7 @@ const text = (description) => str(description === undefined ? {} : { description
 const list = () => arr(str());
 const json = { type: "object", additionalProperties: true };
 const rows = () => arr(json);
+const skipBlankCells = () => bool({ description: "Keep existing values where a cell is blank." });
 function operation(id, route, method, cli, mcp, pack, summary, fields = {}, required = [], options = {}) {
     const { annotations, ...behavior } = options;
     const parameters = [...route.matchAll(/\{(\w+)\}/g)].map((match) => match[1]);
@@ -87,10 +88,10 @@ export const CUSTOMER_OPERATIONS = [
     operation("table_ingestions.append", "/api/cli/table-ingestion-runs/{ingestion_run_id}/items", "POST", "table-ingestions append", "oxygen_table_ingestions_append_items", "runs", "Append generated row chunks with items [{position:0,payload:{rows:[{column:value}]}}]. For capped provider paging, create a new approved tool_page run from the last completed item.nextCursor; preserve the Table, filters/mapping/upsert key and use a new credit cap.", { items: rows(), max_attempts: int({ minimum: 1 }) }, ["items"], cliOnly),
     operation("tables.favorites.get", "/api/cli/tables/favorite", "GET", "tables favorites", "oxygen_tables_favorites", "tables", "Read starred Tables/folders (per-member preference; free (0 credits)); next_cursor. Catalog stars differ.", TABLE_FAVORITES_LIST_CONTRACT.properties, [], { generated: { cli: true, mcp: false } }),
     operation("tables.favorite.set", "/api/cli/tables/favorite", "POST", "tables favorite", "oxygen_tables_favorite", "tables", "Star/unstar exactly one table or folder (saved per-member preference). Free (0 credits). Catalog stars differ.", TABLE_FAVORITE_CONTRACT.properties, ["favorite"]),
-    operation("tables.import.csv", "/api/cli/tables/import-csv", "POST", "tables import-csv", "oxygen_tables_import_csv", "tables", "Import inline CSV into a hosted Table through its durable ingestion run. Use staged upload for large files.", { csv_text: text(), csv_base64: text(), table: text(), table_name: text(), project: text(), filename: text(), upsert_key: text(), batch_size: int({ minimum: 1, maximum: 5000 }) }, [], cliOnly),
+    operation("tables.import.csv", "/api/cli/tables/import-csv", "POST", "tables import-csv", "oxygen_tables_import_csv", "tables", "Import inline CSV into a hosted Table through its durable ingestion run. Use staged upload for large files.", { csv_text: text(), csv_base64: text(), table: text(), table_name: text(), project: text(), filename: text(), upsert_key: text(), skip_blank_cells: skipBlankCells(), batch_size: int({ minimum: 1, maximum: 5000 }) }, [], cliOnly),
     operation("tables.import.prepare", "/api/cli/tables/import-url", "POST", "tables import-upload", "oxygen_tables_import_upload", "tables", "Prepare a scoped storage upload for a hosted Table import; uploads and imports are separate, inspectable steps.", { file_name: text(), content_type: text(), byte_length: int({ minimum: 1 }), trace_id: text(), format: enumOf(["csv", "json", "xlsx"]) }, ["file_name", "byte_length"]),
     operation("tables.import.preview", "/api/cli/tables/import-preview", "POST", "tables import-preview", "oxygen_tables_import_preview", "tables", "Preview a staged file's headers, rows and existing-table mapping; writes no imported rows.", { storage_key: text(), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), byte_length: int({ minimum: 1 }), table: text(), upsert_key: text() }, ["storage_key", "byte_length"], { mutates: false }),
-    operation("tables.import.staged", "/api/cli/tables/import-staged", "POST", "tables import-staged", "oxygen_tables_import_staged", "tables", "Start a durable hosted import from this workspace's staged file; choose an existing table or create_name.", { table: text(), create_name: text(), project: text(), storage_key: text(), storage_bucket: text(), storage_provider: enumOf(["s3"]), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), sha256: text(), upsert_key: text(), source_key_map: json, byte_length: int({ minimum: 1 }), row_count: int({ minimum: 1 }), max_concurrency: int({ minimum: 1, maximum: 1000 }), source: enumOf(["cli", "mcp", "web"]), batch_size: int({ minimum: 1, maximum: 5000 }) }, ["storage_key", "byte_length"]),
+    operation("tables.import.staged", "/api/cli/tables/import-staged", "POST", "tables import-staged", "oxygen_tables_import_staged", "tables", "Start a durable hosted import from this workspace's staged file; choose an existing table or create_name.", { table: text(), create_name: text(), project: text(), storage_key: text(), storage_bucket: text(), storage_provider: enumOf(["s3"]), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), sha256: text(), upsert_key: text(), skip_blank_cells: skipBlankCells(), source_key_map: json, byte_length: int({ minimum: 1 }), row_count: int({ minimum: 1 }), max_concurrency: int({ minimum: 1, maximum: 1000 }), source: enumOf(["cli", "mcp", "web"]), batch_size: int({ minimum: 1, maximum: 5000 }) }, ["storage_key", "byte_length"]),
     operation("tables.import.file", "/api/cli/tables/import-file", "POST", "tables import-file", "oxygen_tables_import_file", "tables", "Import small base64 file bytes through the shared multipart import API; use staged upload for large files.", { content_base64: text(), file_name: text(), content_type: text(), table: text(), table_name: text(), project: text(), format: enumOf(["csv", "json", "xlsx"]), sheet: text(), upsert_key: text(), source_key_map: json, source_hash: text(), batch_size: int({ minimum: 1, maximum: 5000 }), max_concurrency: int({ minimum: 1 }) }, ["content_base64", "file_name"], { multipart: { contentField: "content_base64", nameField: "file_name", typeField: "content_type", fileField: "file" } }),
     operation("tables.link.suggest", "/api/cli/tables/link/suggest", "POST", "tables link-suggest", "oxygen_tables_link_suggest", "tables", "Plan column links and matching row counts between Tables; creates no relation. Apply with tables link --to (MCP oxygen_tables_link_bulk).", TABLE_LINK_SUGGEST_CONTRACT.properties, ["table", "to"], { mutates: false }),
     operation("tables.recover_pending", "/api/cli/tables/recover-pending", "POST", "tables recover-pending", "oxygen_tables_recover_pending", "tables", "Recover BetterContact email/phone requests and read verification blockers; no new orders or imports.", TABLE_RECOVER_PENDING_CONTRACT.properties, ["table"], { ...mcpOnly, annotations: { openWorldHint: true } }),

package/node_modules/@oxygen/shared/dist/file-import.d.ts

@@ -67,6 +67,14 @@ export declare function parseRowsSampleText(text: string, format: Exclude<RowsFi
 }): RowsSample;
 export declare function inferImportColumnLabels(rows: Record<string, unknown>[]): string[];
 export declare function normalizeRowsForNewTable(rows: Record<string, unknown>[]): NewTableImportRows;
+/**
+ * The row without its blank cells, for an import that must leave a record's
+ * existing value alone where the file has nothing ("skip blank cells"): an
+ * upsert writes only the keys a row carries. Blank is null, undefined or text
+ * that is only whitespace. The upsert key always stays, so a row without one is
+ * still reported as missing its key instead of quietly dropping out.
+ */
+export declare function dropBlankImportCells(row: Record<string, unknown>, keepKey?: string | null): Record<string, unknown>;
 export declare function normalizeImportColumnKey(value: string): string;
 /**
  * Refuse a JSON or XLSX file over the buffered-parse ceiling before anything is

package/node_modules/@oxygen/shared/dist/file-import.js

@@ -217,6 +217,22 @@ export function normalizeRowsForNewTable(rows) {
 // it MATCHES imported file headers back to the column key MINTED by tenant-db's
 // toSnakeIdentifier, and has call sites across web/CLI/API. The two must never
 // diverge \u2014 see packages/shared/src/identifiers.ts + identifiers.test.ts.
+/**
+ * The row without its blank cells, for an import that must leave a record's
+ * existing value alone where the file has nothing ("skip blank cells"): an
+ * upsert writes only the keys a row carries. Blank is null, undefined or text
+ * that is only whitespace. The upsert key always stays, so a row without one is
+ * still reported as missing its key instead of quietly dropping out.
+ */
+export function dropBlankImportCells(row, keepKey) {
+    const kept = {};
+    for (const [key, value] of Object.entries(row)) {
+        const blank = value === null || value === undefined || (typeof value === "string" && value.trim() === "");
+        if (!blank || key === keepKey)
+            kept[key] = value;
+    }
+    return kept;
+}
 export function normalizeImportColumnKey(value) {
     return toSnakeIdentifier(value, "column");
 }

package/node_modules/@oxygen/shared/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1014.618";
+export declare const OXYGEN_BUILD_VERSION = "1.1014.619";

package/node_modules/@oxygen/shared/dist/version.generated.js

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1014.618";
+export const OXYGEN_BUILD_VERSION = "1.1014.619";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.1014.618",
+  "version": "1.1014.619",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",