callkaro-cli-unofficial 0.4.1 → 0.5.1

package/dist/commands/accounts.js

@@ -44,7 +44,19 @@ async function loginCommand(opts) {
         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 }));
+        // The password is kept by default so a token the server stops accepting can
+        // be re-issued on its own — the `ck_` token is opaque and has no refresh
+        // route, so a dead token is otherwise a dead end. `--no-save-password` opts
+        // out and brings back a manual re-login.
+        const keep = opts.savePassword !== false;
+        (0, ui_1.success)((0, config_1.saveLogin)(res.user?.email || email, { token: res.token, user: res.user, ...(keep ? { password } : {}) }));
+        if (keep) {
+            (0, ui_1.info)('  Password saved (plain text, mode 0600) so the CLI can renew this token by itself.');
+            (0, ui_1.info)('  Drop it with `cku accounts remove <email>`, or sign in with --no-save-password.');
+        }
+        else {
+            (0, ui_1.info)('  Password not saved. The token cannot be renewed, so re-run this if it stops working.');
+        }
     }
     catch (err) {
         (0, ui_1.handleError)(err);
@@ -160,9 +172,24 @@ async function configCommand() {
 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.
+    // Never print tokens or passwords: this output ends up in agent transcripts
+    // and CI logs. `signedIn` says whether a credential is held, not what it is.
     if (opts.json) {
-        return void console.log(JSON.stringify(accounts.map(({ token, ...a }) => ({ ...a, signedIn: Boolean(token) })), null, 2));
+        return void console.log(JSON.stringify(accounts.map(({ token, password, dashboard, ...a }) => ({
+            ...a,
+            signedIn: Boolean(token),
+            ...(dashboard
+                ? {
+                    dashboard: {
+                        email: dashboard.email,
+                        userId: dashboard.userId,
+                        expiresAt: dashboard.expiresAt,
+                        savedAt: dashboard.savedAt,
+                        signedIn: Boolean(dashboard.token),
+                    },
+                }
+                : {}),
+        })), null, 2));
     }
     if (!accounts.length) {
         return void (0, ui_1.info)('No accounts saved. Run `cku login` to add one.');

package/dist/commands/contacts.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collect = void 0;
+exports.contactsListCommand = contactsListCommand;
+exports.contactsGetCommand = contactsGetCommand;
+exports.contactsCreateCommand = contactsCreateCommand;
+exports.contactsUpdateCommand = contactsUpdateCommand;
+exports.contactsDeleteCommand = contactsDeleteCommand;
+exports.contactsUploadCommand = contactsUploadCommand;
+exports.contactsExportCommand = contactsExportCommand;
+exports.contactsAssignCommand = contactsAssignCommand;
+exports.attributesListCommand = attributesListCommand;
+exports.attributesSetCommand = attributesSetCommand;
+exports.attributesDeleteCommand = attributesDeleteCommand;
+const fs_1 = require("fs");
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const collect = (val, acc) => {
+    acc.push(val);
+    return acc;
+};
+exports.collect = collect;
+const ATTRIBUTE_TYPES = [
+    'string', 'description', 'enum', 'number', 'date', 'boolean', 'datetime', 'time', 'array', 'object',
+];
+/** ["city=Pune", "age=30"] -> { city: "Pune", age: "30" }. The server coerces by attribute type. */
+function parsePairs(pairs, flag) {
+    const out = {};
+    for (const pair of pairs || []) {
+        const i = pair.indexOf('=');
+        if (i < 1)
+            throw new Error(`${flag} expects name=value, got "${pair}"`);
+        out[pair.slice(0, i).trim()] = pair.slice(i + 1);
+    }
+    return out;
+}
+function filterQuery(o) {
+    const attrs = parsePairs(o.attr, '--attr');
+    return {
+        search: o.search,
+        channel: o.channel,
+        lastMessageStates: o.lastMessageState,
+        createdFrom: o.createdFrom,
+        createdTo: o.createdTo,
+        updatedFrom: o.updatedFrom,
+        updatedTo: o.updatedTo,
+        attrs: Object.keys(attrs).length ? JSON.stringify(attrs) : undefined,
+    };
+}
+/** Attribute values are stored as { value, comment, source, ... }; show just the value. */
+const attrValue = (c, name) => {
+    const a = c.attributes?.[name];
+    const v = a && typeof a === 'object' && 'value' in a ? a.value : a;
+    return v === undefined || v === null ? '' : typeof v === 'object' ? JSON.stringify(v) : String(v);
+};
+function output(value, opts, label) {
+    if (opts.file) {
+        (0, fs_1.writeFileSync)(opts.file, JSON.stringify(value, null, 2));
+        (0, ui_1.success)(`Saved ${label} to ${opts.file}`);
+        return true;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(value, null, 2));
+        return true;
+    }
+    return false;
+}
+// ---- contacts -------------------------------------------------------------
+async function contactsListCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const { contacts, pagination } = await api.listContacts({
+            ...filterQuery(opts),
+            assignedToMe: opts.assignedToMe ? 'true' : undefined,
+            page: opts.page,
+            pageSize: opts.pageSize,
+        });
+        if (output({ contacts, pagination }, opts, 'contacts'))
+            return;
+        if (!contacts.length)
+            return void (0, ui_1.info)('No contacts match.');
+        const names = opts.columns
+            ? String(opts.columns).split(',').map((s) => s.trim()).filter(Boolean)
+            : [...new Set(contacts.flatMap((c) => Object.keys(c.attributes || {})))].slice(0, 3);
+        (0, ui_1.table)(['PHONE', 'CHANNELS', ...names], contacts.map((c) => [c.phone_number, (c.channels || []).join(','), ...names.map((n) => attrValue(c, n))]));
+        (0, ui_1.info)(`Page ${pagination.page}/${pagination.totalPages || 1} — ${pagination.total} contact(s)${pagination.hasNext ? '  (use --page to see more)' : ''}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function contactsGetCommand(phone, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const { contact } = await api.getContact(phone);
+        if (output(contact, opts, 'contact'))
+            return;
+        (0, ui_1.keyValue)({
+            Phone: contact.phone_number,
+            Channels: (contact.channels || []).join(', '),
+            Created: contact.createdAt,
+            Updated: contact.updatedAt,
+        });
+        const names = Object.keys(contact.attributes || {});
+        if (names.length) {
+            console.log();
+            (0, ui_1.table)(['ATTRIBUTE', 'VALUE'], names.map((n) => [n, attrValue(contact, n)]));
+        }
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function contactsCreateCommand(phone, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const attributes = parsePairs(opts.attr, '--attr');
+        const { contact } = await api.saveContact({
+            phone_number: phone,
+            channels: opts.channel?.length ? opts.channel : undefined,
+        });
+        if (Object.keys(attributes).length)
+            await api.updateContactAttributes(contact.phone_number, attributes);
+        (0, ui_1.success)(`Contact ${contact.phone_number} saved.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function contactsUpdateCommand(phone, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const attributes = parsePairs(opts.attr, '--attr');
+        for (const name of opts.clear || [])
+            attributes[name] = '';
+        if (!Object.keys(attributes).length) {
+            throw new Error('Nothing to update: pass --attr name=value and/or --clear name.');
+        }
+        const { msg } = await api.updateContactAttributes(phone, attributes);
+        (0, ui_1.success)(msg || 'Contact updated.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function contactsDeleteCommand(phone, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        if (!(await (0, ui_1.confirm)(`Delete contact ${phone}? This cannot be undone.`, opts.yes)))
+            return;
+        await api.deleteContact(phone);
+        (0, ui_1.success)('Contact deleted.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function contactsUploadCommand(file, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        if (!(0, fs_1.existsSync)(file))
+            throw new Error(`File not found: ${file}`);
+        const { upload, invalid } = await api.uploadContacts(file, opts.ignoreUnknown);
+        (0, ui_1.success)(`${upload.contactsWritten} contact(s) written from ${upload.rowsRead} row(s).`);
+        if (upload.ignoredColumns?.length)
+            (0, ui_1.info)(`Ignored columns: ${upload.ignoredColumns.join(', ')}`);
+        if (upload.skippedCells) {
+            (0, ui_1.info)(`${upload.skippedCells} cell(s) skipped:`);
+            for (const bad of invalid || []) {
+                console.error(`  row ${bad.row} ${bad.column}: ${bad.reason}${bad.value ? ` ("${bad.value}")` : ''}`);
+            }
+        }
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function contactsExportCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.exportContacts({
+            ...filterQuery(opts),
+            export_fields: opts.fields,
+            user_email: opts.email,
+        });
+        if (res.processing)
+            return void (0, ui_1.info)(res.msg || `Export started; it will be emailed to ${opts.email}.`);
+        if (opts.file) {
+            (0, fs_1.writeFileSync)(opts.file, res.csv || '');
+            return void (0, ui_1.success)(`Saved contacts to ${opts.file}`);
+        }
+        process.stdout.write(res.csv || '');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/**
+ * What `assign` would do, without starting anything. Selects contacts the way the server does:
+ * --phones keeps only numbers that are contacts (the rest are silently skipped on a real assign,
+ * so say which), otherwise the filters pick the set. The server stops at 20000 contacts.
+ */
+async function assignDryRun(api, opts, phones, q) {
+    let target = `voice agent ${opts.agent}`;
+    if (opts.workflow) {
+        const wf = await api.getWorkflow(opts.workflow);
+        const steps = wf.graph?.nodes?.length ?? 0;
+        if (wf.type && wf.type !== 'normal')
+            throw new Error('This workflow is deprecated and cannot take contacts.');
+        if (!steps)
+            throw new Error(`Workflow "${wf.workFlowName}" has no steps yet; the server would refuse this assign.`);
+        target = `workflow "${wf.workFlowName}" (${steps} nodes)`;
+    }
+    let total;
+    let sample;
+    const missing = [];
+    if (phones?.length) {
+        const wanted = [...new Set(phones.map((p) => p.replace(/\D/g, '')).filter(Boolean))];
+        const found = [];
+        for (let i = 0; i < wanted.length; i += 8) {
+            await Promise.all(wanted.slice(i, i + 8).map(async (p) => {
+                try {
+                    await api.getContact(p);
+                    found.push(p);
+                }
+                catch {
+                    missing.push(p);
+                }
+            }));
+        }
+        total = found.length;
+        sample = wanted.filter((p) => found.includes(p)).slice(0, 5);
+    }
+    else {
+        const { contacts, pagination } = await api.listContacts({ ...q, page: 1, pageSize: 5 });
+        total = pagination.total;
+        sample = contacts.map((c) => c.phone_number);
+    }
+    (0, ui_1.keyValue)({
+        Target: target,
+        'Would assign': `${total} contact(s)${total > 20000 ? ' (the server caps one assign at 20000)' : ''}`,
+        Sample: sample.join(', ') || undefined,
+        'Not contacts (skipped)': missing.length ? missing.join(', ') : undefined,
+        Starts: opts.at || 'now',
+        'Daily window': opts.window,
+    });
+    (0, ui_1.info)('Dry run: nothing was started. Contacts already running in the workflow are skipped by a real assign.');
+}
+/** Add contacts to a workflow (--workflow) or call them with a voice agent (--agent). */
+async function contactsAssignCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        if (Boolean(opts.workflow) === Boolean(opts.agent)) {
+            throw new Error('Pass exactly one of --workflow <id> or --agent <id>.');
+        }
+        const phones = opts.phones?.split(',').map((p) => p.trim()).filter(Boolean);
+        const q = filterQuery(opts);
+        const hasFilters = Object.values(q).some((v) => v !== undefined);
+        if (opts.dryRun)
+            return await assignDryRun(api, opts, phones, q);
+        if (!phones?.length && !hasFilters && !(await (0, ui_1.confirm)('No --phones or filters given: assign EVERY contact?', opts.yes))) {
+            return;
+        }
+        let minTriggerTime;
+        let maxTriggerTime;
+        if (opts.window) {
+            const m = String(opts.window).match(/^(\d{2}:\d{2})-(\d{2}:\d{2})$/);
+            if (!m)
+                throw new Error('--window must be HH:MM-HH:MM, e.g. 10:00-19:00');
+            [, minTriggerTime, maxTriggerTime] = m;
+        }
+        const res = await api.assignContacts({
+            scope: phones?.length ? 'contacts' : 'filtered',
+            phones,
+            filters: { ...q, attrs: q.attrs ? JSON.parse(q.attrs) : undefined },
+            target: opts.workflow ? 'workflow' : 'voice',
+            workflowId: opts.workflow,
+            agentId: opts.agent,
+            name: opts.name,
+            language: opts.language,
+            scheduleLater: Boolean(opts.at),
+            scheduleAt: opts.at,
+            minTriggerTime,
+            maxTriggerTime,
+            numberOfRetries: opts.retries !== undefined ? Number(opts.retries) : undefined,
+            gapBetweenRetries: opts.gaps,
+            carryOver: opts.carryOver,
+            priority: opts.priority !== undefined ? Number(opts.priority) : undefined,
+            force: opts.force,
+        });
+        (res.contactsAssigned === 0 ? ui_1.info : ui_1.success)(res.msg || 'Assigned.');
+        if (res.alreadyRunning)
+            (0, ui_1.info)(`${res.alreadyRunning} already in this workflow (skipped; use --force to restart them).`);
+        if (res.truncated)
+            (0, ui_1.info)('The selection was capped at the server limit; narrow the filters to cover the rest.');
+        if (res.batchId)
+            (0, ui_1.info)(`Batch id: ${res.batchId}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+// ---- attribute definitions --------------------------------------------------
+async function attributesListCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const { definitions } = await api.listContactAttributes();
+        if (output(definitions, opts, 'attributes'))
+            return;
+        if (!definitions.length) {
+            return void (0, ui_1.info)('No attributes defined yet. Create one with `cku contacts attributes set <name>`.');
+        }
+        (0, ui_1.table)(['NAME', 'TYPE', 'LABEL', 'OPTIONS', 'AI-UPDATABLE', 'REQUIRED'], definitions.map((d) => [
+            d.name,
+            d.type,
+            d.display_name || '',
+            (d.options || []).join(','),
+            d.updateOn === 'manual' ? 'no' : 'yes',
+            d.required ? 'yes' : '',
+        ]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/**
+ * Create or edit an attribute. Saving replaces the whole definition server-side,
+ * so an existing one is read first and only the flags given are changed.
+ */
+async function attributesSetCommand(name, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        if (opts.type && !ATTRIBUTE_TYPES.includes(opts.type)) {
+            throw new Error(`--type must be one of: ${ATTRIBUTE_TYPES.join(', ')}`);
+        }
+        if (opts.defaultMode && !['drop', 'type_default', 'custom'].includes(opts.defaultMode)) {
+            throw new Error('--default-mode must be drop, type_default or custom');
+        }
+        const { definitions } = await api.listContactAttributes();
+        const old = definitions.find((d) => d.name === name);
+        if (!old && !opts.type) {
+            throw new Error(`"${name}" does not exist yet; pass --type (${ATTRIBUTE_TYPES.join(', ')}).`);
+        }
+        const merged = {
+            ...(old || {}),
+            name,
+            type: opts.type ?? old?.type,
+            display_name: opts.label ?? old?.display_name,
+            description: opts.description ?? old?.description ?? '',
+            options: opts.options !== undefined
+                ? String(opts.options).split(',').map((s) => s.trim()).filter(Boolean)
+                : old?.options ?? [],
+            updateOn: opts.manualOnly ? 'manual' : opts.aiUpdatable ? 'both' : old?.updateOn ?? 'both',
+            required: opts.required ? true : opts.optional ? false : old?.required ?? false,
+            showOnScreen: opts.hidden ? false : opts.visible ? true : old?.showOnScreen ?? true,
+            default_mode: opts.defaultMode ?? old?.default_mode ?? 'custom',
+            default_value: opts.defaultValue ?? old?.default_value ?? '',
+        };
+        const { definition } = await api.saveContactAttribute(merged);
+        (0, ui_1.success)(`Attribute "${definition.name}" ${old ? 'updated' : 'created'} (${definition.type}).`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function attributesDeleteCommand(name, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        if (!(await (0, ui_1.confirm)(`Delete attribute "${name}"? Values already on contacts are kept but hidden.`, opts.yes))) {
+            return;
+        }
+        await api.deleteContactAttribute(name);
+        (0, ui_1.success)(`Attribute "${name}" deleted.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/simulations.js

@@ -9,6 +9,7 @@ exports.toTestFunctions = toTestFunctions;
 exports.simTestsListCommand = simTestsListCommand;
 exports.simCreateCommand = simCreateCommand;
 exports.simUpdateCommand = simUpdateCommand;
+exports.simModelsCommand = simModelsCommand;
 exports.simDeleteCommand = simDeleteCommand;
 exports.waitForBatch = waitForBatch;
 exports.simRunCommand = simRunCommand;
@@ -66,31 +67,42 @@ async function simCreateCommand(agentId, opts) {
         // Parse the JSON flags before prompting, so a typo fails before any typing.
         const testVariables = opts.variables ? toTestVariables(await (0, jsonInput_1.readJsonFlag)(opts.variables, '--variables')) : {};
         const testFunctions = opts.functions ? toTestFunctions(await (0, jsonInput_1.readJsonFlag)(opts.functions, '--functions')) : [];
-        let { name, prompt, criteria } = opts;
+        let { name, persona, prompt, criteria } = opts;
         if (!name || !prompt || !criteria) {
             (0, ui_1.needTty)('Pass --name, --prompt and --criteria.');
             const answers = await (0, prompts_1.default)([
                 { type: name ? null : 'text', name: 'name', message: 'Test case name' },
+                {
+                    type: persona !== undefined ? null : 'text',
+                    name: 'persona',
+                    message: 'Caller persona (who they are, tone, what they know)',
+                },
                 { 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;
+            if (persona === undefined && answers.persona)
+                persona = answers.persona;
             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({
+        const payload = {
             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 || ''}.`);
+        };
+        if (opts.model !== undefined)
+            payload.testLLMModel = opts.model;
+        if (persona !== undefined)
+            payload.userPersona = persona;
+        const res = await api.createTestCase(payload);
+        (0, ui_1.success)(`Created test case ${res.testCase?._id || ''} (model: ${res.testCase?.testLLMModel || opts.model || 'default'}).`);
     }
     catch (err) {
         (0, ui_1.handleError)(err);
@@ -107,6 +119,8 @@ async function simUpdateCommand(testCaseId, opts) {
         const body = {};
         if (opts.name !== undefined)
             body.testcaseName = opts.name;
+        if (opts.persona !== undefined)
+            body.userPersona = opts.persona;
         if (opts.prompt !== undefined)
             body.userPrompt = opts.prompt;
         if (opts.criteria !== undefined)
@@ -118,7 +132,7 @@ async function simUpdateCommand(testCaseId, opts) {
         if (opts.functions !== undefined)
             body.testFunctions = toTestFunctions(await (0, jsonInput_1.readJsonFlag)(opts.functions, '--functions'));
         if (!Object.keys(body).length) {
-            return (0, ui_1.handleError)(new Error('Nothing to update. Pass at least one of --name, --prompt, --criteria, --model, --variables, --functions.'));
+            return (0, ui_1.handleError)(new Error('Nothing to update. Pass at least one of --name, --persona, --prompt, --criteria, --model, --variables, --functions.'));
         }
         const res = await api.updateTestCase(testCaseId, body);
         (0, ui_1.success)(`Updated test case ${res.testCase?._id || testCaseId}: ${Object.keys(body).join(', ')}.`);
@@ -127,6 +141,19 @@ async function simUpdateCommand(testCaseId, opts) {
         (0, ui_1.handleError)(err);
     }
 }
+async function simModelsCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.simulationModels();
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        const def = res.categories?.[0]?.defaultModel;
+        (0, ui_1.table)(['MODEL', 'DEFAULT'], (res.models || []).map((m) => [m.id, m.id === def ? 'yes' : '']));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
 async function simDeleteCommand(testCaseId, opts) {
     const api = (0, session_1.requireApi)();
     try {
@@ -174,11 +201,17 @@ function resultTable(rows) {
     (0, ui_1.table)(['TEST CASE', 'VERSION', 'RESULT', 'TURNS', 'SUMMARY'], rows.map((r) => [
         r.testcaseId?.testcaseName || r.testcaseName || r.testcaseId || '',
         r.versionId?.versionName || r.versionId || '',
-        r.isTestSucceed === undefined ? '' : r.isTestSucceed ? 'PASS' : 'FAIL',
+        r.analysisStatus === 'failed'
+            ? 'GRADING FAILED'
+            : r.isTestSucceed === undefined
+                ? ''
+                : r.isTestSucceed
+                    ? 'PASS'
+                    : 'FAIL',
         r.total_turns ?? '',
         String(r.testResultSummary || '').replace(/\s+/g, ' ').slice(0, 70),
     ]));
-    const passed = rows.filter((r) => r.isTestSucceed).length;
+    const passed = rows.filter((r) => r.analysisStatus !== 'failed' && r.isTestSucceed).length;
     (0, ui_1.info)(`\n${passed}/${rows.length} passed.`);
 }
 async function simRunCommand(agentId, opts) {
@@ -213,7 +246,7 @@ async function simRunCommand(agentId, opts) {
         if (!done) {
             return (0, ui_1.handleError)(new Error(`Timed out with ${rows.length}${total ? `/${total}` : ''} results. The run is still going: cku sim results ${batchId} --wait`));
         }
-        if (rows.some((r) => !r.isTestSucceed))
+        if (rows.some((r) => r.analysisStatus === 'failed' || !r.isTestSucceed))
             process.exitCode = 1;
     }
     catch (err) {
@@ -236,6 +269,9 @@ async function simRunsListCommand(agentId, opts) {
             r.epoch ?? '',
             r.createdAt ? new Date(r.createdAt).toLocaleString('en-US') : '',
         ]));
+        if (typeof res.totalCost === 'number') {
+            console.log(`Total cost, all runs: ${res.totalCost > 0 ? res.totalCost.toFixed(3) : 'N/A'}`);
+        }
     }
     catch (err) {
         (0, ui_1.handleError)(err);

package/dist/commands/update.js

@@ -36,6 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateCommand = updateCommand;
 const child_process_1 = require("child_process");
 const ui_1 = require("../lib/ui");
+const win = process.platform === 'win32';
+const bin = (name) => (win ? `${name}.cmd` : name);
 /**
  * `cku update` — upgrade the CLI itself from npm, then refresh the skill pack
  * (which lives in its own repo, so it may have moved on even if the CLI hasn't).
@@ -46,7 +48,7 @@ async function updateCommand(opts) {
         try {
             let legacyInstalled = false;
             try {
-                (0, child_process_1.execFileSync)('npm', ['list', '--global', '@callkaro/cli', '--depth=0'], { stdio: 'ignore' });
+                (0, child_process_1.execFileSync)(bin('npm'), ['list', '--global', '@callkaro/cli', '--depth=0'], { stdio: 'ignore', shell: win });
                 legacyInstalled = true;
             }
             catch {
@@ -54,19 +56,24 @@ async function updateCommand(opts) {
             }
             if (legacyInstalled) {
                 (0, ui_1.info)('Removing legacy @callkaro/cli installation …');
-                (0, child_process_1.execFileSync)('npm', ['uninstall', '--global', '@callkaro/cli'], { stdio: 'ignore' });
+                (0, child_process_1.execFileSync)(bin('npm'), ['uninstall', '--global', '@callkaro/cli'], { stdio: 'ignore', shell: win });
             }
-            (0, child_process_1.execFileSync)('npm', ['install', '--global', 'callkaro-cli-unofficial'], { stdio: 'ignore' });
+            (0, child_process_1.execFileSync)(bin('npm'), ['install', '--global', 'callkaro-cli-unofficial'], { stdio: 'ignore', shell: win });
         }
         catch {
-            (0, ui_1.fail)('npm could not write to the global folder (it needs elevated permissions).');
-            (0, ui_1.info)('Re-run as:\n  sudo cku update');
+            if (win) {
+                (0, ui_1.fail)('npm could not update the CLI. Run PowerShell as Administrator, or re-run:\n  npm install --global callkaro-cli-unofficial');
+            }
+            else {
+                (0, ui_1.fail)('npm could not write to the global folder (it needs elevated permissions).');
+                (0, ui_1.info)('Re-run as:\n  sudo cku update');
+            }
             process.exitCode = 1;
             return;
         }
         let version = '';
         try {
-            version = (0, child_process_1.execFileSync)('cku', ['--version'], { encoding: 'utf8' }).trim();
+            version = (0, child_process_1.execFileSync)(bin('cku'), ['--version'], { encoding: 'utf8', shell: win }).trim();
         }
         catch {
             /* not on PATH yet in this shell */