openmausbot 0.1.94 → 0.1.95

package/dist-server/server/drivers/chat-mcp-tools.js

@@ -7,7 +7,6 @@ import { stripControlPlaneEnv } from "../config.js";
 import { augmentedPath } from "../env-path.js";
 import { killCliTree, spawnCli } from "../procs.js";
 import { chatImage } from "./chat-images.js";
-import { ChatBoatClient } from "./chat-boat-tools.js";
 import { mcpStdioServer } from "../mcp-gate-config.js";
 import { allowsTool, canUseMcpServer, parseToolScope } from "../../shared/tool-scope.js";
 /** The transport cannot safely continue this turn. A dispatched operation may
@@ -238,7 +237,7 @@ const validatorOptions = {
     // or describe an open tuple. Ajv still enforces every constraint.
     strictRequired: false, strictTypes: false, strictTuples: false,
 };
-function compileSchema(schema) {
+export function compileToolSchema(schema) {
     const dialect = schema.$schema;
     if (dialect !== undefined && dialect !== "http://json-schema.org/draft-07/schema#" && dialect !== "https://json-schema.org/draft/2020-12/schema") {
         throw new Error("MCP tool schema uses an unsupported dialect; use JSON Schema draft-07 or 2020-12");
@@ -291,8 +290,6 @@ export async function mountChatTools(integrations, signal, computerUse = false,
     const scope = parsed.scope;
     const servers = [];
     const eligible = (server) => scope === undefined || canUseMcpServer(scope, server);
-    if (computerUse && integrations?.computer && eligible("computer"))
-        servers.push(["computer", integrations.computer]);
     if (computerUse && integrations?.localComputer && eligible("computer"))
         servers.push(["computer", integrations.localComputer]);
     if (computerUse && integrations?.browser && eligible("browser"))
@@ -339,10 +336,10 @@ export async function mountChatTools(integrations, signal, computerUse = false,
                 throw aborted();
             // Every mounted MCP server can return images when the caller enables
             // image delivery, including custom servers. Text stays bounded below.
-            const client = "boxId" in descriptor ? new ChatBoatClient(descriptor) : new ChatMcpClient(descriptor, computerUse);
+            const client = new ChatMcpClient(descriptor, computerUse);
             clients.push(client);
             const include = (tool) => scope === undefined || (object(tool) && typeof tool.name === "string" && allowsTool(scope, { kind: "mcp", server: name, name: tool.name }));
-            const tools = client instanceof ChatMcpClient ? await client.tools(signal, include) : (await client.tools()).filter(include);
+            const tools = await client.tools(signal, include);
             return { name, client, builtInBrowser: descriptor === integrations?.browser, tools };
         }));
         for (const mount of mounts) {
@@ -360,7 +357,7 @@ export async function mountChatTools(integrations, signal, computerUse = false,
                     throw new Error("MCP tools require an object input schema");
                 if (Buffer.byteLength(JSON.stringify(tool.inputSchema)) > SCHEMA_BYTES)
                     throw new Error("MCP tool schema exceeds the 64KB limit");
-                const schema = compileSchema(tool.inputSchema);
+                const schema = compileToolSchema(tool.inputSchema);
                 const parameters = { ...tool.inputSchema };
                 const constraints = {};
                 if (computerUse) {

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

@@ -6,8 +6,9 @@
 //
 // Integrations become MCP servers on the CLI:
 //   - Composio Sessions (connected apps → tools) over streamable HTTP
-//   - the bot's cloud computer (boat.dev) via server/computer-proxy.ts
-//     — screenshot/exec/open_url, the CUA-on-the-boat bridge
+//   - every computer (this Mac, a Local VM, a VPS, or a Boat cloud
+//     computer through server/harness-mcp-proxy.ts computer) as the one
+//     stdio `computer` server in turn.integrations.localComputer
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { createServer as createNetServer } from "node:net";
@@ -339,7 +340,7 @@ export function claudeCliUpdate(version, cli) {
     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"] : []),
+        ...(missing.includes("--system-prompt-snapshot") ? ["resumed turns cannot refresh stale system prompts"] : []),
     ];
     return {
         title: "Update Claude Code for context controls",
@@ -1034,10 +1035,11 @@ 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.
-        // Most flags before any snapshot assume a current CLI; autocompact
-        // requires confirmed help support. 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.
+        // A turn that finds it empty reads the version itself first: the
+        // snapshot-refresh flag every turn passes is newer than the other context
+        // controls, and an unknown flag would reject the turn. If that read
+        // fails, most flags assume a current CLI; the snapshot flag needs a
+        // confirmed version and autocompact a confirmed help listing.
         let cliVersion = null;
         let cliVersionChecked = false;
         // Whether `claude --help` lists --autocompact, read once per CLI version
@@ -1203,7 +1205,7 @@ export const ClaudeDriver = {
                 args.push("--disallowedTools", config.disallowedTools.join(","));
             }
             const turnEnvironment = environment();
-            if ((turn.refreshSystemPrompt || turn.guestConfined || turn.toolScope !== undefined) && !cliVersionChecked) {
+            if (!cliVersionChecked) {
                 const version = await readCliVersion(turnEnvironment);
                 if (version) {
                     cliVersion = parseClaudeCliVersion(version);
@@ -1246,12 +1248,12 @@ export const ClaudeDriver = {
             if (compactWindow && cliHasAutocompact === true) {
                 args.push("--autocompact", compactWindow);
             }
-            // 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")) {
+            // A resumed conversation can still carry an earlier assignment, place
+            // or teammate list in Claude's recorded system prompt, so every turn
+            // refreshes 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 (cliVersionChecked && claudeCliSupports(cliVersion, "--system-prompt-snapshot")) {
                 args.push("--system-prompt-snapshot", "off");
             }
             const turnModel = config.managed ? turn.model : await resolveClaudeTurnModel(turn.model, turnEnvironment);

package/dist-server/server/drivers/openai-chat.js

@@ -325,7 +325,7 @@ export function createOpenAIChatRuntime(options) {
             throw new Error(options.missingKeyError);
         if (active.has(turn.threadId))
             throw new Error("a turn is already running on this thread");
-        if (options.computerUse && (turn.images?.length || turn.integrations?.computer || turn.integrations?.localComputer || turn.integrations?.browser))
+        if (options.computerUse && (turn.images?.length || turn.integrations?.localComputer || turn.integrations?.browser))
             assertImageTransport(options.apiUrl);
         const turnId = newId();
         const abort = new AbortController();
@@ -334,7 +334,7 @@ export function createOpenAIChatRuntime(options) {
         for (const message of messages)
             retainImages(message.content);
         const model = turn.model || options.models().default;
-        const secrets = [options.apiKey, turn.integrations?.computer?.token, turn.integrations?.computer?.control?.token].filter((value) => Boolean(value));
+        const secrets = [options.apiKey].filter((value) => Boolean(value));
         for (const integration of Object.values(turn.integrations ?? {})) {
             const entries = object(integration);
             const specs = entries && "command" in entries ? [entries] : Object.values(entries ?? {}).map(object);
@@ -695,10 +695,7 @@ export function createOpenAIChatRuntime(options) {
         adapter: {
             provider: options.driverKind,
             capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false,
-                    // Same gate as cloudComputerMcp: with tools off the runtime cannot
-                    // mount the leased Boat descriptor either. The fleet invariant test
-                    // pins usesCloudComputer === (remoteAgent || cloudComputerMcp).
-                    usesCloudComputer: options.tools !== false, cloudComputerMcp: options.tools !== false, localComputerMcp: options.tools !== false,
+                    localComputerMcp: options.tools !== false,
                     browserMcp: options.tools !== false, nativeImageInput: true, images: true } : {}),
                 sessionModelSwitch: "in-session", customMcp: options.tools !== false, agentsMcp: options.tools !== false, composioMcp: options.tools !== false,
                 // The runtime owns the whole tool loop, so it can always take a

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

@@ -17,6 +17,10 @@ const TERMINAL_PATTERNS = [
         pattern: /\b(?:40[13]|unauthorized|forbidden|invalid api key|missing bearer|authentication required|not logged in|logged out)\b/i,
         reason: "auth",
     },
+    // A subscription's usage window is hours away, so its limit is terminal
+    // for this engine even when the provider phrases it as a rate limit;
+    // checked before the transient 429 pattern for that reason.
+    { pattern: /\busage limit\b|\bhit your (?:usage )?limit\b|\b(?:weekly|daily|monthly|subscription|usage) limit reached\b|\bout of credits\b/i, reason: "quota" },
     { pattern: /\b402\b|\bquota\b|\bbilling\b|\bsubscription\b/i, reason: "quota" },
     { pattern: /\bmodel not found\b|\bunknown model\b|\bdoes not exist for model\b|\bunsupported model\b/i, reason: "unknown_model" },
     { pattern: /\b400\b|\b422\b|\binvalid request\b|\bmalformed\b|\bunexpected status\b/i, reason: "invalid_request" },
@@ -50,14 +54,14 @@ export function classifyError(err) {
         const { exitCode: code } = err;
         if (code !== null && code < 0)
             return { transient: false, reason: "interrupted" };
-        for (const { pattern, reason } of TRANSIENT_PATTERNS) {
-            if (pattern.test(text))
-                return { transient: true, reason };
-        }
         for (const { pattern, reason } of TERMINAL_PATTERNS) {
             if (pattern.test(text))
                 return { transient: false, reason };
         }
+        for (const { pattern, reason } of TRANSIENT_PATTERNS) {
+            if (pattern.test(text))
+                return { transient: true, reason };
+        }
         return { transient: false, reason: "terminal_exit" };
     }
     for (const { pattern, reason } of TERMINAL_PATTERNS) {

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

@@ -4,7 +4,7 @@
 // driver's own install descriptor and never from a request, npm runs with
 // a fixed argument list, and the binary is found on the engines' PATH
 // afterwards because that directory is registered ahead of everything else.
-import { existsSync, mkdirSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { DATA_DIR, stripWorkspaceCredentialEnv } from "./config.js";
@@ -169,7 +169,3 @@ function runNpm(args, env, cwd, timeoutMs) {
         });
     });
 }
-/** True once something has been installed here, for status pages. */
-export function enginesInstalled(baseDir = DATA_DIR) {
-    return existsSync(enginesBinDir(baseDir));
-}

