@seawork/server 1.0.21 → 1.0.22-rc.2

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -1,23 +1,22 @@
-import { execFile, execSync } from "node:child_process";
+import { execSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync, realpathSync } from "node:fs";
+import { realpathSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
-import { promisify } from "node:util";
 import { z } from "zod";
 import { loadCodexPersistedTimeline } from "./codex-rollout-timeline.js";
 import { mapCodexRolloutToolCall, mapCodexToolCallFromThreadItem, } from "./codex/tool-call-mapper.js";
 import { applyProviderEnv, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { resolveElectronNodeRuntime } from "../../../utils/electron-helper.js";
 import { getLatencyProxyUrlSync } from "../../latency-proxy.js";
-import { findExecutable } from "../../../utils/executable.js";
+import { selectCodexBinary, selectEffectiveCodexBinary, verifyCommandAvailable, } from "./codex-binary-resolver.js";
 import { getSeaworkModels } from "./seawork-models.js";
 import { spawnProcess } from "../../../utils/spawn.js";
 import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
 import { buildCodexFeatures, codexModelSupportsFastMode } from "./codex-feature-definitions.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { collectStdout, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 // issue #259: window after turn/interrupt during which the next turn/start
@@ -39,7 +38,6 @@ const CODEX_APP_SERVER_CAPABILITIES = {
     supportsReasoningStream: true,
     supportsToolInvocations: true,
 };
-const execFileAsync = promisify(execFile);
 const CODEX_MODES = [
     {
         id: "auto",
@@ -209,15 +207,17 @@ function mergeCodexConfiguredDefaults(primary, fallback) {
         thinkingOptionId: primary.thinkingOptionId ?? fallback.thinkingOptionId,
     };
 }
-async function resolveCodexBinary() {
-    const found = await findExecutable("codex");
-    if (found) {
-        return found;
-    }
-    throw new Error("Codex binary not found. Install the Codex CLI (https://github.com/openai/codex) and ensure it is available in your shell PATH.");
+async function resolveCodexBinary(runtimeSettings, logger) {
+    // Pass the same env daemon would spawn with so default/append resolution
+    // honors `agents.providers.codex.env.PATH` — matches actual launch
+    // behavior. `command.replace` bypasses this (resolveProviderCommandPrefix
+    // takes argv[0] directly).
+    const spawnEnv = buildCodexAppServerEnv(runtimeSettings);
+    const selection = await selectCodexBinary({ logger, spawnEnv });
+    return selection.binary;
 }
-async function resolveCodexLaunchPrefix(runtimeSettings) {
-    return resolveProviderCommandPrefix(runtimeSettings?.command, resolveCodexBinary);
+async function resolveCodexLaunchPrefix(runtimeSettings, logger) {
+    return resolveProviderCommandPrefix(runtimeSettings?.command, () => resolveCodexBinary(runtimeSettings, logger));
 }
 function resolveCodexHomeDir() {
     return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
@@ -3594,7 +3594,7 @@ export class CodexAppServerAgentClient {
         this.capabilities = CODEX_APP_SERVER_CAPABILITIES;
     }
     async spawnAppServer(options) {
-        const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings);
+        const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings, this.logger);
         this.logger.trace({
             launchPrefix,
         }, "Spawning Codex app server");
@@ -3664,7 +3664,7 @@ export class CodexAppServerAgentClient {
         let binaryPath = null;
         let probeError = null;
         try {
-            const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings);
+            const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings, this.logger);
             binaryPath = launchPrefix.command;
             let command = launchPrefix.command;
             let args = [...launchPrefix.args, "--version"];
@@ -3682,10 +3682,11 @@ export class CodexAppServerAgentClient {
                     args = [resolvedCommand, ...args];
                 }
             }
-            const { stdout } = await execFileAsync(command, args, {
-                encoding: "utf8",
-                timeout: 5000,
-                windowsHide: true,
+            // Route via spawnProcess so Windows `.cmd`/`.bat` (e.g. corp shims
+            // pointed at by `agents.providers.codex.command`) launch correctly
+            // — execFileAsync can't spawn batch wrappers directly.
+            const stdout = await collectStdout(command, args, {
+                timeoutMs: 5000,
                 env: {
                     ...buildCodexAppServerEnv(this.runtimeSettings),
                     ...(command === electronRuntime ? { ELECTRON_RUN_AS_NODE: "1" } : {}),
@@ -3701,9 +3702,13 @@ export class CodexAppServerAgentClient {
             probeError = err instanceof Error ? err.message : String(err);
         }
         try {
-            const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings);
+            const launchPrefix = await resolveCodexLaunchPrefix(this.runtimeSettings, this.logger);
             binaryPath = binaryPath ?? launchPrefix.command;
-            const version = await resolveBinaryVersion(launchPrefix.command);
+            // Pass through the full launch args AND the same env daemon would
+            // spawn with, so wrapper overrides resolve via provider env.PATH
+            // and the version probe stays consistent with the actual launch
+            // path (the primary attempt above already does this).
+            const version = await resolveBinaryVersion(launchPrefix.command, [...launchPrefix.args, "--version"], buildCodexAppServerEnv(this.runtimeSettings));
             return { version, binaryPath, probeError };
         }
         catch (err) {
@@ -4001,26 +4006,88 @@ export class CodexAppServerAgentClient {
         return getSeaworkModels("codex");
     }
     async isAvailable() {
-        const command = this.runtimeSettings?.command;
-        if (command?.mode === "replace") {
-            return existsSync(command.argv[0]);
+        try {
+            // Same selector daemon spawn uses, so UI availability matches actual
+            // launch behavior. We always run `verifyCommandAvailable` against
+            // the resolved binary — without that check `install-state-stale`
+            // (recorded path that's now missing/broken) and unhealthy PATH
+            // candidates would still report Available even though daemon spawn
+            // would fail immediately. The bare-name semantics of
+            // `verifyCommandAvailable` cover `command-override` cases like
+            // `argv=["docker", ...]` while still rejecting paths that don't
+            // exist or aren't executable.
+            //
+            // `installStateRejected` is set by the resolver when an unhealthy
+            // recorded install OR an unhealthy PATH candidate was selected as
+            // a last-resort. Trust the probe verdict and report unavailable
+            // rather than letting `verifyCommandAvailable` (file-existence
+            // only) accept a fake/stale shim that just happens to be
+            // launchable. Diagnostic still surfaces the path + reason for
+            // troubleshooting.
+            const spawnEnv = buildCodexAppServerEnv(this.runtimeSettings);
+            const selection = await selectEffectiveCodexBinary(this.runtimeSettings, { spawnEnv });
+            if (selection.installStateRejected) {
+                return false;
+            }
+            return await verifyCommandAvailable(selection.binary, { spawnEnv });
+        }
+        catch {
+            return false;
         }
-        return (await findExecutable("codex")) !== null;
     }
     async getDiagnostic() {
         try {
             const available = await this.isAvailable();
-            const resolvedBinary = await findExecutable("codex");
+            let resolvedBinary = null;
+            let selectionSource = "unknown";
+            let installStateRejected;
+            try {
+                const selection = await selectEffectiveCodexBinary(this.runtimeSettings, {
+                    spawnEnv: buildCodexAppServerEnv(this.runtimeSettings),
+                });
+                resolvedBinary = selection.binary;
+                selectionSource = selection.source;
+                installStateRejected = selection.installStateRejected;
+            }
+            catch {
+                // Throws only when there's no override AND neither install-state
+                // nor PATH has anything; leave resolvedBinary=null.
+            }
             const entries = [
                 {
                     label: "Binary",
                     value: resolvedBinary ?? "not found",
                 },
                 {
-                    label: "Version",
-                    value: resolvedBinary ? await resolveBinaryVersion(resolvedBinary) : "unknown",
+                    label: "Source",
+                    value: selectionSource,
                 },
             ];
+            if (installStateRejected) {
+                entries.push({
+                    label: "Install-state rejected",
+                    value: installStateRejected,
+                });
+            }
+            // Version probe must run the FULL daemon command (program + args),
+            // not just the program. For a wrapper override like
+            // `["docker","run","--rm","my-wrapper","codex"]` the version of
+            // interest is codex's, not docker's. `resolveCodexLaunchPrefix` is
+            // already the source of truth for what spawn uses, so reuse it.
+            let versionValue = "unknown";
+            if (resolvedBinary) {
+                try {
+                    const { command, args } = await resolveCodexLaunchPrefix(this.runtimeSettings, this.logger);
+                    // Same env daemon would spawn with so `env.PATH` overrides
+                    // resolve `command` (e.g. "docker") the same way.
+                    versionValue = await resolveBinaryVersion(command, [...args, "--version"], buildCodexAppServerEnv(this.runtimeSettings));
+                }
+                catch {
+                    // Resolver shouldn't fail here if we got resolvedBinary above,
+                    // but stay defensive — keep "unknown".
+                }
+            }
+            entries.push({ label: "Version", value: versionValue });
             let status = formatDiagnosticStatus(available);
             if (!available) {
                 entries.push({ label: "Models", value: "Not checked" });