@robzilla1738/agentswarm 0.2.0

package/dist/cli.js

@@ -0,0 +1,667 @@
+"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.main = main;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const control_1 = require("./control");
+const deepseek_1 = require("./deepseek");
+const deepseek_2 = require("./deepseek");
+const providers_1 = require("./providers");
+const hub_1 = require("./hub");
+const journal_1 = require("./journal");
+const run_1 = require("./run");
+const executor_1 = require("./executor");
+const sandbox_1 = require("./sandbox");
+const terminal_1 = require("./terminal");
+const util_1 = require("./util");
+const BIN_PATH = path.join(__dirname, "..", "bin", "swarm.js");
+/** Flags that never take a value — they must not swallow the next positional
+ *  (`swarm run --fg "mission"` would otherwise eat the mission). */
+const BOOL_FLAGS = new Set(["fg", "open", "resume"]);
+function parseArgs(argv) {
+    const _ = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith("--")) {
+            const key = a.slice(2);
+            const next = argv[i + 1];
+            if (key.startsWith("no-")) {
+                flags[key.slice(3)] = false;
+            }
+            else if (!BOOL_FLAGS.has(key) && next !== undefined && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            _.push(a);
+        }
+    }
+    return { _, flags };
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const { _, flags } = parseArgs(argv);
+    const cmd = _[0];
+    try {
+        switch (cmd) {
+            case undefined:
+            case "help":
+            case "-h":
+            case "--help":
+                printHelp();
+                break;
+            case "run":
+                await cmdRun(_.slice(1).join(" "), flags);
+                break;
+            case "_exec":
+                await cmdExec(_[1], Boolean(flags.resume));
+                break;
+            case "resume":
+                await cmdResume(_[1], flags);
+                break;
+            case "sandbox":
+                await cmdSandbox(_[1]);
+                break;
+            case "serve":
+                await cmdServe(flags);
+                break;
+            case "watch":
+                await cmdWatch(_[1]);
+                break;
+            case "ls":
+            case "list":
+                cmdList();
+                break;
+            case "report":
+                cmdReport(_[1], flags);
+                break;
+            case "note":
+                cmdNote(_[1], _.slice(2).join(" "));
+                break;
+            case "cancel":
+                cmdCancel(_[1]);
+                break;
+            case "config":
+                await cmdConfig(_.slice(1), flags);
+                break;
+            case "models":
+                await cmdModels();
+                break;
+            case "demo":
+                await cmdDemo(flags);
+                break;
+            default:
+                console.error(util_1.ansi.red(`unknown command: ${cmd}`));
+                printHelp();
+                process.exit(1);
+        }
+    }
+    catch (e) {
+        console.error(util_1.ansi.red("error: ") + (0, util_1.errMsg)(e));
+        process.exit(1);
+    }
+}
+// ---------------------------------------------------------------- run
+function optionOverrides(flags, cfg) {
+    const o = {};
+    if (flags.workers)
+        o.maxWorkers = Number(flags.workers);
+    if (flags.steps)
+        o.maxStepsPerTask = Number(flags.steps);
+    if (flags.tasks)
+        o.maxTasks = Number(flags.tasks);
+    if (flags.budget)
+        o.maxTokens = Number(flags.budget);
+    if (typeof flags.model === "string")
+        o.model = flags.model;
+    if (typeof flags.conductor === "string")
+        o.conductorModel = flags.conductor;
+    if (typeof flags.verify === "string" && ["off", "normal", "strict"].includes(flags.verify)) {
+        o.verification = flags.verify;
+    }
+    if (flags.thinking === false)
+        o.thinking = false;
+    if (typeof flags.effort === "string") {
+        if (!["low", "medium", "high", "max"].includes(flags.effort)) {
+            throw new Error("--effort must be one of: low | medium | high | max");
+        }
+        o.reasoningEffort = flags.effort;
+    }
+    if (flags.safe === false)
+        o.safeMode = false;
+    if (typeof flags.sandbox === "string") {
+        const v = flags.sandbox;
+        if (v !== "auto" && !sandbox_1.SANDBOX_KINDS.includes(v)) {
+            throw new Error(`--sandbox must be one of: ${sandbox_1.SANDBOX_KINDS.join(" | ")} | auto`);
+        }
+        o.sandboxRuntime = v === "auto" ? (0, sandbox_1.resolveSandboxKind)({ ...cfg, sandboxRuntime: "auto" }) : v;
+    }
+    return o;
+}
+async function cmdRun(mission, flags) {
+    if (!mission.trim()) {
+        console.error(util_1.ansi.red('Provide a mission: swarm run "build X / research Y"'));
+        process.exit(1);
+    }
+    const cfg = (0, config_1.loadConfig)();
+    // Validate flags before any network round-trip so typos fail instantly.
+    const overrides = optionOverrides(flags, cfg);
+    if (!cfg.apiKey && providers_1.PROVIDERS[cfg.provider].keyRequired) {
+        console.error(util_1.ansi.red(`No ${providers_1.PROVIDERS[cfg.provider].label} API key set. `) + "Run: swarm config set apiKey <...>");
+        process.exit(1);
+    }
+    process.stdout.write(util_1.ansi.gray("validating API key… "));
+    const auth = await (0, deepseek_2.validateAuth)(cfg);
+    if (auth.status === "invalid") {
+        console.error(util_1.ansi.red(`\n✗ ${providers_1.PROVIDERS[cfg.provider].label} key rejected: `) + (auth.message || "invalid key"));
+        console.error(util_1.ansi.gray("  Set a valid key: ") + "swarm config set apiKey <...>");
+        process.exit(1);
+    }
+    process.stdout.write(auth.status === "ok" ? util_1.ansi.green("ok\n") : util_1.ansi.gray("skipped\n"));
+    const sandbox = flags.sandbox !== false && !flags.cwd;
+    if (typeof flags.sandbox === "string" && flags.cwd) {
+        console.log(util_1.ansi.yellow("note: ") + "--cwd runs execute directly on the host — --sandbox is ignored");
+    }
+    const cwd = typeof flags.cwd === "string" ? flags.cwd : process.cwd();
+    const meta = (0, run_1.createRun)({
+        mission: mission.trim(),
+        cwd,
+        sandbox,
+        options: (0, run_1.optionsFromConfig)(cfg, overrides),
+    });
+    if (flags.fg) {
+        await execForeground(cfg, meta, true);
+        return;
+    }
+    // Default: launch detached, attach a live dashboard by tailing the journal.
+    (0, run_1.launchDetached)(meta.id, BIN_PATH);
+    console.log(`${util_1.ansi.cyan("🐝 swarm launched")} ${util_1.ansi.gray(meta.id)} ${util_1.ansi.gray("· workdir:")} ${meta.cwd}`);
+    await new Promise((r) => setTimeout(r, 400));
+    let detaching = false;
+    const onSig = () => {
+        detaching = true;
+    };
+    process.on("SIGINT", onSig);
+    await watchRunUntilSignal(meta.id, cfg.pricing, () => detaching);
+    process.off("SIGINT", onSig);
+    if (detaching && (0, run_1.isRunLive)(meta.id)) {
+        console.log("\n" +
+            util_1.ansi.yellow("detached") +
+            ` — run continues in the background.\n  reattach:  swarm watch ${meta.id}\n  steer:     swarm note ${meta.id} "..."\n  stop:      swarm cancel ${meta.id}`);
+    }
+    else {
+        printFinalLine(meta.id);
+    }
+}
+/** `swarm sandbox [test]` — show the resolved runtime; boot + echo + teardown. */
+async function cmdSandbox(sub) {
+    const cfg = (0, config_1.loadConfig)();
+    const resolved = (0, sandbox_1.resolveSandboxKind)(cfg);
+    console.log(`configured: ${cfg.sandboxRuntime} → resolved: ${util_1.ansi.bold(resolved)}`);
+    console.log(util_1.ansi.gray(`docker daemon: ${(0, sandbox_1.dockerAvailable)() ? "up" : "not reachable"} · e2b key: ${cfg.e2bApiKey ? "set" : "—"} · modal: ${cfg.modalTokenId ? "set" : "—"} · vercel: ${cfg.vercelToken ? "set" : "—"}`));
+    if (resolved === "host") {
+        console.log(util_1.ansi.gray("host = the run's isolated workspace on this machine (the default; nothing to install)."));
+        console.log(util_1.ansi.gray("for container/cloud isolation: swarm config set sandboxRuntime docker|e2b|modal|vercel|auto"));
+    }
+    if (sub === "test" || (sub && sandbox_1.SANDBOX_KINDS.includes(sub))) {
+        const kind = sandbox_1.SANDBOX_KINDS.includes(sub) ? sub : resolved;
+        process.stdout.write(`testing ${kind}… `);
+        const r = await (0, sandbox_1.testSandbox)(cfg, kind);
+        console.log(r.ok ? util_1.ansi.green("✓ ok ") + util_1.ansi.gray(r.detail) : util_1.ansi.red("✗ ") + r.detail);
+        process.exit(r.ok ? 0 : 1);
+    }
+}
+async function cmdExec(id, resume = false) {
+    if (!id)
+        throw new Error("_exec requires a run id");
+    const meta = (0, run_1.loadMeta)(id);
+    if (!meta)
+        throw new Error(`run not found: ${id}`);
+    const cfg = (0, config_1.loadConfig)();
+    await execForeground(cfg, meta, false, resume);
+    process.exit(0);
+}
+/** Resume an interrupted run: settled tasks keep their results, in-flight tasks re-run. */
+async function cmdResume(id, flags) {
+    if (!id)
+        throw new Error("usage: swarm resume <run-id>");
+    const info = (0, run_1.resumeInfo)(id);
+    if (!info.resumable) {
+        console.error(util_1.ansi.red("✗ cannot resume: ") + (info.reason || "unknown"));
+        process.exit(1);
+    }
+    const cfg = (0, config_1.loadConfig)();
+    const meta = (0, run_1.loadMeta)(id);
+    console.log(`${util_1.ansi.cyan("🐝 resuming")} ${util_1.ansi.gray(id)} ${util_1.ansi.gray("· workdir:")} ${meta.cwd}`);
+    if (flags.fg) {
+        await execForeground(cfg, meta, true, true);
+        return;
+    }
+    (0, run_1.launchDetached)(id, BIN_PATH, true);
+    await new Promise((r) => setTimeout(r, 400));
+    let detaching = false;
+    const onSig = () => {
+        detaching = true;
+    };
+    process.on("SIGINT", onSig);
+    await watchRunUntilSignal(id, cfg.pricing, () => detaching);
+    process.off("SIGINT", onSig);
+    if (detaching && (0, run_1.isRunLive)(id)) {
+        console.log("\n" + util_1.ansi.yellow("detached") + ` — run continues in the background. Reattach: swarm watch ${id}`);
+    }
+    else {
+        printFinalLine(id);
+    }
+}
+async function execForeground(cfg, meta, render, resume = false) {
+    // Reduce the journal BEFORE opening it for appends — the seed must reflect
+    // exactly what the dead engine left behind.
+    const seed = resume ? (0, run_1.loadRunState)(meta.id, cfg.pricing) : null;
+    const journal = new journal_1.Journal((0, config_1.runDir)(meta.id));
+    const renderer = render ? new terminal_1.TerminalRenderer(cfg.pricing) : null;
+    if (renderer) {
+        journal.onEvent = (ev) => renderer.ingest(ev);
+        renderer.start();
+    }
+    (0, run_1.writePid)(meta.id);
+    const executor = new executor_1.Executor(cfg, meta, journal);
+    if (resume && seed) {
+        const resets = seed
+            .taskList()
+            .filter((t) => t.status === "running" || t.status === "verifying")
+            .map((t) => t.id);
+        journal.append("run.resumed", { resets });
+        executor.seedFromState(seed, resets);
+    }
+    else {
+        journal.append("run.created", { meta });
+    }
+    const onSig = () => {
+        if (renderer) {
+            renderer.stop();
+            console.log(util_1.ansi.yellow("\ncancelling…"));
+        }
+        executor.cancel();
+    };
+    process.on("SIGINT", onSig);
+    // A crash without a terminal status would leave the run "running" forever
+    // in every viewer. Record the failure, flush, and exit non-zero.
+    const onFatal = (e) => {
+        try {
+            journal.append("run.status", { status: "failed", reason: `engine crashed: ${(0, util_1.errMsg)(e)}` });
+        }
+        catch {
+            /* nothing left to do */
+        }
+        journal.flush().finally(() => {
+            (0, run_1.clearPid)(meta.id);
+            if (renderer)
+                renderer.stop();
+            process.exit(1);
+        });
+    };
+    process.on("uncaughtException", onFatal);
+    process.on("unhandledRejection", onFatal);
+    try {
+        await executor.run();
+    }
+    finally {
+        process.off("SIGINT", onSig);
+        process.off("uncaughtException", onFatal);
+        process.off("unhandledRejection", onFatal);
+        (0, run_1.clearPid)(meta.id);
+        await journal.flush();
+        if (renderer)
+            renderer.stop();
+    }
+    if (render)
+        printFinalLine(meta.id);
+}
+async function watchRunUntilSignal(id, pricing, shouldStop) {
+    const { eventsFile, readNewEvents } = await Promise.resolve().then(() => __importStar(require("./journal")));
+    const renderer = new terminal_1.TerminalRenderer(pricing);
+    const file = eventsFile((0, config_1.runDir)(id));
+    const tail = { offset: 0, carry: "" };
+    renderer.start();
+    return new Promise((resolve) => {
+        const tick = () => {
+            if (shouldStop()) {
+                renderer.stop();
+                return resolve();
+            }
+            try {
+                for (const ev of readNewEvents(file, tail))
+                    renderer.ingest(ev);
+            }
+            catch {
+                /* not ready */
+            }
+            const st = renderer.getState().status;
+            if (["done", "failed", "cancelled"].includes(st)) {
+                setTimeout(() => {
+                    try {
+                        for (const ev of readNewEvents(file, tail))
+                            renderer.ingest(ev);
+                    }
+                    catch { /* ignore */ }
+                    renderer.stop();
+                    resolve();
+                }, 400);
+                return;
+            }
+            setTimeout(tick, 250);
+        };
+        tick();
+    });
+}
+// ---------------------------------------------------------------- serve
+async function cmdServe(flags) {
+    const cfg = (0, config_1.loadConfig)();
+    const port = Number(flags.port) || (flags.port === "0" ? 0 : cfg.hubPort);
+    const uiDir = findUiDir();
+    const server = (0, hub_1.startHub)({ port, uiDir, binPath: BIN_PATH });
+    // Report the port actually bound (matters for --port 0 / collisions).
+    server.on("listening", () => {
+        const addr = server.address();
+        const bound = typeof addr === "object" && addr ? addr.port : port;
+        const url = `http://localhost:${bound}`;
+        console.log(`${util_1.ansi.cyan("🐝 agentswarm hub")} ${util_1.ansi.gray("·")} ${util_1.ansi.bold(url)}`);
+        console.log(util_1.ansi.gray(`   api:      ${url}/api`));
+        console.log(util_1.ansi.gray(`   ui:       ${uiDir ? "built ✓ (served here)" : "not built — run: npm run setup   (or: npm run build:ui)"}`));
+        console.log(util_1.ansi.gray(`   api key:  ${cfg.apiKey ? (0, config_1.maskKey)(cfg.apiKey) + " ✓" : util_1.ansi.red("not set — open Settings or: swarm config set apiKey <sk-...>")}`));
+        console.log(util_1.ansi.gray("   Ctrl-C to stop the hub (background runs keep going).\n"));
+        if (flags.open)
+            openBrowser(url);
+    });
+    server.on("error", (e) => {
+        console.error(util_1.ansi.red(`hub failed: ${(0, util_1.errMsg)(e)}`));
+        process.exit(1);
+    });
+    await new Promise(() => { }); // run forever
+}
+function findUiDir() {
+    const candidates = [
+        path.join(__dirname, "..", "ui", "out"),
+        path.join(process.cwd(), "ui", "out"),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(path.join(c, "index.html")))
+            return c;
+    }
+    return null;
+}
+function openBrowser(url) {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    try {
+        (0, child_process_1.spawn)(cmd, [url], { detached: true, stdio: "ignore" }).unref();
+    }
+    catch {
+        /* ignore */
+    }
+}
+// ---------------------------------------------------------------- watch / list / report
+async function cmdWatch(id) {
+    if (!id)
+        throw new Error("usage: swarm watch <id>");
+    id = resolveId(id);
+    if (!(0, run_1.loadMeta)(id))
+        throw new Error(`run not found: ${id}`);
+    const cfg = (0, config_1.loadConfig)();
+    await (0, terminal_1.watchRun)(id, cfg.pricing);
+    printFinalLine(id);
+}
+function cmdList() {
+    const cfg = (0, config_1.loadConfig)();
+    const runs = (0, run_1.listRuns)(cfg.pricing);
+    if (!runs.length) {
+        console.log(util_1.ansi.gray("no runs yet. start one: ") + 'swarm run "your mission"');
+        return;
+    }
+    console.log(util_1.ansi.bold("runs") + util_1.ansi.gray(`  (~/.agentswarm/runs)`));
+    for (const r of runs) {
+        const live = r.pid ? util_1.ansi.cyan(" ●live") : "";
+        const st = r.status === "done" ? util_1.ansi.green(r.status) : r.status === "failed" ? util_1.ansi.red(r.status) : util_1.ansi.yellow(r.status);
+        const tok = (0, util_1.fmtTokens)(r.usage.promptTokens + r.usage.completionTokens);
+        console.log(`  ${util_1.ansi.gray(r.id)}  ${st.padEnd(14)} ${util_1.ansi.gray(`${r.tasks.done}/${r.tasks.total} tasks`)}  ${util_1.ansi.gray(tok + " tok")}  ${util_1.ansi.green((0, util_1.fmtMoney)(r.cost))}${live}`);
+        console.log(`     ${clipLine(r.mission, 90)}`);
+    }
+}
+function cmdReport(id, flags) {
+    if (!id)
+        throw new Error("usage: swarm report <id>");
+    id = resolveId(id);
+    const file = path.join((0, config_1.runDir)(id), "artifacts", "final-report.md");
+    if (!fs.existsSync(file)) {
+        console.error(util_1.ansi.yellow("no final report yet for ") + id);
+        process.exit(1);
+    }
+    if (flags.open) {
+        openBrowser("file://" + file);
+        console.log(file);
+        return;
+    }
+    process.stdout.write(fs.readFileSync(file, "utf8") + "\n");
+    const arts = path.join((0, config_1.runDir)(id), "artifacts");
+    console.log(util_1.ansi.gray(`\nartifacts: ${arts}`));
+}
+function cmdNote(id, text) {
+    if (!id || !text)
+        throw new Error('usage: swarm note <id> "message"');
+    id = resolveId(id);
+    if (!(0, run_1.loadMeta)(id))
+        throw new Error(`run not found: ${id}`);
+    (0, control_1.appendControl)((0, config_1.runDir)(id), { kind: "note", text });
+    console.log(util_1.ansi.green("✓ ") + ((0, run_1.isRunLive)(id) ? "note delivered to the conductor" : "note queued (run is not live)"));
+}
+function cmdCancel(id) {
+    if (!id)
+        throw new Error("usage: swarm cancel <id>");
+    id = resolveId(id);
+    if (!(0, run_1.loadMeta)(id))
+        throw new Error(`run not found: ${id}`);
+    (0, control_1.appendControl)((0, config_1.runDir)(id), { kind: "cancel" });
+    console.log(util_1.ansi.yellow("⛔ cancel requested for ") + id);
+}
+// ---------------------------------------------------------------- config / models
+async function cmdConfig(rest, flags) {
+    const sub = rest[0] || "list";
+    if (sub === "list" || sub === "get") {
+        const cfg = (0, config_1.loadConfig)();
+        if (sub === "get" && rest[1]) {
+            const key = rest[1];
+            const v = key === "apiKey" || key === "tinyfishApiKey" ? (0, config_1.maskKey)(String(cfg[key])) : cfg[key];
+            console.log(typeof v === "object" ? JSON.stringify(v, null, 2) : String(v));
+            return;
+        }
+        console.log(util_1.ansi.bold("config") + util_1.ansi.gray(`  (${(0, config_1.configPath)()})`));
+        for (const k of config_1.SETTABLE_KEYS) {
+            let v = cfg[k];
+            if (k === "apiKey" || k === "tinyfishApiKey")
+                v = v ? (0, config_1.maskKey)(String(v)) : util_1.ansi.red("(not set)");
+            console.log(`  ${k.padEnd(18)} ${util_1.ansi.gray(String(v))}`);
+        }
+        return;
+    }
+    if (sub === "set") {
+        const key = rest[1];
+        const value = rest.slice(2).join(" ");
+        if (!key || value === "")
+            throw new Error("usage: swarm config set <key> <value>");
+        if (!config_1.SETTABLE_KEYS.includes(key)) {
+            throw new Error(`unknown/settable keys: ${config_1.SETTABLE_KEYS.join(", ")}`);
+        }
+        const coerced = (0, config_1.coerceConfigValue)(key, value);
+        if (key === "apiKey") {
+            const k = String(coerced);
+            if (k.includes("...") || k.includes("…") || k.length < 20) {
+                throw new Error(`that doesn't look like a real API key (got ${k.length} chars). ` +
+                    `Paste the full key from your provider's console.`);
+            }
+        }
+        (0, config_1.saveConfig)({ [key]: coerced });
+        console.log(util_1.ansi.green("✓ ") + `set ${key}`);
+        if (key === "apiKey")
+            console.log(util_1.ansi.gray("  verify it works: ") + "swarm models");
+        return;
+    }
+    if (sub === "path") {
+        console.log((0, config_1.configPath)());
+        return;
+    }
+    throw new Error("usage: swarm config [list|get <key>|set <key> <value>|path]");
+}
+async function cmdModels() {
+    const cfg = (0, config_1.loadConfig)();
+    if (!cfg.apiKey) {
+        console.log(util_1.ansi.gray("known (priced) models:"));
+        for (const m of Object.keys(cfg.pricing))
+            console.log("  " + m);
+        console.log(util_1.ansi.gray("\nset an API key to list live models: swarm config set apiKey <sk-...>"));
+        return;
+    }
+    try {
+        const models = await (0, deepseek_1.listModels)(cfg);
+        console.log(util_1.ansi.bold("available models"));
+        for (const m of models) {
+            const priced = cfg.pricing[m] ? util_1.ansi.green(" priced") : "";
+            console.log("  " + m + priced);
+        }
+    }
+    catch (e) {
+        console.error(util_1.ansi.red("could not list models: ") + (0, util_1.errMsg)(e));
+    }
+}
+// ---------------------------------------------------------------- demo
+async function cmdDemo(flags) {
+    const cfg = (0, config_1.loadConfig)();
+    if (!cfg.apiKey && providers_1.PROVIDERS[cfg.provider].keyRequired) {
+        console.error(util_1.ansi.red("Demo needs an API key for the active provider. ") + "Run: swarm config set apiKey <...>");
+        process.exit(1);
+    }
+    const mission = typeof flags.mission === "string"
+        ? flags.mission
+        : "Research the current state of open-weight agent-swarm systems (Kimi K2.6, others), then produce a concise comparison report with a recommendation for a developer wanting long-horizon autonomy on a budget. Save the report as comparison.md.";
+    const meta = (0, run_1.createRun)({
+        mission,
+        cwd: process.cwd(),
+        sandbox: true,
+        options: (0, run_1.optionsFromConfig)(cfg, { maxWorkers: 4, maxTasks: 12, ...optionOverrides(flags, cfg) }),
+    });
+    console.log(util_1.ansi.cyan("running demo mission in an isolated workspace…\n"));
+    await execForeground(cfg, meta, true);
+}
+// ---------------------------------------------------------------- shared
+function resolveId(idOrPrefix) {
+    if ((0, run_1.loadMeta)(idOrPrefix))
+        return idOrPrefix;
+    // allow short prefixes
+    try {
+        const dir = path.join((0, config_1.runDir)(idOrPrefix), "..");
+        const ids = fs.readdirSync(dir).filter((d) => d.startsWith(idOrPrefix));
+        if (ids.length === 1)
+            return ids[0];
+    }
+    catch {
+        /* ignore */
+    }
+    return idOrPrefix;
+}
+function printFinalLine(id) {
+    const meta = (0, run_1.loadMeta)(id);
+    if (!meta)
+        return;
+    const reportFile = path.join((0, config_1.runDir)(id), "artifacts", "final-report.md");
+    console.log("");
+    if (fs.existsSync(reportFile)) {
+        console.log(util_1.ansi.green("✓ final report: ") + reportFile);
+        console.log(util_1.ansi.gray("  view: ") + `swarm report ${id}`);
+    }
+    else {
+        console.log(util_1.ansi.gray(`run ${id} ended without a final report (see: swarm watch ${id})`));
+    }
+}
+function clipLine(s, n) {
+    const t = s.replace(/\s+/g, " ").trim();
+    return util_1.ansi.gray(t.length > n ? t.slice(0, n - 1) + "…" : t);
+}
+function printHelp() {
+    const b = util_1.ansi.bold;
+    console.log(`${b("agentswarm")} — a local agent swarm for long-horizon work (DeepSeek, OpenAI, Anthropic, Grok, MiniMax, OpenRouter, Ollama, LM Studio)
+
+${b("USAGE")}
+  swarm run "<mission>" [options]     decompose & execute a mission with a parallel swarm
+  swarm serve [--port 7777] [--open]  start the mission-control web UI + API
+  swarm watch <id>                    attach a live dashboard to a run
+  swarm resume <id> [--fg]            resume an interrupted run (done tasks keep their results)
+  swarm ls                            list runs
+  swarm report <id> [--open]          print (or open) a run's final report
+  swarm note <id> "<text>"            steer a live run (the conductor reads it)
+  swarm cancel <id>                   stop a run gracefully (still synthesizes)
+  swarm config [list|get|set ...]     manage config (~/.agentswarm/config.json)
+  swarm sandbox [test|<runtime>]      show / smoke-test the shell runtime (host, docker, e2b, modal, vercel)
+  swarm models                        list models from the active provider
+  swarm demo                          run a self-contained demo mission
+
+${b("RUN OPTIONS")}
+  --workers N        max parallel agents (default ${(0, config_1.loadConfig)().maxWorkers})
+  --steps N          max tool steps per task (default ${(0, config_1.loadConfig)().maxStepsPerTask})
+  --tasks N          max total tasks (default ${(0, config_1.loadConfig)().maxTasks})
+  --budget N         token budget for the whole run (default ${(0, util_1.fmtTokens)((0, config_1.loadConfig)().maxTokensPerRun)})
+  --model X          worker model (default ${(0, config_1.loadConfig)().model})
+  --conductor X      conductor model (default ${(0, config_1.loadConfig)().conductorModel})
+  --verify off|normal|strict   adversarial verification (default ${(0, config_1.loadConfig)().verification})
+  --effort low|medium|high|max  reasoning effort (default ${(0, config_1.loadConfig)().reasoningEffort})
+  --no-thinking      disable thinking mode
+  --no-safe          disable command/path safety guards (careful)
+  --sandbox X        shell runtime for this run: host | docker | e2b | modal | vercel | auto
+                     (default ${(0, config_1.loadConfig)().sandboxRuntime}; host = isolated workspace, no install needed)
+  --cwd <path>       run against a real directory (default: isolated workspace)
+  --fg               run in the foreground in this process (Ctrl-C cancels)
+
+${b("FIRST RUN")}
+  swarm config set apiKey <key>             # key for the active provider (default: DeepSeek)
+  swarm config set provider <id>            # deepseek | openai | anthropic | xai | minimax | openrouter | ollama | lmstudio | custom
+  pip install searchkit                     # optional: local, citable web search for agents
+  swarm serve --open                        # open the web UI
+`);
+}