package/dist-server/server/harness/registry.js

@@ -228,7 +228,6 @@ export class ProviderRegistry {
                     modelVariants: inst.adapter.capabilities.modelVariants === true,
                     queueing: inst.adapter.capabilities.queueing === true,
                     localComputerMcp: inst.adapter.capabilities.localComputerMcp === true,
-                    cloudComputerMcp: inst.adapter.capabilities.cloudComputerMcp === true,
                     approvalReview: inst.reviewPermission !== undefined,
                 },
                 access: driver?.metadata.access ?? "subscription",

package/dist-server/server/{browser-proxy.js → harness-mcp-proxy.js}

@@ -1,17 +1,29 @@
-// Per-turn MCP entry point. Only a scoped browser capability crosses into the
-// agent process; engine commands, session names, and credentials stay in OMB.
+// Per-turn MCP entry point for the tools the harness serves itself: the
+// built-in browser and the cloud computer. argv[2] names which one. Only a
+// turn-scoped capability crosses into the agent process; engine commands,
+// session names, and provider credentials (the Boat token) stay in OMB.
 import { pathToFileURL } from "node:url";
 const MAX_INPUT_BYTES = 1_048_576;
 const MAX_OUTPUT_BYTES = 16_777_216;
 const MAX_PENDING = 16;
