parallel-codex-tui 0.1.3 → 0.1.5

package/dist/workers/live-probe.js

@@ -0,0 +1,177 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { ensureDir, readTextIfExists, writeText } from "../core/file-store.js";
+import { createWorkerRegistry, getAdapter } from "./registry.js";
+import { workerProvider } from "./provider.js";
+export async function runLiveAgentProbes(config, workspaceRoot, engines, options = {}) {
+    const activeEngines = [...new Set(engines)];
+    if (activeEngines.length === 0) {
+        return {
+            ok: true,
+            lines: ["agent live probe: skipped (no process Worker providers active)"]
+        };
+    }
+    const probesRoot = join(workspaceRoot, config.dataDir, "probes");
+    await ensureDir(probesRoot);
+    const runRoot = await mkdtemp(join(probesRoot, ".agent-"));
+    const registry = options.registry ?? createWorkerRegistry(config);
+    const nonce = options.nonce ?? (() => randomBytes(4).toString("hex"));
+    const results = [];
+    for (const engine of activeEngines) {
+        try {
+            results.push(await probeEngine(config, registry, engine, runRoot, nonce(), options.timeoutMs));
+        }
+        catch (error) {
+            results.push({
+                ok: false,
+                line: `${engine} live probe: failed (${safeProbeError(error)}; artifacts ${runRoot})`
+            });
+        }
+    }
+    const ok = results.every((result) => result.ok);
+    if (ok) {
+        await rm(runRoot, { force: true, recursive: true });
+    }
+    return {
+        ok,
+        lines: results.map((result) => result.line)
+    };
+}
+async function probeEngine(config, registry, engine, runRoot, nonce, timeoutOverride) {
+    const startedAt = Date.now();
+    const worker = workerProvider(config, engine).config;
+    const adapter = getAdapter(registry, engine);
+    const cwd = join(runRoot, `${engine}-workspace`);
+    await mkdir(cwd, { recursive: true });
+    const first = probeChallenge(engine, "fresh", nonce);
+    let nativeSessionId = null;
+    const firstSpec = await probeSpec({
+        config,
+        engine,
+        cwd,
+        dir: join(runRoot, `${engine}-fresh`),
+        workerId: `doctor-${engine}-fresh`,
+        challenge: first,
+        timeoutOverride,
+        onNativeSession: (sessionId) => {
+            nativeSessionId = sessionId;
+        }
+    });
+    const firstResult = await adapter.run(firstSpec);
+    await requireProbeAnswer(firstResult, firstSpec, first.expected);
+    if (!worker.nativeSession.enabled || !worker.nativeSession.detectSessionId) {
+        return {
+            ok: true,
+            line: `${engine} live probe: ok (fresh; native resume disabled; ${formatProbeDuration(Date.now() - startedAt)})`
+        };
+    }
+    if (!nativeSessionId) {
+        throw new Error("fresh request succeeded but no native session id was detected");
+    }
+    const second = probeChallenge(engine, "resume", nonce);
+    let resumedSessionId = null;
+    const now = new Date().toISOString();
+    const nativeSession = {
+        engine,
+        role: "main",
+        worker_id: firstSpec.workerId,
+        session_id: nativeSessionId,
+        scope: "main",
+        cwd,
+        created_at: now,
+        last_used_at: now,
+        source: "manual"
+    };
+    const resumeSpec = await probeSpec({
+        config,
+        engine,
+        cwd,
+        dir: join(runRoot, `${engine}-resume`),
+        workerId: `doctor-${engine}-resume`,
+        challenge: second,
+        timeoutOverride,
+        nativeSession,
+        onNativeSession: (sessionId) => {
+            resumedSessionId = sessionId;
+        }
+    });
+    const resumeResult = await adapter.run(resumeSpec);
+    await requireProbeAnswer(resumeResult, resumeSpec, second.expected);
+    if (resumedSessionId && resumedSessionId !== nativeSessionId) {
+        throw new Error("resume request returned a different native session id");
+    }
+    return {
+        ok: true,
+        line: `${engine} live probe: ok (fresh + resume; session ${compactProbeSessionId(nativeSessionId)}; ${formatProbeDuration(Date.now() - startedAt)})`
+    };
+}
+async function probeSpec(input) {
+    const worker = workerProvider(input.config, input.engine).config;
+    await mkdir(input.dir, { recursive: true });
+    const promptPath = join(input.dir, "prompt.md");
+    await writeText(promptPath, `${input.challenge.prompt}\n`);
+    const maximumTimeout = input.timeoutOverride ?? 120_000;
+    const timeoutMs = Math.min(worker.timeoutMs ?? maximumTimeout, maximumTimeout);
+    const firstOutputTimeoutMs = Math.min(worker.firstOutputTimeoutMs ?? timeoutMs, timeoutMs);
+    const idleTimeoutMs = Math.min(worker.idleTimeoutMs ?? timeoutMs, timeoutMs);
+    return {
+        workerId: input.workerId,
+        role: "main",
+        engine: input.engine,
+        cwd: input.cwd,
+        enforceWorkspaceIsolation: true,
+        filesDir: input.dir,
+        promptPath,
+        outputLogPath: join(input.dir, "output.log"),
+        statusPath: join(input.dir, "status.json"),
+        prompt: input.challenge.prompt,
+        timeoutMs,
+        firstOutputTimeoutMs,
+        idleTimeoutMs,
+        ...(input.nativeSession ? { nativeSession: input.nativeSession } : {}),
+        nativeSessionConfig: {
+            ...worker.nativeSession,
+            fallback: "fail"
+        },
+        modelConfig: worker.model,
+        onNativeSession: input.onNativeSession
+    };
+}
+async function requireProbeAnswer(result, spec, expected) {
+    const output = await readTextIfExists(spec.outputLogPath);
+    if (result.exitCode !== 0 || result.cancelled || result.failure) {
+        throw new Error(result.failure?.summary || `worker exited with code ${result.exitCode}`);
+    }
+    if (!output.includes(expected)) {
+        throw new Error(`response did not contain challenge result ${expected}`);
+    }
+}
+function probeChallenge(engine, phase, nonce) {
+    const segments = ["PCT", engine.toUpperCase(), phase.toUpperCase(), nonce.toUpperCase()];
+    return {
+        prompt: [
+            "This is a connectivity probe. Do not use tools or modify files.",
+            `Join these segments with underscores and reply with only the joined value: ${segments.join(" | ")}`
+        ].join("\n"),
+        expected: segments.join("_")
+    };
+}
+function compactProbeSessionId(sessionId) {
+    return sessionId.length > 12 ? `${sessionId.slice(0, 8)}...` : sessionId;
+}
+function formatProbeDuration(durationMs) {
+    if (durationMs < 1000) {
+        return `${durationMs}ms`;
+    }
+    return `${(durationMs / 1000).toFixed(1).replace(/\.0$/, "")}s`;
+}
+function safeProbeError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 300) || "unknown error";
+}

