@oxygen-agent/cli 1.1014.135 → 1.1014.618

package/dist/commands/lead-sourcing.d.ts

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

package/dist/commands/lead-sourcing.js

@@ -0,0 +1,52 @@
+import { parseJsonObject } from "../cli-values.js";
+import { readFileIfPresent } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+function readSpecFileBody(path) {
+    const text = readFileSync(resolve(path), "utf8");
+    try {
+        return { spec: parseJsonObject(text) };
+    }
+    catch (error) {
+        if (error instanceof OxygenError && error.code === "invalid_json") {
+            return { spec_prompt: text };
+        }
+        throw error;
+    }
+}
+export function registerLeadSourcingFamily(program, handleAsyncAction) {
+    program
+        .command("lead-sourcing")
+        .description("ICP-gated lead sourcing planning and audit commands.")
+        .addCommand(new Command("plan")
+        .description("Compile a natural-language ICP into an account-first lead sourcing plan.")
+        .requiredOption("--prompt <file|text>", "ICP prompt text, or a local file path containing the prompt.")
+        .option("--materialize-preview", "Create a preview table for the plan. Defaults to no table side effect.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("lead-sourcing plan", options, () => requestOxygen("/api/cli/lead-sourcing/plan", {
+            method: "POST",
+            body: {
+                prompt: readFileIfPresent(options.prompt),
+                ...(options.materializePreview ? { materialize_preview: true } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("audit")
+        .description("Audit a sourced lead table against a lead-sourcing spec.")
+        .argument("<table>", "Table id or slug.")
+        .requiredOption("--spec <file>", "JSON LeadSourcingSpec file, or a text prompt file to compile into a spec.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("lead-sourcing audit", options, () => requestOxygen("/api/cli/lead-sourcing/audit", {
+            method: "POST",
+            body: {
+                table,
+                ...readSpecFileBody(options.spec),
+            },
+        }));
+    }));
+}

package/dist/commands/limits.d.ts

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

package/dist/commands/limits.js

@@ -0,0 +1,54 @@
+import { addContractFlags, readContractFlags } from "../contract-flags.js";
+import { requestOxygen } from "../http-client.js";
+import { addProviderLimitFlags, providerLimitBody, providerLimitQuery } from "../workspace-utility-flags.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { LIMITS_READ_QUERY_CONTRACT, limitsReadQueryIssue } from "@oxygen/shared/contracts/limits-read";
+import { Command } from "commander";
+export function registerLimitsFamily(program, handleAsyncAction, billingDocsUrl) {
+    program
+        .command("limits")
+        .description("Plan-tier limits, spend-safety defaults, per-channel sending limits, and storage capacity posture. `limits show --section capacity` returns storage alone, including which Table is full.")
+        .addHelpText("after", "\nRun `oxygen limits show --json` to see your current plan's API and webhook rates, Table and workspace storage headroom, and the next scheduled change. The $999 and $1,999 rows-per-Table increases remain held until capacity testing passes.\n")
+        .addCommand(addContractFlags(new Command("show")
+        .description("Compare every plan size: price, monthly credits, volume bonus and price per 100 credits (`plan_bands`). Show your plan band and its limits beside every plan size's (API rate, webhook ingress, storage, import file size, columns per auto-run, signals feed, spend defaults incl. Agent and Copilot caps, fastest workflow schedule), the per-channel sending limits every plan shares (emails per mailbox, WhatsApp, LinkedIn, calls) and its workflow Code-step and run-attempt limits, plus Tables capacity usage naming the largest Table. Each plan size's storage says whether it is in force, scheduled to change on a date, or awaiting its rows-per-Table capacity test, with the values it moves to. `spend_safety_defaults.enterprise_agent_run_default` gives Enterprise the $1,999 band’s in-force Agent default with no contract override; `agent_run_approved_max_credits` is the maximum for an explicitly approved higher run. `spend_safety_defaults.applies_to` says what each spend default bounds: an unattended trigger delivery, a table auto-run batch, one Agent run, or the attended Copilot. `web_url` opens the same view in the web app (Settings → Plan limits), including any scheduled change. Read-only; spends no credits. Recovery: " + billingDocsUrl + "."), LIMITS_READ_QUERY_CONTRACT)
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("limits show", options, () => {
+            const projection = readContractFlags(options, LIMITS_READ_QUERY_CONTRACT);
+            const issue = limitsReadQueryIssue(projection);
+            if (issue)
+                throw new OxygenError("invalid_request", issue);
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(projection))
+                if (value !== undefined)
+                    params.set(key, String(value));
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/limits${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("provider")
+        .description("Per-provider call-rate overrides and BYOK daily warning thresholds. With no subcommand, lists policies (same as `limits provider list`).")
+        .addCommand(addProviderLimitFlags(new Command("list")
+        .description("List enforced workspace provider overrides and the plan-tier BYOK daily threshold with its enforcement mode; read-only, 0 credits."), "list")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        const suffix = providerLimitQuery(options, "list");
+        await handleAsyncAction("limits provider list", options, () => requestOxygen(`/api/cli/limits/provider${suffix ? `?${suffix}` : ""}`));
+    }), { isDefault: true })
+        .addCommand(addProviderLimitFlags(new Command("set")
+        .description("Set an enforced provider request limit; admin/owner only. Approve the exact provider, operation and window before running; execution saves the policy. Raising a cap can permit more use. 0 credits."), "set")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("limits provider set", options, () => requestOxygen("/api/cli/limits/provider", {
+            method: "POST",
+            body: providerLimitBody(options),
+        }));
+    }))
+        .addCommand(addProviderLimitFlags(new Command("delete")
+        .description("Delete one provider override after approving its selector; admin/owner only, 0 credits; remaining matches apply, otherwise a code default if defined. Upstream and other limits remain. Read the separate BYOK plan threshold and enforcement mode with limits provider list."), "delete")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        const query = providerLimitQuery(options, "delete");
+        await handleAsyncAction("limits provider delete", options, () => requestOxygen(`/api/cli/limits/provider?${query.toString()}`, { method: "DELETE" }));
+    })));
+}

