@oxygen-agent/cli 1.45.4 → 1.50.37

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { execFileSync, spawnSync } from "node:child_process";
+// skipcq: JS-0271 — bin entry source; build chmod+x on dist/index.js
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -8,7 +9,7 @@ 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 { OXYGEN_VERSION, OxygenError, success, toFailure } from "@oxygen/shared";
+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";
 import { isRecipeDefinition } from "@oxygen/recipe-sdk";
@@ -17,6 +18,7 @@ import { clearCredentials, defaultApiUrl, listCredentialProfiles, normalizeApiUr
 import { requestOxygen } from "./http-client.js";
 import { runLocalCustomHttpColumn } from "./local-custom-http-column.js";
 import { addSessionOutput, addSessionStatus, getSessionUsage, startSession, updateSessionStep, } from "./session.js";
+import { updateCli } from "./update.js";
 const BROWSER_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 const OXYGEN_SPINNER_INTERVAL_MS = 90;
 const OXYGEN_SPINNER_FRAMES = [
@@ -43,7 +45,6 @@ const TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS = 600;
 const TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS = 5;
 const WORKFLOW_TAIL_DEFAULT_TIMEOUT_SECONDS = 600;
 const WORKFLOW_TAIL_DEFAULT_INTERVAL_SECONDS = 2;
-const DEFAULT_CLI_PACKAGE_SPEC = "@oxygen-agent/cli@latest";
 const CLI_MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 const RECIPE_ESBUILD_NODE_PATHS = [
     resolve("node_modules"),
@@ -227,6 +228,36 @@ export function createProgram() {
         .action(async (options) => {
         await handleUpdateAction(options);
     });
+    program
+        .command("api-keys")
+        .description("Manage Oxygen CLI API keys for the current organization.")
+        .addCommand(new Command("list")
+        .description("List active CLI API keys for the current user and organization.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("api-keys list", options, async () => requestOxygen("/api/cli/api-keys"));
+    }))
+        .addCommand(new Command("create")
+        .description("Create a CLI API key. The token is shown once.")
+        .option("--name <name>", "Key name. Defaults to 'CLI key'.")
+        .option("--expires-at <iso>", "Expiration timestamp as ISO 8601.")
+        .option("--expires-in-days <days>", "Expire the key after this many days.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("api-keys create", options, async () => requestOxygen("/api/cli/api-keys", {
+            method: "POST",
+            body: buildApiKeyCreateBody(options),
+        }));
+    }))
+        .addCommand(new Command("revoke")
+        .description("Revoke a CLI API key for the current user and organization.")
+        .argument("<key-id>", "CLI API key id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (keyId, options) => {
+        await handleAsyncAction("api-keys revoke", options, async () => requestOxygen(`/api/cli/api-keys/${encodeURIComponent(keyId)}`, {
+            method: "DELETE",
+        }));
+    }));
     program
         .command("whoami")
         .description("Show the current Oxygen CLI identity.")
@@ -488,9 +519,9 @@ export function createProgram() {
         await handleAsyncAction("tables import", options, async () => importRows(table, options));
     }))
         .addCommand(new Command("export")
-        .description("Export workspace table rows as JSON, JSONL, or CSV.")
+        .description("Export workspace table rows as JSON, JSONL, CSV, or a human-readable table.")
         .argument("<table>", "Table id or slug.")
-        .option("--format <format>", "json, jsonl, or csv. Defaults to json.")
+        .option("--format <format>", "json, jsonl, csv, or table. Defaults to json. Use table for a typed, human-readable rendering with thousands grouping.")
         .option("--output <path>", "Write export content to a file.")
         .option("--limit <n>", "Maximum rows to export. Defaults to 100; hard cap is 1000.")
         .option("--json", "Print a JSON envelope.")
@@ -587,6 +618,17 @@ export function createProgram() {
             method: "POST",
             body: { table },
         }));
+    }))
+        .addCommand(new Command("move")
+        .description("Move a workspace table to a different project.")
+        .argument("<table>", "Table id or slug.")
+        .requiredOption("--project <project>", "Destination project id or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables move", options, async () => requestOxygen("/api/cli/tables/move", {
+            method: "POST",
+            body: { table, project: options.project },
+        }));
     }));
     tablesCommand.addCommand(new Command("webhook")
         .description("Create and manage direct table webhooks.")
@@ -691,6 +733,139 @@ export function createProgram() {
             body: { id: assetId },
         }));
     })));
