openmausbot 0.1.78 → 0.1.80

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

@@ -18,7 +18,6 @@ import { augmentedPath } from "../env-path.js";
 import { brokerSocketPath, describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
 import { classifyResumeFailure, mayReplay, recoveryPromptFor } from "../resume-recovery.js";
 import { ClaudeLoginController } from "./claude-login-auth.js";
-import { computerProxyEnv } from "../container-computer.js";
 import { gateServer, resultBudget } from "../mcp-gate-config.js";
 import { newEventId, newId } from "../contracts.js";
 import { askInputSummary, commandSummary, toolDetailPreview } from "../tool-summary.js";
@@ -26,7 +25,7 @@ import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS }
 import { applyClaudeInject, decodeInjectId, mergeLocalInject, probeLocalInjects, resolveInjectId, } from "./local-inject.js";
 import { appendNative } from "./native.js";
 import { SPAWNED_PROXIES } from "../proxy-paths.js";
-import { ASK_USER_QUESTION_TOOL, askQuestionSummary, parseAskQuestions, questionChoices, } from "../../shared/ask-question.js";
+import { ASK_USER_QUESTION_TOOL, askQuestionSummary, parseAskQuestions, parseChoices, questionChoices, } from "../../shared/ask-question.js";
 /** Whether `claude` has been signed in.
  *
  * Credential storage is deliberately not inspected here. Claude Code uses the
@@ -244,11 +243,14 @@ export const CLAUDE_FLAG_FLOORS = {
     "--strict-mcp-config": [1, 0, 60],
     "--setting-sources": [1, 0, 122],
     "--autocompact": [2, 1, 122],
+    // 2.1.267 is the first CLI that accepts it; below that the recorded prompt
+    // simply is not refreshed, which is the pre-existing behaviour.
+    "--system-prompt-snapshot": [2, 1, 267],
 };
 /** The newest floor above: a CLI at or past it accepts everything the
  * harness sends. Below it the engine still works, minus the flags the CLI
  * predates, and the Engines page suggests an update. */
-export const CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--autocompact"];
+export const CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--system-prompt-snapshot"];
 /** `claude --version` prints "2.1.232 (Claude Code)"; the first dotted triple
  * is the version. Null when nothing parses, e.g. a wrapper that prints its
  * own banner first — see claudeCliSupports for how that is treated. */