package/dist/commands/linkedin.d.ts

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

package/dist/commands/linkedin.js

@@ -0,0 +1,275 @@
+import { readPositiveInt } from "../cli-values.js";
+import { readCsvOption, readPositiveNumber } from "../command-support.js";
+import { addContractFlags, readContractFlags } from "../contract-flags.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { LINKEDIN_SENT_INVITES_QUERY_CONTRACT } from "@oxygen/shared/contracts/linkedin-invites-list";
+import { Command } from "commander";
+const LINKEDIN_SENT_INVITES_FLAG_OVERLAY = {
+    account: { valueName: "<ref>", help: "Scope to one sender account (sender id, connection id, or Unipile account id).", parse: readOption },
+    limit: { valueName: "<n>", help: "Maximum invitations to return.", parse: readPositiveInt },
+    cursor: { valueName: "<cursor>", parse: readOption },
+};
+// `linkedin intent autoenroll` request body. The route reads `captures` (the wire
+// name of the capture kinds) plus `post_id`/`post`, so the CSV `--kinds` flag maps
+// onto `captures` here rather than inventing a second server field.
+//
+// An omitted `--kinds` sends NO captures key at all: the server then defaults to the
+// captures `linkedin intent setup` already provisioned for this sender, and a
+// client-side default list would instead CREATE captures the user never agreed to.
+// Same reasoning for the caps — omitted means "inherit the plan-tier ceiling and the
+// sender's ramped daily cap", which only the server can resolve.
+function buildLinkedinIntentAutoenrollBody(options) {
+    const account = readOption(options.account);
+    if (!account)
+        throw new Error("--account is required.");
+    if (options.disable && options.approved) {
+        throw new OxygenError("conflicting_flags", "Pass either --disable (revoke the standing grant) or --approved (arm it), not both.", { exitCode: 1 });
+    }
+    // Revoking only ever narrows authority, so it carries the scope and nothing else —
+    // forwarding caps or a sequence on a disable would imply they still bind something.
+    const kinds = readCsvOption(options.kinds);
+    const post = readOption(options.post);
+    if (options.disable) {
+        return {
+            account,
+            disable: true,
+            ...(kinds.length > 0 ? { captures: kinds } : {}),
+            ...(post ? { post } : {}),
+        };
+    }
+    const sequence = readOption(options.sequence);
+    const postUrl = readOption(options.postUrl);
+    // Both readers THROW on a typed-but-unusable cap (0, negative, non-numeric) rather
+    // than returning undefined, which matters here: undefined means "inherit the server
+    // default", so coercing a typed `--max-enrolls-per-day 0` to absent would answer a
+    // request to enrol NOBODY by granting the sender's full ramped daily cap. Narrowing
+    // must never widen. Pinned by the cap tests in index.test.ts.
+    const maxCreditsPerCycle = readPositiveNumber(options.maxCreditsPerCycle);
+    const maxEnrollsPerDay = readPositiveInt(options.maxEnrollsPerDay);
+    return {
+        account,
+        ...(sequence ? { sequence } : {}),
+        ...(kinds.length > 0 ? { captures: kinds } : {}),
+        ...(maxCreditsPerCycle !== undefined ? { max_credits_per_cycle: maxCreditsPerCycle } : {}),
+        ...(maxEnrollsPerDay !== undefined ? { max_enrolls_per_day: maxEnrollsPerDay } : {}),
+        ...(options.includeExistingNetwork ? { include_existing_network: true } : {}),
+        ...(post ? { post } : {}),
+        ...(postUrl ? { post_url: postUrl } : {}),
+        ...(options.approved ? { approved: true } : {}),
+    };
+}
+export function registerLinkedinFamily(program, handleAsyncAction) {
+    program.addCommand(new Command("linkedin")
+        .description("Put your own LinkedIn network in a table and keep it current. `linkedin network setup` captures everyone you are connected to and everyone who follows you into one self-refreshing 'LinkedIn Network' table (free, read-only on your account, paced so the account is never at risk); `linkedin network status` reports the pace and `linkedin network pause` switches it off. `linkedin invitations setup` does the same for open connection requests — received and sent — in one self-updating table. Also home to `linkedin intent` (engagement capture) and `linkedin ingestion status` (every LinkedIn read drip and each account's remaining read budget).")
+        .addCommand(new Command("network")
+        .description("Capture everyone already in your LinkedIn network \u2014 the people you are connected to and the people who follow you \u2014 into one self-refreshing workspace table you can filter, enrich and enroll from. READ-ONLY on your LinkedIn account: it lists your own connections and followers and nothing else. It sends no messages, no connection requests, and does not visit anyone's profile. Runs as a slow background drip on its OWN per-account read budget, so it cannot slow down or starve anything else the account does: about 2,000 people a day while it first walks your network (40 reads of up to 50 people), then a light check a few times a day for new arrivals. Only inside each account's own 07:00-22:00 working hours, spaced minutes apart, never in a burst; a newly armed account eases in over its first two weeks. LinkedIn does not say how big a network is until the walk has been through it, so a large network takes days \u2014 `status` reports the rate, not a completion date it cannot know. Free \u2014 no Oxygen credits for this read; it uses your connected LinkedIn account, whose seat or credit reservation has its own terms.")
+        .addCommand(new Command("setup")
+        .description("Arm (or re-arm) network capture. Creates or reuses one merged 'LinkedIn Network' table and starts a connections drip and a followers drip per account, both writing into that one table deduped on LinkedIn member id \u2014 somebody who is both shows as 'both' in the Relationship column. This is a STANDING permission: capture keeps running until you switch it off with `linkedin network pause`, and a LinkedIn account you connect later is armed automatically. A newly connected account eases into full read speed over its first two weeks. Nothing is sent and no credits are charged. The response names each account it armed (`senders[].display_name`) \u2014 check it is yours before leaving it running.")
+        .option("--account <ref>", "Account to capture (sender id, connection id, or Unipile account id). Omit to capture every connected LinkedIn account.")
+        .option("--table <ref>", "Existing workspace table (id or slug) to capture into. Omit to create or reuse 'LinkedIn Network'.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin network setup", options, () => {
+            const account = readOption(options.account);
+            const table = readOption(options.table);
+            return requestOxygen("/api/cli/tables/linkedin-network", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(table ? { table } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show network capture progress: `accounts[]` lists every connected LinkedIn account with its headline, `on` (switched on or not), and state (off|collecting|waiting|paused|attention); which accounts are armed, what each one may actually read TODAY after its warm-up ramp (`reads_per_day_now` / `people_per_day_now`), and per-drip state \u2014 including whether each half is still doing its first full walk ('backfill') or has switched to the light check ('delta'). `pace` states the rate in people per day and says plainly that no completion date exists until the first walk finishes, rather than inventing one. Also previews the table and deep-links to it. A capture sitting in 'backfill' for days is working as designed, not stuck.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin network status", options, () => requestOxygen("/api/cli/tables/linkedin-network"));
+    }))
+        .addCommand(new Command("pause")
+        .description("Switch network capture off: the worker stops reading that account's connections and followers until you run `linkedin network setup` again. Pass --account to pause one account (the one you armed by mistake, say); omit it to pause every armed account. The table and its rows stay exactly as they are, and re-arming continues the walk where it stopped rather than starting over. A standalone `connections import` or `followers import` is not touched. Free.")
+        .option("--account <ref>", "Account to pause (sender id, connection id, or Unipile account id). Omit to pause every armed LinkedIn account.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin network pause", options, () => {
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/tables/linkedin-network/pause", {
+                method: "POST",
+                body: { ...(account ? { account } : {}) },
+            });
+        });
+    })))
+        .addCommand(new Command("intent")
+        .description("Capture organic LinkedIn intent in durable OXYGEN Workflows + linked Tables. People are deduped; every reaction, comment, weekly profile view, new follower, and new connection is retained as a touchpoint. Engagement does not create CRM leads.")
+        .addCommand(new Command("setup")
+        .description("Create/reuse the canonical OXYGEN Tables, link them, and arm capture-only worker-backed engagement workflows for profile viewers, followers, and connections. Optionally add a recurring post-engager workflow with --post.")
+        .requiredOption("--account <ref>", "Connected LinkedIn sender to read through.")
+        .option("--post <social_id>", "Optional composite social_id for a post whose reactions + comments should be watched.")
+        .option("--post-url <url>", "Optional public post URL retained with the post watch.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin intent setup", options, () => {
+            const account = readOption(options.account);
+            const post = readOption(options.post);
+            const postUrl = readOption(options.postUrl);
+            return requestOxygen("/api/cli/linkedin/intent", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(post ? { post } : {}),
+                    ...(postUrl ? { post_url: postUrl } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show the canonical intent tables, their linked-table deep-links, and the capture feeds filling them. Workspace-wide: it lists every sender's captures and takes no --account; filter by the sender_account_id on each capture instead.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin intent status", options, () => requestOxygen("/api/cli/linkedin/intent"));
+    }))
+        // A sibling of `setup`, not a flag on it: setup is free, idempotent and
+        // needs no approval ("make sure these captures and tables exist"), while
+        // this is a STANDING authorization to contact people on every future
+        // cycle. One verb carrying both postures would make the safe default
+        // ambiguous on the surface a founder reads first.
+        .addCommand(new Command("autoenroll")
+        .description("Authorize the captures armed by `linkedin intent setup` to enroll the people they capture into a sequence — the step that turns captured rows into outreach. PREVIEWS BY DEFAULT and writes nothing: it prints the resolved sender and its effective daily caps, the sequence, per-capture create-vs-patch, the live audience split (already 1st-degree / needs an invite / suppressed / already owned by another sender, and — while a capture still baselines — how many are recorded rather than contacted), anything that would make --approved fail before it writes, the resolved spend + enroll caps and where each came from, and a 7-day send forecast. Re-run with --approved to arm a STANDING grant: every later cycle enrolls newly captured people under those caps without asking again, including people you have never seen. This play is a drip, not a blast — a connections import walks LinkedIn on a metered budget (15 relations reads a day by default, ~50 people a read), so a real network lands over days, and a sender on the warm-up ramp is floored at 5 invites and 5 messages a day for its first three days no matter what caps you set. Revoke at any time with `--disable`.")
+        .requiredOption("--account <ref>", "Connected LinkedIn sender whose captures are authorized (sender id, connection id, or Unipile account id).")
+        .option("--sequence <ref>", "Sequence (id or slug) the captured people are enrolled into. Required to arm: a standing grant has to name the journey it puts people in.")
+        .option("--kinds <csv>", "Captures to authorize: connections, followers, profile_viewers, own_posts, post. Defaults to every capture `linkedin intent setup` already provisioned for this sender; naming a kind it never provisioned creates that capture.")
+        .option("--max-credits-per-cycle <n>", "Hard credit ceiling for one cycle of this grant. Omit to inherit your plan tier's per-delivery default (the preview prints which applied). Capturing through a connected account costs 0 credits; a cookieless harvest does not.")
+        .option("--max-enrolls-per-day <n>", "Cap on new people enrolled per UTC day. Omit to inherit the sender's effective — warm-up-ramped — daily message cap.")
+        .option("--include-existing-network", "Also reach the connections you ALREADY have. Without this flag the first cycle records everyone already captured as a silent baseline and only enrolls people who connect, follow, view, or engage from now on.")
+        .option("--post <social_id>", "Composite post social_id from `oxygen posts get`. Required when the `post` capture is authorized.")
+        .option("--post-url <url>", "Public LinkedIn post URL retained with the post capture.")
+        .option("--approved", "Arm the standing grant. Without it nothing is written and nobody is contacted.")
+        .option("--disable", "Revoke the standing grant for this sender. Needs no approval — it only narrows authority. The captures and their tables keep filling; only the permission to contact people is cleared.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin intent autoenroll", options, () => requestOxygen("/api/cli/linkedin/intent/autoenroll", {
+            method: "POST",
+            body: buildLinkedinIntentAutoenrollBody(options),
+        }));
+    })))
+        .addCommand(new Command("ingestion")
+        .description("Inspect the LinkedIn ingestion drips that read your network, post engagers, and message history into the workspace.")
+        .addCommand(new Command("status")
+        .description("Unified status of every LinkedIn ingestion drip (connections import, engagement harvest, message-history backfill) plus each account's remaining ingest read budget for the day.")
+        .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin ingestion status", options, () => {
+            const account = readOption(options.account);
+            const params = new URLSearchParams();
+            if (account)
+                params.set("account", account);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/ingestion/status${suffix ? `?${suffix}` : ""}`);
+        });
+    })))
+        .addCommand(new Command("connections")
+        .description("Send LinkedIn connection invitations from a sender account.")
+        .addCommand(new Command("invite")
+        .description("Send a LinkedIn connection invitation. A real external social action gated behind approval: prints a preview by default and only sends when you pass --approved. The recipient can be a member provider id (ACo…) or a profile URL / public identifier. The per-account invite quota and warm-up ramp are enforced server-side, and already-invited recipients are de-duplicated automatically.")
+        .requiredOption("--recipient <id_or_url>", "Recipient LinkedIn provider id (ACo…) or profile URL / public identifier.")
+        .option("--account <ref>", "Sender account that sends the invite (sender id, connection id, or Unipile account id). Omit for the org default.")
+        .option("--message <text>", "Optional invitation note (~300 chars max).")
+        .option("--approved", "Actually send the invite. Omit to preview only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin connections invite", options, () => {
+            const recipient = readOption(options.recipient);
+            const account = readOption(options.account);
+            const message = readOption(options.message);
+            return requestOxygen("/api/cli/linkedin/connections/invite", {
+                method: "POST",
+                body: {
+                    ...(recipient ? { recipient } : {}),
+                    ...(account ? { account } : {}),
+                    ...(message ? { message } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
+    })))
+        .addCommand(new Command("invitations")
+        .description("Open LinkedIn connection requests on your own accounts. `setup` keeps one self-updating 'LinkedIn Open Connection Requests' table of every pending request — people who asked to connect with you (received) and requests you sent (sent) — and marks each one accepted or no_longer_pending when it disappears; `status` and `pause` manage it. `list` and `withdraw` act on the sent requests directly.")
+        .addCommand(new Command("setup")
+        .description("Switch on the open connection requests table. Creates or reuses one 'LinkedIn Open Connection Requests' table and checks each chosen account about twice a day, inside that account's working hours: every pending request, received and sent, is a row with the person, the account it is on (`account`), its `direction` and its `status`. A request that disappears is marked `accepted` when the person is now a connection, otherwise `no_longer_pending` (LinkedIn does not say whether it was declined, withdrawn or expired); acceptances seen live are marked within minutes. READ-ONLY on LinkedIn: nothing is accepted, declined, withdrawn or sent. Free — no Oxygen credits; the reads count against each account's daily LinkedIn read budget. Accounts connected later stay off until you switch them on.")
+        .option("--account <ref>", "Account to switch on (sender id, connection id, or Unipile account id). Omit to switch on every connected LinkedIn account.")
+        .option("--table <ref>", "Existing workspace table (id or slug) to write into. Omit to create or reuse 'LinkedIn Open Connection Requests'.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations setup", options, () => {
+            const account = readOption(options.account);
+            const table = readOption(options.table);
+            return requestOxygen("/api/cli/tables/linkedin-open-invites", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(table ? { table } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show the open connection requests table: `accounts[]` lists every connected LinkedIn account with `on`, its state (off|collecting|waiting|paused|attention), and when it was last and will next be checked. Also previews the table and deep-links to it.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations status", options, () => requestOxygen("/api/cli/tables/linkedin-open-invites"));
+    }))
+        .addCommand(new Command("pause")
+        .description("Stop checking open connection requests for one account (--account) or every account. The table and its rows stay; `linkedin invitations setup` switches it back on. Free.")
+        .option("--account <ref>", "Account to pause (sender id, connection id, or Unipile account id). Omit to pause every account.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations pause", options, () => {
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/tables/linkedin-open-invites/pause", {
+                method: "POST",
+                body: { ...(account ? { account } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("withdraw")
+        .description("Withdraw pending sent LinkedIn invitations. A real external social action gated behind approval: prints the resolved target list by default and only withdraws when you pass --approved. Select targets with --ids (a comma-separated id list from `linkedin invitations list`) OR --older-than <days> (pending invites older than N days, among the 100 most recent sent) — not both. Idempotent: an invite that is already gone counts as withdrawn.")
+        .option("--ids <a,b>", "Comma-separated invitation ids to withdraw (from `linkedin invitations list`).")
+        .option("--older-than <days>", "Withdraw pending sent invites older than this many days (among the 100 most recent sent) instead of an explicit id list.")
+        .option("--account <ref>", "Sender account (sender id, connection id, or Unipile account id). Omit for the org default.")
+        .option("--approved", "Actually withdraw. Omit to preview the target list only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations withdraw", options, () => {
+            const ids = (options.ids ?? "").split(",").map((id) => id.trim()).filter(Boolean);
+            const olderThan = readPositiveInt(options.olderThan);
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/linkedin/connections/invite/withdraw", {
+                method: "POST",
+                body: {
+                    ...(ids.length > 0 ? { invitation_ids: ids } : {}),
+                    ...(olderThan !== undefined ? { older_than_days: olderThan } : {}),
+                    ...(account ? { account } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(addContractFlags(new Command("list")
+        .description("List the account's pending sent LinkedIn invitations with their invitation ids — the ids `linkedin invitations withdraw --ids` cancels. Read-only provider fetch: no provider write or credits. --cursor resumes the same sender's returned continuation. For received requests too, kept in a table that updates itself, use `linkedin invitations setup`."), LINKEDIN_SENT_INVITES_QUERY_CONTRACT, LINKEDIN_SENT_INVITES_FLAG_OVERLAY)
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations list", options, () => {
+            const selectors = readContractFlags(options, LINKEDIN_SENT_INVITES_QUERY_CONTRACT, LINKEDIN_SENT_INVITES_FLAG_OVERLAY);
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(selectors))
+                if (value !== undefined && value !== null)
+                    params.set(key, String(value));
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/connections/invites-sent${suffix ? `?${suffix}` : ""}`);
+        });
+    }))));
+}

package/dist/commands/login.d.ts

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