package/dist/workers/mock-adapter.js

@@ -3,16 +3,36 @@ import { appendText, readTextIfExists, writeJson, writeText } from "../core/file
 export class MockWorkerAdapter {
     name = "mock";
     async run(spec) {
+        if (spec.signal?.aborted) {
+            return cancelMockWorker(spec);
+        }
         const nativeSessionId = spec.nativeSession?.session_id ?? `mock-${spec.workerId}`;
         await spec.onNativeSession?.(nativeSessionId);
         await setStatus(spec, "running", "mock-running", `${spec.role} mock worker running`, nativeSessionId);
         await appendText(spec.outputLogPath, `[mock:${spec.role}] started\n`);
         if (spec.role === "judge") {
-            await writeText(join(spec.filesDir, "requirements.md"), "# Requirements\n\n- Mock requirements derived from the user request.\n");
-            await writeText(join(spec.filesDir, "plan.md"), "# Plan\n\n1. Run Actor.\n2. Run Critic.\n");
-            await writeText(join(spec.filesDir, "acceptance.md"), "# Acceptance\n\n- Mock review approves the result.\n");
-            await writeText(join(spec.filesDir, "actor-brief.md"), "# Actor Brief\n\nImplement the requested change and write a worklog.\n");
-            await writeText(join(spec.filesDir, "critic-brief.md"), "# Critic Brief\n\nReview the Actor output against acceptance criteria.\n");
+            if (spec.prompt.includes("# Role:") && spec.prompt.includes("· Final acceptance")) {
+                const criterionIds = promptJsonArray(spec.prompt, "Required acceptance criterion ids");
+                const changedPaths = promptJsonArray(spec.prompt, "Authoritative changed paths");
+                await writeJson(join(spec.filesDir, "final-acceptance.json"), {
+                    version: 1,
+                    decision: "approved",
+                    summary: "Mock Final Judge verified every acceptance criterion.",
+                    acceptance: criterionIds.map((criterionId) => ({
+                        criterion_id: criterionId,
+                        status: "passed",
+                        evidence: "Mock verification completed."
+                    })),
+                    changed_paths: changedPaths
+                });
+            }
+            else {
+                await writeText(join(spec.filesDir, "requirements.md"), "# Requirements\n\n- [R-001] Mock requirements derived from the user request.\n");
+                await writeText(join(spec.filesDir, "plan.md"), "# Plan\n\n1. [P-001] Implement the scoped change.\n2. [P-002] Run focused verification.\n");
+                await writeText(join(spec.filesDir, "acceptance.md"), "# Acceptance\n\n- [A-001] [R-001] Focused tests pass for the requested behavior.\n");
+                await writeText(join(spec.filesDir, "actor-brief.md"), "# Actor Brief\n\nImplement the requested change and write a worklog.\n");
+                await writeText(join(spec.filesDir, "critic-brief.md"), "# Critic Brief\n\nReview the Actor output against acceptance criteria.\n");
+            }
         }
         if (spec.role === "actor") {
             await writeText(join(spec.filesDir, "worklog.md"), "# Worklog\n\n- Mock actor completed the implementation.\n");
@@ -33,7 +53,10 @@ export class MockWorkerAdapter {
             }
         }
         if (spec.role === "main") {
-            await appendText(spec.outputLogPath, `Mock simple response for: ${spec.prompt.trim()}\n`);
+            await appendText(spec.outputLogPath, `Mock simple response for: ${mainRequestFromPrompt(spec.prompt)}\n`);
+        }
+        if (spec.signal?.aborted) {
+            return cancelMockWorker(spec, nativeSessionId);
         }
         await appendText(spec.outputLogPath, `[mock:${spec.role}] done\n`);
         await setStatus(spec, "done", "mock-done", `${spec.role} mock worker done`, nativeSessionId);
@@ -44,19 +67,61 @@ export class MockWorkerAdapter {
         };
     }
 }
