callkaro-cli-unofficial 0.1.0

package/dist/commands/models.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelsCommand = modelsCommand;
+const dashboardApi_1 = require("../lib/dashboardApi");
+const ui_1 = require("../lib/ui");
+const agentUpdate_1 = require("../lib/agentUpdate");
+const catalog_1 = require("../lib/catalog");
+/**
+ * `cku models` — what the server actually accepts, per slot.
+ *
+ * The point of this command is that the answer changes. `ENUMS` used to carry a
+ * hardcoded list of 7 ids while the server accepted 44 for agent models, so
+ * `agents update --set '{"model":"…"}'` rejected values that work fine in the
+ * dashboard.
+ *
+ * With a dashboard session this reads the live `/auth/get-user` payload, which is
+ * the same one the validator uses, so the two cannot drift apart. Without one it
+ * reads the identical lists out of `catalog.json` — the file `catalog:sync` last
+ * overlaid from the server, and the one `npm run catalog:check` compares against
+ * it. Either way the answer is the server's; the only difference is how fresh.
+ */
+/** Field -> slot, mirroring MODEL_SLOTS in lib/agentUpdate.ts. */
+const SLOTS = [
+    { field: 'model', slot: 'agent', note: 'the agent\'s own LLM' },
+    { field: 'secondary_model', slot: 'agent', note: 'secondary LLM' },
+    { field: 'postcallmodel', slot: 'post-call', note: 'post-call analysis' },
+];
+const OTHER_SLOTS = [
+    'capability', 'filler', 'simulation', 'chat-agent',
+    'call-analyzer', 'ai-auditor', 'kpi-rca', 'workflow-analytics',
+];
+/**
+ * The server's lists, or the shipped copy. A missing dashboard session is an
+ * ordinary state, not an error — the shipped table is good enough to plan an
+ * update with, and refusing to print it would push people back to guessing.
+ */
+async function readSlots() {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().getUser();
+        const llm = res?.catalogs?.llmModels || {};
+        if (!Object.keys(llm).length)
+            throw new Error('the response carried no model catalogue');
+        // Keep the validator in step with what is on screen, so a value copied from
+        // this output is not rejected a moment later.
+        (0, agentUpdate_1.applyLiveModels)(res?.catalogs);
+        return { llm, source: 'the server, now' };
+    }
+    catch (err) {
+        if (!Object.keys(catalog_1.LLM_MODELS).length) {
+            return { llm: {}, source: '', error: err };
+        }
+        return { llm: catalog_1.LLM_MODELS, source: 'catalog.json, last synced from the server' };
+    }
+}
+async function modelsCommand(opts) {
+    const { llm, source, error } = await readSlots();
+    if (!Object.keys(llm).length) {
+        return (0, ui_1.handleError)(new Error(`Could not read the model catalogue from the server, and catalog.json carries none.\n` +
+            `  ${error.message}\n` +
+            '  Sign in with `cku dashboard login`, or refresh the shipped copy with `npm run catalog:sync`.'));
+    }
+    if (opts.json)
+        return void console.log(JSON.stringify(llm, null, 2));
+    if (opts.slot) {
+        const list = llm[opts.slot];
+        if (!list) {
+            const known = Object.keys(llm).sort().join(', ');
+            return (0, ui_1.handleError)(new Error(`No "${opts.slot}" slot in the server catalogue.\n  Slots: ${known}`));
+        }
+        (0, ui_1.info)(`${opts.slot} · ${list.length} model(s)\n`);
+        for (const m of list)
+            (0, ui_1.info)(`  ${m}`);
+        return;
+    }
+    (0, ui_1.info)('Model slots, and the fields each one governs:\n');
+    (0, ui_1.table)(['FIELD', 'SLOT', 'COUNT', 'GOVERNS'], SLOTS.map((s) => [s.field, s.slot, (llm[s.slot] || []).length, s.note || '']));
+    const other = OTHER_SLOTS.filter((s) => llm[s]?.length);
+    if (other.length) {
+        (0, ui_1.info)('\nOther slots the server exposes (not agent fields):');
+        (0, ui_1.table)(['SLOT', 'COUNT'], other.map((s) => [s, llm[s].length]));
+    }
+    const agentList = llm.agent || [];
+    if (agentList.length) {
+        (0, ui_1.info)(`\n${agentList.length} models for --set model / secondary_model, including:`);
+        // Show a sample rather than all 44: the full list is one flag away, and a
+        // wall of ids buries the point.
+        (0, ui_1.info)(`  ${agentList.slice(0, 12).join(', ')}`);
+        if (agentList.length > 12)
+            (0, ui_1.info)(`  … and ${agentList.length - 12} more — cku models --slot agent`);
+    }
+    const post = llm['post-call'] || [];
+    if (post.length) {
+        (0, ui_1.info)(`\n${post.length} for --set postcallmodel: ${post.join(', ')}`);
+    }
+    (0, ui_1.info)(`\nSource: ${source}.`);
+    if (source !== 'the server, now') {
+        (0, ui_1.info)('  `cku dashboard login` re-reads it live; `npm run catalog:check` reports how far it has drifted.');
+    }
+}

