@oxygen-agent/cli 1.1014.985 → 1.1014.1087

package/dist/command-families/tables/register-row-writes.js

@@ -0,0 +1,140 @@
+import { parseJsonObject } from "../../cli-values.js";
+import { parseJsonArray, readFileIfPresent } from "../../command-support.js";
+import { requestOxygen } from "../../http-client.js";
+import { readOption } from "../../util.js";
+import { Command } from "commander";
+import { writeRowDeleteWarnings } from "./display.js";
+import { readDeleteRowIdsOption } from "./row-selection.js";
+export function registerRowWrites({ tablesCommand, handleAsyncAction }) {
+    tablesCommand.addCommand(new Command("create")
+        .description("Create a table private to the active workspace. Free — 0 Oxygen credits. To create a table and import a file in one step, use `tables import --create <name>`.")
+        .argument("<name>", "Display name for the table.")
+        .requiredOption("--columns-json <json>", 'Required nonempty JSON array of column definitions, e.g. [{"key":"name","label":"Name","dataType":"text"},{"key":"domain","label":"Domain","dataType":"text"}]. A column may name a field type instead, as `columns add --type` does: {"label":"Stage","type":"select","options":["Lead","Won"]} (text, number, checkbox, date, json, markdown, image, select, multi_select, status). Inspect an existing shape with `oxygen tables describe <table>`.')
+        .option("--project <project>", "Project id or slug. Defaults to General.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (name, options) => {
+        await handleAsyncAction("tables create", options, () => requestOxygen("/api/cli/tables", {
+            method: "POST",
+            body: {
+                name,
+                columns: parseJsonArray(options.columnsJson),
+                ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
+            },
+        }));
+    }));
+    tablesCommand.addCommand(new Command("duplicate")
+        .description("Duplicate a workspace table. Copies row values unless --schema-only is set.")
+        .argument("<table>", "Source table id or slug.")
+        .option("--name <name>", "Display name for the duplicated table. Defaults to '<source> Copy'.")
+        .option("--schema-only", "Duplicate columns and definitions without copying row values.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables duplicate", options, () => requestOxygen(`/api/cli/tables/${encodeURIComponent(table)}/duplicate`, {
+            method: "POST",
+            body: {
+                ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+                ...(options.schemaOnly ? { include_rows: false } : {}),
+            },
+        }));
+    }));
+    tablesCommand.addCommand(new Command("insert")
+        .description("Insert rows into a workspace table. Table writes cost 0 Oxygen credits; paid column runs are separate.")
+        .argument("<table>", "Table id or slug.")
+        .requiredOption("--rows-json <json>", 'JSON array of row objects keyed by column key, e.g. [{"name":"Acme","domain":"acme.test"},{"name":"Globex","domain":"globex.test"}].')
+        .option("--request-id <id>", "Stable retry key. Reuse it after a timeout to return the committed write without duplicating rows.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables insert", options, () => requestOxygen("/api/cli/tables/rows", {
+            method: "POST",
+            body: {
+                table,
+                rows: parseJsonArray(options.rowsJson),
+                ...(readOption(options.requestId) ? { request_id: readOption(options.requestId) } : {}),
+            },
+        }));
+    }));
+    tablesCommand.addCommand(new Command("update")
+        .description("Update one workspace table row.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<row_id>", "Workspace row UUID.")
+        .requiredOption("--values-json <json>", "JSON object of values keyed by column key.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, rowId, options) => {
+        await handleAsyncAction("tables update", options, () => requestOxygen("/api/cli/tables/rows/update", {
+            method: "POST",
+            body: {
+                table,
+                row_id: rowId,
+                values: parseJsonObject(options.valuesJson),
+            },
+        }));
+    }));
+    tablesCommand.addCommand(new Command("delete-row")
+        .description("Delete one workspace table row. A lead enrolled in a campaign stays enrolled; the response names those campaigns.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<row_id>", "Workspace row UUID.")
+        .option("--metadata-json <json-or-file>", "Durable row deletion provenance.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, rowId, options) => {
+        await handleAsyncAction("tables delete-row", options, async () => {
+            const data = await requestOxygen("/api/cli/tables/rows/delete", {
+                method: "POST",
+                body: {
+                    table,
+                    row_id: rowId,
+                    ...(options.metadataJson !== undefined ? { metadata: parseJsonObject(readFileIfPresent(options.metadataJson)) } : {}),
+                },
+            });
+            if (!options.json)
+                writeRowDeleteWarnings(data);
+            return data;
+        });
+    }));
+    tablesCommand.addCommand(new Command("delete-rows")
+        .description("Delete exact workspace row IDs. For a matching filtered selection, use tables rows remove-selection. Campaign enrollments stay enrolled; the response names those campaigns.")
+        .addHelpText("after", "\nFor a matching filtered selection, use tables rows remove-selection --help.")
+        .argument("<table>", "Table id or slug.")
+        .option("--row-ids-json <json>", "JSON array of workspace row UUIDs.")
+        .option("--row-ids-file <path>", "File containing row UUIDs or rows with a _row_id column.")
+        .option("--row-id-column <key>", "Column to read from --row-ids-file. Defaults to _row_id.")
+        .option("--format <format>", "File format for --row-ids-file: json, jsonl, csv, or xlsx.")
+        .option("--sheet <name>", "Worksheet name when reading row IDs from an XLSX file.")
+        .option("--metadata-json <json-or-file>", "Durable row deletion provenance.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables delete-rows", options, async () => {
+            const rowIds = await readDeleteRowIdsOption(options);
+            const data = await requestOxygen("/api/cli/tables/rows/delete", {
+                method: "POST",
+                body: {
+                    table,
+                    row_ids: rowIds,
+                    ...(options.metadataJson !== undefined ? { metadata: parseJsonObject(readFileIfPresent(options.metadataJson)) } : {}),
+                },
+            });
+            if (!options.json)
+                writeRowDeleteWarnings(data);
+            return data;
+        });
+    }));
+    tablesCommand.addCommand(new Command("upsert")
+        .description("Insert or update rows in a workspace table by a column key.")
+        .argument("<table>", "Table id or slug.")
+        .requiredOption("--key <key>", "Column key used to match existing rows.")
+        .requiredOption("--rows-json <json>", "JSON array of row objects keyed by column key.")
+        .option("--return <mode>", "Response shape: summary, ids, or rows. Defaults to summary.")
+        .option("--dry-run", "Preview inserts, updates, duplicate keys, and field conflicts without writing rows.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables upsert", options, () => requestOxygen("/api/cli/tables/rows/upsert", {
+            method: "POST",
+            body: {
+                table,
+                key: options.key,
+                rows: parseJsonArray(options.rowsJson),
+                ...(readOption(options["return"]) ? { return: readOption(options["return"]) } : {}),
+                ...(options.dryRun ? { dry_run: true } : {}),
+            },
+        }));
+    }));
+}

