@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/process/supervisor/adapters/child.js

@@ -0,0 +1,143 @@
+import { killProcessTree } from "../../kill-tree.js";
+import { spawnWithFallback } from "../../spawn-utils.js";
+import { toStringEnv } from "./env.js";
+function resolveCommand(command) {
+    if (process.platform !== "win32") {
+        return command;
+    }
+    const lower = command.toLowerCase();
+    if (lower.endsWith(".exe") || lower.endsWith(".cmd") || lower.endsWith(".bat")) {
+        return command;
+    }
+    const basename = lower.split(/[\\/]/).pop() ?? lower;
+    if (basename === "npm" || basename === "pnpm" || basename === "yarn" || basename === "npx") {
+        return `${command}.cmd`;
+    }
+    return command;
+}
+export async function createChildAdapter(params) {
+    const resolvedArgv = [...params.argv];
+    resolvedArgv[0] = resolveCommand(resolvedArgv[0] ?? "");
+    const stdinMode = params.stdinMode ?? (params.input !== undefined ? "pipe-closed" : "inherit");
+    // On Windows, `detached: true` creates a new process group and can prevent
+    // stdout/stderr pipes from connecting when running under a Scheduled Task
+    // (headless, no console). Default to `detached: false` on Windows; on
+    // POSIX systems keep `detached: true` so the child survives parent exit.
+    const useDetached = process.platform !== "win32";
+    const options = {
+        cwd: params.cwd,
+        env: params.env ? toStringEnv(params.env) : undefined,
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: useDetached,
+        windowsHide: true,
+        windowsVerbatimArguments: params.windowsVerbatimArguments,
+    };
+    if (stdinMode === "inherit") {
+        options.stdio = ["inherit", "pipe", "pipe"];
+    }
+    else {
+        options.stdio = ["pipe", "pipe", "pipe"];
+    }
+    const spawned = await spawnWithFallback({
+        argv: resolvedArgv,
+        options,
+        fallbacks: useDetached
+            ? [
+                {
+                    label: "no-detach",
+                    options: { detached: false },
+                },
+            ]
+            : [],
+    });
+    const child = spawned.child;
+    if (child.stdin) {
+        if (params.input !== undefined) {
+            child.stdin.write(params.input);
+            child.stdin.end();
+        }
+        else if (stdinMode === "pipe-closed") {
+            child.stdin.end();
+        }
+    }
+    const stdin = child.stdin
+        ? {
+            destroyed: false,
+            write: (data, cb) => {
+                try {
+                    child.stdin.write(data, cb);
+                }
+                catch (err) {
+                    cb?.(err);
+                }
+            },
+            end: () => {
+                try {
+                    child.stdin.end();
+                }
+                catch {
+                    // ignore close errors
+                }
+            },
+            destroy: () => {
+                try {
+                    child.stdin.destroy();
+                }
+                catch {
+                    // ignore destroy errors
+                }
+            },
+        }
+        : undefined;
+    const onStdout = (listener) => {
+        child.stdout.on("data", (chunk) => {
+            listener(chunk.toString());
+        });
+    };
+    const onStderr = (listener) => {
+        child.stderr.on("data", (chunk) => {
+            listener(chunk.toString());
+        });
+    };
+    const wait = async () => await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
+            resolve({ code, signal });
+        });
+    });
+    const kill = (signal) => {
+        const pid = child.pid ?? undefined;
+        if (signal === undefined || signal === "SIGKILL") {
+            if (pid) {
+                killProcessTree(pid);
+            }
+            else {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // ignore kill errors
+                }
+            }
+            return;
+        }
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // ignore kill errors for non-kill signals
+        }
+    };
+    const dispose = () => {
+        child.removeAllListeners();
+    };
+    return {
+        pid: child.pid ?? undefined,
+        stdin,
+        onStdout,
+        onStderr,
+        wait,
+        kill,
+        dispose,
+    };
+}

package/dist/process/supervisor/adapters/env.js

@@ -0,0 +1,13 @@
+export function toStringEnv(env) {
+    if (!env) {
+        return {};
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined) {
+            continue;
+        }
+        out[key] = String(value);
+    }
+    return out;
+}

