openmausbot 0.1.88 → 0.1.90

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

@@ -7,7 +7,7 @@
 // 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-box bridge
+//     — screenshot/exec/open_url, the CUA-on-the-boat bridge
 import { createHash, randomBytes } from "node:crypto";
 import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { createServer as createNetServer } from "node:net";
@@ -435,7 +435,7 @@ function askQuestions(ask) {
 function askSummary(ask) {
     const questions = askQuestions(ask);
     if (questions)
-        return askQuestionSummary(questions).slice(0, 300);
+        return askQuestionSummary(questions);
     return askInputSummary(ask.input) ?? ask.tool ?? "tool";
 }
 /** Where the hook helper reads this thread's current turn token. Stable per
@@ -752,6 +752,109 @@ function firstText(content) {
     }
     return "";
 }
+/** A turn's own cost from the CLI's total_cost_usd, which is not a per-turn
+ * figure: it is "cumulative across turns in streaming-input sessions — each
+ * result carries the running total so far" (2.1.282), and a retained process
+ * runs turn after turn. So a turn costs the growth since the total its
+ * process reported for the turn before — or, for a process's first turn,
+ * since the total the CLI restored on --resume (see restoredCostBase). With
+ * no known start (null) the turn keeps its whole figure. A total that went
+ * down is not the same count, so it is taken whole too rather than booked as
+ * a negative cost. Rounding to 1e-10 USD removes only the float noise of the
+ * subtraction. */
+export function turnCostFromRunningTotal(total, previous) {
+    if (total === null)
+        return null;
+    if (previous === null || total < previous)
+        return total;
+    return Number((total - previous).toFixed(10));
+}
+export function claudeCostSnapshot(total, modelUsage) {
+    if (typeof total !== "number" || !Number.isFinite(total))
+        return null;
+    const count = (value) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
+    const models = {};
+    if (modelUsage && typeof modelUsage === "object" && !Array.isArray(modelUsage)) {
+        for (const [model, raw] of Object.entries(modelUsage)) {
+            if (!raw || typeof raw !== "object")
+                continue;
+            const u = raw;
+            models[model] = [count(u.inputTokens), count(u.cacheReadInputTokens), count(u.cacheCreationInputTokens), count(u.outputTokens)];
+        }
+    }
+    return { total, models };
+}
+/** The running total a resumed session already carried before this
+ * process's first turn. On --resume the CLI (2.1.282) restores the session's
+ * cost from an earlier state — not always the latest one this driver saw —
+ * so that turn's total_cost_usd and modelUsage include the earlier turns.
+ * The restored state is the earlier state that sits inside the new counts
+ * and leaves exactly this turn's own usage: in one model (usage leaves out
+ * side calls such as a Haiku title) or summed over all models (a turn split
+ * between two); nothing restored is 0. When no state fits exactly — the CLI
+ * saved work that never reported a result, like an interrupted turn — the
+ * latest state inside the new counts stands, so that work is booked once,
+ * with this turn. Either way the latest state wins, not the highest total:
+ * a resume that went back to an older state leaves later, lower totals. */
+export function restoredCostBase(earlier, current, usage) {
+    const turn = [usage.input, usage.cacheRead, usage.cacheWrite, usage.output];
+    const nothing = { total: 0, models: {} };
+    let exact = null;
+    let inside = 0;
+    // oldest first: the session's states in the order they were recorded
+    for (const state of [nothing, ...earlier]) {
+        const within = Object.entries(state.models).every(([model, counts]) => counts.every((n, i) => n <= (current.models[model]?.[i] ?? 0)));
+        if (!within)
+            continue;
+        inside = state.total;
+        const growth = Object.entries(current.models).map(([model, counts]) => counts.map((n, i) => n - (state.models[model]?.[i] ?? 0)));
+        const isTurn = (counts) => counts.every((n, i) => n === turn[i]);
+        const summed = turn.map((_, i) => growth.reduce((sum, counts) => sum + counts[i], 0));
+        if (growth.some(isTurn) || isTurn(summed))
+            exact = state.total;
+    }
+    return exact ?? inside;
+}
+/** Each Claude session's latest cost states, so the first turn after a
+ * --resume can tell what the CLI restored — after an app restart too. Small
+ * by design: a few states for the most recent sessions. */
+const COST_HISTORY_FILE = join(DATA_DIR, "claude-cost-history.json");
+const COST_HISTORY_SESSIONS = 100;
+const COST_HISTORY_STATES = 8;
+function isCostSnapshot(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const { total, models } = value;
+    return typeof total === "number" && !!models && typeof models === "object" &&
+        Object.values(models).every((counts) => Array.isArray(counts) && counts.length === 4 && counts.every((n) => typeof n === "number"));
+}
+function readCostHistory() {
+    try {
+        const parsed = JSON.parse(readFileSync(COST_HISTORY_FILE, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return Object.fromEntries(Object.entries(parsed).map(([id, states]) => [id, Array.isArray(states) ? states.filter(isCostSnapshot) : []]));
+    }
+    catch {
+        return {};
+    }
+}
+function recordCostState(sessionId, state) {
+    const history = readCostHistory();
+    const states = [...(history[sessionId] ?? []), state].slice(-COST_HISTORY_STATES);
+    // most recent session last, so the oldest ones are dropped first
+    delete history[sessionId];
+    history[sessionId] = states;
+    const ids = Object.keys(history);
+    for (const id of ids.slice(0, Math.max(0, ids.length - COST_HISTORY_SESSIONS)))
+        delete history[id];
+    try {
+        writeFileAtomic(COST_HISTORY_FILE, JSON.stringify(history), { mode: 0o600 });
+    }
+    catch {
+        // a lost state only means a later resume keeps its whole figure
+    }
+}
 /** Claude's stream-json input accepts the same image source blocks as the
  * Anthropic Messages API. Keep the old string form for text-only turns so a
  * CLI update cannot disturb the overwhelmingly common path. */
@@ -1155,7 +1258,7 @@ export const ClaudeDriver = {
             mcpServers.ogb = { command: process.execPath, args: [PERM_PROXY_PATH, socketPath], env: { ...NODE_ENV_FLAG }, alwaysLoad: true };
             allowed.push("mcp__ogb");
             // The MCP config carries credentials — a Composio consumer key in a
-            // header, the box token in the computer proxy's env, the comms token in
+            // header, the boat token in the computer proxy's env, the comms token in
             // the agents proxy's env. On argv every one of those is world-readable
             // through `ps` for the life of the turn, to any local process. The CLI
             // accepts a FILE for this flag, so the secrets go in a 0600 file that
@@ -1414,11 +1517,12 @@ export const ClaudeDriver = {
                 idleTimer: null,
                 closing: false,
                 stderr: "",
+                costTotal: undefined,
             };
             sessions.set(threadId, session);
             // settles the TURN, not the process: the CLI stays for the next
             // message until it has been quiet for SESSION_IDLE_MS
-            const settle = (ok, stopReason, cost = null, usage) => {
+            const settle = (ok, stopReason, total = null, usage) => {
                 const t = session.turn;
                 if (!t || t.settled)
                     return;
@@ -1450,11 +1554,31 @@ export const ClaudeDriver = {
                 // retry resumes on a fresh process; healthy sibling sessions stay warm.
                 if (stopReason === "update_required")
                     closeSession(threadId, "update required");
+                // `total` is the CLI's running total for this process; the harness
+                // books turn.completed.cost as this turn's own spend
+                const cost = turnCostFromRunningTotal(total, session.costTotal ?? null);
+                if (total !== null)
+                    session.costTotal = total;
                 emit({ ...base(threadId, t.turnId), type: "turn.completed", ok, stopReason, cost, ...(usage ? { usage } : {}) });
                 if (session.child.exitCode === null && !session.closing)
                     armIdle(threadId);
             };
             const currentTurnId = () => session.turn?.turnId ?? turnId;
+            // The process's first result with a cost says what --resume restored,
+            // which its turns are measured from; every result is kept for a later
+            // resume. A result without one (an API error) decides nothing yet.
+            const noteCostState = (total, modelUsage, usage) => {
+                const state = claudeCostSnapshot(total, modelUsage);
+                if (!state)
+                    return;
+                if (session.costTotal === undefined) {
+                    session.costTotal = session.sessionId
+                        ? restoredCostBase(readCostHistory()[session.sessionId] ?? [], state, usage)
+                        : null;
+                }
+                if (session.sessionId)
+                    recordCostState(session.sessionId, state);
+            };
             const handleLine = (line) => {
                 if (session.closing)
                     return;
@@ -1575,11 +1699,19 @@ export const ClaudeDriver = {
                         // and deny approvals while that user turn is still running.
                         if (o.origin?.kind === "task-notification")
                             break;
-                        // result.usage is this invocation's total — one process per turn,
-                        // so it is the turn's figure. cache reads count as input: they
-                        // are billed (at the cache rate) and they fill the window — but
-                        // they are reported separately too, so the UI can show how much
-                        // of the figure was context re-read rather than new text.
+                        // result.usage is this turn's own figure, "per-turn in
+                        // streaming-input sessions" (2.1.282) even on a retained process.
+                        // cache reads count as input: they are billed (at the cache rate)
+                        // and they fill the window — but they are reported separately
+                        // too, so the UI can show how much of the figure was context
+                        // re-read rather than new text. total_cost_usd is instead the
+                        // process's running total; settle() books this turn's share.
+                        noteCostState(o.total_cost_usd, o.modelUsage, {
+                            input: o.usage?.input_tokens || 0,
+                            cacheRead: o.usage?.cache_read_input_tokens || 0,
+                            cacheWrite: o.usage?.cache_creation_input_tokens || 0,
+                            output: o.usage?.output_tokens || 0,
+                        });
                         settle(o.is_error !== true, session.turn?.authFailed
                             ? "auth_required"
                             : session.turn?.updateRequired
@@ -1877,10 +2009,11 @@ export const ClaudeDriver = {
          * summaries can contain paths, commands, or secrets, so the generic
          * `claude -p "prompt"` shape is not safe for review. No tools or MCP
          * servers are mounted in this isolated process. */
-        const generateReview = (prompt, signal) => new Promise((resolve, reject) => {
-            const child = spawnCli(config.cli, ["-p", "--model", config.managedModels?.[0] ?? "claude-haiku-4-5", "--output-format", "text"], {
+        const generateReview = (prompt, signal, onUsage) => new Promise((resolve, reject) => {
+            const model = config.managedModels?.[0] ?? "claude-haiku-4-5";
+            const child = spawnCli(config.cli, ["-p", "--model", model, "--output-format", onUsage ? "json" : "text"], {
                 stdio: ["pipe", "pipe", "pipe"],
-                env: environment(config.managedModels?.[0] ?? "claude-haiku-4-5"),
+                env: environment(model),
             });
             let stdout = "";
             let stderr = "";
@@ -1919,6 +2052,37 @@ export const ClaudeDriver = {
             });
             child.on("error", (error) => finish(error));
             child.on("close", (code) => {
+                if (settled)
+                    return;
+                if (onUsage) {
+                    try {
+                        const result = JSON.parse(stdout);
+                        if (!result || result.type !== "result")
+                            throw new Error("Claude text generation returned no result");
+                        const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+                        const cachedInput = count(result.usage?.cache_read_input_tokens);
+                        const inputs = [count(result.usage?.input_tokens), cachedInput, count(result.usage?.cache_creation_input_tokens)]
+                            .filter((value) => value !== undefined);
+                        const models = result.modelUsage && typeof result.modelUsage === "object" && !Array.isArray(result.modelUsage)
+                            ? Object.keys(result.modelUsage) : [];
+                        onUsage({
+                            model: models.length === 1 ? models[0] : models.find(candidate => candidate === model || candidate.startsWith(`${model}-`)) ?? model,
+                            input: inputs.length ? inputs.reduce((sum, value) => sum + value, 0) : undefined,
+                            output: count(result.usage?.output_tokens),
+                            cachedInput,
+                            costUsd: count(result.total_cost_usd),
+                        });
+                        if (result.is_error === true)
+                            throw new Error(typeof result.result === "string" && result.result.trim() ? result.result : stderr.trim() || "Claude text generation failed");
+                        if (typeof result.result !== "string")
+                            throw new Error("Claude text generation returned no text");
+                        stdout = result.result;
+                    }
+                    catch (error) {
+                        finish(error instanceof Error ? error : new Error(String(error)));
+                        return;
+                    }
+                }
                 if (code === 0)
                     finish();
                 else
@@ -2000,7 +2164,7 @@ export const ClaudeDriver = {
                     return () => listeners.delete(listener);
                 },
             },
-            generateText: (prompt, options) => generateReview(prompt, options?.signal),
+            generateText: (prompt, options) => generateReview(prompt, options?.signal, options?.onUsage),
             reviewPermission: generateReview,
             dispose: async () => {
                 try {

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

@@ -11,7 +11,7 @@ export function appendNative(threadId, entry) {
     const file = join(NATIVE_DIR, `${threadId}.ndjson`);
     try {
         // The session-setup messages carry the credentials the agent is handed —
-        // the box and comms tokens ride inside session/new's mcpServers env, and
+        // the boat and comms tokens ride inside session/new's mcpServers env, and
         // an MCP header can carry a Composio key. These files are ordinary
         // 0644 files people paste into bug reports, so values are masked while
         // the shape stays intact.

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

@@ -64,7 +64,7 @@ export function createOpenAIChatRuntime(options) {
         turnId,
         createdAt: new Date().toISOString(),
     });
-    const complete = async (messages, model, stream, signal, onDelta, tools = []) => {
+    const complete = async (messages, model, stream, signal, onDelta, tools = [], onUsage) => {
         // Idle timer that is renewed on every received chunk during streaming
         const timeoutController = new AbortController();
         let idleTimer = null;
@@ -99,6 +99,17 @@ export function createOpenAIChatRuntime(options) {
             }
             if (!stream || response.headers.get("content-type")?.includes("application/json")) {
                 const json = await response.json();
+                if (onUsage) {
+                    activeSignal.throwIfAborted();
+                    const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+                    onUsage({
+                        model: typeof json.model === "string" && json.model.trim() ? json.model : model,
+                        input: count(json.usage?.prompt_tokens),
+                        output: count(json.usage?.completion_tokens),
+                        cachedInput: count(json.usage?.prompt_tokens_details?.cached_tokens),
+                        costUsd: count(json.usage?.cost),
+                    });
+                }
                 const bodyError = providerError(json);
                 if (bodyError)
                     throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
@@ -617,7 +628,11 @@ export function createOpenAIChatRuntime(options) {
             : { state: "unavailable", reason: options.unavailableReason },
         adapter: {
             provider: options.driverKind,
-            capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false, cloudComputerMcp: options.tools !== false, localComputerMcp: options.tools !== false,
+            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,
                     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
@@ -657,9 +672,9 @@ export function createOpenAIChatRuntime(options) {
                 return () => listeners.delete(listener);
             },
         },
-        generateText: async (prompt, { signal } = {}) => {
+        generateText: async (prompt, { signal, onUsage } = {}) => {
             const model = options.generateModel?.() ?? options.models().default;
-            const { text, reasoning, toolCalls } = await complete([{ role: "user", content: prompt }], model, false, signal);
+            const { text, reasoning, toolCalls } = await complete([{ role: "user", content: prompt }], model, false, signal, undefined, [], onUsage);
             if (toolCalls.length)
                 throw new ChatProtocolError("provider returned tool calls to a text-only helper");
             return text.trim() ? text : reasoning;

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

@@ -465,7 +465,7 @@ export const PiDriver = {
                 ensurePiInjectModel(turn.model, { ...process.env, ...input.environment });
             }
             // integrations → stdio MCP servers for the pi-mcp-extension. The config
-            // carries credentials (box token, composio key, comms token), so it goes
+            // carries credentials (boat token, composio key, comms token), so it goes
             // into a 0600 temp file removed when the turn settles — never on argv.
             const mcpServers = buildMcpServers(turn);
             let mcpTempDir = null;
@@ -476,7 +476,7 @@ export const PiDriver = {
                 }
                 catch (err) {
                     // A failed write must not leave the temp dir behind — a partial file
-                    // could still hold the box token / composio key / comms token.
+                    // could still hold the boat token / composio key / comms token.
                     try {
                         rmSync(mcpTempDir, { recursive: true, force: true });
                     }
@@ -488,7 +488,7 @@ export const PiDriver = {
             }
             const childArgs = mcpServers ? [...PI_ARGS, "-e", SPAWNED_PROXIES.piMcpExtension] : PI_ARGS;
             // spawnCli can throw synchronously (unresolvable CLI); if it does, the
-            // 0600 temp file with the box token / composio key / comms token must
+            // 0600 temp file with the boat token / composio key / comms token must
             // not be left on disk — settle() never runs because no child existed.
             const child = (() => {
                 try {

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

@@ -7,7 +7,7 @@
 // uses one envelope profile and lets the per-driver capability decide the
 // delta; the tool names themselves come from the real catalog, so this
 // never drifts from what a turn is actually shown.
-import { APPROVAL_MODES, supportsApprovalMode } from "../shared/approval-mode.js";
+import { APPROVAL_MODES, supportsApprovalMode as driverKindSupportsApprovalMode } from "../shared/approval-mode.js";
 import { availableTools } from "./drivers/agents-catalog.js";
 /** The widest turn the harness can build: every optional integration on and
  * a coordinating (room) turn, where the room-only coordination tools exist.
@@ -35,8 +35,8 @@ export function harnessCapabilityLines(from, to) {
             : "Loses peer coordination and every team tool: " + names.length + " tools including " + coordination.join(", ") + " go away.");
     }
     if (from.driverKind !== to.driverKind) {
-        const lost = APPROVAL_MODES.filter((mode) => supportsApprovalMode(from.driverKind, mode) && !supportsApprovalMode(to.driverKind, mode));
-        const gained = APPROVAL_MODES.filter((mode) => !supportsApprovalMode(from.driverKind, mode) && supportsApprovalMode(to.driverKind, mode));
+        const lost = APPROVAL_MODES.filter((mode) => driverKindSupportsApprovalMode(from.driverKind, mode) && !driverKindSupportsApprovalMode(to.driverKind, mode));
+        const gained = APPROVAL_MODES.filter((mode) => !driverKindSupportsApprovalMode(from.driverKind, mode) && driverKindSupportsApprovalMode(to.driverKind, mode));
         if (lost.length)
             lines.push("Loses approval levels: " + lost.join(", ") + ".");
         if (gained.length)
@@ -44,3 +44,18 @@ export function harnessCapabilityLines(from, to) {
     }
     return lines;
 }
+/** Binds the registry to the approval-support check so each gate passes its
+ * model selection — or a driver view it already holds — and stops
+ * unwrapping registry.cliTarget(...)?.driverKind at every call site. The
+ * lookup prefers shadow state, so a mid-reconfig instance answers with the
+ * driver it would actually run. */
+export function createApprovalModeSupport(registry) {
+    return function supportsApprovalMode(target, mode) {
+        const driverKind = target === undefined
+            ? undefined
+            : "driverKind" in target
+                ? target.driverKind
+                : registry.cliTarget(target.instanceId)?.driverKind;
+        return driverKindSupportsApprovalMode(driverKind, mode);
+    };
+}

package/dist-server/server/hosted-models.js

@@ -2,6 +2,7 @@ import { existsSync, lstatSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.js";
+import { cloudHomeConfigured } from "./cloud-home.js";
 import { hostedWorkspaceConfiguration } from "./enterprise.js";
 export const HOSTED_MODEL_POLICY_HEADER = "X-Omb-Hosted-Model-Policy";
 export const HOSTED_MODEL_SETUP_ERROR = "No company models are assigned to this workspace. Ask your administrator to enable model access in Admin.";
@@ -15,10 +16,14 @@ const catalogSchema = z.object({
 }).strict();
 const providerFor = { claude: "anthropic", codex: "openai", opencode: "openrouter" };
 /** Operator-only policy. An ordinary desktop has neither input and keeps its
- * personal providers. Partial policy configuration must never enable them. */
+ * personal providers. Partial policy configuration must never enable them.
+ * A Cloud home never routes to a model gateway: it ignores both inputs
+ * (cloud-home.ts), and its person signs in with their own engines. */
 export function hostedModelPolicy(dataDirectory, env = process.env) {
     if (env.OMB_HOSTED_MODELS === undefined && env.OMB_HOSTED_MODEL_TOKEN === undefined)
         return null;
+    if (cloudHomeConfigured(env))
+        return null;
     const hosted = hostedWorkspaceConfiguration(env);
     if (!hosted?.portalMembership || env.OMB_DESKTOP_PARENT === "1" || !/^omb_workspace_[A-Za-z0-9_-]{43}$/.test(env.OMB_HOSTED_MODEL_TOKEN ?? "")) {
         throw new Error("Hosted model access requires complete portal-managed configuration.");