package/dist/command-families/tables/register-views.d.ts

@@ -0,0 +1,2 @@
+import type { TablesRegistrationContext } from "./registration-context.js";
+export declare function registerViews({ tablesCommand, handleAsyncAction }: TablesRegistrationContext): void;

package/dist/command-families/tables/register-views.js

@@ -0,0 +1,83 @@
+import { readNonNegativeInt } from "../../cli-values.js";
+import { parseJsonValue } from "../../command-support.js";
+import { requestOxygen } from "../../http-client.js";
+import { readOption } from "../../util.js";
+import { Command } from "commander";
+export function registerViews({ tablesCommand, handleAsyncAction }) {
+    // One authoritative statement of the config shape, on the flag that stores
+    // it. The previous copy — "(filters, sorts, columns, group). Usually written
+    // by the app." — named the LEGACY key and disowned the flag; a blind-eval
+    // agent (2026-09-20) followed it, wrote {"group":{"columnKey":...}}, and got a
+    // board that grouped by accident. --group-by is the plain path; this is the
+    // full one, and it says which key is the grouping key.
+    const TABLE_VIEW_CONFIG_HELP = 'JSON view config, typed v2 shape: {"version":2,"groupBy":"<select column key>","filterTree":{...},"sorts":[{"columnKey":"...","direction":"asc|desc"}],"visibleColumns":["..."],"cardFields":["..."]}. '
+        + 'groupBy is the kanban group-by column (--group-by sets it for you); a complete board config is \'{"version":2,"groupBy":"lifecycle_stage"}\'. Malformed v2 is rejected with invalid_view_config.';
+    tablesCommand.addCommand(new Command("views")
+        .description("Create and manage saved table views (grid / kanban configurations).")
+        .addCommand(new Command("list")
+        .description("List a table's saved views.")
+        .argument("<table>", "Table id or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, options) => handleAsyncAction("tables views list", options, () => requestOxygen(`/api/cli/tables/${encodeURIComponent(table)}/views`))))
+        .addCommand(new Command("get")
+        .description("Get one saved view by id.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<view>", "View id.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, view, options) => handleAsyncAction("tables views get", options, () => requestOxygen(`/api/cli/tables/views?table=${encodeURIComponent(table)}&view=${encodeURIComponent(view)}`))))
+        .addCommand(new Command("create")
+        .description("Create a saved view.")
+        .argument("<table>", "Table id or slug.")
+        .requiredOption("--name <name>", "View name.")
+        .option("--view-type <type>", "table (grid) or kanban (board split into lanes by a select/status column). Defaults to table; --group-by implies kanban. A kanban created without --group-by is not refused: the board renders on the table's first groupable column and every read reports that fallback as effective_group_by plus a warning, so pin the column with --group-by.")
+        .option("--group-by <column>", "Kanban: the editable select/status column key the board splits on, e.g. --group-by lifecycle_stage. Unknown or non-groupable keys are refused with the groupable candidates. The response's effective_group_by is the column the board actually uses.")
+        .option("--config <json>", TABLE_VIEW_CONFIG_HELP)
+        .option("--default", "Make this the table's default view.")
+        .option("--no-default", "Clear this view's default status.")
+        .option("--position <n>", "Zero-based order among the table's saved views.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, options) => handleAsyncAction("tables views create", options, () => requestOxygen(`/api/cli/tables/${encodeURIComponent(table)}/views`, {
+        method: "POST",
+        body: {
+            name: readOption(options.name),
+            ...(readOption(options.viewType) ? { view_type: readOption(options.viewType) } : {}),
+            ...(readOption(options.groupBy) ? { group_by: readOption(options.groupBy) } : {}),
+            ...(readOption(options.config)
+                ? { config: parseJsonValue(readOption(options.config) ?? "", "--config") }
+                : {}),
+            ...(typeof options.default === "boolean" ? { is_default: options.default } : {}),
+            ...(readOption(options.position) !== null ? { position: readNonNegativeInt(options.position) } : {}),
+        },
+    }))))
+        .addCommand(new Command("update")
+        .description("Update a saved view.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<view>", "View id.")
+        .option("--name <name>", "Rename the view.")
+        .option("--view-type <type>", "table (grid) or kanban (board). A kanban whose config names no group column renders on the first groupable column; reads report that fallback as effective_group_by plus a warning.")
+        .option("--group-by <column>", "Kanban: change the select/status column the board splits on; folds into the stored config and keeps the rest of it. Refused for a grid view unless --view-type kanban is passed with it.")
+        .option("--config <json>", `${TABLE_VIEW_CONFIG_HELP} Replaces the stored config.`)
+        .option("--default", "Make this the table's default view.")
+        .option("--no-default", "Clear this view's default status.")
+        .option("--position <n>", "0-based order among the table's views.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, view, options) => handleAsyncAction("tables views update", options, () => requestOxygen(`/api/cli/tables/${encodeURIComponent(table)}/views/${encodeURIComponent(view)}`, {
+        method: "PATCH",
+        body: {
+            ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+            ...(readOption(options.viewType) ? { view_type: readOption(options.viewType) } : {}),
+            ...(readOption(options.groupBy) ? { group_by: readOption(options.groupBy) } : {}),
+            ...(readOption(options.config)
+                ? { config: parseJsonValue(readOption(options.config) ?? "", "--config") }
+                : {}),
+            ...(typeof options.default === "boolean" ? { is_default: options.default } : {}),
+            ...(readOption(options.position) ? { position: Number(readOption(options.position)) } : {}),
+        },
+    }))))
+        .addCommand(new Command("delete")
+        .description("Delete a saved view by id.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<view>", "View id.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, view, options) => handleAsyncAction("tables views delete", options, () => requestOxygen(`/api/cli/tables/${encodeURIComponent(table)}/views/${encodeURIComponent(view)}`, { method: "DELETE" })))));
+}

package/dist/command-families/tables/register-watchers.d.ts

@@ -0,0 +1,2 @@
+import type { TablesRegistrationContext } from "./registration-context.js";
+export declare function registerWatchers({ tablesCommand, handleAsyncAction }: TablesRegistrationContext): void;

package/dist/command-families/tables/register-watchers.js

@@ -0,0 +1,65 @@
+import { readPositiveNumber, parseJsonArray } from "../../command-support.js";
+import { requestOxygen } from "../../http-client.js";
+import { readOption } from "../../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+export function registerWatchers({ tablesCommand, handleAsyncAction }) {
+    const watcherCommand = tablesCommand.command("watcher")
+        .description("Professional Network Post Engagers: one editable table of daily engagers, source attribution, and current employers from posts in the past 7 days. Start with preview (free); create/resume activate paid daily monitoring after exact approval.");
+    watcherCommand.command("get")
+        .description("Read a table's Professional Network Post Engagers configuration and status. Free.")
+        .argument("<table>", "Watcher table id or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables watcher get", options, () => requestOxygen(`/api/cli/tables/linkedin-profile-watcher?table=${encodeURIComponent(table)}`, { method: "GET" }));
+    });
+    for (const action of ["preview", "create", "update", "pause", "resume"]) {
+        const command = watcherCommand.command(action)
+            .description({
+            preview: "Free configuration and credit preview: no provider calls, writes, or scheduling. Omit --max-credits for a recommendation and preview hash. Ask for real profile URLs; never invent them.",
+            create: "Create and activate a Professional Network Post Engagers table after approval of its exact preview. Starts collection now and daily at 07:00 UTC under the approved per-cycle cap.",
+            update: "Edit watched profiles or the per-cycle cap from the table. Preview the changes first; approval binds the exact new configuration.",
+            pause: "Pause daily monitoring while retaining the table and collected rows.",
+            resume: "Resume paid daily monitoring after reviewing a fresh preview and approving its per-cycle credit cap.",
+        }[action])
+            .option("--table <table>", "Existing watcher table id or slug; required for get/update/pause/resume.")
+            .option("--json", "Print a JSON envelope.");
+        if (action !== "pause") {
+            command
+                .option("--name <name>", "Watcher table display name.")
+                .option("--project <project>", "Project id or slug; defaults to General.")
+                .option("--profiles-json <json>", "JSON array of 1–10 real public LinkedIn profile URLs; replaces the watched list.")
+                .option("--max-credits <credits>", "Hard credit ceiling for each daily cycle; never a monthly ceiling.")
+                .option("--credential-mode <mode>", "managed (default): Oxygen credits per cycle. user_api_key: every LinkedIn call runs on your own Up2Data key saved in Connections, billed by Up2Data; Oxygen charges only its own-key platform fee per successful call.");
+            if (action !== "preview")
+                command
+                    .option("--preview-hash <hash>", "Exact configuration hash returned by preview; re-preview after any change.")
+                    .option("--approved", "Approve this exact configuration and recurring per-cycle spending.");
+        }
+        if (action === "create") {
+            command.requiredOption("--request-id <uuid>", "One stable UUID for this new watcher. Reuse it and the identical configuration after a timeout; never generate a new retry key.");
+        }
+        command.action(async (options) => {
+            await handleAsyncAction(`tables watcher ${action}`, options, () => {
+                const profiles = options.profilesJson === undefined ? undefined : parseJsonArray(options.profilesJson);
+                if (profiles !== undefined && profiles.some((profile) => typeof profile !== "string")) {
+                    throw new OxygenError("invalid_input", "--profiles-json must be an array of LinkedIn profile URL strings.");
+                }
+                return requestOxygen("/api/cli/tables/linkedin-profile-watcher", {
+                    method: "POST",
+                    body: {
+                        action,
+                        ...(readOption(options.table) ? { table: readOption(options.table) } : {}),
+                        ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+                        ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
+                        ...(profiles !== undefined ? { profiles } : {}),
+                        ...(options.maxCredits !== undefined ? { max_credits_per_cycle: readPositiveNumber(options.maxCredits) } : {}),
+                        ...(readOption(options.requestId) ? { request_id: readOption(options.requestId) } : {}),
+                        ...(readOption(options.previewHash) ? { preview_hash: readOption(options.previewHash) } : {}),
+                        ...(options.approved ? { approved: true } : {}),
+                        ...(readOption(options.credentialMode) ? { credential_mode: readOption(options.credentialMode) } : {}),
+                    },
+                });
+            });
+        });
+    }
+}