package/dist/process/supervisor/adapters/pty.js

@@ -0,0 +1,148 @@
+import { killProcessTree } from "../../kill-tree.js";
+import { toStringEnv } from "./env.js";
+const FORCE_KILL_WAIT_FALLBACK_MS = 4000;
+export async function createPtyAdapter(params) {
+    const module = (await import("@lydell/node-pty"));
+    const spawn = module.spawn ?? module.default?.spawn;
+    if (!spawn) {
+        throw new Error("PTY support is unavailable (node-pty spawn not found).");
+    }
+    const pty = spawn(params.shell, params.args, {
+        cwd: params.cwd,
+        env: params.env ? toStringEnv(params.env) : undefined,
+        name: params.name ?? process.env.TERM ?? "xterm-256color",
+        cols: params.cols ?? 120,
+        rows: params.rows ?? 30,
+    });
+    let dataListener = null;
+    let exitListener = null;
+    let waitResult = null;
+    let resolveWait = null;
+    let waitPromise = null;
+    let forceKillWaitFallbackTimer = null;
+    const clearForceKillWaitFallback = () => {
+        if (!forceKillWaitFallbackTimer) {
+            return;
+        }
+        clearTimeout(forceKillWaitFallbackTimer);
+        forceKillWaitFallbackTimer = null;
+    };
+    const settleWait = (value) => {
+        if (waitResult) {
+            return;
+        }
+        clearForceKillWaitFallback();
+        waitResult = value;
+        if (resolveWait) {
+            const resolve = resolveWait;
+            resolveWait = null;
+            resolve(value);
+        }
+    };
+    const scheduleForceKillWaitFallback = (signal) => {
+        clearForceKillWaitFallback();
+        // Some PTY hosts fail to emit onExit after kill; use a delayed fallback
+        // so callers can still unblock without marking termination immediately.
+        forceKillWaitFallbackTimer = setTimeout(() => {
+            settleWait({ code: null, signal });
+        }, FORCE_KILL_WAIT_FALLBACK_MS);
+        forceKillWaitFallbackTimer.unref();
+    };
+    exitListener =
+        pty.onExit((event) => {
+            const signal = event.signal && event.signal !== 0 ? event.signal : null;
+            settleWait({ code: event.exitCode ?? null, signal });
+        }) ?? null;
+    const stdin = {
+        destroyed: false,
+        write: (data, cb) => {
+            try {
+                pty.write(data);
+                cb?.(null);
+            }
+            catch (err) {
+                cb?.(err);
+            }
+        },
+        end: () => {
+            try {
+                const eof = process.platform === "win32" ? "\x1a" : "\x04";
+                pty.write(eof);
+            }
+            catch {
+                // ignore EOF errors
+            }
+        },
+    };
+    const onStdout = (listener) => {
+        dataListener =
+            pty.onData((chunk) => {
+                listener(chunk.toString());
+            }) ?? null;
+    };
+    const onStderr = (_listener) => {
+        // PTY gives a unified output stream.
+    };
+    const wait = async () => {
+        if (waitResult) {
+            return waitResult;
+        }
+        if (!waitPromise) {
+            waitPromise = new Promise((resolve) => {
+                resolveWait = resolve;
+                if (waitResult) {
+                    const settled = waitResult;
+                    resolveWait = null;
+                    resolve(settled);
+                }
+            });
+        }
+        return waitPromise;
+    };
+    const kill = (signal = "SIGKILL") => {
+        try {
+            if (signal === "SIGKILL" && typeof pty.pid === "number" && pty.pid > 0) {
+                killProcessTree(pty.pid);
+            }
+            else if (process.platform === "win32") {
+                pty.kill();
+            }
+            else {
+                pty.kill(signal);
+            }
+        }
+        catch {
+            // ignore kill errors
+        }
+        if (signal === "SIGKILL") {
+            scheduleForceKillWaitFallback(signal);
+        }
+    };
+    const dispose = () => {
+        try {
+            dataListener?.dispose();
+        }
+        catch {
+            // ignore disposal errors
+        }
+        try {
+            exitListener?.dispose();
+        }
+        catch {
+            // ignore disposal errors
+        }
+        clearForceKillWaitFallback();
+        dataListener = null;
+        exitListener = null;
+        settleWait({ code: null, signal: null });
+    };
+    return {
+        pid: pty.pid || undefined,
+        stdin,
+        onStdout,
+        onStderr,
+        wait,
+        kill,
+        dispose,
+    };
+}