+    program
+        .command("templates")
+        .description("Reusable prompt templates layered into AI columns at run time.")
+        .addCommand(new Command("list")
+        .description("List prompt templates in the workspace.")
+        .option("--kind <kind>", "Filter by ai_column_system, scoring_rubric, or other.")
+        .option("--include-archived", "Include archived templates.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("templates list", options, async () => {
+            const params = new URLSearchParams();
+            if (readOption(options.kind))
+                params.set("kind", readOption(options.kind));
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/templates${qs}`);
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Read one prompt template by id or slug.")
+        .argument("<id_or_slug>", "Template UUID or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (idOrSlug, options) => {
+        await handleAsyncAction("templates get", options, async () => requestOxygen("/api/cli/templates/get", {
+            method: "POST",
+            body: idOrSlug.includes("-") && idOrSlug.length >= 32
+                ? { id: idOrSlug }
+                : { slug: idOrSlug },
+        }));
+    }))
+        .addCommand(new Command("upsert")
+        .description("Create or update a prompt template.")
+        .option("--id <id>", "Existing template UUID to update. Omit to create.")
+        .option("--slug <slug>", "Stable slug (kebab-case).")
+        .option("--name <name>", "Human-readable name.")
+        .option("--description <text>", "Short description.")
+        .option("--kind <kind>", "Template kind: ai_column_system, scoring_rubric, or other.")
+        .option("--body <text>", "Prompt body.")
+        .option("--body-file <path>", "Path to a file containing the prompt body.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("templates upsert", options, async () => {
+            const body = {};
+            if (readOption(options.id))
+                body.id = readOption(options.id);
+            if (readOption(options.slug))
+                body.slug = readOption(options.slug);
+            if (readOption(options.name))
+                body.name = readOption(options.name);
+            if (readOption(options.description) !== undefined)
+                body.description = readOption(options.description);
+            if (readOption(options.kind))
+                body.kind = readOption(options.kind);
+            if (readOption(options.body))
+                body.body = readOption(options.body);
+            else if (readOption(options.bodyFile)) {
+                const path = readOption(options.bodyFile);
+                const fs = await import("node:fs/promises");
+                body.body = await fs.readFile(path, "utf8");
+            }
+            return requestOxygen("/api/cli/templates/upsert", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("archive")
+        .description("Archive a prompt template. Seeded templates cannot be archived.")
+        .argument("<id>", "Template UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("templates archive", options, async () => requestOxygen("/api/cli/templates/archive", { method: "POST", body: { id } }));
+    }));
+    program
+        .command("reviews")
+        .description("Human-in-the-loop reviews for AI-generated outreach messages.")
+        .addCommand(new Command("list")
+        .description("List message reviews.")
+        .option("--status <status>", "Filter by pending, accepted, rejected, or superseded.")
+        .option("--table <table_id>", "Filter by table id.")
+        .option("--limit <n>", "Max rows to return (default 50, max 200).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("reviews list", options, async () => {
+            const params = new URLSearchParams();
+            if (readOption(options.status))
+                params.set("status", readOption(options.status));
+            if (readOption(options.table))
+                params.set("table_id", readOption(options.table));
+            if (readOption(options.limit))
+                params.set("limit", readOption(options.limit));
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/message-reviews${qs}`);
+        });
+    }))
+        .addCommand(new Command("next")
+        .description("Read the oldest pending review.")
+        .option("--table <table_id>", "Filter by table id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("reviews next", options, async () => {
+            const params = new URLSearchParams();
+            if (readOption(options.table))
+                params.set("table_id", readOption(options.table));
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/message-reviews/next${qs}`);
+        });
+    }))
+        .addCommand(new Command("accept")
+        .description("Accept a pending message review.")
+        .argument("<review_id>", "Message review UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (reviewId, options) => {
+        await handleAsyncAction("reviews accept", options, async () => requestOxygen("/api/cli/message-reviews/decide", {
+            method: "POST",
+            body: { id: reviewId, decision: "accept" },
+        }));
+    }))
+        .addCommand(new Command("reject")
+        .description("Reject a pending message review with optional highlights and auto-rerun.")
+        .argument("<review_id>", "Message review UUID.")
+        .option("--highlights-json <json>", "JSON array of {start,end,comment} highlight objects.")
+        .option("--auto-rerun", "Trigger a single-row rerun of the column after rejecting.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (reviewId, options) => {
+        await handleAsyncAction("reviews reject", options, async () => {
+            const body = { id: reviewId, decision: "reject" };
+            if (readOption(options.highlightsJson)) {
+                body.highlights = JSON.parse(readOption(options.highlightsJson));
+            }
+            if (options.autoRerun)
+                body.auto_rerun = true;
+            return requestOxygen("/api/cli/message-reviews/decide", { method: "POST", body });
+        });
+    }));
     program
         .command("columns")
         .description("Workspace table column commands.")
@@ -795,6 +970,24 @@ export function createProgram() {
                 },
             });
         });
+    }))
+        .addCommand(new Command("rerun")
+        .description("Re-run a single AI column cell, optionally threading a prior message review's feedback into the prompt.")
+        .requiredOption("--table <table>", "Table id or slug.")
+        .requiredOption("--column <column>", "Column id or key.")
+        .requiredOption("--row <row_id>", "Row UUID.")
+        .option("--from-review-id <review_id>", "Prior message review whose feedback to thread into the regeneration prompt.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("columns rerun", options, async () => requestOxygen("/api/cli/columns/rerun", {
+            method: "POST",
+            body: {
+                table: options.table,
+                column: options.column,
+                row_id: options.row,
+                ...(readOption(options.fromReviewId) ? { from_review_id: readOption(options.fromReviewId) } : {}),
+            },
+        }));
     }))
         .addCommand(new Command("materialize")
         .description("Materialize useful fields from a JSONB result column into target columns.")
@@ -1181,6 +1374,48 @@ export function createProgram() {
             },
         }));
     }));
+    program
+        .command("companies")
+        .description("Company prospecting and account enrichment workflows.")
+        .addCommand(new Command("enrich")
+        .description("Preview or run a company enrichment waterfall over an existing table.")
+        .addCommand(new Command("preview")
+        .description("Inspect missing company fields, provider routing, and credit estimates without provider calls.")
+        .argument("<table>", "Table id or slug.")
+        .option("--missing-fields <fields>", "Comma-separated fields to fill: domain,linkedin_url,headcount,industry,funding,technologies,hiring_signals,company_profile.")
+        .option("--providers <providers>", "Comma-separated provider order pool. Defaults to blitzapi,crustdata,ai_ark,prospeo,leadmagic.")
+        .option("--all", "Preview all rows.")
+        .option("--limit <n>", "Preview a limited row scope.")
+        .option("--row-ids <ids>", "Comma-separated row ids.")
+        .option("--filter-json <json>", "Filter object or array for row selection.")
+        .option("--selection-json <json>", "Raw table action selection JSON.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("companies enrich preview", options, async () => requestOxygen("/api/cli/company-enrichment/preview", {
+            method: "POST",
+            body: readCompaniesEnrichBody(table, options),
+        }));
+    }))
+        .addCommand(new Command("run")
+        .description("Queue a live company enrichment waterfall, or return a dry-run plan.")
+        .argument("<table>", "Table id or slug.")
+        .option("--missing-fields <fields>", "Comma-separated fields to fill.")
+        .option("--providers <providers>", "Comma-separated provider pool.")
+        .option("--mode <mode>", "dry_run or live. Defaults to live.")
+        .option("--max-credits <n>", "Required credit ceiling for live runs.")
+        .option("--all", "Run on all rows.")
+        .option("--limit <n>", "Run on a limited row scope.")
+        .option("--row-ids <ids>", "Comma-separated row ids.")
+        .option("--filter-json <json>", "Filter object or array for row selection.")
+        .option("--selection-json <json>", "Raw table action selection JSON.")
+        .option("--force", "Re-run the waterfall audit column even when it already has a value.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("companies enrich run", options, async () => requestOxygen("/api/cli/company-enrichment/run", {
+            method: "POST",
+            body: readCompaniesEnrichBody(table, options),
+        }));
+    })));
     program
         .command("worker")
         .description("Background worker commands.")
@@ -1614,8 +1849,9 @@ export function createProgram() {
         .description("Configure provider events that can trigger workflows.")
         .addCommand(new Command("list")
         .description("List supported provider events and this org's enabled subscriptions.")
-        .option("--source <source>", "Filter by event source, such as hubspot.")
+        .option("--source <source>", "Filter by event source, such as hubspot or composio.gmail.")
         .option("--event <event>", "Filter by event type, such as contact.created.")
+        .option("--toolkit <id>", "Filter by toolkit / integration id, such as gmail.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("integrations events list", options, async () => {
@@ -1624,25 +1860,47 @@ export function createProgram() {
                 query.set("source", readOption(options.source) ?? "");
             if (readOption(options.event))
                 query.set("event", readOption(options.event) ?? "");
+            if (readOption(options.toolkit))
+                query.set("toolkit", readOption(options.toolkit) ?? "");
             const suffix = query.toString() ? `?${query.toString()}` : "";
             return requestOxygen(`/api/cli/integrations/events${suffix}`);
         });
     }))
         .addCommand(new Command("enable")
         .description("Enable a provider event for a connected integration account.")
-        .requiredOption("--source <source>", "Event source, such as hubspot.")
+        .requiredOption("--source <source>", "Event source, such as hubspot or composio.gmail.")
         .requiredOption("--event <event>", "Event type, such as contact.created.")
         .option("--connection-id <connection_id>", "Specific integration connection id. Defaults to the active default connection.")
+        .option("--trigger-config <json>", "JSON object passed to the provider when registering the trigger (Composio triggers only).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("integrations events enable", options, async () => requestOxygen("/api/cli/integrations/events/enable", {
-            method: "POST",
-            body: {
-                source: readOption(options.source),
-                event: readOption(options.event),
-                ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
-            },
-        }));
+        await handleAsyncAction("integrations events enable", options, async () => {
+            const triggerConfigRaw = readOption(options.triggerConfig);
+            let triggerConfig;
+            if (triggerConfigRaw) {
+                try {
+                    const parsed = JSON.parse(triggerConfigRaw);
+                    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                        throw new Error("--trigger-config must be a JSON object.");
+                    }
+                    triggerConfig = parsed;
+                }
+                catch (error) {
+                    throw new Error(error instanceof Error
+                        ? `Invalid --trigger-config: ${error.message}`
+                        : "Invalid --trigger-config");
+                }
+            }
+            return requestOxygen("/api/cli/integrations/events/enable", {
+                method: "POST",
+                body: {
+                    source: readOption(options.source),
+                    event: readOption(options.event),
+                    ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+                    ...(triggerConfig ? { trigger_config: triggerConfig } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("disable")
         .description("Disable a provider event for a connected integration account.")
@@ -2153,6 +2411,7 @@ function referencesRecipeSdk(source) {
 // Escape Next static analysis (the CLI is bundled by tsc, but mirror the
 // worker's escape so both load identically).
 const dynamicRecipeImport = new Function("specifier", "return import(specifier);");
+// skipcq: JS-R1003
 async function importRecipeModule(specifier) {
     try {
         return await dynamicRecipeImport(specifier);
@@ -2354,6 +2613,55 @@ function readTableRunSelection(options) {
         exitCode: 1,
     });
 }
+function readCompaniesEnrichBody(table, options) {
+    const body = { table };
+    const fields = readCsvOption(options.missingFields);
+    const providers = readCsvOption(options.providers);
+    const selection = readCompaniesEnrichSelection(options);
+    const mode = readOption(options.mode);
+    const maxCredits = readPositiveNumber(options.maxCredits);
+    if (fields.length > 0)
+        body.missing_fields = fields;
+    if (providers.length > 0)
+        body.providers = providers;
+    if (selection)
+        body.selection = selection;
+    if (mode)
+        body.mode = mode;
+    if (maxCredits !== undefined)
+        body.max_credits = maxCredits;
+    if (options.force !== undefined)
+        body.force = Boolean(options.force);
+    return body;
+}
+function readCompaniesEnrichSelection(options) {
+    const explicitSelection = readSelectionJsonOption(options.selectionJson);
+    const hasAll = Boolean(options.all);
+    const limit = readPositiveInt(options.limit);
+    const rowIds = readCsvOption(options.rowIds);
+    const filterSelection = readFilterSelectionOption(options.filterJson);
+    const selectedModes = [
+        Boolean(explicitSelection),
+        hasAll,
+        Boolean(limit),
+        rowIds.length > 0,
+        Boolean(filterSelection),
+    ].filter(Boolean).length;
+    if (selectedModes > 1) {
+        throw new OxygenError("invalid_company_enrichment", "Pass only one row scope option.", { exitCode: 1 });
+    }
+    if (explicitSelection)
+        return explicitSelection;
+    if (hasAll)
+        return { mode: "all" };
+    if (limit)
+        return { mode: "limit", limit };
+    if (rowIds.length > 0)
+        return { mode: "row_ids", row_ids: rowIds };
+    if (filterSelection)
+        return filterSelection;
+    return undefined;
+}
 function readFilterSelectionOption(value) {
     const filters = readFilterJsonOption(value);
     return filters ? { mode: "filter", filters } : undefined;
@@ -2569,11 +2877,13 @@ async function prepareImportTarget(table, options, parsedRows) {
             exitCode: 1,
         });
     }
+    const createdWebUrl = readRecordString(created, "web_url")
+        ?? readRecordString(created, "deepLink");
     return {
         tableRef: createdSlug,
         rows: normalized.rows,
         createdTable: created,
-        tableWebUrl: tableWebUrl(createdSlug),
+        tableWebUrl: createdWebUrl ?? tableWebUrl(createdSlug),
         upsertKey: normalizeCreatedTableUpsertKey(options.upsertKey, normalized.keyBySource),
     };
 }
@@ -2756,16 +3066,17 @@ async function exportRows(table, options) {
             ...(limit ? { limit } : {}),
         },
     });
-    const content = formatRows(result.rows, format, result.columns);
+    const formatted = formatRows(result.rows, format, result.columns);
     if (options.output) {
-        writeFileSync(options.output, content);
+        writeFileSync(options.output, formatted.content);
     }
     return {
         table: result.table ?? null,
         format,
         rowCount: result.rows.length,
         output: options.output ?? null,
-        ...(options.output ? {} : { content }),
+        ...(options.output ? {} : { content: formatted.content }),
+        ...(formatted.rescuedCount > 0 ? { rescuedNumericCells: formatted.rescuedCount } : {}),
     };
 }
 async function readRowsFile(path, format, sheet) {
@@ -2778,18 +3089,26 @@ function normalizeCreatedTableUpsertKey(value, keyBySource) {
 }
 function normalizeExportRowsFormat(value) {
     const normalized = value?.trim().toLowerCase() || "json";
-    if (normalized === "json" || normalized === "jsonl" || normalized === "csv")
+    if (normalized === "json"
+        || normalized === "jsonl"
+        || normalized === "csv"
+        || normalized === "table")
         return normalized;
-    throw new OxygenError("invalid_format", "Export format must be json, jsonl, or csv.", {
+    throw new OxygenError("invalid_format", "Export format must be json, jsonl, csv, or table.", {
         details: { format: value },
         exitCode: 1,
     });
 }
 function formatRows(rows, format, columns) {
-    if (format === "json")
-        return `${JSON.stringify(rows, null, 2)}\n`;
-    if (format === "jsonl")
-        return `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`;
+    if (format === "json") {
+        return { content: `${JSON.stringify(rows, null, 2)}\n`, rescuedCount: 0 };
+    }
+    if (format === "jsonl") {
+        return {
+            content: `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`,
+            rescuedCount: 0,
+        };
+    } // skipcq: JS-0246
     const keys = [
         "_row_id",
         "_created_at",
@@ -2797,10 +3116,57 @@ function formatRows(rows, format, columns) {
         ...(columns?.map((column) => column.key) ?? []),
         ...rows.flatMap((row) => Object.keys(row)),
     ].filter((key, index, all) => all.indexOf(key) === index && rows.some((row) => key in row));
-    return [
-        keys.map(escapeCsvField).join(","),
-        ...rows.map((row) => keys.map((key) => escapeCsvField(row[key])).join(",")),
-    ].join("\n") + "\n";
+    if (format === "csv") {
+        return {
+            content: [
+                keys.map(escapeCsvField).join(","),
+                ...rows.map((row) => keys.map((key) => escapeCsvField(row[key])).join(",")),
+            ].join("\n") + "\n",
+            rescuedCount: 0,
+        };
+    }
+    // "table": render with type-aware formatting and a Markdown-style frame.
+    const columnByKey = new Map(columns?.map((c) => [c.key, c]) ?? []);
+    let rescuedCount = 0;
+    const headers = keys.map((key) => columnByKey.get(key)?.label ?? key);
+    const formattedRows = rows.map((row) => keys.map((key) => {
+        const column = columnByKey.get(key) ?? null;
+        const formatted = formatCellForDisplay(row[key], column, {
+            surface: "cli",
+            onRescued: () => {
+                rescuedCount += 1;
+            },
+        });
+        // Pipe and any line-break char are the row/cell delimiters of the
+        // Markdown frame — raw values containing them would corrupt the layout.
+        // Match on the line-break class (not just `\r?\n`) so a standalone `\r`
+        // doesn't slip through and split the row visually.
+        return formatted.replace(/[\r\n]+/g, " ↵ ").replace(/\|/g, "\\|");
+    }));
+    const widths = headers.map((header, columnIndex) => {
+        let max = header.length;
+        for (const row of formattedRows) {
+            const cell = row[columnIndex] ?? "";
+            if (cell.length > max)
+                max = cell.length;
+        }
+        return Math.min(max, 60);
+    });
+    const renderRow = (cells) => "| " + cells.map((cell, i) => clipCell(cell, widths[i]).padEnd(widths[i])).join(" | ") + " |";
+    const separator = "|" + widths.map((w) => "-".repeat(w + 2)).join("|") + "|";
+    const lines = [renderRow(headers), separator, ...formattedRows.map(renderRow)];
+    if (rescuedCount > 0) {
+        lines.push("");
+        lines.push(`# Note: reformatted ${rescuedCount} cell${rescuedCount === 1 ? "" : "s"} that look numeric in text columns. Run \`oxygen columns retype --to numeric\` to make this permanent.`);
+    }
+    return { content: lines.join("\n") + "\n", rescuedCount };
+}
+function clipCell(value, width) {
+    if (value.length <= width)
+        return value;
+    if (width <= 1)
+        return value.slice(0, width);
+    return value.slice(0, width - 1) + "…";
 }
 function escapeCsvField(value) {
     const text = value === null || value === undefined
@@ -3000,64 +3366,46 @@ async function handleUpdateAction(options) {
         process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
     }
 }
