@robzilla1738/agentswarm 0.2.0

package/dist/hub.js

@@ -0,0 +1,553 @@
+"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.startHub = startHub;
+const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const config_1 = require("./config");
+const control_1 = require("./control");
+const deepseek_1 = require("./deepseek");
+const providers_1 = require("./providers");
+const journal_1 = require("./journal");
+const run_1 = require("./run");
+const sandbox_1 = require("./sandbox");
+const util_1 = require("./util");
+const PKG_VERSION = (() => {
+    try {
+        // dist/hub.js → ../package.json; npm always ships package.json.
+        return String(require("../package.json").version || "0.0.0");
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".ico": "image/x-icon",
+    ".woff2": "font/woff2",
+    ".txt": "text/plain; charset=utf-8",
+    ".md": "text/markdown; charset=utf-8",
+};
+function startHub(opts) {
+    const server = http.createServer((req, res) => {
+        handle(req, res, opts).catch((e) => {
+            sendJson(res, 500, { error: (0, util_1.errMsg)(e) });
+        });
+    });
+    server.listen(opts.port, "127.0.0.1");
+    return server;
+}
+async function handle(req, res, opts) {
+    const url = new url_1.URL(req.url || "/", `http://localhost:${opts.port}`);
+    const p = url.pathname;
+    res.setHeader("access-control-allow-origin", "*");
+    res.setHeader("access-control-allow-methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("access-control-allow-headers", "content-type");
+    if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    if (p.startsWith("/api/")) {
+        await api(req, res, url, opts);
+        return;
+    }
+    serveStatic(req, res, p, opts.uiDir);
+}
+// ---------------------------------------------------------------- api
+async function api(req, res, url, opts) {
+    const cfg = (0, config_1.loadConfig)();
+    const p = url.pathname;
+    const method = req.method || "GET";
+    if (p === "/api/health")
+        return sendJson(res, 200, { ok: true, version: PKG_VERSION, apiKey: Boolean(cfg.apiKey) });
+    if (p === "/api/config" && method === "GET")
+        return sendJson(res, 200, publicConfig(cfg));
+    if (p === "/api/config" && method === "POST") {
+        const body = await readBody(req);
+        const patch = {};
+        const errors = [];
+        for (const [k, v] of Object.entries(body)) {
+            if (k === "providers")
+                continue; // handled below
+            if (!config_1.SETTABLE_KEYS.includes(k))
+                continue;
+            try {
+                patch[k] = (0, config_1.coerceConfigValue)(k, v);
+            }
+            catch (e) {
+                errors.push((0, util_1.errMsg)(e));
+            }
+        }
+        // Per-provider credentials: { providers: { openai: { apiKey, baseUrl } } }
+        if (body.providers && typeof body.providers === "object") {
+            const creds = {};
+            for (const [id, cred] of Object.entries(body.providers)) {
+                if (!(0, providers_1.isProviderId)(id)) {
+                    errors.push(`unknown provider: ${id}`);
+                    continue;
+                }
+                if (!cred || typeof cred !== "object")
+                    continue;
+                const c = {};
+                if (typeof cred.apiKey === "string")
+                    c.apiKey = cred.apiKey.trim();
+                if (typeof cred.baseUrl === "string")
+                    c.baseUrl = cred.baseUrl.trim();
+                creds[id] = c;
+            }
+            patch.providers = creds;
+        }
+        // All-or-nothing: a typo in one field must not half-apply the form.
+        if (errors.length)
+            return sendJson(res, 400, { error: errors.join("; ") });
+        const next = (0, config_1.saveConfig)(patch);
+        return sendJson(res, 200, publicConfig(next));
+    }
+    if (p === "/api/validate" && method === "GET") {
+        const r = await (0, deepseek_1.validateAuth)(cfg);
+        return sendJson(res, 200, r);
+    }
+    if (p === "/api/sandbox/test" && method === "POST") {
+        const body = await readBody(req);
+        const kind = sandbox_1.SANDBOX_KINDS.includes(body.runtime)
+            ? body.runtime
+            : (0, sandbox_1.resolveSandboxKind)(cfg);
+        const r = await (0, sandbox_1.testSandbox)(cfg, kind);
+        return sendJson(res, 200, { kind, ...r });
+    }
+    if (p === "/api/models" && method === "GET") {
+        try {
+            const models = await (0, deepseek_1.listModels)(cfg);
+            return sendJson(res, 200, { models });
+        }
+        catch (e) {
+            return sendJson(res, 200, { models: Object.keys(cfg.pricing), error: (0, util_1.errMsg)(e) });
+        }
+    }
+    if (p === "/api/runs" && method === "GET") {
+        return sendJson(res, 200, { runs: (0, run_1.listRuns)(cfg.pricing) });
+    }
+    if (p === "/api/runs" && method === "POST") {
+        const body = await readBody(req);
+        if (!body.mission || typeof body.mission !== "string") {
+            return sendJson(res, 400, { error: "mission is required" });
+        }
+        const provider = providers_1.PROVIDERS[cfg.provider];
+        if (!cfg.apiKey && provider.keyRequired) {
+            return sendJson(res, 400, { error: `No ${provider.label} API key configured. Set it in Settings first.` });
+        }
+        const auth = await (0, deepseek_1.validateAuth)(cfg);
+        if (auth.status === "invalid") {
+            return sendJson(res, 400, {
+                error: `${provider.label} key rejected: ${auth.message || "invalid"}. Open Settings and paste a valid key.`,
+            });
+        }
+        const overrides = sanitizeOptions(body.options);
+        const sandbox = body.sandbox !== false; // default to sandbox for UI-created runs
+        const cwd = sandbox ? process.cwd() : String(body.cwd || process.cwd());
+        if (!sandbox) {
+            if (!path.isAbsolute(cwd)) {
+                return sendJson(res, 400, { error: "cwd must be an absolute path" });
+            }
+            if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
+                return sendJson(res, 400, { error: `directory not found: ${cwd}` });
+            }
+        }
+        const meta = (0, run_1.createRun)({
+            mission: body.mission.trim(),
+            cwd,
+            sandbox,
+            options: (0, run_1.optionsFromConfig)(cfg, overrides),
+        });
+        (0, run_1.launchDetached)(meta.id, opts.binPath);
+        return sendJson(res, 200, { id: meta.id });
+    }
+    const m = p.match(/^\/api\/runs\/([^/]+)(\/.*)?$/);
+    if (m) {
+        const id = m[1];
+        const sub = m[2] || "";
+        const meta = (0, run_1.loadMeta)(id);
+        if (!meta)
+            return sendJson(res, 404, { error: "run not found" });
+        if (sub === "" && method === "GET") {
+            const state = (0, run_1.loadRunState)(id, cfg.pricing);
+            if (!state)
+                return sendJson(res, 404, { error: "run not found" });
+            return sendJson(res, 200, snapshot(state, id));
+        }
+        if (sub === "" && method === "DELETE") {
+            try {
+                (0, run_1.deleteRun)(id);
+            }
+            catch (e) {
+                return sendJson(res, 409, { error: (0, util_1.errMsg)(e) });
+            }
+            return sendJson(res, 200, { ok: true });
+        }
+        if (sub === "/events" && method === "GET") {
+            const since = Number(url.searchParams.get("since") || "0");
+            const events = (0, journal_1.readEvents)((0, config_1.runDir)(id)).filter((e) => e.seq > since);
+            return sendJson(res, 200, { events, live: (0, run_1.isRunLive)(id) });
+        }
+        if (sub === "/stream" && method === "GET") {
+            return streamEvents(res, id);
+        }
+        if (sub === "/note" && method === "POST") {
+            const body = await readBody(req);
+            if (!body.text)
+                return sendJson(res, 400, { error: "text required" });
+            (0, control_1.appendControl)((0, config_1.runDir)(id), { kind: "note", text: String(body.text) });
+            return sendJson(res, 200, { ok: true });
+        }
+        if (sub === "/cancel" && method === "POST") {
+            (0, control_1.appendControl)((0, config_1.runDir)(id), { kind: "cancel" });
+            // Belt and braces: SIGINT the engine so the abort lands instantly even
+            // mid-API-call. The engine's handler cancels gracefully (still
+            // synthesizes a report from completed work).
+            const pid = (0, run_1.readPid)(id);
+            if (pid) {
+                try {
+                    process.kill(pid, "SIGINT");
+                }
+                catch {
+                    /* already gone — the control line covers it */
+                }
+            }
+            return sendJson(res, 200, { ok: true });
+        }
+        if (sub === "/resume" && method === "POST") {
+            const info = (0, run_1.resumeInfo)(id);
+            if (!info.resumable)
+                return sendJson(res, 409, { error: info.reason || "not resumable" });
+            (0, run_1.launchDetached)(id, opts.binPath, true);
+            return sendJson(res, 200, { ok: true });
+        }
+        if (sub === "/report" && method === "GET") {
+            const file = path.join((0, config_1.runDir)(id), "artifacts", "final-report.md");
+            if (!fs.existsSync(file))
+                return sendJson(res, 404, { error: "no report yet" });
+            res.writeHead(200, { "content-type": "text/markdown; charset=utf-8" });
+            res.end(fs.readFileSync(file));
+            return;
+        }
+        if (sub === "/artifacts" && method === "GET") {
+            return sendJson(res, 200, { artifacts: listArtifactFiles(id) });
+        }
+        const art = sub.match(/^\/artifacts\/(.+)$/);
+        if (art && method === "GET") {
+            const rel = decodeURIComponent(art[1]);
+            const base = path.join((0, config_1.runDir)(id), "artifacts");
+            const file = path.join(base, rel);
+            // pathInside (not startsWith): "artifacts-evil" passes a prefix check.
+            if (!(0, util_1.pathInside)(base, file) || !fs.existsSync(file) || fs.statSync(file).isDirectory()) {
+                return sendJson(res, 404, { error: "not found" });
+            }
+            res.writeHead(200, {
+                "content-type": MIME[path.extname(file)] || "application/octet-stream",
+            });
+            fs.createReadStream(file).pipe(res);
+            return;
+        }
+    }
+    sendJson(res, 404, { error: "not found" });
+}
+function streamEvents(res, id) {
+    res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+        "x-accel-buffering": "no",
+    });
+    res.write(": connected\n\n");
+    const file = (0, journal_1.eventsFile)((0, config_1.runDir)(id));
+    const state = { offset: 0, carry: "" };
+    const flush = () => {
+        let evs;
+        try {
+            evs = (0, journal_1.readNewEvents)(file, state);
+        }
+        catch {
+            return;
+        }
+        for (const ev of evs) {
+            res.write(`data: ${JSON.stringify(ev)}\n\n`);
+        }
+    };
+    // Liveness side-channel: lets the UI distinguish "quiet but alive" from
+    // "engine process died without a terminal status".
+    const sendLive = () => {
+        res.write(`event: live\ndata: ${JSON.stringify({ live: (0, run_1.isRunLive)(id) })}\n\n`);
+    };
+    // Initial backlog + then poll. (fs.watch is unreliable on some platforms;
+    // a 400ms poll over an append-only file is cheap and robust.)
+    flush();
+    sendLive();
+    const poll = setInterval(flush, 400);
+    const ping = setInterval(() => res.write(": ping\n\n"), 15000);
+    const liveTimer = setInterval(sendLive, 3000);
+    const stop = () => {
+        clearInterval(poll);
+        clearInterval(ping);
+        clearInterval(liveTimer);
+    };
+    res.on("close", stop);
+    res.on("error", stop);
+}
+// ---------------------------------------------------------------- helpers
+function publicConfig(cfg) {
+    const active = providers_1.PROVIDERS[cfg.provider];
+    // Active provider's suggestions first, then anything else with pricing.
+    const knownModels = [
+        ...active.knownModels,
+        ...Object.keys(cfg.pricing).filter((m) => !active.knownModels.includes(m)),
+    ];
+    return {
+        provider: cfg.provider,
+        providers: providers_1.PROVIDER_IDS.map((id) => {
+            const info = providers_1.PROVIDERS[id];
+            const cred = cfg.providers[id] || {};
+            const key = id === cfg.provider ? cfg.apiKey : cred.apiKey || "";
+            return {
+                id,
+                label: info.label,
+                keyRequired: info.keyRequired,
+                keyUrl: info.keyUrl,
+                local: Boolean(info.local),
+                note: info.note,
+                keySet: Boolean(key),
+                keyMasked: (0, config_1.maskKey)(key),
+                baseUrl: cred.baseUrl || info.baseUrl,
+                defaultBaseUrl: info.baseUrl,
+                defaultModel: info.defaultModel,
+                knownModels: info.knownModels,
+            };
+        }),
+        apiKeySet: Boolean(cfg.apiKey) || !active.keyRequired,
+        apiKeyMasked: (0, config_1.maskKey)(cfg.apiKey),
+        tinyfishKeySet: Boolean(cfg.tinyfishApiKey),
+        tinyfishKeyMasked: (0, config_1.maskKey)(cfg.tinyfishApiKey),
+        searchBackend: cfg.searchBackend,
+        searchkitCmd: cfg.searchkitCmd,
+        sandboxRuntime: cfg.sandboxRuntime,
+        sandboxResolved: (0, sandbox_1.resolveSandboxKind)(cfg),
+        sandboxImage: cfg.sandboxImage,
+        dockerUp: (0, sandbox_1.dockerAvailable)(),
+        e2bKeySet: Boolean(cfg.e2bApiKey),
+        e2bKeyMasked: (0, config_1.maskKey)(cfg.e2bApiKey),
+        e2bTemplate: cfg.e2bTemplate,
+        modalConfigured: Boolean(cfg.modalTokenId && cfg.modalTokenSecret),
+        vercelConfigured: Boolean(cfg.vercelToken),
+        vercelTeamId: cfg.vercelTeamId,
+        vercelProjectId: cfg.vercelProjectId,
+        baseUrl: cfg.baseUrl,
+        model: cfg.model,
+        conductorModel: cfg.conductorModel,
+        maxWorkers: cfg.maxWorkers,
+        maxStepsPerTask: cfg.maxStepsPerTask,
+        maxTasks: cfg.maxTasks,
+        maxTokensPerRun: cfg.maxTokensPerRun,
+        verification: cfg.verification,
+        thinking: cfg.thinking,
+        reasoningEffort: cfg.reasoningEffort,
+        safeMode: cfg.safeMode,
+        contextTokenLimit: cfg.contextTokenLimit,
+        knownModels,
+        pricing: cfg.pricing,
+    };
+}
+function sanitizeOptions(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const o = raw;
+    const out = {};
+    const num = (k, lo, hi) => {
+        const v = Number(o[k]);
+        if (Number.isFinite(v))
+            out[k] = Math.min(hi, Math.max(lo, Math.round(v)));
+    };
+    if (typeof o.model === "string" && o.model.trim())
+        out.model = o.model.trim();
+    if (typeof o.conductorModel === "string" && o.conductorModel.trim())
+        out.conductorModel = o.conductorModel.trim();
+    num("maxWorkers", 1, 32);
+    num("maxStepsPerTask", 3, 200);
+    num("maxTasks", 1, 1000);
+    num("maxTokens", 50_000, 2_000_000_000);
+    if (o.verification === "off" || o.verification === "normal" || o.verification === "strict") {
+        out.verification = o.verification;
+    }
+    if (typeof o.thinking === "boolean")
+        out.thinking = o.thinking;
+    if (o.reasoningEffort === "low" || o.reasoningEffort === "medium" || o.reasoningEffort === "high" || o.reasoningEffort === "max") {
+        out.reasoningEffort = o.reasoningEffort;
+    }
+    if (typeof o.safeMode === "boolean")
+        out.safeMode = o.safeMode;
+    if (sandbox_1.SANDBOX_KINDS.includes(o.sandboxRuntime)) {
+        out.sandboxRuntime = o.sandboxRuntime;
+    }
+    return out;
+}
+function snapshot(state, id) {
+    if (!state)
+        return { error: "not found" };
+    return {
+        id,
+        meta: state.meta,
+        status: state.status,
+        statusReason: state.statusReason,
+        summary: state.summary(),
+        tasks: state.taskList(),
+        agents: [...state.agents.values()],
+        notes: state.notes,
+        conductorLog: state.conductorLog,
+        operatorNotes: state.operatorNotes,
+        usageByModel: Object.fromEntries(state.usageByModel),
+        cost: state.cost,
+        finalSummary: state.finalSummary,
+        finalReportPath: state.finalReportPath,
+        live: (0, run_1.isRunLive)(id),
+        lastSeq: state.lastSeq,
+    };
+}
+function listArtifactFiles(id) {
+    const base = path.join((0, config_1.runDir)(id), "artifacts");
+    const out = [];
+    const walk = (d, prefix) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.isDirectory())
+                walk(path.join(d, e.name), prefix + e.name + "/");
+            else {
+                let size = 0;
+                try {
+                    size = fs.statSync(path.join(d, e.name)).size;
+                }
+                catch { /* race */ }
+                out.push({ name: prefix + e.name, size });
+            }
+        }
+    };
+    walk(base, "");
+    return out;
+}
+function serveStatic(req, res, p, uiDir) {
+    if (!uiDir || !fs.existsSync(uiDir)) {
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end(fallbackPage());
+        return;
+    }
+    let rel = decodeURIComponent(p.replace(/^\/+/, ""));
+    if (rel === "")
+        rel = "index.html";
+    let file = path.join(uiDir, rel);
+    if (!(0, util_1.pathInside)(uiDir, file)) {
+        res.writeHead(403);
+        res.end("forbidden");
+        return;
+    }
+    // SPA / static-export fallbacks.
+    if (!fs.existsSync(file) || fs.statSync(file).isDirectory()) {
+        const htmlCandidate = file.replace(/\/$/, "") + ".html";
+        if (fs.existsSync(htmlCandidate))
+            file = htmlCandidate;
+        else if (fs.existsSync(path.join(file, "index.html")))
+            file = path.join(file, "index.html");
+        else
+            file = path.join(uiDir, "index.html");
+    }
+    if (!fs.existsSync(file)) {
+        res.writeHead(404);
+        res.end("not found");
+        return;
+    }
+    res.writeHead(200, { "content-type": MIME[path.extname(file)] || "application/octet-stream" });
+    fs.createReadStream(file).pipe(res);
+}
+function fallbackPage() {
+    return `<!doctype html><html><head><meta charset="utf-8"><title>agentswarm hub</title>
+<style>body{background:#050505;color:#f2f2f2;font:15px/1.6 -apple-system,system-ui,sans-serif;max-width:680px;margin:8vh auto;padding:0 24px}code{background:#161616;border:1px solid #262626;padding:2px 7px;border-radius:5px;color:#e5e5e5;font-family:ui-monospace,monospace}a{color:#fff}p{color:#a1a1a1}</style>
+</head><body>
+<h1>agentswarm hub is running</h1>
+<p>The API is live, but the web UI hasn't been built yet.</p>
+<p>Build it once (from the repo root):</p>
+<p><code>npm run setup</code></p>
+<p>…then restart <code>swarm serve</code> and reload this page. (Engine already built? <code>npm run build:ui</code> is enough.) Or run the UI in dev mode against this hub:</p>
+<p><code>npm run dev:ui</code> → open <a href="http://localhost:7780">http://localhost:7780</a></p>
+<p>The REST API is available under <code>/api/*</code>.</p>
+</body></html>`;
+}
+// ---------------------------------------------------------------- io
+function sendJson(res, status, body) {
+    const s = JSON.stringify(body);
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    res.end(s);
+}
+function readBody(req) {
+    return new Promise((resolve) => {
+        let data = "";
+        req.on("data", (c) => {
+            data += c;
+            if (data.length > 20_000_000)
+                req.destroy();
+        });
+        req.on("end", () => {
+            if (!data.trim())
+                return resolve({});
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch {
+                resolve({});
+            }
+        });
+        req.on("error", () => resolve({}));
+    });
+}