@oxygen-agent/cli 1.1014.136 → 1.1014.619

package/dist/commands/viewers.js

@@ -0,0 +1,72 @@
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { MANAGED_DATA_SUPPLIERS } from "@oxygen/shared/data-suppliers";
+import { Command } from "commander";
+export function registerViewersFamily(program, handleAsyncAction) {
+    program.addCommand(new Command("viewers")
+        .description("Read the named LinkedIn 'who viewed my profile' (WVMP) viewers into a Clay-like workspace table that leads with each person's photo, name and `viewed_account` (\"Viewed profile of\": every one of your connected accounts that person viewed). `import` arms (or resumes) a slow, durable background drip per account under a dedicated conservative read budget; `pause` switches an account off without touching rows or the table; `enrichment` switches standing paid full-profile enrichment of new viewers on/off. LinkedIn hides anonymous/private viewers, so the table is always a partial sample. `status` reports two counts with two denominators: `viewers_count` is named viewers captured from LinkedIn into the per-account mirror (a person who viewed two of your accounts counts twice) and `table_row_count` is rows in the table, one per viewer — they are not the same number and neither is a page or read counter.")
+        .addCommand(new Command("import")
+        .description("Start (or re-arm, or resume a paused account) a durable profile-viewers (WVMP) import. Named viewers drip into a workspace table (one row per viewer, upserted on provider_id) from the deduped per-account mirror over many ticks; poll `viewers status` to watch them accrue. Two columns are coarser than they look: `view_count` counts the capture walks a viewer re-appeared in (about one every 6 hours), not profile views, and `last_viewed_at` is approximate — LinkedIn only reports 'Viewed 3w ago'-style recency, stored as the earliest day it can mean. Do not run this for an account whose viewers already land through a LinkedIn capture feed (`viewers status` says `landing_via: feed`): it would arm a second writer into a different table. The import itself sends no messages and charges no Oxygen credits; `--enrich`/`--no-enrich` switch standing per-viewer paid enrichment on or off in the same call (omit to leave it as-is) — see `viewers enrichment`.")
+        .option("--account <ref>", "Sender account to import (sender id, connection id, or Unipile account id); also switches a paused account back on. Omit to import every active LinkedIn account.")
+        .option("--table <ref>", "Existing workspace table (id or slug) to import into. Omit to create or reuse a 'LinkedIn Profile Viewers' table.")
+        .option("--enrich", "Also switch on standing full-profile enrichment for new viewers (see `viewers enrichment`). Omit to leave enrichment as-is.")
+        .option("--no-enrich", "Also switch off standing full-profile enrichment. Omit to leave enrichment as-is.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("viewers import", options, () => {
+            const account = readOption(options.account);
+            const table = readOption(options.table);
+            return requestOxygen("/api/cli/linkedin/viewers/import", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(table ? { table } : {}),
+                    ...(options.enrich === undefined ? {} : { enrich: options.enrich }),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show durable profile-viewers (WVMP) import progress: `accounts[]` lists every connected LinkedIn account with its display_name, headline, picture_url, per-account `on` (true when switched on, whatever its health) and state (off|collecting|waiting|paused|attention) with state_note, last_read_at/next_read_at, and whether it is toggleable — plus a preview of the viewers table, `enrichment` (on, credits_per_person, columns — see `viewers enrichment`) and a deep-link to open it. Read job/org `health` before `last_error`, worst state wins: `landing` — every import lands somewhere (its own table, or the LinkedIn capture feed named in `landing_via`/`jobs[].landing`) and is due; `waiting` — it lands, but the last tick parked on the account's daily read quota until `next_tick_at` (a wait, not a fault); `paused` — an account was switched off with `viewers pause`; `viewers import --account <ref>` switches it back on; `stalled` — the landing feed is stopped or paused, or the import spent its retries; `health_note` carries the exact repair (`oxygen feeds resume <id>` or `viewers import`); `unbound` — armed with no table and no feed, reading LinkedIn every tick and writing nothing, without ever recording an error (repair: `viewers import`); `none` — nothing armed. Two counts, two denominators: `viewers_count` is named viewers captured from LinkedIn into the per-account mirror (`viewers_count_scope` says workspace or one account; a person who viewed two of your accounts counts twice), `table_row_count` is rows in the table (one per viewer). They diverge while landing lags capture.")
+        .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("viewers 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/viewers/status${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("pause")
+        .description("Switch the profile-viewers import off for one account or all: rows and the table stay exactly as they are, and `viewers import --account <ref>` switches it back on. Imports landed by a LinkedIn capture feed are not touched here — pause the feed instead with `oxygen feeds pause <id>`. Free.")
+        .option("--account <ref>", "Sender 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("viewers pause", options, () => {
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/linkedin/viewers/pause", {
+                method: "POST",
+                body: { ...(account ? { account } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("enrichment")
+        .description("Turn automatic full-profile enrichment of NEW profile viewers on or off for the viewers table (" + MANAGED_DATA_SUPPLIERS.scraper + " profile: about, current role and company, experience, education, location). This is STANDING credit spend, charged credits_per_person credits per enriched viewer, applied only to viewers first seen after `enrichment.enabled_at`, each delivery bounded by `enrichment.max_credits_per_delivery` (the plan default). Switching on adds the table's Person profile columns (a paid lookup plus its extractors); they stay, with their data, when switched off. Existing rows are never charged by it — enrich them on demand by running the Person profile column. `viewers status` shows `enrichment` (on, credits_per_person, enabled_at, max_credits_per_delivery, next_capture_at: when new viewers can next arrive); the runs appear on the table's Runs page. Requires exactly one of --on or --off.")
+        .option("--on", "Switch standing enrichment on for new viewers.")
+        .option("--off", "Switch standing enrichment off.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("viewers enrichment", options, () => {
+            if (options.on === options.off) {
+                throw new Error("Pass exactly one of --on or --off.");
+            }
+            return requestOxygen("/api/cli/linkedin/viewers/enrichment", {
+                method: "POST",
+                body: { enabled: options.on === true },
+            });
+        });
+    })));
+}

package/dist/commands/voice.d.ts

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

package/dist/commands/voice.js

@@ -0,0 +1,351 @@
+import { splitCommaList } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { Command } from "commander";
+/** The shared search/buy filters, in the snake_case the voice numbers route reads. */
+function voiceNumberFilters(options) {
+    const areaCode = readOption(options.areaCode);
+    const region = readOption(options.region);
+    const country = readOption(options.country);
+    return {
+        ...(areaCode ? { area_code: areaCode } : {}),
+        ...(region ? { in_region: region } : {}),
+        ...(country ? { iso_country: country.toUpperCase() } : {}),
+    };
+}
+export function registerVoiceFamily(program, handleAsyncAction) {
+    program.addCommand(new Command("voice")
+        .description("The call channel. `tasks` works the call queue — leads waiting for a HUMAN to dial, queued by sequence call steps, CRM records, table rows, and replies. Claiming takes a lease so two reps never dial the same prospect. `numbers` manages the dialing pool: list, search, buy, tag, cap, release. Nothing here places a call: a call is live audio a rep holds in the web softphone at /sequencer/calls (a beta feature: Settings → Beta features; 5 credits per connected minute), so the terminal works everything around it. Only `numbers buy --approved` starts a charge.")
+        .addCommand(new Command("tasks")
+        .description("Work the call queue: queue | list | claim | complete | extend | skip | override.\n\nA call that nobody answers is dispositioned for you from the call itself, which\nalso resumes any sequence enrollment parked on it — so `complete` and `skip`\nreport already_recorded:true rather than failing when that has happened. You log\nonly what a person said.\n\nWhat blocks a dial, and what you can do about it:\n  calling_window     lead's local time outside 09:00-20:00      waivable per lead\n  unknown_timezone   no timezone on the lead, so the window\n                     cannot be checked (fails closed)          waivable per lead\n  daily_cap          the chosen number hit today's dial cap     waivable per lead\n  suppressed         on the workspace do-not-call list          NEVER waivable\n  destination_blocked your numbers cannot reach that country    NEVER waivable\n\n`list` reports dialable, block_reason and block_detail per lead, plus\ndialable_count and blocked_by_reason for the page. Waive one with `override`.")
+        .addCommand(new Command("queue")
+        .description("Put a lead INTO the call queue. Idempotent: a lead who already has an open task comes back with created:false rather than a duplicate, because the queue guarantees one open call per person. Queuing is not dialing — it writes a row a human later acts on. Consumes 0 credits.")
+        .requiredOption("--phone <e164>", "The lead's number in E.164 (a leading + then 2-15 digits).")
+        .option("--name <name>", "The lead's name, shown on the dial screen.")
+        .option("--timezone <tz>", "IANA timezone (e.g. America/New_York). Calls are allowed 09:00-20:00 in the lead's local time; WITHOUT a timezone that window cannot be checked, so the guardrail fails closed and the lead cannot be dialed.")
+        .option("--override <guardrails>", "Comma-separated guardrails to waive for THIS lead: calling_window (the 09:00-20:00 local window), unknown_timezone, daily_cap. Do-not-call, credits, number health and destination coverage are never waivable.")
+        .option("--note <text>", "Talking points for the rep. Shown on the dial screen, never sent to the lead.")
+        .option("--assigned-user-id <id>", "Assign the call task to this workspace user.")
+        .option("--source <source>", "Origin: manual (default), crm, table, reply, sequence.")
+        .option("--priority <n>", "Higher sorts first in the queue.")
+        .option("--due <iso>", "ISO-8601 timestamp; the task stays out of the queue until then.")
+        .option("--crm-record <id>", "Bind the task to a CRM record.")
+        .option("--subject-provider <name>", "Bind the task to a subject in a CRM you already use (e.g. hubspot, attio) instead of an Oxygen record. Requires --subject-external-id.")
+        .option("--subject-external-id <id>", "That provider's own id for the person. Requires --subject-provider.")
+        .option("--table <id>", "Bind the task to a table.")
+        .option("--row <id>", "Bind the task to a table row.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice tasks queue", options, () => {
+            const phone = readOption(options.phone);
+            if (!phone)
+                throw new Error("--phone is required.");
+            const name = readOption(options.name);
+            const timezone = readOption(options.timezone);
+            const note = readOption(options.note);
+            const source = readOption(options.source);
+            const priority = readOption(options.priority);
+            const due = readOption(options.due);
+            const crmRecord = readOption(options.crmRecord);
+            const subjectProvider = readOption(options.subjectProvider);
+            const subjectExternalId = readOption(options.subjectExternalId);
+            // Caught server-side too (and by a CHECK), but failing here
+            // costs no round trip and names the missing flag.
+            if (Boolean(subjectProvider) !== Boolean(subjectExternalId)) {
+                throw new Error("--subject-provider and --subject-external-id must be passed together.");
+            }
+            const table = readOption(options.table);
+            const row = readOption(options.row);
+            const override = readOption(options.override);
+            return requestOxygen("/api/cli/voice/tasks", {
+                method: "POST",
+                body: {
+                    action: "queue",
+                    ...(readOption(options.assignedUserId) ? { assigned_user_id: readOption(options.assignedUserId) } : {}),
+                    lead_phone: phone,
+                    ...(name ? { lead_name: name } : {}),
+                    ...(timezone ? { lead_timezone: timezone } : {}),
+                    ...(note ? { note } : {}),
+                    ...(source ? { source } : {}),
+                    ...(priority ? { priority: Number(priority) } : {}),
+                    ...(due ? { due_at: due } : {}),
+                    ...(crmRecord ? { crm_record_id: crmRecord } : {}),
+                    ...(subjectProvider ? { subject_provider: subjectProvider } : {}),
+                    ...(subjectExternalId ? { subject_external_id: subjectExternalId } : {}),
+                    ...(table ? { table_id: table } : {}),
+                    ...(row ? { row_id: row } : {}),
+                    ...(override ? { guardrail_overrides: override } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("override")
+        .description("Waive a guardrail for ONE lead — the exception path for a prospect who asked to be called outside their window, or one whose timezone you know you do not have. Waivable: calling_window, unknown_timezone, daily_cap. NEVER waivable: do-not-call, credits, number health, and destination permissions (no flag makes a carrier accept a call it rejects). The waiver replaces any previous one; pass --guardrail none to clear it. The dial still records that the check failed and was waived. A lead can be blocked by more than one thing, so check still_blocked_by in the response — a waiver that did not make the lead dialable still succeeds. Consumes 0 credits.")
+        .requiredOption("--task <id>", "The call task to waive a guardrail on.")
+        .requiredOption("--guardrail <name>", "calling_window (waive the 09:00-20:00 local calling window) | unknown_timezone (dial without a known local time) | daily_cap (dial past the number's cap for today) | none (clear every waiver).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice tasks override", options, () => {
+            const task = readOption(options.task);
+            if (!task)
+                throw new Error("--task is required.");
+            const guardrail = readOption(options.guardrail);
+            if (!guardrail)
+                throw new Error("--guardrail is required.");
+            return requestOxygen("/api/cli/voice/tasks", {
+                method: "POST",
+                body: {
+                    action: "override",
+                    task_id: task,
+                    // "none" is the documented way to clear every waiver; the
+                    // server treats an empty list as "replace with nothing".
+                    guardrail_overrides: guardrail === "none" ? [] : guardrail,
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("list")
+        .description("List the call queue, best-first (highest priority, then earliest due). Defaults to every status; filter with --status.")
+        .option("--status <statuses>", "Comma-separated: pending, claimed, completed, skipped, canceled.")
+        .option("--source <source>", "Filter by origin: sequence, crm, table, reply, manual.")
+        .option("--sequence <id>", "Only tasks queued by this sequence.")
+        .option("--limit <n>", "Maximum tasks to return (1-200; default 50).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice tasks list", options, () => {
+            const params = new URLSearchParams();
+            const status = readOption(options.status);
+            if (status)
+                params.set("status", status);
+            const source = readOption(options.source);
+            if (source)
+                params.set("source", source);
+            const sequence = readOption(options.sequence);
+            if (sequence)
+                params.set("sequence_id", sequence);
+            const limit = readOption(options.limit);
+            if (limit)
+                params.set("limit", limit);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/voice/tasks${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("claim")
+        .description("Take the next due call task, or a specific one with --task. Returns a lease_token you must pass to `complete` — the lease is what stops a second rep dialing the same prospect. A specific task already held by someone else fails with 409 rather than being stolen.")
+        .option("--task <id>", "Claim this specific task instead of the next due one.")
+        .option("--sequence <id>", "Only claim from this sequence's queue.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice tasks claim", options, () => {
+            const task = readOption(options.task);
+            const sequence = readOption(options.sequence);
+            return requestOxygen("/api/cli/voice/tasks", {
+                method: "POST",
+                body: {
+                    action: "claim",
+                    ...(task ? { task_id: task } : {}),
+                    ...(sequence ? { sequence_id: sequence } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("complete")
+        .description("Record the outcome of a claimed call. Lease-guarded: a lease reclaimed mid-call fails with 409 rather than overwriting the new holder's outcome.")
+        .requiredOption("--task <id>", "The claimed task's id.")
+        .requiredOption("--lease <token>", "The lease_token returned by `claim`.")
+        .requiredOption("--disposition <value>", "connected, no_answer, voicemail, busy, wrong_number, not_interested, callback_requested, meeting_booked, do_not_call, failed.")
+        .option("--notes <text>", "Free-text call notes.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice tasks complete", options, () => {
+            const task = readOption(options.task);
+            if (!task)
+                throw new Error("--task is required.");
+            const lease = readOption(options.lease);
+            if (!lease)
+                throw new Error("--lease is required.");
+            const disposition = readOption(options.disposition);
+            if (!disposition)
+                throw new Error("--disposition is required.");
+            const notes = readOption(options.notes);
+            return requestOxygen("/api/cli/voice/tasks", {
+                method: "POST",
+                body: {
+                    action: "complete",
+                    task_id: task,
+                    lease_token: lease,
+                    disposition,
+                    ...(notes ? { notes } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("extend")
+        .description("Renew a claimed task's 15-minute lease. Completing needs a live lease, so a longer call must heartbeat or its outcome and notes are rejected as stale.")
+        .requiredOption("--task <id>", "The claimed task's id.")
+        .requiredOption("--lease <token>", "The lease_token returned by `claim`.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice tasks extend", options, () => {
+            const task = readOption(options.task);
+            if (!task)
+                throw new Error("--task is required.");
+            const lease = readOption(options.lease);
+            if (!lease)
+                throw new Error("--lease is required.");
+            return requestOxygen("/api/cli/voice/tasks", {
+                method: "POST",
+                body: { action: "extend", task_id: task, lease_token: lease },
+            });
+        });
+    }))
+        .addCommand(new Command("skip")
+        .description("Drop a task out of the queue without dialing (bad data, a rep pass, a guardrail block). Needs no lease — the guardrail gate skips tasks it never claimed.")
+        .requiredOption("--task <id>", "The task to skip.")
+        .requiredOption("--reason <text>", "Why it was skipped; stored on the task.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice tasks skip", options, () => {
+            const task = readOption(options.task);
+            if (!task)
+                throw new Error("--task is required.");
+            const reason = readOption(options.reason);
+            if (!reason)
+                throw new Error("--reason is required.");
+            return requestOxygen("/api/cli/voice/tasks", {
+                method: "POST",
+                body: { action: "skip", task_id: task, reason },
+            });
+        });
+    })))
+        .addCommand(new Command("numbers")
+        .description("The org's dialing pool: list | search | requirements | buy | tag | cap | release. Searching is free; buying previews the recurring monthly charge until you pass --approved.")
+        .addCommand(new Command("list")
+        .description("List the org's phone numbers with warm-up state, daily cap, and what each one costs per month. Optional --tag narrows to one campaign's numbers.")
+        .option("--tag <tags>", "Comma-separated workspace tags — matches phone numbers carrying ANY of these tags (see `oxygen tags list`).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice numbers list", options, () => {
+            const params = new URLSearchParams();
+            const tags = splitCommaList(options.tag);
+            if (tags.length > 0)
+                params.set("tag", tags.join(","));
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/voice/numbers${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("search")
+        .description("Find numbers you could buy, by area code or region. Free: searching buys nothing and reserves nothing, so a listed number can be gone by the time you buy it.")
+        .option("--area-code <code>", "Area code, e.g. 415 (US/CA).")
+        .option("--region <code>", "State or region, e.g. CA.")
+        .option("--country <iso>", "ISO country code (default US). Run `voice numbers requirements` first for a country outside US/CA.")
+        .option("--limit <n>", "How many to return (1-30; default 10).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice numbers search", options, () => {
+            const limit = readOption(options.limit);
+            return requestOxygen("/api/cli/voice/numbers", {
+                method: "POST",
+                body: {
+                    action: "search",
+                    ...voiceNumberFilters(options),
+                    ...(limit ? { limit: Number(limit) } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("requirements")
+        .description("What a country demands before it sells a number (business details, documents). Free, and read live from the carrier.")
+        .option("--country <iso>", "ISO country code (default US).")
+        .option("--end-user <type>", "business (default) or individual.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice numbers requirements", options, () => {
+            const country = readOption(options.country);
+            const endUser = readOption(options.endUser);
+            return requestOxygen("/api/cli/voice/numbers", {
+                method: "POST",
+                body: {
+                    action: "requirements",
+                    ...(country ? { iso_country: country.toUpperCase() } : {}),
+                    ...(endUser ? { end_user_type: endUser } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("buy")
+        .description("Buy phone numbers for the dialer. A number is a RECURRING monthly charge until you release it, and it starts in warm-up on a reduced daily cap. Previews by default: the preview names the numbers and the monthly credits, and nothing is bought until you pass --approved. At most 10 per order.")
+        .option("--count <n>", "How many numbers to buy (1-10). Not needed with --number.")
+        .option("--number <e164s>", "Exact numbers to buy, comma-separated (from `voice numbers search`).")
+        .option("--area-code <code>", "Pick numbers in this area code.")
+        .option("--region <code>", "Pick numbers in this state or region.")
+        .option("--country <iso>", "ISO country code (default US).")
+        .option("--approved", "Actually buy. Without this you get a preview and nothing is bought or charged.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice numbers buy", options, () => {
+            const numbers = splitCommaList(options.number);
+            const count = readOption(options.count);
+            if (numbers.length === 0 && !count)
+                throw new Error("Pass --count <n> or --number <e164,...>.");
+            return requestOxygen("/api/cli/voice/numbers", {
+                method: "POST",
+                body: {
+                    action: "buy",
+                    ...voiceNumberFilters(options),
+                    ...(numbers.length > 0 ? { phone_numbers: numbers } : { count: Number(count) }),
+                    ...(options.approved === true ? { approved: true } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("tag")
+        .description("Replace a phone number's workspace tags (whole set; `--tags \"\"` clears) — e.g. pool the numbers dialing one campaign behind its tag. See `oxygen tags list` for the vocabulary.")
+        .argument("<number>", "Phone number in E.164 (e.g. +14155550142) or its id.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (number, options) => {
+        await handleAsyncAction("voice numbers tag", options, () => requestOxygen(`/api/cli/voice/numbers/${encodeURIComponent(number)}/tags`, {
+            method: "POST",
+            body: { tags: splitCommaList(options.tags) },
+        }));
+    }))
+        .addCommand(new Command("cap")
+        .description("Adjust one number's daily dial cap. `voice numbers list` shows every number's cap, today's ceiling and dials left.")
+        .addCommand(new Command("set")
+        .description("Set one phone number's daily dial cap (dials per day, 1-300; new numbers get 100). A warming number still dials at its ramp's ceiling until it has warmed. Consumes no credits. Example: `oxygen voice numbers cap set +14155550142 --daily-cap 150`.")
+        .argument("<number>", "Phone number in E.164 (e.g. +14155550142) or its id.")
+        .requiredOption("--daily-cap <n>", "New daily dial cap, a whole number from 1 to 300.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (number, options) => {
+        await handleAsyncAction("voice numbers cap set", options, () => {
+            const raw = readOption(options.dailyCap);
+            if (!raw)
+                throw new Error("--daily-cap is required.");
+            return requestOxygen(`/api/cli/voice/numbers/${encodeURIComponent(number)}/cap`, {
+                method: "PATCH",
+                body: { daily_cap: Number(raw) },
+            });
+        });
+    })))
+        .addCommand(new Command("release")
+        .description("Give a number back to the carrier and stop its monthly charge. IRREVERSIBLE — the number returns to the carrier's pool and can be taken by someone else within minutes; you cannot get it back. Previews by default; pass --approved to actually release.")
+        .requiredOption("--number <e164>", "The number to release, e.g. +14155550142.")
+        .option("--approved", "Actually release it. Without this you get a preview and nothing changes.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("voice numbers release", options, () => {
+            const number = readOption(options.number);
+            if (!number)
+                throw new Error("--number is required.");
+            return requestOxygen("/api/cli/voice/numbers", {
+                method: "POST",
+                body: {
+                    action: "release",
+                    phone_number: number,
+                    ...(options.approved === true ? { approved: true } : {}),
+                },
+            });
+        });
+    }))));
+}

package/dist/commands/whatsapp.d.ts

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