+const NAMES = { browser: "Browser", computer: "Cloud computer" };
+/** What a model needs after a failed call, per tool family: the failure is
+ * about this one connection, and an uncertain action must be checked first. */
+const RECOVERY = {
+    browser: " This failure does not establish that all browsers are unavailable. Inspect available connections with select_computer if that tool is present. Keep the requested computer and account; do not bypass a permission refusal or human takeover, and do not repeat an uncertain action without checking its result.",
+    computer: " Keep working on the assigned cloud computer only; do not bypass a person's control of it, and take a fresh screenshot before repeating an action whose result is uncertain.",
+};
+export function parseHarnessMcpKind(value) {
+    return value === "browser" || value === "computer" ? value : null;
+}
 function failure(id, method, message, code = -32603) {
     return method === "tools/call"
         ? { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: message }], isError: true } }
         : { jsonrpc: "2.0", id, error: { code, message } };
 }
-async function boundedJson(response) {
+async function boundedJson(response, name) {
     if (!response.body)
-        throw new Error("Browser server returned an empty response.");
+        throw new Error(`${name} server returned an empty response.`);
     const reader = response.body.getReader();
     const chunks = [];
     let size = 0;
@@ -22,7 +34,7 @@ async function boundedJson(response) {
                 break;
             size += value.byteLength;
             if (size > MAX_OUTPUT_BYTES)
-                throw new Error("Browser response exceeded the size limit.");
+                throw new Error(`${name} response exceeded the size limit.`);
             chunks.push(Buffer.from(value));
         }
         return JSON.parse(Buffer.concat(chunks).toString("utf8"));
@@ -31,7 +43,7 @@ async function boundedJson(response) {
         await reader.cancel().catch(() => { });
     }
 }
-export async function browserProxyRequest(frame, connection) {
+export async function harnessMcpRequest(frame, connection) {
     if (!frame || typeof frame !== "object" || Array.isArray(frame))
         return failure(null, null, "Invalid request.", -32600);
     const message = frame;
@@ -40,10 +52,11 @@ export async function browserProxyRequest(frame, connection) {
         return failure(null, null, "Invalid request.", -32600);
     if (!Object.hasOwn(message, "id"))
         return undefined;
+    const name = NAMES[connection.kind];
     if (message.method === "initialize")
         return {
             jsonrpc: "2.0", id,
-            result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "openmausbot-browser", version: "1" } },
+            result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: `openmausbot-${connection.kind}`, version: "1" } },
         };
     if (message.method === "ping")
         return { jsonrpc: "2.0", id, result: {} };
