doer-agent 0.5.9 → 0.6.0

package/dist/agent.js

@@ -2,22 +2,18 @@ import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { StringCodec } from "nats";
-import { buildAgentSettingsEnvPatch, readAgentModelInstructions, readAgentSettingsConfig, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
+import { buildAgentSettingsEnvPatch, readAgentSettingsConfig, } from "./agent-settings.js";
 import { handleFsRpcMessage } from "./agent-fs-rpc.js";
 import { handleGitRpcMessage } from "./agent-git-rpc.js";
-import { subscribeToCodexAuthRpc } from "./agent-codex-auth-rpc.js";
+import { subscribeToCodexAppRpc } from "./agent-codex-app-rpc.js";
+import { createCodexAppServerManager } from "./codex-app-server-manager.js";
 import { subscribeToDaemonRpc } from "./agent-daemon-rpc.js";
-import { buildDaemonMcpConfigArgs, buildDatabaseMcpConfigArgs, buildManagedCodexArgs, createLocalCodexCliTools, normalizeCodexModel, normalizeShellRpcCodexAuthBundle, spawnManagedCodexCommand, } from "./agent-codex-cli.js";
+import { createLocalCodexCliTools } from "./agent-codex-cli.js";
 import { connectBootstrapWithRetry } from "./agent-jetstream.js";
-import { prepareCommandExecution } from "./agent-run-execution.js";
-import { attachManagedRunProcessLifecycle, createPendingRunSessionTracker } from "./agent-run-lifecycle.js";
-import { claimRunStartSlot, cloneRunTask, getStoredRun, listPersistedRunTasks, persistRunTask, publishImmediateRunEvent, pruneStaleRunsDir, releaseRunStartSlot, removeRunTask, updateRunStartSlotSession, } from "./agent-run-state.js";
 import { runConnectedAgentSession } from "./agent-session-loop.js";
 import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
-import { prepareCodexAuthBundle, sendSignalToPid, sendSignalToTaskProcess, } from "./agent-task-execution.js";
-import { collectSessionJsonlFiles, detectPendingRunSession, findSessionFilePathBySessionId, stopAllSessionWatchers, subscribeToSessionRpc, } from "./agent-session-rpc.js";
-import { handleNonStartRunRpc, normalizeRunRpcRequest, publishRunRpcResponse, } from "./agent-run-rpc.js";
-import { buildAgentCodexAuthRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentRunEventsSubject, buildAgentRunRpcSubject, buildAgentSessionRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, normalizeEnvPatch, filterValidRunImagePaths, normalizeRunImagePaths, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, writeRunStatus, writeRunStream, } from "./agent-runtime-utils.js";
+import { sendSignalToTaskProcess } from "./agent-task-execution.js";
+import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
 import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
 import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
 import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
@@ -27,12 +23,12 @@ const AGENT_PROJECT_DIR = path.join(AGENT_MODULE_DIR, "..");
 const AGENT_PACKAGE_JSON_PATH = path.join(AGENT_PROJECT_DIR, "package.json");
 const HEARTBEAT_INTERVAL_MS = 5_000;
 const HEARTBEAT_FAILURE_THRESHOLD = 3;
+const codexAppEventCodec = StringCodec();
 let activeTaskLogContext = null;
 let workspaceRootOverride = null;
 function resolveWorkspaceRoot() {
     return workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
 }
-const runRpcCodec = StringCodec();
 function writeAgentInfo(message) {
     process.stdout.write(`[doer-agent] ${message}\n`);
     eventPersistenceHelpers.emitAgentMetaLog("info", message);
@@ -49,143 +45,6 @@ function writeAgentInfraError(message) {
         // Keep heartbeat/connectivity failures non-fatal.
     }
 }
-async function updateRunSessionMetadata(task, metadata) {
-    let changed = false;
-    const previousSessionId = task.sessionId;
-    if (!task.sessionId && typeof metadata.sessionId === "string" && metadata.sessionId.trim()) {
-        task.sessionId = metadata.sessionId.trim();
-        changed = true;
-    }
-    if (!task.sessionFilePath && typeof metadata.sessionFilePath === "string" && metadata.sessionFilePath.trim()) {
-        task.sessionFilePath = metadata.sessionFilePath.trim();
-        changed = true;
-    }
-    if (!task.sessionFilePath && task.sessionId) {
-        const resolvedSessionFilePath = await findSessionFilePathBySessionId(resolveWorkspaceRoot(), task.sessionId).catch(() => null);
-        if (resolvedSessionFilePath) {
-            task.sessionFilePath = resolvedSessionFilePath;
-            changed = true;
-        }
-    }
-    if (!changed) {
-        return;
-    }
-    task.updatedAt = formatLocalTimestamp();
-    await persistRunTask(resolveWorkspaceRoot(), task).catch(() => undefined);
-    if (metadata.nc) {
-        publishImmediateRunEvent({
-            nc: metadata.nc,
-            userId: task.userId,
-            task,
-            buildRunEventsSubject: buildAgentRunEventsSubject,
-        });
-    }
-    if (!previousSessionId && task.sessionId) {
-        await updateRunStartSlotSession({
-            workspaceRoot: resolveWorkspaceRoot(),
-            runId: task.id,
-            previousSessionId,
-            sessionId: task.sessionId,
-            formatTimestamp: formatLocalTimestamp,
-        }).catch(() => undefined);
-    }
-}
-async function startManagedRun(args) {
-    const prepared = await prepareCommandExecution({
-        cwd: args.cwd,
-        userId: args.userId,
-        taskId: args.runId,
-        codexAuthBundle: args.codexAuthBundle,
-        runtimeEnvPatch: args.runtimeEnvPatch,
-        agentProjectDir: AGENT_PROJECT_DIR,
-        resolveShellPath: runtimeEnvHelpers.resolveShellPath,
-        resolveTaskWorkspace: runtimeEnvHelpers.resolveTaskWorkspace,
-        resolveCodexHomePath: runtimeEnvHelpers.resolveCodexHomePath,
-        prepareCodexAuthBundle,
-        readAgentSettingsConfig,
-        resolveWorkspaceRoot,
-        buildAgentSettingsEnvPatch,
-        prepareTaskGitEnv: runtimeEnvHelpers.prepareTaskGitEnv,
-    });
-    const child = spawnManagedCodexCommand({
-        codexArgs: args.codexArgs,
-        taskWorkspace: prepared.taskWorkspace,
-        env: prepared.env,
-        agentToken: args.agentToken,
-    });
-    const now = formatLocalTimestamp();
-    const task = {
-        id: args.runId,
-        userId: args.userId,
-        agentId: args.agentId,
-        processPid: typeof child.pid === "number" ? child.pid : null,
-        sessionId: typeof args.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : null,
-        sessionFilePath: null,
-        status: "running",
-        cancelRequested: false,
-        resultExitCode: null,
-        resultSignal: null,
-        error: null,
-        createdAt: now,
-        updatedAt: now,
-        startedAt: now,
-        finishedAt: null,
-    };
-    let pendingSessionPollClosed = false;
-    const knownPendingSessionFiles = new Set();
-    const pendingSessionTracker = createPendingRunSessionTracker({
-        task,
-        detectPendingRunSession: async () => detectPendingRunSession(resolveWorkspaceRoot(), knownPendingSessionFiles),
-        updateRunSessionMetadata: async (metadata) => updateRunSessionMetadata(task, { ...metadata, nc: args.nc }),
-    });
-    const stopPendingSessionPoll = () => {
-        pendingSessionPollClosed = true;
-        pendingSessionTracker.stop();
-    };
-    const pollPendingSession = async () => {
-        if (pendingSessionPollClosed) {
-            stopPendingSessionPoll();
-            return;
-        }
-        await pendingSessionTracker.poll();
-    };
-    if (!task.sessionId) {
-        const existingFiles = await collectSessionJsonlFiles(resolveWorkspaceRoot()).catch(() => []);
-        for (const file of existingFiles) {
-            knownPendingSessionFiles.add(file.filePath);
-        }
-        pendingSessionTracker.start();
-    }
-    child.stdout.on("data", (chunk) => writeRunStream(task.id, "stdout", chunk));
-    child.stderr.on("data", (chunk) => writeRunStream(task.id, "stderr", chunk));
-    attachManagedRunProcessLifecycle({
-        child,
-        task,
-        nc: args.nc,
-        stopPendingSessionPoll,
-        getStoredRun: (runId) => getStoredRun(resolveWorkspaceRoot(), runId),
-        publishImmediateRunEvent: (eventArgs) => publishImmediateRunEvent({
-            ...eventArgs,
-            buildRunEventsSubject: buildAgentRunEventsSubject,
-        }),
-        removeRunTask: (runId) => removeRunTask(resolveWorkspaceRoot(), runId),
-        releaseRunStartSlot: ({ runId, sessionId }) => releaseRunStartSlot({
-            workspaceRoot: resolveWorkspaceRoot(),
-            runId,
-            sessionId,
-        }),
-        codexAuthCleanup: prepared.codexAuthCleanup,
-        writeRunStatus,
-        formatTimestamp: formatLocalTimestamp,
-    });
-    void persistRunTask(resolveWorkspaceRoot(), task).catch(() => undefined);
-    publishImmediateRunEvent({ nc: args.nc, userId: task.userId, task, buildRunEventsSubject: buildAgentRunEventsSubject });
-    writeRunStatus(task.id, `started requestId=${args.requestId} cwd=${prepared.taskWorkspace}`);
-    if (!task.sessionId) {
-        void pollPendingSession();
-    }
-    return cloneRunTask(task);
-}
 function subscribeToSettingsRpc(args) {
     const subject = buildAgentSettingsRpcSubject(args.userId, args.agentId);
     args.jetstream.nc.subscribe(subject, {
@@ -200,6 +59,7 @@ function subscribeToSettingsRpc(args) {
                 nc: args.jetstream.nc,
                 agentId: args.agentId,
                 workspaceRoot: resolveWorkspaceRoot(),
+                onSettingsUpdated: () => args.codexAppServerManager.restart("settings updated"),
                 onError: writeAgentError,
             });
         },
@@ -225,140 +85,6 @@ function subscribeToGitRpc(args) {
     });
     writeAgentInfo(`git rpc subscribed subject=${subject}`);
 }
