@oxygen-agent/cli 1.1014.985 → 1.1014.1087

package/README.md

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

package/dist/command-families/program.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createProgram(): Command;

package/dist/command-families/program.js

@@ -0,0 +1,241 @@
+// Build the actual command tree without starting the executable, diagnostics, or updates.
+// The executable retains its ordered runtime initialization imports in index.ts.
+import { registerAdminLeadMagnetCommands } from "../admin-lead-magnet-commands.js";
+import { handleAsyncAction } from "../cli-output.js";
+import { recordCliProfileFlag } from "../cli-profile-context.js";
+import { registerActionColumnFamily } from "../commands/action-column.js";
+import { registerActivationFamily } from "../commands/activation.js";
+import { registerAdminFamily } from "../commands/admin.js";
+import { registerAdsFamily } from "../commands/ads.js";
+import { registerAgentFamily } from "../commands/agent.js";
+import { registerApiKeysFamily } from "../commands/api-keys.js";
+import { registerApprovalsFamily } from "../commands/approvals.js";
+import { registerAuthFamily } from "../commands/auth.js";
+import { registerBillingFamily } from "../commands/billing.js";
+import { registerBlueprintsFamily } from "../commands/blueprints.js";
+import { registerBudgetFamily } from "../commands/budget.js";
+import { registerCallablesFamily } from "../commands/callables.js";
+import { registerCapabilitiesFamily } from "../commands/capabilities.js";
+import { registerCellsFamily } from "../commands/cells.js";
+import { registerColumnsFamily } from "../commands/columns.js";
+import { registerCommandsFamily } from "../commands/commands.js";
+import { registerCommentsFamily } from "../commands/comments.js";
+import { registerCompaniesFamily } from "../commands/companies.js";
+import { registerConnectionsFamily } from "../commands/connections.js";
+import { registerContextFamily } from "../commands/context.js";
+import { registerCopilotFamily } from "../commands/copilot.js";
+import { registerCrmFamily } from "../commands/crm.js";
+import { registerCustomIntegrationsFamily } from "../commands/custom-integrations.js";
+import { registerDashboardsFamily } from "../commands/dashboards.js";
+import { registerDbFamily } from "../commands/db.js";
+import { registerDeliverabilityFamily } from "../commands/deliverability.js";
+import { registerDirectoryFamily } from "../commands/directory.js";
+import { registerDomainsFamily } from "../commands/domains.js";
+import { registerEgressFamily } from "../commands/egress.js";
+import { registerEmailFamily } from "../commands/email.js";
+import { registerEngagementFamily } from "../commands/engagement.js";
+import { registerEnrichColumnFamily } from "../commands/enrich-column.js";
+import { registerEnrichmentFamily } from "../commands/enrichment.js";
+import { registerFeedbackFamily } from "../commands/feedback.js";
+import { registerFeedsFamily } from "../commands/feeds.js";
+import { registerFindFamily } from "../commands/find.js";
+import { registerFollowersFamily } from "../commands/followers.js";
+import { registerFormulasFamily } from "../commands/formulas.js";
+import { registerHomeFamily } from "../commands/home.js";
+import { registerInboxFamily } from "../commands/inbox.js";
+import { registerIntegrationsFamily } from "../commands/integrations.js";
+import { registerKnowledgeFamily } from "../commands/knowledge.js";
+import { registerLeadSourcingFamily } from "../commands/lead-sourcing.js";
+import { registerLimitsFamily } from "../commands/limits.js";
+import { registerLinkedinFamily } from "../commands/linkedin.js";
+import { registerLoginFamily } from "../commands/login.js";
+import { registerLogoutFamily } from "../commands/logout.js";
+import { registerMailboxesFamily } from "../commands/mailboxes.js";
+import { registerManagedInboxesFamily } from "../commands/managed-inboxes.js";
+import { registerMessagesFamily } from "../commands/messages.js";
+import { registerNotetakerFamily } from "../commands/notetaker.js";
+import { registerObservabilityFamily } from "../commands/observability.js";
+import { registerOrgsFamily } from "../commands/orgs.js";
+import { registerPeopleFamily } from "../commands/people.js";
+import { registerPostsFamily } from "../commands/posts.js";
+import { registerProfilesFamily } from "../commands/profiles.js";
+import { registerProjectsFamily } from "../commands/projects.js";
+import { registerPromptsFamily } from "../commands/prompts.js";
+import { registerPublishingFamily } from "../commands/publishing.js";
+import { registerRecipesFamily } from "../commands/recipes.js";
+import { registerReviewsFamily } from "../commands/reviews.js";
+import { registerRowsFamily } from "../commands/rows.js";
+import { registerRunsFamily } from "../commands/runs.js";
+import { registerSearchFamily } from "../commands/search.js";
+import { registerSendersFamily } from "../commands/senders.js";
+import { registerSequencesFamily } from "../commands/sequences.js";
+import { registerSessionFamily } from "../commands/session.js";
+import { registerSignalsFamily } from "../commands/signals.js";
+import { registerSignupLeadsFamily } from "../commands/signup-leads.js";
+import { registerSkillsFamily } from "../commands/skills.js";
+import { registerSourcingFamily } from "../commands/sourcing.js";
+import { registerStatusFamily } from "../commands/status.js";
+import { registerSupabaseFamily } from "../commands/supabase.js";
+import { registerSupportFamily } from "../commands/support.js";
+import { registerSuppressionsFamily } from "../commands/suppressions.js";
+import { registerTableIngestionsFamily } from "../commands/table-ingestions.js";
+import { registerTableRunsFamily } from "../commands/table-runs.js";
+import { registerTablesFamily } from "../commands/tables.js";
+import { registerTagsFamily } from "../commands/tags.js";
+import { registerToolsFamily } from "../commands/tools.js";
+import { registerUpdateFamily } from "../commands/update.js";
+import { registerVerifyFamily } from "../commands/verify.js";
+import { registerViewersFamily } from "../commands/viewers.js";
+import { registerVoiceFamily } from "../commands/voice.js";
+import { registerWhatsappFamily } from "../commands/whatsapp.js";
+import { registerWhoamiFamily } from "../commands/whoami.js";
+import { registerWorkerFamily } from "../commands/worker.js";
+import { registerWorkflowsFamily } from "../commands/workflows.js";
+import { registerWorkspaceFamily } from "../commands/workspace.js";
+import { registerConnectorsCommands } from "../connectors-commands.js";
+import { defaultApiUrl } from "../credentials.js";
+import { registerCrmFileReadCommands } from "../crm-file-read-commands.js";
+import { registerCrmSupportFlags } from "../crm-support-flags.js";
+import { registerCustomerOperationCommands } from "../customer-operation-commands.js";
+import { registerFunctionsCommands } from "../functions-commands.js";
+import { applyOxygenHelp, enableCommandSuggestions, oxygenDocsUrl, validateRequiredOptionValues } from "../help.js";
+import { registerKnowledgeRepositoryCommands } from "../knowledge-repository-commands.js";
+import { resolveCliBinaryName } from "../runtime.js";
+import { registerSettingsCommands } from "../settings-commands.js";
+import { registerUgcCommands } from "../ugc-commands.js";
+import { registerVisualCommands } from "../visual-commands.js";
+import { registerWorkspaceSkillCommands } from "../workspace-skill-commands.js";
+import { OXYGEN_VERSION } from "@oxygen/shared/version";
+import { Command } from "commander";
+export function createProgram() {
+    const program = new Command();
+    const binaryName = resolveCliBinaryName();
+    const directoryDocsUrl = oxygenDocsUrl(defaultApiUrl(), "/agencies");
+    const billingDocsUrl = oxygenDocsUrl(defaultApiUrl(), "/safety/billing");
+    program
+        .name(binaryName)
+        .description("The agentic GTM platform for B2B GTM teams: tables, enrichment, sequences, workflows, CRM, knowledge. Everything here also runs in the web app and over MCP; every state-changing action returns a web_url deep-link.")
+        .version(OXYGEN_VERSION)
+        .option("--pretty", "Indent JSON for human reading; omit for compact agent output.")
+        .option("--profile <name>", "Use a stored CLI profile for this command.")
+        .option("--org <organization>", "Use an organization id, Clerk org id, or slug for this command.");
+    program.hook("preAction", (_root, selected) => {
+        validateRequiredOptionValues(program, selected);
+        const options = program.opts();
+        if (options.profile) {
+            recordCliProfileFlag(options.profile);
+            process.env.OXYGEN_PROFILE = options.profile;
+        }
+        if (options.org) {
+            process.env.OXYGEN_ORG = options.org;
+        }
+    });
+    registerLoginFamily(program, handleAsyncAction);
+    registerAuthFamily(program, handleAsyncAction);
+    registerProfilesFamily(program, handleAsyncAction);
+    registerLogoutFamily(program, handleAsyncAction);
+    registerUpdateFamily(program, handleAsyncAction);
+    registerApiKeysFamily(program, handleAsyncAction);
+    registerWhoamiFamily(program, handleAsyncAction);
+    registerHomeFamily(program, handleAsyncAction);
+    registerWorkspaceFamily(program, handleAsyncAction);
+    registerActivationFamily(program, handleAsyncAction);
+    registerCommandsFamily(program, handleAsyncAction, binaryName);
+    registerCapabilitiesFamily(program, handleAsyncAction);
+    registerStatusFamily(program, handleAsyncAction);
+    registerOrgsFamily(program, handleAsyncAction);
+    registerSupportFamily(program, handleAsyncAction);
+    registerFeedbackFamily(program, handleAsyncAction);
+    registerDbFamily(program, handleAsyncAction);
+    registerProjectsFamily(program, handleAsyncAction);
+    registerNotetakerFamily(program, handleAsyncAction);
+    registerPublishingFamily(program, handleAsyncAction);
+    registerDashboardsFamily(program, handleAsyncAction);
+    registerCrmFamily(program, handleAsyncAction);
+    registerSignalsFamily(program, handleAsyncAction);
+    registerTablesFamily(program, handleAsyncAction, binaryName);
+    registerFeedsFamily(program, handleAsyncAction);
+    registerContextFamily(program, handleAsyncAction);
+    registerKnowledgeFamily(program, handleAsyncAction);
+    registerAdsFamily(program, handleAsyncAction);
+    registerTagsFamily(program, handleAsyncAction);
+    registerCommentsFamily(program, handleAsyncAction);
+    registerApprovalsFamily(program, handleAsyncAction);
+    registerBlueprintsFamily(program, handleAsyncAction);
+    registerRecipesFamily(program, handleAsyncAction);
+    registerPromptsFamily(program, handleAsyncAction);
+    registerReviewsFamily(program, handleAsyncAction);
+    registerColumnsFamily(program, handleAsyncAction);
+    registerActionColumnFamily(program, handleAsyncAction);
+    registerFormulasFamily(program, handleAsyncAction);
+    registerTableRunsFamily(program, handleAsyncAction);
+    registerTableIngestionsFamily(program, handleAsyncAction);
+    registerSourcingFamily(program, handleAsyncAction);
+    registerLeadSourcingFamily(program, handleAsyncAction);
+    registerSearchFamily(program, handleAsyncAction);
+    registerCompaniesFamily(program, handleAsyncAction);
+    registerPeopleFamily(program, handleAsyncAction);
+    registerWorkerFamily(program, handleAsyncAction);
+    registerLimitsFamily(program, handleAsyncAction, billingDocsUrl);
+    registerBillingFamily(program, handleAsyncAction, billingDocsUrl);
+    registerBudgetFamily(program, handleAsyncAction);
+    registerEgressFamily(program, handleAsyncAction);
+    registerDirectoryFamily(program, handleAsyncAction, directoryDocsUrl, billingDocsUrl);
+    registerAdminFamily(program, handleAsyncAction, binaryName);
+    registerSignupLeadsFamily(program, handleAsyncAction);
+    registerObservabilityFamily(program, handleAsyncAction);
+    registerAgentFamily(program, handleAsyncAction);
+    registerCopilotFamily(program, handleAsyncAction);
+    registerRunsFamily(program, handleAsyncAction);
+    registerRowsFamily(program, handleAsyncAction);
+    registerCellsFamily(program, handleAsyncAction);
+    registerSessionFamily(program, handleAsyncAction);
+    registerCustomIntegrationsFamily(program, handleAsyncAction);
+    registerToolsFamily(program, handleAsyncAction);
+    registerEnrichColumnFamily(program, handleAsyncAction);
+    registerFindFamily(program, handleAsyncAction);
+    registerVerifyFamily(program, handleAsyncAction);
+    registerEnrichmentFamily(program, handleAsyncAction);
+    registerSupabaseFamily(program, handleAsyncAction);
+    registerIntegrationsFamily(program, handleAsyncAction);
+    registerSendersFamily(program, handleAsyncAction);
+    registerConnectionsFamily(program, handleAsyncAction);
+    registerFollowersFamily(program, handleAsyncAction);
+    registerViewersFamily(program, handleAsyncAction);
+    registerPostsFamily(program, handleAsyncAction);
+    registerEngagementFamily(program, handleAsyncAction);
+    registerLinkedinFamily(program, handleAsyncAction);
+    registerWhatsappFamily(program, handleAsyncAction);
+    registerInboxFamily(program, handleAsyncAction);
+    registerMessagesFamily(program, handleAsyncAction);
+    registerSequencesFamily(program, handleAsyncAction);
+    registerVoiceFamily(program, handleAsyncAction);
+    registerSuppressionsFamily(program, handleAsyncAction);
+    registerEmailFamily(program, handleAsyncAction);
+    registerManagedInboxesFamily(program, handleAsyncAction);
+    registerMailboxesFamily(program, handleAsyncAction);
+    registerDeliverabilityFamily(program, handleAsyncAction);
+    registerDomainsFamily(program, handleAsyncAction);
+    registerCallablesFamily(program, handleAsyncAction);
+    registerWorkflowsFamily(program, handleAsyncAction);
+    registerSkillsFamily(program, handleAsyncAction);
+    registerVisualCommands(program, handleAsyncAction);
+    registerFunctionsCommands(program, handleAsyncAction);
+    registerUgcCommands(program, handleAsyncAction);
+    registerKnowledgeRepositoryCommands(program, handleAsyncAction);
+    registerAdminLeadMagnetCommands(program, handleAsyncAction);
+    registerConnectorsCommands(program, handleAsyncAction);
+    registerSettingsCommands(program, handleAsyncAction);
+    registerCrmSupportFlags(program);
+    registerWorkspaceSkillCommands(program, handleAsyncAction);
+    registerCustomerOperationCommands(program, handleAsyncAction);
+    registerCrmFileReadCommands(program, handleAsyncAction);
+    // After the register* helpers: help groups are assigned to the commands that
+    // exist when this runs, and a family registered later fell into commander's
+    // trailing default "Commands:" list (the 2026-09-30 blind agent read the first
+    // 80 lines of help and missed `connectors` there).
+    applyOxygenHelp(program, binaryName, oxygenDocsUrl(defaultApiUrl()));
+    // Last, so every command registered above is covered.
+    enableCommandSuggestions(program);
+    return program;
+}

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

