parallel-codex-tui 0.3.1 → 0.4.0

package/dist/supervisor/runner.js

@@ -0,0 +1,238 @@
+import { createRuntime } from "../bootstrap.js";
+import { readProcessStartToken } from "../core/process-identity.js";
+import { appendSupervisorEvent, readSupervisorCommands, readSupervisorRunRequest, readSupervisorRunState, supervisorRunFiles, writeSupervisorRunState } from "./store.js";
+const COMMAND_POLL_MS = 100;
+export async function runSupervisorJob(runDir) {
+    const files = supervisorRunFiles(runDir);
+    const request = await readSupervisorRunRequest(files);
+    let state = await readSupervisorRunState(files);
+    let runtime = null;
+    const controller = new AbortController();
+    let commandLoopStopped = false;
+    let writeQueue = Promise.resolve();
+    let eventSequence = 0;
+    const enqueue = (operation) => {
+        writeQueue = writeQueue.then(operation, operation);
+    };
+    const replaceState = (update) => {
+        state = update(state);
+        const snapshot = state;
+        enqueue(() => writeSupervisorRunState(files, snapshot));
+    };
+    const emit = (type, payload) => {
+        const event = {
+            version: 1,
+            sequence: eventSequence,
+            at: new Date().toISOString(),
+            type,
+            payload
+        };
+        eventSequence += 1;
+        enqueue(() => appendSupervisorEvent(files, event));
+    };
+    const stopFromSignal = () => controller.abort();
+    process.once("SIGTERM", stopFromSignal);
+    process.once("SIGINT", stopFromSignal);
+    try {
+        const startedAt = new Date().toISOString();
+        const processStartToken = await readProcessStartToken(process.pid);
+        replaceState((current) => ({
+            ...current,
+            status: "running",
+            updated_at: startedAt,
+            started_at: startedAt,
+            pid: process.pid,
+            ...(processStartToken ? { process_start_token: processStartToken } : {})
+        }));
+        await writeQueue;
+        runtime = await createRuntime(request.app_root, request.workspace_root);
+        const commandLoop = consumeCommands(files, runtime, controller, () => commandLoopStopped, () => {
+            replaceState((current) => ({
+                ...current,
+                status: "cancelling",
+                updated_at: new Date().toISOString()
+            }));
+        });
+        try {
+            const result = await executeRequest(request, runtime, controller.signal, {
+                onRouteStart: (value) => emit("route-start", value),
+                onRouteProgress: (value) => emit("route-progress", value),
+                onRoute: (value) => emit("route", value),
+                onStatus: (value) => {
+                    emit("status", value);
+                    if (value.taskId !== "main") {
+                        replaceState((current) => ({
+                            ...current,
+                            task_id: value.taskId,
+                            updated_at: new Date().toISOString()
+                        }));
+                    }
+                },
+                onWorker: (value) => emit("worker", value)
+            });
+            await writeQueue;
+            await persistRunMessage(runtime, request, result.summary, result.taskId);
+            const finishedAt = new Date().toISOString();
+            state = {
+                ...state,
+                status: "completed",
+                updated_at: finishedAt,
+                finished_at: finishedAt,
+                task_id: result.taskId ?? requestedTaskId(request),
+                result
+            };
+            delete state.error;
+            await writeSupervisorRunState(files, state);
+        }
+        catch (error) {
+            await writeQueue;
+            const cancelled = controller.signal.aborted || isAbortError(error);
+            const summary = cancelled
+                ? cancellationSummary(request)
+                : error instanceof Error ? error.message : String(error);
+            try {
+                await persistRunMessage(runtime, request, summary, requestedTaskId(request));
+            }
+            catch {
+                // The terminal state remains recoverable even when chat persistence fails.
+            }
+            const finishedAt = new Date().toISOString();
+            state = {
+                ...state,
+                status: cancelled ? "cancelled" : "failed",
+                updated_at: finishedAt,
+                finished_at: finishedAt,
+                task_id: state.task_id ?? requestedTaskId(request),
+                error: summary
+            };
+            delete state.result;
+            await writeSupervisorRunState(files, state);
+        }
+        finally {
+            commandLoopStopped = true;
+            await commandLoop;
+        }
+    }
+    catch (error) {
+        const finishedAt = new Date().toISOString();
+        const summary = error instanceof Error ? error.message : String(error);
+        state = {
+            ...state,
+            status: controller.signal.aborted ? "cancelled" : "failed",
+            updated_at: finishedAt,
+            finished_at: finishedAt,
+            error: controller.signal.aborted ? cancellationSummary(request) : summary
+        };
+        delete state.result;
+        try {
+            await writeQueue;
+            await writeSupervisorRunState(files, state);
+        }
+        catch {
+            // The CLI-level failure handler is the last resort when the run directory is unavailable.
+        }
+    }
+    finally {
+        commandLoopStopped = true;
+        process.off("SIGTERM", stopFromSignal);
+        process.off("SIGINT", stopFromSignal);
+        try {
+            runtime?.index.close();
+        }
+        catch {
+            // Process exit closes a damaged or already-closed SQLite handle.
+        }
+    }
+}
+async function executeRequest(request, runtime, signal, callbacks) {
+    const common = {
+        cwd: request.cwd,
+        signal,
+        ...callbacks
+    };
+    switch (request.kind) {
+        case "handle-request":
+            return runtime.orchestrator.handleRequest({
+                ...common,
+                request: request.request,
+                route: request.route,
+                roleSelection: request.role_selection
+            });
+        case "handle-task-turn":
+            return runtime.orchestrator.handleTaskTurn({
+                ...common,
+                request: request.request,
+                taskId: request.task_id,
+                route: request.route,
+                roleSelection: request.role_selection
+            });
+        case "answer-task-question":
+            return runtime.orchestrator.answerTaskQuestion({
+                ...common,
+                request: request.request,
+                taskId: request.task_id,
+                route: request.route,
+                roleSelection: request.role_selection
+            });
+        case "retry-task":
+            return runtime.orchestrator.retryTask({
+                ...common,
+                taskId: request.task_id
+            });
+        case "resume-feature":
+            return runtime.orchestrator.resumeFeature({
+                ...common,
+                taskId: request.task_id,
+                featureId: request.feature_id
+            });
+    }
+}
+async function consumeCommands(files, runtime, controller, stopped, onCancelling) {
+    const handled = new Set();
+    while (!stopped()) {
+        try {
+            const commands = await readSupervisorCommands(files);
+            for (const command of commands) {
+                if (handled.has(command.id)) {
+                    continue;
+                }
+                handled.add(command.id);
+                if (command.type === "cancel-run") {
+                    onCancelling();
+                    controller.abort();
+                }
+                else if (command.type === "cancel-feature") {
+                    await runtime.orchestrator.cancelFeature(command.task_id, command.feature_id);
+                }
+                else {
+                    await runtime.orchestrator.pauseFeature(command.task_id, command.feature_id);
+                }
+            }
+        }
+        catch {
+            // A concurrent append can expose a partial final JSONL row; the next poll retries it.
+        }
+        await delay(COMMAND_POLL_MS);
+    }
+}
+async function persistRunMessage(runtime, request, text, resultTaskId) {
+    await runtime.sessions.appendChatMessage({
+        from: "system",
+        text,
+        taskId: resultTaskId ?? requestedTaskId(request) ?? undefined
+    });
+}
+function requestedTaskId(request) {
+    return request.kind === "handle-request" ? null : request.task_id;
+}
+function cancellationSummary(request) {
+    return request.kind === "retry-task" || request.kind === "resume-feature"
+        ? "cancelled · retry stopped"
+        : "cancelled · request stopped";
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/supervisor/store.js

@@ -0,0 +1,213 @@
+import { randomUUID } from "node:crypto";
+import { readdir, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { appendJsonLine, ensureDir, pathExists, readJson, readTextIfExists, removeIfExists, writeJson } from "../core/file-store.js";
+import { processIsAlive, readProcessStartToken } from "../core/process-identity.js";
+import { SupervisorCommandSchema, SupervisorControllerSchema, SupervisorRunEventSchema, SupervisorRunRequestSchema, SupervisorRunStateSchema } from "./protocol.js";
+const SUPERVISOR_DIR = "supervisor";
+const RUNS_DIR = "runs";
+const REQUEST_FILE = "request.json";
+const STATE_FILE = "state.json";
+const EVENTS_FILE = "events.jsonl";
+const COMMANDS_FILE = "commands.jsonl";
+const CONTROLLER_FILE = "controller.json";
+const ACKNOWLEDGED_FILE = "acknowledged.json";
+export function supervisorRoot(workspaceRoot, dataDir) {
+    return join(workspaceRoot, dataDir, SUPERVISOR_DIR);
+}
+export function supervisorRunsRoot(workspaceRoot, dataDir) {
+    return join(supervisorRoot(workspaceRoot, dataDir), RUNS_DIR);
+}
+export function supervisorRunFiles(runDir) {
+    return {
+        dir: runDir,
+        requestPath: join(runDir, REQUEST_FILE),
+        statePath: join(runDir, STATE_FILE),
+        eventsPath: join(runDir, EVENTS_FILE),
+        commandsPath: join(runDir, COMMANDS_FILE),
+        controllerPath: join(runDir, CONTROLLER_FILE),
+        acknowledgedPath: join(runDir, ACKNOWLEDGED_FILE)
+    };
+}
+export function createSupervisorRunId(now = new Date()) {
+    const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+    return `run-${stamp}-${randomUUID().slice(0, 8)}`;
+}
+export async function createSupervisorRun(workspaceRoot, dataDir, request) {
+    const runsRoot = supervisorRunsRoot(workspaceRoot, dataDir);
+    const files = supervisorRunFiles(join(runsRoot, request.run_id));
+    const stagingFiles = supervisorRunFiles(join(runsRoot, `.${request.run_id}.${process.pid}.${randomUUID().slice(0, 8)}.pending`));
+    const now = request.created_at;
+    await ensureDir(stagingFiles.dir);
+    try {
+        await writeJson(stagingFiles.requestPath, SupervisorRunRequestSchema.parse(request));
+        await writeSupervisorRunState(stagingFiles, {
+            version: 1,
+            run_id: request.run_id,
+            kind: request.kind,
+            status: "queued",
+            app_root: request.app_root,
+            workspace_root: request.workspace_root,
+            created_at: now,
+            updated_at: now,
+            ...(request.kind === "handle-request" ? {} : { task_id: request.task_id })
+        });
+        await rename(stagingFiles.dir, files.dir);
+    }
+    catch (error) {
+        await rm(stagingFiles.dir, { recursive: true, force: true });
+        throw error;
+    }
+    return files;
+}
+export async function readSupervisorRunRequest(files) {
+    return readJson(files.requestPath, SupervisorRunRequestSchema);
+}
+export async function readSupervisorRunState(files) {
+    return readJson(files.statePath, SupervisorRunStateSchema);
+}
+export async function writeSupervisorRunState(files, state) {
+    await writeJson(files.statePath, SupervisorRunStateSchema.parse(state));
+}
+export async function appendSupervisorEvent(files, event) {
+    await appendJsonLine(files.eventsPath, SupervisorRunEventSchema.parse(event));
+}
+export async function readSupervisorEvents(files) {
+    return readJsonLines(files.eventsPath, SupervisorRunEventSchema);
+}
+export async function appendSupervisorCommand(files, command) {
+    await appendJsonLine(files.commandsPath, SupervisorCommandSchema.parse(command));
+}
+export async function readSupervisorCommands(files) {
+    return readJsonLines(files.commandsPath, SupervisorCommandSchema);
+}
+export async function acknowledgeSupervisorRun(files) {
+    await writeJson(files.acknowledgedPath, {
+        version: 1,
+        acknowledged_at: new Date().toISOString(),
+        pid: process.pid
+    });
+}
+export async function supervisorRunIsAcknowledged(files) {
+    return pathExists(files.acknowledgedPath);
+}
+export async function listSupervisorRuns(workspaceRoot, dataDir) {
+    const root = supervisorRunsRoot(workspaceRoot, dataDir);
+    if (!(await pathExists(root))) {
+        return [];
+    }
+    const names = await readdir(root);
+    const records = [];
+    for (const name of names) {
+        if (!name.startsWith("run-")) {
+            continue;
+        }
+        const files = supervisorRunFiles(join(root, name));
+        const state = await readValidJson(files.statePath, SupervisorRunStateSchema);
+        if (state) {
+            records.push({ files, state });
+        }
+    }
+    return records.sort((left, right) => left.state.created_at.localeCompare(right.state.created_at));
+}
+export function supervisorRunIsTerminal(state) {
+    return state.status === "completed" || state.status === "failed" || state.status === "cancelled";
+}
+export async function supervisorRunProcessIsActive(state) {
+    if (!state.pid || !processIsAlive(state.pid)) {
+        return false;
+    }
+    if (!state.process_start_token) {
+        return true;
+    }
+    return await readProcessStartToken(state.pid) === state.process_start_token;
+}
+export async function claimSupervisorController(files, options = {}) {
+    const pid = options.pid ?? process.pid;
+    const owner = SupervisorControllerSchema.parse({
+        version: 1,
+        controller_id: options.controllerId ?? randomUUID(),
+        pid,
+        acquired_at: (options.now ?? (() => new Date()))().toISOString(),
+        ...await optionalProcessStartToken(pid)
+    });
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (await writeJsonExclusive(files.controllerPath, owner)) {
+            return {
+                owner,
+                release: () => releaseSupervisorController(files, owner.controller_id)
+            };
+        }
+        const current = await readValidJson(files.controllerPath, SupervisorControllerSchema);
+        if (current && await supervisorControllerIsActive(current)) {
+            return null;
+        }
+        await removeControllerIfOwned(files.controllerPath, current?.controller_id);
+    }
+    return null;
+}
+async function releaseSupervisorController(files, controllerId) {
+    await removeControllerIfOwned(files.controllerPath, controllerId);
+}
+async function removeControllerIfOwned(path, controllerId) {
+    if (controllerId) {
+        const current = await readValidJson(path, SupervisorControllerSchema);
+        if (!current || current.controller_id !== controllerId) {
+            return;
+        }
+    }
+    await removeIfExists(path);
+}
+async function supervisorControllerIsActive(controller) {
+    if (!processIsAlive(controller.pid)) {
+        return false;
+    }
+    if (!controller.process_start_token) {
+        return true;
+    }
+    return await readProcessStartToken(controller.pid) === controller.process_start_token;
+}
+async function optionalProcessStartToken(pid) {
+    const token = await readProcessStartToken(pid);
+    return token ? { process_start_token: token } : {};
+}
+async function writeJsonExclusive(path, value) {
+    try {
+        await ensureDir(dirname(path));
+        await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+        return true;
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function readJsonLines(path, schema) {
+    const text = await readTextIfExists(path);
+    const records = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const parsed = schema.safeParse(JSON.parse(line));
+            if (parsed.success) {
+                records.push(parsed.data);
+            }
+        }
+        catch {
+            // A partial final line is ignored until the next poll completes it.
+        }
+    }
+    return records;
+}
+async function readValidJson(path, schema) {
+    try {
+        return await readJson(path, schema);
+    }
+    catch {
+        return null;
+    }
+}