doer-agent 0.7.3 → 0.7.5

package/dist/agent-codex-app-rpc.js

@@ -62,6 +62,9 @@ function normalizeCodexAppRpcRequest(args) {
     const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
     const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
     const method = typeof args.request.method === "string" ? args.request.method.trim() : "";
+    const timeoutMs = typeof args.request.timeoutMs === "number" && Number.isFinite(args.request.timeoutMs)
+        ? Math.min(180_000, Math.max(1_000, Math.trunc(args.request.timeoutMs)))
+        : undefined;
     if (!requestId || !requestAgentId || requestAgentId !== args.agentId || actionRaw !== "request" || !method) {
         throw new Error("invalid codex app rpc request");
     }
@@ -70,6 +73,7 @@ function normalizeCodexAppRpcRequest(args) {
         action: "request",
         method,
         params: args.request.params,
+        timeoutMs,
     };
 }
 async function handleCodexAppRpcMessage(args) {
@@ -78,7 +82,7 @@ async function handleCodexAppRpcMessage(args) {
         const payload = JSON.parse(codexAppRpcCodec.decode(args.msg.data));
         const request = normalizeCodexAppRpcRequest({ request: payload, agentId: args.agentId });
         requestId = request.requestId;
-        const result = applyCodexAppRpcOmitRules(request.method, await args.manager.request(request.method, request.params));
+        const result = applyCodexAppRpcOmitRules(request.method, await args.manager.request(request.method, request.params, request.timeoutMs));
         args.msg.respond(codexAppRpcCodec.encode(JSON.stringify({
             requestId,
             ok: true,

package/dist/agent-codex-cli.js

@@ -11,6 +11,21 @@ function toTomlStringLiteral(value) {
 function toTomlStringArray(values) {
     return `[${values.map((value) => toTomlStringLiteral(value)).join(", ")}]`;
 }
+function buildMcpServerConfigArgs(args) {
+    const serverName = args.serverName.trim();
+    const configArgs = [
+        "--config",
+        `mcp_servers.${serverName}.command=${toTomlStringLiteral(args.command)}`,
+        "--config",
+        `mcp_servers.${serverName}.args=${toTomlStringArray(args.commandArgs)}`,
+        "--config",
+        `mcp_servers.${serverName}.enabled=${args.enabled === false ? "false" : "true"}`,
+    ];
+    for (const [key, value] of Object.entries(args.env ?? {})) {
+        configArgs.push("--config", `mcp_servers.${serverName}.env.${key}=${toTomlStringLiteral(value)}`);
+    }
+    return configArgs;
+}
 function hasDirectCodexBinary() {
     const result = spawnSync("bash", ["-lc", "command -v codex >/dev/null 2>&1"], {
         stdio: "ignore",
@@ -71,6 +86,26 @@ export function buildMobileMcpConfigArgs(args) {
         },
     });
 }
+export function buildCustomMcpConfigArgs(servers) {
+    const configArgs = [];
+    const reservedNames = new Set(["doer_daemon", "doer_mobile"]);
+    const seenNames = new Set();
+    for (const server of servers) {
+        const serverName = server.name.trim();
+        if (!server.enabled || !serverName || !server.command.trim() || reservedNames.has(serverName) || seenNames.has(serverName)) {
+            continue;
+        }
+        seenNames.add(serverName);
+        configArgs.push(...buildMcpServerConfigArgs({
+            serverName,
+            command: server.command,
+            commandArgs: server.args,
+            env: Object.fromEntries(server.env.map((variable) => [variable.key, variable.value])),
+            enabled: true,
+        }));
+    }
+    return configArgs;
+}
 function buildWorkspaceMcpConfigArgs(args) {
     const serverName = args.serverName.trim();
     const distEntry = path.join(args.agentProjectDir, args.distEntryRelativePath);
@@ -80,20 +115,16 @@ function buildWorkspaceMcpConfigArgs(args) {
     const commandArgs = existsSync(distEntry)
         ? [distEntry, "--workspace-root", args.workspaceRoot]
         : ["--import", tsxLoaderPath, srcEntry, "--workspace-root", args.workspaceRoot];
-    const configArgs = [
-        "--config",
-        `mcp_servers.${serverName}.command=${toTomlStringLiteral(command)}`,
-        "--config",
-        `mcp_servers.${serverName}.args=${toTomlStringArray(commandArgs)}`,
-        "--config",
-        `mcp_servers.${serverName}.env.${args.workspaceRootEnvName}=${toTomlStringLiteral(args.workspaceRoot)}`,
-        "--config",
-        `mcp_servers.${serverName}.enabled=true`,
-    ];
-    for (const [key, value] of Object.entries(args.env ?? {})) {
-        configArgs.push("--config", `mcp_servers.${serverName}.env.${key}=${toTomlStringLiteral(value)}`);
-    }
-    return configArgs;
+    return buildMcpServerConfigArgs({
+        serverName,
+        command,
+        commandArgs,
+        env: {
+            [args.workspaceRootEnvName]: args.workspaceRoot,
+            ...(args.env ?? {}),
+        },
+        enabled: true,
+    });
 }
 export function buildLocalCodexCliCommand(args) {
     const quotedArgs = args.map(shellSingleQuote).join(" ");

package/dist/agent-settings.js

@@ -41,6 +41,9 @@ export function createDefaultAgentSettingsConfig() {
         env: {
             variables: [],
         },
+        mcp: {
+            servers: [],
+        },
     };
 }
 function normalizeNullableString(value) {
@@ -115,6 +118,74 @@ function normalizeAgentEnvironmentSettings(value, fallback) {
     }
     return { variables };
 }
+function normalizeMcpServerName(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed || !/^[A-Za-z0-9_-]+$/.test(trimmed)) {
+        return null;
+    }
+    if (trimmed === "doer_daemon" || trimmed === "doer_mobile") {
+        return null;
+    }
+    return trimmed;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => (typeof item === "string" ? item.replace(/\r/g, "") : null))
+        .filter((item) => item !== null && item.trim().length > 0);
+}
+function normalizeAgentMcpServer(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const raw = value;
+    const name = normalizeMcpServerName(raw.name);
+    const command = typeof raw.command === "string" ? raw.command.trim() : "";
+    if (!name || !command) {
+        return null;
+    }
+    const env = [];
+    const seenKeys = new Set();
+    const envRaw = Array.isArray(raw.env) ? raw.env : [];
+    for (const item of envRaw) {
+        const normalized = normalizeAgentEnvironmentVariable(item);
+        if (!normalized || seenKeys.has(normalized.key)) {
+            continue;
+        }
+        seenKeys.add(normalized.key);
+        env.push(normalized);
+    }
+    return {
+        name,
+        command,
+        args: normalizeStringArray(raw.args),
+        env,
+        enabled: raw.enabled !== false,
+    };
+}
+function normalizeAgentMcpSettings(value, fallback) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return fallback;
+    }
+    const raw = value;
+    const serversRaw = Array.isArray(raw.servers) ? raw.servers : [];
+    const servers = [];
+    const seenNames = new Set();
+    for (const item of serversRaw) {
+        const normalized = normalizeAgentMcpServer(item);
+        if (!normalized || seenNames.has(normalized.name)) {
+            continue;
+        }
+        seenNames.add(normalized.name);
+        servers.push(normalized);
+    }
+    return { servers };
+}
 export function normalizeAgentSettingsConfig(value, fallback) {
     const base = fallback ?? createDefaultAgentSettingsConfig();
     const raw = value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -123,6 +194,7 @@ export function normalizeAgentSettingsConfig(value, fallback) {
     const realtime = raw.realtime && typeof raw.realtime === "object" ? raw.realtime : {};
     const git = raw.git && typeof raw.git === "object" ? raw.git : {};
     const env = raw.env && typeof raw.env === "object" ? raw.env : null;
+    const mcp = raw.mcp && typeof raw.mcp === "object" ? raw.mcp : null;
     return {
         general: {
             personality: normalizeCodexPersonality(general.personality, base.general.personality),
@@ -152,6 +224,7 @@ export function normalizeAgentSettingsConfig(value, fallback) {
             oauthScope: git.oauthScope === null ? null : normalizeNullableString(git.oauthScope) ?? base.git.oauthScope,
         },
         env: normalizeAgentEnvironmentSettings(env, base.env),
+        mcp: normalizeAgentMcpSettings(mcp, base.mcp),
     };
 }
 export async function readAgentSettingsConfig(args) {
@@ -245,6 +318,18 @@ export async function toAgentSettingsPublic(args) {
                 value: variable.value,
             })),
         },
+        mcp: {
+            servers: args.config.mcp.servers.map((server) => ({
+                name: server.name,
+                command: server.command,
+                args: [...server.args],
+                env: server.env.map((variable) => ({
+                    key: variable.key,
+                    value: variable.value,
+                })),
+                enabled: server.enabled,
+            })),
+        },
     };
 }
 export function normalizeAgentSettingsPatch(value) {
@@ -287,6 +372,7 @@ export function normalizeAgentSettingsPatch(value) {
     move("gitOauthLogin", "git", "oauthLogin");
     move("gitOauthScope", "git", "oauthScope");
     move("environmentVariables", "env", "variables");
+    move("mcpServers", "mcp", "servers");
     return patch;
 }
 export function buildAgentSettingsEnvPatch(config) {

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

@@ -22,9 +22,9 @@ export class CodexAppServerClient {
     constructor(options) {
         this.options = options;
     }
-    async request(method, params) {
+    async request(method, params, timeoutMs) {
         await this.start();
-        return await this.requestStarted(method, params);
+        return await this.requestStarted(method, params, timeoutMs);
     }
     async notify(method, params) {
         await this.start();
@@ -92,14 +92,14 @@ export class CodexAppServerClient {
         });
         await this.notify("initialized");
     }
-    async requestStarted(method, params) {
+    async requestStarted(method, params, timeoutMsOverride) {
         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;
+        const timeoutMs = timeoutMsOverride ?? this.options.requestTimeoutMs ?? 30_000;
         return await new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pending.delete(id);

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

@@ -1,5 +1,5 @@
 import { buildAgentSettingsEnvPatch, readAgentModelInstructions, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
-import { buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs } from "./agent-codex-cli.js";
+import { buildCustomMcpConfigArgs, buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs } from "./agent-codex-cli.js";
 import { CodexAppServerClient } from "./codex-app-server-client.js";
 function toTomlStringLiteral(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
@@ -40,6 +40,7 @@ async function buildCodexAppServerArgs(args) {
             userId: args.userId,
             workspaceRoot: args.workspaceRoot,
         }),
+        ...buildCustomMcpConfigArgs(args.settings.mcp.servers),
         ...buildFeatureArg(true, "goals"),
         ...buildFeatureArg(args.settings.codex.computerUseEnabled, "computer_use"),
         ...buildFeatureArg(args.settings.codex.browserUseEnabled, "browser_use"),
@@ -82,7 +83,7 @@ export function createCodexAppServerManager(args) {
             settings,
             userId: args.userId,
         });
-        args.onLog?.(`starting codex app-server model=${settings.codex.model} reasoningEffort=${settings.codex.reasoningEffort} personality=${settings.general.personality} computerUse=${settings.codex.computerUseEnabled} browserUse=${settings.codex.browserUseEnabled}`);
+        args.onLog?.(`starting codex app-server model=${settings.codex.model} reasoningEffort=${settings.codex.reasoningEffort} personality=${settings.general.personality} computerUse=${settings.codex.computerUseEnabled} browserUse=${settings.codex.browserUseEnabled} mcpServers=${settings.mcp.servers.filter((server) => server.enabled).length}`);
         return new CodexAppServerClient({
             cwd: args.workspaceRoot,
             args: appServerArgs,
@@ -116,9 +117,9 @@ export function createCodexAppServerManager(args) {
         }
     };
     return {
-        async request(method, params) {
+        async request(method, params, timeoutMs) {
             const activeClient = await getClient();
-            return await activeClient.request(method, params);
+            return await activeClient.request(method, params, timeoutMs);
         },
         async restart(reason) {
             generation += 1;

package/package.json

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