package/dist/process/supervisor/index.js

@@ -0,0 +1,10 @@
+import { createProcessSupervisor } from "./supervisor.js";
+let singleton = null;
+export function getProcessSupervisor() {
+    if (singleton) {
+        return singleton;
+    }
+    singleton = createProcessSupervisor();
+    return singleton;
+}
+export { createProcessSupervisor } from "./supervisor.js";

package/dist/process/supervisor/registry.js

@@ -0,0 +1,117 @@
+function nowMs() {
+    return Date.now();
+}
+const DEFAULT_MAX_EXITED_RECORDS = 2_000;
+function resolveMaxExitedRecords(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+        return DEFAULT_MAX_EXITED_RECORDS;
+    }
+    return Math.max(1, Math.floor(value));
+}
+export function createRunRegistry(options) {
+    const records = new Map();
+    const maxExitedRecords = resolveMaxExitedRecords(options?.maxExitedRecords);
+    const pruneExitedRecords = () => {
+        if (!records.size) {
+            return;
+        }
+        let exited = 0;
+        for (const record of records.values()) {
+            if (record.state === "exited") {
+                exited += 1;
+            }
+        }
+        if (exited <= maxExitedRecords) {
+            return;
+        }
+        let remove = exited - maxExitedRecords;
+        for (const [runId, record] of records.entries()) {
+            if (remove <= 0) {
+                break;
+            }
+            if (record.state !== "exited") {
+                continue;
+            }
+            records.delete(runId);
+            remove -= 1;
+        }
+    };
+    const add = (record) => {
+        records.set(record.runId, { ...record });
+    };
+    const get = (runId) => {
+        const record = records.get(runId);
+        return record ? { ...record } : undefined;
+    };
+    const list = () => {
+        return Array.from(records.values()).map((record) => ({ ...record }));
+    };
+    const listByScope = (scopeKey) => {
+        if (!scopeKey.trim()) {
+            return [];
+        }
+        return Array.from(records.values())
+            .filter((record) => record.scopeKey === scopeKey)
+            .map((record) => ({ ...record }));
+    };
+    const updateState = (runId, state, patch) => {
+        const current = records.get(runId);
+        if (!current) {
+            return undefined;
+        }
+        const updatedAtMs = nowMs();
+        const next = {
+            ...current,
+            ...patch,
+            state,
+            updatedAtMs,
+            lastOutputAtMs: current.lastOutputAtMs,
+        };
+        records.set(runId, next);
+        return { ...next };
+    };
+    const touchOutput = (runId) => {
+        const current = records.get(runId);
+        if (!current) {
+            return;
+        }
+        const ts = nowMs();
+        records.set(runId, {
+            ...current,
+            lastOutputAtMs: ts,
+            updatedAtMs: ts,
+        });
+    };
+    const finalize = (runId, exit) => {
+        const current = records.get(runId);
+        if (!current) {
+            return null;
+        }
+        const firstFinalize = current.state !== "exited";
+        const ts = nowMs();
+        const next = {
+            ...current,
+            state: "exited",
+            terminationReason: current.terminationReason ?? exit.reason,
+            exitCode: current.exitCode !== undefined ? current.exitCode : exit.exitCode,
+            exitSignal: current.exitSignal !== undefined ? current.exitSignal : exit.exitSignal,
+            updatedAtMs: ts,
+        };
+        records.set(runId, next);
+        pruneExitedRecords();
+        return { record: { ...next }, firstFinalize };
+    };
+    const del = (runId) => {
+        records.delete(runId);
+    };
+    return {
+        add,
+        get,
+        list,
+        listByScope,
+        updateState,
+        touchOutput,
+        finalize,
+        delete: del,
+    };
+}

