openmausbot 0.1.58 → 0.1.60

package/dist-server/server/drivers/codex.js

@@ -8,7 +8,7 @@
 // codex-cli 0.144.4 by agentcal.
 //
 // resumeCursor is the codex thread id; a later turn tries thread/resume
-// and falls back to a fresh thread/start.
+// and preserves that history or reports a failed resume.
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { stripWorkspaceCredentialEnv } from "../config.js";
@@ -22,6 +22,7 @@ import { codexLocalProviderArgs } from "./local-inject.js";
 import { augmentedPath, splitCliString } from "../env-path.js";
 import { classifyError, computeBackoff, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { appendNative } from "./native.js";
+import { codexDeveloperInstructions, syncCodexInstructions } from "./codex-instructions.js";
 export { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 const DRIVER_KIND = "codex";
 const ASTRA_MODEL_ID = "gpt-6-astra";
@@ -300,18 +301,24 @@ function permissionProfileUnsupported(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /(?:experimental api|invalid params|unknown field|unknown.*permissions|permissions.*(?:unsupported|sandbox)|cannot.*permissions)/i.test(message);
 }
-/** Keep private host paths out of diagnostics while preserving enough of the
- * app-server input shape to debug image delivery. The unmodified request is
+/** Keep native instructions and private host paths out of diagnostics while
+ * preserving enough of the input shape to debug delivery. The unmodified request is
  * still written to the provider immediately after this log copy is made. */
 function codexNativeLogMessage(message) {
     if (!message || typeof message !== "object" || Array.isArray(message))
         return message;
     const record = message;
-    if (record.method !== "turn/start")
-        return message;
     const params = record.params;
     if (!params || typeof params !== "object" || Array.isArray(params))
         return message;
+    if (record.method === "thread/start" || record.method === "thread/resume") {
+        return { ...record, params: { ...params, developerInstructions: "[developer instructions omitted]" } };
+    }
+    if (record.method === "thread/inject_items") {
+        return { ...record, params: { ...params, items: "[developer instruction update omitted]" } };
+    }
+    if (record.method !== "turn/start")
+        return message;
     const input = params.input;
     if (!Array.isArray(input))
         return message;
@@ -547,11 +554,13 @@ export const CodexDriver = {
                     });
                     send({ jsonrpc: "2.0", id, method, params });
                 });
+                let stopping;
+                const terminate = () => stopping ??= killCliTree(child);
                 const stop = () => {
                     stopRequested = true;
-                    killCliTree(child);
+                    return terminate();
                 };