-async function handleRunRpcMessage(args) {
-    let requestId = "unknown";
-    let responseSubject = "";
-    try {
-        const payload = JSON.parse(runRpcCodec.decode(args.msg.data));
-        const request = normalizeRunRpcRequest({
-            request: payload,
-            agentId: args.agentId,
-            normalizeModel: normalizeCodexModel,
-            normalizeImagePaths: normalizeRunImagePaths,
-            normalizeEnvPatch,
-            normalizeCodexAuthBundle: normalizeShellRpcCodexAuthBundle,
-        });
-        requestId = request.requestId;
-        responseSubject = request.responseSubject;
-        if (request.action === "start") {
-            const runId = request.runId ?? requestId;
-            await claimRunStartSlot({
-                workspaceRoot: resolveWorkspaceRoot(),
-                runId,
-                sessionId: request.sessionId,
-                formatTimestamp: formatLocalTimestamp,
-            });
-            try {
-                const workspaceRoot = resolveWorkspaceRoot();
-                const localAgentSettings = await readAgentSettingsConfig({ workspaceRoot });
-                const customInstructions = await readAgentModelInstructions(workspaceRoot);
-                const validImagePaths = await filterValidRunImagePaths({
-                    workspaceRoot,
-                    imagePaths: request.imagePaths,
-                    onInvalidImage: (imagePath, reason) => {
-                        writeRunStatus(runId, `skipping invalid image path=${imagePath} reason=${reason}`);
-                    },
-                });
-                const task = await startManagedRun({
-                    requestId,
-                    runId,
-                    serverBaseUrl: args.serverBaseUrl,
-                    userId: args.userId,
-                    agentId: args.agentId,
-                    nc: args.jetstream.nc,
-                    sessionId: request.sessionId,
-                    codexArgs: buildManagedCodexArgs({
-                        prompt: request.prompt ?? "",
-                        imagePaths: validImagePaths,
-                        sessionId: request.sessionId,
-                        model: request.model,
-                        personality: localAgentSettings.general.personality,
-                        modelInstructionsFile: customInstructions ? resolveAgentModelInstructionsFilePath(workspaceRoot) : null,
-                        configOverrides: [
-                            ...buildDaemonMcpConfigArgs({
-                                agentProjectDir: AGENT_PROJECT_DIR,
-                                workspaceRoot,
-                            }),
-                            ...buildDatabaseMcpConfigArgs({
-                                agentProjectDir: AGENT_PROJECT_DIR,
-                                workspaceRoot,
-                            }),
-                            "--config",
-                            `features.computer_use=${localAgentSettings.codex.computerUseEnabled ? "true" : "false"}`,
-                            "--config",
-                            `features.browser_use=${localAgentSettings.codex.browserUseEnabled ? "true" : "false"}`,
-                        ],
-                    }),
-                    cwd: request.cwd,
-                    runtimeEnvPatch: request.runtimeEnvPatch,
-                    codexAuthBundle: request.codexAuthBundle,
-                    agentToken: args.agentToken,
-                });
-                publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
-            }
-            catch (error) {
-                await releaseRunStartSlot({
-                    workspaceRoot: resolveWorkspaceRoot(),
-                    runId,
-                    sessionId: request.sessionId,
-                }).catch(() => undefined);
-                throw error;
-            }
-            return;
-        }
-        await handleNonStartRunRpc({
-            request,
-            nc: args.jetstream.nc,
-            userId: args.userId,
-            agentId: args.agentId,
-            listPersistedRunTasks: async () => listPersistedRunTasks(resolveWorkspaceRoot()),
-            cloneRunTask,
-            getStoredRun: async (runId) => getStoredRun(resolveWorkspaceRoot(), runId),
-            persistRunTask: async (task) => persistRunTask(resolveWorkspaceRoot(), task),
-            publishImmediateRunEvent: (task) => publishImmediateRunEvent({
-                nc: args.jetstream.nc,
-                userId: task.userId,
-                task,
-                buildRunEventsSubject: buildAgentRunEventsSubject,
-            }),
-            writeRunStatus,
-            sendSignalToPid,
-            formatTimestamp: formatLocalTimestamp,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (responseSubject) {
-            publishRunRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: false, error: message },
-            });
-        }
-        writeAgentError(`run rpc failed requestId=${requestId} error=${message}`);
-    }
-}
-function subscribeToRunRpc(args) {
-    const subject = buildAgentRunRpcSubject(args.userId, args.agentId);
-    args.jetstream.nc.subscribe(subject, {
-        callback: (error, msg) => {
-            if (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`run rpc subscription error: ${message}`);
-                return;
-            }
-            void handleRunRpcMessage({
-                msg,
-                jetstream: args.jetstream,
-                serverBaseUrl: args.serverBaseUrl,
-                userId: args.userId,
-                agentId: args.agentId,
-                agentToken: args.agentToken,
-            });
-        },
-    });
-    writeAgentInfo(`run rpc subscribed subject=${subject}`);
-}
 function subscribeToFsRpc(args) {
     const subject = buildAgentFsRpcSubject(args.userId, args.agentId);
     args.jetstream.nc.subscribe(subject, {
@@ -380,6 +106,20 @@ function subscribeToFsRpc(args) {
     });
     writeAgentInfo(`fs rpc subscribed subject=${subject}`);
 }
+function formatCodexAppNotificationParams(params) {
+    if (params === undefined) {
+        return "undefined";
+    }
+    try {
+        return JSON.stringify(params);
+    }
+    catch {
+        return String(params);
+    }
+}
+function shouldForwardCodexAppNotification(method) {
+    return method !== "item/agentMessage/delta";
+}
 const runtimeEnvHelpers = createRuntimeEnvHelpers({
     resolveWorkspaceRoot,
     agentProjectDir: AGENT_PROJECT_DIR,
@@ -421,8 +161,6 @@ async function main() {
     process.env.WORKSPACE = startupWorkspaceRoot;
     process.env.CODEX_HOME = path.join(startupWorkspaceRoot, ".codex");
     await mkdir(process.env.CODEX_HOME, { recursive: true }).catch(() => undefined);
-    // Preserve run state for processes that are still alive after an agent restart.
-    await pruneStaleRunsDir(resolveWorkspaceRoot());
     const serverBaseUrlRaw = resolveArgOrEnv(args, ["server", "url"], ["DOER_AGENT_SERVER"], DEFAULT_SERVER_BASE_URL);
     const requestedServerBaseUrl = serverBaseUrlRaw.replace(/\/$/, "");
     const serverBaseUrl = resolveContainerReachableServerBaseUrl(requestedServerBaseUrl);
@@ -481,6 +219,26 @@ async function main() {
             formatTimestamp: formatLocalTimestamp,
             heartbeatAgentSession: heartbeatSession,
             subscribeAll: () => {
+                const codexAppServerManager = createCodexAppServerManager({
+                    workspaceRoot: resolveWorkspaceRoot(),
+                    resolveCodexHomePath: runtimeEnvHelpers.resolveCodexHomePath,
+                    readAgentSettingsConfig,
+                    onLog: writeAgentInfo,
+                    onNotification: (method, params) => {
+                        if (!shouldForwardCodexAppNotification(method)) {
+                            return;
+                        }
+                        writeAgentInfo(`codex app-server notification method=${method} params=${formatCodexAppNotificationParams(params)}`);
+                        const event = {
+                            type: "codex.app.notification",
+                            agentId: initialAgentId,
+                            method,
+                            params,
+                            emittedAt: new Date().toISOString(),
+                        };
+                        jetstream.nc.publish(buildAgentCodexAppEventsSubject(userId, initialAgentId), codexAppEventCodec.encode(JSON.stringify(event)));
+                    },
+                });
                 subscribeToFsRpc({
                     jetstream,
                     serverBaseUrl,
@@ -499,27 +257,12 @@ async function main() {
                     onInfo: writeAgentInfo,
                     onError: writeAgentError,
                 });
-                subscribeToSessionRpc({
-                    nc: jetstream.nc,
-                    subject: buildAgentSessionRpcSubject(userId, initialAgentId),
-                    agentId: initialAgentId,
-                    workspaceRoot: resolveWorkspaceRoot(),
-                    onInfo: writeAgentInfo,
-                    onError: writeAgentError,
-                    formatTimestamp: formatLocalTimestamp,
-                });
-                subscribeToCodexAuthRpc({
+                subscribeToCodexAppRpc({
                     nc: jetstream.nc,
-                    subject: buildAgentCodexAuthRpcSubject(userId, initialAgentId),
+                    subject: buildAgentCodexAppRpcSubject(userId, initialAgentId),
+                    eventsSubject: buildAgentCodexAppEventsSubject(userId, initialAgentId),
                     agentId: initialAgentId,
-                    workspaceRoot: resolveWorkspaceRoot(),
-                    buildLocalCodexCliCommand: localCodexCliTools.buildLocalCodexCliCommand,
-                    resolveShellPath: runtimeEnvHelpers.resolveShellPath,
-                    resolveCodexHomePath: runtimeEnvHelpers.resolveCodexHomePath,
-                    runLocalCodexCli: localCodexCliTools.runLocalCodexCli,
-                    runLocalCodexCliWithInput: localCodexCliTools.runLocalCodexCliWithInput,
-                    sendSignalToTaskProcess,
-                    stripAnsi: localCodexCliTools.stripAnsi,
+                    manager: codexAppServerManager,
                     onInfo: writeAgentInfo,
                     onError: writeAgentError,
                 });
@@ -527,6 +270,7 @@ async function main() {
                     jetstream,
                     userId,
                     agentId: initialAgentId,
+                    codexAppServerManager,
                 });
                 subscribeToGitRpc({
                     jetstream,
@@ -546,15 +290,7 @@ async function main() {
                     onInfo: writeAgentInfo,
                     onError: writeAgentError,
                 });
-                subscribeToRunRpc({
-                    jetstream,
-                    serverBaseUrl,
-                    userId,
-                    agentId: initialAgentId,
-                    agentToken,
-                });
             },
-            stopAllSessionWatchers: () => stopAllSessionWatchers({ onError: writeAgentError }),
             onInfraError: writeAgentInfraError,
             sleep,
         });

package/dist/codex-app-server-client.js

@@ -0,0 +1,148 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+export class CodexAppServerClient {
+    options;
+    child = null;
+    stdoutLines = null;
+    nextRequestId = 1;
+    startPromise = null;
+    pending = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async request(method, params) {
+        await this.start();
+        return await this.requestStarted(method, params);
+    }
+    async notify(method, params) {
+        await this.start();
+        const child = this.child;
+        if (!child || child.killed) {
+            throw new Error("Codex app-server is not running");
+        }
+        const payload = params === undefined ? { method } : { method, params };
+        child.stdin.write(`${JSON.stringify(payload)}\n`, "utf8");
+    }
+    async stop() {
+        const child = this.child;
+        if (!child || child.killed) {
+            return;
+        }
+        child.kill("SIGTERM");
+    }
+    async start() {
+        if (this.child && !this.child.killed) {
+            return;
+        }
+        if (this.startPromise) {
+            return await this.startPromise;
+        }
+        this.startPromise = this.startInner();
+        try {
+            await this.startPromise;
+        }
+        finally {
+            this.startPromise = null;
+        }
+    }
+    async startInner() {
+        this.child = spawn("codex", this.options.args, {
+            cwd: this.options.cwd,
+            env: this.options.env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child.stdout.setEncoding("utf8");
+        this.child.stderr.setEncoding("utf8");
+        this.stdoutLines = createInterface({ input: this.child.stdout });
+        this.stdoutLines.on("line", (line) => this.handleLine(line));
+        this.child.stderr.on("data", (chunk) => {
+            const message = chunk.trim();
+            if (message) {
+                this.options.onLog?.(`[codex-app-server] ${message}`);
+            }
+        });
+        this.child.once("exit", (code, signal) => {
+            this.options.onLog?.(`[codex-app-server] exited code=${code ?? "null"} signal=${signal ?? "null"}`);
+            this.rejectPending(new Error("Codex app-server exited"));
+            this.stdoutLines?.close();
+            this.stdoutLines = null;
+            this.child = null;
+        });
+        await this.requestStarted("initialize", {
+            clientInfo: {
+                name: "doer-agent",
+                title: "Doer Agent",
+                version: "0.5.9",
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        await this.notify("initialized");
+    }
+    async requestStarted(method, params) {
+        const child = this.child;
+        if (!child || child.killed) {
+            throw new Error("Codex app-server is not running");
+        }
+        const id = this.nextRequestId++;
+        const payload = params === undefined ? { id, method } : { id, method, params };
+        const timeoutMs = this.options.requestTimeoutMs ?? 30_000;
+        return await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Timed out waiting for Codex app-server response: ${method}`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            child.stdin.write(`${JSON.stringify(payload)}\n`, "utf8", (error) => {
+                if (!error) {
+                    return;
+                }
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            });
+        });
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            this.options.onLog?.("[codex-app-server] ignored malformed JSON line");
+            return;
+        }
+        if (!message || typeof message !== "object" || Array.isArray(message)) {
+            return;
+        }
+        const record = message;
+        if (record.id !== undefined) {
+            const id = Number(record.id);
+            const pending = Number.isInteger(id) ? this.pending.get(id) : null;
+            if (!pending) {
+                return;
+            }
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            if (record.error && typeof record.error === "object" && !Array.isArray(record.error)) {
+                const error = record.error;
+                pending.reject(new Error(typeof error.message === "string" ? error.message : "Codex app-server request failed"));
+            }
+            else {
+                pending.resolve(record.result);
+            }
+            return;
+        }
+        if (typeof record.method === "string") {
+            this.options.onNotification?.(record.method, record.params);
+        }
+    }
+    rejectPending(error) {
+        for (const [id, pending] of this.pending) {
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+    }
+}