callkaro-cli-unofficial 0.1.0

package/README.md

@@ -0,0 +1,196 @@
+# cku
+
+An unofficial fork of the [CallKaro CLI](https://www.npmjs.com/package/@callkaro-official/cli). It installs as `cku`, so it sits alongside the official `ck` without either one overwriting the other.
+
+Manage voice agents, calls, phone numbers, batch campaigns, simulations and analytics from the terminal.
+
+```
+cku agents list
+cku calls make --agent <id> --to <number> --test
+cku accounts use tejas@acme.com
+```
+
+---
+
+## Why this exists
+
+Three reasons, all of them things the official CLI can't do.
+
+**It doesn't fight the official CLI for a name.** Both packages write to the same global `node_modules/.bin`. If both were called `ck`, whichever npm install ran last would silently take over. You'd type `ck`, get official behaviour, and get no signal anything had changed. `cku` cannot collide.
+
+**It holds several accounts at once.** The official CLI keeps one session. This one keeps a file per account, and can pin an account to a folder, so two agents working in two directories can't switch each other out from under themselves.
+
+**It fixes three upstream bugs.** Details and evidence in [`docs/BUG-REPORT.md`](docs/BUG-REPORT.md).
+
+---
+
+## Install
+
+```bash
+npm install --global callkaro-cli-unofficial
+```
+
+Or, to work on it directly:
+
+```bash
+git clone https://github.com/TejasLamba2006/callkaro-cli-unofficial
+cd callkaro-cli-unofficial
+npm install && npm run build && npm link
+```
+
+Node 18 or newer.
+
+---
+
+## How it fits together
+
+![Runtime flow: cku commands through the shared layer to the backend, config, and the skill pack](docs/images/runtime-flow.webp)
+
+Every arrow above is a real import or a real call, checked against the source. `api.ts` is the only thing that touches the network. `config.ts` is the only thing that reads a token, which is why every route to the backend goes through it. The ASCII version below says the same thing for the terminal:
+
+```
+┌─ cku ─────────────────────────────────────────────┐
+│  index.ts     commander wiring, 44 subcommands     │
+│     ↓                                             │
+│  commands/    agents, calls, numbers, batches,     │
+│               sim, analytics, audits, skills       │
+│     ↓                                             │
+│  lib/         api.ts, config.ts, agentUpdate.ts,   │
+│               looseJson.ts, ui.ts, catalog.ts     │
+└──────┬────────────────────────────────────────────┘
+       ↓
+  account resolution, highest precedence first
+       │
+  CK_TOKEN → CK_ACCOUNT → ./.cku.json → global → none
+       │
+       ↓
+  backend.callkaro.ai
+  /cli/*  ·  61 endpoints  ·  Bearer ck_5b02…
+```
+
+One thing worth knowing up front: the official CLI ships **compiled output only**. Its npm package has `dist/` and nothing else: no TypeScript, no tests, no build config, and it isn't in any public repo. So this is a reconstruction. The `/cli/*` contract was rebuilt from the published bundle, and the command surface matches v4.0.0 exactly (44 subcommands against the official 40; the four extras are the `accounts` group).
+
+The public API at `api.callkaro.ai` is a different thing entirely, with an `X-API-KEY` header and three documented endpoints. This CLI doesn't use it. [`docs/architecture.md`](docs/architecture.md) covers the boundaries, and [`docs/api.md`](docs/api.md) has the full endpoint inventory.
+
+---
+
+## Several accounts
+
+```bash
+cku login                              # add an account
+cku accounts                           # list them, * marks the active one
+cku accounts use <email>               # change the global default
+cku accounts remove <email>            # forget one
+```
+
+### Pin an account to a folder
+
+If you're running more than one agent at a time, this is the part that matters.
+
+```bash
+cd ~/work/bot-alpha && cku accounts bind alpha@acme.com
+cd ~/work/bot-beta  && cku accounts bind beta@other.com
+```
+
+`bind` writes a `.cku.json` into that directory containing just the account slug and no token, so it's safe to commit. Every `cku` command in that folder (and anything nested under it) uses that account, regardless of what the global default says.
+
+Why this matters: `cku accounts use` changes **shared** state. Two agents in two folders both calling it would overwrite each other, and whichever wrote last would silently redirect the other bot's commands to the wrong CallKaro account. No error, just wrong data. A bound folder never reads shared state at all, so that can't happen.
+
+```
+cku accounts status
+```
+
+tells you which account is in effect *and where the choice came from*: env var, this folder, or the global default. Worth running first when something looks off, since acting on the wrong account is the most damaging mistake available here.
+
+Override for a single command with `CK_ACCOUNT=<email> cku whoami`.
+
+---
+
+## Fixes over the official CLI
+
+Full write-ups, with line numbers and reproduction steps, in [`docs/BUG-REPORT.md`](docs/BUG-REPORT.md).
+
+**`agents update --set` silently deleted agent configuration.** Send a partial `voice_configuration` and the backend replaces the whole object, so nine keys, including the voice itself, were dropped, and the command reported success. The agent kept working; it just couldn't make calls. The fix already exists upstream as `deepMerge`, with a comment describing exactly this problem. Nothing ever called it.
+
+**`skills install` failed on every run on Windows.** `tar` was handed an absolute path, and `C:/Users/...` gets read as a `<host>:<path>` remote spec, so tar tried to connect to a machine named "C". Since the temp path always sits under a drive root, this never worked there. It's also the only way to install the skill pack, so an agent couldn't bootstrap itself on Windows. Linux and macOS were never affected; no drive letters, no colon in a path.
+
+**`agents export` can't always be re-imported.** For some agents the export response omits a field the CLI's own validator requires, so the round trip fails. That part needs a backend fix; a workaround is in the `callkaro-cli` skill.
+
+My own first port of this fix had a worse version of the same bug: I merged against the agent's default version, so updating any other version could swap its voice for the default's. That's fixed and covered by a test, and the details are in [`docs/official-fixes.md`](docs/official-fixes.md).
+
+---
+
+## Staying current
+
+A daily workflow checks npm for a newer `@callkaro-official/cli` and, when it finds one, regenerates the provider catalogue and opens a PR onto the `official` branch. It never merges anything itself.
+
+| Branch | What's on it |
+|---|---|
+| `official` | Clean base. Changes only arrive through sync PRs. |
+| `main` | `official` plus your customizations. Your working branch. |
+
+To take an update: review the PR, merge into `official`, then merge `official` into `main`.
+
+Worth knowing what the sync does and doesn't do. It regenerates `src/data/catalog.json` — the provider tables and the per-slot LLM model lists — because those change when the dashboard changes. It does **not** port command code, because the official source isn't available, so that's maintained by hand. The PR lists which commands were added or removed so you know what to look at.
+
+Keep your customizations in as few files as you can. That diff is the one you have to resolve on every update.
+
+---
+
+## Development
+
+```bash
+npm run build          # tsc -> dist/, copy endpoints.json, chmod +x
+npm test               # build, then node --test
+npm run test:only      # tests without rebuilding
+npm run dev            # build and run
+npm run catalog:sync   # regenerate the catalogue: provider tables + per-slot LLM lists, from the server
+npm run catalog:check  # fail if catalog.json disagrees with the server snapshot (offline)
+npm run catalog:check:live  # same, against the live server (needs `cku dashboard login`)
+```
+
+Single test file:
+
+```bash
+node --test tests/agentUpdate.test.js
+```
+
+210 tests. No linter or formatter is configured.
+
+### Layout
+
+`src/index.ts` is commander wiring and almost nothing else. Every command, flag and description is declared there. `src/commands/` holds one module per command group. `src/lib/` holds the shared layer, and that's where the rules worth knowing live:
+
+- **`api.ts`** is the only place that talks to the backend. Adding an endpoint means adding a method here, not a raw `fetch` in a command.
+- **`looseJson.ts`** has two parsers, chosen by where the text came from. Values from argv get a repair pass, because PowerShell strips quotes out of single-quoted arguments and `--set '{"name":"x"}'` arrives as `{name:x}`. Values from files or stdin are parsed strictly, since the shell never touched them and a real typo should be reported rather than guessed at.
+- **`agentUpdate.ts`** merges updates into objects the backend replaces wholesale, so a partial update doesn't drop its siblings.
+- **`ui.ts`** sets `process.exitCode` rather than calling `process.exit()`. On Windows, exiting while a fetch socket is still closing trips a libuv assertion that aborts with code 127 and a pile of C-level noise.
+
+### Regenerating docs
+
+Both of these read from the code, so they can't drift:
+
+```bash
+node scripts/gen-api-inventory.js          # endpoint tables in docs/api.md
+node scripts/gen-cli-reference.js ../callkaro-skills/skills/callkaro-cli/REFERENCE.md
+```
+
+---
+
+## Skills
+
+The CLI installs a skill pack for Claude Code and other coding agents, so an agent can drive `cku` without being told how.
+
+```bash
+cku skills install --claude          # this fork's pack
+cku skills install --claude --official   # the upstream pack
+cku skills update                    # refresh every install
+```
+
+Targets include `--cursor --copilot --gemini --windsurf --roo --opencode --cline --codex --all`, plus `--project` to install into a repo rather than your user account. Skills ship from GitHub, so a new one reaches users without a CLI release.
+
+---
+
+## License
+
+Apache-2.0, matching the upstream CLI.

package/dist/commands/accounts.js

@@ -0,0 +1,275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectAccount = exports.keyValue = void 0;
+exports.loginCommand = loginCommand;
+exports.registerCommand = registerCommand;
+exports.logoutCommand = logoutCommand;
+exports.whoamiCommand = whoamiCommand;
+exports.configCommand = configCommand;
+exports.accountsCommand = accountsCommand;
+exports.accountsBindCommand = accountsBindCommand;
+exports.accountsUnbindCommand = accountsUnbindCommand;
+exports.accountsStatusCommand = accountsStatusCommand;
+exports.accountsUseCommand = accountsUseCommand;
+exports.accountsRemoveCommand = accountsRemoveCommand;
+const prompts_1 = __importDefault(require("prompts"));
+const path_1 = require("path");
+const config_1 = require("../lib/config");
+Object.defineProperty(exports, "projectAccount", { enumerable: true, get: function () { return config_1.projectAccount; } });
+const browserAuth_1 = require("../lib/browserAuth");
+const dashboardAuth_1 = require("../lib/dashboardAuth");
+const ui_1 = require("../lib/ui");
+Object.defineProperty(exports, "keyValue", { enumerable: true, get: function () { return ui_1.keyValue; } });
+/** `ck login` — add or replace an account, then make it active. */
+async function loginCommand(opts) {
+    // Default: sign in through the browser so no password is typed in a terminal.
+    if (!opts.password) {
+        // browserAuth saves the session and prints the one success line.
+        if (!(await (0, browserAuth_1.browserAuth)('login')))
+            process.exitCode = 1;
+        return;
+    }
+    try {
+        const { api } = (0, config_1.getClient)();
+        const answers = await (0, prompts_1.default)([
+            { type: opts.email ? null : 'text', name: 'email', message: 'Email' },
+            { type: 'password', name: 'password', message: 'Password' },
+        ], { onCancel: () => process.exit(1) });
+        const email = opts.email || answers.email;
+        const password = answers.password;
+        if (!email || !password)
+            return (0, ui_1.handleError)(new Error('Email and password are required'));
+        const res = await api.login(email, password);
+        (0, ui_1.success)((0, config_1.saveLogin)(res.user?.email || email, { token: res.token, user: res.user }));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function registerCommand(opts) {
+    try {
+        if (opts.google) {
+            const user = await (0, browserAuth_1.browserAuth)('signup');
+            if (!user)
+                process.exitCode = 1;
+            return;
+        }
+        const { api } = (0, config_1.getClient)();
+        const answers = await (0, prompts_1.default)([
+            { type: opts.email ? null : 'text', name: 'email', message: 'Email' },
+            { type: opts.name ? null : 'text', name: 'name', message: 'Your name' },
+            { type: 'password', name: 'password', message: 'Password' },
+        ], { onCancel: () => process.exit(1) });
+        const email = opts.email || answers.email;
+        const name = opts.name || answers.name;
+        if (!email || !name || !answers.password) {
+            return (0, ui_1.handleError)(new Error('Email, name and password are required'));
+        }
+        await api.registerStart(email);
+        (0, ui_1.info)(`We sent a 6-digit code to ${email}.`);
+        const { otp } = await (0, prompts_1.default)([{ type: 'text', name: 'otp', message: 'Verification code' }], { onCancel: () => process.exit(1) });
+        if (!otp)
+            return (0, ui_1.handleError)(new Error('Verification code is required'));
+        const res = await api.registerVerify({ email, name, password: answers.password, otp });
+        (0, ui_1.info)('Account created.');
+        (0, ui_1.success)((0, config_1.saveLogin)(res.user?.email || email, { token: res.token, user: res.user }));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function logoutCommand() {
+    let revoked = false;
+    try {
+        const { api, cfg } = (0, config_1.getClient)();
+        if (cfg.token)
+            await api.logout();
+        revoked = Boolean(cfg.token);
+    }
+    catch (err) {
+        // Revocation is best-effort: clear locally even if the server is unreachable.
+        (0, ui_1.info)(err instanceof Error ? `Server revoke failed (${err.message}); clearing the local session anyway.` : 'Server revoke failed; clearing the local session anyway.');
+    }
+    if (process.env.CK_TOKEN) {
+        // clearSession leaves stored accounts alone under CK_TOKEN.
+        if (revoked)
+            (0, ui_1.success)('Revoked the CK_TOKEN session. Stored accounts are untouched.');
+        else
+            (0, ui_1.info)('The CK_TOKEN session was not revoked. Stored accounts are untouched.');
+        (0, ui_1.info)('  Unset CK_TOKEN to fall back to your stored accounts.');
+        return;
+    }
+    const email = (0, config_1.clearSession)();
+    if (!email)
+        return void (0, ui_1.info)('Not signed in — nothing to log out of.');
+    (0, ui_1.success)(`Logged out of ${email}. Run \`cku login\` to sign back in.`);
+}
+async function whoamiCommand(opts) {
+    try {
+        const { api } = (0, config_1.getClient)();
+        const res = await api.me();
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        const user = res.user || res;
+        if (!user?.email) {
+            (0, ui_1.fail)('Could not read your account details. Run `cku login`.');
+            process.exitCode = 1;
+            return;
+        }
+        (0, ui_1.success)(`Logged in as ${user.email}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function configCommand() {
+    const cfg = (0, config_1.loadConfig)();
+    const envToken = process.env.CK_TOKEN;
+    const accounts = (0, config_1.listAccounts)();
+    (0, ui_1.info)('Effective configuration:');
+    (0, ui_1.info)('');
+    (0, ui_1.info)(`  backend      ${(0, config_1.backendUrl)()}`);
+    (0, ui_1.info)(`  web          ${(0, config_1.webUrl)()}`);
+    (0, ui_1.info)(`  skills repo  ${(0, config_1.skillsRepo)()}`);
+    (0, ui_1.info)(`  config dir   ${config_1.configPath.replace(/config\.json$/, '')}`);
+    if (envToken) {
+        (0, ui_1.info)('  session      CK_TOKEN from the environment (ignores stored accounts)');
+    }
+    else if (cfg.token) {
+        const src = (0, config_1.accountSource)();
+        const where = src === 'env' ? 'CK_ACCOUNT' : src === 'project' ? 'this folder' : 'global default';
+        (0, ui_1.info)(`  account      ${cfg.email || 'unknown'}  (from ${where})`);
+    }
+    else {
+        (0, ui_1.info)('  session      not signed in — run `cku login`');
+    }
+    (0, ui_1.info)(`  accounts     ${accounts.length} saved${accounts.length ? ` — \`cku accounts list\`` : ''}`);
+}
+/** `cku accounts` — list / switch / add / remove stored logins. */
+async function accountsCommand(opts) {
+    const accounts = (0, config_1.listAccounts)();
+    const active = (0, config_1.activeAccount)();
+    // Never print tokens: this output ends up in agent transcripts and CI logs.
+    if (opts.json) {
+        return void console.log(JSON.stringify(accounts.map(({ token, ...a }) => ({ ...a, signedIn: Boolean(token) })), null, 2));
+    }
+    if (!accounts.length) {
+        return void (0, ui_1.info)('No accounts saved. Run `cku login` to add one.');
+    }
+    (0, ui_1.table)(['', 'EMAIL', 'CK TOKEN', 'DASHBOARD', 'SAVED'], accounts.map((a) => [
+        active && (0, config_1.slugFor)(a.email || '') === active ? '*' : '',
+        a.email || '(unknown)',
+        a.token ? 'yes' : 'no',
+        a.dashboard?.token ? (0, dashboardAuth_1.expiryLabel)(a.dashboard.token) : '—',
+        a.savedAt ? new Date(a.savedAt).toLocaleString('en-US') : '',
+    ]));
+    const source = (0, config_1.accountSource)();
+    (0, ui_1.info)(`\n* = active account (${source === 'env' ? 'CK_ACCOUNT' : source === 'project' ? 'this folder\'s .cku.json' : 'global default'}).`);
+    (0, ui_1.info)('CK TOKEN gates /cli/* commands. DASHBOARD gates /auth/* and /v2/*, and is a separate');
+    (0, ui_1.info)('login that expires in 24h — add one with `cku dashboard login`.');
+    if (source === 'global') {
+        (0, ui_1.info)('  Tip: `cku accounts bind <email>` pins an account to this folder, so parallel');
+        (0, ui_1.info)('  agents in different folders cannot switch each other out from under themselves.');
+    }
+}
+/** Selecting a signed-out account succeeds, but commands will fail until it signs in. */
+function warnIfSignedOut(a) {
+    if (!a.token)
+        (0, ui_1.info)(`  ${a.email} is signed out — run \`cku login\` to sign it back in.`);
+}
+/** `cku accounts bind <email>` — pin an account to this folder (`.cku.json`). */
+async function accountsBindCommand(emailOrSlug, opts) {
+    const accounts = (0, config_1.listAccounts)();
+    const wanted = (0, config_1.slugFor)(emailOrSlug);
+    const match = accounts.find((a) => (0, config_1.slugFor)(a.email || '') === wanted) ||
+        accounts.find((a) => (0, config_1.slugFor)(a.email || '').startsWith(wanted));
+    if (!match) {
+        return (0, ui_1.handleError)(new Error(`No saved account matches "${emailOrSlug}".\n` +
+            `  Saved: ${accounts.map((a) => a.email).join(', ') || '(none)'}\n` +
+            `  Run \`cku accounts list\` first, or \`cku login\` to add one.`));
+    }
+    if (opts.global) {
+        (0, config_1.setActiveAccount)(match.email || emailOrSlug);
+        (0, ui_1.success)(`Default account set to ${match.email} (global — affects every unbound folder).`);
+        return warnIfSignedOut(match);
+    }
+    const path = (0, path_1.join)(process.cwd(), '.cku.json');
+    (0, config_1.bindProjectAccount)(match.email || emailOrSlug);
+    (0, ui_1.success)(`This folder now uses ${match.email}.`);
+    (0, ui_1.info)(`  wrote ${path}`);
+    (0, ui_1.info)('  Commit it if the whole team should use the same account here.');
+    warnIfSignedOut(match);
+}
+/** `cku accounts unbind` — drop this folder's binding. */
+async function accountsUnbindCommand() {
+    if ((0, config_1.unbindProjectAccount)())
+        (0, ui_1.success)('Removed this folder\'s binding. Now using the global default.');
+    else {
+        (0, ui_1.fail)('This folder has no .cku.json binding.');
+        process.exitCode = 1;
+    }
+}
+/** `cku accounts status` — which account, and where the choice came from. */
+async function accountsStatusCommand() {
+    const accounts = (0, config_1.listAccounts)();
+    const active = (0, config_1.activeAccount)();
+    const source = (0, config_1.accountSource)();
+    (0, ui_1.info)('Account resolution');
+    (0, ui_1.info)('');
+    (0, ui_1.info)(`  in effect    ${active ? accounts.find((a) => (0, config_1.slugFor)(a.email || '') === active)?.email || active : '(none)'}`);
+    (0, ui_1.info)(`  from         ${source === 'env' ? 'CK_ACCOUNT environment variable'
+        : source === 'project' ? `.cku.json in ${process.cwd()}`
+            : source === 'global' ? 'global default'
+                : 'nothing — no account selected'}`);
+    (0, ui_1.info)(`  saved        ${accounts.length} account(s)`);
+    if (source === 'global') {
+        (0, ui_1.info)('');
+        (0, ui_1.info)('  This is shared state: another agent running `cku accounts use` would change it.');
+        (0, ui_1.info)('  Run `cku accounts bind <email>` here to make this folder independent.');
+    }
+}
+/** `cku accounts use <email>` — make a stored account active. */
+async function accountsUseCommand(emailOrSlug) {
+    const accounts = (0, config_1.listAccounts)();
+    const wanted = (0, config_1.slugFor)(emailOrSlug);
+    const match = accounts.find((a) => (0, config_1.slugFor)(a.email || '') === wanted) ||
+        accounts.find((a) => (0, config_1.slugFor)(a.email || '').startsWith(wanted));
+    if (!match) {
+        return (0, ui_1.handleError)(new Error(`No saved account matches "${emailOrSlug}".\n` +
+            `  Saved: ${accounts.map((a) => a.email).join(', ') || '(none)'}\n` +
+            `  Run \`cku accounts list\` to see them.`));
+    }
+    (0, config_1.setActiveAccount)(match.email || emailOrSlug);
+    (0, ui_1.success)(`Now using ${match.email}.`);
+    warnIfSignedOut(match);
+}
+/** `cku accounts remove <email> [--yes]` — forget a stored login. */
+async function accountsRemoveCommand(emailOrSlug, opts) {
+    const accounts = (0, config_1.listAccounts)();
+    const wanted = (0, config_1.slugFor)(emailOrSlug);
+    const match = accounts.find((a) => (0, config_1.slugFor)(a.email || '') === wanted) ||
+        accounts.find((a) => (0, config_1.slugFor)(a.email || '').startsWith(wanted));
+    if (!match)
+        return (0, ui_1.handleError)(new Error(`No saved account matches "${emailOrSlug}".`));
+    if (!opts.yes) {
+        const { ok } = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'ok',
+            message: `Remove the saved login for ${match.email}?`,
+            initial: false,
+        });
+        if (!ok)
+            return void (0, ui_1.info)('Cancelled.');
+    }
+    const slug = (0, config_1.slugFor)(match.email || '');
+    (0, config_1.removeAccount)(slug);
+    (0, ui_1.success)(`Removed ${match.email}.`);
+    // Leave .cku.json alone — it may be committed — but say it now dangles.
+    if ((0, config_1.projectAccount)() === slug) {
+        (0, ui_1.info)(`  Warning: this folder's .cku.json still binds ${match.email}, which is no longer saved.`);
+        (0, ui_1.info)('  Run `cku accounts unbind` here, or `cku login` to add the account back.');
+    }
+}

package/dist/commands/agentPhone.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setInboundCommand = setInboundCommand;
+exports.setOutboundCommand = setOutboundCommand;
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+/** Read the current inbound number ids off an agent detail response. */
+function currentInboundIds(agent) {
+    const list = Array.isArray(agent?.inboundPhoneNumbers) ? agent.inboundPhoneNumbers : [];
+    return list.map((v) => (typeof v === 'object' ? v?._id : v)).filter(Boolean);
+}
+/**
+ * `cku agents set-inbound <agentId> --number <id> [--remove]`
+ *
+ * Reuses PUT /cli/agents/:id (full inbound array replacement). The backend
+ * enforces the one-inbound-agent-per-number rule and returns 409 on conflict.
+ */
+async function setInboundCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    if (!opts.number)
+        return (0, ui_1.handleError)(new Error('--number <phoneNumberId> is required'));
+    try {
+        const { agent } = await api.getAgent(agentId);
+        const ids = new Set(currentInboundIds(agent));
+        if (opts.remove)
+            ids.delete(opts.number);
+        else
+            ids.add(opts.number);
+        await api.updateAgent(agentId, undefined, { inboundPhoneNumbers: [...ids] });
+        (0, ui_1.success)(`${opts.remove ? 'Removed' : 'Set'} inbound number on agent ${agentId}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku agents set-outbound <agentId> --number <id>` (or `--clear`) */
+async function setOutboundCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    if (!opts.clear && !opts.number)
+        return (0, ui_1.handleError)(new Error('--number <phoneNumberId> or --clear is required'));
+    try {
+        await api.updateAgent(agentId, undefined, { outboundPhoneNumber: opts.clear ? null : opts.number });
+        (0, ui_1.success)(opts.clear ? `Cleared outbound number on agent ${agentId}.` : `Set outbound number on agent ${agentId}.`);
+        if (!opts.clear)
+            (0, ui_1.info)('Note: an outbound number may be shared by multiple agents.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}