@@ -0,0 +1,22 @@
+import { TablesAutoDedupeSetOptions, TablesDedupeOptions, TablesWebhookCreateOptions } from "./options.js";
+export declare const TABLE_WEBHOOK_RATE_HELP: string;
+export declare function tableWebhookListPath(options: {
+    table?: string | undefined;
+    status?: string | undefined;
+    limit?: string | undefined;
+}): string;
+export declare function readTableWebhookAutoRunOptions(options: TablesWebhookCreateOptions): Record<string, unknown> | null;
+export declare function parsePromoteMapOption(value: string | undefined): Array<{
+    column: string;
+    attribute: string;
+}>;
+export declare function normalizePromotePolicy(value: string | undefined): "fill_empty_only" | "overwrite" | "skip_conflicts";
+export declare function buildDedupeRequest(table: string, options: TablesDedupeOptions): {
+    endpoint: string;
+    body: Record<string, unknown>;
+};
+export declare function buildTablesAutoDedupeSetBody(table: string, options: TablesAutoDedupeSetOptions): Record<string, unknown>;
+export declare function normalizeDedupeNormalizer(value: string | undefined): "exact" | "email" | "domain" | "linkedin_url" | "fuzzy_label";
+export declare function normalizeDedupeKeep(value: string | undefined): "oldest" | "newest" | "most_complete";
+export declare function normalizeDedupeMergeValues(value: string | undefined): "fill_empty" | null;
+export declare function readSortJsonOption(value: string | undefined): Record<string, unknown>[] | undefined;

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

