doer-agent 0.8.3 → 0.8.5

package/dist/agent-codex-cli.js

@@ -70,6 +70,22 @@ export function buildDaemonMcpConfigArgs(args) {
         workspaceRootEnvName: "DOER_DAEMON_WORKSPACE_ROOT",
     });
 }
+export function buildThreadsMcpConfigArgs(args) {
+    return buildWorkspaceMcpConfigArgs({
+        agentProjectDir: args.agentProjectDir,
+        workspaceRoot: args.workspaceRoot,
+        serverName: args.serverName?.trim() || "doer_threads",
+        distEntryRelativePath: path.join("dist", "threads-mcp-server.js"),
+        srcEntryRelativePath: path.join("src", "threads-mcp-server.ts"),
+        workspaceRootEnvName: "DOER_THREADS_WORKSPACE_ROOT",
+        env: {
+            DOER_THREADS_AGENT_ID: args.agentId,
+            DOER_AGENT_TOKEN: args.agentToken,
+            DOER_THREADS_SERVER_BASE_URL: args.serverBaseUrl,
+            DOER_THREADS_USER_ID: args.userId,
+        },
+    });
+}
 export function buildMobileMcpConfigArgs(args) {
     return buildWorkspaceMcpConfigArgs({
         agentProjectDir: args.agentProjectDir,
@@ -88,7 +104,7 @@ export function buildMobileMcpConfigArgs(args) {
 }
 export function buildCustomMcpConfigArgs(servers) {
     const configArgs = [];
-    const reservedNames = new Set(["doer_daemon", "doer_mobile"]);
+    const reservedNames = new Set(["doer_daemon", "doer_mobile", "doer_threads"]);
     const seenNames = new Set();
     for (const server of servers) {
         const serverName = server.name.trim();

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

@@ -18,6 +18,7 @@ export class CodexAppServerClient {
     stdoutLines = null;
     nextRequestId = 1;
     startPromise = null;
+    stopPromise = null;
     pending = new Map();
     constructor(options) {
         this.options = options;
@@ -37,10 +38,19 @@ export class CodexAppServerClient {
     }
     async stop() {
         const child = this.child;
-        if (!child || child.killed) {
+        if (!child) {
             return;
         }
-        child.kill("SIGTERM");
+        if (this.stopPromise) {
+            return await this.stopPromise;
+        }
+        this.stopPromise = this.stopChild(child);
+        try {
+            await this.stopPromise;
+        }
+        finally {
+            this.stopPromise = null;
+        }
     }
     async start() {
         if (this.child && !this.child.killed) {
@@ -60,9 +70,12 @@ export class CodexAppServerClient {
     async startInner() {
         this.child = spawn(process.execPath, [resolveCodexCliBinPath(), ...this.options.args], {
             cwd: this.options.cwd,
+            detached: process.platform !== "win32",
             env: this.options.env,
             stdio: ["pipe", "pipe", "pipe"],
         });
+        const childPid = this.child.pid;
+        const removeExitHooks = this.registerProcessExitHooks(childPid);
         this.child.stdout.setEncoding("utf8");
         this.child.stderr.setEncoding("utf8");
         this.stdoutLines = createInterface({ input: this.child.stdout });
@@ -75,6 +88,8 @@ export class CodexAppServerClient {
         });
         this.child.once("exit", (code, signal) => {
             this.options.onLog?.(`[codex-app-server] exited code=${code ?? "null"} signal=${signal ?? "null"}`);
+            removeExitHooks();
+            this.signalProcessGroup(childPid, "SIGTERM");
             this.rejectPending(new Error("Codex app-server exited"));
             this.stdoutLines?.close();
             this.stdoutLines = null;
@@ -157,4 +172,95 @@ export class CodexAppServerClient {
             pending.reject(error);
         }
     }
+    async stopChild(child) {
+        const pid = child.pid;
+        if (!pid) {
+            child.kill("SIGTERM");
+            return;
+        }
+        this.signalProcessGroup(pid, "SIGTERM") || child.kill("SIGTERM");
+        const exited = await this.waitForExit(child, 5_000);
+        if (!exited) {
+            this.options.onLog?.("[codex-app-server] forcing process group shutdown after timeout");
+            this.signalProcessGroup(pid, "SIGKILL") || child.kill("SIGKILL");
+            await this.waitForExit(child, 1_000);
+        }
+        else {
+            this.signalProcessGroup(pid, "SIGTERM");
+        }
+    }
+    registerProcessExitHooks(pid) {
+        if (!pid || process.platform === "win32") {
+            return () => { };
+        }
+        let removed = false;
+        const cleanup = () => {
+            this.signalProcessGroup(pid, "SIGTERM");
+        };
+        const signalHandlers = new Map();
+        const remove = () => {
+            if (removed) {
+                return;
+            }
+            removed = true;
+            process.off("exit", cleanup);
+            for (const [signal, handler] of signalHandlers) {
+                process.off(signal, handler);
+            }
+        };
+        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;
+                }
+            };
+            signalHandlers.set(signal, handler);
+            process.once(signal, handler);
+        }
+        return remove;
+    }
+    signalProcessGroup(pid, signal) {
+        if (!pid || process.platform === "win32") {
+            return false;
+        }
+        try {
+            process.kill(-pid, signal);
+            return true;
+        }
+        catch (error) {
+            const code = typeof error === "object" && error !== null && "code" in error
+                ? String(error.code)
+                : "";
+            if (code && code !== "ESRCH") {
+                this.options.onLog?.(`[codex-app-server] failed to signal process group pid=${pid} signal=${signal} code=${code}`);
+            }
+            return false;
+        }
+    }
+    async waitForExit(child, timeoutMs) {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            return true;
+        }
+        return await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve(false);
+            }, timeoutMs);
+            const onExit = () => {
+                cleanup();
+                resolve(true);
+            };
+            const cleanup = () => {
+                clearTimeout(timer);
+                child.off("exit", onExit);
+            };
+            child.once("exit", onExit);
+        });
+    }
 }

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

@@ -1,5 +1,5 @@
 import { buildAgentSettingsEnvPatch, readAgentModelInstructions, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
-import { buildCustomMcpConfigArgs, buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs } from "./agent-codex-cli.js";
+import { buildCustomMcpConfigArgs, buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs, buildThreadsMcpConfigArgs } from "./agent-codex-cli.js";
 import { CodexAppServerClient } from "./codex-app-server-client.js";
 function toTomlStringLiteral(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
@@ -32,6 +32,14 @@ async function buildCodexAppServerArgs(args) {
             agentProjectDir: args.agentProjectDir,
             workspaceRoot: args.workspaceRoot,
         }),
+        ...buildThreadsMcpConfigArgs({
+            agentId: args.agentId,
+            agentProjectDir: args.agentProjectDir,
+            agentToken: args.agentToken,
+            serverBaseUrl: args.serverBaseUrl,
+            userId: args.userId,
+            workspaceRoot: args.workspaceRoot,
+        }),
         ...buildMobileMcpConfigArgs({
             agentId: args.agentId,
             agentProjectDir: args.agentProjectDir,

package/dist/threads-mcp-server.js

@@ -0,0 +1,170 @@
+import path from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod/v4";
+function parseWorkspaceRoot(argv) {
+    const flagIndex = argv.findIndex((token) => token === "--workspace-root");
+    const flagValue = flagIndex >= 0 ? argv[flagIndex + 1] : "";
+    const envValue = process.env.DOER_THREADS_WORKSPACE_ROOT?.trim() || process.env.WORKSPACE?.trim() || process.cwd();
+    return path.resolve((flagValue || envValue || process.cwd()).trim());
+}
+function formatJson(value) {
+    return JSON.stringify(value, null, 2);
+}
+function optionalEnv(name) {
+    return process.env[name]?.trim() || "";
+}
+function getThreadApiConfig() {
+    const agentId = optionalEnv("DOER_THREADS_AGENT_ID");
+    const agentToken = optionalEnv("DOER_AGENT_TOKEN");
+    const serverBaseUrl = optionalEnv("DOER_THREADS_SERVER_BASE_URL").replace(/\/$/, "");
+    const userId = optionalEnv("DOER_THREADS_USER_ID");
+    const missing = [
+        agentId ? null : "DOER_THREADS_AGENT_ID",
+        agentToken ? null : "DOER_AGENT_TOKEN",
+        serverBaseUrl ? null : "DOER_THREADS_SERVER_BASE_URL",
+        userId ? null : "DOER_THREADS_USER_ID",
+    ].filter((item) => Boolean(item));
+    if (missing.length > 0) {
+        throw new Error(`thread tools are unavailable; missing ${missing.join(", ")}`);
+    }
+    return { agentId, agentToken, serverBaseUrl, userId };
+}
+function codexThreadPath(config, method) {
+    return `/api/users/${encodeURIComponent(config.userId)}/agents/${encodeURIComponent(config.agentId)}/codex/${method}`;
+}
+async function postDoerJson(pathValue, body, timeoutMs) {
+    const config = getThreadApiConfig();
+    const response = await fetch(`${config.serverBaseUrl}${pathValue}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${config.agentToken}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            ...(timeoutMs ? { "x-doer-rpc-timeout-ms": String(timeoutMs) } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        throw new Error(typeof data.error === "string" ? data.error : `Doer server returned ${response.status}`);
+    }
+    return data;
+}
+function jsonToolResult(result) {
+    return {
+        content: [{ type: "text", text: formatJson(result) }],
+        structuredContent: result && typeof result === "object" && !Array.isArray(result)
+            ? result
+            : { result },
+    };
+}
+function threadListParams(args) {
+    const limit = Number.isFinite(args.limit) && args.limit
+        ? Math.min(100, Math.max(1, Math.trunc(args.limit)))
+        : 50;
+    return {
+        cursor: args.cursor?.trim() || null,
+        limit,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+        sourceKinds: [
+            "cli",
+            "vscode",
+            "exec",
+            "appServer",
+            "subAgent",
+            "subAgentReview",
+            "subAgentCompact",
+            "subAgentThreadSpawn",
+            "subAgentOther",
+            "unknown",
+        ],
+        archived: args.archived ?? false,
+        searchTerm: args.searchTerm?.trim() || null,
+    };
+}
+async function archiveThread(threadId) {
+    const config = getThreadApiConfig();
+    return postDoerJson(codexThreadPath(config, "thread/archive"), { threadId: threadId.trim() }, 180_000);
+}
+async function main() {
+    parseWorkspaceRoot(process.argv.slice(2));
+    const server = new McpServer({
+        name: "doer-threads",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+        instructions: "Start, list, read, close, and archive Codex threads for the current Doer agent.",
+    });
+    server.registerTool("threads_list", {
+        description: "List Codex threads for this Doer agent using the same API as the Doer thread list.",
+        inputSchema: {
+            archived: z.boolean().optional().describe("Whether to list archived threads. Defaults to false."),
+            cursor: z.string().optional().describe("Optional pagination cursor returned by the thread list API."),
+            limit: z.number().int().min(1).max(100).optional().describe("Maximum number of threads to return. Defaults to 50."),
+            searchTerm: z.string().optional().describe("Optional text search term."),
+        },
+    }, async ({ archived, cursor, limit, searchTerm }) => {
+        const config = getThreadApiConfig();
+        const result = await postDoerJson(codexThreadPath(config, "thread/list"), threadListParams({ archived, cursor, limit, searchTerm }), 180_000);
+        return jsonToolResult(result);
+    });
+    server.registerTool("threads_start", {
+        description: "Create a new Codex thread for this Doer agent and start its first turn.",
+        inputSchema: {
+            prompt: z.string().min(1).describe("User prompt for the first turn in the new thread."),
+        },
+    }, async ({ prompt }) => {
+        const config = getThreadApiConfig();
+        const result = await postDoerJson(codexThreadPath(config, "thread/send"), { prompt }, 180_000);
+        return jsonToolResult(result);
+    });
+    server.registerTool("threads_read", {
+        description: "Read a Codex thread and its recent turn contents for this Doer agent.",
+        inputSchema: {
+            threadId: z.string().min(1).describe("Codex thread id to read."),
+            cursor: z.string().optional().describe("Optional pagination cursor for turns."),
+            limit: z.number().int().min(1).max(100).optional().describe("Maximum number of turns to return. Defaults to 50."),
+        },
+    }, async ({ threadId, cursor, limit }) => {
+        const config = getThreadApiConfig();
+        const normalizedThreadId = threadId.trim();
+        const turnsLimit = Number.isFinite(limit) && limit ? Math.min(100, Math.max(1, Math.trunc(limit))) : 50;
+        const [thread, turns] = await Promise.all([
+            postDoerJson(codexThreadPath(config, "thread/read"), { threadId: normalizedThreadId }, 180_000),
+            postDoerJson(codexThreadPath(config, "thread/turns/list"), {
+                threadId: normalizedThreadId,
+                cursor: cursor?.trim() || null,
+                limit: turnsLimit,
+                sortDirection: "desc",
+            }, 180_000),
+        ]);
+        return jsonToolResult({ thread, turns });
+    });
+    server.registerTool("threads_close", {
+        description: "Close a Codex thread for this Doer agent by archiving it with the same API as Doer thread delete.",
+        inputSchema: {
+            threadId: z.string().min(1).describe("Codex thread id to close."),
+        },
+    }, async ({ threadId }) => {
+        return jsonToolResult(await archiveThread(threadId) ?? { ok: true });
+    });
+    server.registerTool("threads_archive", {
+        description: "Archive a Codex thread for this Doer agent using the same API as Doer thread delete.",
+        inputSchema: {
+            threadId: z.string().min(1).describe("Codex thread id to archive."),
+        },
+    }, async ({ threadId }) => {
+        return jsonToolResult(await archiveThread(threadId) ?? { ok: true });
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});

package/package.json

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