openmausbot 0.1.72 → 0.1.74

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

@@ -482,12 +482,15 @@ export async function createPermissionBroker(opts) {
                     continue;
                 }
                 const ask = { id: askId, kind, tool: msg.tool ?? "tool", input: msg.input ?? {}, at: Date.now() };
-                const finish = (behavior, message, source) => {
+                const finish = (behavior, message, source, always) => {
                     if (!pending.delete(askId))
                         return;
                     clearTimeout(timer);
                     try {
-                        conn.write(JSON.stringify({ t: "answer", id: askId, behavior, message }) + "\n");
+                        // `always` rides to the proxy, which hands the CLI's own suggested
+                        // permission rules back as updatedPermissions: Claude remembers
+                        // the allow for the session, the harness remembers nothing.
+                        conn.write(JSON.stringify({ t: "answer", id: askId, behavior, message, ...(always ? { always: true } : {}) }) + "\n");
                     }
                     catch { }
                     opts.onResolve({ ...ask, behavior, source });
@@ -570,13 +573,13 @@ export async function createPermissionBroker(opts) {
         }
     };
     return {
-        answer(askId, behavior, message) {
+        answer(askId, behavior, message, always) {
             const p = pending.get(askId);
             if (!p)
                 return false;
             if (p.ask.kind === "question" ? behavior !== "answer" : behavior === "answer")
                 return false;
-            p.finish(behavior, message, "user");
+            p.finish(behavior, message, "user", always && behavior === "allow");
             return true;
         },
         pause() {
@@ -752,6 +755,12 @@ export const ClaudeDriver = {
             ? configuredIdleMinimum
             : 10_000;
         const SESSION_IDLE_MS = Math.max(sessionIdleMinimum, Number(process.env.OMB_CLAUDE_SESSION_IDLE_MS) || 10 * 60_000);
+        const stopSession = (session) => {
+            void killCliTree(session.child).then((stopped) => {
+                if (stopped)
+                    void session.finishClose?.();
+            });
+        };
         const closeSession = (threadId, why) => {
             const s = sessions.get(threadId);
             if (!s || s.closing)
@@ -772,8 +781,7 @@ export const ClaudeDriver = {
             }
             catch { }
             const kill = setTimeout(() => {
-                if (s.child.exitCode === null)
-                    killCliTree(s.child);
+                stopSession(s);
             }, 5_000);
             kill.unref?.();
         };
@@ -833,7 +841,8 @@ export const ClaudeDriver = {
             const permissionMode = turn.approvalMode === undefined
                 ? config.permissionMode
                 : turn.approvalMode === "full" ? "bypassPermissions"
-                    : turn.approvalMode === "auto" ? "auto" : "default";
+                    : turn.approvalMode === "auto" ? "auto"
+                        : turn.approvalMode === "edits" ? "acceptEdits" : "default";
             const controlsHost = turn.integrations?.localComputer?.scope === "local-computer";
             if (controlsHost && permissionMode === "bypassPermissions" && turn.approvalMode !== "full") {
                 throw new Error("local computer control requires the interactive approval broker");
@@ -1049,7 +1058,7 @@ export const ClaudeDriver = {
                 live.turn = { turnId, settled: false, sawStreamDelta: false };
                 active.set(threadId, { stop: () => {
                         closeSession(threadId, "interrupted");
-                        killCliTree(live.child);
+                        stopSession(live);
                     }, turnId, broker: live.broker });
                 emit({ ...base(threadId, turnId), type: "turn.started" });
                 const volatile = turn.systemVolatile ?? "";
@@ -1121,6 +1130,13 @@ export const ClaudeDriver = {
                         onAsk: (ask) => {
                             const eventTurnId = sessions.get(threadId)?.turn?.turnId ?? turnId;
                             askTools.set(ask.id, typeof ask.tool === "string" ? ask.tool : undefined);
+                            // Auto was requested: say whether the CLI's reviewer is actually
+                            // running, from init, so the harness can tell a classifier's
+                            // verdict from a Manual session asking about everything.
+                            const nativeMode = sessions.get(threadId)?.nativePermissionMode ?? null;
+                            const nativeReview = permissionMode === "auto" && nativeMode !== null
+                                ? nativeMode === "auto" ? "active" : "inactive"
+                                : undefined;
                             emit({
                                 ...base(threadId, eventTurnId),
                                 type: "request.opened",
@@ -1128,6 +1144,10 @@ export const ClaudeDriver = {
                                 requestType: ask.kind,
                                 tool: ask.tool,
                                 summary: askSummary(ask),
+                                nativeReview,
+                                // the proxy hands Claude its own suggested rules on `always`;
+                                // host control stays one action at a time
+                                allowSession: ask.kind === "permission" && !(controlsHost && typeof ask.tool === "string" && ask.tool.startsWith("mcp__computer")) ? true : undefined,
                                 approvalScope: typeof ask.tool === "string" && controlsHost && ask.tool.startsWith("mcp__computer")
                                     ? "local-computer"
                                     : undefined,
@@ -1190,6 +1210,7 @@ export const ClaudeDriver = {
                 volatile: turn.systemVolatile ?? "",
                 sessionId: sessionId ?? newSessionId,
                 sawInit: false,
+                nativePermissionMode: null,
                 turn: { turnId, settled: false, sawStreamDelta: false },
                 idleTimer: null,
                 closing: false,
@@ -1231,6 +1252,8 @@ export const ClaudeDriver = {
             };
             const currentTurnId = () => session.turn?.turnId ?? turnId;
             const handleLine = (line) => {
+                if (session.closing)
+                    return;
                 let o;
                 try {
                     o = JSON.parse(line);
@@ -1243,6 +1266,7 @@ export const ClaudeDriver = {
                     case "system":
                         if (o.subtype === "init") {
                             session.sawInit = true;
+                            session.nativePermissionMode = typeof o.permissionMode === "string" ? o.permissionMode : null;
                             if (typeof o.session_id === "string")
                                 session.sessionId = o.session_id;
                             emit({ ...base(threadId, currentTurnId()), type: "session.started", sessionId: o.session_id, model: o.model });
@@ -1371,7 +1395,22 @@ export const ClaudeDriver = {
                 emit({ ...base(threadId, currentTurnId()), type: "runtime.error", ...describeSpawnFailure(e, config.cli) });
                 settle(false, "spawn_error");
             });
-            child.on("close", (code) => {
+            let closeFinalized = false;
+            const finalizeClose = async (code) => {
+                if (closeFinalized)
+                    return;
+                // The root can close while its MCP helpers are still running. Join
+                // an in-flight stop (or reap its remaining group) before releasing
+                // the turn so a replacement cannot overlap the old helpers.
+                if (!(await killCliTree(child, 0))) {
+                    session.broker?.close();
+                    session.broker = undefined;
+                    emit({ ...base(threadId, currentTurnId()), type: "runtime.error", message: "Claude could not be confirmed stopped; its helper processes may still be running." });
+                    return;
+                }
+                if (closeFinalized)
+                    return;
+                closeFinalized = true;
                 // a turn still running when the process died is a failed turn; a
                 // process that exited between turns (idle close, contract change)
                 // is just a session ending
@@ -1536,6 +1575,10 @@ export const ClaudeDriver = {
                 removePrivateTempDir(session.systemPromptPath);
                 if (sessions.get(threadId) === session)
                     sessions.delete(threadId);
+            };
+            child.on("close", (code) => {
+                session.finishClose = () => finalizeClose(code);
+                void session.finishClose();
             });
             const stop = () => {
                 // taskkill is asynchronous on Windows. Retire steering and approvals
@@ -1543,7 +1586,7 @@ export const ClaudeDriver = {
                 closeSession(threadId, "interrupted");
                 retry.cancelled = true;
                 retryAbort.abort();
-                killCliTree(child);
+                stopSession(session);
             };
             active.set(threadId, { stop, turnId, broker });
             emit({ ...base(threadId, turnId), type: "turn.started" });
@@ -1683,7 +1726,7 @@ export const ClaudeDriver = {
                     if (!broker)
                         return "unavailable";
                     const behavior = decision.behavior === "answer" ? "answer" : decision.behavior;
-                    if (!broker.answer(requestId, behavior, decision.message))
+                    if (!broker.answer(requestId, behavior, decision.message, decision.always))
                         return "unavailable";
                     return behavior === "allow" ? "allowed-once" : behavior === "answer" ? "answered" : "rejected";
                 },

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

@@ -181,6 +181,9 @@ function mcpAppApprovalForm(params) {
 /** Codex persists these values on its native thread. Keep them explicit on
  * start, resume, and every turn so switching modes cannot leave a more
  * permissive sandbox/reviewer stuck to the next request. */
+/** Ask and Edits both run Codex's workspace-write sandbox with the person as
+ * reviewer: Codex has no narrower "edits only" mode, so the selector never
+ * offers Edits for it (supportsApprovalMode) and a stray value asks. */
 function namedApprovalParams(mode) {
     if (mode === "full") {
         return {
@@ -515,6 +518,10 @@ export const CodexDriver = {
                     stdio: ["pipe", "pipe", "pipe"],
                 });
                 let abandoned = false;
+                let codexThreadId = null;
+                let codexTurnId = null;
+                let startingNativeTurn = false;
+                const earlyNotifications = [];
                 const state = {
                     settled: false,
                     lastText: "",
@@ -553,6 +560,21 @@ export const CodexDriver = {
                     rpcPending.set(id, {
                         resolve: (v) => {
                             clearTimeout(timer);
+                            if (method === "turn/start") {
+                                if (typeof v?.turn?.id !== "string" || !v.turn.id) {
+                                    reject(new Error("Codex did not return a native turn id"));
+                                    return;
+                                }
+                                // Bind synchronously: a single stdout chunk can contain the
+                                // response, streamed events, completion and a late request.
+                                codexTurnId = v.turn.id;
+                                startingNativeTurn = false;
+                                for (const notification of earlyNotifications.splice(0)) {
+                                    if (state.settled)
+                                        break;
+                                    handleNotification(notification);
+                                }
+                            }
                             resolve(v);
                         },
                         reject: (e) => {
@@ -563,10 +585,18 @@ export const CodexDriver = {
                     send({ jsonrpc: "2.0", id, method, params });
                 });
                 let stopping;
-                const terminate = () => stopping ??= killCliTree(child);
-                const stop = () => {
+                const terminate = () => stopping ??= killCliTree(child).then((stopped) => {
+                    if (!stopped)
+                        stopping = undefined;
+                    return stopped;
+                });
+                let completeStoppedTurn;
+                const stop = async () => {
                     stopRequested = true;
-                    return terminate();
+                    const stopped = await terminate();
+                    if (stopped)
+                        completeStoppedTurn?.();
+                    return stopped;
                 };
                 const settle = async (ok, stopReason) => {
                     if (state.settled)
@@ -583,15 +613,9 @@ export const CodexDriver = {
                         active.delete(threadId);
                         emit({ ...base(threadId, turnId), type: "turn.completed", ok, stopReason, cost: null, ...(state.usage ? { usage: state.usage } : {}) });
                     };
-                    if (await stop()) {
-                        complete();
-                    }
-                    else {
+                    completeStoppedTurn = complete;
+                    if (!(await stop())) {
                         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
@@ -710,6 +734,33 @@ export const CodexDriver = {
                 };
                 const handleNotification = (msg) => {
                     const p = msg.params ?? {};
+                    // An app-server also emits notifications for native helper threads.
+                    // Only this request's parent may write its transcript/usage or settle
+                    // its run. Requests still use the approval broker above, including
+                    // helper requests; ignoring child *notifications* must not grant tools.
+                    const connectionError = msg.method === "error" &&
+                        !("threadId" in p) && !("turnId" in p);
+                    if (!connectionError) {
+                        if (!codexThreadId || p.threadId !== codexThreadId)
+                            return;
+                        if (!codexTurnId) {
+                            // Some servers stream before acknowledging turn/start. Retain a
+                            // bounded prefix, then filter against the authoritative response.
+                            if (startingNativeTurn) {
+                                if (earlyNotifications.length >= 1024) {
+                                    void settle(false, "too_many_events_before_turn_start");
+                                }
+                                else {
+                                    earlyNotifications.push(msg);
+                                }
+                            }
+                            return;
+                        }
+                        const eventTurnId = msg.method === "turn/started" || msg.method === "turn/completed"
+                            ? p.turn?.id : p.turnId;
+                        if (eventTurnId !== codexTurnId)
+                            return;
+                    }
                     switch (msg.method) {
                         // token-level chat text; the item/completed frame follows with the
                         // whole message, so its delta is only a fallback when none streamed
@@ -897,6 +948,12 @@ export const CodexDriver = {
                 child.on("close", (code) => {
                     if (abandoned)
                         return;
+                    if (state.settled) {
+                        // Root exit alone cannot release a turn after an uncertain stop.
+                        // Recheck its group; an explicit later Stop can also retry this.
+                        void stop();
+                        return;
+                    }
                     if (!state.settled) {
                         emit({
                             ...base(threadId, turnId),
@@ -959,7 +1016,6 @@ export const CodexDriver = {
                     // 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;
                     if (cursor) {
                         try {
@@ -1020,21 +1076,24 @@ export const CodexDriver = {
                         ...(promptText ? [{ type: "text", text: promptText }] : []),
                         ...(turn.images ?? []).map((image) => ({ type: "localImage", path: image.path })),
                     ];
-                    const startTurn = () => request("turn/start", {
-                        threadId: codexThreadId,
-                        input: turnInput,
-                        ...approvalParams.turn,
-                        // Spread, not `effort: turn.effort ?? null`. Probed against
-                        // codex-cli 0.146.0: null is indistinguishable from an absent key
-                        // — both leave the thread's current effort alone, emitting no
-                        // thread/settings/updated, and thread/resume reads the old value
-                        // back. The app-server offers no way to clear a level either:
-                        // "" is rejected outright and thread/start takes no effort at
-                        // all. So a thread keeps the last level it was sent until it is
-                        // sent another, and choosing Default lands on the bot's next new
-                        // thread rather than the current one.
-                        ...(turn.effort ? { effort: turn.effort } : {}),
-                    });
+                    const startTurn = () => {
+                        startingNativeTurn = true;
+                        return request("turn/start", {
+                            threadId: codexThreadId,
+                            input: turnInput,
+                            ...approvalParams.turn,
+                            // Spread, not `effort: turn.effort ?? null`. Probed against
+                            // codex-cli 0.146.0: null is indistinguishable from an absent key
+                            // — both leave the thread's current effort alone, emitting no
+                            // thread/settings/updated, and thread/resume reads the old value
+                            // back. The app-server offers no way to clear a level either:
+                            // "" is rejected outright and thread/start takes no effort at
+                            // all. So a thread keeps the last level it was sent until it is
+                            // sent another, and choosing Default lands on the bot's next new
+                            // thread rather than the current one.
+                            ...(turn.effort ? { effort: turn.effort } : {}),
+                        });
+                    };
                     try {
                         await startTurn();
                     }

package/dist-server/server/engine-install.js

@@ -112,10 +112,16 @@ function runNpm(args, env, cwd, timeoutMs) {
         let timedOut = false;
         const timer = setTimeout(() => {
             timedOut = true;
-            void killCliTree(child);
+            void killCliTree(child).then((stopped) => {
+                rejectRun(new Error(stopped
+                    ? "The install took too long and was stopped. Check the server's network connection and try again."
+                    : "The install took too long, but npm could not be confirmed stopped. Ask the server administrator to stop the install process before trying again."));
+            });
         }, timeoutMs);
         timer.unref();
         child.once("error", (error) => {
+            if (timedOut)
+                return; // A failed kill is not a failed npm launch.
             clearTimeout(timer);
             rejectRun(new Error(error.code === "ENOENT"
                 ? "npm is not installed on this server. Install Node.js with npm for the user running OpenMausBot, then try again."
@@ -123,10 +129,8 @@ function runNpm(args, env, cwd, timeoutMs) {
         });
         child.once("close", (code) => {
             clearTimeout(timer);
-            if (timedOut) {
-                rejectRun(new Error("The install took too long and was stopped. Check the server's network connection and try again."));
-                return;
-            }
+            if (timedOut)
+                return; // The whole group must stop, not just npm's root.
             resolveRun({ code, output });
         });
     });