@getpaseo/server 0.1.25 → 0.1.27

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

@@ -1,5 +1,6 @@
 import { execSync, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -7,7 +8,8 @@ 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, isProviderCommandAvailable, 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";
@@ -86,16 +88,11 @@ function mergeCodexConfiguredDefaults(primary, fallback) {
     };
 }
 function resolveCodexBinary() {
-    try {
-        const codexPath = execSync("which codex", { encoding: "utf8" }).trim();
-        if (codexPath) {
-            return codexPath;
-        }
-    }
-    catch {
-        // Fall through to error
+    const found = findExecutable("codex");
+    if (found) {
+        return found;
     }
-    throw new Error("Codex CLI not found. Please install codex globally: npm install -g @openai/codex");
+    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);
@@ -835,6 +832,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;
@@ -1031,6 +1048,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({
@@ -1170,6 +1202,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,
@@ -1322,6 +1383,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();
@@ -2053,7 +2116,6 @@ class CodexAppServerAgentSession {
             this.pendingCommandOutputDeltas.clear();
             this.pendingFileChangeOutputDeltas.clear();
             this.warnedIncompleteEditToolCallIds.clear();
-            this.eventQueue?.end();
             return;
         }
         if (parsed.kind === "plan_updated") {
@@ -2116,11 +2178,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,
@@ -2132,6 +2196,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);
@@ -2297,6 +2378,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;
@@ -2429,6 +2534,9 @@ export class CodexAppServerAgentClient {
     }
     spawnAppServer() {
         const launchPrefix = resolveCodexLaunchPrefix(this.runtimeSettings);
+        this.logger.trace({
+            launchPrefix
+        }, "Spawning Codex app server");
         return spawn(launchPrefix.command, [...launchPrefix.args, "app-server"], {
             stdio: ["pipe", "pipe", "pipe"],
             env: applyProviderEnv(process.env, this.runtimeSettings),
@@ -2595,7 +2703,11 @@ export class CodexAppServerAgentClient {
         }
     }
     async isAvailable() {
-        return isProviderCommandAvailable(this.runtimeSettings?.command, resolveCodexBinary);
+        const command = this.runtimeSettings?.command;
+        if (command?.mode === "replace") {
+            return existsSync(command.argv[0]);
+        }
+        return true;
     }
 }
 //# sourceMappingURL=codex-app-server-agent.js.map