@wyrd-company/async-codex-mcp 0.1.0 → 0.2.0

package/dist/src/callback-cli.js

@@ -3,7 +3,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 const options = parseArgs(process.argv.slice(2));
-const server = new McpServer({ name: "async-codex-mcp-callback", version: "0.1.0" }, {
+const server = new McpServer({ name: "async-codex-mcp-callback", version: "0.2.0" }, {
     instructions: "Use async_codex_ask_user only when you need a user answer before continuing. Use async_codex_notify_user for non-blocking progress updates or FYIs.",
 });
 server.tool("async_codex_ask_user", "Ask the user a blocking question. Codex waits until the user responds to the async session.", {

package/dist/src/codex-client.d.ts

@@ -17,6 +17,7 @@ export declare class CodexMcpClient implements CodexClientLike {
     constructor(config: AsyncCodexConfig);
     callCodex(profile: ToolProfile, args: CodexToolArguments): Promise<CallToolResult>;
     continueSession(sessionId: string, prompt: string, cwd?: string): Promise<CallToolResult>;
+    private requestOptions;
     close(): Promise<void>;
     private getClient;
 }

package/dist/src/codex-client.js

@@ -27,14 +27,19 @@ export class CodexMcpClient {
             codexArgs["developer-instructions"] = profile.developerInstructions;
         if (Object.keys(profile.config).length > 0)
             codexArgs.config = profile.config;
-        return client.callTool({ name: "codex", arguments: codexArgs });
+        return client.callTool({ name: "codex", arguments: codexArgs }, undefined, this.requestOptions());
     }
     async continueSession(sessionId, prompt, cwd) {
         const client = await this.getClient();
         const args = { threadId: sessionId, prompt };
         if (cwd)
             args.cwd = cwd;
-        return client.callTool({ name: "codex-reply", arguments: args });
+        return client.callTool({ name: "codex-reply", arguments: args }, undefined, this.requestOptions());
+    }
+    // The SDK default request timeout is 60s, which aborts any Codex run
+    // longer than a minute regardless of callback state.
+    requestOptions() {
+        return { timeout: this.config.codex.requestTimeoutSec * 1000, resetTimeoutOnProgress: true };
     }
     async close() {
         await this.client?.close();
@@ -45,7 +50,7 @@ export class CodexMcpClient {
     async getClient() {
         if (this.client)
             return this.client;
-        this.client = new Client({ name: "async-codex-mcp-client", version: "0.1.0" });
+        this.client = new Client({ name: "async-codex-mcp-client", version: "0.2.0" });
         this.transport = new StdioClientTransport({
             command: this.config.codex.command,
             args: this.config.codex.args,

package/dist/src/config.d.ts

@@ -9,7 +9,8 @@ declare const profileSchema: z.ZodObject<{
     developerInstructions: z.ZodOptional<z.ZodString>;
     config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     callbacks: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodBoolean;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        askTimeoutSec: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 declare const configSchema: z.ZodObject<{
@@ -18,9 +19,11 @@ declare const configSchema: z.ZodObject<{
         args: z.ZodDefault<z.ZodArray<z.ZodString>>;
         env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
         cwd: z.ZodOptional<z.ZodString>;
+        requestTimeoutSec: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     callbacks: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
+        askTimeoutSec: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
     tools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
@@ -32,7 +35,8 @@ declare const configSchema: z.ZodObject<{
         developerInstructions: z.ZodOptional<z.ZodString>;
         config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         callbacks: z.ZodOptional<z.ZodObject<{
-            enabled: z.ZodBoolean;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            askTimeoutSec: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>>;
 }, z.core.$strip>;

package/dist/src/config.js

@@ -9,12 +9,15 @@ const codexServerSchema = z.object({
     args: z.array(z.string()).default(["mcp-server"]),
     env: stringRecordSchema.default({}),
     cwd: z.string().optional(),
+    requestTimeoutSec: z.number().int().positive().default(86400),
 });
 const callbacksSchema = z.object({
     enabled: z.boolean().default(true),
+    askTimeoutSec: z.number().int().positive().default(3600),
 }).strict();
 const profileCallbacksSchema = z.object({
-    enabled: z.boolean(),
+    enabled: z.boolean().optional(),
+    askTimeoutSec: z.number().int().positive().optional(),
 }).strict();
 const profileSchema = z.object({
     description: z.string().optional(),
@@ -28,8 +31,8 @@ const profileSchema = z.object({
     callbacks: profileCallbacksSchema.optional(),
 }).strict();
 const configSchema = z.object({
-    codex: codexServerSchema.default({ command: "codex", args: ["mcp-server"], env: {} }),
-    callbacks: callbacksSchema.default({ enabled: true }),
+    codex: codexServerSchema.default({ command: "codex", args: ["mcp-server"], env: {}, requestTimeoutSec: 86400 }),
+    callbacks: callbacksSchema.default({ enabled: true, askTimeoutSec: 3600 }),
     tools: z.record(z.string(), profileSchema).default({
         codex: {
             description: "Run Codex asynchronously with danger-full-access sandboxing.",

package/dist/src/server.js

@@ -20,9 +20,12 @@ const answerShape = {
     message: z.string().min(1).describe("User response to return to Codex."),
 };
 export function createServer(config, options = {}) {
-    const server = new McpServer({ name: "async-codex-mcp", version: "0.1.0" }, {
-        capabilities: { logging: {} },
-        instructions: "Starts Codex sub-agent sessions asynchronously. Profile tools return immediately with an async session id; use continue-session after completion to resume.",
+    const server = new McpServer({ name: "async-codex-mcp", version: "0.2.0" }, {
+        capabilities: { logging: {}, experimental: { "claude/channel": {} } },
+        instructions: "Starts Codex sub-agent sessions asynchronously. Profile tools return immediately with an async session id; use continue-session after completion to resume. " +
+            'When this server runs as a Claude Code channel, session events arrive as <channel source="async-codex-mcp" session_id="..." kind="...">. ' +
+            "kind=ask means Codex is blocked waiting for input: call answer-session with the session_id from the tag. " +
+            "kind=notify is a non-blocking progress update. kind=completed or kind=failed means the session finished; use session-status or continue-session.",
     });
     const client = options.client ?? new CodexMcpClient(config);
     const store = options.store ?? new SessionStore();
@@ -155,12 +158,22 @@ function errorMessageFromResult(result) {
         .trim();
     return text || "Codex returned an error result.";
 }
+async function sendChannelNotification(server, content, meta) {
+    const cleanMeta = Object.fromEntries(Object.entries(meta).filter((entry) => typeof entry[1] === "string"));
+    await server.server.notification({
+        method: "notifications/claude/channel",
+        params: { content, meta: cleanMeta },
+    });
+}
 async function sendSessionNotification(server, sessionId, status, codexSessionId, error) {
     await server.server.sendLoggingMessage({
         level: status === "completed" ? "notice" : "error",
         logger: "async-codex-mcp",
         data: { session_id: sessionId, status, codex_session_id: codexSessionId, error },
     });
+    await sendChannelNotification(server, status === "completed"
+        ? `Async Codex session ${sessionId} completed. Use session-status to read the result or continue-session to resume.`
+        : `Async Codex session ${sessionId} failed: ${error ?? "unknown error"}`, { session_id: sessionId, kind: status, codex_session_id: codexSessionId });
 }
 async function sendCallbackNotification(server, sessionId, type, message, extra) {
     await server.server.sendLoggingMessage({
@@ -168,6 +181,7 @@ async function sendCallbackNotification(server, sessionId, type, message, extra)
         logger: "async-codex-mcp",
         data: { session_id: sessionId, type, message, ...extra },
     });
+    await sendChannelNotification(server, extra.context ? `${message}\n\nContext: ${extra.context}` : message, { session_id: sessionId, kind: type, topic: extra.topic });
 }
 async function prepareProfile(config, profile, sessionId, callbackHub) {
     if (!callbacksEnabled(config, profile)) {
@@ -192,6 +206,9 @@ async function prepareProfile(config, profile, sessionId, callbackHub) {
                         "--session-id",
                         sessionId,
                     ],
+                    // Codex aborts blocked ask_user calls at its default MCP tool
+                    // timeout (60s); a human answer routinely takes longer.
+                    tool_timeout_sec: profile.callbacks?.askTimeoutSec ?? config.callbacks.askTimeoutSec,
                 },
             },
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wyrd-company/async-codex-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Async MCP proxy for Codex MCP server profiles",
   "type": "module",
   "bin": {
@@ -12,14 +12,18 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "prepack": "npm run build",
+    "build:bundle": "esbuild src/cli.ts src/callback-cli.ts --bundle --platform=node --target=node20 --format=esm --outdir=dist/bundle --banner:js=\"import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);\"",
+    "prepack": "npm run build && npm run build:bundle",
     "test": "vitest run",
     "start": "node dist/src/cli.js"
   },
   "files": [
+    ".claude-plugin",
+    ".mcp.json",
+    "bin",
     "dist/src",
-    "fixtures",
-    "plugins/async-codex-mcp"
+    "dist/bundle",
+    "fixtures"
   ],
   "repository": {
     "type": "git",
@@ -38,6 +42,7 @@
     "@openai/codex": "^0.135.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.15.3",
+    "esbuild": "^0.25.0",
     "mcp-testing-kit": "github:thoughtspot/mcp-testing-kit",
     "typescript": "^5.8.3",
     "vitest": "^3.1.2"