openmausbot 0.1.93 → 0.1.95

package/dist-server/server/cli.js

@@ -812,7 +812,7 @@ export async function runBrowser(options, io = defaultIo()) {
             io.error("on Linux, install Chrome's system libraries with `sudo openmausbot browser install --with-deps`, then retry `openmausbot browser install` as the user running serve");
         return 1;
     }
-    io.log("browser installed for this user and data directory; run serve as the same user, then enable it under Settings → Experimental and per bot");
+    io.log("browser installed for this user and data directory; run serve as the same user, then enable it under Settings → Computers and per bot");
     if (process.platform === "linux" && options.withDeps)
         io.log("if serve runs as another user, run `openmausbot browser install` from that user's login shell too");
     return 0;
@@ -834,8 +834,13 @@ export function serverEntry(here = HERE) {
 }
 /** Everything `--tunnel` needs before the server starts, or the one reason
  * it cannot have it. Fails closed: no silent fallback to a local-only server. */
-async function planTunnel(options, log) {
+async function planTunnel(options, log, recovery) {
     let access = null;
+    let account = null;
+    const fail = (error) => {
+        account?.service.dispose();
+        return { error };
+    };
     const credential = fleetCredential();
     if (credential) {
         // A fleet-started container: the credential is the whole identity.
@@ -848,36 +853,41 @@ async function planTunnel(options, log) {
         }
     }
     else {
-        const account = createTunnelAccount({ dataDir: options.dataDir, version: serverVersion() });
+        account = createTunnelAccount({ dataDir: options.dataDir, version: serverVersion(), recovery });
         if (account.credentials.status === "unavailable")
-            return { error: `${account.credentials.file} exists but could not be read; fix or remove it` };
+            return fail(`${account.credentials.file} exists but could not be read; fix or remove it`);
         if (!describeTunnelAccount(account.credentials.read()).email) {
-            return { error: "no account on this machine yet: run `openmausbot login` first, then `openmausbot serve --tunnel`" };
+            return fail("no account on this machine yet: run `openmausbot login` first, then `openmausbot serve --tunnel`");
         }
         // A fresh connector token when the control plane answers; the saved one otherwise.
         try {
             const state = await account.service.retry();
-            if (state.message && !tunnelAccess(account.credentials.read()))
-                log(`tunnel: ${state.message}`);
+            const saved = tunnelAccess(account.credentials.read()) !== null;
+            // Said even when a saved address exists: an expired sign-in means this
+            // machine can no longer repair that address on its own.
+            if (state.status === "signed-out")
+                log(`tunnel: the sign-in on this machine expired; run \`openmausbot login\` to renew it${saved ? " (serving the saved address until then)" : ""}`);
+            else if (state.message)
+                log(`tunnel: ${state.message}${saved ? " Serving the saved address for now." : ""}`);
         }
         catch (error) {
             log(`tunnel: control plane not reachable right now (${message(error)}); using the saved address`);
         }
         access = tunnelAccess(account.credentials.read());
         if (!access)
-            return { error: "this machine has no public address; run `openmausbot login` again" };
+            return fail("this machine has no public address; run `openmausbot login` again");
     }
     let binary;
     try {
         binary = await ensureCloudflared({ dataDir: options.dataDir, log });
     }
     catch (error) {
-        return { error: `--tunnel: ${message(error)}` };
+        return fail(`--tunnel: ${message(error)}`);
     }
     const guardian = guardianEntry();
     if (!guardian)
-        return { error: "--tunnel: the connector guardian is missing from this install" };
-    return { access, binary, guardian, origin: createTunnelOrigin() };
+        return fail("--tunnel: the connector guardian is missing from this install");
+    return { access, binary, guardian, origin: createTunnelOrigin(), account };
 }
 export async function runServe(options, log = console.log) {
     const { browserEngineStatus, describeBrowserEngine } = await import("./browser-engine.js");
@@ -896,8 +906,11 @@ export async function runServe(options, log = console.log) {
         tailscale = probe.status;
     }
     let plan = null;
+    // The tunnel this process serves, once it runs; the account service's
+    // background recovery reads it (see TunnelRecovery).
+    const serving = { tunnel: null };
     if (options.tunnel) {
-        const planned = await planTunnel(options, log);
+        const planned = await planTunnel(options, log, { running: () => serving.tunnel });
         if ("error" in planned) {
             console.error(planned.error);
             return 1;
@@ -991,6 +1004,7 @@ export async function runServe(options, log = console.log) {
     catch (error) {
         if ((tailscaleServing || (startupCancelled && tailscaleAttempted)) && tailscale)
             await tailscaleServeOff(tailscale).catch(() => undefined);
+        plan?.account?.service.dispose();
         if (plan)
             cleanupTunnelOrigin(plan.origin);
         if (error instanceof SetupCancelled) {
@@ -1015,6 +1029,8 @@ export async function runServe(options, log = console.log) {
     let stopping = null;
     const stop = () => {
         stopping ??= (async () => {
+            serving.tunnel = null;
+            plan?.account?.service.dispose();
             // The gateway and the edge stop accepting before the server they forward to goes away.
             if (tunnel)
                 await tunnel.stop().catch(() => undefined);
@@ -1083,6 +1099,10 @@ export async function runServe(options, log = console.log) {
                 onState: (state) => log(describeTunnelState(state, plan.access.endpoint)),
             });
             tunnel.started.catch((error) => log(`tunnel: ${message(error)}`));
+            // From here on the endpoint is checked every 15 minutes; one reclaimed
+            // while this machine was offline is re-created behind the same address.
+            serving.tunnel = tunnel;
+            void plan.account?.service.restore().catch(() => undefined);
         }
         log("");
         log(`OpenMausBot is running on http://127.0.0.1:${options.port}${publicUrl ? `, reachable at ${publicUrl}` : ""}`);

package/dist-server/server/cloud-backend.js

@@ -1,13 +1,9 @@
 export const CLOUD_BACKEND_CHANGE_ERROR = "stop the active turn before changing the cloud backend";
-export const VPS_ALIAS_CHANGE_ERROR = "stop the active VPS turn before changing the SSH config alias";
 export const BOAT_ACCOUNT_RESOURCES_ERROR = "remove this installation's cloud computers before changing or clearing the Boat account";
 export const VPS_ALIAS_RESOURCES_ERROR = "remove this installation's VPS computers before changing or clearing the SSH config alias";
 export function cloudBackendChangeError(botBusy, activeVpsThread) {
     return botBusy || activeVpsThread ? CLOUD_BACKEND_CHANGE_ERROR : null;
 }
-export function vpsAliasChangeError(currentAlias, nextAlias, activeVpsThread) {
-    return activeVpsThread && currentAlias !== nextAlias ? VPS_ALIAS_CHANGE_ERROR : null;
-}
 /** An old Boat account may be detached only when it owns no local resources.
  * Token rotation is safe when the replacement credential proves access to
  * the exact same provider identities. */

package/dist-server/server/cloud-computer-tools.js

@@ -0,0 +1,110 @@
+import { isolatedRemoteCommand, runCommand, screenshotBoat } from "./boat.js";
+import { CONTROL_REFUSAL_PLAIN } from "./control-client.js";
+import { compileToolSchema } from "./drivers/chat-mcp-tools.js";
+const coordinate = { type: "integer", minimum: 0, maximum: 32767 };
+const tool = (name, description, properties = {}, required = []) => ({ name, description, inputSchema: { type: "object", properties, required, additionalProperties: false } });
+export const CLOUD_COMPUTER_TOOLS = [
+    tool("screenshot", "See the assigned cloud desktop at native pixel resolution."),
+    tool("get_screen_size", "Get the cloud desktop width and height."),
+    tool("click", "Click a point on the cloud desktop.", { x: coordinate, y: coordinate, button: { type: "string", enum: ["left", "middle", "right"] }, count: { type: "integer", minimum: 1, maximum: 3 } }, ["x", "y"]),
+    tool("move", "Move the cloud mouse pointer.", { x: coordinate, y: coordinate }, ["x", "y"]),
+    tool("drag", "Drag on the cloud desktop.", { x: coordinate, y: coordinate, to_x: coordinate, to_y: coordinate }, ["x", "y", "to_x", "to_y"]),
+    tool("type_text", "Type Unicode text into the focused cloud application.", { text: { type: "string", maxLength: 4000 } }, ["text"]),
+    tool("key_press", "Press an X11 key or shortcut.", { key: { type: "string", pattern: "^[A-Za-z0-9_+]+$", minLength: 1, maxLength: 100 } }, ["key"]),
+    tool("scroll", "Scroll at a point on the cloud desktop.", { x: coordinate, y: coordinate, direction: { type: "string", enum: ["up", "down", "left", "right"] }, amount: { type: "integer", minimum: 1, maximum: 30 } }, ["x", "y", "direction"]),
+    tool("open_url", "Request opening an HTTP or HTTPS URL in the cloud desktop browser; inspect the screen to confirm it loaded.", { url: { type: "string", pattern: "^https?://", maxLength: 2000 } }, ["url"]),
+    tool("exec", "Run a shell command on the assigned cloud computer.", { command: { type: "string", minLength: 1, maxLength: 4000 } }, ["command"]),
+];
+const quote = (value) => "'" + value.replace(/'/g, "'\\''") + "'";
+const buttons = { left: 1, middle: 2, right: 3 };
+const scrollButtons = { up: 4, down: 5, left: 6, right: 7 };
+let validators;
+/** Why a call cannot run, or null. Checked before anything else touches the
+ * call: x and y reach the remote shell unquoted, so only the advertised
+ * integer schema stands between a model's arguments and a command line. */
+export function cloudComputerCallProblem(name, args) {
+    validators ??= new Map(CLOUD_COMPUTER_TOOLS.map(entry => [entry.name, compileToolSchema(entry.inputSchema)]));
+    const validate = typeof name === "string" ? validators.get(name) : undefined;
+    if (!validate)
+        return "Unknown cloud computer tool. Use one of the advertised computer tools.";
+    if (!args || typeof args !== "object" || Array.isArray(args) || !validate(args)) {
+        return "Tool arguments do not match the advertised input schema; use its required fields and types.";
+    }
+    return null;
+}
+/** One tool call on the given Boat with the server's own Boat account. The
+ * caller has already checked the arguments and the person's control. */
+export async function runCloudComputerTool(cfg, boxId, name, args, signal) {
+    const problem = cloudComputerCallProblem(name, args);
+    if (problem)
+        return { isError: true, content: [{ type: "text", text: problem }] };
+    signal.throwIfAborted();
+    if (name === "screenshot") {
+        const shot = await screenshotBoat(cfg, "", boxId, { signal, nativeSize: true });
+        signal.throwIfAborted();
+        return { content: [{ type: "image", mimeType: "image/jpeg", data: shot.png }] };
+    }
+    const a = args;
+    const mouse = `xdotool mousemove --sync ${a.x} ${a.y}`;
+    let command;
+    switch (name) {
+        case "get_screen_size":
+            command = "xdotool getdisplaygeometry";
+            break;
+        case "click":
+            command = `${mouse} click --repeat ${a.count ?? 1} --delay 100 ${buttons[String(a.button ?? "left")]}`;
+            break;
+        case "move":
+            command = mouse;
+            break;
+        case "drag":
+            command = `${mouse} mousedown 1 mousemove --sync ${a.to_x} ${a.to_y} mouseup 1`;
+            break;
+        case "type_text":
+            command = `printf %s ${quote(Buffer.from(String(a.text)).toString("base64"))} | base64 -d | xclip -selection clipboard && xdotool key --clearmodifiers ctrl+v`;
+            break;
+        case "key_press":
+            command = `xdotool key --clearmodifiers ${quote(String(a.key))}`;
+            break;
+        case "scroll":
+            command = `${mouse} click --repeat ${a.amount ?? 3} --delay 80 ${scrollButtons[String(a.direction)]}`;
+            break;
+        case "open_url":
+            command = `nohup xdg-open ${quote(String(a.url))} >/dev/null 2>&1 </dev/null &`;
+            break;
+        case "exec":
+            command = String(a.command);
+            break;
+        default: return { isError: true, content: [{ type: "text", text: "Unknown cloud computer tool." }] };
+    }
+    const result = await runCommand(cfg, boxId, isolatedRemoteCommand(command), { signal });
+    signal.throwIfAborted();
+    if (name === "open_url" && result.ok)
+        return { content: [{ type: "text", text: "Browser launch requested. Page loading is not confirmed; inspect the screen before continuing." }] };
+    return { isError: !result.ok, content: [{ type: "text", text: JSON.stringify(result) }] };
+}
+/** One JSON-RPC request from harness-mcp-proxy, answered with its MCP
+ * `result`. The order is the safety argument: arguments are checked before
+ * the control gate (which may claim the seat), a person's control refuses
+ * the call before anything reaches the Boat, and the turn's capability must
+ * still be live before and after the Boat acts. */
+export async function cloudComputerRpc(request, deps) {
+    if (request?.method === "tools/list") {
+        deps.assertActive();
+        return { tools: CLOUD_COMPUTER_TOOLS };
+    }
+    if (request?.method !== "tools/call")
+        throw Object.assign(new Error("unsupported computer method"), { status: 400 });
+    const params = (request.params && typeof request.params === "object" ? request.params : {});
+    const args = params.arguments ?? {};
+    const problem = cloudComputerCallProblem(params.name, args);
+    if (problem)
+        return { isError: true, content: [{ type: "text", text: problem }] };
+    const control = await deps.gate();
+    deps.assertActive();
+    if (control.held)
+        return { isError: true, content: [{ type: "text", text: control.blockedReason || CONTROL_REFUSAL_PLAIN }] };
+    const result = await runCloudComputerTool(deps.cfg, deps.boxId, params.name, args, deps.signal);
+    deps.assertActive();
+    return result;
+}

package/dist-server/server/cloud-home.js

@@ -26,7 +26,6 @@ import { join } from "node:path";
 import { writeFileAtomic } from "./atomic.js";
 import { hostedWorkspaceConfigured } from "./enterprise.js";
 import { formatPairingCode } from "./sessions.js";
-export const CLOUD_HOME_CONTRACT_VERSION = 1;
 /** Any of these switches the server into Cloud home mode; then all are required. */
 export const CLOUD_HOME_KEYS = ["OMB_CLOUD_ROLE", "OMB_CLOUD_MACHINE_ID", "OMB_CLOUD_ADMIN_URL", "OMB_CLOUD_BOOTSTRAP_SECRET"];
 /** A platform model gateway's settings. A Cloud home never uses them: given

package/dist-server/server/cloud-lending.js

@@ -21,9 +21,6 @@ import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.js";
 const personOf = (line) => line?.role === "user" && !line.peerAsk ? line.sender?.id : undefined;
-export function cloudHomeTurnMayLend(turn) {
-    return cloudHomeLendingRefusal(turn) === null;
-}
 export function cloudHomeLendingRefusal(turn) {
     const { request } = turn;
     if (!request?.messageId || request.stopped || !request.generations.has(turn.generation))

package/dist-server/server/cloud-move-http.js

@@ -1,11 +1,17 @@
 import { z } from "zod";
-import { backupsBytes, beginUpload, CLOUD_MOVE_MAX_BYTES, CLOUD_MOVE_MAX_PART_BYTES, CLOUD_MOVE_PART_BYTES, completedUpload, discardNextPreviousCloud, discardUpload, forgetMoveRestore, freeVolumeBytes, isEmptyWorkspace, moveSpaceNeeded, noteMoveRestore, prepareNextPreviousCloud, previousCloud, previousCloudArchiveBytes, removeMoveFiles, stagePreviousCloud, tidyCloudMoveStorage, uploadStatus, validUploadDeclaration, workspaceContents, workspaceMoveSize, writeUploadPart, } from "./cloud-move.js";
+import { backupsBytes, beginUpload, CLOUD_MOVE_MAX_BYTES, CLOUD_MOVE_MAX_PART_BYTES, CLOUD_MOVE_PART_BYTES, completedUpload, discardNextPreviousCloud, discardUpload, enabledRoutineCount, forgetMoveRestore, freeVolumeBytes, isEmptyWorkspace, moveSpaceNeeded, noteMoveRestore, prepareNextPreviousCloud, previousCloud, previousCloudArchiveBytes, removeMoveFiles, stagePreviousCloud, tidyCloudMoveStorage, totalVolumeBytes, uploadStatus, validUploadDeclaration, workspaceContents, workspaceMoveSize, writeUploadPart, } from "./cloud-move.js";
 import { commitPendingWorkspaceRestore, createWorkspaceBackup, stageWorkspaceBackup } from "./workspace-backup.js";
 export const CLOUD_MOVE_PREFIX = "/api/cloud-move";
 const failure = (message, status) => Object.assign(new Error(message), { status });
 const HELD_CACHE_MS = 30_000;
 export function createCloudMoveRoutes(options) {
     const freeBytes = options.freeBytes ?? freeVolumeBytes;
+    const volumeBytes = (path) => { try {
+        return (options.volumeBytes ?? totalVolumeBytes)(path);
+    }
+    catch {
+        return null;
+    } };
     // A move's restore that startup has installed keeps no safety copy or
     // staged files; an abandoned upload goes after a day.
     if (options.cloudHome) {
@@ -113,7 +119,7 @@ export function createCloudMoveRoutes(options) {
             if (!auth.scopes.includes("admin"))
                 throw failure("Only the owner can move a workspace.", 403);
             if (method === "GET" && path === `${CLOUD_MOVE_PREFIX}/estimate`) {
-                json(res, 200, { ...workspaceContents(options.dataDir), ...workspaceMoveSize(options.dataDir), maxBytes: CLOUD_MOVE_MAX_BYTES });
+                json(res, 200, { ...workspaceContents(options.dataDir), ...workspaceMoveSize(options.dataDir), routines: enabledRoutineCount(options.dataDir), maxBytes: CLOUD_MOVE_MAX_BYTES });
                 return true;
             }
             if (!options.cloudHome)
@@ -126,7 +132,7 @@ export function createCloudMoveRoutes(options) {
                 if (!held || held.at + HELD_CACHE_MS < Date.now())
                     held = { at: Date.now(), bytes: backupsBytes(options.dataDir) };
                 json(res, 200, {
-                    contents, empty: isEmptyWorkspace(contents), freeBytes: freeBytes(options.dataDir), maxBytes: CLOUD_MOVE_MAX_BYTES,
+                    contents, empty: isEmptyWorkspace(contents), freeBytes: freeBytes(options.dataDir), volumeBytes: volumeBytes(options.dataDir), maxBytes: CLOUD_MOVE_MAX_BYTES,
                     partBytes: CLOUD_MOVE_PART_BYTES, upload: uploadStatus(options.dataDir), previous: previousCloud(options.dataDir), job,
                     // What backups and the previous Cloud hold on the volume.
                     heldBytes: held.bytes,

package/dist-server/server/cloud-move.js

@@ -96,6 +96,24 @@ export function freeVolumeBytes(path) {
     const free = disk.bavail * disk.bsize;
     return free > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(free);
 }
+/** The whole volume, so the app can tell how far a disk that grows may still grow. */
+export function totalVolumeBytes(path) {
+    const disk = statfsSync(path, { bigint: true });
+    const total = disk.blocks * disk.bsize;
+    return total > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(total);
+}
+/** Routines switched on in this workspace. A move brings them paused, so the
+ * app says how many to turn on there. */
+export function enabledRoutineCount(dataDir) {
+    try {
+        const value = JSON.parse(readFileSync(join(dataDir, "routines.json"), "utf8"));
+        const routines = value && typeof value === "object" ? value.routines : undefined;
+        return Array.isArray(routines) ? routines.filter((routine) => routine && typeof routine === "object" && routine.enabled !== false).length : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 /** Peak extra space a move of `upload` bytes needs: the upload, its decrypted
  * copy and its staged files exist together while it is checked; the restore
  * then installs from the staged copy. Replacing a workspace first backs it up

package/dist-server/server/composio.js

@@ -244,9 +244,35 @@ function trustedAuthUrl(value, slug) {
     }
     return url.toString();
 }
+/** Composio's own hosts are always trusted. A backend the operator pointed
+ * the app at explicitly (OMB_COMPOSIO_API — a dev or test stub) may hand back
+ * a Session on its own origin, since the API itself was already trusted that
+ * far; any other host is refused. */
+export function trustedSessionMcpUrl(value) {
+    let mcp;
+    try {
+        mcp = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    if (mcp.protocol === "https:" && (mcp.hostname === "composio.dev" || mcp.hostname.endsWith(".composio.dev")))
+        return true;
+    if (mcp.protocol !== "https:" && !(mcp.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(mcp.hostname)))
+        return false;
+    const override = process.env.OMB_COMPOSIO_API;
+    if (!override)
+        return false;
+    try {
+        return new URL(override).origin === mcp.origin;
+    }
+    catch {
+        return false;
+    }
+}
 function parseSessionResponse(session) {
     const mcp = new URL(session.mcp.url);
-    if (mcp.protocol !== "https:" || (mcp.hostname !== "composio.dev" && !mcp.hostname.endsWith(".composio.dev"))) {
+    if (!trustedSessionMcpUrl(session.mcp.url)) {
         throw new Error("Composio returned an untrusted Session MCP URL");
     }
     return { ...session, mcp: { ...session.mcp, url: mcp.toString() } };
@@ -497,7 +523,7 @@ export async function mcpIntegration(cfg, context) {
         },
     };
 }
-export async function relayMcp(cfg, payload, transportSessionId) {
+export async function relayMcp(cfg, payload, transportSessionId, beforeSend) {
     const apiKey = projectApiKey(cfg);
     let url;
     let identity;
@@ -529,6 +555,9 @@ export async function relayMcp(cfg, payload, transportSessionId) {
     if (forwardedTransportSessionId) {
         headers.set("mcp-session-id", forwardedTransportSessionId);
     }
+    // Session discovery can await network I/O. Turn authority and mutable
+    // permissions must be checked after it, immediately before dispatch.
+    beforeSend?.();
     const response = await fetch(url, {
         method: "POST",
         headers,

package/dist-server/server/computer-control.js

@@ -153,18 +153,3 @@ export class ComputerControl {
         return snapshot;
     }
 }
-/** Safely executes an async tool or desktop control call, catching runtime exceptions gracefully. */
-export async function executeToolSafely(toolName, fn) {
-    try {
-        const data = await fn();
-        return { success: true, data };
-    }
-    catch (err) {
-        const errorMessage = err?.message || String(err) || 'Unknown execution error';
-        console.error(`[Tool Execution Error] Name: ${toolName} | Details: ${errorMessage}`);
-        return {
-            success: false,
-            error: `Tool '${toolName}' failed to execute: ${errorMessage}`
-        };
-    }
-}

package/dist-server/server/computer-observation.js

@@ -10,80 +10,6 @@ export const emptyObservationMetrics = () => ({
     verificationSuccesses: 0,
     verificationFailures: 0,
 });
-export function normalizeCrop(raw, maxWidth, maxHeight) {
-    if (!raw || typeof raw !== "object")
-        return null;
-    const value = raw;
-    const x = Math.round(Number(value.x));
-    const y = Math.round(Number(value.y));
-    const width = Math.round(Number(value.width));
-    const height = Math.round(Number(value.height));
-    if (![x, y, width, height, maxWidth, maxHeight].every(Number.isFinite) ||
-        maxWidth <= 0 ||
-        maxHeight <= 0 ||
-        x < 0 ||
-        y < 0 ||
-        width < 32 ||
-        height < 32) {
-        return null;
-    }
-    if (x + width > maxWidth || y + height > maxHeight)
-        return null;
-    return { x, y, width, height };
-}
-/** Canonical value for internal navigation checks. Credentials are never
- * needed for equality and are removed here; query and fragment remain so
- * two distinct application states cannot verify as the same destination. */
-export function normalizeBrowserUrl(value) {
-    if (typeof value !== "string" || !value || value.length > 8_192)
-        return null;
-    try {
-        const url = new URL(value);
-        if (!/^https?:$/.test(url.protocol))
-            return null;
-        url.username = "";
-        url.password = "";
-        return url.toString();
-    }
-    catch {
-        return null;
-    }
-}
-/** Removes credentials, query, and fragment before browser state reaches a model or log. */
-export function safeBrowserUrl(value) {
-    const normalized = normalizeBrowserUrl(value);
-    if (!normalized)
-        return null;
-    const url = new URL(normalized);
-    url.search = "";
-    url.hash = "";
-    const safe = url.toString();
-    return safe.length <= 2_048 ? safe : null;
-}
-/** Parses Chrome's /json/list response into a small, safe structured observation. */
-export function parseBrowserTargets(raw) {
-    if (raw.length > 1_000_000)
-        return [];
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
-            return [];
-        return parsed.slice(0, 20).flatMap((item) => {
-            if (!item || typeof item !== "object")
-                return [];
-            const value = item;
-            const comparisonUrl = normalizeBrowserUrl(value.url);
-            const url = safeBrowserUrl(value.url);
-            if (value.type !== "page" || !url || !comparisonUrl || typeof value.id !== "string")
-                return [];
-            const title = typeof value.title === "string" ? value.title.replace(/\s+/g, " ").trim().slice(0, 200) : "";
-            return [{ id: value.id.slice(0, 100), title, url, comparisonUrl }];
-        });
-    }
-    catch {
-        return [];
-    }
-}
 /**
  * Keeps observations cheap without claiming the screen is immutable. Every
  * requested observation still captures fresh pixels (pages can change without

package/dist-server/server/computer-wait.js

@@ -2,11 +2,11 @@
 //
 // The chip used to read "Waiting for computer — X / Y is using it; will
 // continue automatically", which people read as an error about a machine
-// they could not see. It is a queue position: this turn is behind one named
-// turn on one desktop, and it starts on its own when that turn ends. Say
-// that, name the holder as a bot running a thread, and keep the same words
-// on every surface (chat chip, room chip, the gate's refusal) so a person
-// who has read it once recognises it everywhere.
+// they could not see. It is a queue position: this turn sits behind a named
+// turn on one desktop — and every turn queued ahead of it — and starts on
+// its own when they finish. Say that, name the holder as a bot running a
+// thread, and keep the same words on every surface (chat chip, room chip,
+// the gate's refusal) so a person who has read it once recognises it everywhere.
 /** Whole minutes, or seconds under one minute, singular at exactly one. */
 const minutes = (ms) => {
     const value = ms >= 60_000 ? Math.round(ms / 60_000) : Math.round(ms / 1000);
@@ -19,11 +19,30 @@ export function computerWaitDuration(ms) {
     return ms < 1_000 ? "under a second" : minutes(ms);
 }
 const holderPhrase = (holder) => holder.task ? `${holder.name} is running ${holder.task}` : `${holder.name} is using it`;
-/** The chip a turn shows while it is queued behind another turn's desktop. */
-export function computerWaitingText(holder) {
+const ordinal = (position) => {
+    const mod100 = position % 100;
+    const mod10 = position % 10;
+    const suffix = mod100 >= 11 && mod100 <= 13 ? "th" : mod10 === 1 ? "st" : mod10 === 2 ? "nd" : mod10 === 3 ? "rd" : "th";
+    return `${position}${suffix}`;
+};
+/** The chip a turn shows while it is queued behind another turn's desktop:
+ * its stable queue position, the holder, and — only once waits here have
+ * history — about how long they have been taking. */
+export function computerWaitingText(holder, queue) {
+    const position = queue?.position && queue.position > 0 ? queue.position : undefined;
+    const place = position ? ` — ${ordinal(position)} in queue` : "";
+    const estimate = queue?.estimateMs !== undefined ? `; recent waits here have taken ${computerWaitDuration(queue.estimateMs)}` : "";
+    // Behind more than the holder, that turn ending is not this turn's start:
+    // the released seat goes to the front waiter first, so this turn starts
+    // only once every turn ahead of it has finished (#1652).
+    const starts = position && position > 1
+        ? "Starts automatically when the turns ahead finish"
+        : holder
+            ? "Starts automatically when that finishes"
+            : "Starts automatically when it is free";
     if (!holder)
-        return "Waiting for its turn on this computer. Starts automatically when it is free.";
-    return `Waiting for its turn on this computer — ${holderPhrase(holder)}. Starts automatically when that finishes.`;
+        return `Waiting for its turn on this computer${place}. ${starts}${estimate}.`;
+    return `Waiting for its turn on this computer${place} — ${holderPhrase(holder)}. ${starts}${estimate}.`;
 }
 /** The resolution appended once the wait landed and this turn holds the
  * desktop: how long it waited, and who held it. The waiting chip stays as
@@ -38,9 +57,10 @@ export function computerStoppedWaitingText(holder, waitedMs) {
     const who = holder ? ` — ${holderPhrase(holder)}` : "";
     return `Stopped waiting for the computer after ${computerWaitDuration(waitedMs)}${who}.`;
 }
-/** The error after the wait ceiling: still names who holds it, and says
- * what a person can do — stop that turn, or move this one. */
-export function computerStillBusyText(holder, ceilingMs) {
+/** The resolution appended when the wait ceiling parks the turn (#1651):
+ * still names who holds it, but the work is not lost — the turn settled and
+ * resumes on its own when the desktop frees, so nobody has to fix it. */
+export function computerParkedText(holder, ceilingMs) {
     const who = holder ? ` — ${holderPhrase(holder).replace(" is running ", " is still running ").replace(" is using it", " is still using it")}` : "";
-    return `Computer is still busy after ${minutes(ceilingMs)}${who}. Stop that turn, or run this on another computer.`;
+    return `Computer still busy after ${minutes(ceilingMs)}${who}. Parked — it continues automatically when the computer is free.`;
 }