@getpaseo/server 0.1.26 → 0.1.28

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

@@ -2,14 +2,14 @@ import { execSync, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
-import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 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 { applyProviderEnv, findExecutable, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
+import { extractCodexTerminalSessionId, nonEmptyString } from "./tool-call-mapper-utils.js";
 const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const CODEX_PROVIDER = "codex";
@@ -87,49 +87,12 @@ function mergeCodexConfiguredDefaults(primary, fallback) {
         thinkingOptionId: primary.thinkingOptionId ?? fallback.thinkingOptionId,
     };
 }
-const CODEX_TARGET_TRIPLE = {
-    linux: { x64: "x86_64-unknown-linux-musl", arm64: "aarch64-unknown-linux-musl" },
-    darwin: { x64: "x86_64-apple-darwin", arm64: "aarch64-apple-darwin" },
-    win32: { x64: "x86_64-pc-windows-msvc", arm64: "aarch64-pc-windows-msvc" },
-};
-const CODEX_PLATFORM_PACKAGE = {
-    "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
-    "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
-    "x86_64-apple-darwin": "@openai/codex-darwin-x64",
-    "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
-    "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
-    "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64",
-};
-function resolveBundledCodexBinary() {
-    const targetTriple = CODEX_TARGET_TRIPLE[process.platform]?.[process.arch];
-    if (!targetTriple) {
-        return null;
-    }
-    const platformPackage = CODEX_PLATFORM_PACKAGE[targetTriple];
-    if (!platformPackage) {
-        return null;
-    }
-    const binaryName = process.platform === "win32" ? "codex.exe" : "codex";
-    try {
-        const require = createRequire(import.meta.url);
-        const packageJsonPath = require.resolve(`${platformPackage}/package.json`);
-        const vendorRoot = path.join(path.dirname(packageJsonPath), "vendor");
-        const binaryPath = path.join(vendorRoot, targetTriple, "codex", binaryName);
-        if (existsSync(binaryPath)) {
-            return binaryPath;
-        }
-    }
-    catch {
-        // Platform package not installed
-    }
-    return null;
-}
 function resolveCodexBinary() {
-    const bundled = resolveBundledCodexBinary();
-    if (bundled) {
-        return bundled;
+    const found = findExecutable("codex");
+    if (found) {
+        return found;
     }
-    throw new Error(`Bundled Codex binary not found for platform ${process.platform}-${process.arch}. Ensure the @openai/codex package and its platform-specific optional dependency are installed.`);
+    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.");
 }
 function resolveCodexLaunchPrefix(runtimeSettings) {
     return resolveProviderCommandPrefix(runtimeSettings?.command, resolveCodexBinary);
@@ -425,7 +388,11 @@ class CodexAppServerClient {
         this.nextId = 1;
         this.disposed = false;
         this.stderrBuffer = "";
+        this.resolveExitPromise = null;
         this.rl = readline.createInterface({ input: child.stdout });
+        this.exitPromise = new Promise((resolve) => {
+            this.resolveExitPromise = resolve;
+        });
         this.rl.on("line", (line) => this.handleLine(line));
         child.stderr.on("data", (chunk) => {
             this.stderrBuffer += chunk.toString();
@@ -444,6 +411,8 @@ class CodexAppServerClient {
             }
             this.pending.clear();
             this.disposed = true;
+            this.resolveExitPromise?.();
+            this.resolveExitPromise = null;
         });
     }
     setNotificationHandler(handler) {
@@ -481,11 +450,13 @@ class CodexAppServerClient {
         this.disposed = true;
         this.rl.close();
         try {
-            this.child.kill();
+            this.child.stdin.end();
         }
         catch {
             // ignore
         }
+        terminateChildProcessTree(this.child);
+        await this.exitPromise;
     }
     async handleLine(line) {
         if (!line.trim())
@@ -539,6 +510,26 @@ class CodexAppServerClient {
         }
     }
 }
+function terminateChildProcessTree(child) {
+    if (child.killed) {
+        return;
+    }
+    if (process.platform !== "win32" && typeof child.pid === "number" && child.pid > 0) {
+        try {
+            process.kill(-child.pid, "SIGTERM");
+            return;
+        }
+        catch {
+            // Fall back to the direct child when no separate process group exists.
+        }
+    }
+    try {
+        child.kill("SIGTERM");
+    }
+    catch {
+        // ignore
+    }
+}
 function toAgentUsage(tokenUsage) {
     if (!tokenUsage || typeof tokenUsage !== "object")
         return undefined;
@@ -869,6 +860,26 @@ function mapCodexPatchNotificationToToolCall(params) {
     }
     return params.running ? toRunningToolCall(mapped) : mapped;
 }
+function mapCodexTerminalInteractionToToolCall(params) {
+    const processId = nonEmptyString(params.processId ?? undefined);
+    const callId = processId
+        ? `terminal-session-${processId}`
+        : nonEmptyString(params.fallbackCallId ?? undefined) ?? "terminal-interaction";
+    const label = nonEmptyString(params.command ?? undefined);
+    return {
+        type: "tool_call",
+        callId,
+        name: "terminal",
+        status: "completed",
+        error: null,
+        detail: {
+            type: "plain_text",
+            ...(label ? { label } : {}),
+            icon: "square_terminal",
+        },
+        ...(processId ? { metadata: { processId } } : {}),
+    };
+}
 function threadItemToTimeline(item, options) {
     if (!item || typeof item !== "object")
         return null;
@@ -1065,6 +1076,21 @@ const CodexEventExecCommandOutputDeltaNotificationSchema = z.object({
     })
         .passthrough(),
 }).passthrough();
+const CodexEventTerminalInteractionNotificationSchema = z.object({
+    msg: z
+        .object({
+        type: z.literal("terminal_interaction"),
+        call_id: z.string().optional(),
+        process_id: z.union([z.string(), z.number()]).optional(),
+        stdin: z.string().optional(),
+    })
+        .passthrough(),
+}).passthrough();
+const ItemCommandExecutionTerminalInteractionNotificationSchema = z.object({
+    itemId: z.string().optional(),
+    processId: z.union([z.string(), z.number()]).optional(),
+    stdin: z.string().optional(),
+}).passthrough();
 const CodexEventPatchApplyBeginNotificationSchema = z.object({
     msg: z
         .object({
@@ -1204,6 +1230,35 @@ const CodexNotificationSchema = z.union([
         method: z.literal("codex/event/exec_command_output_delta"),
         params: z.unknown(),
     }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
+    z.object({
+        method: z.literal("codex/event/terminal_interaction"),
+        params: CodexEventTerminalInteractionNotificationSchema,
+    }).transform(({ params }) => ({
+        kind: "terminal_interaction",
+        source: "codex_event",
+        callId: params.msg.call_id ?? null,
+        processId: typeof params.msg.process_id === "number"
+            ? String(params.msg.process_id)
+            : params.msg.process_id ?? null,
+        stdin: params.msg.stdin ?? null,
+    })),
+    z.object({ method: z.literal("codex/event/terminal_interaction"), params: z.unknown() }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
+    z.object({
+        method: z.literal("item/commandExecution/terminalInteraction"),
+        params: ItemCommandExecutionTerminalInteractionNotificationSchema,
+    }).transform(({ params }) => ({
+        kind: "terminal_interaction",
+        source: "item",
+        callId: params.itemId ?? null,
+        processId: typeof params.processId === "number"
+            ? String(params.processId)
+            : params.processId ?? null,
+        stdin: params.stdin ?? null,
+    })),
+    z.object({
+        method: z.literal("item/commandExecution/terminalInteraction"),
+        params: z.unknown(),
+    }).transform(({ method, params }) => ({ kind: "invalid_payload", method, params })),
     z.object({
         method: z.literal("codex/event/patch_apply_begin"),
         params: CodexEventPatchApplyBeginNotificationSchema,
@@ -1356,6 +1411,8 @@ class CodexAppServerAgentSession {
         this.pendingReasoning = new Map();
         this.pendingCommandOutputDeltas = new Map();
         this.pendingFileChangeOutputDeltas = new Map();
+        this.terminalCommandByProcessId = new Map();
+        this.emittedTerminalInteractionKeys = new Set();
         this.emittedExecCommandStartedCallIds = new Set();
         this.emittedExecCommandCompletedCallIds = new Set();
         this.emittedItemStartedIds = new Set();
@@ -2087,7 +2144,6 @@ class CodexAppServerAgentSession {
             this.pendingCommandOutputDeltas.clear();
             this.pendingFileChangeOutputDeltas.clear();
             this.warnedIncompleteEditToolCallIds.clear();
-            this.eventQueue?.end();
             return;
         }
         if (parsed.kind === "plan_updated") {
@@ -2150,11 +2206,13 @@ class CodexAppServerAgentSession {
         }
         if (parsed.kind === "exec_command_completed") {
             const bufferedOutput = this.consumeOutputDelta(this.pendingCommandOutputDeltas, parsed.callId);
+            const resolvedOutput = parsed.output ?? bufferedOutput;
+            this.rememberTerminalProcessForCommand(parsed.command, resolvedOutput);
             const timelineItem = mapCodexExecNotificationToToolCall({
                 callId: parsed.callId,
                 command: parsed.command,
                 cwd: parsed.cwd ?? this.config.cwd ?? null,
-                output: parsed.output ?? bufferedOutput,
+                output: resolvedOutput,
                 exitCode: parsed.exitCode,
                 success: parsed.success,
                 stderr: parsed.stderr,
@@ -2166,6 +2224,23 @@ class CodexAppServerAgentSession {
             }
             return;
         }
+        if (parsed.kind === "terminal_interaction") {
+            const interactionKey = [
+                parsed.processId ?? "",
+                parsed.stdin ?? "",
+            ].join("\u0000");
+            if (!this.shouldEmitTerminalInteractionKey(interactionKey)) {
+                return;
+            }
+            const timelineItem = mapCodexTerminalInteractionToToolCall({
+                processId: parsed.processId,
+                fallbackCallId: parsed.callId,
+                command: (parsed.processId ? this.terminalCommandByProcessId.get(parsed.processId) : undefined) ??
+                    null,
+            });
+            this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+            return;
+        }
         if (parsed.kind === "patch_apply_started") {
             if (parsed.callId) {
                 this.pendingFileChangeOutputDeltas.delete(parsed.callId);
@@ -2331,6 +2406,30 @@ class CodexAppServerAgentSession {
         store.delete(id);
         return buffered.join("");
     }
+    rememberTerminalProcessForCommand(command, output) {
+        const normalizedCommand = normalizeCodexCommandValue(command);
+        if (!normalizedCommand) {
+            return;
+        }
+        const displayCommand = typeof normalizedCommand === "string"
+            ? normalizedCommand
+            : normalizedCommand.join(" ").trim();
+        if (!displayCommand) {
+            return;
+        }
+        const processId = extractCodexTerminalSessionId(output ?? undefined);
+        if (!processId) {
+            return;
+        }
+        this.terminalCommandByProcessId.set(processId, displayCommand);
+    }
+    shouldEmitTerminalInteractionKey(key) {
+        if (this.emittedTerminalInteractionKeys.has(key)) {
+            return false;
+        }
+        this.emittedTerminalInteractionKeys.add(key);
+        return true;
+    }
     warnOnIncompleteEditToolCall(item, source, payload) {
         if (!isEditToolCallWithoutContent(item)) {
             return;
@@ -2467,6 +2566,7 @@ export class CodexAppServerAgentClient {
             launchPrefix
         }, "Spawning Codex app server");
         return spawn(launchPrefix.command, [...launchPrefix.args, "app-server"], {
+            detached: process.platform !== "win32",
             stdio: ["pipe", "pipe", "pipe"],
             env: applyProviderEnv(process.env, this.runtimeSettings),
         });