package/dist/commands/numbers.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numbersListCommand = numbersListCommand;
+exports.numbersCatalogCommand = numbersCatalogCommand;
+exports.numbersBuyCommand = numbersBuyCommand;
+exports.numbersSpamCommand = numbersSpamCommand;
+exports.numbersUnspamCommand = numbersUnspamCommand;
+exports.numbersReleaseCommand = numbersReleaseCommand;
+const prompts_1 = __importDefault(require("prompts"));
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+function fmtDate(v) {
+    if (!v)
+        return '';
+    const d = new Date(v);
+    return isNaN(d.getTime()) ? '' : d.toLocaleDateString('en-US', { month: 'long', day: 'numeric', year: 'numeric' });
+}
+const agentsCol = (list) => list && list.length ? list.map((a) => a.name).join('\n') : '';
+const isObjectId = (s) => /^[0-9a-fA-F]{24}$/.test(s);
+/** Digits only — so "+91 98…", "91-98…" and "9198…" all compare equal. */
+const digits = (s) => (s || '').replace(/\D/g, '');
+/**
+ * Accept either a phone-number id or the number itself (with or without `+`,
+ * spaces or dashes). Numbers are resolved to their id against the user's list,
+ * so `cku numbers spam 918244464128` works like the id form.
+ */
+async function resolveNumberId(api, input, pool = 'mine') {
+    if (isObjectId(input))
+        return input;
+    const wanted = digits(input);
+    if (!wanted)
+        throw new Error(`"${input}" is not a phone number or id`);
+    const { phoneNumbers } = pool === 'catalog' ? await api.numbersCatalog() : await api.listNumbers();
+    const matches = (phoneNumbers || []).filter((n) => digits(n.phoneNumber) === wanted);
+    if (matches.length === 0) {
+        throw new Error(pool === 'catalog'
+            ? `No buyable number matches ${input} (see \`cku numbers catalog\`)`
+            : `You don't own a number matching ${input} (see \`cku numbers list\`)`);
+    }
+    if (matches.length > 1)
+        throw new Error(`${input} matches ${matches.length} numbers — pass the id instead`);
+    return matches[0]._id;
+}
+async function numbersListCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const { phoneNumbers } = await api.listNumbers();
+        const list = phoneNumbers || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(list, null, 2));
+        if (!list.length)
+            return void (0, ui_1.info)('No phone numbers yet.');
+        (0, ui_1.table)(['NUMBER', 'ID', 'PURCHASED', 'SPAM', 'STATUS', 'INBOUND AGENT', 'OUTBOUND AGENTS'], list.map((n) => [
+            `+${n.phoneNumber}`,
+            n._id,
+            fmtDate(n.allotedOn),
+            n.spammed ? 'spam' : '',
+            n.unrented ? 'released' : 'active',
+            n.inboundAgent ? n.inboundAgent.name : '',
+            agentsCol(n.outboundAgents),
+        ]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function numbersCatalogCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const { phoneNumbers, pricepernumber } = await api.numbersCatalog();
+        const list = phoneNumbers || [];
+        if (opts.json)
+            return void console.log(JSON.stringify({ phoneNumbers: list, pricepernumber }, null, 2));
+        if (!list.length)
+            return void (0, ui_1.info)('No numbers available to buy right now.');
+        (0, ui_1.info)(`Price per number: ₹${pricepernumber}\n`);
+        (0, ui_1.table)(['NUMBER', 'ID', 'COUNTRY'], list.map((n) => [`+${n.phoneNumber}`, n._id, n.countryCode || '']));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function numbersBuyCommand(numberOrId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const numberId = await resolveNumberId(api, numberOrId, 'catalog');
+        const { phoneNumbers, pricepernumber } = await api.numbersCatalog();
+        const number = (phoneNumbers || []).find((n) => n._id === numberId);
+        if (!number) {
+            return (0, ui_1.handleError)(new Error('That number is not in the buyable pool (already taken or invalid id).'));
+        }
+        if (!opts.yes) {
+            const { ok } = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'ok',
+                message: `Buy +${number.phoneNumber} for ₹${pricepernumber}? This deducts credits.`,
+                initial: false,
+            });
+            if (!ok)
+                return void (0, ui_1.info)('Cancelled.');
+        }
+        const res = await api.buyNumber(numberId, pricepernumber);
+        return void (0, ui_1.success)(res.message || `Bought +${number.phoneNumber}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/**
+ * Spam is a single toggle endpoint (`PUT /cli/numbers/:id/spam` with a boolean),
+ * so marking and unmarking share one code path. `cku numbers spam --off` and
+ * `cku numbers unspam` both land here — `unspam` just exists so it's findable.
+ */
+async function setSpamFlag(numberOrId, spam) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const numberId = await resolveNumberId(api, numberOrId);
+        const res = await api.setSpam(numberId, spam);
+        (0, ui_1.success)(res.message || `Number ${spam ? 'marked as spam' : 'unmarked as spam'}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function numbersSpamCommand(numberOrId, opts) {
+    return setSpamFlag(numberOrId, !opts.off);
+}
+async function numbersUnspamCommand(numberOrId) {
+    return setSpamFlag(numberOrId, false);
+}
+async function numbersReleaseCommand(numberOrId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const numberId = await resolveNumberId(api, numberOrId);
+        if (!opts.yes) {
+            const { ok } = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'ok',
+                message: 'Release (unrent) this number? It will be unassigned from all agents.',
+                initial: false,
+            });
+            if (!ok)
+                return void (0, ui_1.info)('Cancelled.');
+        }
+        const res = await api.releaseNumber(numberId);
+        (0, ui_1.success)(res.message || 'Released.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/ongoing.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ongoingStatusCommand = ongoingStatusCommand;
+exports.ongoingControlCommand = ongoingControlCommand;
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+async function ongoingStatusCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.ongoingStatus();
+        const data = res.data || res;
+        if (opts.json)
+            return void console.log(JSON.stringify(data, null, 2));
+        const summary = data.agent_tasks_summary || {};
+        const paused = data.agent_pause_summary || {};
+        const agentIds = Object.keys(summary);
+        (0, ui_1.info)(`User paused: ${data.user_paused ? 'yes' : 'no'}   Window: ${data.min_trigger_time ?? '—'}–${data.max_trigger_time ?? '—'}\n`);
+        if (!agentIds.length)
+            return void console.log('No queued calls.');
+        (0, ui_1.table)(['AGENT ID', 'QUEUED', 'STATUS'], agentIds.map((id) => [id, String(summary[id] ?? 0), paused[id] ? 'Paused' : 'Active']));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku ongoing pause|resume|clear [--agent <id>]` — no `--agent` means the whole account. */
+async function ongoingControlCommand(action, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        if (opts.agent)
+            await api.ongoingAgent(action, opts.agent);
+        else
+            await api.ongoingUser(action);
+        (0, ui_1.success)(`${action} ${opts.agent ? `agent ${opts.agent}` : 'all agents'} — done.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/secrets.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secretsListCommand = secretsListCommand;
+exports.secretsSetCommand = secretsSetCommand;
+exports.secretsRemoveCommand = secretsRemoveCommand;
+exports.secretsRenameCommand = secretsRenameCommand;
+const prompts_1 = __importDefault(require("prompts"));
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+function validateName(input) {
+    const name = input.trim();
+    if (!name)
+        throw new Error('Secret name is required');
+    if (name.length > 256)
+        throw new Error('Secret name must be at most 256 characters');
+    return name;
+}
+/** An untouched secret — value blanked so the server keeps what it has. */
+const preserve = (secret) => ({ name: secret.name, value: '', originalName: secret.name });
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => (data += chunk));
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}
+async function readSecretValue(name, fromStdin) {
+    if (fromStdin) {
+        if (process.stdin.isTTY)
+            throw new Error('--stdin requires piped or redirected input');
+        return (await readStdin()).trim();
+    }
+    const answer = await (0, prompts_1.default)({ type: 'password', name: 'value', message: `Value for ${name}` });
+    return typeof answer.value === 'string' ? answer.value.trim() : undefined;
+}
+async function secretsListCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const { secrets } = await api.listSecrets();
+        const list = secrets || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(list, null, 2));
+        if (!list.length)
+            return void (0, ui_1.info)('No secrets saved.');
+        (0, ui_1.table)(['NAME', 'VALUE'], list.map((secret) => [secret.name, secret.value]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function secretsSetCommand(inputName, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const name = validateName(inputName);
+        const value = await readSecretValue(name, opts.stdin);
+        if (value === undefined)
+            return void (0, ui_1.info)('Cancelled.');
+        if (!value)
+            throw new Error('Secret value cannot be empty');
+        if (value.length > 8192)
+            throw new Error('Secret value must be at most 8192 characters');
+        const { secrets } = await api.listSecrets();
+        const existing = (secrets || []).some((secret) => secret.name === name);
+        const payload = (secrets || []).map((secret) => secret.name === name ? { name, value, originalName: name } : preserve(secret));
+        if (!existing)
+            payload.push({ name, value });
+        await api.saveSecrets(payload);
+        (0, ui_1.success)(`Secret "${name}" ${existing ? 'updated' : 'created'}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function secretsRemoveCommand(inputName, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const name = validateName(inputName);
+        const { secrets } = await api.listSecrets();
+        const list = secrets || [];
+        if (!list.some((secret) => secret.name === name))
+            throw new Error(`Secret "${name}" not found`);
+        if (!opts.yes) {
+            const answer = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'ok',
+                message: `Remove secret "${name}"?`,
+                initial: false,
+            });
+            if (!answer.ok)
+                return void (0, ui_1.info)('Cancelled.');
+        }
+        await api.saveSecrets(list.filter((secret) => secret.name !== name).map(preserve));
+        (0, ui_1.success)(`Secret "${name}" removed.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function secretsRenameCommand(inputOldName, inputNewName) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const oldName = validateName(inputOldName);
+        const newName = validateName(inputNewName);
+        if (oldName === newName)
+            return void (0, ui_1.info)('Secret name is unchanged.');
+        const { secrets } = await api.listSecrets();
+        const list = secrets || [];
+        if (!list.some((secret) => secret.name === oldName))
+            throw new Error(`Secret "${oldName}" not found`);
+        if (list.some((secret) => secret.name === newName))
+            throw new Error(`Secret "${newName}" already exists`);
+        const payload = list.map((secret) => secret.name === oldName ? { name: newName, value: '', originalName: oldName } : preserve(secret));
+        await api.saveSecrets(payload);
+        (0, ui_1.success)(`Secret "${oldName}" renamed to "${newName}".`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/setJson.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSetJson = readSetJson;
+exports.pruneUndefined = pruneUndefined;
+exports.requireVersion = requireVersion;
+const fs_1 = require("fs");
+const looseJson_1 = require("../lib/looseJson");
+/**
+ * `--set '<json>'` or `--set @file.json`, one convention across every command
+ * that takes structured input.
+ *
+ * Inline argv may have had its quotes stripped by the shell, so it goes through
+ * the lenient repair pass; a file's contents did not, and stay strict.
+ */
+function readSetJson(raw) {
+    let text = raw;
+    let fromShell = true;
+    if (text.startsWith('@')) {
+        const path = text.slice(1);
+        if (!(0, fs_1.existsSync)(path))
+            throw new Error(`File not found: ${path}`);
+        text = (0, looseJson_1.readJsonFile)(path);
+        fromShell = false;
+    }
+    try {
+        return (fromShell ? (0, looseJson_1.parseLooseJson)(text) : JSON.parse(text));
+    }
+    catch (err) {
+        throw new Error(`--set is not valid JSON: ${err.message}`);
+    }
+}
+/** Drop undefined-valued keys, so spreading this over a defaults object doesn't clobber them. */
+function pruneUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+/** First id from a `--versions` spec, or a clear error naming the flag. */
+function requireVersion(spec, flag = '--versions <versionId>') {
+    const id = (spec || '').split(',').map((s) => s.trim()).filter(Boolean)[0];
+    if (!id)
+        throw new Error(`${flag} is required`);
+    return id;
+}

package/dist/commands/simulations.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simTestsListCommand = simTestsListCommand;
+exports.simCreateCommand = simCreateCommand;
+exports.simDeleteCommand = simDeleteCommand;
+exports.simRunCommand = simRunCommand;
+exports.simRunsListCommand = simRunsListCommand;
+exports.simResultsCommand = simResultsCommand;
+const prompts_1 = __importDefault(require("prompts"));
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+async function simTestsListCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.listTestCases(agentId);
+        const rows = res.testCases || res.data || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No test cases yet.');
+        (0, ui_1.table)(['NAME', 'ID', 'PROMPT', 'CRITERIA', 'MODEL'], rows.map((t) => [t.testcaseName || t.name || '', t._id, t.userPrompt || '', t.successCriteria || '', t.testLLMModel || '']));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function simCreateCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        let { name, prompt, criteria } = opts;
+        if (!name || !prompt || !criteria) {
+            const answers = await (0, prompts_1.default)([
+                { type: name ? null : 'text', name: 'name', message: 'Test case name' },
+                { type: prompt ? null : 'text', name: 'prompt', message: 'Simulated user prompt' },
+                { type: criteria ? null : 'text', name: 'criteria', message: 'Success criteria' },
+            ], { onCancel: () => process.exit(1) });
+            name = name || answers.name;
+            prompt = prompt || answers.prompt;
+            criteria = criteria || answers.criteria;
+        }
+        if (!name || !prompt || !criteria) {
+            return (0, ui_1.handleError)(new Error('--name, --prompt and --criteria are all required (or answer the prompts)'));
+        }
+        const res = await api.createTestCase({
+            agentId,
+            testcaseName: name,
+            userPrompt: prompt,
+            successCriteria: criteria,
+            testLLMModel: opts.model || 'gpt-4.1-mini',
+            testVariables: {},
+            testFunctions: [],
+        });
+        (0, ui_1.success)(`Created test case ${res.testCase?._id || ''}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function simDeleteCommand(testCaseId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        if (!opts.yes) {
+            const { ok } = await (0, prompts_1.default)({
+                type: 'confirm', name: 'ok', message: `Delete test case ${testCaseId}?`, initial: false,
+            });
+            if (!ok)
+                return void (0, ui_1.info)('Cancelled.');
+        }
+        const res = await api.deleteTestCase(testCaseId);
+        (0, ui_1.success)(res.msg || 'Deleted.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function simRunCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    const testIds = (opts.tests || '').split(',').map((s) => s.trim()).filter(Boolean);
+    const versionIds = (opts.versions || '').split(',').map((s) => s.trim()).filter(Boolean);
+    if (!testIds.length)
+        return (0, ui_1.handleError)(new Error('--tests <testCaseIds> is required'));
+    if (!versionIds.length)
+        return (0, ui_1.handleError)(new Error('--versions <versionIds> is required'));
+    try {
+        const res = await api.runSimulation({
+            agentId, testIds, versionIds,
+            batchName: opts.name || `cli-run-${Date.now()}`,
+            epoch: 1,
+        });
+        (0, ui_1.success)(`Simulation run started (${res.batch?._id || ''}). Results arrive asynchronously.`);
+        (0, ui_1.info)(`Check with: cku sim results ${res.batch?._id || '<batchId>'}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function simRunsListCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.listSimulationRuns(agentId);
+        const rows = res.runs || res.data || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No simulation runs yet.');
+        (0, ui_1.table)(['NAME', 'BATCH ID', 'STATUS', 'CREATED'], rows.map((r) => [
+            r.batchName || r.name || '',
+            r.batch?._id || r._id || '',
+            r.status || '',
+            r.createdAt ? new Date(r.createdAt).toLocaleString('en-US') : '',
+        ]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function simResultsCommand(batchId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.simulationResults(batchId);
+        const rows = res.results || res.data || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No results yet — runs are asynchronous.');
+        (0, ui_1.table)(['TEST CASE', 'VERSION', 'PASSED', 'SCORE'], rows.map((r) => [
+            r.testcaseName || r.testCaseId || '',
+            r.versionId?.versionName || r.versionId || '',
+            r.passed === undefined ? '' : r.passed ? 'yes' : 'no',
+            r.score ?? '',
+        ]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}