@oxygen-agent/cli 1.128.5 → 1.134.0

package/README.md

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

package/dist/http-client.d.ts

@@ -1,6 +1,6 @@
 import { type StoredCredentials } from "./credentials.js";
 type RequestOptions = {
-    method?: "GET" | "POST" | "DELETE";
+    method?: "GET" | "POST" | "PATCH" | "DELETE";
     body?: Record<string, unknown>;
     formData?: FormData;
     credentials?: StoredCredentials;

package/dist/index.js

@@ -808,32 +808,109 @@ 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>", "secret or none. Defaults to secret; use none only for public provider webhooks that cannot send auth headers.")
         .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("--json", "Print a JSON envelope.")
-        .action(async (table, options) => {
-        await handleAsyncAction("tables webhook create", options, async () => requestOxygen("/api/cli/tables/webhooks", {
+        .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.")
+        .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.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, options) => {
+        const autoRun = readTableWebhookAutoRunOptions(options);
+        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) } : {}),
+                ...(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>", "secret or none. 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.")
+        .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.")
+        .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, 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.")
@@ -2071,12 +2148,12 @@ 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. 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.")
         .option("--target-count <n>", "Desired company count when planning from --prompt.")
         .option("--source-intent <intent>", "Override detected intent when planning from --prompt.")
-        .option("--preflight-complete", "Confirm required descriptor, count, enum, or provider-specific preflight checks before live mode.")
         .option("--approved", "Required for live runs after inspecting dry-run output.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -2264,7 +2341,7 @@ export function createProgram() {
         .description("Inspect and retry durable signup lead webhook deliveries.")
         .addCommand(new Command("list")
         .description("List signup lead webhook deliveries for the current organization.")
-        .option("--status <status>", "Filter by pending, running, succeeded, retrying, failed, or dead.")
+        .option("--status <status>", "Filter by pending, running, succeeded, skipped, retrying, failed, or dead.")
         .option("--limit <n>", "Maximum deliveries to return. Defaults to 50.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -3600,6 +3677,66 @@ 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
+        || options.autoRunMaxCredits !== undefined
+        || options.autoRunMaxConcurrency !== undefined
+        || Boolean(options.autoRunForce)
+        || options.autoRunConnectionId !== undefined
+        || Boolean(options.autoRunApproved);
+    if (!requested)
+        return null;
+    if (columns.length === 0) {
+        throw new OxygenError("invalid_table_webhook", "Pass --auto-run-columns when configuring webhook auto-runs.", {
+            exitCode: 1,
+        });
+    }
+    const maxCredits = readPositiveNumber(options.autoRunMaxCredits);
+    const maxConcurrency = readPositiveInt(options.autoRunMaxConcurrency);
+    return {
+        columns,
+        approved: Boolean(options.autoRunApproved),
+        ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+        ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
+        ...(options.autoRunForce ? { force: true } : {}),
+        ...(readOption(options.autoRunConnectionId) ? { connection_id: readOption(options.autoRunConnectionId) } : {}),
+    };
+}
 function readTableRunActions(options) {
     if (options.actionsJson && readOption(options.column)) {
         throw new OxygenError("invalid_table_run", "Pass either --actions-json or --column, not both.", {
@@ -3728,13 +3865,13 @@ function readCompaniesSearchRunBody(options) {
         ...(options.routeId ? { route_id: options.routeId } : {}),
         ...(options.toolId ? { tool_id: options.toolId } : {}),
         ...(options.table ? { table: options.table } : {}),
+        ...(options.upsertKey ? { upsert_key: options.upsertKey } : {}),
         ...(options.mode ? { mode: options.mode } : {}),
         ...(maxPages !== undefined ? { max_pages: maxPages } : {}),
         ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
         ...(targetCount !== undefined ? { target_count: targetCount } : {}),
         ...(options.sourceIntent ? { source_intent: options.sourceIntent } : {}),
         ...(options.approved ? { approved: true } : {}),
-        ...(options.preflightComplete ? { preflight_complete: true } : {}),
     };
 }
 function readCompanySearchPlanJson(value) {

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

@@ -14,7 +14,7 @@ export function log(level, msg, fields) {
         ts: new Date().toISOString(),
         level,
         msg,
-        service_name: process.env.OTEL_SERVICE_NAME ?? process.env.OXYGEN_SERVICE_NAME ?? null,
+        service_name: process.env.OXYGEN_SERVICE_NAME ?? process.env.OTEL_SERVICE_NAME ?? null,
         oxygen_version: OXYGEN_VERSION,
         sha: process.env.VERCEL_GIT_COMMIT_SHA ?? null,
         region: process.env.VERCEL_REGION ?? null,
@@ -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/telemetry.js

@@ -55,14 +55,27 @@ export function recordTelemetryHistogram(name, value, attributes) {
     histogram.record(value, normalizeTelemetryAttributes(commonTelemetryAttributes(attributes)));
 }
 export function commonTelemetryAttributes(attributes) {
+    const workerProcess = isWorkerProcess();
     return {
         "oxygen.version": OXYGEN_VERSION,
-        "deployment.environment": process.env.VERCEL_ENV ?? process.env.NODE_ENV ?? null,
-        "deployment.sha": process.env.VERCEL_GIT_COMMIT_SHA ?? process.env.FLY_IMAGE_REF ?? null,
-        "cloud.region": process.env.VERCEL_REGION ?? process.env.FLY_REGION ?? null,
+        "deployment.environment": workerProcess
+            ? process.env.FLY_ENVIRONMENT ?? process.env.NODE_ENV ?? null
+            : process.env.VERCEL_ENV ?? process.env.NODE_ENV ?? null,
+        "deployment.sha": workerProcess
+            ? process.env.FLY_IMAGE_REF ?? process.env.VERCEL_GIT_COMMIT_SHA ?? null
+            : process.env.VERCEL_GIT_COMMIT_SHA ?? process.env.FLY_IMAGE_REF ?? null,
+        "cloud.region": workerProcess
+            ? process.env.FLY_REGION ?? process.env.VERCEL_REGION ?? null
+            : process.env.VERCEL_REGION ?? process.env.FLY_REGION ?? null,
         ...attributes,
     };
 }
+function isWorkerProcess() {
+    if (process.env.OXYGEN_PROCESS_ROLE === "worker")
+        return true;
+    const flyApp = process.env.FLY_APP_NAME ?? process.env.FLY_APP ?? "";
+    return flyApp.includes("oxygen-table-worker");
+}
 function getMeter() {
     return metrics.getMeter("oxygen", OXYGEN_VERSION);
 }

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

@@ -1,2 +1,2 @@
-export declare const OXYGEN_VERSION = "1.128.5";
+export declare const OXYGEN_VERSION = "1.134.0";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.0.0";

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

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

package/package.json

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