package/dist/process/supervisor/supervisor.js

@@ -0,0 +1,244 @@
+import crypto from "node:crypto";
+import { getShellConfig } from "../../agents/shell-utils.js";
+import { createSubsystemLogger } from "../../logging/subsystem.js";
+import { createChildAdapter } from "./adapters/child.js";
+import { createPtyAdapter } from "./adapters/pty.js";
+import { createRunRegistry } from "./registry.js";
+const log = createSubsystemLogger("process/supervisor");
+function clampTimeout(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return undefined;
+    }
+    return Math.max(1, Math.floor(value));
+}
+function isTimeoutReason(reason) {
+    return reason === "overall-timeout" || reason === "no-output-timeout";
+}
+export function createProcessSupervisor() {
+    const registry = createRunRegistry();
+    const active = new Map();
+    const cancel = (runId, reason = "manual-cancel") => {
+        const current = active.get(runId);
+        if (!current) {
+            return;
+        }
+        registry.updateState(runId, "exiting", {
+            terminationReason: reason,
+        });
+        current.run.cancel(reason);
+    };
+    const cancelScope = (scopeKey, reason = "manual-cancel") => {
+        if (!scopeKey.trim()) {
+            return;
+        }
+        for (const [runId, run] of active.entries()) {
+            if (run.scopeKey !== scopeKey) {
+                continue;
+            }
+            cancel(runId, reason);
+        }
+    };
+    const spawn = async (input) => {
+        const runId = input.runId?.trim() || crypto.randomUUID();
+        if (input.replaceExistingScope && input.scopeKey?.trim()) {
+            cancelScope(input.scopeKey, "manual-cancel");
+        }
+        const startedAtMs = Date.now();
+        const record = {
+            runId,
+            sessionId: input.sessionId,
+            backendId: input.backendId,
+            scopeKey: input.scopeKey?.trim() || undefined,
+            state: "starting",
+            startedAtMs,
+            lastOutputAtMs: startedAtMs,
+            createdAtMs: startedAtMs,
+            updatedAtMs: startedAtMs,
+        };
+        registry.add(record);
+        let forcedReason = null;
+        let settled = false;
+        let stdout = "";
+        let stderr = "";
+        let timeoutTimer = null;
+        let noOutputTimer = null;
+        const captureOutput = input.captureOutput !== false;
+        const overallTimeoutMs = clampTimeout(input.timeoutMs);
+        const noOutputTimeoutMs = clampTimeout(input.noOutputTimeoutMs);
+        const setForcedReason = (reason) => {
+            if (forcedReason) {
+                return;
+            }
+            forcedReason = reason;
+            registry.updateState(runId, "exiting", { terminationReason: reason });
+        };
+        let cancelAdapter = null;
+        const requestCancel = (reason) => {
+            setForcedReason(reason);
+            cancelAdapter?.(reason);
+        };
+        const touchOutput = () => {
+            registry.touchOutput(runId);
+            if (!noOutputTimeoutMs || settled) {
+                return;
+            }
+            if (noOutputTimer) {
+                clearTimeout(noOutputTimer);
+            }
+            noOutputTimer = setTimeout(() => {
+                requestCancel("no-output-timeout");
+            }, noOutputTimeoutMs);
+        };
+        try {
+            if (input.mode === "child" && input.argv.length === 0) {
+                throw new Error("spawn argv cannot be empty");
+            }
+            const adapter = input.mode === "pty"
+                ? await (async () => {
+                    const { shell, args: shellArgs } = getShellConfig();
+                    const ptyCommand = input.ptyCommand.trim();
+                    if (!ptyCommand) {
+                        throw new Error("PTY command cannot be empty");
+                    }
+                    return await createPtyAdapter({
+                        shell,
+                        args: [...shellArgs, ptyCommand],
+                        cwd: input.cwd,
+                        env: input.env,
+                    });
+                })()
+                : await createChildAdapter({
+                    argv: input.argv,
+                    cwd: input.cwd,
+                    env: input.env,
+                    windowsVerbatimArguments: input.windowsVerbatimArguments,
+                    input: input.input,
+                    stdinMode: input.stdinMode,
+                });
+            registry.updateState(runId, "running", { pid: adapter.pid });
+            const clearTimers = () => {
+                if (timeoutTimer) {
+                    clearTimeout(timeoutTimer);
+                    timeoutTimer = null;
+                }
+                if (noOutputTimer) {
+                    clearTimeout(noOutputTimer);
+                    noOutputTimer = null;
+                }
+            };
+            cancelAdapter = (_reason) => {
+                if (settled) {
+                    return;
+                }
+                adapter.kill("SIGKILL");
+            };
+            if (overallTimeoutMs) {
+                timeoutTimer = setTimeout(() => {
+                    requestCancel("overall-timeout");
+                }, overallTimeoutMs);
+            }
+            if (noOutputTimeoutMs) {
+                noOutputTimer = setTimeout(() => {
+                    requestCancel("no-output-timeout");
+                }, noOutputTimeoutMs);
+            }
+            adapter.onStdout((chunk) => {
+                if (captureOutput) {
+                    stdout += chunk;
+                }
+                input.onStdout?.(chunk);
+                touchOutput();
+            });
+            adapter.onStderr((chunk) => {
+                if (captureOutput) {
+                    stderr += chunk;
+                }
+                input.onStderr?.(chunk);
+                touchOutput();
+            });
+            const waitPromise = (async () => {
+                const result = await adapter.wait();
+                if (settled) {
+                    return {
+                        reason: forcedReason ?? "exit",
+                        exitCode: result.code,
+                        exitSignal: result.signal,
+                        durationMs: Date.now() - startedAtMs,
+                        stdout,
+                        stderr,
+                        timedOut: isTimeoutReason(forcedReason ?? "exit"),
+                        noOutputTimedOut: forcedReason === "no-output-timeout",
+                    };
+                }
+                settled = true;
+                clearTimers();
+                adapter.dispose();
+                active.delete(runId);
+                const reason = forcedReason ?? (result.signal != null ? "signal" : "exit");
+                const exit = {
+                    reason,
+                    exitCode: result.code,
+                    exitSignal: result.signal,
+                    durationMs: Date.now() - startedAtMs,
+                    stdout,
+                    stderr,
+                    timedOut: isTimeoutReason(forcedReason ?? reason),
+                    noOutputTimedOut: forcedReason === "no-output-timeout",
+                };
+                registry.finalize(runId, {
+                    reason: exit.reason,
+                    exitCode: exit.exitCode,
+                    exitSignal: exit.exitSignal,
+                });
+                return exit;
+            })().catch((err) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimers();
+                    active.delete(runId);
+                    adapter.dispose();
+                    registry.finalize(runId, {
+                        reason: "spawn-error",
+                        exitCode: null,
+                        exitSignal: null,
+                    });
+                }
+                throw err;
+            });
+            const managedRun = {
+                runId,
+                pid: adapter.pid,
+                startedAtMs,
+                stdin: adapter.stdin,
+                wait: async () => await waitPromise,
+                cancel: (reason = "manual-cancel") => {
+                    requestCancel(reason);
+                },
+            };
+            active.set(runId, {
+                run: managedRun,
+                scopeKey: input.scopeKey?.trim() || undefined,
+            });
+            return managedRun;
+        }
+        catch (err) {
+            registry.finalize(runId, {
+                reason: "spawn-error",
+                exitCode: null,
+                exitSignal: null,
+            });
+            log.warn(`spawn failed: runId=${runId} reason=${String(err)}`);
+            throw err;
+        }
+    };
+    return {
+        spawn,
+        cancel,
+        cancelScope,
+        reconcileOrphans: async () => {
+            // Deliberate no-op: this supervisor uses in-memory ownership only.
+            // Active runs are not recovered after process restart in the current model.
+        },
+        getRecord: (runId) => registry.get(runId),
+    };
+}

package/dist/process/supervisor/types.js

@@ -0,0 +1 @@
+export {};