@@ -52,30 +65,30 @@ export async function browserProxyRequest(frame, connection) {
     try {
         const url = new URL(connection.url);
         if (!connection.token || url.protocol !== "http:" || !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
-            throw new Error("Browser connection is not configured. Start a new bot turn from OpenMausBot.");
+            throw new Error(`${name} connection is not configured. Start a new bot turn from OpenMausBot.`);
         }
         const body = JSON.stringify({ method: message.method, params: message.params ?? {} });
         if (Buffer.byteLength(body) > MAX_INPUT_BYTES)
-            throw new Error("Browser request exceeded the size limit.");
-        const response = await fetch(new URL("/api/internal/browser/mcp", url), {
+            throw new Error(`${name} request exceeded the size limit.`);
+        const response = await fetch(new URL(`/api/internal/${connection.kind}/mcp`, url), {
             method: "POST", redirect: "error",
             headers: { "content-type": "application/json", authorization: `Bearer ${connection.token}` },
             body, signal: AbortSignal.timeout(130_000),
         });
-        const payload = await boundedJson(response);
+        const payload = await boundedJson(response, name);
         if (!response.ok || !payload || typeof payload !== "object" || !Object.hasOwn(payload, "result")) {
-            throw new Error(typeof payload?.error === "string" ? payload.error.slice(0, 2_000) : "Browser server is unavailable. Start a new bot turn or try again.");
+            throw new Error(typeof payload?.error === "string" ? payload.error.slice(0, 2_000) : `${name} server is unavailable. Start a new bot turn or try again.`);
         }
         return { jsonrpc: "2.0", id, result: payload.result };
     }
     catch (error) {
         const detail = error instanceof Error && !/fetch failed|abort|timeout/i.test(error.message)
-            ? error.message : "Browser connection was interrupted. Do not repeat the action until its state is checked.";
-        return failure(id, message.method, detail + " This failure does not establish that all browsers are unavailable. Inspect available connections with select_computer if that tool is present. Keep the requested computer and account; do not bypass a permission refusal or human takeover, and do not repeat an uncertain action without checking its result.");
+            ? error.message : `${name} connection was interrupted. Do not repeat the action until its state is checked.`;
+        return failure(id, message.method, detail + RECOVERY[connection.kind]);
     }
 }
-function run() {
-    const connection = { url: process.env.OMB_HARNESS_URL ?? "", token: process.env.OMB_BROWSER_TOKEN ?? "" };
+function run(kind) {
+    const connection = { url: process.env.OMB_HARNESS_URL ?? "", token: process.env.OMB_MCP_TOKEN ?? "", kind };
     let input = Buffer.alloc(0);
     let pending = 0;
     const output = (message) => {
@@ -114,11 +127,11 @@ function run() {
             if (pending >= MAX_PENDING) {
                 const request = frame;
                 if (request && Object.hasOwn(request, "id"))
-                    output(failure(request.id ?? null, request.method, "Too many pending browser requests."));
+                    output(failure(request.id ?? null, request.method, `Too many pending ${kind} requests.`));
                 continue;
             }
             pending++;
-            void browserProxyRequest(frame, connection).then(output).finally(() => { pending--; });
+            void harnessMcpRequest(frame, connection).then(output).finally(() => { pending--; });
         }
         if (input.length > MAX_INPUT_BYTES) {
             process.stdin.destroy();
@@ -126,5 +139,12 @@ function run() {
         }
     });
 }
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
-    run();
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const kind = parseHarnessMcpKind(process.argv[2]);
+    if (!kind) {
+        process.stderr.write("usage: harness-mcp-proxy browser|computer\n");
+        process.exitCode = 2;
+    }
+    else
+        run(kind);
+}