@@ -0,0 +1,250 @@
+import { readPositiveInt } from "../../cli-values.js";
+import { readCsvOption, readPositiveNumber, parseJsonArray } from "../../command-support.js";
+import { readOption, isRecord } from "../../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { PUBLIC_WEBHOOK_INGRESS_PER_TARGET_PER_MINUTE } from "@oxygen/shared/plan-band";
+// The only numbers on `tables import --help` used to be --batch-size (a
+// per-request chunk) and the background threshold, so users read 500 as a
+// per-file cap. Echo the shared row ceiling and the tiered byte ceilings instead
+// of restating either as a chunk-size constraint.
+// Webhook ingress scales with plan size (repricing 2026-09, decision L4.4).
+export const TABLE_WEBHOOK_RATE_HELP = `${PUBLIC_WEBHOOK_INGRESS_PER_TARGET_PER_MINUTE.free.toLocaleString("en-US")}–${PUBLIC_WEBHOOK_INGRESS_PER_TARGET_PER_MINUTE["1999"].toLocaleString("en-US")} requests a minute by plan size, per endpoint and sender IP; 429 returns Retry-After; \`oxygen limits show\` lists yours`;
+export 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}` : ""}`;
+}
+export 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,
+        ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+        ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
+        ...(options.autoRunForce ? { force: true } : {}),
+        ...(readOption(options.autoRunConnectionId) ? { connection_id: readOption(options.autoRunConnectionId) } : {}),
+    };
+}
+// Parse a `tables promote --map` value into the wire mappings [{column, attribute}].
+// Accepts the CSV pair form `column=attribute,column2=attribute2` (LHS is the working
+// column, RHS the CRM attribute — the reverse of --bind-map's identity=column), a
+// JSON array of {column, attribute}, or a JSON object { column: attribute }.
+export function parsePromoteMapOption(value) {
+    const trimmed = readOption(value);
+    if (!trimmed) {
+        throw new OxygenError("invalid_promote_map", "--map is required: column=attribute pairs or a JSON array/object.", { exitCode: 1 });
+    }
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            throw new OxygenError("invalid_promote_map", "--map JSON is not valid JSON.", { details: { value: trimmed }, exitCode: 1 });
+        }
+        const entries = Array.isArray(parsed)
+            ? parsed.map((entry) => {
+                const record = isRecord(entry) ? entry : {};
+                return {
+                    column: typeof record.column === "string" ? record.column.trim() : "",
+                    attribute: typeof record.attribute === "string" ? record.attribute.trim() : "",
+                };
+            })
+            : isRecord(parsed)
+                ? Object.entries(parsed).map(([column, attribute]) => ({ column: column.trim(), attribute: String(attribute).trim() }))
+                : [];
+        const mappings = entries.filter((mapping) => mapping.column && mapping.attribute);
+        if (mappings.length === 0) {
+            throw new OxygenError("invalid_promote_map", "--map must contain at least one column-to-attribute mapping.", { exitCode: 1 });
+        }
+        return mappings;
+    }
+    const mappings = [];
+    for (const entry of readCsvOption(value)) {
+        const separator = entry.indexOf("=");
+        if (separator <= 0 || separator === entry.length - 1) {
+            throw new OxygenError("invalid_promote_map", "--map entries must be column=attribute pairs, e.g. job_title=job_title,seniority=seniority.", { details: { entry }, exitCode: 1 });
+        }
+        mappings.push({ column: entry.slice(0, separator).trim(), attribute: entry.slice(separator + 1).trim() });
+    }
+    if (mappings.length === 0) {
+        throw new OxygenError("invalid_promote_map", "--map must contain at least one column-to-attribute mapping.", { exitCode: 1 });
+    }
+    return mappings;
+}
+// Map the hyphenated CLI policy flag to the wire enum.
+export function normalizePromotePolicy(value) {
+    const normalized = (readOption(value) ?? "fill-empty-only").replace(/-/g, "_");
+    if (normalized === "fill_empty_only" || normalized === "overwrite" || normalized === "skip_conflicts") {
+        return normalized;
+    }
+    throw new OxygenError("invalid_promote_policy", "--policy must be fill-empty-only, overwrite, or skip-conflicts.", {
+        details: { policy: value },
+        exitCode: 1,
+    });
+}
+// Route `tables dedupe` to the preview / apply / cross-check API by flag: --against
+// switches to the read-only cross-table check (rejecting --apply); --apply targets
+// the destructive delete (approved only when --approved is set); otherwise preview.
+export function buildDedupeRequest(table, options) {
+    const onColumns = readCsvOption(options.on);
+    if (onColumns.length === 0) {
+        throw new OxygenError("invalid_dedupe", "--on requires at least one column.", { exitCode: 1 });
+    }
+    const normalizer = normalizeDedupeNormalizer(options.normalize);
+    const scanLimit = readPositiveInt(options.scanLimit);
+    const against = readOption(options.against);
+    if (against) {
+        if (options.apply) {
+            throw new OxygenError("invalid_dedupe", "--apply cannot be combined with --against; the cross-table check is read-only.", { exitCode: 1 });
+        }
+        const againstColumn = readOption(options.againstColumn);
+        if (!againstColumn) {
+            throw new OxygenError("invalid_dedupe", "--against-column is required with --against.", { exitCode: 1 });
+        }
+        if (onColumns.length > 1) {
+            throw new OxygenError("invalid_dedupe", "The cross-table check matches on a single --on column.", { exitCode: 1 });
+        }
+        return {
+            endpoint: "/api/cli/tables/dedupe/cross-check",
+            body: {
+                table,
+                column: onColumns[0],
+                against_table: against,
+                against_column: againstColumn,
+                normalizer,
+                ...(scanLimit ? { scan_limit: scanLimit } : {}),
+            },
+        };
+    }
+    const keys = onColumns.map((column) => ({ column, normalizer }));
+    const keep = normalizeDedupeKeep(options.keep);
+    if (options.apply) {
+        const mergeValues = normalizeDedupeMergeValues(options.mergeValues);
+        return {
+            endpoint: "/api/cli/tables/dedupe/apply",
+            body: {
+                table,
+                keys,
+                keep,
+                ...(mergeValues ? { merge_values: mergeValues } : {}),
+                ...(scanLimit ? { scan_limit: scanLimit } : {}),
+                // --approved is the only path that deletes; without it the API 409s with the preview.
+                ...(options.approved ? { approved: true } : {}),
+            },
+        };
+    }
+    return {
+        endpoint: "/api/cli/tables/dedupe/preview",
+        body: { table, keys, keep, ...(scanLimit ? { scan_limit: scanLimit } : {}) },
+    };
+}
+// Build the standing auto-dedupe `set` body: --on columns paired positionally
+// with --normalize modes (unpaired columns default to exact). fuzzy-label maps
+// through so the API rejects it with the on-demand pointer — one source of
+// truth for the hot-path restriction.
+export function buildTablesAutoDedupeSetBody(table, options) {
+    const onColumns = readCsvOption(options.on);
+    if (onColumns.length === 0) {
+        throw new OxygenError("invalid_auto_dedupe", "--on requires at least one column.", { exitCode: 1 });
+    }
+    const normalizers = readCsvOption(options.normalize);
+    const keys = onColumns.map((column, index) => ({
+        column,
+        normalizer: normalizeDedupeNormalizer(normalizers[index]),
+    }));
+    const keep = normalizeDedupeKeep(options.keep);
+    const mergeValues = normalizeDedupeMergeValues(options.mergeValues);
+    return {
+        table,
+        keys,
+        keep,
+        ...(mergeValues ? { merge_values: mergeValues } : {}),
+    };
+}
+// Map the CLI --normalize flag to the wire normalizer vocabulary.
+export function normalizeDedupeNormalizer(value) {
+    const normalized = (readOption(value) ?? "exact").toLowerCase();
+    switch (normalized) {
+        case "exact":
+            return "exact";
+        case "email":
+            return "email";
+        case "domain":
+            return "domain";
+        case "linkedin":
+        case "linkedin-url":
+        case "linkedin_url":
+            return "linkedin_url";
+        case "fuzzy":
+        case "fuzzy-label":
+        case "fuzzy_label":
+            return "fuzzy_label";
+        default:
+            throw new OxygenError("invalid_dedupe_normalize", "--normalize must be exact, email, domain, linkedin, or fuzzy-label.", {
+                details: { normalize: value },
+                exitCode: 1,
+            });
+    }
+}
+export function normalizeDedupeKeep(value) {
+    const normalized = (readOption(value) ?? "oldest").replace(/-/g, "_");
+    if (normalized === "oldest" || normalized === "newest" || normalized === "most_complete") {
+        return normalized;
+    }
+    throw new OxygenError("invalid_dedupe_keep", "--keep must be oldest, newest, or most-complete.", {
+        details: { keep: value },
+        exitCode: 1,
+    });
+}
+export function normalizeDedupeMergeValues(value) {
+    const raw = readOption(value);
+    if (!raw)
+        return null;
+    const normalized = raw.replace(/-/g, "_");
+    if (normalized === "fill_empty")
+        return "fill_empty";
+    if (normalized === "none")
+        return null;
+    throw new OxygenError("invalid_dedupe_merge", "--merge-values must be fill-empty.", {
+        details: { merge_values: value },
+        exitCode: 1,
+    });
+}
+export function readSortJsonOption(value) {
+    const raw = readOption(value);
+    if (!raw)
+        return undefined;
+    const parsed = parseJsonArray(raw);
+    if (parsed.length === 0)
+        return undefined;
+    if (parsed.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry))) {
+        throw new OxygenError("invalid_sort", "--sort-json must be an array of sort-rule objects.", {
+            exitCode: 1,
+        });
+    }
+    return parsed;
+}

package/dist/command-families/tables/bundle-export.d.ts

@@ -0,0 +1,7 @@
+import type { WriteStream } from "node:fs";
+import { TablesExportBundleOptions, TablesExportOptions } from "./options.js";
+export declare function exportRows(table: string, options: TablesExportOptions): Promise<Record<string, unknown>>;
+export declare function exportTableBundle(table: string, options: TablesExportBundleOptions): Promise<Record<string, unknown>>;
+export declare function writeBundleLine(stream: WriteStream, line: string): Promise<void>;
+export declare function finishBundleStream(stream: WriteStream): Promise<void>;
+export declare function assertBundleSerializable(bundle: Record<string, unknown>, rowCount: number): void;