-function detectCliInstallPrefix() {
-    try {
-        const path = fileURLToPath(import.meta.url);
-        const suffixes = [
-            "/lib/node_modules/@oxygen-agent/cli/dist/index.js",
-            "/lib/node_modules/@oxygen/cli/dist/index.js",
-        ];
-        for (const suffix of suffixes) {
-            if (path.endsWith(suffix)) {
-                return path.slice(0, -suffix.length);
-            }
+function buildApiKeyCreateBody(options) {
+    const body = {};
+    const name = readOption(options.name);
+    if (name)
+        body.name = name;
+    const expiresAt = resolveApiKeyExpiresAt(options);
+    if (expiresAt)
+        body.expires_at = expiresAt;
+    return body;
+}
+function resolveApiKeyExpiresAt(options) {
+    const expiresAt = readOption(options.expiresAt);
+    const expiresInDays = readOption(options.expiresInDays);
+    if (expiresAt && expiresInDays) {
+        throw new OxygenError("conflicting_flags", "Pass either --expires-at or --expires-in-days, not both.", {
+            exitCode: 1,
+        });
+    }
+    if (expiresAt) {
+        const date = new Date(expiresAt);
+        if (!Number.isFinite(date.getTime())) {
+            throw new OxygenError("invalid_expires_at", "--expires-at must be a valid ISO 8601 timestamp.", {
+                details: { expires_at: expiresAt },
+                exitCode: 1,
+            });
         }
+        return date.toISOString();
     }
-    catch {
-        // Non-file URL (e.g. running from a bundler) — fall through.
+    if (expiresInDays) {
+        const days = readPositiveInt(expiresInDays);
+        if (!days) {
+            throw new OxygenError("invalid_number", "--expires-in-days must be a positive integer.", {
+                details: { value: expiresInDays },
+                exitCode: 1,
+            });
+        }
+        return new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString();
     }
     return null;
 }
-function updateCli(options) {
-    const packageSpec = readOption(options.package) ?? DEFAULT_CLI_PACKAGE_SPEC;
-    const prefix = detectCliInstallPrefix();
-    const args = prefix
-        ? ["install", "-g", "--prefix", prefix, packageSpec]
-        : ["install", "-g", packageSpec];
-    const command = ["npm", ...args].join(" ");
-    if (options.dryRun) {
-        return {
-            current_version: OXYGEN_VERSION,
-            package: packageSpec,
-            command,
-            dry_run: true,
-            updated: false,
-        };
-    }
-    const result = spawnSync("npm", args, {
-        encoding: "utf8",
-        stdio: options.json ? ["ignore", "pipe", "pipe"] : "inherit",
-    });
-    if (result.error || result.status !== 0) {
-        throw new OxygenError("cli_update_failed", "Unable to update the Oxygen CLI.", {
-            details: {
-                command,
-                package: packageSpec,
-                exit_code: result.status,
-                reason: result.error instanceof Error ? result.error.message : null,
-                stderr: typeof result.stderr === "string" && result.stderr.trim() ? result.stderr.trim().slice(0, 4000) : null,
-            },
-            exitCode: 1,
-        });
-    }
-    return {
-        current_version: OXYGEN_VERSION,
-        package: packageSpec,
-        command,
-        dry_run: false,
-        updated: true,
-    };
-}
 async function login(options) {
     const apiUrl = normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl());
     const token = readOption(options.token) ?? await promptForToken({
@@ -3255,6 +3603,7 @@ function formatLoginSuccess(identity, credentials, profile) {
         .update(`oxygen-cli:${credentials.token}`)
         .digest("hex");
     const c = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    // skipcq: JS-0820 — not a React component; rule misfire on array of tuples
     const rows = [
         ["Account", email],
         ["Organization", org],
@@ -3331,7 +3680,7 @@ function formatProfileUseSuccess(profile) {
         `  ${c.dim("Fingerprint")}   ${profile.token_fingerprint}`,
         "",
     ].join("\n");
-}
+} // skipcq: JS-C1002
 function formatLogoutSuccess(result) {
     const c = ansi(output.isTTY === true && !process.env.NO_COLOR);
     const removed = result.removedProfile
@@ -3342,7 +3691,7 @@ function formatLogoutSuccess(result) {
         `${c.green("[OK]")} ${c.bold("CLI logged out")}`,
         "",
         `  ${c.dim("Credentials")}   ${removed}`,
-        `  ${c.dim("Profiles left")}  ${String(result.remainingProfiles)}`,
+        `  ${c.dim("Profiles left")}  ${String(result.remainingProfiles)}`, // skipcq: JS-C1002
         "",
     ].join("\n");
 }
@@ -3357,7 +3706,7 @@ function formatUpdateSuccess(result) {
         `  ${c.dim("Command")}     ${result.command}`,
         "",
     ].join("\n");
-}
+} // skipcq: JS-C1002
 function renderBox(lines) {
     const width = Math.max(...lines.map(visibleLength), 0);
     const border = `+${"-".repeat(width + 2)}+`;
@@ -3365,6 +3714,7 @@ function renderBox(lines) {
     return [border, ...body, border].join("\n");
 }
 function visibleLength(value) {
+    // skipcq: JS-0004 — ESC (\x1b) is the ANSI CSI introducer; required to strip color codes
     return value.replace(/\x1b\[[0-9;]*m/g, "").length;
 }
 function ansi(enabled) {
@@ -3372,7 +3722,7 @@ function ansi(enabled) {
         ? (text) => `\x1b[${open}m${text}\x1b[${close}m`
         : (text) => text;
     return {
-        bold: wrap(1, 22),
+        bold: wrap(1, 22), // skipcq: JS-0117  // skipcq: JS-W1035
         dim: wrap(2, 22),
         green: wrap(32, 39),
     };
@@ -3520,4 +3870,3 @@ function muteTokenEcho() {
     }
 }
 await createProgram().parseAsync(process.argv);
-//# sourceMappingURL=index.js.map