callkaro-cli-unofficial 0.1.0

package/dist/commands/skills.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSkills = fetchSkills;
+exports.readManifest = readManifest;
+exports.syncSkills = syncSkills;
+exports.skillsInstallCommand = skillsInstallCommand;
+exports.skillsUpdateCommand = skillsUpdateCommand;
+exports.skillsDirCommand = skillsDirCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const child_process_1 = require("child_process");
+const ui_1 = require("../lib/ui");
+const config_1 = require("../lib/config");
+/**
+ * Skills live in their own public repo (Mail-Daddy-AI/callkaro-skills), NOT in
+ * this package — so a skills update never requires a CLI release. Install and
+ * update both mean: download the repo tarball, extract `skills/callkaro`, copy
+ * it into place.
+ */
+const CODEX_MARK_START = '<!-- callkaro-skills:start -->';
+const CODEX_MARK_END = '<!-- callkaro-skills:end -->';
+const PROVIDERS = {
+    copilot: { label: 'GitHub Copilot', global: ['.copilot'], project: ['.github'] },
+    gemini: { label: 'Gemini CLI', global: ['.gemini'], project: ['.gemini'] },
+    cursor: { label: 'Cursor', global: ['.cursor'], project: ['.cursor'] },
+    windsurf: { label: 'Windsurf', global: ['.codeium', 'windsurf'], project: ['.windsurf'] },
+    roo: { label: 'Roo Code', global: ['.roo'], project: ['.roo'] },
+    opencode: { label: 'OpenCode', global: ['.config', 'opencode'], project: ['.opencode'] },
+    cline: { label: 'Cline', global: ['.cline'], project: ['.cline'] },
+    claude: { label: 'Claude Code', global: ['.claude'], project: ['.claude'] },
+    codex: { label: 'OpenAI Codex', global: ['.codex'], project: ['.codex'] },
+};
+const providerNames = Object.keys(PROVIDERS);
+/**
+ * Where a provider's skills live, e.g. ~/.claude/skills/ for Claude Code at
+ * user scope, or <cwd>/.claude/skills/ with --project. The skills root, not a
+ * single skill — each skill is a subdirectory beneath it.
+ */
+function providerTarget(provider, project) {
+    const root = project ? process.cwd() : (0, os_1.homedir)();
+    const segments = project ? PROVIDERS[provider].project : PROVIDERS[provider].global;
+    return (0, path_1.join)(root, ...segments, 'skills');
+}
+function selectedProviders(opts) {
+    if (opts.all)
+        return providerNames;
+    const selected = providerNames.filter((p) => opts[p]);
+    return selected.length > 0 ? selected : ['claude'];
+}
+function hasProviderSelection(opts) {
+    return Boolean(opts.all) || providerNames.some((p) => opts[p]);
+}
+/**
+ * Fetch the skills repo and return the local path to its skills root.
+ * Uses the GitHub codeload tarball + system `tar` (present on macOS, Linux and
+ * Windows 10+), so no git and no npm dependency is required.
+ *
+ * Returns every directory under `skills/`, not just `skills/callkaro`. The
+ * upstream pack is a single `callkaro` skill; this fork's pack is a set of
+ * `callkaro-*` skills. Installing the whole directory works for both layouts
+ * and keeps a new skill flowing through without a CLI change.
+ */
+async function fetchSkills(official) {
+    const repo = (0, config_1.skillsRepoFor)(official);
+    const branch = (0, config_1.skillsBranch)();
+    const url = `https://codeload.github.com/${repo}/tar.gz/refs/heads/${branch}`;
+    const work = (0, path_1.join)((0, os_1.tmpdir)(), `cku-skills-${Date.now()}`);
+    const cleanup = () => {
+        try {
+            (0, fs_1.rmSync)(work, { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+    };
+    (0, fs_1.mkdirSync)(work, { recursive: true });
+    (0, ui_1.info)(`Fetching skills from ${repo}@${branch}…`);
+    let res;
+    try {
+        res = await fetch(url);
+    }
+    catch (e) {
+        cleanup();
+        throw new Error(`Could not reach GitHub (${e.message}). Check your connection and retry.`);
+    }
+    if (!res.ok) {
+        cleanup();
+        throw new Error(`Download failed (${res.status}) from ${url}`);
+    }
+    const tgz = (0, path_1.join)(work, 'skills.tar.gz');
+    (0, fs_1.writeFileSync)(tgz, Buffer.from(await res.arrayBuffer()));
+    try {
+        // Run tar with `work` as the working directory and pass only *relative*
+        // names. An absolute path is not an option on Windows: GNU tar reads
+        // "C:/Users/..." as a <host>:<path> remote spec and tries to connect to a
+        // machine named "C" ("Cannot connect to C: resolve failed"). Backslashes
+        // fail differently — tar treats them as escapes. Relative names sidestep
+        // both, and are exactly what upstream does not do, which is why
+        // `ck skills install` is broken on Windows.
+        (0, child_process_1.execFileSync)('tar', ['-xzf', 'skills.tar.gz', '--strip-components=1'], {
+            cwd: work,
+            stdio: 'ignore',
+        });
+    }
+    catch {
+        cleanup();
+        throw new Error('Could not extract the download — is `tar` available on your PATH?');
+    }
+    const skillsRoot = (0, path_1.join)(work, 'skills');
+    if (!(0, fs_1.existsSync)(skillsRoot)) {
+        cleanup();
+        throw new Error(`The repo ${repo} has no skills/ directory — check the branch (${branch}).`);
+    }
+    // A skill is a directory containing SKILL.md; anything else is not one.
+    const names = (0, fs_1.readdirSync)(skillsRoot, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && (0, fs_1.existsSync)((0, path_1.join)(skillsRoot, e.name, 'SKILL.md')))
+        .map((e) => e.name);
+    if (!names.length) {
+        cleanup();
+        throw new Error(`No skills found in ${repo}@${branch} — expected directories under skills/ each containing SKILL.md.`);
+    }
+    return { dir: skillsRoot, names, cleanup };
+}
+/** Copy the pack into a target dir, replacing whatever is there. */
+function place(src, dest) {
+    try {
+        (0, fs_1.rmSync)(dest, { recursive: true, force: true }); // drop files deleted upstream
+    }
+    catch (e) {
+        // Almost always: a previous `sudo cku ...` left root-owned files behind.
+        throw new Error(`Cannot replace ${dest} (${e.code || e.message}).\n` +
+            `It likely contains files owned by another user — created by running the CLI with sudo.\n` +
+            `Fix it with:\n  sudo rm -rf ${dest}\nthen re-run this command WITHOUT sudo.`);
+    }
+    (0, fs_1.mkdirSync)(dest, { recursive: true });
+    (0, fs_1.cpSync)(src, dest, { recursive: true });
+    restoreOwnershipIfSudo(dest);
+}
+/**
+ * When invoked through sudo, files land owned by root inside the user's home —
+ * which then blocks every later non-sudo `skills update`. Hand them back to the
+ * invoking user so the next run works normally.
+ */
+function restoreOwnershipIfSudo(dest) {
+    if (process.platform === 'win32')
+        return;
+    const uid = process.env.SUDO_UID;
+    const gid = process.env.SUDO_GID;
+    if (!uid || typeof process.getuid !== 'function' || process.getuid() !== 0)
+        return;
+    try {
+        (0, child_process_1.execFileSync)('chown', ['-R', `${uid}:${gid || uid}`, dest], { stdio: 'ignore' });
+    }
+    catch {
+        (0, ui_1.info)(`Note: could not hand ${dest} back to your user — if a later update fails, run: sudo chown -R $USER ${dest}`);
+    }
+}
+/** Codex has no skills system — wire a pointer block into ~/.codex/AGENTS.md. */
+function wireCodexPointer() {
+    const codexHome = (0, path_1.join)((0, os_1.homedir)(), '.codex');
+    const block = `${CODEX_MARK_START}
+## CallKaro voice agents
+For ANY task involving CallKaro (voice agents, calls, batch campaigns,
+simulations, phone numbers, analytics): FIRST read
+~/.codex/skills/callkaro/SKILL.md and follow the files it routes to
+(INSTRUCTIONS.md for how to operate; authoring-pipeline/ when building agents).
+All operations run through the \`cku\` CLI (this fork) — it must be logged in (\`cku login\`).
+If you have the official CLI instead, substitute \`ck\` for \`cku\` throughout.
+Prefer \`--json\` output and never invent ids — list first.
+${CODEX_MARK_END}`;
+    const agentsMd = (0, path_1.join)(codexHome, 'AGENTS.md');
+    let content = (0, fs_1.existsSync)(agentsMd) ? (0, fs_1.readFileSync)(agentsMd, 'utf8') : '';
+    if (content.includes(CODEX_MARK_START)) {
+        content = content.replace(new RegExp(`${CODEX_MARK_START}[\\s\\S]*?${CODEX_MARK_END}`), block);
+    }
+    else {
+        content = content ? `${content.replace(/\n*$/, '\n\n')}${block}\n` : `${block}\n`;
+    }
+    (0, fs_1.mkdirSync)(codexHome, { recursive: true });
+    (0, fs_1.writeFileSync)(agentsMd, content);
+    return agentsMd;
+}
+/**
+ * Install and update are the same operation: pull the latest pack and place it.
+ * Each skill goes into its own subdirectory under the provider's skills root,
+ * so adding a skill to the repo flows through with no CLI change.
+ *
+ * `pack` lets a caller that already fetched (bare `update`) avoid a second download.
+ */
+async function installOrUpdate(opts, verb, pack) {
+    const { dir, names, cleanup } = pack || (await fetchSkills(Boolean(opts.official)));
+    const repo = (0, config_1.skillsRepoFor)(Boolean(opts.official));
+    try {
+        const providers = selectedProviders(opts);
+        for (const provider of providers) {
+            const root = providerTarget(provider, Boolean(opts.project));
+            syncSkills(root, dir, names, repo);
+            if (provider === 'codex' && !opts.project) {
+                const agentsMd = wireCodexPointer();
+                (0, ui_1.success)(`${verb} for ${PROVIDERS[provider].label}:\n  skills: ${root}\n  wired into: ${agentsMd}`);
+            }
+            else {
+                (0, ui_1.success)(`${verb} for ${PROVIDERS[provider].label}:\n  ${root}\n  ${names.length} skill(s): ${names.join(', ')}`);
+            }
+        }
+        (0, ui_1.info)(opts.project
+            ? 'Scope: this project. Commit the skill folder(s) to share them with your team.'
+            : 'Scope: your user account — available across projects.');
+        const which = opts.official ? `official (${config_1.OFFICIAL_SKILLS_REPO})` : `fork (${(0, config_1.skillsRepo)()})`;
+        (0, ui_1.info)(`\nPack: ${which}`);
+        (0, ui_1.info)('Open a new agent session and ask it anything about CallKaro.');
+        (0, ui_1.info)('Requires the `cku` CLI to be logged in (`cku login`) — the skill pack documents that CLI.');
+    }
+    finally {
+        cleanup();
+    }
+}
+/**
+ * Which skills `cku` itself put in a skills root, per source repo. Lives beside
+ * them as `.cku-skills.json`.
+ *
+ * Pruning and bare `update` both go by this record, never by the `callkaro*`
+ * name prefix. The official `ck` installs its own `callkaro` skill into the same
+ * roots, and a prefix match would delete it (or update a root `cku` never
+ * installed into). A skill not listed here is not ours to touch.
+ */
+const MANIFEST = '.cku-skills.json';
+function readManifest(root) {
+    try {
+        const m = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(root, MANIFEST), 'utf8'));
+        return m && typeof m === 'object' && !Array.isArray(m) ? m : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Place a pack's skills into `root`, remove skills this repo installed earlier
+ * that the pack no longer has, and record what is now installed.
+ *
+ * Keyed by repo, so updating the fork pack never prunes skills placed from the
+ * upstream pack beside it, and vice versa.
+ */
+function syncSkills(root, srcDir, names, repo) {
+    (0, fs_1.mkdirSync)(root, { recursive: true });
+    const manifest = readManifest(root);
+    for (const name of names)
+        place((0, path_1.join)(srcDir, name), (0, path_1.join)(root, name));
+    for (const name of manifest[repo] || []) {
+        if (names.includes(name))
+            continue;
+        try {
+            (0, fs_1.rmSync)((0, path_1.join)(root, name), { recursive: true, force: true });
+            (0, ui_1.info)(`  removed stale skill: ${name}`);
+        }
+        catch {
+            /* leave it; the next update can retry */
+        }
+    }
+    manifest[repo] = [...names];
+    const path = (0, path_1.join)(root, MANIFEST);
+    (0, fs_1.writeFileSync)(path, JSON.stringify(manifest, null, 2) + '\n');
+    restoreOwnershipIfSudo(path);
+}
+async function skillsInstallCommand(opts) {
+    try {
+        await installOrUpdate(opts, 'Installed');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+async function skillsUpdateCommand(opts) {
+    try {
+        // With no flags, refresh every location that already has this pack, so a
+        // bare `cku skills update` does the obvious thing for every provider.
+        if (!opts.project && !hasProviderSelection(opts)) {
+            const pack = await fetchSkills(Boolean(opts.official));
+            const repo = (0, config_1.skillsRepoFor)(Boolean(opts.official));
+            // "Has this pack" = cku recorded installing it there, or (for installs made
+            // before the record existed) one of the pack's own skill names is present.
+            // Not any `callkaro*` directory: ~/.claude/skills/callkaro is usually the
+            // official `ck` skill, and updating that root would install this pack beside it.
+            const holdsPack = (root) => Boolean(readManifest(root)[repo]) ||
+                pack.names.some((n) => (0, fs_1.existsSync)((0, path_1.join)(root, n, 'SKILL.md')));
+            const targets = providerNames
+                .flatMap((provider) => [
+                { opts: { ...opts, [provider]: true }, path: providerTarget(provider, false) },
+                { opts: { ...opts, [provider]: true, project: true }, path: providerTarget(provider, true) },
+            ])
+                .filter((target) => holdsPack(target.path));
+            if (targets.length === 0) {
+                pack.cleanup();
+                (0, ui_1.fail)('The skill pack is not installed yet — run `cku skills install` first.');
+                process.exitCode = 1;
+                return;
+            }
+            // One download serves every target; cleanup runs after the last.
+            const shared = { ...pack, cleanup: () => { } };
+            try {
+                for (const t of targets)
+                    await installOrUpdate(t.opts, 'Updated', shared);
+            }
+            finally {
+                pack.cleanup();
+            }
+            return;
+        }
+        await installOrUpdate(opts, 'Updated');
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}
+function skillsDirCommand(opts) {
+    for (const provider of selectedProviders(opts)) {
+        console.log(providerTarget(provider, Boolean(opts.project)));
+    }
+}

package/dist/commands/transcribers.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transcribersCommand = transcribersCommand;
+const ui_1 = require("../lib/ui");
+const dashboardAuth_1 = require("../lib/dashboardAuth");
+const catalog_1 = require("../lib/catalog");
+function rowsFor(p) {
+    if (!p.models.length) {
+        return [{
+                provider: p.name,
+                model: '(none)',
+                languageKind: p.languageKind || '—',
+                languages: p.languages.join(' '),
+            }];
+    }
+    return p.models.map((m) => ({
+        provider: p.name,
+        model: m.name,
+        languageKind: p.languageKind || '—',
+        languages: m.languages.join(' '),
+    }));
+}
+/** `--provider X --fields` — the exact keys a provider's `transcriber` object takes. */
+function showFields(p, json) {
+    if (json) {
+        return void console.log(JSON.stringify({ provider: p.name, fields: p.fields, models: p.models, languageKind: p.languageKind, languages: p.languages, gate: p.gate, notes: p.notes }, null, 2));
+    }
+    (0, ui_1.keyValue)({
+        provider: p.name,
+        'transcriber keys': p.fields.join(', '),
+        models: p.models.length ? p.models.map((m) => m.name).join(', ') : '(no transcriber_model key)',
+        transcriber_language: p.languageKind === 'array' ? 'array of locales' : 'single string',
+        languages: p.languages.join(' '),
+        access: p.gate === 'admin' ? 'master admin only' : 'all accounts',
+    });
+    if (p.notes)
+        (0, ui_1.info)(`\n${p.notes}`);
+    (0, ui_1.info)("\nCopy transcriber_language verbatim — never reformat [\"en-IN\"] to \"en\", and never wrap a string provider's value in an array.");
+}
+function unknownProvider(name) {
+    (0, ui_1.info)(`Unknown transcriber provider "${name}". Known: ${catalog_1.TRANSCRIBER_PROVIDERS.map((p) => p.name).join(', ')}.`);
+    process.exitCode = 1;
+}
+async function transcribersCommand(opts) {
+    try {
+        // Prefer the server's own model list; the built-in copy has drifted from it
+        // (Groq is listed here but not served, and Smallest's model id has changed).
+        await (0, dashboardAuth_1.refreshModelCatalog)();
+        const providers = (0, catalog_1.visibleTranscriberProviders)({ all: opts.all });
+        const stale = providers.filter((p) => p.servedBy === false);
+        if (opts.fields) {
+            if (!opts.provider) {
+                (0, ui_1.info)('--fields needs a provider, e.g. `cku transcribers --provider sarvam --fields`.');
+                process.exitCode = 1;
+                return;
+            }
+            const p = (0, catalog_1.findTranscriberProvider)(opts.provider);
+            if (!p)
+                return unknownProvider(opts.provider);
+            return showFields(p, opts.json);
+        }
+        let scoped = providers;
+        if (opts.provider) {
+            const p = (0, catalog_1.findTranscriberProvider)(opts.provider);
+            if (!p)
+                return unknownProvider(opts.provider);
+            scoped = providers.filter((x) => x.name === p.name);
+            // A gated provider asked for by name should still show, not be silently empty.
+            if (!scoped.length)
+                scoped = [p];
+        }
+        let rows = scoped.flatMap(rowsFor);
+        if (opts.language) {
+            rows = rows.filter((r) => r.languages.split(' ').some((l) => (0, catalog_1.langMatches)(l, [opts.language])));
+        }
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No transcribers matched. Try fewer filters.');
+        (0, ui_1.table)(['PROVIDER', 'MODEL', 'LANGUAGE FIELD', 'LANGUAGES'], rows.map((r) => [r.provider, r.model, r.languageKind, r.languages]));
+        (0, ui_1.info)(`\n${rows.length} provider/model combination(s).`);
+        (0, ui_1.info)('Use `cku transcribers --provider <name> --fields` for the exact keys a provider takes.');
+        if (!opts.all && catalog_1.TRANSCRIBER_PROVIDERS.some((p) => p.gate === 'admin')) {
+            (0, ui_1.info)('Admin-gated providers are hidden — add --all to include them.');
+        }
+        if (stale.length) {
+            (0, ui_1.info)('');
+            (0, ui_1.info)(`Not currently served by the backend, kept from the built-in list: ${stale.map((p) => p.name).join(', ')}`);
+            (0, ui_1.info)('  Their models are stale. Re-run `npm run catalog:sync` to drop them.');
+        }
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}

package/dist/commands/update.js

@@ -0,0 +1,86 @@
+"use strict";
+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.updateCommand = updateCommand;
+const child_process_1 = require("child_process");
+const ui_1 = require("../lib/ui");
+/**
+ * `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).
+ */
+async function updateCommand(opts) {
+    try {
+        (0, ui_1.info)('Installing globally via npm …');
+        try {
+            let legacyInstalled = false;
+            try {
+                (0, child_process_1.execFileSync)('npm', ['list', '--global', '@callkaro/cli', '--depth=0'], { stdio: 'ignore' });
+                legacyInstalled = true;
+            }
+            catch {
+                /* legacy package is not installed */
+            }
+            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)('npm', ['install', '--global', 'callkaro-cli-unofficial'], { stdio: 'ignore' });
+        }
+        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');
+            process.exitCode = 1;
+            return;
+        }
+        let version = '';
+        try {
+            version = (0, child_process_1.execFileSync)('cku', ['--version'], { encoding: 'utf8' }).trim();
+        }
+        catch {
+            /* not on PATH yet in this shell */
+        }
+        (0, ui_1.success)(`CLI updated${version ? ` to v${version}` : ''}.`);
+        if (opts.skipSkills) {
+            (0, ui_1.info)('Skipped the skill pack (--skip-skills). Refresh it with `cku skills update`.');
+            return;
+        }
+        (0, ui_1.info)('\nRefreshing the skill pack…');
+        const { skillsUpdateCommand } = await Promise.resolve().then(() => __importStar(require('./skills')));
+        await skillsUpdateCommand({});
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}