openmausbot 0.1.96 → 0.1.97

package/dist-server/permission-proxy.js

@@ -8,7 +8,6 @@ var MAX_OPTIONS = 12;
 var MAX_QUESTION_TEXT = 8e3;
 var MAX_LABEL = 120;
 var MAX_DESCRIPTION = 400;
-var MAX_CUSTOM_ANSWER = 2e3;
 function text(value, limit) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
@@ -60,9 +59,6 @@ function parseAskQuestions(input) {
   }
   return questions.length ? questions : null;
 }
-var OMB_ASK_FENCE = /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[ \t]*omb-ask[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]{0,3}\2[ \t]*(?=\r?\n|$)/;
-var OMB_ASK_FENCE_GLOBAL = new RegExp(OMB_ASK_FENCE.source, OMB_ASK_FENCE.flags + "g");
-var MAX_ANSWER_ECHO = 6 * MAX_CUSTOM_ANSWER;
 function questionAnswersByQuestion(message, questions) {
   return questionAnswersById(message, questions.map((question) => ({ id: question.question, question })));
 }

package/dist-server/server/auto-approve.js

@@ -79,7 +79,7 @@ export function delegatedApprovalMode(input) {
 // the permission path in permission-proxy). Approving it there does not
 // produce an answer: the CLI runs the tool with none and the model is told
 // "The user did not answer the questions." — a question silently lost.
-const ASKS_A_PERSON = new Set(["askuserquestion", "ask_user", "omb-ask"]);
+const ASKS_A_PERSON = new Set(["askuserquestion", "ask_user"]);
 // A web search is a low-level read. Approve for me allows these names and
 // nothing wider: a bare search, a page fetch, and every other tool stay a
 // prompt. The name is the same shape as a question — one mcp__<server>__

package/dist-server/server/auto-vm-claims.js

@@ -18,6 +18,18 @@ export function startAutoVmClaim(table, threadId, generation) {
     slot.begin = slot.claim().then(() => { slot.claimed = true; }, (error) => {
         slot.failed = true;
         slot.failure = error instanceof Error ? error.message : String(error);
-        slot.onRejected?.(slot.failure);
+        slot.onRejected?.(slot.failure, error);
     });
 }
+/** How long a computer call should wait on its thread's lazy claim, or null
+ * when it should not wait: the first call waits while the claim it fires
+ * lands; a slow claim (graceMs) is waited on by every call until it settles. */
+export function lazyClaimWaitMs(slot, defaultGraceMs) {
+    if (!slot?.lazy)
+        return null;
+    if (!slot.begin)
+        return slot.graceMs ?? defaultGraceMs;
+    if (slot.graceMs !== undefined && !slot.claimed && !slot.failed)
+        return slot.graceMs;
+    return null;
+}

package/dist-server/server/automatic-recovery.js

@@ -3,8 +3,7 @@ import { supportsWorkspaceFiles } from "./workspace.js";
  * its filesystem to another machine. Approval and organisation policy are
  * checked by the ordinary model-switch and turn-admission gates. */
 export function recoveryCapabilityError(from, to) {
-    if (from.capabilities.remoteAgent || to.capabilities.remoteAgent ||
-        supportsWorkspaceFiles(from.driverKind) !== supportsWorkspaceFiles(to.driverKind)) {
+    if (supportsWorkspaceFiles(from.driverKind) !== supportsWorkspaceFiles(to.driverKind)) {
         return "The backup cannot use the same workspace.";
     }
     const tools = ["agentsMcp", "computerMcp", "composioMcp",

package/dist-server/server/boat.js

@@ -86,13 +86,12 @@ function scopedBoatPrefix() {
     scopedBoatPrefixCache = `ogb-${scope}-`;
     return scopedBoatPrefixCache;
 }
-/** Decide lifecycle work before a turn mounts Boat. Auto may observe and
- * attach an already-ready Boat, but only explicit Cloud may create or wake. */
-export function boatTurnLifecycleAction({ explicitCloud, state, }) {
+/** Decide lifecycle work before a turn mounts Boat. Only a turn whose place
+ * is Cloud gets here (Auto never reads the Boat account), so a missing Boat
+ * is created and a sleeping one woken. */
+export function boatTurnLifecycleAction(state) {
     if (state && READY.has(state))
         return "attach";
-    if (!explicitCloud)
-        return "none";
     return state ? "wake" : "provision";
 }
 /** Keep one provider account for the whole logical operation. Settings may
@@ -346,36 +345,46 @@ async function mintDesktopUrl(cfg, boxId, { vncBudgetMs = 60_000 } = {}) {
 }
 async function waitReady(cfg, boxId, budgetMs = 90_000) {
     assertBoatNotDeleting(boxId);
-    const t0 = Date.now();
+    const deadline = Date.now() + budgetMs;
+    // Every request ends with the budget: a relay that accepts the connection
+    // and then stalls must not hold a turn's start past it.
+    const untilDeadline = () => AbortSignal.timeout(Math.max(1, deadline - Date.now()));
+    const outOfTime = (error) => error instanceof Error && error.name === "TimeoutError";
     // Boat's words for the last failed resume, if the wait runs out on them.
     let resumeFailure = null;
-    while (Date.now() - t0 < budgetMs) {
-        assertBoatNotDeleting(boxId);
-        const { body } = await boatJson(cfg, `/boxes/${boxId}`);
-        const state = body?.box?.state;
-        if (READY.has(state))
-            return body.box;
-        if (state === "error")
-            return null;
-        // an archiving boat can't resume until the snapshot lands — nudge after.
-        // A refusal (a plan limit, say) is final: report it now. A server error
-        // is retried on the next poll, as Boat asks; 409 is a state race with a
-        // wake already under way.
-        if (state === "archived") {
-            const resumed = await boatJson(cfg, `/boxes/${boxId}/resume`, { method: "POST" });
-            if (resumed.ok)
-                resumeFailure = null;
-            else if (resumed.status !== 409) {
-                const message = boatErrorMessage(resumed.status, "waking the cloud computer", resumed.body, usesIncludedBoat(cfg));
-                if (resumed.status < 500)
-                    throw new Error(message);
-                resumeFailure = message;
+    try {
+        while (Date.now() < deadline) {
+            assertBoatNotDeleting(boxId);
+            const { body } = await boatJson(cfg, `/boxes/${boxId}`, { signal: untilDeadline() });
+            const state = body?.box?.state;
+            if (READY.has(state))
+                return body.box;
+            if (state === "error")
+                return null;
+            // an archiving boat can't resume until the snapshot lands — nudge after.
+            // A refusal (a plan limit, say) is final: report it now. A server error
+            // is retried on the next poll, as Boat asks; 409 is a state race with a
+            // wake already under way.
+            if (state === "archived") {
+                const resumed = await boatJson(cfg, `/boxes/${boxId}/resume`, { method: "POST", signal: untilDeadline() });
+                if (resumed.ok)
+                    resumeFailure = null;
+                else if (resumed.status !== 409) {
+                    const refusal = boatRefusal(resumed.status, "waking the cloud computer", resumed.body, usesIncludedBoat(cfg));
+                    if (resumed.status < 500)
+                        throw refusal;
+                    resumeFailure = refusal;
+                }
             }
+            await new Promise((r) => setTimeout(r, Math.min(2500, Math.max(0, deadline - Date.now()))));
         }
-        await new Promise((r) => setTimeout(r, 2500));
+    }
+    catch (error) {
+        if (!outOfTime(error))
+            throw error;
     }
     if (resumeFailure)
-        throw new Error(resumeFailure);
+        throw resumeFailure;
     return null;
 }
 // Resolving a bot's boat means LISTing every boat in the account, so it is
@@ -948,6 +957,17 @@ export function boatErrorMessage(status, what, body, included = false) {
     }
     return theirs ? `${what} failed: ${theirs}` : `${what} failed (${status})`;
 }
+/** A refused start as an error that keeps the provider's status and code
+ * (the Admin's own, such as subscription_inactive), so a failed place is
+ * read from the code first and from the words only until every refusal
+ * has one (shared/place-view.ts cloudRefusal). Named apart from `status`,
+ * which a route would answer with. */
+export function boatRefusal(status, what, body, included = false) {
+    const code = body?.error?.code ?? body?.code;
+    return Object.assign(new Error(boatErrorMessage(status, what, body, included)), {
+        boatStatus: status, ...(typeof code === "string" && /^[a-z0-9_]{1,64}$/.test(code) ? { boatCode: code } : {}),
+    });
+}
 /** boat.dev trial accounts reject the normal eight-hour auto-stop with a
  * structured `trial_auto_stop_required` refusal. Retry that one condition
  * once at the provider's advertised maximum (or the documented two-hour
@@ -967,44 +987,13 @@ function idempotentCreateInProgress(result) {
     const code = result.body?.error?.code ?? result.body?.code;
     return result.status === 409 && code === "idempotency_in_progress";
 }
-/** The keys this OpenMausBot already holds, as the environment its bots'
- * agents read on the boat. The boat is created with `noEnv: true`, so the
- * boat.dev account's own logins never land in the guest: the boat has exactly
- * these and nothing else (see "Whose keys" in the Boat integrated-agents docs). */
-export function boatCredentialEnv(cfg, env = process.env) {
-    const out = {};
-    const put = (name, value) => {
-        if (typeof value === "string" && value.trim())
-            out[name] = value.trim();
-    };
-    // The workspace key only: an ANTHROPIC_API_KEY in the server's own env is
-    // never the workspace key (see loadConfig), so it is not forwarded either.
-    put("ANTHROPIC_API_KEY", cfg.anthropic?.key);
-    for (const name of BOAT_FORWARDED_CREDENTIAL_ENV)
-        put(name, env[name]);
-    return out;
-}
-/** Names the boat's agents read (Claude Code, Codex, pi, OpenCode, Prime
- * Agent, Kimi), forwarded verbatim from this server's environment when set. */
-const BOAT_FORWARDED_CREDENTIAL_ENV = [
-    "CLAUDE_CODE_OAUTH_TOKEN",
-    "OPENAI_API_KEY",
-    "OPENROUTER_API_KEY",
-    "LLMGATEWAY_API_KEY",
-    "DEEPSEEK_API_KEY",
-    "MOONSHOT_API_KEY",
-    "KIMI_CODE_ACCESS_TOKEN",
-    "KIMI_CODE_REFRESH_TOKEN",
-];
-async function requestBoatCreate(cfg, botId, ttlSeconds, env) {
-    // The computer needs the user's desktop session, not the account owner's
-    // host credentials. Keep provider-side env injection off; the only keys the
-    // guest ever has are the ones this OpenMausBot forwards (`env`), which its
-    // agents need now that the turn runs on the boat. The idempotency identity
-    // stays the secret-free part: a trial-TTL retry must receive a different
-    // key, and the journal on disk never carries a credential.
+async function requestBoatCreate(cfg, botId, ttlSeconds) {
+    // The computer is a desktop the bot's own engine drives from here, so it
+    // needs no AI sign-in of its own: provider-side env injection stays off and
+    // no key this OpenMausBot holds is ever sent to it. A trial-TTL retry must
+    // receive a different idempotency key, and the journal on disk never
+    // carries a credential.
     const body = JSON.stringify({ ttlSeconds, noEnv: true });
-    const wireBody = JSON.stringify({ ttlSeconds, noEnv: true, ...(Object.keys(env).length ? { env } : {}) });
     let attempt = beginBoatCreate(botId, body);
     let request = attempt.request;
     let createdThisAttempt = attempt.startedNow;
@@ -1034,7 +1023,7 @@ async function requestBoatCreate(cfg, botId, ttlSeconds, env) {
                 method: "POST",
                 headers: { "Idempotency-Key": request.idempotencyKey },
                 signal: AbortSignal.timeout(45_000),
-                body: wireBody,
+                body,
             });
         }
         catch (error) {
@@ -1067,12 +1056,12 @@ async function requestBoatCreate(cfg, botId, ttlSeconds, env) {
         return { ...last, request, createdThisAttempt };
     }
 }
-async function createBoat(cfg, botId, env) {
-    const first = await requestBoatCreate(cfg, botId, DEFAULT_BOAT_TTL_SECONDS, env);
+async function createBoat(cfg, botId) {
+    const first = await requestBoatCreate(cfg, botId, DEFAULT_BOAT_TTL_SECONDS);
     if (first.ok)
         return first;
     const trialTtl = trialBoatTtlSeconds(first.body);
-    return trialTtl === null ? first : requestBoatCreate(cfg, botId, trialTtl, env);
+    return trialTtl === null ? first : requestBoatCreate(cfg, botId, trialTtl);
 }
 /** A prior explicit delete always wins over provisioning. Reconcile/retry the
  * old immutable target, then require a fresh provision request so one click
@@ -1111,10 +1100,9 @@ export async function boatStatus(cfg, botId) {
 }
 /**
  * Find-or-create the bot's persistent boat, wait for ready, and mint a fresh
- * desktop URL. The boat ships its own computer-use driver and agent runner.
+ * desktop URL. The boat ships its own computer-use driver.
  */
 export async function provisionBoat(cfg, botId, _botName) {
-    const credentialEnv = boatCredentialEnv(cfg);
     cfg = snapshotBoatConfig(cfg);
     if (!boatConfigured(cfg)) {
         throw new Error('box provider not enabled — add {"box":{"token":"…"}} to ~/.openmausbot/config.json');
@@ -1132,9 +1120,9 @@ export async function provisionBoat(cfg, botId, _botName) {
             // Provider-side backstop: archives itself (billing pauses, disk
             // survives) if every stop path dies. Trial accounts get one narrower
             // retry when boat.dev reports their shorter TTL ceiling.
-            const createRes = await createBoat(cfg, botId, credentialEnv);
+            const createRes = await createBoat(cfg, botId);
             if (!createRes.ok || !createRes.body?.box?.id) {
-                throw new Error(boatErrorMessage(createRes.status, "boat create", createRes.body, usesIncludedBoat(cfg)));
+                throw boatRefusal(createRes.status, "boat create", createRes.body, usesIncludedBoat(cfg));
             }
             boat = createRes.body.box;
             createRequest = createRes.request;
@@ -1151,8 +1139,7 @@ export async function provisionBoat(cfg, botId, _botName) {
         const ready = await waitReady(cfg, boat.id);
         if (!ready)
             throw new Error("box did not become ready within 90s — retry in a minute");
-        // Nothing to install: every boat ships its own computer-use driver and
-        // registers it with every harness it runs.
+        // Nothing to install: every boat ships its own computer-use driver.
         const joinUrl = await mintDesktopUrl(cfg, boat.id);
         if (!joinUrl)
             throw new Error("box desktop link could not be created");
@@ -1249,14 +1236,11 @@ export async function execOnBoat(cfg, botId, command) {
 //
 // The frame is for a person: it fills the panel and opens in the chat's
 // image viewer, so it keeps the desktop's native size up to 1080p and a
-// quality where page text stays legible. (Sizing it is now the only say
-// OpenMausBot has over any frame off this box: the turn runs on the boat's
-// own agent, so the model's own captures never pass through here.) Only
-// wider displays are scaled down, with -resize rather than -thumbnail so
-// the resample is not the fast-and-blurry kind meant for icons. The
-// pointer is drawn into the frame (scrot --pointer, ffmpeg -draw_mouse):
-// watching the bot work means seeing where its cursor is, and X11
-// captures leave it out by default.
+// quality where page text stays legible. Only wider displays are scaled
+// down, with -resize rather than -thumbnail so the resample is not the
+// fast-and-blurry kind meant for icons. The pointer is drawn into the frame
+// (scrot --pointer, ffmpeg -draw_mouse): watching the bot work means seeing
+// where its cursor is, and X11 captures leave it out by default.
 const PANEL_PATH = "/tmp/ogb-panel.jpg";
 export const PANEL_FRAME_WIDTH = 1920;
 export const PANEL_FRAME_QUALITY = 85;

package/dist-server/server/bot-overview.js

@@ -147,7 +147,7 @@ export function grantsSummary(connectorTools) {
 function computerReach(computer, cloudHome = false) {
     // A Cloud home never offers either; say so rather than list a preference
     // that every task there refuses.
-    const unavailable = cloudHome ? ", which isn't available on OMB Cloud" : "";
+    const unavailable = cloudHome ? ", which isn't available on My Cloud" : "";
     switch (computer) {
         case "cloud":
             return "Computer preference: cloud computer.";

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

@@ -16,7 +16,7 @@ import { delimiter, dirname, join, resolve } from "node:path";
 import { writeFileAtomic } from "./atomic.js";
 import { DATA_DIR } from "./config.js";
 import { browserBundlePaths } from "./browser-bundle-release.js";
-import { browserRuntimeEnv } from "./browser-runtime.js";
+import { BROWSER_VIEWPORT_ARGS, browserRuntimeEnv, ownsBrowserViewport } from "./browser-runtime.js";
 import { SIGN_IN_PROMPT } from "./system-prompt.js";
 import { AGENT_BROWSER_VERSION, agentBrowserReleaseUrl, agentBrowserReleaseVersion, resolveAgentBrowserReleaseAsset, } from "./browser-engine-release.js";
 const ENGINE_DIR = "tools/agent-browser";
@@ -467,6 +467,43 @@ export function agentBrowserIntegration(input) {
     }
     return { command: input.binaryPath, args: ["mcp", "--tools", "core", "--no-webmcp"], env };
 }
+/** Give the session's browser the standard page size, launching it with the
+ * session's own launch environment if it is not running yet. Best effort:
+ * false (and the page keeps whatever size it had) on any failure. */
+export function setBrowserViewport(binaryPath, env, timeoutMs = 30_000) {
+    if (!ownsBrowserViewport(env))
+        return Promise.resolve(true);
+    return new Promise((settle) => {
+        let child;
+        try {
+            child = spawn(binaryPath, [...BROWSER_VIEWPORT_ARGS, "--json", "--no-webmcp"], { env: browserRuntimeEnv(env), stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+        }
+        catch {
+            settle(false);
+            return;
+        }
+        let output = "";
+        let settled = false;
+        const finish = (ok) => { if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            settle(ok);
+        } };
+        const timer = setTimeout(() => { child.kill("SIGKILL"); finish(false); }, timeoutMs);
+        timer.unref?.();
+        child.stdout?.on("data", (chunk) => { if (output.length < 65_536)
+            output += String(chunk); });
+        child.on("error", () => finish(false));
+        child.on("close", (code) => {
+            try {
+                finish(code === 0 && JSON.parse(output)?.success === true);
+            }
+            catch {
+                finish(false);
+            }
+        });
+    });
+}
 /** How long a settled-frame capture may take before the turn gives up on it.
  * The poller runs beside a live turn, so a hung browser must not hold the
  * transcript open; a missing picture is better than a stuck fold. */

package/dist-server/server/browser-live.js

@@ -1,12 +1,22 @@
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
-import { browserRuntimeEnv } from "./browser-runtime.js";
+import { BROWSER_VIEWPORT_ARGS, browserRuntimeEnv, ownsBrowserViewport } from "./browser-runtime.js";
 import { closeBrowserSession } from "./browser-engine.js";
 const execute = promisify(execFile);
 const MAX_FRAME = 3 * 1024 * 1024;
 const MAX_BUFFER = 4 * 1024 * 1024;
 const HEARTBEAT_MS = 10_000;
+const COMMAND_TIMEOUT_MS = 30_000;
+const VIEWPORT_TIMEOUT_MS = 5_000;
+// Opening a view while the bot's own command holds the session: each stream
+// probe waits up to STATUS_PROBE_MS (it may also have to launch the browser),
+// then the view shows that it is waiting and probes again with a bounded
+// backoff for as long as the viewer stays, up to a limit. A probe that is
+// waiting in line answers as soon as the bot's command finishes.
+const STATUS_PROBE_MS = 10_000;
+const BUSY_RETRY_MS = [1_000, 2_000, 5_000];
+const BUSY_LIMIT_MS = 10 * 60_000;
 // The native press resolver supplies the virtual key codes and Enter/Tab text
 // that its raw input_keyboard relay omits. Keep unknown keys literal.
 const DISCRETE_KEYS = new Set(["Backspace", "Enter", "Tab", "Escape", "Delete", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Home", "End", "PageUp", "PageDown"]);
@@ -17,6 +27,20 @@ export class BrowserLiveError extends Error {
     status;
     constructor(message, status = 400) { super(message); this.name = "BrowserLiveError"; this.status = status; }
 }
+/** The engine is there but did not answer in time: another command, usually
+ * the bot's own, holds the same browser session. Not a missing engine. */
+export class BrowserBusyError extends BrowserLiveError {
+    constructor(message = "The browser is busy with another action and did not answer in time. Try again shortly.") {
+        super(message, 503);
+        this.name = "BrowserBusyError";
+    }
+}
+/** execFile's own timeout: it killed a command that had not exited, as
+ * opposed to a missing binary, a failed command, an abort or an overflow. */
+function timedOut(error) {
+    const failure = error;
+    return failure?.killed === true && failure.signal === "SIGKILL" && failure.code == null;
+}
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -183,6 +207,8 @@ export class BrowserLive {
         }
         if (!viewer.res.headersSent)
             return; // A peer can change control while this viewer is still starting.
+        if (viewer.waiting && message.type !== "waiting" && message.type !== "error")
+            return;
         if (viewer.res.writableLength > MAX_BUFFER) {
             this.close(viewer);
             return;
@@ -279,6 +305,7 @@ export class BrowserLive {
         if (viewer.closed)
             return;
         viewer.closed = true;
+        viewer.abort.abort();
         this.viewers.delete(viewer.id);
         clearTimeout(viewer.heartbeat);
         clearTimeout(viewer.drainTimer);
@@ -303,13 +330,14 @@ export class BrowserLive {
         if (viewer.pressedKeys.size || viewer.pressedButtons.size)
             this.runtime.abandonHumanInput(viewer.session, viewer.id);
     }
-    async command(viewer, args) {
+    async command(viewer, args, timeout = COMMAND_TIMEOUT_MS) {
         if (!this.current(viewer))
             throw new BrowserLiveError("This browser view is no longer available.", 409);
         const env = browserRuntimeEnv({ ...viewer.spec.env, AGENT_BROWSER_SESSION: viewer.session });
         try {
             const { stdout } = await execute(viewer.spec.command, [...args, "--json", "--no-webmcp"], {
-                env, timeout: 30_000, killSignal: "SIGKILL", maxBuffer: 1024 * 1024, encoding: "utf8", windowsHide: true,
+                env, timeout, killSignal: "SIGKILL", maxBuffer: 1024 * 1024, encoding: "utf8", windowsHide: true,
+                signal: viewer.abort.signal,
             });
             if (!this.current(viewer))
                 throw new Error("stale viewer");
@@ -324,6 +352,8 @@ export class BrowserLive {
             return data;
         }
         catch (error) {
+            if (timedOut(error))
+                throw new BrowserBusyError();
             console.warn("browser-live:", error);
             if (browserLaunchFailure(error)) {
                 // The daemon is alive but holding a launch configuration Chrome
@@ -349,6 +379,73 @@ export class BrowserLive {
             throw new BrowserLiveError("The browser could not complete this action. Check that the browser engine is installed, then reconnect.", 503);
         }
     }
+    /** Find (or start) the session's stream and make sure its browser runs. */
+    async connect(viewer) {
+        // A failed launch already started this session's daemon teardown; wait
+        // for it so the status probe meets a fresh daemon, not the stuck one.
+        // Checked on every attempt: a reset can start while the view waits.
+        const resetting = this.sessionResets.get(viewer.session);
+        if (resetting)
+            await resetting;
+        let status = await this.command(viewer, ["stream", "status"], STATUS_PROBE_MS);
+        if (status.enabled !== true) {
+            try {
+                status = await this.command(viewer, ["stream", "enable"]);
+            }
+            catch (error) {
+                if (error instanceof BrowserBusyError)
+                    throw error;
+                status = await this.command(viewer, ["stream", "status"]); // Another view may have enabled the same session.
+            }
+        }
+        const port = browserStreamPort(status);
+        // `open` without a URL is an idempotent launch, never navigation away from the bot's page.
+        if (status.connected !== true)
+            await this.command(viewer, ["open"]);
+        // The status probe itself may have launched the browser. Give its page the
+        // standard size, as the bot's runtime does, so the page, the frames and
+        // the clicks share one geometry; at that size this changes nothing. Best
+        // effort and brief: a failure or a busy session keeps the current size.
+        if (ownsBrowserViewport(viewer.spec.env ?? {})) {
+            await this.command(viewer, [...BROWSER_VIEWPORT_ARGS], VIEWPORT_TIMEOUT_MS).catch(() => undefined);
+        }
+        return port;
+    }
+    /** While another command holds the session, keep the view open and waiting
+     * instead of failing it: start the event stream, say so, and retry with a
+     * bounded backoff until the browser answers, the viewer leaves, or the
+     * limit passes. */
+    async connectWhenFree(viewer) {
+        const deadline = Date.now() + BUSY_LIMIT_MS;
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await this.connect(viewer);
+            }
+            catch (error) {
+                if (!(error instanceof BrowserBusyError) || !this.current(viewer))
+                    throw error;
+                if (Date.now() >= deadline)
+                    throw new BrowserBusyError("The bot is still using this browser. Reconnect when it has finished.");
+            }
+            viewer.waiting = true;
+            this.startEvents(viewer);
+            this.send(viewer, { type: "waiting", reason: "busy" });
+            await new Promise((resolve) => {
+                const done = () => { clearTimeout(timer); viewer.abort.signal.removeEventListener("abort", done); resolve(); };
+                const timer = setTimeout(done, BUSY_RETRY_MS[Math.min(attempt, BUSY_RETRY_MS.length - 1)]);
+                timer.unref?.();
+                viewer.abort.signal.addEventListener("abort", done, { once: true });
+            });
+            if (!this.current(viewer))
+                throw new BrowserLiveError("This browser view is no longer available.", 409);
+        }
+    }
+    startEvents(viewer) {
+        if (viewer.res.headersSent)
+            return;
+        viewer.res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", "X-Accel-Buffering": "no", Connection: "keep-alive" });
+        viewer.res.flushHeaders();
+    }
     async input(viewer, message) {
         if (!viewer.port)
             throw new BrowserLiveError("The browser stream is not connected.", 409);
@@ -415,36 +512,23 @@ export class BrowserLive {
         if (this.viewers.size >= 8 || [...this.viewers.values()].filter((v) => v.session === options.session).length >= 2) {
             throw new BrowserLiveError("Too many browser views are open. Close another browser panel first.", 429);
         }
-        const viewer = { ...options, id: randomUUID(), closed: false, blocked: false, pendingActions: 0, restarting: false, pressedKeys: new Set(), pressedButtons: new Set() };
+        const viewer = { ...options, id: randomUUID(), closed: false, blocked: false, pendingActions: 0, restarting: false, pressedKeys: new Set(), pressedButtons: new Set(), waiting: false, abort: new AbortController() };
         if (!this.current(viewer))
             throw new BrowserLiveError("This browser view is no longer available.", 409);
         this.viewers.set(viewer.id, viewer);
         options.res.once("close", () => this.close(viewer));
         options.res.once("error", () => this.close(viewer));
         try {
-            // A failed launch already started this session's daemon teardown; wait
-            // for it so the status probe meets a fresh daemon, not the stuck one.
-            const resetting = this.sessionResets.get(viewer.session);
-            if (resetting)
-                await resetting;
-            let status = await this.command(viewer, ["stream", "status"]);
-            if (status.enabled !== true) {
-                try {
-                    status = await this.command(viewer, ["stream", "enable"]);
-                }
-                catch {
-                    status = await this.command(viewer, ["stream", "status"]);
-                } // Another view may have enabled the same session.
-            }
-            const port = browserStreamPort(status);
+            const port = await this.connectWhenFree(viewer);
+            // Best-effort steps of the startup swallow their own failures, an abort
+            // by close() included; a viewer closed meanwhile gets no socket.
+            if (!this.current(viewer))
+                throw new BrowserLiveError("This browser view is no longer available.", 409);
             viewer.port = port;
-            // `open` without a URL is an idempotent launch, never navigation away from the bot's page.
-            if (status.connected !== true)
-                await this.command(viewer, ["open"]);
             const socket = new WebSocket(`ws://127.0.0.1:${port}/?pacing=ack&maxFps=15`);
             viewer.socket = socket;
-            options.res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", "X-Accel-Buffering": "no", Connection: "keep-alive" });
-            options.res.flushHeaders();
+            this.startEvents(viewer);
+            viewer.waiting = false;
             this.send(viewer, { type: "ready", viewerId: viewer.id });
             this.control(viewer.session);
             socket.addEventListener("message", (event) => {
@@ -511,7 +595,10 @@ export class BrowserLive {
         catch (error) {
             console.warn("browser-live:", error);
             if (options.res.headersSent) {
-                this.send(viewer, { type: "error", retryable: true, message: "The browser stream could not start." });
+                // A view that waited out a busy browser gets the reason, and no
+                // automatic retry loop on top of the wait it already did.
+                const busy = error instanceof BrowserBusyError;
+                this.send(viewer, { type: "error", retryable: !busy, message: busy ? error.message : "The browser stream could not start." });
                 this.close(viewer);
                 return;
             }

package/dist-server/server/browser-runtime.js

@@ -23,6 +23,24 @@ export function browserRuntimeEnv(overrides) {
     const env = Object.fromEntries(HOST_ENV.flatMap((key) => process.env[key] === undefined ? [] : [[key, process.env[key]]]));
     return { ...env, ...overrides };
 }
+/** The page size of a headless browser OMB launches, in CSS pixels.
+ *
+ * agent-browser sizes the Chrome *window* (`--window-size=1280,720`). Full
+ * Chrome in headless mode (Chrome for Testing, as the Docker image installs)
+ * takes its emulated browser UI out of that window, so the page itself comes
+ * out 1280×577 while the screencast metadata still reports 1280×720, and the
+ * live view aimed clicks at the wrong place. chrome-headless-shell has no such
+ * UI, so there this changes nothing. agent-browser has no launch option for
+ * the page size; `set viewport` sets it and resizes the window's content area,
+ * which the browser's later tabs inherit. */
+export const BROWSER_VIEWPORT = { width: 1280, height: 720 };
+export const BROWSER_VIEWPORT_ARGS = ["set", "viewport", String(BROWSER_VIEWPORT.width), String(BROWSER_VIEWPORT.height)];
+/** Only a headless browser this server launches is OMB's to size. A browser
+ * attached over CDP is someone's own Chrome, and a headed window is the
+ * user's to size. */
+export function ownsBrowserViewport(env) {
+    return env.AGENT_BROWSER_HEADLESS === "1" && !env.AGENT_BROWSER_CDP;
+}
 export class TransportError extends Error {
 }
 /** A server-owned JSONL client. Neither child stderr nor its environment is
@@ -215,9 +233,11 @@ export class BrowserRuntime {
     toolLists = new Map();
     options;
     closeBrowser;
-    constructor({ closeBrowser, ...options } = {}) {
+    applyViewport;
+    constructor({ closeBrowser, applyViewport, ...options } = {}) {
         this.options = { requestTimeoutMs: 120_000, takeoverTimeoutMs: 15_000, idleMs: 60_000, maxPending: 16, resultBudget: DEFAULT_BROWSER_RESULT_BUDGET, ...options };
         this.closeBrowser = closeBrowser ?? (async () => false);
+        this.applyViewport = applyViewport;
     }
     gate(session) {
         let gate = this.gates.get(session);
@@ -300,6 +320,16 @@ export class BrowserRuntime {
             beforeDispatch?.();
             if (method === "tools/call" && this.gate(session).owner !== null)
                 throw new Error(BROWSER_CONTROL_REFUSAL);
+            if (method === "tools/call" && this.applyViewport) {
+                // The bot's first call on a transport may launch the browser. Size its
+                // page first, once per transport, so the page, the bot's screenshots
+                // and the live view agree. Failure only leaves the engine's default.
+                entry.viewport ??= this.applyViewport(spec).catch(() => undefined);
+                await entry.viewport;
+                beforeDispatch?.();
+                if (this.gate(session).owner !== null)
+                    throw new Error(BROWSER_CONTROL_REFUSAL);
+            }
             try {
                 // The model sees slimmed schemas and text-only, bounded results; the
                 // launch/session parameters OMB owns never reach the engine from a call.