@robzilla1738/agentswarm 0.2.0

package/dist/run.js

@@ -0,0 +1,309 @@
+"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.optionsFromConfig = optionsFromConfig;
+exports.createRun = createRun;
+exports.metaPath = metaPath;
+exports.loadMeta = loadMeta;
+exports.executeRun = executeRun;
+exports.listRuns = listRuns;
+exports.deleteRun = deleteRun;
+exports.resumeInfo = resumeInfo;
+exports.launchDetached = launchDetached;
+exports.loadRunState = loadRunState;
+exports.pidPath = pidPath;
+exports.writePid = writePid;
+exports.clearPid = clearPid;
+exports.readPid = readPid;
+exports.isRunLive = isRunLive;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const executor_1 = require("./executor");
+const journal_1 = require("./journal");
+const sandbox_1 = require("./sandbox");
+const state_1 = require("./state");
+const util_1 = require("./util");
+function optionsFromConfig(cfg, overrides = {}) {
+    return {
+        model: cfg.model,
+        conductorModel: cfg.conductorModel,
+        maxWorkers: cfg.maxWorkers,
+        maxStepsPerTask: cfg.maxStepsPerTask,
+        maxTasks: cfg.maxTasks,
+        maxTokens: cfg.maxTokensPerRun,
+        verification: cfg.verification,
+        thinking: cfg.thinking,
+        reasoningEffort: cfg.reasoningEffort,
+        safeMode: cfg.safeMode,
+        // Resolved at launch so the run is reproducible across resume even if
+        // the operator later changes the default.
+        sandboxRuntime: (0, sandbox_1.resolveSandboxKind)(cfg),
+        ...overrides,
+    };
+}
+function createRun(input) {
+    const id = (0, util_1.rid)("run");
+    const dir = (0, config_1.runDir)(id);
+    let cwd = path.resolve(input.cwd);
+    if (input.sandbox) {
+        // Isolated working directory inside the run folder.
+        cwd = path.join(dir, "workspace");
+        (0, util_1.ensureDir)(cwd);
+    }
+    const meta = {
+        id,
+        mission: input.mission,
+        createdAt: Date.now(),
+        cwd,
+        sandbox: input.sandbox,
+        options: input.options,
+    };
+    (0, util_1.ensureDir)(dir);
+    (0, util_1.ensureDir)(path.join(dir, "artifacts"));
+    (0, util_1.writeJson)(path.join(dir, "meta.json"), meta);
+    return meta;
+}
+function metaPath(id) {
+    return path.join((0, config_1.runDir)(id), "meta.json");
+}
+function loadMeta(id) {
+    try {
+        return JSON.parse(fs.readFileSync(metaPath(id), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Execute a run to completion in this process. */
+async function executeRun(cfg, meta, journal) {
+    const ex = new executor_1.Executor(cfg, meta, journal);
+    await ex.run();
+    return ex;
+}
+/**
+ * Re-reducing every journal on every dashboard poll gets expensive once runs
+ * accumulate; summaries are pure functions of the journal file, so cache them
+ * keyed on (size, mtime).
+ */
+const summaryCache = new Map();
+/**
+ * Live runs additionally tail their journal incrementally: a multi-hour run's
+ * growing events.jsonl costs O(new bytes) per poll instead of a full re-parse.
+ */
+const liveCache = new Map();
+const TERMINAL_STATUSES = ["done", "failed", "cancelled"];
+/** Grace before a silent, pid-less run is presumed dead (engine startup, fs lag). */
+const STALE_AFTER_MS = 20_000;
+/**
+ * A run whose engine process vanished without writing a terminal status
+ * (kill -9, reboot) would otherwise show "running" forever. Presentation-level
+ * only — the journal stays untouched.
+ */
+function applyLiveness(s) {
+    if (s.pid || TERMINAL_STATUSES.includes(s.status))
+        return s;
+    const lastBeat = s.heartbeatAt || s.updatedAt || s.createdAt;
+    if (Date.now() - lastBeat > STALE_AFTER_MS) {
+        s.status = "failed";
+        s.statusReason = "interrupted — the engine process is no longer running";
+    }
+    return s;
+}
+function listRuns(pricing) {
+    let ids;
+    try {
+        ids = fs.readdirSync((0, config_1.runsDir)()).filter((d) => d.startsWith("run_"));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const id of ids) {
+        const meta = loadMeta(id);
+        if (!meta)
+            continue;
+        let stat = null;
+        try {
+            stat = fs.statSync((0, journal_1.eventsFile)((0, config_1.runDir)(id)));
+        }
+        catch {
+            /* no events yet */
+        }
+        const cached = summaryCache.get(id);
+        let pure;
+        if (cached && stat && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
+            pure = cached.summary;
+        }
+        else {
+            let live = liveCache.get(id);
+            if (!live) {
+                live = { state: new state_1.RunState(pricing), tail: { offset: 0, carry: "" } };
+                liveCache.set(id, live);
+            }
+            for (const ev of (0, journal_1.readNewEvents)((0, journal_1.eventsFile)((0, config_1.runDir)(id)), live.tail))
+                live.state.apply(ev);
+            if (!live.state.meta)
+                live.state.meta = meta;
+            pure = live.state.summary();
+            pure.id = id;
+            pure.mission = meta.mission;
+            pure.model = meta.options.model;
+            pure.createdAt = meta.createdAt;
+            if (stat)
+                summaryCache.set(id, { size: stat.size, mtimeMs: stat.mtimeMs, summary: pure });
+            // Terminal runs never change again — the frozen summary suffices.
+            if (TERMINAL_STATUSES.includes(pure.status))
+                liveCache.delete(id);
+        }
+        const s = { ...pure, tasks: { ...pure.tasks } };
+        s.pid = readPid(id);
+        out.push(applyLiveness(s));
+    }
+    out.sort((a, b) => b.createdAt - a.createdAt);
+    return out;
+}
+/** Permanently remove a run's directory (journal, artifacts, workspace). */
+function deleteRun(id) {
+    if (isRunLive(id))
+        throw new Error("run is live — stop it before deleting");
+    // A just-launched engine takes a moment to write its pid file; deleting in
+    // that window would yank the directory out from under it. Refuse while the
+    // run is non-terminal and fresh enough that the engine may still appear.
+    const evs = (0, journal_1.readEvents)((0, config_1.runDir)(id));
+    const lastStatus = [...evs].reverse().find((e) => e.type === "run.status");
+    const status = String(lastStatus?.status ?? "planning");
+    if (!TERMINAL_STATUSES.includes(status)) {
+        const lastT = evs.length ? evs[evs.length - 1].t : loadMeta(id)?.createdAt ?? 0;
+        if (Date.now() - lastT <= STALE_AFTER_MS) {
+            throw new Error("run is still starting — stop it or wait a moment");
+        }
+    }
+    fs.rmSync((0, config_1.runDir)(id), { recursive: true, force: true });
+    summaryCache.delete(id);
+    liveCache.delete(id);
+}
+/**
+ * Whether an interrupted run can be resumed: it must exist, not be live, and
+ * its journal must not have reached a terminal status. (A run the liveness
+ * layer *presents* as failed/interrupted still has a non-terminal journal.)
+ */
+function resumeInfo(id) {
+    const meta = loadMeta(id);
+    if (!meta)
+        return { resumable: false, reason: "run not found" };
+    if (isRunLive(id))
+        return { resumable: false, reason: "run is already running" };
+    const evs = (0, journal_1.readEvents)((0, config_1.runDir)(id));
+    if (!evs.length)
+        return { resumable: false, reason: "run never started — launch it instead" };
+    const last = [...evs].reverse().find((e) => e.type === "run.status");
+    const status = String(last?.status ?? "planning");
+    if (TERMINAL_STATUSES.includes(status)) {
+        return { resumable: false, reason: `run already ended (${status})` };
+    }
+    return { resumable: true };
+}
+/** Spawn the engine for a run as a detached background process. */
+function launchDetached(id, binPath, resume = false) {
+    let out = "ignore";
+    try {
+        out = fs.openSync(path.join((0, config_1.runDir)(id), "exec.log"), "a");
+    }
+    catch {
+        /* log is best-effort */
+    }
+    const child = (0, child_process_1.spawn)(process.execPath, [binPath, "_exec", id, ...(resume ? ["--resume"] : [])], {
+        detached: true,
+        stdio: ["ignore", out, out],
+        env: process.env,
+    });
+    child.unref();
+    if (typeof out === "number") {
+        try {
+            fs.closeSync(out);
+        }
+        catch {
+            /* child holds its own descriptor */
+        }
+    }
+}
+function loadRunState(id, pricing) {
+    const meta = loadMeta(id);
+    if (!meta)
+        return null;
+    const state = new state_1.RunState(pricing);
+    for (const ev of (0, journal_1.readEvents)((0, config_1.runDir)(id)))
+        state.apply(ev);
+    if (!state.meta)
+        state.meta = meta;
+    return state;
+}
+// ---------- pid tracking (for the hub to know what's live) ----------
+function pidPath(id) {
+    return path.join((0, config_1.runDir)(id), "run.pid");
+}
+function writePid(id) {
+    try {
+        fs.writeFileSync(pidPath(id), String(process.pid), "utf8");
+    }
+    catch {
+        /* best effort */
+    }
+}
+function clearPid(id) {
+    try {
+        fs.unlinkSync(pidPath(id));
+    }
+    catch {
+        /* gone */
+    }
+}
+function readPid(id) {
+    try {
+        const pid = Number(fs.readFileSync(pidPath(id), "utf8").trim());
+        if (!pid)
+            return null;
+        process.kill(pid, 0); // throws if not alive
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+function isRunLive(id) {
+    return readPid(id) !== null;
+}