+async function cancelMockWorker(spec, nativeSessionId) {
+    await appendText(spec.outputLogPath, "[mock] cancelled\n");
+    await setStatus(spec, "cancelled", "mock-cancelled", `${spec.role} mock worker cancelled`, nativeSessionId);
+    return {
+        workerId: spec.workerId,
+        exitCode: 130,
+        signal: "SIGTERM",
+        cancelled: true
+    };
+}
+function mainRequestFromPrompt(prompt) {
+    const marker = "\nUser request:\n";
+    const markerIndex = prompt.indexOf(marker);
+    return markerIndex >= 0 ? prompt.slice(markerIndex + marker.length).trim() : prompt.trim();
+}
 function featureDirFromPrompt(prompt) {
     const line = prompt.split("\n").find((item) => item.startsWith("Feature directory: "));
     return line ? line.replace("Feature directory: ", "").trim() : null;
 }
+function promptJsonArray(prompt, label) {
+    const line = prompt.split("\n").find((item) => item.startsWith(`${label}: `));
+    if (!line) {
+        return [];
+    }
+    try {
+        const value = JSON.parse(line.slice(label.length + 2));
+        return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
 async function setStatus(spec, state, phase, summary, nativeSessionId) {
-    await writeJson(spec.statusPath, {
+    const status = {
         worker_id: spec.workerId,
+        ...(spec.featureId ? { feature_id: spec.featureId } : {}),
+        ...(spec.featureTitle ? { feature_title: spec.featureTitle } : {}),
         role: spec.role,
         engine: spec.engine,
+        ...(spec.modelConfig?.name.trim() ? { model_name: spec.modelConfig.name.trim() } : {}),
+        ...(spec.modelConfig?.provider.trim() ? { model_provider: spec.modelConfig.provider.trim() } : {}),
         state,
         phase,
         last_event_at: new Date().toISOString(),
         summary,
         ...(nativeSessionId ? { native_session_id: nativeSessionId } : {})
-    });
+    };
+    await writeJson(spec.statusPath, status);
+    notifyStatus(spec, status);
+}
+function notifyStatus(spec, status) {
+    try {
+        void Promise.resolve(spec.onStatus?.(status)).catch(() => { });
+    }
+    catch {
+        // Status observers cannot change the worker outcome.
+    }
 }

package/dist/workers/native-attach.js

@@ -2,30 +2,105 @@ import { accessSync, chmodSync, constants, existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { readdir } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, relative, sep } from "node:path";
 import { spawn } from "node-pty";
 import { pathExists, pathIsDirectory, readJson, readTextIfExists, removeIfExists, writeJson } from "../core/file-store.js";
 import { NativeSessionSchema, TaskMetaSchema } from "../domain/schemas.js";
 import { detectResumeSessionId } from "./native-session-detection.js";
+import { workerProvider } from "./provider.js";
 const require = createRequire(import.meta.url);
 export async function buildNativeAttachLaunch(input) {
-    const nativeSession = await readWorkerNativeSession(input.worker);
-    const workerConfig = input.config.workers[input.worker.engine];
+    return buildNativeSessionLaunch(input, "resume");
+}
+export async function buildNativeForkLaunch(input) {
+    return buildNativeSessionLaunch(input, "fork");
+}
+async function buildNativeSessionLaunch(input, mode) {
+    const workerConfig = workerProvider(input.config, input.worker.engine).config;
+    const nativeSession = await readWorkerNativeSession(input.worker, workerConfig.capabilities.profile);
     const modelConfig = workerConfig.model;
+    const env = modelEnvironment(modelConfig);
+    const interactiveArgs = mode === "fork"
+        ? workerConfig.interactive.forkArgs
+        : workerConfig.interactive.args;
+    if (mode === "fork" && interactiveArgs.length === 0) {
+        throw new Error(`Native session fork is not configured for ${input.worker.engine}. `
+            + `Set workers.${input.worker.engine}.interactive.forkArgs with a {sessionId} template.`);
+    }
+    const workerDir = dirname(input.worker.statusPath);
+    const taskDir = dirname(workerDir);
     if (!(await pathExists(nativeSession.cwd))) {
         throw new Error(`Native session workspace not found for ${input.worker.label}: ${nativeSession.cwd}`);
     }
     if (!(await pathIsDirectory(nativeSession.cwd))) {
         throw new Error(`Native session workspace is not a directory for ${input.worker.label}: ${nativeSession.cwd}`);
     }
+    const recordedDirs = nativeSession.writable_dirs?.length
+        ? nativeSession.writable_dirs
+        : isWithin(nativeSession.cwd, join(taskDir, "workspaces")) ? [taskDir] : [];
+    const additionalDirs = [];
+    for (const directory of recordedDirs) {
+        if (directory !== nativeSession.cwd && await pathIsDirectory(directory)) {
+            additionalDirs.push(directory);
+        }
+    }
     return {
         command: workerConfig.interactive.command,
-        args: workerConfig.interactive.args.map((arg) => renderTemplate(arg, nativeSession.session_id, modelConfig)),
+        args: nativeAttachArgs({
+            args: [
+                ...interactiveArgs,
+                ...modelConfig.args
+            ].map((arg) => renderTemplate(arg, nativeSession.session_id, modelConfig)),
+            providerId: input.worker.engine,
+            capabilities: workerConfig.capabilities,
+            additionalDirs
+        }),
+        ...(Object.keys(env).length > 0 ? { env } : {}),
         cwd: nativeSession.cwd,
         sessionId: nativeSession.session_id,
-        label: input.worker.label
+        label: mode === "fork" ? `${input.worker.label} · fork` : input.worker.label
     };
 }
+function nativeAttachArgs(input) {
+    if (input.additionalDirs.length === 0 || input.capabilities.writableDirArgs.length === 0) {
+        return input.args;
+    }
+    const args = input.capabilities.profile === "codex"
+        ? withCodexWritableSandbox(input.args, input.providerId)
+        : input.args;
+    return [
+        ...args,
+        ...[...new Set(input.additionalDirs)].flatMap((directory) => (input.capabilities.writableDirArgs.map((arg) => arg.replaceAll("{dir}", directory))))
+    ];
+}
+function withCodexWritableSandbox(args, providerId) {
+    const sandbox = codexSandboxSelection(args);
+    if (sandbox === "read-only") {
+        throw new Error("Codex native attach cannot use recorded worker directories with a read-only sandbox. "
+            + `Set workers.${providerId}.interactive.args to workspace-write or danger-full-access.`);
+    }
+    return sandbox ? args : [...args, "--sandbox", "workspace-write"];
+}
+function codexSandboxSelection(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (arg === "--dangerously-bypass-approvals-and-sandbox") {
+            return "danger-full-access";
+        }
+        if (arg === "--sandbox" || arg === "-s") {
+            return args[index + 1]?.trim().toLowerCase() || null;
+        }
+        const match = arg.match(/^(?:--sandbox|-s)=(.+)$/);
+        if (match) {
+            return match[1]?.trim().toLowerCase() || null;
+        }
+    }
+    return null;
+}
+function isWithin(path, root) {
+    const pathFromRoot = relative(root, path);
+    return pathFromRoot === "" || (!pathFromRoot.startsWith(`..${sep}`) && pathFromRoot !== "..");
+}
 export function startNativeAttachProcess(launch, handlers = {}) {
     ensureNodePtySpawnHelperExecutable();
     const child = spawn(launch.command, launch.args, {
@@ -35,24 +110,39 @@ export function startNativeAttachProcess(launch, handlers = {}) {
         cwd: launch.cwd,
         env: {
             ...process.env,
+            ...(launch.env ?? {}),
             TERM: process.env.TERM || "xterm-256color"
         }
     });
+    let closed = false;
     child.onData((chunk) => {
         handlers.onOutput?.(chunk);
     });
     child.onExit(({ exitCode }) => {
+        closed = true;
         handlers.onClose?.(exitCode);
     });
     return {
         write(input) {
             child.write(input);
         },
+        resize(cols, rows) {
+            if (closed) {
+                return;
+            }
+            child.resize(Math.max(1, Math.trunc(cols)), Math.max(1, Math.trunc(rows)));
+        },
         kill() {
+            if (closed) {
+                return;
+            }
             child.kill("SIGTERM");
         }
     };
 }
+function modelEnvironment(modelConfig) {
+    return Object.fromEntries(Object.entries(modelConfig.env ?? {}).map(([name, value]) => [name, renderTemplate(value, "", modelConfig)]));
+}
 function ensureNodePtySpawnHelperExecutable() {
     if (process.platform === "win32") {
         return;
@@ -69,22 +159,22 @@ function ensureNodePtySpawnHelperExecutable() {
         chmodSync(helperPath, 0o755);
     }
 }
-async function readWorkerNativeSession(worker) {
+async function readWorkerNativeSession(worker, profile) {
     const workerDir = dirname(worker.statusPath);
     const nativePath = join(workerDir, "native-session.json");
     const record = await readAttachNativeSessionIfValid(nativePath);
     if (!record) {
-        const recoveredCodex = await recoverCodexNativeSession(worker, workerDir);
+        const recoveredCodex = await recoverCodexNativeSession(worker, workerDir, profile);
         if (recoveredCodex) {
             await writeJson(nativePath, NativeSessionSchema.parse(recoveredCodex));
             return recoveredCodex;
         }
-        const recovered = await recoverClaudeNativeSession(worker, workerDir);
+        const recovered = await recoverClaudeNativeSession(worker, workerDir, profile);
         if (recovered) {
             await writeJson(nativePath, NativeSessionSchema.parse(recovered));
             return recovered;
         }
-        throw new Error(`No native session recorded for ${worker.label}. Run the worker once before attaching, or make sure ${worker.engine} persisted a resumable session.`);
+        throw new Error(`No native session for ${worker.label} · run once before attach`);
     }
     if (record.engine !== worker.engine) {
         throw new Error(`Native session engine mismatch for ${worker.label}: expected ${worker.engine}, got ${record.engine}`);
@@ -106,8 +196,8 @@ async function readAttachNativeSessionIfValid(nativePath) {
         return null;
     }
 }
-async function recoverCodexNativeSession(worker, workerDir) {
-    if (worker.engine !== "codex") {
+async function recoverCodexNativeSession(worker, workerDir, profile) {
+    if (profile !== "codex") {
         return null;
     }
     const taskDir = dirname(workerDir);
@@ -122,7 +212,7 @@ async function recoverCodexNativeSession(worker, workerDir) {
     }
     const now = new Date().toISOString();
     return {
-        engine: "codex",
+        engine: worker.engine,
         role: worker.role,
         worker_id: worker.id,
         session_id: sessionId,
@@ -133,8 +223,8 @@ async function recoverCodexNativeSession(worker, workerDir) {
         source: "output-detected"
     };
 }
-async function recoverClaudeNativeSession(worker, workerDir) {
-    if (worker.engine !== "claude") {
+async function recoverClaudeNativeSession(worker, workerDir, profile) {
+    if (profile !== "claude") {
         return null;
     }
     const prompt = await readTextIfExists(join(workerDir, "prompt.md"));
@@ -154,7 +244,7 @@ async function recoverClaudeNativeSession(worker, workerDir) {
         return null;
     }
     return {
-        engine: "claude",
+        engine: worker.engine,
         role: worker.role,
         worker_id: worker.id,
         session_id: match.sessionId,
@@ -249,5 +339,5 @@ function renderTemplate(value, sessionId, modelConfig) {
         .replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => process.env[name] ?? "");
 }
 export function supportsNativeAttach(engine) {
-    return engine === "codex" || engine === "claude" || engine === "mock";
+    return Boolean(engine);
 }