@oxygen-agent/cli 1.131.7 → 1.138.0

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation and support, visit https://oxygen-agent.com.
 
-Version: 1.131.7
+Version: 1.138.0

package/dist/index.js

@@ -8,7 +8,7 @@ import { basename, dirname, extname, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { formatCellForDisplay, OXYGEN_VERSION, OxygenError, success, toFailure } from "@oxygen/shared";
 import { inferRowsFileFormat, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, } from "@oxygen/shared/file-import";
 import { assertRecipeBundleSafe, assertWorkflowManifest, buildRecipeManifest, compileWorkflowDefinition, isAnyWorkflowManifest, isRecipeManifest, isWorkflowDefinition, isWorkflowManifest, } from "@oxygen/workflows";
@@ -725,11 +725,12 @@ export function createProgram() {
         .argument("<table>", "Table id or slug.")
         .option("--limit <n>", "Maximum preview rows to return. Defaults to 25; hard cap is 1000.")
         .option("--fields <columns>", "Comma-separated column keys or ids to include.")
+        .option("--include-system-fields", "Include _row_id, _created_at, and _updated_at in preview rows.")
         .option("--include-cell-states", "Include per-cell run state in the preview response.")
         .option("--summary-only", "Return table metadata and stats without row JSON.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables preview", options, async () => {
+        await handleAsyncAction("tables preview", options, () => {
             const limit = readPositiveInt(options.limit);
             return requestOxygen("/api/cli/tables/preview", {
                 method: "POST",
@@ -737,6 +738,7 @@ export function createProgram() {
                     table,
                     ...(limit ? { limit } : {}),
                     ...(readOption(options.fields) ? { fields: readCsvOption(options.fields) } : {}),
+                    ...(options.includeSystemFields ? { include_system_fields: true } : {}),
                     ...(options.includeCellStates ? { include_cell_states: true } : {}),
                     ...(options.summaryOnly ? { summary_only: true } : {}),
                 },
@@ -808,31 +810,52 @@ export function createProgram() {
     }));
     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.")
         .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("--auto-run-columns <csv>", "Comma-separated enrichment, tool, AI, or formula columns to queue for webhook-written rows.")
-        .option("--auto-run-max-credits <n>", "Approved credit safety ceiling for webhook-triggered paid auto-runs.")
+        .addOption(new Option("--auto-run-max-credits <n>", "Deprecated optional safety ceiling for webhook-triggered auto-runs.").hideHelp())
         .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.")
-        .option("--auto-run-approved", "Approve this webhook to queue the configured auto-run columns for rows it writes.")
+        .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(async (table, options) => {
+        .action((table, options) => {
         const autoRun = readTableWebhookAutoRunOptions(options);
-        await handleAsyncAction("tables webhook create", options, async () => requestOxygen("/api/cli/tables/webhooks", {
+        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) } : {}),
@@ -845,23 +868,51 @@ export function createProgram() {
         .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>", "Approved credit safety ceiling for webhook-triggered paid auto-runs.")
+        .addOption(new Option("--auto-run-max-credits <n>", "Deprecated optional safety ceiling for webhook-triggered auto-runs.").hideHelp())
         .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.")
-        .option("--auto-run-approved", "Approve this webhook to queue the configured auto-run columns for rows it writes.")
+        .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(async (endpointId, options) => {
+        .action((endpointId, options) => {
         const autoRun = readTableWebhookAutoRunOptions(options);
-        await handleAsyncAction("tables webhook update", options, async () => requestOxygen("/api/cli/tables/webhooks", {
+        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, or failed.")
+        .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,
+    }))))));
     program
         .command("context")
         .description("Workspace-level GTM context commands.")
@@ -2099,7 +2150,7 @@ export function createProgram() {
         .option("--route-id <id>", "Route id from the plan to execute.")
         .option("--tool-id <tool>", "Tool id from the plan to execute.")
         .option("--table <table>", "Existing table id or slug to receive rows. If omitted for live, Oxygen creates a table.")
-        .option("--upsert-key <column>", "Column key used for live upsert. Defaults to the plan upsert key, usually domain.")
+        .option("--upsert-key <column>", "Column key used for live upsert. Must match the plan upsert key, usually domain.")
         .option("--mode <mode>", "dry_run or live. Defaults to dry_run.")
         .option("--max-pages <n>", "Maximum provider pages to ingest. Defaults to the route estimate.")
         .option("--max-credits <n>", "Required credit ceiling for live runs.")
@@ -3628,6 +3679,40 @@ function normalizeWorkflowRunErrors(value) {
 function isTerminalWorkflowRunStatus(status) {
     return status === "completed" || status === "failed" || status === "canceled";
 }
+function tableWebhookListPath(options) {
+    const params = new URLSearchParams();
+    const table = readOption(options.table);
+    const status = readOption(options.status);
+    const limit = readPositiveInt(options.limit);
+    if (table)
+        params.set("table", table);
+    if (status)
+        params.set("status", status);
+    if (limit)
+        params.set("limit", String(limit));
+    const query = params.toString();
+    return `/api/cli/tables/webhooks${query ? `?${query}` : ""}`;
+}
+function tableWebhookDeliveriesPath(options) {
+    const params = new URLSearchParams();
+    const endpointId = readOption(options.endpointId);
+    const table = readOption(options.table);
+    const status = readOption(options.status);
+    const autoRunStatus = readOption(options.autoRunStatus);
+    const limit = readPositiveInt(options.limit);
+    if (endpointId)
+        params.set("endpoint_id", endpointId);
+    if (table)
+        params.set("table", table);
+    if (status)
+        params.set("status", status);
+    if (autoRunStatus)
+        params.set("auto_run_status", autoRunStatus);
+    if (limit)
+        params.set("limit", String(limit));
+    const query = params.toString();
+    return `/api/cli/tables/webhooks/deliveries${query ? `?${query}` : ""}`;
+}
 function readTableWebhookAutoRunOptions(options) {
     const columns = readCsvOption(options.autoRunColumns);
     const requested = columns.length > 0
@@ -3647,7 +3732,6 @@ function readTableWebhookAutoRunOptions(options) {
     const maxConcurrency = readPositiveInt(options.autoRunMaxConcurrency);
     return {
         columns,
-        approved: Boolean(options.autoRunApproved),
         ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
         ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
         ...(options.autoRunForce ? { force: true } : {}),

package/node_modules/@oxygen/shared/dist/log.js

@@ -24,9 +24,12 @@ export function log(level, msg, fields) {
             ...fields,
         }),
     });
-    if (level === "error" || level === "warn") {
+    if (level === "error") {
         console.error(line);
     }
+    else if (level === "warn") {
+        console.warn(line);
+    }
     else {
         console.log(line);
     }

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

@@ -1,2 +1,2 @@
-export declare const OXYGEN_VERSION = "1.131.7";
-export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.0.0";
+export declare const OXYGEN_VERSION = "1.138.0";
+export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.135.0";

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

@@ -1,3 +1,3 @@
-export const OXYGEN_VERSION = "1.131.7";
+export const OXYGEN_VERSION = "1.138.0";
 // Bump this only when deployed CLI/API contracts require a newer CLI.
-export const OXYGEN_MINIMUM_CLI_VERSION = "1.0.0";
+export const OXYGEN_MINIMUM_CLI_VERSION = "1.135.0";

package/package.json

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