package/dist/command-families/tables/register-webhooks.d.ts

@@ -0,0 +1,2 @@
+import type { TablesRegistrationContext } from "./registration-context.js";
+export declare function registerWebhooks({ tablesCommand, handleAsyncAction }: TablesRegistrationContext): void;

package/dist/command-families/tables/register-webhooks.js

@@ -0,0 +1,126 @@
+import { tableWebhookDeliveriesPath } from "../../command-support.js";
+import { requestOxygen } from "../../http-client.js";
+import { readOption } from "../../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command, Option } from "commander";
+import { TABLE_WEBHOOK_RATE_HELP, readTableWebhookAutoRunOptions, tableWebhookListPath } from "./automation.js";
+export function registerWebhooks({ tablesCommand, handleAsyncAction }) {
+    tablesCommand.addCommand(new Command("webhook")
+        .description("Create and manage direct table webhooks.")
+        .addCommand(new Command("list")
+        .description("List direct table webhooks.")
+        .argument("[table]", "Optional table id or slug.")
+        .option("--status <status>", "Filter by active or disabled.")
+        .option("--limit <n>", "Maximum webhooks to return. Defaults to 100.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, options) => handleAsyncAction("tables webhook list", options, () => requestOxygen(tableWebhookListPath({
+        table: table ?? options.table,
+        status: options.status,
+        limit: options.limit,
+    })))))
+        .addCommand(new Command("get")
+        .description("Get one direct table webhook by endpoint id.")
+        .argument("<endpoint_id>", "Webhook endpoint id, such as tw_...")
+        .option("--json", "Print a JSON envelope.")
+        .action((endpointId, options) => handleAsyncAction("tables webhook get", options, () => {
+        const params = new URLSearchParams({ endpoint_id: endpointId });
+        return requestOxygen(`/api/cli/tables/webhooks?${params.toString()}`);
+    })))
+        .addCommand(new Command("create")
+        .description(`Create a direct webhook endpoint that writes inbound JSON into a table (${TABLE_WEBHOOK_RATE_HELP}).`)
+        .argument("<table>", "Table id or slug.")
+        .option("--name <name>", "Display name for the webhook.")
+        .option("--mode <mode>", "insert or upsert. Defaults to upsert when --upsert-key is set, otherwise insert.")
+        .option("--auth-mode <mode>", "none or secret. Defaults to none; use secret when the sender can include an Oxygen webhook secret.")
+        .option("--upsert-key <key>", "Column key used to upsert rows. Required for upsert mode.")
+        .option("--items-path <path>", "Dot path to an array of row objects in the webhook payload.")
+        .option("--event-id-path <path>", "Dot path to the event id. Defaults to event_id, eventId, id, or payload hash.")
+        .option("--event-type-path <path>", "Dot path to the event type. Defaults to type or event.")
+        .option("--occurred-at-path <path>", "Dot path to the event timestamp.")
+        .option("--source <source>", "http (default) writes inbound JSON anyone can POST. unipile subscribes the table to your connected LinkedIn/WhatsApp accounts' events instead — no endpoint URL, no secret to share, and 0 credits: rows appear as the events reach Oxygen.")
+        .option("--account <unipile_account_id>", "unipile source only. Listen to ONE connected account. Omit to listen to every connected account in the workspace.")
+        .option("--events <csv>", "unipile source only. Comma-separated event types, e.g. relation.new,message.new. Omit for every event the receiver handles. Post reactions, post comments, profile viewers and followers are NOT pushed by the provider — capture those with a scheduled feed (`oxygen feeds bind`).")
+        .option("--mapping <mapping>", "unipile source only. curated (default) flattens known events into stable named columns; passthrough lands the raw provider event so you can map any type yourself.")
+        .option("--auto-run-columns <csv>", "Comma-separated enrichment, tool, AI, or formula columns to queue for webhook-written rows.")
+        .option("--auto-run-max-credits <n>", "Credit ceiling per webhook-triggered auto-run batch; items beyond it are skipped with credit_limit_reached. Defaults to your plan's per-delivery ceiling when omitted.")
+        .option("--auto-run-max-concurrency <n>", "Maximum concurrent row items for webhook-triggered auto-runs.")
+        .option("--auto-run-force", "Run auto-run columns even when the target cell already has a value.")
+        .option("--auto-run-connection-id <connection_id>", "Optional provider integration connection id for auto-runs.")
+        .addOption(new Option("--auto-run-approved", "Deprecated no-op. Auto-run is enabled by --auto-run-columns.").hideHelp())
+        .option("--json", "Print a JSON envelope.")
+        .action((table, options) => {
+        const autoRun = readTableWebhookAutoRunOptions(options);
+        const unipile = readOption(options.source) === "unipile";
+        return handleAsyncAction("tables webhook create", options, () => requestOxygen("/api/cli/tables/webhooks", {
+            method: "POST",
+            body: {
+                table,
+                ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+                ...(readOption(options.mode) ? { mode: readOption(options.mode) } : {}),
+                ...(readOption(options.authMode) ? { auth_mode: readOption(options.authMode) } : {}),
+                ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
+                ...(readOption(options.itemsPath) ? { items_path: readOption(options.itemsPath) } : {}),
+                ...(readOption(options.eventIdPath) ? { event_id_path: readOption(options.eventIdPath) } : {}),
+                ...(readOption(options.eventTypePath) ? { event_type_path: readOption(options.eventTypePath) } : {}),
+                ...(readOption(options.occurredAtPath) ? { occurred_at_path: readOption(options.occurredAtPath) } : {}),
+                ...(unipile
+                    ? {
+                        feed_kind: "unipile",
+                        ...(readOption(options.account) ? { unipile_account_id: readOption(options.account) } : {}),
+                        ...(readOption(options.events) ? { event_types: readOption(options.events) } : {}),
+                        ...(readOption(options.mapping) ? { mapping: readOption(options.mapping) } : {}),
+                    }
+                    : {}),
+                ...(autoRun ? { auto_run: autoRun } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("update")
+        .description("Update a direct table webhook endpoint.")
+        .argument("<endpoint_id>", "Webhook endpoint id, such as tw_...")
+        .option("--name <name>", "Update the webhook display name.")
+        .option("--status <status>", "active or disabled.")
+        .option("--auth-mode <mode>", "none or secret. Setting secret rotates and returns a new webhook secret.")
+        .option("--auto-run-columns <csv>", "Comma-separated enrichment, tool, AI, or formula columns to queue for webhook-written rows.")
+        .option("--auto-run-max-credits <n>", "Credit ceiling per webhook-triggered auto-run batch; items beyond it are skipped with credit_limit_reached. Defaults to your plan's per-delivery ceiling when omitted.")
+        .option("--auto-run-max-concurrency <n>", "Maximum concurrent row items for webhook-triggered auto-runs.")
+        .option("--auto-run-force", "Run auto-run columns even when the target cell already has a value.")
+        .option("--auto-run-connection-id <connection_id>", "Optional provider integration connection id for auto-runs.")
+        .addOption(new Option("--auto-run-approved", "Deprecated no-op. Auto-run is enabled by --auto-run-columns.").hideHelp())
+        .option("--clear-auto-run", "Remove the webhook auto-run configuration.")
+        .option("--json", "Print a JSON envelope.")
+        .action((endpointId, options) => {
+        const autoRun = readTableWebhookAutoRunOptions(options);
+        if (autoRun && options.clearAutoRun) {
+            throw new OxygenError("invalid_table_webhook", "Pass either auto-run options or --clear-auto-run, not both.", {
+                exitCode: 1,
+            });
+        }
+        return handleAsyncAction("tables webhook update", options, () => requestOxygen("/api/cli/tables/webhooks", {
+            method: "PATCH",
+            body: {
+                endpoint_id: endpointId,
+                ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+                ...(readOption(options.status) ? { status: readOption(options.status) } : {}),
+                ...(readOption(options.authMode) ? { auth_mode: readOption(options.authMode) } : {}),
+                ...(autoRun ? { auto_run: autoRun } : {}),
+                ...(options.clearAutoRun ? { clear_auto_run: true } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("deliveries")
+        .description("List direct table webhook deliveries and auto-run enqueue status.")
+        .argument("[endpoint_id]", "Optional webhook endpoint id, such as tw_...")
+        .option("--table <table>", "Filter by table id or slug.")
+        .option("--status <status>", "Filter by received, completed, failed, or rejected (rejected = arrived while the feed was paused and was turned away; no rows written). A delivery refused with HTTP 429 for exceeding the plan's rate is not recorded here: the sender redelivers it.")
+        .option("--auto-run-status <status>", "Filter by not_configured, queued, skipped, or failed_to_enqueue.")
+        .option("--limit <n>", "Maximum deliveries to return. Defaults to 50.")
+        .option("--json", "Print a JSON envelope.")
+        .action((endpointId, options) => handleAsyncAction("tables webhook deliveries", options, () => requestOxygen(tableWebhookDeliveriesPath({
+        endpointId,
+        table: options.table,
+        status: options.status,
+        autoRunStatus: options.autoRunStatus,
+        limit: options.limit,
+    }))))));
+}

package/dist/command-families/tables/registration-context.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from "commander";
+import type { ExtractedCommandActionHandler } from "../../command-support.js";
+/** The actual command parent, shared action/error boundary and executable name. */
+export type TablesRegistrationContext = {
+    tablesCommand: Command;
+    handleAsyncAction: ExtractedCommandActionHandler;
+    binaryName: any;
+};

package/dist/command-families/tables/registration-context.js

@@ -0,0 +1 @@
+export {};

package/dist/command-families/tables/registration.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+import type { ExtractedCommandActionHandler } from "../../command-support.js";
+export declare function registerTablesFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler, binaryName: any): void;

package/dist/command-families/tables/registration.js

@@ -0,0 +1,30 @@
+import { registerExternalImports } from "./register-external-imports.js";
+import { registerRowWrites } from "./register-row-writes.js";
+import { registerFiles } from "./register-files.js";
+import { registerReads } from "./register-reads.js";
+import { registerLifecycle } from "./register-lifecycle.js";
+import { registerWatchers } from "./register-watchers.js";
+import { registerFollowers } from "./register-followers.js";
+import { registerRelations } from "./register-relations.js";
+import { registerRowActions } from "./register-row-actions.js";
+import { registerWebhooks } from "./register-webhooks.js";
+import { registerViews } from "./register-views.js";
+import { registerAutomation } from "./register-automation.js";
+export function registerTablesFamily(program, handleAsyncAction, binaryName) {
+    const tablesCommand = program
+        .command("tables")
+        .description("Tenant workspace tables: create, import rows (CSV, a link, a HubSpot saved list, a Pipedrive saved filter, Supabase), enrich with columns, and run them. `tables sources` lists every way a table can start.");
+    const context = { tablesCommand, handleAsyncAction, binaryName };
+    registerExternalImports(context);
+    registerRowWrites(context);
+    registerFiles(context);
+    registerReads(context);
+    registerLifecycle(context);
+    registerWatchers(context);
+    registerFollowers(context);
+    registerRelations(context);
+    registerRowActions(context);
+    registerWebhooks(context);
+    registerViews(context);
+    registerAutomation(context);
+}

package/dist/command-families/tables/row-selection.d.ts

@@ -0,0 +1,5 @@
+import { TablesDeleteRowsOptions } from "./options.js";
+export declare function readDeleteRowIdsOption(options: TablesDeleteRowsOptions): Promise<string[]>;
+export declare function tryParseJsonStringArray(value: string): string[] | null;
+export declare function parsePlainRowIdList(value: string): string[];
+export declare function normalizeDeleteRowIds(values: unknown[]): string[];

package/dist/command-families/tables/row-selection.js

@@ -0,0 +1,82 @@
+import { parseJsonArray } from "../../command-support.js";
+import { readOption } from "../../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { normalizeRowsFormat, inferRowsFileFormat, parseRowsFileBuffer } from "@oxygen/shared/file-import";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+export async function readDeleteRowIdsOption(options) {
+    const rowIdsJson = readOption(options.rowIdsJson);
+    const rowIdsFile = readOption(options.rowIdsFile);
+    if (rowIdsJson && rowIdsFile) {
+        throw new OxygenError("invalid_request", "Pass either --row-ids-json or --row-ids-file, not both.", {
+            exitCode: 1,
+        });
+    }
+    if (!rowIdsJson && !rowIdsFile) {
+        throw new OxygenError("invalid_request", "Pass --row-ids-json or --row-ids-file.", {
+            exitCode: 1,
+        });
+    }
+    if (rowIdsJson)
+        return normalizeDeleteRowIds(parseJsonArray(rowIdsJson));
+    const filePath = resolve(rowIdsFile ?? "");
+    const buffer = readFileSync(filePath);
+    const format = normalizeRowsFormat(options.format, inferRowsFileFormat(filePath));
+    if (format === "json") {
+        const text = buffer.toString("utf8");
+        const inlineIds = tryParseJsonStringArray(text);
+        if (inlineIds)
+            return normalizeDeleteRowIds(inlineIds);
+        if (!options.format && !text.trimStart().startsWith("[")) {
+            return normalizeDeleteRowIds(parsePlainRowIdList(text));
+        }
+    }
+    const sheet = readOption(options.sheet);
+    const rows = await parseRowsFileBuffer(buffer, format, sheet ? { sheet } : {});
+    const rowIdColumn = readOption(options.rowIdColumn) ?? "_row_id";
+    return normalizeDeleteRowIds(rows.map((row, index) => {
+        const value = row[rowIdColumn];
+        if (typeof value !== "string" || !value.trim()) {
+            throw new OxygenError("invalid_request", `Row id column "${rowIdColumn}" must contain row UUID strings.`, {
+                details: { row_number: index + 1, column: rowIdColumn },
+                exitCode: 1,
+            });
+        }
+        return value.trim();
+    }));
+}
+export function tryParseJsonStringArray(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(parsed) || !parsed.every((entry) => typeof entry === "string"))
+        return null;
+    return parsed;
+}
+export function parsePlainRowIdList(value) {
+    return value
+        .split(/[\n,]/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+export function normalizeDeleteRowIds(values) {
+    const rowIds = values.map((value, index) => {
+        if (typeof value !== "string" || !value.trim()) {
+            throw new OxygenError("invalid_request", "Row IDs must be non-empty strings.", {
+                details: { index },
+                exitCode: 1,
+            });
+        }
+        return value.trim();
+    });
+    if (rowIds.length === 0) {
+        throw new OxygenError("invalid_request", "Row ID list cannot be empty.", {
+            exitCode: 1,
+        });
+    }
+    return rowIds;
+}

package/dist/command-families/tables/send.d.ts

@@ -0,0 +1,6 @@
+import { TablesSendOptions } from "./options.js";
+export declare function buildTablesSendRequest(source: string, target: string, options: TablesSendOptions): Record<string, unknown>;
+export declare function parseTablesSendMapping(options: TablesSendOptions): Array<Record<string, unknown>> | null;
+export declare function parseTablesSendFilters(value: string | undefined): Array<Record<string, unknown>> | null;
+export declare function normalizeTablesSendMode(value: string | undefined): "insert" | "upsert";
+export declare function writeTablesSendHint(data: unknown): void;