parallel-codex-tui 0.1.3 → 0.1.4

package/dist/core/router.js

@@ -1,78 +1,484 @@
 import { spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+import { StringDecoder } from "node:string_decoder";
 import { RouteDecisionSchema } from "../domain/schemas.js";
-export async function routeRequestWithCodex(request, config, runner = runCodexRouterProcess, cwd = config.projectRoot) {
+import { ProcessTreeCleanupError, terminateProcessTree } from "./process-tree.js";
+import { classifyRouterFailure } from "./router-audit.js";
+import { sanitizeRouterText } from "./router-redaction.js";
+export async function routeRequestWithCodex(request, config, runner = runCodexRouterProcess, cwd = config.projectRoot, signal, onProgress) {
+    const startedAt = Date.now();
+    const telemetryStartedAt = performance.now();
+    let dispatchMs;
+    if (signal?.aborted) {
+        throw cancellationError();
+    }
     if (config.router.defaultMode === "simple") {
-        return simpleRoute("Forced simple mode from config.", config);
+        return annotateRoute(simpleRoute("Forced simple mode from config.", config), "forced", startedAt);
     }
     if (config.router.defaultMode === "complex") {
-        return complexRoute("Forced complex mode from config.", config);
+        return annotateRoute(complexRoute("Forced complex mode from config.", config), "forced", startedAt);
     }
+    const proxyContext = routerProxyContext(config.router.codex.env);
+    const commandLabel = routerCommandLabel(config.router.codex.command);
+    const routerName = routerDisplayName(commandLabel);
     try {
-        const output = await runner(buildCodexRouterPrompt(request, config), config, cwd);
-        const route = parseCodexRoute(output, config);
-        return RouteDecisionSchema.parse(route);
+        const prompt = buildCodexRouterPrompt(request, config);
+        dispatchMs = Math.max(0, performance.now() - telemetryStartedAt);
+        emitRouterProgress(onProgress, "dispatching");
+        const result = normalizeRouterRunnerResult(await runner(prompt, config, cwd, signal, onProgress));
+        let route;
+        const parseStartedAt = performance.now();
+        emitRouterProgress(onProgress, "parsing");
+        try {
+            route = RouteDecisionSchema.parse(parseCodexRoute(result.output, config));
+        }
+        catch (error) {
+            throw routerExecutionError(error, mergeRouterTelemetry(result.telemetry, {
+                router_dispatch_ms: dispatchMs,
+                router_parse_ms: Math.max(0, performance.now() - parseStartedAt)
+            }), "response");
+        }
+        return annotateRoute(route, "codex", startedAt, mergeRouterTelemetry(result.telemetry, {
+            router_dispatch_ms: dispatchMs,
+            router_parse_ms: Math.max(0, performance.now() - parseStartedAt)
+        }), proxyContext, commandLabel);
     }
     catch (error) {
-        const fallback = fallbackRoute(config);
+        if (error instanceof ProcessTreeCleanupError) {
+            throw error;
+        }
+        if (signal?.aborted || isAbortError(error)) {
+            throw cancellationError();
+        }
+        const context = routerExecutionErrorContext(error);
+        const failureSummary = summarizeRouterError(error);
+        const fallback = annotateRoute(fallbackRoute(config, routerName), "fallback", startedAt, mergeRouterTelemetry(context.telemetry, {
+            router_dispatch_ms: dispatchMs
+        }), proxyContext, commandLabel);
         return {
             ...fallback,
-            reason: `Codex router failed: ${summarizeRouterError(error)}. ${fallback.reason}`
+            ...(context.stage ? { router_failure_stage: context.stage } : {}),
+            router_failure_kind: routerFailureKind(failureSummary, context.stage, context.timeoutKind),
+            ...(context.timeoutKind ? { router_timeout_kind: context.timeoutKind } : {}),
+            reason: `${routerName} failed: ${failureSummary}. ${fallback.reason}`
         };
     }
 }
-export async function runCodexRouterProcess(prompt, config, cwd = config.projectRoot) {
-    const { command, args, timeoutMs } = config.router.codex;
+function routerFailureKind(summary, stage, timeoutKind) {
+    if (timeoutKind) {
+        return "timeout";
+    }
+    const classified = classifyRouterFailure(summary);
+    if (classified) {
+        return classified;
+    }
+    if (stage === "spawn") {
+        return "unavailable";
+    }
+    if (stage === "input") {
+        return "input";
+    }
+    if (stage === "exit") {
+        return "exit";
+    }
+    if (stage === "response") {
+        return "invalid-output";
+    }
+    return "unknown";
+}
+function annotateRoute(route, source, startedAt, telemetry, proxyContext, routerCommand) {
+    return {
+        ...route,
+        ...normalizeRouterTelemetry(telemetry),
+        ...routerProxyRouteFields(proxyContext),
+        ...(routerCommand ? { router_command: routerCommand } : {}),
+        source,
+        duration_ms: Math.max(0, Date.now() - startedAt)
+    };
+}
+export function routerCommandLabel(command) {
+    const executable = command.trim().split(/[\\/]/).filter(Boolean).at(-1) ?? "router";
+    const safe = sanitizeRouterText(executable)
+        .replace(/[\u0000-\u001f\u007f|·]+/g, "-")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    return Array.from(safe || "router").slice(0, 80).join("");
+}
+function routerDisplayName(commandLabel) {
+    return /^codex(?:\.exe)?$/i.test(commandLabel) ? "Codex router" : `Router ${commandLabel}`;
+}
+export async function runCodexRouterProcess(prompt, config, cwd = config.projectRoot, signal, onProgress) {
+    const { command, args, timeoutMs, firstOutputTimeoutMs, idleTimeoutMs, maxOutputBytes } = config.router.codex;
+    const routerName = routerDisplayName(routerCommandLabel(command));
+    if (signal?.aborted) {
+        throw cancellationError();
+    }
+    const configuredEnvironment = routerEnvironment(config.router.codex.env);
+    const env = {
+        ...process.env,
+        ...configuredEnvironment
+    };
+    const proxyConfigured = hasConfiguredProxy(env);
+    let progressPhase;
+    const reportProgress = (phase) => {
+        if (progressPhase === phase) {
+            return;
+        }
+        progressPhase = phase;
+        emitRouterProgress(onProgress, phase);
+    };
+    reportProgress("starting");
     return new Promise((resolve, reject) => {
+        const processStartedAt = Date.now();
+        const detached = process.platform !== "win32";
         const child = spawn(command, args, {
             cwd,
-            env: process.env,
-            stdio: ["pipe", "pipe", "pipe"]
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached
         });
         let stdout = "";
         let stderr = "";
+        const stdoutDecoder = new StringDecoder("utf8");
+        const stderrDecoder = new StringDecoder("utf8");
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let spawnMs;
+        let firstOutputMs;
+        let firstStdoutMs;
+        let firstStderrMs;
         let settled = false;
-        let timeout;
-        const finish = (error, output = stdout) => {
+        let terminating = false;
+        let totalTimeout;
+        let firstOutputTimeout;
+        let idleTimeout;
+        let abortListener;
+        const clearRunTimers = () => {
+            if (totalTimeout) {
+                clearTimeout(totalTimeout);
+                totalTimeout = undefined;
+            }
+            if (firstOutputTimeout) {
+                clearTimeout(firstOutputTimeout);
+                firstOutputTimeout = undefined;
+            }
+            if (idleTimeout) {
+                clearTimeout(idleTimeout);
+                idleTimeout = undefined;
+            }
+        };
+        const telemetry = () => ({
+            ...(typeof spawnMs === "number" ? { router_spawn_ms: spawnMs } : {}),
+            ...(typeof firstOutputMs === "number" ? { router_first_output_ms: firstOutputMs } : {}),
+            ...(typeof firstStdoutMs === "number" ? { router_first_stdout_ms: firstStdoutMs } : {}),
+            ...(typeof firstStderrMs === "number" ? { router_first_stderr_ms: firstStderrMs } : {}),
+            router_process_ms: Math.max(0, Date.now() - processStartedAt),
+            router_stdout_bytes: stdoutBytes,
+            router_stderr_bytes: stderrBytes
+        });
+        const finish = (error, output = stdout, stage, timeoutKind) => {
             if (settled) {
                 return;
             }
             settled = true;
-            if (timeout) {
-                clearTimeout(timeout);
+            clearRunTimers();
+            if (abortListener) {
+                signal?.removeEventListener("abort", abortListener);
             }
             if (error) {
-                reject(error);
+                reject(stage ? routerExecutionError(error, telemetry(), stage, timeoutKind) : error);
             }
             else {
-                resolve(output);
+                resolve({ output, telemetry: telemetry() });
             }
         };
+        const terminateThenFinish = (error, output = stdout, stage, timeoutKind) => {
+            if (settled || terminating) {
+                return;
+            }
+            terminating = true;
+            reportProgress("stopping");
+            clearRunTimers();
+            if (abortListener) {
+                signal?.removeEventListener("abort", abortListener);
+                abortListener = undefined;
+            }
+            void terminateProcessTree(child, {
+                processGroup: detached,
+                label: `${routerName} process`,
+                termGraceMs: 250,
+                killWaitMs: 500,
+                pollMs: 20
+            }).then(() => finish(error, output, stage, timeoutKind), (cleanupError) => finish(cleanupError instanceof ProcessTreeCleanupError
+                ? cleanupError
+                : new ProcessTreeCleanupError(`${routerName} cleanup failed: ${errorMessage(cleanupError)}`)));
+        };
+        const timeoutRouter = (kind, limitMs, stage) => {
+            if (settled || terminating) {
+                return;
+            }
+            const detail = summarizeRouterProcessDetail(stderr);
+            const proxyContext = proxyConfigured && !/\bproxy\b|代理/i.test(detail)
+                ? " with proxy configured"
+                : "";
+            const timeoutLabel = kind === "first-output" ? " first output" : kind === "idle" ? " idle" : "";
+            terminateThenFinish(new Error(`${routerName}${timeoutLabel} timed out after ${limitMs}ms${proxyContext}${detail ? `: ${detail}` : ""}`), stdout, stage, kind);
+        };
+        const stopIfOutputLimitExceeded = () => {
+            if (stdoutBytes + stderrBytes <= maxOutputBytes) {
+                return false;
+            }
+            terminateThenFinish(new Error(`${routerName} output exceeded ${maxOutputBytes} byte limit`), stdout, "response");
+            return true;
+        };
+        const resetIdleTimeout = () => {
+            if (idleTimeout) {
+                clearTimeout(idleTimeout);
+                idleTimeout = undefined;
+            }
+            if (idleTimeoutMs <= 0 || (timeoutMs > 0 && idleTimeoutMs >= timeoutMs)) {
+                return;
+            }
+            idleTimeout = setTimeout(() => timeoutRouter("idle", idleTimeoutMs, "streaming"), idleTimeoutMs);
+        };
+        const recordOutputActivity = () => {
+            if (firstOutputTimeout) {
+                clearTimeout(firstOutputTimeout);
+                firstOutputTimeout = undefined;
+            }
+            resetIdleTimeout();
+        };
+        abortListener = () => {
+            terminateThenFinish(cancellationError());
+        };
+        signal?.addEventListener("abort", abortListener, { once: true });
+        child.once("spawn", () => {
+            if (terminating) {
+                return;
+            }
+            spawnMs = Math.max(0, Date.now() - processStartedAt);
+            reportProgress("waiting-output");
+        });
         if (timeoutMs > 0) {
-            timeout = setTimeout(() => {
-                child.kill("SIGTERM");
-                finish(new Error(`Codex router timed out after ${timeoutMs}ms`));
+            totalTimeout = setTimeout(() => {
+                const stage = stdoutBytes + stderrBytes === 0 ? "waiting-output" : "streaming";
+                timeoutRouter("total", timeoutMs, stage);
             }, timeoutMs);
         }
+        if (firstOutputTimeoutMs > 0 && (timeoutMs <= 0 || firstOutputTimeoutMs < timeoutMs)) {
+            firstOutputTimeout = setTimeout(() => timeoutRouter("first-output", firstOutputTimeoutMs, "waiting-output"), firstOutputTimeoutMs);
+        }
         child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString("utf8");
+            if (settled || terminating) {
+                return;
+            }
+            stdoutBytes += chunk.byteLength;
+            firstOutputMs ??= Math.max(0, Date.now() - processStartedAt);
+            firstStdoutMs ??= Math.max(0, Date.now() - processStartedAt);
+            if (stopIfOutputLimitExceeded()) {
+                return;
+            }
+            stdout += stdoutDecoder.write(chunk);
+            recordOutputActivity();
+            reportProgress("receiving-response");
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString("utf8");
+            if (settled || terminating) {
+                return;
+            }
+            stderrBytes += chunk.byteLength;
+            firstOutputMs ??= Math.max(0, Date.now() - processStartedAt);
+            firstStderrMs ??= Math.max(0, Date.now() - processStartedAt);
+            if (stopIfOutputLimitExceeded()) {
+                return;
+            }
+            stderr += stderrDecoder.write(chunk);
+            recordOutputActivity();
+            if (stdoutBytes === 0) {
+                reportProgress("receiving-stderr");
+            }
         });
         child.on("error", (error) => {
-            finish(error);
+            if (terminating) {
+                return;
+            }
+            finish(error, stdout, "spawn");
         });
         child.on("close", (code, signal) => {
+            if (terminating) {
+                return;
+            }
+            stdout += stdoutDecoder.end();
+            stderr += stderrDecoder.end();
             if (code === 0) {
                 finish(null);
                 return;
             }
             const detail = (stderr || stdout).trim();
-            finish(new Error(`Codex router exited with ${signal ? `signal ${signal}` : `code ${code ?? 1}`}${detail ? `: ${detail}` : ""}`));
+            finish(new Error(`${routerName} exited with ${signal ? `signal ${signal}` : `code ${code ?? 1}`}${detail ? `: ${detail}` : ""}`), stdout, "exit");
         });
-        child.stdin.write(prompt);
-        child.stdin.end();
+        child.stdin.once("error", (error) => {
+            terminateThenFinish(new Error(`${routerName} input failed: ${error.message}`), stdout, "input");
+        });
+        if (signal?.aborted) {
+            abortListener();
+        }
+        else {
+            child.stdin.end(prompt);
+        }
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function normalizeRouterRunnerResult(result) {
+    return typeof result === "string"
+        ? { output: result }
+        : { output: result.output, telemetry: normalizeRouterTelemetry(result.telemetry) };
+}
+function normalizeRouterTelemetry(telemetry) {
+    if (!telemetry) {
+        return undefined;
+    }
+    const normalized = {};
+    for (const key of [
+        "router_dispatch_ms",
+        "router_spawn_ms",
+        "router_first_output_ms",
+        "router_first_stdout_ms",
+        "router_first_stderr_ms",
+        "router_process_ms",
+        "router_parse_ms",
+        "router_stdout_bytes",
+        "router_stderr_bytes"
+    ]) {
+        const value = telemetry[key];
+        if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+            continue;
+        }
+        normalized[key] = key.endsWith("_bytes") ? Math.trunc(value) : value;
+    }
+    return normalized;
+}
+function mergeRouterTelemetry(telemetry, additions) {
+    return normalizeRouterTelemetry({
+        ...telemetry,
+        ...Object.fromEntries(Object.entries(additions).filter(([, value]) => value !== undefined))
+    });
+}
+function routerExecutionError(error, telemetry, stage, timeoutKind) {
+    const source = error instanceof Error ? error : new Error(String(error));
+    const wrapped = new Error(source.message);
+    wrapped.name = source.name;
+    wrapped.routerTelemetry = normalizeRouterTelemetry(telemetry);
+    wrapped.routerFailureStage = stage;
+    wrapped.routerTimeoutKind = timeoutKind;
+    return wrapped;
+}
+function routerExecutionErrorContext(error) {
+    if (!(error instanceof Error)) {
+        return {};
+    }
+    const executionError = error;
+    return {
+        ...(executionError.routerTelemetry ? { telemetry: executionError.routerTelemetry } : {}),
+        ...(executionError.routerFailureStage ? { stage: executionError.routerFailureStage } : {}),
+        ...(executionError.routerTimeoutKind ? { timeoutKind: executionError.routerTimeoutKind } : {})
+    };
+}
+function routerEnvironment(configured, env = process.env) {
+    return Object.fromEntries(Object.entries(configured).map(([name, value]) => [
+        name,
+        value.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, variable) => env[variable] ?? "")
+    ]));
+}
+export function routerProxyConfigured(configured, env = process.env) {
+    return routerProxyContext(configured, env).configured;
+}
+export function routerProxyContext(configured, env = process.env) {
+    const configuredEnvironment = routerEnvironment(configured, env);
+    const configuredProxy = preferredProxyEntry(configuredEnvironment);
+    if (configuredProxy) {
+        return {
+            configured: true,
+            source: "router-config",
+            variable: configuredProxy.name,
+            endpoint: safeProxyEndpoint(configuredProxy.value)
+        };
+    }
+    const inheritedProxy = preferredProxyEntry({
+        ...env,
+        ...configuredEnvironment
     });
+    if (!inheritedProxy) {
+        return { configured: false };
+    }
+    return {
+        configured: true,
+        source: "environment",
+        variable: inheritedProxy.name,
+        endpoint: safeProxyEndpoint(inheritedProxy.value)
+    };
+}
+function hasConfiguredProxy(env) {
+    return Object.entries(env).some(([name, value]) => (/^(?:HTTP|HTTPS|ALL)_PROXY$/i.test(name) && Boolean(value?.trim())));
+}
+function preferredProxyEntry(env) {
+    const candidates = Object.entries(env)
+        .filter((entry) => (/^(?:HTTP|HTTPS|ALL)_PROXY$/i.test(entry[0]) && Boolean(entry[1]?.trim())))
+        .sort((left, right) => {
+        const priority = proxyVariablePriority(left[0]) - proxyVariablePriority(right[0]);
+        return priority || left[0].localeCompare(right[0]);
+    });
+    const selected = candidates[0];
+    return selected ? { name: selected[0], value: selected[1].trim() } : null;
+}
+function proxyVariablePriority(name) {
+    const normalized = name.toUpperCase();
+    return normalized === "HTTPS_PROXY" ? 0 : normalized === "ALL_PROXY" ? 1 : 2;
+}
+function safeProxyEndpoint(value) {
+    try {
+        const normalized = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value)
+            ? value
+            : `http://${value}`;
+        const parsed = new URL(normalized);
+        return parsed.host || "custom";
+    }
+    catch {
+        return "custom";
+    }
+}
+function routerProxyRouteFields(proxyContext) {
+    if (!proxyContext) {
+        return {};
+    }
+    if (!proxyContext.configured) {
+        return { proxy_configured: false };
+    }
+    return {
+        proxy_configured: true,
+        proxy_source: proxyContext.source,
+        proxy_variable: proxyContext.variable,
+        proxy_endpoint: proxyContext.endpoint
+    };
+}
+function emitRouterProgress(listener, phase) {
+    try {
+        listener?.({ phase });
+    }
+    catch {
+        // UI progress listeners must never change Router execution semantics.
+    }
+}
+function cancellationError() {
+    const error = new Error("Request cancelled.");
+    error.name = "AbortError";
+    return error;
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
 }
 function buildCodexRouterPrompt(request, config) {
     return [
@@ -94,12 +500,22 @@ function buildCodexRouterPrompt(request, config) {
     ].join("\n");
 }
 function parseCodexRoute(output, config) {
+    const routerName = routerDisplayName(routerCommandLabel(config.router.codex.command));
     const jsonText = extractJsonObject(output);
     const parsed = JSON.parse(jsonText);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Invalid ${routerName} response object`);
+    }
+    const record = parsed;
+    const mode = typeof record.mode === "string" ? record.mode.trim().toLowerCase() : "";
+    if (mode !== "simple" && mode !== "complex") {
+        throw new Error(`Invalid ${routerName} mode`);
+    }
+    const reason = typeof record.reason === "string" ? record.reason.trim() : "";
     return {
-        mode: parsed.mode === "complex" ? "complex" : "simple",
-        reason: parsed.reason || "Codex router decision.",
-        suggested_roles: parsed.mode === "complex" ? ["judge", "actor", "critic"] : [],
+        mode,
+        reason: reason ? sanitizeRouterText(reason) : `${routerName} decision.`,
+        suggested_roles: mode === "complex" ? ["judge", "actor", "critic"] : [],
         judge_engine: config.pairing.judge,
         actor_engine: config.pairing.actor,
         critic_engine: config.pairing.critic
@@ -116,14 +532,14 @@ function extractJsonObject(output) {
     }
     return match[0];
 }
-function fallbackRoute(config) {
+function fallbackRoute(config, routerName) {
     if (config.router.codex.fallback === "simple") {
-        return simpleRoute("Codex router fallback forced simple.", config);
+        return simpleRoute(`${routerName} fallback forced simple.`, config);
     }
     if (config.router.codex.fallback === "complex") {
-        return complexRoute("Codex router fallback forced complex.", config);
+        return complexRoute(`${routerName} fallback forced complex.`, config);
     }
-    return complexRoute("Codex router fallback forced complex.", config);
+    return complexRoute(`${routerName} fallback forced complex.`, config);
 }
 function summarizeRouterError(error) {
     const raw = error instanceof Error ? error.message : String(error);
@@ -131,7 +547,18 @@ function summarizeRouterError(error) {
         .split(/\r?\n/)
         .map((line) => line.trim())
         .find((line) => line && !line.toLowerCase().startsWith("tip:") && !line.toLowerCase().startsWith("usage:"));
-    return (meaningful || "unknown router error").replace(/[.。]+$/u, "");
+    return sanitizeRouterText(meaningful || "unknown router error").replace(/[.。]+$/u, "");
+}
+function summarizeRouterProcessDetail(output) {
+    const lines = output
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const latest = lines.at(-1) ?? "";
+    return sanitizeRouterText(latest).slice(0, 240);
 }
 function simpleRoute(reason, config) {
     return {