parallel-codex-tui 0.1.0 → 0.1.4

package/dist/workers/live-probe.js

@@ -0,0 +1,176 @@
+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";
+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 Codex or Claude workers 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 = config.workers[engine];
+    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 = input.config.workers[input.engine];
+    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,14 +3,17 @@ 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, "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");
         }
@@ -33,7 +36,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,13 +50,30 @@ 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;
 }
 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,
         state,
@@ -58,5 +81,15 @@ async function setStatus(spec, state, phase, summary, nativeSessionId) {
         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,23 +2,90 @@ 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, readJson, readTextIfExists, writeJson } from "../core/file-store.js";
+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";
 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];
     const modelConfig = workerConfig.model;
+    const env = modelEnvironment(modelConfig);
+    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: [
+                ...workerConfig.interactive.args,
+                ...modelConfig.args
+            ].map((arg) => renderTemplate(arg, nativeSession.session_id, modelConfig)),
+            capabilities: workerConfig.capabilities,
+            additionalDirs
+        }),
+        ...(Object.keys(env).length > 0 ? { env } : {}),
         cwd: nativeSession.cwd,
         sessionId: nativeSession.session_id,
         label: 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.args;
+    return [
+        ...args,
+        ...[...new Set(input.additionalDirs)].flatMap((directory) => (input.capabilities.writableDirArgs.map((arg) => arg.replaceAll("{dir}", directory))))
+    ];
+}
+function withCodexWritableSandbox(args) {
+    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.codex.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, {
@@ -28,24 +95,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;
@@ -65,20 +147,67 @@ function ensureNodePtySpawnHelperExecutable() {
 async function readWorkerNativeSession(worker) {
     const workerDir = dirname(worker.statusPath);
     const nativePath = join(workerDir, "native-session.json");
-    if (!(await pathExists(nativePath))) {
+    const record = await readAttachNativeSessionIfValid(nativePath);
+    if (!record) {
+        const recoveredCodex = await recoverCodexNativeSession(worker, workerDir);
+        if (recoveredCodex) {
+            await writeJson(nativePath, NativeSessionSchema.parse(recoveredCodex));
+            return recoveredCodex;
+        }
         const recovered = await recoverClaudeNativeSession(worker, workerDir);
         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`);
     }
-    const record = await readJson(nativePath, NativeSessionSchema);
     if (record.engine !== worker.engine) {
         throw new Error(`Native session engine mismatch for ${worker.label}: expected ${worker.engine}, got ${record.engine}`);
     }
+    if (record.worker_id !== worker.id || record.role !== worker.role) {
+        throw new Error(`Native session worker mismatch for ${worker.label}: expected ${worker.role}/${worker.id}, got ${record.role}/${record.worker_id}`);
+    }
     return record;
 }
+async function readAttachNativeSessionIfValid(nativePath) {
+    if (!(await pathExists(nativePath))) {
+        return null;
+    }
+    try {
+        return await readJson(nativePath, NativeSessionSchema);
+    }
+    catch {
+        await removeIfExists(nativePath);
+        return null;
+    }
+}
+async function recoverCodexNativeSession(worker, workerDir) {
+    if (worker.engine !== "codex") {
+        return null;
+    }
+    const taskDir = dirname(workerDir);
+    const cwd = await readTaskCwdIfValid(join(taskDir, "meta.json"));
+    if (!cwd) {
+        return null;
+    }
+    const output = await readTextIfExists(join(workerDir, "output.log"));
+    const sessionId = detectResumeSessionId(output);
+    if (!sessionId) {
+        return null;
+    }
+    const now = new Date().toISOString();
+    return {
+        engine: "codex",
+        role: worker.role,
+        worker_id: worker.id,
+        session_id: sessionId,
+        scope: "task",
+        cwd,
+        created_at: now,
+        last_used_at: now,
+        source: "output-detected"
+    };
+}
 async function recoverClaudeNativeSession(worker, workerDir) {
     if (worker.engine !== "claude") {
         return null;
@@ -88,8 +217,7 @@ async function recoverClaudeNativeSession(worker, workerDir) {
         return null;
     }
     const taskDir = dirname(workerDir);
-    const metaPath = join(taskDir, "meta.json");
-    const cwd = (await pathExists(metaPath)) ? (await readJson(metaPath, TaskMetaSchema)).cwd : null;
+    const cwd = await readTaskCwdIfValid(join(taskDir, "meta.json"));
     if (!cwd) {
         return null;
     }
@@ -112,6 +240,17 @@ async function recoverClaudeNativeSession(worker, workerDir) {
         source: "claude-project-log"
     };
 }
+async function readTaskCwdIfValid(metaPath) {
+    if (!(await pathExists(metaPath))) {
+        return null;
+    }
+    try {
+        return (await readJson(metaPath, TaskMetaSchema)).cwd;
+    }
+    catch {
+        return null;
+    }
+}
 async function findClaudeProjectSession(input) {
     const projectDir = join(claudeProjectsDir(), claudeProjectSlug(input.cwd));
     if (!(await pathExists(projectDir))) {

package/dist/workers/native-session-detection.js

@@ -0,0 +1,17 @@
+export function detectNativeSessionId(text) {
+    const labeled = text.match(/\b(?:session id|session_id|session)\s*[:=]\s*([A-Za-z0-9._:@-]{4,})/i);
+    if (labeled?.[1] && isLikelyNativeSessionId(labeled[1])) {
+        return labeled[1];
+    }
+    return detectResumeSessionId(text);
+}
+export function detectResumeSessionId(text) {
+    const resume = text.match(/\b(?:codex|claude)\s+resume\s+([A-Za-z0-9._:@-]{4,})\b/i);
+    return resume?.[1] && isLikelyNativeSessionId(resume[1]) ? resume[1] : null;
+}
+export function isLikelyNativeSessionId(value) {
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
+        return true;
+    }
+    return value.length >= 8 && /[0-9]/.test(value) && /[._:@-]/.test(value);
+}