@@ -274,9 +276,7 @@ export function claudeCliSupports(version, flag) {
     return version === null || versionAtLeast(version, CLAUDE_FLAG_FLOORS[flag]);
 }
 /** The Engines-page notice for a CLI older than the newest floor. The engine
- * keeps working: turns run without the flags the CLI predates, which means
- * no harness-picked compaction window and, on a very old CLI, no isolation
- * from this machine's own Claude Code setup. */
+ * keeps working without the flags its CLI predates. */
 export function claudeCliUpdate(version, cli) {
     const parsed = parseClaudeCliVersion(version);
     if (!parsed || versionAtLeast(parsed, CLAUDE_CONTEXT_CONTROL_MIN_VERSION))
@@ -284,12 +284,15 @@ export function claudeCliUpdate(version, cli) {
     const floor = CLAUDE_CONTEXT_CONTROL_MIN_VERSION.join(".");
     const missing = Object.keys(CLAUDE_FLAG_FLOORS)
         .filter((flag) => !claudeCliSupports(parsed, flag));
+    const effects = [
+        ...(missing.includes("--autocompact") ? ["no compaction window picked by OpenMausBot"] : []),
+        ...(missing.includes("--setting-sources") ? ["bots still see this machine's own Claude Code setup"] : []),
+        ...(missing.includes("--system-prompt-snapshot") ? ["coordinated resumed turns cannot refresh stale system prompts"] : []),
+    ];
     return {
         title: "Update Claude Code for context controls",
         message: `Claude Code ${parsed.join(".")} predates ${floor}, so bots run without ${missing.join(", ")}: ` +
-            "no compaction window picked by OpenMausBot" +
-            (missing.includes("--setting-sources") ? ", and bots still see this machine's own Claude Code setup" : "") +
-            ". Update it, then refresh Engines.",
+            `${effects.join("; ")}. Update it, then refresh Engines.`,
         command: cli === "claude" ? "claude update" : `${cli} update`,
     };
 }
@@ -338,12 +341,15 @@ function extrasFromUnknown(value) {
  *  ANTHROPIC_API_KEY ("Not logged in · Please run /login"). Live injects
  *  come from mergeLocalInject. */
 export function readClaudeModelCatalog(env = process.env) {
+    // A missing or unreadable settings.json is not fatal: an instance whose
+    // environment sets ANTHROPIC_MODEL (a Claude Code install pointed at an
+    // Anthropic-compatible host) still lists that model as Custom.
     let settings = {};
     try {
         settings = JSON.parse(readFileSync(join(resolveClaudeConfigDir(undefined, env), "settings.json"), "utf8"));
     }
     catch {
-        return STATIC_CLAUDE_MODELS;
+        settings = {};
     }
     const extras = [
         ...extrasFromUnknown(settings.availableModels),
@@ -367,7 +373,6 @@ export function readClaudeModelCatalog(env = process.env) {
 // Resolved from the server root, never relative to this file: bundling inlines
 // this module into an entry one directory up, so a `".."` here would climb too
 // far. See server/proxy-paths.ts.
-const PROXY_PATH = SPAWNED_PROXIES.computer;
 const PERM_PROXY_PATH = SPAWNED_PROXIES.permission;
 const DWEB_PROXY_PATH = SPAWNED_PROXIES.dweb;
 // in the packaged app process.execPath is the Electron binary — this env
@@ -682,6 +687,7 @@ function decodeConfig(raw) {
     return {
         cli: typeof o.cli === "string" ? o.cli : "claude",
         ...(configDir ? { configDir } : {}),
+        ...(o.managed === true ? { managed: true } : {}),
         permissionMode: mode ?? "acceptEdits",
         ...(tools !== undefined ? { tools } : {}),
         ...(disallowedTools !== undefined ? { disallowedTools } : {}),
@@ -768,10 +774,12 @@ export const ClaudeDriver = {
     defaultConfig: () => decodeConfig({}),
     async create(input) {
         const { instanceId, config } = input;
-        const environment = (model) => claudeEnvironment(model, { ...process.env, ...input.environment }, config.configDir, input.environment);
+        const environment = (model) => claudeEnvironment(config.managed ? undefined : model, { ...process.env, ...input.environment }, config.configDir, input.environment);
         const catalogEnv = environment();
         let models = STATIC_CLAUDE_MODELS;
         const refreshModels = async () => {
+            if (config.managed)
+                return;
             try {
                 const resolved = await mergeLocalInject(readClaudeModelCatalog(catalogEnv), catalogEnv);
                 if (resolved.options.length)
@@ -787,10 +795,14 @@ export const ClaudeDriver = {
         // harness snapshots every instance whenever it describes them — app
         // load, the Engines page, and right after `claude update`, which is
         // exactly when the answer changes — so a turn normally finds it filled.
-        // A turn before any snapshot assumes a current CLI rather than paying a
-        // CLI start-up of its own: the flags are the default, the exception is
-        // the older install, and the next snapshot corrects it.
+        // Most turns before any snapshot assume a current CLI. A coordinated
+        // turn checks first because the snapshot-refresh flag is newer than the
+        // other context controls and an unknown flag would reject that request.
         let cliVersion = null;
+        let cliVersionChecked = false;
+        const readCliVersion = (env) => new Promise((resolve) => {
+            execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim() || null));
+        });
         const listeners = new Set();
         // one active turn per thread; a second send while busy is a caller bug
         const active = new Map();
@@ -875,8 +887,16 @@ export const ClaudeDriver = {
         // is a fresh sendTurn, and the attempt cap must survive across launches
         const retryState = new Map();
         const sendTurn = async (turn, logicalTurnId) => {
+            if (config.managed && (!turn.model || turn.model.includes("::") || !config.configDir ||
+                !input.environment.ANTHROPIC_API_KEY || !input.environment.ANTHROPIC_BASE_URL)) {
+                throw new Error("Company model access is unavailable. Reconnect your organization; personal billing will not be used.");
+            }
             const { threadId, botId } = turn;
-            if (active.has(threadId))
+            // An internal relaunch (transient failure, rejected resume) keeps the
+            // logical turn's stop handle in `active` while it sets up, so Stop is
+            // never a silent no-op between two CLI processes of the same turn.
+            const relaunch = logicalTurnId !== undefined;
+            if (active.has(threadId) && !relaunch)
                 throw new Error("a turn is already running on this thread");
             // A bot-level mode is authoritative for this turn. In particular, an
             // old provider instance may still be configured with
@@ -901,7 +921,10 @@ export const ClaudeDriver = {
             const turnId = logicalTurnId ?? newId();
             const retryAbort = new AbortController();
             const retry = retryState.get(threadId) ?? { attempt: 0, cancelled: false };
-            retry.cancelled = false;
+            // A fresh user turn starts un-cancelled. A relaunch must keep a Stop
+            // that landed while it was being scheduled.
+            if (!relaunch)
+                retry.cancelled = false;
             retryState.set(threadId, retry);
             // a retry relaunches the whole CLI; the backoff is scaled down in tests
             // so a fake's transient failures don't stall real seconds
@@ -924,6 +947,13 @@ export const ClaudeDriver = {
                 args.push("--disallowedTools", config.disallowedTools.join(","));
             }
             const turnEnvironment = environment();
+            if (turn.refreshSystemPrompt && !cliVersionChecked) {
+                const version = await readCliVersion(turnEnvironment);
+                if (version) {
+                    cliVersion = parseClaudeCliVersion(version);
+                    cliVersionChecked = true;
+                }
+            }
             const isolated = !inheritsUserConfig(turnEnvironment);
             if (isolated) {
                 // A bot gets the tools and instructions its owner gave it, not
@@ -944,8 +974,16 @@ export const ClaudeDriver = {
             if (compactWindow && claudeCliSupports(cliVersion, "--autocompact")) {
                 args.push("--autocompact", compactWindow);
             }
-            const turnModel = await resolveClaudeTurnModel(turn.model, turnEnvironment);
-            const injected = applyClaudeInject({ ...turnEnvironment }, turnModel);
+            // An old pair conversation can still carry its first assignment in
+            // Claude's recorded system prompt. The current brief rides in the user
+            // turn, so refresh the recorded prompt on --resume too. Gated by the
+            // version floor like every other flag the CLI may predate: an unknown
+            // flag is a hard argument error, not a graceful degrade.
+            if (turn.refreshSystemPrompt && cliVersionChecked && claudeCliSupports(cliVersion, "--system-prompt-snapshot")) {
+                args.push("--system-prompt-snapshot", "off");
+            }
+            const turnModel = config.managed ? turn.model : await resolveClaudeTurnModel(turn.model, turnEnvironment);
+            const injected = config.managed ? { model: turnModel ?? null, injected: false } : applyClaudeInject({ ...turnEnvironment }, turnModel);
             if (injected.model)
                 args.push("--model", injected.model);
             if (turn.effort)
@@ -964,15 +1002,7 @@ export const ClaudeDriver = {
                 mcpServers.composio = { ...turn.integrations.composio };
                 allowed.push("mcp__composio");
             }
-            if (turn.integrations?.computer) {
-                mcpServers.computer = {
-                    command: process.execPath,
-                    args: [PROXY_PATH],
-                    env: { ...NODE_ENV_FLAG, ...computerProxyEnv(turn.integrations.computer) },
-                };
-                allowed.push("mcp__computer");
-            }
-            else if (turn.integrations?.localComputer) {
+            if (turn.integrations?.localComputer) {
                 const local = turn.integrations.localComputer;
                 mcpServers.computer = {
                     command: local.command,
@@ -1216,9 +1246,7 @@ export const ClaudeDriver = {
                                 questions: questions ?? undefined,
                                 // A structured ask still offers flat labels, for the phone
                                 // companions and any client that predates the question card.
-                                choices: questions
-                                    ? questionChoices(questions)
-                                    : Array.isArray(ask.input?.choices) ? ask.input.choices.slice(0, 5) : undefined,
+                                choices: questions ? questionChoices(questions) : parseChoices(ask.input?.choices),
                             });
                         },
                         onResolve: (resolved) => {
@@ -1259,6 +1287,16 @@ export const ClaudeDriver = {
                 cleanupUnownedLaunch();
                 throw error;
             }
+            // Stop reached the relaunch handle while this attempt was still setting
+            // up (model probe, broker). Settle the logical turn as interrupted
+            // instead of spawning a process nobody wants.
+            if (relaunch && retry.cancelled) {
+                cleanupUnownedLaunch();
+                if (active.get(threadId)?.turnId === turnId)
+                    active.delete(threadId);
+                emit({ ...base(threadId, turnId), type: "turn.completed", ok: false, stopReason: "interrupted", cost: null });
+                return { turnId };
+            }
             let child;
             try {
                 child = spawnCli(config.cli, args, {
@@ -1409,6 +1447,9 @@ export const ClaudeDriver = {
                                 ...(typeof msg.usage.cache_read_input_tokens === "number"
                                     ? { cachedInput: msg.usage.cache_read_input_tokens }
                                     : {}),
+                                // one assistant message = one model call, and its prompt is
+                                // everything in the window: fresh text, cache reads and writes
+                                contextTokens: (msg.usage.input_tokens || 0) + (msg.usage.cache_read_input_tokens || 0) + (msg.usage.cache_creation_input_tokens || 0),
                             });
                         }
                         break;
@@ -1544,14 +1585,18 @@ export const ClaudeDriver = {
                                 });
                                 return;
                             }
-                            // hand the thread back before recursing — the relaunch's own
-                            // guard would otherwise reject it as "already running"
-                            active.delete(threadId);
+                            // Keep Stop reachable while the relaunch sets up: there is no
+                            // process yet, so this handle only records the cancellation and
+                            // the relaunched sendTurn honors it before spawning.
+                            retryState.set(threadId, retry);
+                            active.set(threadId, { stop: () => { retry.cancelled = true; retryAbort.abort(); }, turnId });
                             try {
                                 const cursor = session.sessionId ?? sessionId ?? undefined;
                                 await sendTurn({ ...turn, resumeCursor: cursor }, turnId);
                             }
                             catch (e) {
+                                if (active.get(threadId)?.turnId === turnId)
+                                    active.delete(threadId);
                                 retryState.delete(threadId);
                                 emit({
                                     ...base(threadId, turnId),
@@ -1605,7 +1650,9 @@ export const ClaudeDriver = {
                         }
                         sessions.delete(threadId);
                         session.turn = null;
-                        active.delete(threadId);
+                        // Same relaunch handle as the transient-retry path above.
+                        retryState.set(threadId, retry);
+                        active.set(threadId, { stop: () => { retry.cancelled = true; retryAbort.abort(); }, turnId });
                         emit({
                             ...base(threadId, turnId),
                             type: "turn.retrying",
@@ -1619,6 +1666,8 @@ export const ClaudeDriver = {
                                 await sendTurn({ ...turn, resumeCursor: undefined, recoveryText: undefined, text: recovery.text }, turnId);
                             }
                             catch (e) {
+                                if (active.get(threadId)?.turnId === turnId)
+                                    active.delete(threadId);
                                 retryState.delete(threadId);
                                 emit({
                                     ...base(threadId, turnId),
@@ -1687,12 +1736,11 @@ export const ClaudeDriver = {
         const login = new ClaudeLoginController({ cli: config.cli, environment, onAuthenticated: async () => { await refreshModels(); } });
         const snapshot = async () => {
             const env = environment();
-            const version = await new Promise((resolve) => {
-                execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim()));
-            });
+            const version = await readCliVersion(env);
             if (!version)
                 return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
             cliVersion = parseClaudeCliVersion(version);
+            cliVersionChecked = true;
             const auth = await claudeAuthStatus(config.cli, env);
             // claudeEnvironment strips ANTHROPIC_API_KEY, so turns run on the
             // CLI's own login (Pro/Max): the cost it reports is what the call