callkaro-cli-unofficial 0.1.0

package/dist/lib/logQuery.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Runs a shell-style text query over a call's raw log without ever printing
+ * the blob URL. The URL (from api.getCall's logfile_url) is only used here,
+ * internally, to download the log text once per command invocation.
+ *
+ * just-bash is ESM-only; this package builds to CommonJS, so it's loaded
+ * with a dynamic import().
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogNotFoundError = void 0;
+exports.unavailableReason = unavailableReason;
+exports.getLogText = getLogText;
+exports.runLogQuery = runLogQuery;
+const MAX_LOG_BYTES = 8 * 1024 * 1024;
+const FETCH_TIMEOUT_MS = 15_000;
+const MAX_RESULT_CHARS = 20_000; // CLI output isn't token-budgeted like an LLM tool result
+const MAX_LINE_CHARS = 1_000;
+const LOG_UNAVAILABLE_MESSAGE = 'No log available for this call. If the call was made recently, wait a bit and try again -- ' +
+    'otherwise the log has likely expired (logs are kept for 7 days).';
+class LogNotFoundError extends Error {
+    constructor() {
+        super('Log file not found at storage.');
+        this.name = 'LogNotFoundError';
+    }
+}
+exports.LogNotFoundError = LogNotFoundError;
+function unavailableReason(_call) {
+    return LOG_UNAVAILABLE_MESSAGE;
+}
+function isTrustedLogHost(hostname) {
+    return hostname.toLowerCase().endsWith('.blob.core.windows.net');
+}
+async function downloadLogText(logfileUrl) {
+    let url;
+    try {
+        url = new URL(logfileUrl);
+    }
+    catch {
+        throw new Error('Stored log URL is malformed.');
+    }
+    // Host allowlist + no redirects: a blob URL from the API must not be able to
+    // send us somewhere else, and a redirect would bypass the host check.
+    if (url.protocol !== 'https:' || !isTrustedLogHost(url.hostname)) {
+        throw new Error('Stored log URL host is not allowed.');
+    }
+    const response = await fetch(url, {
+        redirect: 'error',
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+    if (response.status === 404)
+        throw new LogNotFoundError();
+    if (!response.ok || !response.body) {
+        throw new Error(`Log download failed with HTTP ${response.status}.`);
+    }
+    const decoder = new TextDecoder('utf-8');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (bytes + value.byteLength > MAX_LOG_BYTES) {
+                chunks.push(decoder.decode(value.subarray(0, MAX_LOG_BYTES - bytes), { stream: true }));
+                await reader.cancel();
+                break;
+            }
+            bytes += value.byteLength;
+            chunks.push(decoder.decode(value, { stream: true }));
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    chunks.push(decoder.decode());
+    return chunks.join('');
+}
+/** Fetches a call's raw log text. Throws LogNotFoundError when there's no log yet. */
+async function getLogText(call) {
+    if (!call.logfile_url)
+        throw new LogNotFoundError();
+    return downloadLogText(call.logfile_url);
+}
+/**
+ * Runs a shell-style query (grep/awk/sed/cut/sort/uniq/head/tail/wc, piped)
+ * over the log text in a sandboxed, in-process shell -- no real process is
+ * ever spawned, so this is safe on any query typed by a user or an LLM.
+ */
+async function runLogQuery(text, query) {
+    const { Bash } = await Promise.resolve().then(() => __importStar(require('just-bash')));
+    const bash = new Bash({ files: { '/call.log': text } });
+    const { stdout, stderr, exitCode } = await bash.exec(query);
+    if (exitCode !== 0) {
+        throw new Error(stderr || `Query exited with code ${exitCode}.`);
+    }
+    const cappedLines = stdout
+        .split('\n')
+        .map((line) => (line.length > MAX_LINE_CHARS ? `${line.slice(0, MAX_LINE_CHARS)} …[line truncated]` : line))
+        .join('\n');
+    const truncated = cappedLines.length > MAX_RESULT_CHARS;
+    return {
+        result: truncated ? cappedLines.slice(0, MAX_RESULT_CHARS) : cappedLines,
+        truncated,
+    };
+}

package/dist/lib/looseJson.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonFile = readJsonFile;
+exports.stripBom = stripBom;
+exports.parseLooseJson = parseLooseJson;
+const fs_1 = require("fs");
+/**
+ * Read a UTF-8 text file, dropping a leading byte-order mark.
+ *
+ * Windows editors and `Out-File -Encoding utf8` (PowerShell 5.1) write a BOM by
+ * default, and `JSON.parse` rejects it as an unexpected token — so a JSON file
+ * that looks perfectly fine fails to load. Node's 'utf8' decoding keeps the BOM
+ * as U+FEFF, so strip it here, once, for every file we parse.
+ */
+function readJsonFile(path) {
+    return stripBom((0, fs_1.readFileSync)(path, 'utf8'));
+}
+/** Drop a leading U+FEFF, if present. Also applied to stdin, which can carry one. */
+function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+/** Bare tokens that stay unquoted, because JSON gives them a non-string meaning. */
+const LITERAL = /^(true|false|null)$/;
+const NUMBER = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?$/;
+/** Characters that end a bare value / a bare key at the current nesting level. */
+const VALUE_STOP = ',}]';
+const KEY_STOP = ':,}';
+/**
+ * Parse `raw` as JSON, repairing shell-stripped quotes if the strict parse fails.
+ *
+ * PowerShell strips the double quotes out of a single-quoted argument before
+ * handing it to a native program, so
+ *
+ *     ck agents update <id> --set '{"name":"mini"}'
+ *
+ * arrives in `process.argv` as `{name:mini}` — no longer JSON. `parseLooseJson`
+ * puts the quotes back instead: it tries strict `JSON.parse` first and only on
+ * failure runs a repair pass that re-quotes bare keys and bare scalar values
+ * (and accepts 'single-quoted' strings, which shells also mangle).
+ *
+ * Valid JSON always takes the strict path, so nothing well-formed is reinterpreted.
+ *
+ * Use this ONLY for values that came from argv. File and stdin contents are not
+ * touched by the shell, so those stay on strict `JSON.parse` — a genuine typo in
+ * a file should be reported, not guessed at.
+ */
+function parseLooseJson(raw) {
+    const text = raw.trim();
+    try {
+        return JSON.parse(text);
+    }
+    catch (strictErr) {
+        // Only repair something already shaped like an object/array. A bare word is
+        // not mangled JSON, it is just wrong input, and should say so.
+        if (text[0] !== '{' && text[0] !== '[')
+            throw strictErr;
+        let repaired;
+        try {
+            repaired = requote(text);
+        }
+        catch {
+            throw strictErr;
+        }
+        try {
+            return JSON.parse(repaired);
+        }
+        catch {
+            throw strictErr;
+        }
+    }
+}
+/**
+ * Rewrite quote-stripped JSON-ish text into strict JSON.
+ *
+ * A scanner rather than a regex, so nesting, and values containing `:` (URLs) or
+ * spaces, survive: a bare token runs to the next structural character at its own
+ * level, then gets quoted unless it reads as a number or a JSON literal.
+ */
+function requote(text) {
+    let i = 0;
+    const skipWs = () => {
+        while (i < text.length && /\s/.test(text[i]))
+            i++;
+    };
+    const fail = (msg) => {
+        throw new Error(`${msg} at position ${i}`);
+    };
+    function value() {
+        skipWs();
+        const c = text[i];
+        if (c === undefined)
+            return fail('unexpected end of input');
+        if (c === '{')
+            return object();
+        if (c === '[')
+            return array();
+        if (c === '"' || c === "'")
+            return str(c);
+        return bareValue();
+    }
+    function object() {
+        i++; // consume '{'
+        skipWs();
+        if (text[i] === '}') {
+            i++;
+            return '{}';
+        }
+        const parts = [];
+        for (;;) {
+            skipWs();
+            const c = text[i];
+            const key = c === '"' || c === "'" ? str(c) : bareKey();
+            skipWs();
+            if (text[i] !== ':')
+                return fail('expected ":" after object key');
+            i++;
+            parts.push(`${key}:${value()}`);
+            skipWs();
+            if (text[i] === ',') {
+                i++;
+                continue;
+            }
+            if (text[i] === '}') {
+                i++;
+                return `{${parts.join(',')}}`;
+            }
+            return fail('expected "," or "}"');
+        }
+    }
+    function array() {
+        i++; // consume '['
+        skipWs();
+        if (text[i] === ']') {
+            i++;
+            return '[]';
+        }
+        const parts = [];
+        for (;;) {
+            parts.push(value());
+            skipWs();
+            if (text[i] === ',') {
+                i++;
+                continue;
+            }
+            if (text[i] === ']') {
+                i++;
+                return `[${parts.join(',')}]`;
+            }
+            return fail('expected "," or "]"');
+        }
+    }
+    /** Read a quoted string and re-emit it as a valid double-quoted JSON string. */
+    function str(quote) {
+        i++; // consume the opening quote
+        let body = '';
+        while (i < text.length && text[i] !== quote) {
+            if (text[i] === '\\' && i + 1 < text.length) {
+                body += text[i] + text[i + 1];
+                i += 2;
+                continue;
+            }
+            body += text[i++];
+        }
+        if (text[i] !== quote)
+            return fail('unterminated string');
+        i++; // consume the closing quote
+        // Double-quoted bodies already carry JSON escapes, so pass them through.
+        // Single-quoted ones may contain \' (not a JSON escape) and unescaped " —
+        // unescape the former and let JSON.stringify handle the rest.
+        return quote === '"' ? `"${body}"` : JSON.stringify(body.replace(/\\'/g, "'"));
+    }
+    function bareValue() {
+        const token = readUntil(VALUE_STOP);
+        if (token === '')
+            return fail('empty value');
+        if (LITERAL.test(token) || NUMBER.test(token))
+            return token;
+        return JSON.stringify(token);
+    }
+    /** Keys are always strings in JSON — quote even a numeric-looking one. */
+    function bareKey() {
+        const token = readUntil(KEY_STOP);
+        if (token === '')
+            return fail('empty object key');
+        return JSON.stringify(token);
+    }
+    function readUntil(stops) {
+        const start = i;
+        while (i < text.length && !stops.includes(text[i]))
+            i++;
+        return text.slice(start, i).trim();
+    }
+    const out = value();
+    skipWs();
+    if (i < text.length)
+        fail('unexpected trailing input');
+    return out;
+}

package/dist/lib/session.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireApi = requireApi;
+const config_1 = require("./config");
+const ui_1 = require("./ui");
+/**
+ * Get an authenticated API client, or exit if not logged in. Shared by all
+ * commands — the single auth gate.
+ */
+function requireApi() {
+    const { api, cfg } = (0, config_1.getClient)();
+    if (!cfg.token && !process.env.CK_TOKEN) {
+        (0, ui_1.fail)('Not logged in. Run `cku login`.');
+        process.exit(1);
+    }
+    return api;
+}

package/dist/lib/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+/** Thrown for any non-2xx API response; carries the HTTP status and field details. */
+class ApiError extends Error {
+    status;
+    details;
+    constructor(status, message, details = []) {
+        super(message);
+        this.status = status;
+        this.details = details;
+        this.name = 'ApiError';
+    }
+}
+exports.ApiError = ApiError;

package/dist/lib/ui.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fail = exports.info = exports.success = void 0;
+exports.banner = banner;
+exports.keyValue = keyValue;
+exports.table = table;
+exports.handleError = handleError;
+exports.intFlag = intFlag;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const types_1 = require("./types");
+const success = (msg) => console.log(chalk_1.default.green('✔') + ' ' + msg);
+exports.success = success;
+const info = (msg) => console.log(msg);
+exports.info = info;
+const fail = (msg) => console.error(chalk_1.default.red('✖') + ' ' + msg);
+exports.fail = fail;
+/** Styled wordmark shown at the top of help (ANSI Shadow "CKU"). */
+function banner(version) {
+    const art = [
+        ' ██████╗██╗  ██╗██╗   ██╗',
+        '██╔════╝██║ ██╔╝██║   ██║',
+        '██║     █████╔╝ ██║   ██║',
+        '██║     ██╔═██╗ ██║   ██║',
+        '╚██████╗██║  ██╗╚██████╔╝',
+        ' ╚═════╝╚═╝  ╚═╝ ╚═════╝ ',
+    ].join('\n');
+    return ('\n' +
+        chalk_1.default.cyan.bold(art) +
+        chalk_1.default.magenta('  (unofficial fork)') +
+        '\n' +
+        chalk_1.default.dim('  Voice AI agents, straight from your terminal') +
+        chalk_1.default.dim(`   ·   v${version}`) +
+        '\n');
+}
+/** Print an aligned key/value block (used for the account profile). */
+function keyValue(obj) {
+    const entries = Object.entries(obj).filter(([, v]) => v !== undefined && v !== null);
+    if (entries.length === 0)
+        return;
+    const width = Math.max(...entries.map(([k]) => k.length));
+    for (const [k, v] of entries) {
+        console.log(`${chalk_1.default.dim(k.padEnd(width))}  ${v}`);
+    }
+}
+/** Render rows as a bordered table with a highlighted header. */
+function table(headers, rows) {
+    const t = new cli_table3_1.default({ head: headers.map((h) => chalk_1.default.cyan(h)) });
+    for (const row of rows) {
+        t.push(row.map((cell) => (cell === undefined || cell === null ? '' : String(cell))));
+    }
+    console.log(t.toString());
+}
+/**
+ * Turn any thrown error into a clean one-line message + non-zero exit.
+ *
+ * Sets `exitCode` instead of `process.exit()`: on Windows, exiting while a fetch
+ * socket is still closing trips a libuv assertion (UV_HANDLE_CLOSING) that aborts
+ * with code 127 and C-level noise. Letting Node drain and exit keeps a clean
+ * exit 1. Callers return right after, so control doesn't continue.
+ */
+function handleError(err) {
+    (0, exports.fail)(err instanceof Error ? err.message : 'Unexpected error');
+    if (err instanceof types_1.ApiError) {
+        for (const detail of err.details) {
+            const path = detail.path ? `${detail.path}: ` : '';
+            const code = detail.code ? chalk_1.default.dim(` [${detail.code}]`) : '';
+            console.error(`  ${chalk_1.default.cyan(path)}${detail.message}${code}`);
+        }
+    }
+    process.exitCode = 1;
+}
+/**
+ * Parse a positive-integer CLI flag, or return `fallback` when absent.
+ *
+ * `Number('lots')` is NaN, and NaN serialises to `null` in a query string or a
+ * JSON body — so the backend silently receives a null page size instead of the
+ * command reporting a typo. The flag name is passed in so the error names it.
+ */
+function intFlag(raw, flag, fallback) {
+    if (raw === undefined || raw === null || raw === '')
+        return fallback;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+        throw new Error(`${flag} must be a positive whole number (got "${raw}").`);
+    }
+    return n;
+}

package/dist/lib/versions.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Every command that targets a version uses the same flag: `--versions`.
+ * (Plain `--version` is unusable — it collides with the global `-v, --version`.)
+ *
+ * Some commands take a list (export, ab, filters); others target one version.
+ * These helpers keep that single flag forgiving in both cases.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionList = versionList;
+exports.firstVersion = firstVersion;
+/** Split a comma-separated `--versions` value into ids. */
+function versionList(spec) {
+    return (spec || '').split(',').map((s) => s.trim()).filter(Boolean);
+}
+/** First id from `--versions` — for commands that act on a single version. */
+function firstVersion(spec) {
+    return versionList(spec)[0];
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "callkaro-cli-unofficial",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "description": "Unofficial fork of the CallKaro CLI \u2014 manage your voice AI agents from the terminal",
+  "bin": {
+    "cku": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc -p tsconfig.json && node -e \"require('fs').copyFileSync('src/endpoints.json','dist/endpoints.json')\" && node -e \"try{require('fs').chmodSync('dist/index.js',0o755)}catch(e){}\"",
+    "dev": "npm run build && node dist/index.js",
+    "test": "npm run build && node --test tests/*.test.js",
+    "test:only": "node --test tests/*.test.js",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "catalog:sync": "node scripts/sync-catalog.js",
+    "catalog:check": "node scripts/check-catalog-drift.js",
+    "catalog:check:live": "node scripts/check-catalog-drift.js --live"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.0.0",
+    "just-bash": "^3.4.2",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TejasLamba2006/callkaro-cli-unofficial.git"
+  },
+  "homepage": "https://github.com/TejasLamba2006/callkaro-cli-unofficial#readme",
+  "bugs": {
+    "url": "https://github.com/TejasLamba2006/callkaro-cli-unofficial/issues"
+  },
+  "keywords": [
+    "callkaro",
+    "voice-ai",
+    "cli",
+    "agents",
+    "telephony"
+  ]
+}