openmausbot 0.1.95 → 0.1.96

package/dist-server/server/turn-images.js

@@ -9,6 +9,7 @@ import { lstatSync, realpathSync, statSync } from "node:fs";
 import { dirname, extname, resolve } from "node:path";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { ATTACHMENTS_DIR, IMAGE_MAX_BYTES } from "./attachments.js";
+import { decodeAttachmentAttribute } from "./message-file.js";
 /** Matches the companion composer policy. Four maximum-sized images are
  * bounded to 40 MiB before a provider is asked to ingest them. */
 export const TURN_IMAGE_MAX_COUNT = 4;
@@ -24,27 +25,6 @@ const MIME_BY_EXTENSION = {
 function statusError(status, message) {
     return Object.assign(new Error(message), { status });
 }
-/** Decode exactly the entities emitted by the composer. Repeated or unknown
- * encodings stay encoded and therefore cannot acquire a privileged path. */
-function decodeAttachmentAttribute(value) {
-    return value.replace(/&(quot|lt|gt|amp);|&#(9|10|13);/g, (entity, named, numeric) => {
-        if (numeric === "9")
-            return "\t";
-        if (numeric === "10")
-            return "\n";
-        if (numeric === "13")
-            return "\r";
-        if (named === "quot")
-            return '"';
-        if (named === "lt")
-            return "<";
-        if (named === "gt")
-            return ">";
-        if (named === "amp")
-            return "&";
-        return entity;
-    });
-}
 function walk(node, visit) {
     const pending = [node];
     while (pending.length > 0) {

package/dist-server/server/turn-resources.js

@@ -1,12 +1,12 @@
-import { realpathSync } from "node:fs";
-import { relative, resolve, sep } from "node:path";
 /** One harness owns the data directory. Claims are synchronous and last for
  * the whole turn, not just a click: a screenshot and its following click
- * must see the same desktop. These coordinate app-managed resources; they
- * are not a sandbox for arbitrary shell commands. */
+ * must see the same desktop. These coordinate app-managed resources — a
+ * desktop, a browser session, a phone — that only one turn can drive at a
+ * time. A project folder is not one: a bot's threads work in one folder
+ * side by side, as several agent sessions do in one repo. They are not a
+ * sandbox for arbitrary shell commands. */
 export class TurnResources {
     owners = new Map();
-    reclaims = new Map();
     /** Arrival-ordered waiters per requested resource (#1652). Entries exist
      * only while a turn is genuinely waiting (the exclusive bind's poll loop):
      * a lazy claim that failed once and moved on must not sit at the front and
@@ -72,25 +72,16 @@ export class TurnResources {
     waitEstimateMs(resource) {
         return this.waitStats.get(resource)?.ewmaMs;
     }
-    blocker(resource, owner, now = Date.now()) {
-        this.expireIdle(resource, now);
-        for (const [key, current] of this.owners) {
-            if (overlaps(key, resource) && !sameOwner(current.owner, owner))
-                return current.owner;
-        }
-        return undefined;
+    blocker(resource, owner) {
+        const current = this.owners.get(resource);
+        return current && !sameOwner(current, owner) ? current : undefined;
     }
-    claim(resource, owner, options = {}) {
-        const now = options.now ?? Date.now();
-        if (this.blocker(resource, owner, now))
+    claim(resource, owner) {
+        if (this.blocker(resource, owner))
             return false;
         const existing = this.owners.get(resource);
-        if (existing && sameOwner(existing.owner, owner)) {
-            // A repeated claim by the sitting owner changes nothing: replacing
-            // the record would restart activityAt, and re-claims alone would
-            // hold the seat past every quiet window (#1653).
+        if (existing && sameOwner(existing, owner))
             return true;
-        }
         // The free seat belongs to the front waiter; a current holder's
         // revalidation above never loses its own claim to this queue.
         const queue = this.waiters.get(resource);
@@ -101,76 +92,12 @@ export class TurnResources {
             if (!queue.length)
                 this.waiters.delete(resource);
         }
-        const record = { owner };
-        if (options.idle) {
-            record.idle = options.idle;
-            // Taking (or retaking) a seat is itself screen activity: the quiet
-            // window of #1653 starts at the claim, not at the first later call.
-            record.activityAt = now;
-        }
-        this.owners.set(resource, record);
-        const reclaimed = this.reclaims.get(resource);
-        // Seating an owner closes any idle-release record for this resource:
-        // the previous holder re-claimed (its turn lives on), or another turn
-        // took the free seat — an occupied seat is exactly where #1653 says
-        // the old holder yields.
-        if (reclaimed)
-            this.reclaims.delete(resource);
+        this.owners.set(resource, owner);
         return true;
     }
-    owns(resource, owner, now = Date.now()) {
-        this.expireIdle(resource, now);
-        const current = this.owners.get(resource);
-        return Boolean(current && sameOwner(current.owner, owner));
-    }
-    /** A real screen call touched this claim (#1653): restart its quiet
-     * window. Claims without an idle policy — and anything the screen
-     * poller drives — are no-ops, so preview frames can never hold a seat. */
-    activity(resource, owner, now = Date.now()) {
-        // Expiry first: a straggler screen completion arriving at or past the
-        // quiet boundary must release the seat and open the reclaim window,
-        // not restart the clock on a claim that already lapsed.
-        this.expireIdle(resource, now);
+    owns(resource, owner) {
         const current = this.owners.get(resource);
-        if (current?.idle && sameOwner(current.owner, owner))
-            current.activityAt = now;
-    }
-    /** A screen-touching computer tool call started on this claim (#1653):
-     * the desktop is executing real I/O for the sitting owner, so the seat
-     * cannot be idle-released mid-call. Only the sitting owner's start
-     * counts; a start whose completion never arrives holds the seat until
-     * settle — the pre-#1653 behavior, never an overlapping handoff. */
-    beginComputerCall(resource, owner) {
-        const current = this.owners.get(resource);
-        if (current?.idle && sameOwner(current.owner, owner)) {
-            current.computerCallsInFlight = (current.computerCallsInFlight ?? 0) + 1;
-        }
-    }
-    /** The in-flight computer call finished: drop its fence and let the
-     * completion's own activity tick govern the quiet window. A no-op when
-     * the claim lapsed or another turn seated itself in between. */
-    endComputerCall(resource, owner) {
-        const current = this.owners.get(resource);
-        if (!current?.idle || !sameOwner(current.owner, owner))
-            return;
-        const inFlight = current.computerCallsInFlight ?? 0;
-        if (inFlight > 0)
-            current.computerCallsInFlight = inFlight - 1;
-    }
-    /** Who may still re-claim `resource` directly after an idle release
-     * (#1653): the mid-task turn that went quiet, until its reclaim window
-     * ends or another turn seats itself. The direct re-claim itself is
-     * just `claim`: a free seat answers the returning holder's next screen
-     * call without the wait a new arrival would enter. */
-    reclaimHolder(resource, now = Date.now()) {
-        const reclaimed = this.reclaims.get(resource);
-        if (!reclaimed)
-            return undefined;
-        if (reclaimed.until <= now) {
-            this.reclaims.delete(resource);
-            return undefined;
-        }
-        return reclaimed.owner;
+        return Boolean(current && sameOwner(current, owner));
     }
     release(owner) {
         for (const [key, queue] of this.waiters) {
@@ -181,81 +108,23 @@ export class TurnResources {
                 this.waiters.delete(key);
         }
         for (const [key, current] of this.owners) {
-            if (sameOwner(current.owner, owner))
+            if (sameOwner(current, owner))
                 this.owners.delete(key);
         }
-        // A settling turn keeps no reclaim priority (#1653): only a live
-        // mid-task turn may pick its seat back up.
-        for (const [key, reclaimed] of this.reclaims) {
-            if (sameOwner(reclaimed.owner, owner))
-                this.reclaims.delete(key);
-        }
     }
     /** Drop one of an owner's claims early, when the sequence that took it
      * could not finish. The owner's other claims stand until settle. */
-    releaseOne(resource, owner, now = Date.now()) {
-        if (this.owns(resource, owner, now))
+    releaseOne(resource, owner) {
+        if (this.owns(resource, owner))
             this.owners.delete(resource);
         this.stopWaiting(resource, owner);
-        // owns() may have just expired a quiet claim into a reclaim record
-        // for this same owner: an early release keeps no reclaim priority.
-        const reclaimed = this.reclaims.get(resource);
-        if (reclaimed && sameOwner(reclaimed.owner, owner))
-            this.reclaims.delete(resource);
-    }
-    /** Quiet-window expiry (#1653), evaluated when the claim is touched: a
-     * screen-quiet seat is released while its turn lives and remembered for
-     * the reclaim window. Synchronous on purpose — the claim map decides
-     * every transition on the server's single thread. */
-    expireIdle(resource, now) {
-        const current = this.owners.get(resource);
-        if (!current?.idle || current.activityAt === undefined)
-            return;
-        // A call the desktop is still executing fences the seat (#1653):
-        // releasing mid-call would hand one desktop to two turns at once.
-        if ((current.computerCallsInFlight ?? 0) > 0)
-            return;
-        if (!current.idle.quietElapsed(current.activityAt, now))
-            return;
-        this.owners.delete(resource);
-        this.reclaims.set(resource, { owner: current.owner, until: now + current.idle.reclaimMs });
     }
     /** Whether any live owner holds this resource: the parked-resume drain's
      * gate (#1651) — a resume fires only when the seat it queued on is free. */
-    free(resource, now = Date.now()) {
-        for (const key of this.owners.keys()) {
-            if (!overlaps(key, resource))
-                continue;
-            // A quiet-window claim expires the moment anything needs to know
-            // whether the seat is free: the parked-resume gate must not wait on
-            // a claim whose window already elapsed (#1653).
-            this.expireIdle(key, now);
-            if (this.owners.has(key))
-                return false;
-        }
-        return true;
+    free(resource) {
+        return !this.owners.has(resource);
     }
 }
 function sameOwner(a, b) {
     return a.threadId === b.threadId && a.generation === b.generation;
 }
-export function workspaceResource(cwd) {
-    // Selected folders must exist before the engine starts. Resolve symlinks
-    // and native filename casing so aliases cannot grant two writers to the
-    // same project on case-insensitive volumes.
-    const canonical = realpathSync.native(resolve(cwd));
-    return `workspace:${process.platform === "win32" ? canonical.toLowerCase() : canonical}`;
-}
-function overlaps(a, b) {
-    if (a === b)
-        return true;
-    if (!a.startsWith("workspace:") || !b.startsWith("workspace:"))
-        return false;
-    const left = a.slice("workspace:".length);
-    const right = b.slice("workspace:".length);
-    const contains = (parent, child) => {
-        const path = relative(parent, child);
-        return path === "" || (path !== ".." && !path.startsWith(`..${sep}`) && !path.startsWith(sep) && !/^[A-Za-z]:/.test(path));
-    };
-    return contains(left, right) || contains(right, left);
-}

package/dist-server/server/usage-ledger.js

@@ -26,7 +26,9 @@ const promptBytesOf = (value) => {
         ? { stable: clean(record.stable), volatile: clean(record.volatile) }
         : null;
 };
-function monthKey(at) {
+/** The UTC month a row belongs to, `YYYY-MM`: the name of its month file.
+ * The decision, admin-activity and decider logs use the same layout. */
+export function monthKey(at) {
     return `${at.getUTCFullYear()}-${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
 }
 export function usageFileFor(dataDir, at) {

package/dist-server/server/workspace.js

@@ -588,9 +588,8 @@ export function writeMemoryTopic(botId, name, text) {
     writeFileAtomic(join(workspaceDir(botId), "memory", name), redactSecretsInText(text), { mode: 0o600 });
     indexWrittenMemoryFile(botId, `memory/${name}`);
 }
-/** Read one topic file. The name gate runs here too, not only in the HTTP
- * route — a future caller must not be able to turn this into a read of an
- * arbitrary path. Null for anything invalid or unreadable. */
+/** Read one topic file. The name gate runs here, so no caller can turn this
+ * into a read of an arbitrary path. Null for anything invalid or unreadable. */
 export function readMemoryTopic(botId, name) {
     if (!isMemoryTopicName(name))
         return null;

package/dist-server/server-launcher.js

@@ -0,0 +1,72 @@
+// server/server-launcher.ts
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// server/restart.ts
+var RESTART_EXIT_CODE = 75;
+var MAX_RESTARTS = 5;
+var STABLE_RUN_MS = 6e4;
+function restartPolicy(now = Date.now) {
+  let restarts = 0, startedAt = now();
+  return {
+    again(code, stopping = false) {
+      if (now() - startedAt >= STABLE_RUN_MS) restarts = 0;
+      if (stopping || code !== RESTART_EXIT_CODE || restarts >= MAX_RESTARTS) return false;
+      restarts++;
+      startedAt = now();
+      return true;
+    }
+  };
+}
+
+// server/server-launcher.ts
+function superviseServer(start, options = {}) {
+  const signals = options.signals ?? process, now = options.now ?? Date.now;
+  return new Promise((done) => {
+    let child, stopping = false;
+    const policy = restartPolicy(now);
+    const pass = (signal) => () => {
+      stopping = true;
+      child.kill(signal);
+    };
+    const onTerm = pass("SIGTERM"), onInt = pass("SIGINT");
+    const finish = (code) => {
+      signals.off("SIGTERM", onTerm);
+      signals.off("SIGINT", onInt);
+      done(code);
+    };
+    const run = () => {
+      child = start();
+      child.once("error", () => finish(1));
+      child.once("exit", (code, signal) => {
+        if (policy.again(code, stopping)) {
+          console.log("OpenMausBot is starting again to finish installing a copy from the desktop app\u2026");
+          run();
+          return;
+        }
+        finish(code ?? (stopping && (signal === "SIGTERM" || signal === "SIGINT") ? 0 : 1));
+      });
+    };
+    signals.on("SIGTERM", onTerm);
+    signals.on("SIGINT", onInt);
+    run();
+  });
+}
+function isEntry() {
+  try {
+    return Boolean(process.argv[1]) && import.meta.url === pathToFileURL(realpathSync(resolve(process.argv[1]))).href;
+  } catch {
+    return false;
+  }
+}
+if (isEntry()) {
+  const server = join(dirname(fileURLToPath(import.meta.url)), "index.js");
+  void superviseServer(() => spawn(process.execPath, [server], { stdio: "inherit" })).then((code) => {
+    process.exitCode = code;
+  });
+}
+export {
+  superviseServer
+};

package/dist-server/shared/ask-question.js

@@ -34,7 +34,7 @@ export const MAX_CUSTOM_ANSWER = 2000;
 export function isPersistentQuestionCard(card) {
     return Boolean(card && (card.requestType === "question" || card.questionRequest ||
         (!card.requestType && !card.tool && !card.routineRequest && !card.skillRequest && !card.profileRequest &&
-            !card.modelRequest && !card.tighteningRequest && !card.teamSetupRequest)));
+            !card.modelRequest && !card.teamSetupRequest)));
 }
 /** System/provider completion ends the live run, not the human's question. */
 export function shouldSettleRequestCard(card, source) {

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

@@ -0,0 +1,12 @@
+// Which engines can work on a cloud computer: Hosted desktop on Boat, or a
+// self-hosted VPS. One rule for the server (every attach, readiness check and
+// select_computer offer) and the renderer (the Works on panel, the composer's
+// place chip, Webhooks and Routines), so the two never disagree.
+/** An engine with computer tools gets the cloud computer as one more stdio
+ * computer server. The Computer engine (boxAgent) runs its whole turn on its
+ * Boat, so it can work on a Boat but not on a VPS. */
+export function canWorkOnCloud(engine, backend) {
+    const runsOnBoat = engine?.driverKind === "boxAgent";
+    const hasComputerTools = engine?.computerMcp === true;
+    return backend === "vps" ? hasComputerTools && !runsOnBoat : hasComputerTools || runsOnBoat;
+}

package/dist-server/shared/failed-turn.js

@@ -0,0 +1,25 @@
+// A failed turn is stored as an activity row named "error: <what went
+// wrong>", in a 1:1 chat and a room alike. The server writes every such row
+// through failedTurnTool and the clients read it back through
+// failedTurnCause, so the marker and the one length limit live here only.
+const MARKER = "error:";
+/** The longest cause a row keeps. Clients wrap the row and show it whole, so
+ * this only bounds a pathological message (a provider's HTML body, a stack
+ * trace); a sentence a person acts on fits, its next action included. */
+export const FAILED_TURN_MAX_CHARS = 600;
+/** The activity row a failed turn is stored as. */
+export function failedTurnTool(cause, flags = {}) {
+    const words = cause.length > FAILED_TURN_MAX_CHARS ? `${cause.slice(0, FAILED_TURN_MAX_CHARS - 1)}…` : cause;
+    return {
+        name: `${MARKER} ${words}`,
+        ok: false,
+        ...(flags.setup ? { setup: true } : {}),
+        ...(flags.terminal ? { terminal: true } : {}),
+        ...(flags.claudeUpdate ? { claudeUpdate: true } : {}),
+    };
+}
+/** The cause a failed-turn row carries, without its marker; null for any
+ * other activity row. */
+export function failedTurnCause(name) {
+    return name.startsWith(MARKER) ? name.slice(MARKER.length).trim() : null;
+}

package/dist-server/shared/live-approval.js

@@ -1,12 +1,12 @@
 /** "approval": a provider or peer ask the voice may decide with a strict yes/no.
  * "review": a harness-native proposal (skill, routine, profile, default
- * model, tightening, team setup) that must be reviewed on screen.
+ * model, team setup) that must be reviewed on screen.
  * "question": a provider question. An expired proposal is settled: nothing
  * can answer it any more. */
 export function liveCardKind(card) {
     if (!card?.requestId || card.answered || card.dismissed || card.expired)
         return null;
-    if (card.skillRequest || card.routineRequest || card.profileRequest || card.modelRequest || card.tighteningRequest || card.teamSetupRequest) {
+    if (card.skillRequest || card.routineRequest || card.profileRequest || card.modelRequest || card.teamSetupRequest) {
         return "review";
     }
     return card.tool ? "approval" : "question";

package/dist-server/shared/package-format.js

@@ -55,9 +55,9 @@ const encoder = new TextEncoder();
 export function utf8Bytes(value) {
     return encoder.encode(value).length;
 }
-// ── shared field helpers (identical to the v1 reader) ─────────────────────
-const requiredText = (max) => z.string({ error: "must be text" }).trim().min(1, { message: "is required" }).max(max, { message: "is too long" });
-const optionalText = (max) => z
+// ── shared field helpers (the team manifest reader uses these too) ────────
+export const requiredText = (max) => z.string({ error: "must be text" }).trim().min(1, { message: "is required" }).max(max, { message: "is too long" });
+export const optionalText = (max) => z
     .union([z.string({ error: "must be text" }), z.null(), z.undefined()])
     .transform((value) => value?.trim() || undefined)
     .refine((value) => value === undefined || value.length <= max, { message: "is too long" })

package/dist-server/shared/pairing-link.js

@@ -0,0 +1,144 @@
+// The one `openmausbot://pair` link builder. The desktop's phone setup, the
+// headless server's pairing endpoint and `openmausbot pair` all print this
+// link; the Android and iOS scanners read it (android/core Connection.kt
+// `PairingInvite.parse`, ios CompanionCore Client.swift `PairingInvite.parse`).
+//
+// Every value is written with encodeURIComponent, so a space is `%20`. The
+// desktop used URLSearchParams until Oct 2026, which writes a space as `+`;
+// neither phone read that back as a space, and "Miguel's computer" showed up
+// as "Miguel's+computer". The phones now also read `+` as a space, for links
+// from desktops still running the old builder.
+/** How many fallback routes a link will carry. The list is tiny in practice;
+ * the cap only keeps a pathological interface table from bloating the QR. */
+export const MAX_PAIRING_HOSTS = 8;
+const ENDPOINT_KINDS = new Set(["hosted", "tailnet", "lan", "bonjour"]);
+/** Keep the QR contract strict even though its input came from our own
+ * sidecar. A public URL with credentials or a path is not a companion base
+ * URL, and filtering it is safer than teaching the phone to reinterpret it.
+ * Sorted by priority, deduplicated by origin, capped. */
+export function qrEndpoints(endpoints) {
+    const seen = new Set();
+    const valid = [];
+    for (const endpoint of endpoints ?? []) {
+        if (!endpoint ||
+            !ENDPOINT_KINDS.has(endpoint.kind) ||
+            !Number.isInteger(endpoint.priority) ||
+            endpoint.priority < 0 ||
+            endpoint.priority > 1_000_000) {
+            continue;
+        }
+        try {
+            const parsed = new URL(endpoint.url);
+            const expectedProtocol = endpoint.kind === "hosted" ? "https:" : "http:";
+            const explicitPort = parsed.port ? Number(parsed.port) : null;
+            const hostname = parsed.hostname.toLowerCase().replace(/\.$/, "");
+            if (parsed.protocol !== expectedProtocol ||
+                // No empty DNS label (".ts.net", "mac..local"): the phones refuse
+                // one, and one endpoint they refuse makes them refuse the whole QR.
+                hostname.split(".").includes("") ||
+                (endpoint.kind === "tailnet" && !hostname.endsWith(".ts.net")) ||
+                (explicitPort !== null && (!Number.isInteger(explicitPort) || explicitPort < 1 || explicitPort > 65_535)) ||
+                parsed.username ||
+                parsed.password ||
+                parsed.pathname !== "/" ||
+                parsed.search ||
+                parsed.hash ||
+                seen.has(parsed.origin)) {
+                continue;
+            }
+            seen.add(parsed.origin);
+            valid.push({ url: parsed.origin, kind: endpoint.kind, priority: endpoint.priority });
+        }
+        catch {
+            // One malformed advisory route must not invalidate an otherwise usable
+            // pairing QR. It is simply omitted from the route walk.
+        }
+    }
+    return valid.sort((left, right) => left.priority - right.priority).slice(0, MAX_PAIRING_HOSTS);
+}
+/** URL-safe, unpadded base64 keeps the structured JSON smaller than query
+ * escaping every quote and slash while remaining straightforward to decode
+ * with Foundation on iOS. */
+function encodeEndpoints(endpoints) {
+    const bytes = new TextEncoder().encode(JSON.stringify(endpoints));
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function validSecretPublicKey(value) {
+    if (!value || !/^[A-Za-z0-9_-]{87}$/.test(value))
+        return null;
+    try {
+        const base64 = value.replaceAll("-", "+").replaceAll("_", "/") + "=";
+        const decoded = atob(base64);
+        if (decoded.length !== 65 || decoded.charCodeAt(0) !== 4)
+            return null;
+        let binary = "";
+        for (let index = 0; index < decoded.length; index += 1)
+            binary += decoded[index];
+        return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "") === value
+            ? value
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The `address` value: `host:port` (IPv6 bracketed) or a bare http(s)
+ * origin, or null when it is neither. Both phones refuse an address with
+ * credentials, a path, a query or a fragment, as `qrEndpoints` does. */
+function linkAddress(address, port) {
+    const value = address.trim();
+    if (!value)
+        return null;
+    if (/^https?:\/\//i.test(value)) {
+        try {
+            const parsed = new URL(value);
+            if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash)
+                return null;
+            return parsed.origin;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (port === undefined || !Number.isInteger(port) || port < 1 || port > 65_535)
+        return null;
+    const authority = value.includes(":") && !value.startsWith("[") ? `[${value}]` : value;
+    return `${authority}:${port}`;
+}
+/**
+ * A short-lived handoff from a trusted pairing screen to the mobile app. The
+ * credential still has to be redeemed; putting it in the link does not
+ * create or expose the long-lived device token. Null when any required part
+ * is malformed, so a caller never prints a link a phone would refuse.
+ */
+export function phonePairingLink({ address, port, token, code, name, hosts, endpoints, secretPublicKey, }) {
+    const dial = linkAddress(address, port);
+    if (!dial || !/^omb_pair_[A-Za-z0-9_-]{43}$/.test(token))
+        return null;
+    if (code !== undefined && !/^\d{6}$/.test(code))
+        return null;
+    const fields = [["address", dial], ["token", token]];
+    if (code !== undefined)
+        fields.push(["code", code]);
+    if (name?.trim())
+        fields.push(["name", name.trim()]);
+    // Comma-joined, which no hostname or IP literal can contain. Filtered
+    // rather than refused: a bad candidate costs the phone one failed dial,
+    // and dropping the whole link over it would break pairing entirely.
+    const candidates = (hosts ?? [])
+        .map((candidate) => candidate.trim())
+        .filter((candidate) => candidate && !/[\s/?#,[\]]/.test(candidate))
+        .slice(0, MAX_PAIRING_HOSTS);
+    if (candidates.length)
+        fields.push(["hosts", candidates.join(",")]);
+    const routes = qrEndpoints(endpoints);
+    if (routes.length)
+        fields.push(["endpoints", encodeEndpoints(routes)]);
+    const secretKey = validSecretPublicKey(secretPublicKey);
+    if (secretKey)
+        fields.push(["secretKey", secretKey]);
+    return `openmausbot://pair?${fields.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&")}`;
+}

package/dist-server/vps-container-mcp.js

@@ -16202,10 +16202,6 @@ var remoteMutationSchema = remoteEntrySchema.extend({
   }).optional()
 });
 
-// server/cloud-overflow.ts
-var CLOUD_SEAT_IDLE_STOP_MS = 5 * 6e4;
-var CLOUD_SEAT_SLEEP_RETRY_MAX_MS = 10 * 6e4;
-
 // server/config.ts
 var optionalText = external_exports.string().optional();
 var SSH_ALIAS = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
@@ -16403,17 +16399,6 @@ var featureConfigSchema = external_exports.object({
    * conversations that share words with the message ride into the turn.
    * Read-only; on unless explicitly switched off — see autoRecallEnabled. */
   autoRecall: external_exports.boolean().optional(),
-  /** Idle release for computer claims (#1653): a desktop seat that stays
-   * screen-quiet for 90 seconds is released to waiting turns while its
-   * holder's turn still lives; the previous holder re-claims directly
-   * for 10 minutes and yields to an occupied seat. Off until baked; see
-   * computerClaimIdleReleaseEnabled for how to enable it by hand. */
-  computerClaimIdleRelease: external_exports.boolean().optional(),
-  /** Consented cloud overflow for local computer waits (#1655): a wait
-   * may offer a per-second-billed cloud seat, but only through an explicit
-   * consent card or a configured allowlist — never a silent Auto default.
-   * Off until baked; see cloudOverflowEnabled for how to enable it by hand. */
-  cloudOverflow: external_exports.boolean().optional(),
   /** Opt-in shared skills library: one store at the data dir that bots
    * read by assignment instead of per-workspace copies. Off until
    * explicitly enabled — see skillsLibraryEnabled. */
@@ -16539,8 +16524,12 @@ var appConfigSchema = external_exports.object({
    * provider is Boat now and the key is kept for compatibility. */
   box: external_exports.object({ token: optionalText }).optional(),
   vps: vpsConfigSchema.optional(),
-  /** Optional OpenCode key; persisted write-only and passed only to its child. */
-  opencodeGo: external_exports.object({ apiKey: optionalText }).optional(),
+  /** Optional OpenCode key; persisted write-only and passed only to its child.
+   * `providerKeys`: keys for OpenCode's other providers (Venice, Groq…) by the
+   * environment name OpenCode reads, also write-only and only for its child.
+   * Settings changes go through mergeOpenCodeProviderKeys; the stored copy
+   * is read loosely (storedAppConfigSchema). */
+  opencodeGo: external_exports.object({ apiKey: optionalText, providerKeys: external_exports.record(external_exports.string(), external_exports.string()).optional() }).optional(),
   /** Voice settings and the selected voice id. `provider` picks the
    * engine: "elevenlabs" (default; needs `key`), "fish" (needs its own
    * `fishKey`; `fishModel` picks its speech model), "system" (the Mac's
@@ -16620,15 +16609,6 @@ var appConfigSchema = external_exports.object({
   /** The authorization decision log (server/decision-log.ts): days of month
    * files kept, at least; OMB_DECISION_RETENTION_DAYS wins when set. */
   decisions: external_exports.object({ retentionDays: external_exports.number().int().min(1).max(3650).optional() }).strict().optional(),
-  /** #1655 cloud-overflow settings. perSecondCostUsd is the operator's own
-   * verified rate: with no price configured the feature stays inert rather
-   * than show an invented one. allowlistedThreads carries standing consent
-   * for exact thread ids. */
-  cloudOverflow: external_exports.object({
-    perSecondCostUsd: external_exports.number().positive().max(10).optional(),
-    idleStopMs: external_exports.number().int().positive().max(24 * 60 * 6e4).optional(),
-    allowlistedThreads: external_exports.array(external_exports.string().min(1)).max(1e3).optional()
-  }).strict().optional(),
   localVm: localVmConfigSchema.optional(),
   features: featureConfigSchema.optional(),
   onboarding: onboardingConfigSchema.optional(),
@@ -16643,7 +16623,14 @@ var appConfigSchema = external_exports.object({
   mcpServers: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 });
 var storedAppConfigSchema = appConfigSchema.extend({
-  browserProfiles: storedBrowserProfilesSchema.optional()
+  browserProfiles: storedBrowserProfilesSchema.optional(),
+  /** Read loosely, like mcpServers: a hand-edited provider key that isn't
+   * text is dropped here, and a bad name or key later
+   * (openCodeProviderKeys), never the whole file. */
+  opencodeGo: external_exports.object({
+    apiKey: optionalText,
+    providerKeys: external_exports.record(external_exports.string(), external_exports.unknown()).catch({}).transform((keys) => Object.fromEntries(Object.entries(keys).filter((entry) => typeof entry[1] === "string"))).optional()
+  }).optional()
 });
 var appConfigPatchSchema = appConfigSchema.omit({ instances: true, mcpServers: true, cliStartup: true, customDomain: true }).extend({ threads: threadsPatchSchema.optional(), newBots: newBotsPatchSchema.optional() });
 var jsonObjectSchema = external_exports.record(external_exports.string(), external_exports.json());