@mcoda/agents 0.1.35 → 0.1.36

package/dist/adapters/codex/CodexAdapter.js

@@ -20,7 +20,7 @@ export class CodexAdapter {
     async invoke(request) {
         const health = cliHealthy(true);
         const cliDetails = health.details;
-        const result = runCodexExec(request.input, this.config.model);
+        const result = await runCodexExec(request.input, this.config.model);
         return {
             output: result.output,
             adapter: this.config.adapter ?? "codex-cli",

package/dist/adapters/codex/CodexCliRunner.d.ts

@@ -2,10 +2,10 @@ export declare const cliHealthy: (throwOnError?: boolean) => {
     ok: boolean;
     details?: Record<string, unknown>;
 };
-export declare const runCodexExec: (prompt: string, model?: string) => {
+export declare const runCodexExec: (prompt: string, model?: string) => Promise<{
     output: string;
     raw: string;
-};
+}>;
 export declare function runCodexExecStream(prompt: string, model?: string): AsyncGenerator<{
     output: string;
     raw: string;

package/dist/adapters/codex/CodexCliRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CodexCliRunner.d.ts","sourceRoot":"","sources":["../../../src/adapters/codex/CodexCliRunner.ts"],"names":[],"mappings":"AA4hBA,eAAO,MAAM,UAAU,GAAI,sBAAoB,KAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CA2BjG,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,EAAE,QAAQ,MAAM,KAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAuD1F,CAAC;AAEF,wBAAuB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM,GACb,cAAc,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CA+GhE"}
+{"version":3,"file":"CodexCliRunner.d.ts","sourceRoot":"","sources":["../../../src/adapters/codex/CodexCliRunner.ts"],"names":[],"mappings":"AAuyBA,eAAO,MAAM,UAAU,GAAI,sBAAoB,KAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CA+BjG,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,QAAQ,MAAM,EAAE,QAAQ,MAAM,KAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAS1G,CAAC;AAEF,wBAAuB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM,GACb,cAAc,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CAgEhE"}

package/dist/adapters/codex/CodexCliRunner.js

@@ -7,6 +7,12 @@ const CODEX_STREAM_IO_ENV = "MCODA_STREAM_IO";
 const CODEX_STREAM_IO_FORMAT_ENV = "MCODA_STREAM_IO_FORMAT";
 const CODEX_STREAM_IO_COLOR_ENV = "MCODA_STREAM_IO_COLOR";
 const CODEX_STREAM_IO_PREFIX = "codex-cli";
+const CODEX_COMMAND_ENV = "MCODA_CODEX_COMMAND";
+const CODEX_COMMAND_ARGS_ENV = "MCODA_CODEX_COMMAND_ARGS";
+const CODEX_TIMEOUT_ENV = "MCODA_CODEX_TIMEOUT_MS";
+const CODEX_EXIT_GRACE_ENV = "MCODA_CODEX_EXIT_GRACE_MS";
+const CODEX_DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+const CODEX_DEFAULT_EXIT_GRACE_MS = 5000;
 const ANSI = {
     reset: "\u001b[0m",
     bold: "\u001b[1m",
@@ -114,6 +120,94 @@ const extractItemText = (item) => {
     }
     return "";
 };
+const parseCommandArgs = (raw) => {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed
+                    .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+                    .filter(Boolean);
+            }
+        }
+        catch {
+            // fall through to whitespace parsing
+        }
+    }
+    return trimmed.split(/\s+/).filter(Boolean);
+};
+const resolveCodexCommand = () => {
+    const command = process.env[CODEX_COMMAND_ENV]?.trim() || "codex";
+    const preArgs = parseCommandArgs(process.env[CODEX_COMMAND_ARGS_ENV]);
+    return { command, preArgs };
+};
+const parsePositiveIntEnv = (name, fallback) => {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+};
+const resolveCodexTimeoutMs = () => parsePositiveIntEnv(CODEX_TIMEOUT_ENV, CODEX_DEFAULT_TIMEOUT_MS);
+const resolveCodexExitGraceMs = () => parsePositiveIntEnv(CODEX_EXIT_GRACE_ENV, CODEX_DEFAULT_EXIT_GRACE_MS);
+const isIgnorableStdinError = (error) => error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED";
+const safeKill = (child, signal) => {
+    try {
+        if (!child.killed) {
+            child.kill(signal);
+        }
+    }
+    catch {
+        /* ignore kill errors */
+    }
+};
+const scheduleHardKill = (child, delayMs = 250) => {
+    const timer = setTimeout(() => {
+        safeKill(child, "SIGKILL");
+    }, delayMs);
+    timer.unref();
+};
+const extractProtocolError = (parsed) => {
+    if (!parsed || typeof parsed !== "object")
+        return undefined;
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (type === "turn.failed") {
+        const message = parsed?.error?.message ?? parsed?.error;
+        return message ? String(message) : "codex turn failed";
+    }
+    if (type === "error" && parsed?.message) {
+        return String(parsed.message);
+    }
+    return undefined;
+};
+const isCompletionEvent = (parsed) => {
+    if (!parsed || typeof parsed !== "object")
+        return false;
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    return type === "turn.completed" || type === "response.completed";
+};
+const parseCodexOutput = (raw) => {
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    let message = "";
+    for (const line of lines) {
+        const parsed = safeJsonParse(line);
+        const event = extractAssistantText(parsed);
+        if (!event)
+            continue;
+        if (event.kind === "delta") {
+            message += event.text;
+            continue;
+        }
+        message = event.text;
+    }
+    if (!message) {
+        return lines[lines.length - 1] ?? "";
+    }
+    return message;
+};
 const normalizeValue = (value) => {
     if (typeof value !== "string")
         return value;
@@ -541,6 +635,155 @@ const extractAssistantText = (parsed) => {
     }
     return null;
 };
+const invokeCodexProcess = async (prompt, model, hooks) => {
+    const resolvedModel = model ?? "gpt-5.1-codex-max";
+    const sandboxArgs = resolveSandboxArgs();
+    const reasoningEffort = resolveReasoningEffort(resolvedModel);
+    const codexCommand = resolveCodexCommand();
+    const args = [...codexCommand.preArgs, ...sandboxArgs.args, "exec", "--model", resolvedModel, "--json"];
+    if (!sandboxArgs.bypass) {
+        args.push("--full-auto");
+    }
+    if (reasoningEffort) {
+        args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
+    }
+    args.push("-");
+    const timeoutMs = resolveCodexTimeoutMs();
+    const exitGraceMs = resolveCodexExitGraceMs();
+    return await new Promise((resolve, reject) => {
+        const child = spawn(codexCommand.command, args, { stdio: ["pipe", "pipe", "pipe"] });
+        let raw = "";
+        let stderr = "";
+        let lineBuffer = "";
+        let message = "";
+        let protocolError;
+        let settled = false;
+        let forcedExit = false;
+        let completionTimer;
+        const clearTimers = () => {
+            if (completionTimer) {
+                clearTimeout(completionTimer);
+                completionTimer = undefined;
+            }
+            clearTimeout(timeoutHandle);
+        };
+        const finalizeOutput = () => {
+            const parsedOutput = parseCodexOutput(raw).trim();
+            return parsedOutput || message.trim();
+        };
+        const finishResolve = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimers();
+            resolve({ output: finalizeOutput(), raw, forcedExit });
+        };
+        const finishReject = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimers();
+            reject(error);
+        };
+        const scheduleCompletionGrace = () => {
+            if (settled)
+                return;
+            if (completionTimer) {
+                clearTimeout(completionTimer);
+            }
+            completionTimer = setTimeout(() => {
+                if (settled)
+                    return;
+                forcedExit = true;
+                safeKill(child, "SIGTERM");
+                scheduleHardKill(child);
+                finishResolve();
+            }, exitGraceMs);
+            completionTimer.unref();
+        };
+        const handleLine = (line) => {
+            const normalized = line.replace(/\r$/, "");
+            hooks?.onLine?.(normalized);
+            const parsed = safeJsonParse(normalized);
+            const event = extractAssistantText(parsed);
+            if (event) {
+                if (event.kind === "delta") {
+                    message += event.text;
+                }
+                else {
+                    message = event.text;
+                    scheduleCompletionGrace();
+                }
+                hooks?.onAssistantEvent?.(event, normalized);
+            }
+            const parsedError = extractProtocolError(parsed);
+            if (parsedError) {
+                protocolError = parsedError;
+            }
+            if (isCompletionEvent(parsed)) {
+                scheduleCompletionGrace();
+            }
+        };
+        const timeoutHandle = setTimeout(() => {
+            if (settled)
+                return;
+            forcedExit = true;
+            safeKill(child, "SIGTERM");
+            scheduleHardKill(child);
+            const detail = stderr.trim().length > 0 ? `: ${stderr.trim()}` : "";
+            finishReject(new Error(`AUTH_ERROR: codex CLI timed out after ${timeoutMs}ms${detail}`));
+        }, timeoutMs);
+        timeoutHandle.unref();
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            const text = chunk.toString();
+            raw += text;
+            lineBuffer += text;
+            let idx;
+            while ((idx = lineBuffer.indexOf("\n")) !== -1) {
+                const line = lineBuffer.slice(0, idx);
+                lineBuffer = lineBuffer.slice(idx + 1);
+                handleLine(line);
+            }
+        });
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.stdin?.on("error", (error) => {
+            if (settled || isIgnorableStdinError(error))
+                return;
+            finishReject(new Error(`AUTH_ERROR: codex CLI stdin failed (${error.message})`));
+        });
+        child.on("error", (error) => {
+            finishReject(new Error(`AUTH_ERROR: codex CLI failed (${error.message})`));
+        });
+        child.on("close", (code) => {
+            if (lineBuffer.trim()) {
+                handleLine(lineBuffer);
+                lineBuffer = "";
+            }
+            if (settled)
+                return;
+            if ((code ?? 0) !== 0) {
+                finishReject(new Error(`AUTH_ERROR: codex CLI failed (exit ${code ?? 0}): ${stderr || protocolError || "no output"}`));
+                return;
+            }
+            if (protocolError && !finalizeOutput()) {
+                finishReject(new Error(`AUTH_ERROR: codex CLI failed (${protocolError})`));
+                return;
+            }
+            finishResolve();
+        });
+        try {
+            child.stdin?.write(prompt);
+            child.stdin?.end();
+        }
+        catch (error) {
+            finishReject(new Error(`AUTH_ERROR: codex CLI stdin failed (${error.message})`));
+        }
+    });
+};
 export const cliHealthy = (throwOnError = false) => {
     if (process.env.MCODA_CLI_STUB === "1") {
         return { ok: true, details: { stub: true } };
@@ -548,7 +791,11 @@ export const cliHealthy = (throwOnError = false) => {
     if (process.env.MCODA_SKIP_CLI_CHECKS === "1") {
         return { ok: true, details: { skipped: true } };
     }
-    const result = spawnSync("codex", ["--version"], { encoding: "utf8", maxBuffer: CODEX_MAX_BUFFER_BYTES });
+    const codexCommand = resolveCodexCommand();
+    const result = spawnSync(codexCommand.command, [...codexCommand.preArgs, "--version"], {
+        encoding: "utf8",
+        maxBuffer: CODEX_MAX_BUFFER_BYTES,
+    });
     if (result.error) {
         const details = { reason: "missing_cli", error: result.error.message };
         if (throwOnError) {
@@ -569,62 +816,15 @@ export const cliHealthy = (throwOnError = false) => {
     }
     return { ok: true, details: { version: result.stdout?.toString().trim() } };
 };
-export const runCodexExec = (prompt, model) => {
+export const runCodexExec = async (prompt, model) => {
     if (process.env.MCODA_CLI_STUB === "1") {
         const output = `qa-stub:${prompt}`;
         const raw = JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: output } });
         return { output, raw };
     }
-    const health = cliHealthy(true);
-    const resolvedModel = model ?? "gpt-5.1-codex-max";
-    const sandboxArgs = resolveSandboxArgs();
-    const args = [...sandboxArgs.args, "exec", "--model", resolvedModel, "--json"];
-    if (!sandboxArgs.bypass) {
-        args.push("--full-auto");
-    }
-    const reasoningEffort = resolveReasoningEffort(resolvedModel);
-    if (reasoningEffort) {
-        args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
-    }
-    args.push("-");
-    const result = spawnSync("codex", args, {
-        input: prompt,
-        encoding: "utf8",
-        maxBuffer: CODEX_MAX_BUFFER_BYTES,
-    });
-    if (result.error) {
-        const error = new Error(`AUTH_ERROR: codex CLI failed (${result.error.message})`);
-        error.details = { reason: "cli_error", cli: health.details };
-        throw error;
-    }
-    if (result.status !== 0) {
-        const error = new Error(`AUTH_ERROR: codex CLI failed (exit ${result.status}): ${result.stderr ?? result.stdout ?? ""}`);
-        error.details = { reason: "cli_error", exitCode: result.status, stderr: result.stderr };
-        throw error;
-    }
-    const raw = result.stdout?.toString() ?? "";
-    const lines = raw.split(/\r?\n/).filter((l) => l.trim().length > 0);
-    let message = "";
-    for (const line of lines) {
-        try {
-            const parsed = JSON.parse(line);
-            const event = extractAssistantText(parsed);
-            if (!event)
-                continue;
-            if (event.kind === "delta") {
-                message += event.text;
-                continue;
-            }
-            message = event.text;
-        }
-        catch {
-            /* ignore parse errors */
-        }
-    }
-    if (!message) {
-        message = lines[lines.length - 1] ?? "";
-    }
-    return { output: message.trim(), raw };
+    cliHealthy(true);
+    const result = await invokeCodexProcess(prompt, model);
+    return { output: result.output, raw: result.raw };
 };
 export async function* runCodexExecStream(prompt, model) {
     if (process.env.MCODA_CLI_STUB === "1") {
@@ -635,103 +835,55 @@ export async function* runCodexExecStream(prompt, model) {
     }
     cliHealthy(true);
     const resolvedModel = model ?? "gpt-5.1-codex-max";
-    const sandboxArgs = resolveSandboxArgs();
-    const args = [...sandboxArgs.args, "exec", "--model", resolvedModel, "--json"];
-    if (!sandboxArgs.bypass) {
-        args.push("--full-auto");
-    }
-    const reasoningEffort = resolveReasoningEffort(resolvedModel);
-    if (reasoningEffort) {
-        args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
-    }
-    args.push("-");
-    const child = spawn("codex", args, { stdio: ["pipe", "pipe", "pipe"] });
-    child.stdin.write(prompt);
-    child.stdin.end();
-    let stderr = "";
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => {
-        stderr += chunk.toString();
-    });
-    const closePromise = new Promise((resolve, reject) => {
-        child.on("error", (err) => reject(err));
-        child.on("close", (code) => resolve(code ?? 0));
-    });
-    const parseLine = (line) => {
-        try {
-            const parsed = JSON.parse(line);
-            return extractAssistantText(parsed);
-        }
-        catch {
-            return null;
-        }
-    };
-    const stream = child.stdout;
-    stream?.setEncoding("utf8");
     const formatter = createStreamFormatter(resolvedModel);
-    let buffer = "";
+    const queue = [];
+    const waiters = [];
+    let done = false;
+    let failure;
     let sawDelta = false;
-    let streamError = null;
-    try {
-        for await (const chunk of stream ?? []) {
-            buffer += chunk;
-            let idx;
-            while ((idx = buffer.indexOf("\n")) !== -1) {
-                const line = buffer.slice(0, idx);
-                buffer = buffer.slice(idx + 1);
-                const normalized = line.replace(/\r$/, "");
-                formatter.handleLine(normalized);
-                const parsed = parseLine(normalized);
-                if (!parsed)
-                    continue;
-                if (parsed.kind === "delta") {
-                    sawDelta = true;
-                    yield { output: parsed.text, raw: normalized };
-                    continue;
-                }
-                if (!sawDelta) {
-                    const output = parsed.text.endsWith("\n") ? parsed.text : `${parsed.text}\n`;
-                    yield { output, raw: normalized };
-                }
-                sawDelta = false;
-            }
+    const notify = () => {
+        while (waiters.length) {
+            waiters.shift()?.();
         }
-        const trailing = buffer.replace(/\r$/, "");
-        if (trailing) {
-            formatter.handleLine(trailing);
-            const parsed = parseLine(trailing);
-            if (parsed) {
-                if (parsed.kind === "delta") {
-                    sawDelta = true;
-                    yield { output: parsed.text, raw: trailing };
-                }
-                else if (!sawDelta) {
-                    const output = parsed.text.endsWith("\n") ? parsed.text : `${parsed.text}\n`;
-                    yield { output, raw: trailing };
-                    sawDelta = false;
-                }
+    };
+    void invokeCodexProcess(prompt, model, {
+        onLine: (line) => {
+            formatter.handleLine(line);
+        },
+        onAssistantEvent: (event, rawLine) => {
+            if (event.kind === "delta") {
+                sawDelta = true;
+                queue.push({ output: event.text, raw: rawLine });
+                notify();
+                return;
             }
-        }
-    }
-    catch (error) {
-        streamError = error;
-    }
-    const exitCode = await closePromise;
-    if (exitCode !== 0) {
-        formatter.handleLine(JSON.stringify({
-            type: "error",
-            message: `codex exec failed with exit ${exitCode}: ${stderr || "no output"}`,
-        }));
-        const error = new Error(`AUTH_ERROR: codex CLI failed (exit ${exitCode}): ${stderr || "no output"}`);
-        error.details = { reason: "cli_error", exitCode, stderr };
+            if (!sawDelta) {
+                const output = event.text.endsWith("\n") ? event.text : `${event.text}\n`;
+                queue.push({ output, raw: rawLine });
+                notify();
+            }
+            sawDelta = false;
+        },
+    })
+        .catch((error) => {
+        failure = error;
+        formatter.handleLine(JSON.stringify({ type: "error", message: failure.message }));
+    })
+        .finally(() => {
+        done = true;
         formatter.end();
-        if (streamError) {
-            throw streamError;
+        notify();
+    });
+    while (!done || queue.length > 0) {
+        if (queue.length > 0) {
+            yield queue.shift();
+            continue;
         }
-        throw error;
+        await new Promise((resolve) => {
+            waiters.push(resolve);
+        });
     }
-    formatter.end();
-    if (streamError) {
-        throw streamError;
+    if (failure) {
+        throw failure;
     }
 }

package/dist/adapters/openai/OpenAiCliAdapter.js

@@ -19,7 +19,7 @@ export class OpenAiCliAdapter {
     }
     async invoke(request) {
         const cliDetails = codexCliHealthy(true);
-        const result = runCodexExec(request.input, this.config.model);
+        const result = await runCodexExec(request.input, this.config.model);
         return {
             output: result.output,
             adapter: this.config.adapter ?? "codex-cli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcoda/agents",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "Agent registry and capabilities for mcoda.",
   "type": "module",
   "main": "dist/index.js",
@@ -30,8 +30,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@mcoda/shared": "0.1.35",
-    "@mcoda/db": "0.1.35"
+    "@mcoda/shared": "0.1.36",
+    "@mcoda/db": "0.1.36"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",