doer-agent 0.9.7 → 0.9.8

package/dist/agent-runtime-utils.js

@@ -28,9 +28,6 @@ export function buildAgentNotesRpcSubject(userId, agentId) {
 export function buildAgentNotesAiRpcSubject(userId, agentId) {
     return `doer.agent.notes.ai.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
-export function buildAgentThreadTagsRpcSubject(userId, agentId) {
-    return `doer.agent.thread.tags.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
 export function buildAgentDaemonRpcSubject(userId, agentId) {
     return `doer.agent.daemon.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }

package/dist/agent.js

@@ -7,7 +7,6 @@ import { handleFsRpcMessage } from "./agent-fs-rpc.js";
 import { handleGitRpcMessage } from "./agent-git-rpc.js";
 import { handleNotesRpcMessage } from "./agent-notes-rpc.js";
 import { subscribeToNotesAiRpc } from "./agent-notes-ai-rpc.js";
-import { subscribeToThreadTagsRpc } from "./agent-thread-tags-rpc.js";
 import { ensureBundledDoerSkills } from "./agent-bundled-skills.js";
 import { subscribeToCodexAppRpc } from "./agent-codex-app-rpc.js";
 import { createCodexAppServerManager } from "./codex-app-server-manager.js";
@@ -19,7 +18,7 @@ import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
 import { subscribeToMaintenanceRpc } from "./agent-maintenance-rpc.js";
 import { subscribeToHttpProxyRpc } from "./agent-http-proxy-rpc.js";
 import { sendSignalToTaskProcess } from "./agent-task-execution.js";
-import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentNotesRpcSubject, buildAgentNotesAiRpcSubject, buildAgentThreadTagsRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
+import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentNotesRpcSubject, buildAgentNotesAiRpcSubject, 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";
@@ -310,15 +309,6 @@ async function main() {
                     agentId: initialAgentId,
                     codexAppServerManager,
                 });
-                subscribeToThreadTagsRpc({
-                    nc: jetstream.nc,
-                    subject: buildAgentThreadTagsRpcSubject(userId, initialAgentId),
-                    agentId: initialAgentId,
-                    workspaceRoot: resolveWorkspaceRoot(),
-                    manager: codexAppServerManager,
-                    onInfo: writeAgentInfo,
-                    onError: writeAgentError,
-                });
                 subscribeToDaemonRpc({
                     nc: jetstream.nc,
                     subject: buildAgentDaemonRpcSubject(userId, initialAgentId),

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

@@ -12,6 +12,16 @@ function resolveCodexCliBinPath() {
     }
     return path.resolve(path.dirname(packageJsonPath), codexBin);
 }
+export class CodexAppServerRequestError extends Error {
+    code;
+    data;
+    constructor(message, code = -32603, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "CodexAppServerRequestError";
+    }
+}
 export class CodexAppServerClient {
     options;
     child = null;
@@ -20,10 +30,15 @@ export class CodexAppServerClient {
     startPromise = null;
     stopPromise = null;
     pending = new Map();
+    activeTurns = new Map();
+    activeTurnsChanged = new Set();
     constructor(options) {
         this.options = options;
     }
     async request(method, params, timeoutMs) {
+        if (this.stopPromise) {
+            throw new Error("Codex app-server is stopping");
+        }
         await this.start();
         return await this.requestStarted(method, params, timeoutMs);
     }
@@ -68,7 +83,9 @@ export class CodexAppServerClient {
         }
     }
     async startInner() {
-        this.child = spawn(process.execPath, [resolveCodexCliBinPath(), ...this.options.args], {
+        const executable = this.options.executable ?? process.execPath;
+        const executableArgs = this.options.executableArgs ?? [resolveCodexCliBinPath()];
+        this.child = spawn(executable, [...executableArgs, ...this.options.args], {
             cwd: this.options.cwd,
             detached: process.platform !== "win32",
             env: this.options.env,
@@ -91,6 +108,8 @@ export class CodexAppServerClient {
             removeExitHooks();
             this.signalProcessGroup(childPid, "SIGTERM");
             this.rejectPending(new Error("Codex app-server exited"));
+            this.activeTurns.clear();
+            this.notifyActiveTurnsChanged();
             this.stdoutLines?.close();
             this.stdoutLines = null;
             this.child = null;
@@ -144,6 +163,16 @@ export class CodexAppServerClient {
             return;
         }
         const record = message;
+        if (typeof record.method === "string") {
+            if (this.isRequestId(record.id)) {
+                void this.handleServerRequest(record.id, record.method, record.params);
+            }
+            else {
+                this.trackTurnNotification(record.method, record.params);
+                this.options.onNotification?.(record.method, record.params);
+            }
+            return;
+        }
         if (record.id !== undefined) {
             const id = Number(record.id);
             const pending = Number.isInteger(id) ? this.pending.get(id) : null;
@@ -161,8 +190,71 @@ export class CodexAppServerClient {
             }
             return;
         }
-        if (typeof record.method === "string") {
-            this.options.onNotification?.(record.method, record.params);
+    }
+    isRequestId(value) {
+        return (typeof value === "string" && value.length > 0)
+            || (typeof value === "number" && Number.isFinite(value));
+    }
+    async handleServerRequest(id, method, params) {
+        try {
+            if (!this.options.onServerRequest) {
+                throw new CodexAppServerRequestError(`Unsupported Codex app-server request: ${method}`, -32601);
+            }
+            const result = await this.options.onServerRequest(method, params);
+            this.writeMessage({ id, result });
+        }
+        catch (error) {
+            const requestError = error instanceof CodexAppServerRequestError
+                ? error
+                : new CodexAppServerRequestError(error instanceof Error ? error.message : String(error));
+            this.options.onLog?.(`[codex-app-server] server request failed method=${method} error=${requestError.message}`);
+            this.writeMessage({
+                id,
+                error: {
+                    code: requestError.code,
+                    message: requestError.message,
+                    ...(requestError.data === undefined ? {} : { data: requestError.data }),
+                },
+            });
+        }
+    }
+    writeMessage(message) {
+        const child = this.child;
+        if (!child || child.killed || child.stdin.destroyed) {
+            return;
+        }
+        child.stdin.write(`${JSON.stringify(message)}\n`, "utf8");
+    }
+    trackTurnNotification(method, params) {
+        if (method !== "turn/started" && method !== "turn/completed" && method !== "turn/interrupted") {
+            return;
+        }
+        const record = params && typeof params === "object" && !Array.isArray(params)
+            ? params
+            : null;
+        const turn = record?.turn && typeof record.turn === "object" && !Array.isArray(record.turn)
+            ? record.turn
+            : null;
+        const threadId = typeof record?.threadId === "string" ? record.threadId : "";
+        const turnId = typeof turn?.id === "string"
+            ? turn.id
+            : typeof record?.turnId === "string"
+                ? record.turnId
+                : "";
+        if (!threadId || !turnId) {
+            return;
+        }
+        if (method === "turn/started") {
+            this.activeTurns.set(threadId, turnId);
+        }
+        else if (this.activeTurns.get(threadId) === turnId) {
+            this.activeTurns.delete(threadId);
+        }
+        this.notifyActiveTurnsChanged();
+    }
+    notifyActiveTurnsChanged() {
+        for (const listener of this.activeTurnsChanged) {
+            listener();
         }
     }
     rejectPending(error) {
@@ -173,6 +265,7 @@ export class CodexAppServerClient {
         }
     }
     async stopChild(child) {
+        await this.interruptActiveTurns();
         const pid = child.pid;
         if (!pid) {
             child.kill("SIGTERM");
@@ -189,6 +282,42 @@ export class CodexAppServerClient {
             this.signalProcessGroup(pid, "SIGTERM");
         }
     }
+    async interruptActiveTurns() {
+        const turns = [...this.activeTurns.entries()].map(([threadId, turnId]) => ({ threadId, turnId }));
+        if (turns.length === 0) {
+            return;
+        }
+        this.options.onLog?.(`[codex-app-server] interrupting ${turns.length} active turn(s) before shutdown`);
+        await Promise.allSettled(turns.map(({ threadId, turnId }) => this.requestStarted("turn/interrupt", { threadId, turnId }, 5_000)));
+        const timeoutMs = this.options.gracefulShutdownTimeoutMs ?? 10_000;
+        const drained = await this.waitForTurnsToFinish(turns, timeoutMs);
+        if (!drained) {
+            this.options.onLog?.(`[codex-app-server] timed out waiting for active turns to finish before shutdown`);
+        }
+    }
+    async waitForTurnsToFinish(turns, timeoutMs) {
+        const isFinished = () => turns.every(({ threadId, turnId }) => this.activeTurns.get(threadId) !== turnId);
+        if (isFinished()) {
+            return true;
+        }
+        return await new Promise((resolve) => {
+            const onChanged = () => {
+                if (isFinished()) {
+                    cleanup();
+                    resolve(true);
+                }
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve(false);
+            }, timeoutMs);
+            const cleanup = () => {
+                clearTimeout(timer);
+                this.activeTurnsChanged.delete(onChanged);
+            };
+            this.activeTurnsChanged.add(onChanged);
+        });
+    }
     registerProcessExitHooks(pid) {
         if (!pid || process.platform === "win32") {
             return () => { };
@@ -211,14 +340,15 @@ export class CodexAppServerClient {
         process.once("exit", cleanup);
         for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
             const handler = () => {
-                cleanup();
-                remove();
-                try {
-                    process.kill(process.pid, signal);
-                }
-                catch {
-                    process.exitCode = 1;
-                }
+                void this.stop().finally(() => {
+                    remove();
+                    try {
+                        process.kill(process.pid, signal);
+                    }
+                    catch {
+                        process.exitCode = 1;
+                    }
+                });
             };
             signalHandlers.set(signal, handler);
             process.once(signal, handler);

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

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { CodexAppServerClient } from "./codex-app-server-client.js";
+const fixtureSource = String.raw `
+  const fs = require("node:fs");
+  const readline = require("node:readline");
+  const tracePath = process.env.DOER_CODEX_FIXTURE_TRACE;
+  const trace = (value) => fs.appendFileSync(tracePath, value + "\n");
+  const send = (value) => process.stdout.write(JSON.stringify(value) + "\n");
+  let waitingRequestId = null;
+  readline.createInterface({ input: process.stdin }).on("line", (line) => {
+    const message = JSON.parse(line);
+    if (message.method === "initialize") {
+      send({ id: message.id, result: {} });
+      return;
+    }
+    if (message.method === "test/server-request") {
+      waitingRequestId = message.id;
+      send({
+        id: "server-request-1",
+        method: "item/tool/call",
+        params: { tool: "fixture", arguments: {} },
+      });
+      return;
+    }
+    if (message.id === "server-request-1") {
+      trace("server-request-response");
+      send({ id: waitingRequestId, result: message.result });
+      return;
+    }
+    if (message.method === "test/start-turn") {
+      send({
+        method: "turn/started",
+        params: {
+          threadId: "thread-1",
+          turn: { id: "turn-1", status: "inProgress" },
+        },
+      });
+      send({ id: message.id, result: {} });
+      return;
+    }
+    if (message.method === "turn/interrupt") {
+      trace("turn-interrupt");
+      send({ id: message.id, result: {} });
+      send({
+        method: "turn/completed",
+        params: {
+          threadId: "thread-1",
+          turn: { id: "turn-1", status: "interrupted" },
+        },
+      });
+    }
+  });
+  process.on("SIGTERM", () => {
+    trace("sigterm");
+    process.exit(0);
+  });
+`;
+test("handles server requests and drains active turns before shutdown", async () => {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "doer-app-server-client-"));
+    const tracePath = path.join(tempDir, "trace.log");
+    const client = new CodexAppServerClient({
+        cwd: tempDir,
+        args: [],
+        executable: process.execPath,
+        executableArgs: ["--eval", fixtureSource],
+        env: {
+            ...process.env,
+            DOER_CODEX_FIXTURE_TRACE: tracePath,
+        },
+        gracefulShutdownTimeoutMs: 2_000,
+        onServerRequest: async (method, params) => {
+            assert.equal(method, "item/tool/call");
+            assert.deepEqual(params, { tool: "fixture", arguments: {} });
+            return { contentItems: [], success: true };
+        },
+    });
+    const serverRequestResult = await client.request("test/server-request");
+    assert.deepEqual(serverRequestResult, { contentItems: [], success: true });
+    await client.request("test/start-turn");
+    await client.stop();
+    const trace = (await readFile(tracePath, "utf8")).trim().split("\n");
+    assert.deepEqual(trace, [
+        "server-request-response",
+        "turn-interrupt",
+        "sigterm",
+    ]);
+});

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

@@ -1,6 +1,6 @@
 import { buildAgentSettingsEnvPatch, readAgentModelInstructions, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
 import { buildCustomMcpConfigArgs, buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs, buildThreadsMcpConfigArgs, spawnManagedCodexCommand, } from "./agent-codex-cli.js";
-import { CodexAppServerClient } from "./codex-app-server-client.js";
+import { CodexAppServerClient, CodexAppServerRequestError, } from "./codex-app-server-client.js";
 import { startCodexChatBridge } from "./codex-chat-bridge.js";
 import { allocateMcpOauthCallbackPort, buildMcpOauthCallbackBaseUrl, relayMcpOauthCallbackToLocalListener, } from "./mcp-oauth-relay.js";
 function toTomlStringLiteral(value) {
@@ -12,6 +12,35 @@ function buildConfigArg(key, tomlValue) {
 function buildFeatureArg(enabled, name) {
     return [enabled ? "--enable" : "--disable", name];
 }
+function safeServerRequestResponse(method) {
+    switch (method) {
+        case "item/commandExecution/requestApproval":
+        case "item/fileChange/requestApproval":
+            return { decision: "decline" };
+        case "item/tool/requestUserInput":
+            return { answers: {} };
+        case "mcpServer/elicitation/request":
+            return { action: "decline", content: null, _meta: null };
+        case "item/permissions/requestApproval":
+            return { permissions: {}, scope: "turn" };
+        case "item/tool/call":
+            return {
+                contentItems: [{
+                        type: "inputText",
+                        text: "This client does not provide a handler for dynamic tools.",
+                    }],
+                success: false,
+            };
+        case "applyPatchApproval":
+        case "execCommandApproval":
+            return { decision: { denied: { rejection: "Client approval UI is unavailable." } } };
+        case "account/chatgptAuthTokens/refresh":
+        case "attestation/generate":
+            throw new CodexAppServerRequestError(`Unsupported Codex app-server request: ${method}`, -32601);
+        default:
+            throw new CodexAppServerRequestError(`Unknown Codex app-server request: ${method}`, -32601);
+    }
+}
 function resolveCodexModel(settings) {
     const providerKey = settings.codex.modelProvider || "openai";
     if (providerKey === "zai") {
@@ -143,6 +172,7 @@ export function createCodexAppServerManager(args) {
     let client = null;
     let providerProxy = null;
     let createPromise = null;
+    let lifecyclePromise = null;
     let mcpOauthCallbackPortPromise = null;
     let generation = 0;
     const notificationListeners = new Set();
@@ -189,6 +219,10 @@ export function createCodexAppServerManager(args) {
             args: appServerArgs,
             env,
             onLog: args.onLog,
+            onServerRequest: async (method) => {
+                args.onLog?.(`codex app-server server request method=${method} handled=safe-fallback`);
+                return safeServerRequestResponse(method);
+            },
             onNotification: (method, params) => {
                 for (const listener of notificationListeners) {
                     listener(method, params);
@@ -198,6 +232,9 @@ export function createCodexAppServerManager(args) {
         });
     };
     const getClient = async () => {
+        if (lifecyclePromise) {
+            await lifecyclePromise;
+        }
         if (client) {
             return client;
         }
@@ -238,6 +275,21 @@ export function createCodexAppServerManager(args) {
             args.onLog?.(`failed to stop provider proxy: ${error instanceof Error ? error.message : String(error)}`);
         });
     };
+    const scheduleRestart = async (reason) => {
+        if (lifecyclePromise) {
+            return await lifecyclePromise;
+        }
+        const pendingRestart = restartClient(reason);
+        lifecyclePromise = pendingRestart;
+        try {
+            await pendingRestart;
+        }
+        finally {
+            if (lifecyclePromise === pendingRestart) {
+                lifecyclePromise = null;
+            }
+        }
+    };
     const runMcpLogout = async (name) => {
         const settings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
         const server = settings.mcp.servers.find((candidate) => candidate.name === name && candidate.transport === "streamable_http");
@@ -304,7 +356,7 @@ export function createCodexAppServerManager(args) {
             await runMcpLogout(normalizedName);
         },
         async restart(reason) {
-            await restartClient(reason);
+            await scheduleRestart(reason);
         },
         async stop() {
             const activeClient = client;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.9.7",
+  "version": "0.9.8",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",