-                const settle = (ok, stopReason) => {
+                const settle = async (ok, stopReason) => {
                     if (state.settled)
                         return;
                     state.settled = true;
@@ -560,9 +569,22 @@ export const CodexDriver = {
                     for (const p of rpcPending.values())
                         p.reject(new Error("turn settled"));
                     rpcPending.clear();
-                    active.delete(threadId);
-                    emit({ ...base(threadId, turnId), type: "turn.completed", ok, stopReason, cost: null, ...(state.usage ? { usage: state.usage } : {}) });
-                    stop(); // the app-server never exits on its own
+                    const complete = () => {
+                        if (active.get(threadId)?.stop !== stop)
+                            return;
+                        active.delete(threadId);
+                        emit({ ...base(threadId, turnId), type: "turn.completed", ok, stopReason, cost: null, ...(state.usage ? { usage: state.usage } : {}) });
+                    };
+                    if (await stop()) {
+                        complete();
+                    }
+                    else {
+                        emit({ ...base(threadId, turnId), type: "runtime.error", message: "codex did not shut down after termination was requested" });
+                        if (child.exitCode !== null || child.signalCode !== null)
+                            complete();
+                        else
+                            child.once("close", complete);
+                    }
                 };
                 // server→client approval request → canonical request.opened
                 // Host-scope tagging mirrors claude.ts: when this turn mounts the real
@@ -789,7 +811,7 @@ export const CodexDriver = {
                         }
                         case "turn/completed": {
                             const t = p.turn ?? {};
-                            settle(t.status === "completed", t.status === "completed" ? null : (t.error?.message ?? t.status ?? "failed"));
+                            void settle(t.status === "completed", t.status === "completed" ? null : (t.error?.message ?? t.status ?? "failed"));
                             break;
                         }
                         case "error":
@@ -808,9 +830,11 @@ export const CodexDriver = {
                 // multibyte characters that straddle two reads and corrupts the text
                 child.stdout.setEncoding("utf8");
                 child.stdout.on("data", (chunk) => {
+                    if (abandoned || state.settled)
+                        return;
                     buf += chunk;
                     let nl;
-                    while ((nl = buf.indexOf("\n")) !== -1) {
+                    while (!state.settled && (nl = buf.indexOf("\n")) !== -1) {
                         const line = buf.slice(0, nl);
                         buf = buf.slice(nl + 1);
                         if (!line.trim())
@@ -852,7 +876,7 @@ export const CodexDriver = {
                     if (abandoned)
                         return;
                     emit({ ...base(threadId, turnId), type: "runtime.error", ...describeSpawnFailure(e, config.cli) });
-                    settle(false, "spawn_error");
+                    void settle(false, "spawn_error");
                 });
                 child.on("close", (code) => {
                     if (abandoned)
@@ -863,7 +887,7 @@ export const CodexDriver = {
                             type: "runtime.error",
                             message: `codex exited ${code} before turn/completed${stderr ? `: ${stderr.trim().slice(-300)}` : ""}`,
                         });
-                        settle(false, "exit_before_result");
+                        void settle(false, "exit_before_result");
                     }
                 });
                 active.set(threadId, { stop, turnId, asks });
@@ -883,26 +907,28 @@ export const CodexDriver = {
                         capabilities: { experimentalApi: true },
                     });
                     send({ jsonrpc: "2.0", method: "initialized", params: {} });
+                    // developerInstructions replaces, rather than appends to, native
+                    // config. Read it for every approval mode so existing rules survive.
+                    // request() already redacts config/read responses from native logs.
+                    let effectiveConfig;
+                    try {
+                        const configured = await request("config/read", {
+                            cwd: turn.cwd ?? homedir(),
+                            includeLayers: false,
+                        });
+                        effectiveConfig = configured?.config;
+                    }
+                    catch {
+                        // Do not expose a possibly secret-bearing native config error or
+                        // overwrite unknown instructions with an empty fallback.
+                        throw new Error("Could not read Codex configuration; cannot safely update bot instructions. Retry after checking Codex.");
+                    }
+                    const developerInstructions = codexDeveloperInstructions(effectiveConfig, turn.system ?? "");
                     let approvalParams;
                     if (approvalMode === "custom") {
                         // config/read returns the effective global + project config for this
                         // cwd. Reasserting those values is essential: simply omitting them
                         // on a resumed thread would keep the previous named mode sticky.
-                        let effectiveConfig;
-                        try {
-                            const configured = await request("config/read", {
-                                cwd: turn.cwd ?? homedir(),
-                                includeLayers: false,
-                            });
-                            effectiveConfig = configured?.config;
-                        }
-                        catch {
-                            // Older app-servers and transient failures cannot prove the
-                            // user's configured sandbox. Fall back to interactive read-only
-                            // instead of inheriting stale Full or silently broadening a
-                            // possibly read-only config to workspace write.
-                            effectiveConfig = {};
-                        }
                         approvalParams = customApprovalParams(effectiveConfig);
                     }
                     else {
@@ -913,6 +939,9 @@ export const CodexDriver = {
                     // mode may synthesize approvals; Custom must preserve the sandbox
                     // boundary from config.toml (for example never + read-only).
                     autoAcceptPermissions = approvalMode === "full";
+                    // Each turn launches a new app-server. Reassert current bot instructions
+                    // on start AND resume so Codex owns their lifetime through compaction.
+                    // Removed bot rules are cleared without dropping native configured rules.
                     const cursor = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
                     let codexThreadId = null;
                     let startedModel = null;
@@ -920,6 +949,7 @@ export const CodexDriver = {
                         try {
                             const resumed = await request("thread/resume", {
                                 threadId: cursor,
+                                developerInstructions,
                                 ...approvalParams.thread,
                             });
                             codexThreadId = resumed?.thread?.id ?? cursor;
@@ -930,23 +960,22 @@ export const CodexDriver = {
                                 // profile selector. Retry the same resume safely rather than
                                 // losing the native thread or inheriting its previous mode.
                                 approvalParams = approvalParams.fallback;
-                                try {
-                                    const resumed = await request("thread/resume", {
-                                        threadId: cursor,
-                                        ...approvalParams.thread,
-                                    });
-                                    codexThreadId = resumed?.thread?.id ?? cursor;
-                                }
-                                catch {
-                                    /* thread gone or resume unsupported — start fresh below */
-                                }
+                                const resumed = await request("thread/resume", {
+                                    threadId: cursor,
+                                    developerInstructions,
+                                    ...approvalParams.thread,
+                                });
+                                codexThreadId = resumed?.thread?.id ?? cursor;
+                            }
+                            else {
+                                throw error;
                             }
-                            /* thread gone or resume unsupported — start fresh below */
                         }
                     }
                     if (!codexThreadId) {
                         const selection = decodeCodexSelection(turn.model);
                         const startThread = () => request("thread/start", {
+                            developerInstructions,
                             cwd: turn.cwd ?? homedir(),
                             model: selection.model,
                             ...(selection.modelProvider ? { modelProvider: selection.modelProvider } : {}),
@@ -966,8 +995,11 @@ export const CodexDriver = {
                         codexThreadId = started?.thread?.id ?? null;
                         startedModel = started?.model ?? null;
                     }
+                    if (!codexThreadId)
+                        throw new Error("Codex did not return a native thread id");
+                    await syncCodexInstructions(threadId, codexThreadId, developerInstructions, Boolean(cursor), request);
                     emit({ ...base(threadId, turnId), type: "session.started", sessionId: codexThreadId, model: startedModel ?? turn.model ?? null });
-                    const promptText = turn.system ? `${turn.system}\n\n${turn.text}` : turn.text;
+                    const promptText = turn.text;
                     const turnInput = [
                         ...(promptText ? [{ type: "text", text: promptText }] : []),
                         ...(turn.images ?? []).map((image) => ({ type: "localImage", path: image.path })),
@@ -1015,7 +1047,10 @@ export const CodexDriver = {
                         // This app-server never exits by itself. Retire the failed attempt
                         // and silence its late handlers before the replacement launches.
                         abandoned = true;
-                        killCliTree(child);
+                        if (!await terminate()) {
+                            void settle(false, "shutdown_timeout");
+                            return;
+                        }
                         await new Promise((resolve) => {
                             const timer = setTimeout(resolve, Math.max(1, Math.round(delayMs * retryScale)));
                             timer.unref?.();
@@ -1024,7 +1059,7 @@ export const CodexDriver = {
                             void launchAttempt(attempt).catch(() => { });
                         }
                         else {
-                            settle(false, "interrupted");
+                            await settle(false, "interrupted");
                         }
                         return;
                     }
@@ -1035,7 +1070,7 @@ export const CodexDriver = {
                             message,
                             ...(needsAuth ? { setup: true } : {}),
                         });
-                        settle(false, needsAuth ? "auth_required" : "rpc_error");
+                        await settle(false, needsAuth ? "auth_required" : "rpc_error");
                     }
                 }
             };
@@ -1087,7 +1122,9 @@ export const CodexDriver = {
                     effortLevels: ["low", "medium", "high", "xhigh", "max"],
                 },
                 sendTurn,
-                interruptTurn: async (threadId) => active.get(threadId)?.stop(),
+                interruptTurn: async (threadId) => {
+                    await active.get(threadId)?.stop();
+                },
                 respondToRequest: async (threadId, requestId, decision) => {
                     const turn = active.get(threadId);
                     const finish = turn?.asks.get(requestId);
@@ -1098,8 +1135,7 @@ export const CodexDriver = {
                 },
                 hasSession: (threadId) => active.has(threadId),
                 stopAll: async () => {
-                    for (const { stop } of active.values())
-                        stop();
+                    await Promise.all([...active.values()].map(({ stop }) => stop()));
                 },
                 onEvent: (listener) => {
                     listeners.add(listener);
@@ -1107,8 +1143,7 @@ export const CodexDriver = {
                 },
             },
             dispose: async () => {
-                for (const { stop } of active.values())
-                    stop();
+                await Promise.all([...active.values()].map(({ stop }) => stop()));
                 listeners.clear();
             },
         };