callkaro-cli-unofficial 0.1.0

package/dist/commands/analytics.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyticsOverviewCommand = analyticsOverviewCommand;
+exports.analyticsPerformanceCommand = analyticsPerformanceCommand;
+exports.analyticsVersionCommand = analyticsVersionCommand;
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+async function analyticsOverviewCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.analytics({
+            agent_ids: opts.agent,
+            version_ids: opts.versions,
+            name: opts.type,
+            voice_provider: opts.voiceProvider,
+            llm_model: opts.llmModel,
+            is_connected: opts.connected,
+            is_batch_call: opts.batch,
+            startDate: opts.start,
+            endDate: opts.end,
+        });
+        const d = res.data || {};
+        if (opts.json)
+            return void console.log(JSON.stringify(d, null, 2));
+        (0, ui_1.keyValue)({
+            totalCalls: d.total_calls,
+            totalMinutes: d.total_minutes,
+            avgMinutesPerCall: d.avg_minutes_per_call,
+            totalCredits: d.total_credits,
+            avgCreditsPerCall: d.avg_credits_per_call,
+            avgCreditsPerMinute: d.avg_credits_per_minute,
+        });
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function analyticsPerformanceCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.performance({ startDate: opts.start, endDate: opts.end });
+        const rows = res.data || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No performance data.');
+        (0, ui_1.table)(['AGENT ID', 'CALLS', 'CONNECTED', 'CONVERTED', 'RECEIPT→CONV %', 'CONN→CONV %'], rows.map((r) => [
+            r._id, r.total_calls ?? '', r.connected_calls ?? '', r.converted_calls ?? '',
+            r.receipt_to_conversion_pct ?? '', r.connected_to_conversion_pct ?? '',
+        ]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function analyticsVersionCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.versionAnalytics(agentId, {
+            version_ids: opts.versions,
+            startDate: opts.start,
+            endDate: opts.end,
+        });
+        const rows = res.data || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No version analytics.');
+        (0, ui_1.table)(['VERSION', 'CALLS', 'CONNECTED', 'CONVERTED', 'RECEIPT→CONV %', 'CONN→CONV %'], rows.map((r) => [
+            r._id, r.total_calls ?? '', r.connected_calls ?? '', r.converted_calls ?? '',
+            r.overall_receipt_to_conversion_pct ?? '', r.overall_connected_to_conversion_pct ?? '',
+        ]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/analyzers.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzersListCommand = analyzersListCommand;
+exports.analyzersShowCommand = analyzersShowCommand;
+exports.analyzersAuditReportsCommand = analyzersAuditReportsCommand;
+exports.analyzersAuditStrategiesCommand = analyzersAuditStrategiesCommand;
+const dashboardApi_1 = require("../lib/dashboardApi");
+const ui_1 = require("../lib/ui");
+const when = (value) => {
+    if (!value)
+        return '';
+    const d = new Date(value);
+    return isNaN(d.getTime()) ? '' : d.toLocaleString('en-US');
+};
+/** Scores arrive as null when a run has not produced them yet. */
+const score = (v) => (v === undefined || v === null ? '' : String(v));
+function clip(value, max = 60) {
+    const text = value === undefined || value === null ? '' : String(value).replace(/\s+/g, ' ').trim();
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function pageSize(raw, fallback = 25) {
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+/** `cku analyzers list` */
+async function analyzersListCommand(opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().listAnalyzers();
+        const list = Array.isArray(res?.callAnalyzers) ? res.callAnalyzers : [];
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        if (!list.length)
+            return void (0, ui_1.info)('No call analyzers yet. Create one in the dashboard.');
+        (0, ui_1.table)(['NAME', 'ID', 'MODEL', 'WEBHOOK', 'CREATED'], list.map((a) => [a.analyzerName || '(unnamed)', a._id || '', a.extractionModel || '', a.webhookUrl || '', when(a.createdAt)]));
+        (0, ui_1.info)(`\n${list.length} analyzer(s). Full prompt: cku analyzers show <id>`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku analyzers show <id>` — the whole definition, including the prompt. */
+async function analyzersShowCommand(analyzerId, opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().listAnalyzers();
+        const list = Array.isArray(res?.callAnalyzers) ? res.callAnalyzers : [];
+        const found = list.find((a) => a._id === analyzerId);
+        if (!found) {
+            return (0, ui_1.handleError)(new Error(`No analyzer with id "${analyzerId}".\n` +
+                `  ${list.length} analyzer(s) exist — list them with: cku analyzers list`));
+        }
+        if (opts.json)
+            return void console.log(JSON.stringify(found, null, 2));
+        (0, ui_1.keyValue)({
+            id: found._id,
+            name: found.analyzerName,
+            model: found.extractionModel,
+            webhook: found.webhookUrl || '(none)',
+            created: when(found.createdAt),
+            updated: when(found.updatedAt),
+        });
+        if (found.postCallVariables?.length) {
+            (0, ui_1.info)('\nPost-call variables:');
+            (0, ui_1.table)(['NAME', 'TYPE', 'DESCRIPTION'], found.postCallVariables.map((v) => [v.name || '', v.type || '', clip(v.description, 70)]));
+        }
+        // The instruction is the point of the analyzer, so print it in full.
+        if (found.instruction)
+            (0, ui_1.info)(`\nInstruction:\n${found.instruction}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku analyzers audit-reports` — completed audit runs. */
+async function analyzersAuditReportsCommand(opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().listAuditReports();
+        const rows = Array.isArray(res?.data) ? res.data : [];
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No audit reports yet.');
+        const limit = pageSize(opts.limit);
+        (0, ui_1.info)(`\nAudit reports · showing ${Math.min(limit, rows.length)} of ${rows.length}\n`);
+        (0, ui_1.table)(['AGENT', 'STRATEGY', 'STATUS', 'CALLS', 'DONE', 'FAILED', 'SCORE', 'COST', 'LAST AUDIT'], rows.slice(0, limit).map((r) => [
+            r.agentName || r.agentId || '',
+            clip(r.strategyName, 28),
+            r.status || '',
+            r.totalCalls ?? '',
+            r.completedCalls ?? '',
+            r.failedCalls ?? '',
+            score(r.avgOverallScore),
+            r.totalCost ?? '',
+            when(r.lastAuditTime),
+        ]));
+        const p = res?.pagination;
+        if (p)
+            (0, ui_1.info)(`\npage ${p.page} · ${p.totalDocs ?? res.total ?? '?'} total · ${p.hasNext ? 'more available' : 'last page'}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/** `cku analyzers audit-strategies` — rollup per strategy. */
+async function analyzersAuditStrategiesCommand(opts) {
+    try {
+        const res = await (0, dashboardApi_1.dashboardApi)().listAuditStrategies();
+        const rows = Array.isArray(res?.data) ? res.data : [];
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No audit strategies have run yet.');
+        (0, ui_1.table)(['AGENT', 'STRATEGY', 'BATCHES', 'CALLS', 'AUDITED', 'DONE', 'FAILED', 'SCORE', 'COST'], rows.map((r) => [
+            r.agentName || r.agentId || '',
+            clip(r.strategyName, 30),
+            r.batchCount ?? '',
+            r.totalCalls ?? '',
+            r.auditedCalls ?? '',
+            r.completedCalls ?? '',
+            r.failedCalls ?? '',
+            score(r.avgOverallScore),
+            r.totalCost ?? '',
+        ]));
+        const p = res?.pagination;
+        if (p)
+            (0, ui_1.info)(`\n${p.totalDocs ?? res.total ?? rows.length} total`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/auditStrategies.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditListCommand = auditListCommand;
+exports.auditGetCommand = auditGetCommand;
+exports.auditFilterOptionsCommand = auditFilterOptionsCommand;
+exports.auditModelsCommand = auditModelsCommand;
+exports.auditCreateCommand = auditCreateCommand;
+exports.auditUpdateCommand = auditUpdateCommand;
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const setJson_1 = require("./setJson");
+/**
+ * Mirrors the web UI's brand-new-strategy defaults. Applied only on create,
+ * merged under whatever the caller explicitly provides.
+ */
+const DEFAULT_AUDIT_FILTERS = {
+    name: 'inbound,outbound,outbound-api,outbound-scheduled',
+    hangup_reasons: 'CLIENT_INITIATED,PARTICIPANT_REMOVED,SESSION_TIMEOUT',
+};
+const CREATE_DEFAULTS = {
+    active: false,
+    extra_variables: [],
+    llms: { provider: 'callkaro', name: 'callkaro/krishna-2.5' },
+    percentage_calls_to_be_audited_per_hour: 100,
+    max_calls_to_be_audited_per_hour: 0,
+    retranscribe_audio: false,
+    callflow_summary: '',
+};
+const postcallFiltersToKeys = (postcallFilters) => Object.fromEntries((postcallFilters ?? []).map(({ name, value }) => [`postcall_${name}`, value]));
+/**
+ * A numeric CLI flag, or undefined when absent.
+ *
+ * `Number('lots')` is NaN, and NaN serialises to `null` in the JSON body, so the
+ * server would silently receive a null rate instead of a rejected flag. An
+ * unparseable value is an error the user can act on, so it throws here — where
+ * the flag name is still in scope — rather than at the backend.
+ */
+function numericFlag(raw, flag) {
+    if (raw === undefined || raw === null || raw === '')
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new Error(`${flag} must be a number (got "${raw}").\n` +
+            '  Omit the flag to leave the current value unchanged.');
+    }
+    return n;
+}
+/** Scalar flags + --set merged; --set wins for structured fields, flags for scalars. */
+function buildFields(opts) {
+    const setJson = opts.set ? (0, setJson_1.readSetJson)(opts.set) : {};
+    return {
+        setJson,
+        name: opts.name ?? setJson.name,
+        audit_strategy: opts.strategy ?? setJson.audit_strategy,
+        active: opts.disable ? false : (opts.active ?? setJson.active),
+        llms: opts.model ? { provider: opts.model.split('/')[0], name: opts.model } : setJson.llms,
+        percentage_calls_to_be_audited_per_hour: numericFlag(opts.pctPerHour, '--pct-per-hour') ?? setJson.percentage_calls_to_be_audited_per_hour,
+        max_calls_to_be_audited_per_hour: numericFlag(opts.maxPerHour, '--max-per-hour') ?? setJson.max_calls_to_be_audited_per_hour,
+        retranscribe_audio: opts.retranscribe ?? setJson.retranscribe_audio,
+        extra_variables: setJson.extra_variables,
+        callflow_summary: setJson.callflow_summary,
+    };
+}
+async function auditListCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.listAuditStrategies(agentId);
+        const rows = res.auditStrategies || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No audit strategies yet.');
+        (0, ui_1.table)(['NAME', 'ID', 'ACTIVE'], rows.map((s) => [s.name || '', s._id, s.active ? 'yes' : 'no']));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function auditGetCommand(agentId, strategyId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.listAuditStrategies(agentId);
+        const strategy = (res.auditStrategies || []).find((s) => s._id === strategyId);
+        if (!strategy)
+            return (0, ui_1.handleError)(new Error(`Audit strategy ${strategyId} not found for agent ${agentId}.`));
+        if (opts.json)
+            return void console.log(JSON.stringify(strategy, null, 2));
+        (0, ui_1.keyValue)({
+            name: strategy.name,
+            id: strategy._id,
+            active: strategy.active,
+            audit_strategy: strategy.audit_strategy,
+            llms: JSON.stringify(strategy.llms),
+            audit_filters: JSON.stringify(strategy.audit_filters),
+        });
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function auditFilterOptionsCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.getAuditFilterOptions(agentId);
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        (0, ui_1.info)('Hangup reasons:');
+        (res.hangupReasons || []).forEach((r) => (0, ui_1.info)(`  ${r.value} — ${r.meaning}`));
+        (0, ui_1.info)('Drop-off reasons:');
+        (res.dropOffReasons || []).forEach((r) => (0, ui_1.info)(`  ${r.name} — ${r.description}`));
+        (0, ui_1.info)('Boolean postcall filters:');
+        (res.postcallBooleanFilters || []).forEach((r) => (0, ui_1.info)(`  ${r.name} — ${r.description}`));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function auditModelsCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.listAuditModels();
+        const rows = res.models || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No audit models available.');
+        (0, ui_1.table)(['PROVIDER', 'NAME'], rows.map((m) => [m.provider, m.id]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function auditCreateCommand(agentId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const { setJson, ...fields } = buildFields(opts);
+        if (!fields.audit_strategy) {
+            return (0, ui_1.handleError)(new Error('audit_strategy is required — pass --strategy <text> or --set \'{"audit_strategy":"..."}\''));
+        }
+        const res = await api.createAuditStrategy({
+            agentId,
+            ...CREATE_DEFAULTS,
+            ...(0, setJson_1.pruneUndefined)(fields),
+            audit_filters: {
+                ...DEFAULT_AUDIT_FILTERS,
+                ...(setJson.audit_filters || {}),
+                ...postcallFiltersToKeys(setJson.postcall_filters),
+            },
+        });
+        (0, ui_1.success)(`Created audit strategy ${res.auditStrategy?._id || ''}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function auditUpdateCommand(agentId, strategyId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        // The backend replaces audit_filters wholesale on update, not per-key —
+        // fetch the existing strategy and merge onto it so only named keys change.
+        const existing = await api.listAuditStrategies(agentId);
+        const existingStrategy = (existing.auditStrategies || []).find((s) => s._id === strategyId);
+        const { setJson, ...fields } = buildFields(opts);
+        const res = await api.updateAuditStrategy(strategyId, {
+            agentId,
+            ...(0, setJson_1.pruneUndefined)(fields),
+            audit_filters: {
+                ...(existingStrategy?.audit_filters || {}),
+                ...(setJson.audit_filters || {}),
+                ...postcallFiltersToKeys(setJson.postcall_filters),
+            },
+        });
+        (0, ui_1.success)(res.msg || `Updated audit strategy ${strategyId}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/batches.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchesCreateCommand = batchesCreateCommand;
+exports.batchesScheduleCommand = batchesScheduleCommand;
+exports.batchesListCommand = batchesListCommand;
+exports.batchesGetCommand = batchesGetCommand;
+exports.batchesStatusCommand = batchesStatusCommand;
+exports.batchesSendNextTryCommand = batchesSendNextTryCommand;
+exports.batchesSendUntriggeredCommand = batchesSendUntriggeredCommand;
+exports.batchesDownloadCommand = batchesDownloadCommand;
+const fs_1 = require("fs");
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+async function batchesCreateCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    if (!opts.file)
+        return (0, ui_1.handleError)(new Error('--file <path-to-csv> is required'));
+    if (!opts.name)
+        return (0, ui_1.handleError)(new Error('--name <batch name> is required'));
+    if (!(0, fs_1.existsSync)(opts.file))
+        return (0, ui_1.handleError)(new Error(`File not found: ${opts.file}`));
+    try {
+        const res = await api.createBatch(opts.file, {
+            name: opts.name,
+            agentId: opts.agent,
+            language: opts.language,
+            funnelMatrics: opts.funnel,
+            workflow_id: opts.workflow,
+        });
+        (0, ui_1.success)(res.msg || 'Batch created.');
+        if (res.batchCall?._id)
+            (0, ui_1.info)(`Batch id: ${res.batchCall._id}  (${res.phonenumbersCount} numbers)`);
+        if (res.triggerError)
+            (0, ui_1.info)('Dial trigger failed — run `cku batches send-untriggered <id>` to start dialing.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function batchesScheduleCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    if (!opts.file)
+        return (0, ui_1.handleError)(new Error('--file <path-to-csv> is required'));
+    if (!opts.name)
+        return (0, ui_1.handleError)(new Error('--name <batch name> is required'));
+    if (!opts.at)
+        return (0, ui_1.handleError)(new Error('--at <ISO datetime> is required, e.g. --at "2026-08-05T10:00:00+05:30"'));
+    if (!(0, fs_1.existsSync)(opts.file))
+        return (0, ui_1.handleError)(new Error(`File not found: ${opts.file}`));
+    let min_trigger_time, max_trigger_time;
+    if (opts.window) {
+        const m = opts.window.match(/^(\d{2}:\d{2})-(\d{2}:\d{2})$/);
+        if (!m)
+            return (0, ui_1.handleError)(new Error('--window must be HH:MM-HH:MM, e.g. 10:00-19:00'));
+        [, min_trigger_time, max_trigger_time] = m;
+    }
+    try {
+        const res = await api.scheduleBatch(opts.file, {
+            name: opts.name,
+            agentId: opts.agent,
+            scheduleAt: opts.at,
+            min_trigger_time,
+            max_trigger_time,
+            number_of_retries: opts.retries,
+            gap_between_retries: opts.gaps,
+            carry_over: opts.carryOver ? 'true' : undefined,
+            priority: opts.priority,
+            language: opts.language,
+            funnelMatrics: opts.funnel,
+            workflow_id: opts.workflow,
+        });
+        (0, ui_1.success)(res.msg || `Batch scheduled for ${opts.at}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+function fmtDate(v) {
+    if (!v)
+        return '';
+    const d = new Date(v);
+    return isNaN(d.getTime()) ? '' : d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+}
+async function batchesListCommand(opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.listBatches({ page: 1, pageSize: (0, ui_1.intFlag)(opts.limit, '--limit', 20) });
+        const rows = res.batchCalls || [];
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No batches yet.');
+        (0, ui_1.table)(['NAME', 'ID', 'AGENT', 'NUMBERS', 'TRIGGERED', 'CONNECTED', 'CONVERTED', 'TRIES', 'CREATED'], rows.map((b) => [
+            b.name || '', b._id, b.agent?.name || '', b.phonenumbersCount ?? '',
+            b.triggered_calls ?? '', b.connected_calls ?? '', b.converted_calls ?? '',
+            b.total_tries ?? '', fmtDate(b.createdAt),
+        ]));
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function batchesGetCommand(batchId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.getBatch(batchId);
+        if (opts.json)
+            return void console.log(JSON.stringify(res, null, 2));
+        const b = res.batchCall || {};
+        (0, ui_1.keyValue)({ id: b._id, name: b.name, numbers: b.phonenumbersCount, agent: b.agent?.name, created: fmtDate(b.createdAt) });
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function batchesStatusCommand(batchId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.batchStatus(batchId);
+        const data = res.data || {};
+        if (opts.json)
+            return void console.log(JSON.stringify(data, null, 2));
+        (0, ui_1.keyValue)({
+            connectedCalls: data.connectedCalls,
+            nextTry: data.nextTry,
+            trials: Array.isArray(data.all_trials) ? data.all_trials.length : undefined,
+        });
+        (0, ui_1.info)('Use --json for the full per-try distribution.');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+/**
+ * Look up a batch's current total_tries, as the web table does.
+ *
+ * Throws when the batch is not in the first 100 rather than returning 0. An
+ * account with more than 100 batches puts the target on a later page, and a
+ * silent 0 would be APPLIED as max_try_count — telling the server to do nothing
+ * while the command reports success. Guessing here is worse than asking.
+ */
+async function batchTotalTries(api, batchId) {
+    const res = await api.listBatches({ page: 1, pageSize: 100 });
+    const b = (res.batchCalls || []).find((x) => x._id === batchId);
+    if (!b) {
+        throw new Error(`Batch ${batchId} is not in the first 100 returned by the API, so its current try count is unknown.
+` +
+            '  Pass it explicitly: cku batches send-next-try ' + batchId + ' --max-try <n>');
+    }
+    return b.total_tries ?? 0;
+}
+async function batchesSendNextTryCommand(batchId, opts) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const maxTry = opts.maxTry !== undefined ? (0, ui_1.intFlag)(opts.maxTry, '--max-try', 0) : await batchTotalTries(api, batchId);
+        const res = await api.sendNextTry(batchId, maxTry);
+        (0, ui_1.success)(res.msg || `Next-try dial queued for batch ${batchId}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function batchesSendUntriggeredCommand(batchId) {
+    const api = (0, session_1.requireApi)();
+    try {
+        const res = await api.sendUntriggered(batchId);
+        (0, ui_1.success)(res.msg || `Untriggered dial queued for batch ${batchId}.`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function batchesDownloadCommand(batchId, opts) {
+    const api = (0, session_1.requireApi)();
+    const kind = opts.type || 'receipts';
+    if (!['receipts', 'triggered', 'untriggered', 'not-connected'].includes(kind)) {
+        return (0, ui_1.handleError)(new Error('--type must be receipts | triggered | untriggered | not-connected'));
+    }
+    try {
+        const res = await api.batchDownload(batchId, kind);
+        const rows = res.receipts || [];
+        const out = opts.file || `batch-${batchId}-${kind}.json`;
+        (0, fs_1.writeFileSync)(out, JSON.stringify(rows, null, 2));
+        (0, ui_1.success)(`Saved ${rows.length} ${kind} row(s) to ${out}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}