openmausbot 0.1.90 → 0.1.92

package/dist-server/server/team-backup.js

@@ -94,7 +94,9 @@ export function createTeamBackup(store, routines, name) {
             key: group.id, name: group.name, section: group.section, dm: Boolean(group.dm) && memberIds.length === 2,
             bulletin: group.bulletin, memberIds,
             defaultResponder: group.defaultResponder.kind === "member" && !memberIds.includes(group.defaultResponder.botId)
-                ? { kind: "mentions" } : group.defaultResponder,
+                ? { kind: "mentions" }
+                : group.defaultResponder.kind === "auto" && group.defaultResponder.fallbackBotId && !memberIds.includes(group.defaultResponder.fallbackBotId)
+                    ? { kind: "auto" } : group.defaultResponder,
             activeTask: group.threadId, tasks: history(group),
         };
     });
@@ -226,7 +228,9 @@ export function importTeamBackup(store, routines, input, selection, options = {}
             groups.push(group);
             groupIds.set(source.key, group.id);
             const responder = source.defaultResponder;
-            store.patchGroup(group.id, { bulletin: source.bulletin, setupCompletedAt: Date.now(), defaultResponder: responder.kind === "member" ? { kind: "member", botId: botIds.get(responder.botId) } : responder });
+            store.patchGroup(group.id, { bulletin: source.bulletin, setupCompletedAt: Date.now(), defaultResponder: responder.kind === "member" ? { kind: "member", botId: botIds.get(responder.botId) }
+                    : responder.kind === "auto" ? { kind: "auto", ...(responder.fallbackBotId ? { fallbackBotId: botIds.get(responder.fallbackBotId) } : {}) }
+                        : responder });
             // Use the existing task APIs for rooms; direct-message rooms have one.
             const threads = source.tasks.map((task, i) => {
                 if (i === 0) {

package/dist-server/server/team-manifest.js

@@ -25,11 +25,18 @@ const optionalText = (max) => z
     .transform((value) => value?.trim() || undefined)
     .refine((value) => value === undefined || value.length <= max, { message: "is too long" })
     .optional();
-const responderSchema = z.discriminatedUnion("kind", [
+const RESPONDER_KINDS = new Set(["member", "everyone", "mentions", "auto"]);
+/** A responder kind from a newer release reads as "no responder": the room
+ * is created with the default lead, never refused. */
+const responderSchema = z.preprocess((value) => {
+    const kind = value && typeof value === "object" ? value.kind : undefined;
+    return typeof kind === "string" && !RESPONDER_KINDS.has(kind) ? { kind: "mentions" } : value;
+}, z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("member"), member: requiredText(64) }),
     z.object({ kind: z.literal("everyone") }),
     z.object({ kind: z.literal("mentions") }),
-]);
+    z.object({ kind: z.literal("auto"), member: requiredText(64).optional() }),
+]));
 const memberSchema = z.object({
     key: requiredText(64).regex(/^[a-z0-9][a-z0-9_-]*$/, {
         message: "may only contain lowercase letters, numbers, - and _",
@@ -117,7 +124,8 @@ export function parseTeamManifest(value) {
         result.team.description = parsed.data.team.description;
     if (parsed.data.version === LEGACY_TEAM_MANIFEST_VERSION) {
         const defaultResponder = parsed.data.team.room.defaultResponder;
-        if (defaultResponder.kind === "member" && !seenKeys.has(defaultResponder.member)) {
+        if ((defaultResponder.kind === "member" || defaultResponder.kind === "auto") && defaultResponder.member !== undefined &&
+            !seenKeys.has(defaultResponder.member)) {
             throw new Error(`Unknown default responder: ${defaultResponder.member}`);
         }
         result.team.room = {

package/dist-server/server/thread-events.js

@@ -215,6 +215,8 @@ function isRuntimeEvent(value) {
                     value.source === "peer"));
         case "thread.token-usage.updated":
             return typeof value.input === "number" && typeof value.output === "number";
+        case "runtime.notice":
+            return typeof value.message === "string";
         case "runtime.error":
             return typeof value.message === "string" &&
                 (value.setup === undefined || typeof value.setup === "boolean") &&

package/dist-server/server/thread-starters.js

@@ -35,6 +35,39 @@ export class ThreadStarters {
     get(threadId) {
         return this.starters.get(threadId);
     }
+    /** The threads opened for one person, newest first, at most `limit`. */
+    threadsOf(person, limit) {
+        const threads = [];
+        for (const [threadId, starter] of [...this.starters].reverse()) {
+            if (starter !== person)
+                continue;
+            threads.push(threadId);
+            if (threads.length >= limit)
+                break;
+        }
+        return threads;
+    }
+    /** Everyone a thread here was opened for. */
+    people() {
+        return new Set(this.starters.values());
+    }
+    /** Name `to` for every thread whose person `move` accepts: a one-time
+     * migration (server/cloud-owner.ts), not an ordinary record. The threads
+     * that changed. */
+    reassign(move, to) {
+        if (!KEY.test(to))
+            return [];
+        const moved = [];
+        for (const [threadId, person] of this.starters) {
+            if (person === to || !move(person))
+                continue;
+            this.starters.set(threadId, to);
+            moved.push(threadId);
+        }
+        if (moved.length)
+            writeFileAtomic(this.file, JSON.stringify(Object.fromEntries(this.starters)) + "\n", { mode: 0o600 });
+        return moved;
+    }
     /** Record once; a thread keeps the person it was first opened for. */
     set(threadId, person) {
         if (!person || !KEY.test(person) || !THREAD.test(threadId) || this.starters.has(threadId))

package/dist-server/server/thread-title.js

@@ -0,0 +1,46 @@
+// What a generated thread title is asked from.
+//
+// A fresh thread is named from its first message. "Regenerate title" (#1858)
+// names it again from the conversation as it is now: the newest user and bot
+// lines, never tool output, cards or screen frames, and bounded so the
+// one-shot stays as cheap as the first-message one.
+import { redactSecretsInText } from "./redact.js";
+/** The most text either kind of title one-shot ever sees. */
+export const TITLE_INPUT_MAX_CHARS = 1_500;
+const EXCERPT_MAX_MESSAGES = 12;
+const EXCERPT_LINE_MAX_CHARS = 300;
+const ATTACHMENT_TAG = /<attached-(?:image|file)\b[^>]*\/>/g;
+export function threadTitlePrompt(text, source = "first-message") {
+    return [
+        source === "conversation"
+            ? "Name the conversation below by what it is about now."
+            : "Name the conversation that begins with the message below.",
+        "Reply with only a short title: 3 to 6 words, plain text, no quotes, no trailing period.",
+        source === "conversation" ? "Conversation:" : "Message:",
+        text.trim().slice(0, TITLE_INPUT_MAX_CHARS),
+    ].join("\n");
+}
+/** The newest user and bot text lines, oldest first, one per line and each
+ * clipped, until the next line would pass the input cap. Attachment markup
+ * and secrets are scrubbed before anything leaves this machine. Empty when
+ * the thread has nothing a title could be drawn from. */
+export function titleConversationExcerpt(messages) {
+    const lines = [];
+    let length = 0;
+    for (let index = messages.length - 1; index >= 0 && lines.length < EXCERPT_MAX_MESSAGES; index--) {
+        const message = messages[index];
+        // peer asides and still-queued lines are not the conversation yet
+        if (message.kind !== "text" || !message.text || message.aside || message.queued)
+            continue;
+        const text = redactSecretsInText(message.text.replace(ATTACHMENT_TAG, " ")).replace(/\s+/g, " ").trim();
+        if (!text)
+            continue;
+        const clipped = text.length > EXCERPT_LINE_MAX_CHARS ? `${text.slice(0, EXCERPT_LINE_MAX_CHARS - 1)}…` : text;
+        const line = `${message.role === "user" ? "User" : "Bot"}: ${clipped}`;
+        if (length + line.length + 1 > TITLE_INPUT_MAX_CHARS)
+            break;
+        lines.push(line);
+        length += line.length + 1;
+    }
+    return lines.reverse().join("\n");
+}

package/dist-server/server/tts/elevenlabs.js

@@ -10,7 +10,12 @@
 // client already splits text into utterances and fetches the next while the
 // current one plays, which gets the same perceived latency with far fewer
 // moving parts — and no socket to leak when a turn is interrupted.
-const API = process.env.OMB_ELEVENLABS_API || "https://api.elevenlabs.io/v1";
+//
+// The base URL is the caller's: ElevenLabs itself for the person's own key
+// (OMB_ELEVENLABS_API overrides it for dev and tests), Cloud Pro's relay for
+// its included token (included-services.ts). Only a key being saved is
+// verified, and that is always an own key.
+import { elevenLabsProviderApi } from "../included-services.js";
 const MODEL = "eleven_flash_v2_5";
 // 64kbps mono is indistinguishable for speech and a third of the bytes
 const FORMAT = "mp3_44100_64";
@@ -51,7 +56,7 @@ function message(status, what, body) {
  * picker needs next, so it tests exactly the capability that matters. */
 export async function verifyKey(key) {
     try {
-        const res = await fetch(`${API}/voices`, {
+        const res = await fetch(`${elevenLabsProviderApi()}/voices`, {
             headers: { "xi-api-key": key },
             signal: AbortSignal.timeout(20_000),
         });
@@ -63,8 +68,8 @@ export async function verifyKey(key) {
         return { ok: false, message: "Couldn't reach ElevenLabs to check that key — check your connection." };
     }
 }
-export async function listVoices(key) {
-    const res = await fetch(`${API}/voices`, {
+export async function listVoices(key, api) {
+    const res = await fetch(`${api}/voices`, {
         headers: { "xi-api-key": key },
         signal: AbortSignal.timeout(20_000),
     });
@@ -79,8 +84,8 @@ export async function listVoices(key) {
     }))
         .filter((v) => v.id);
 }
-export async function synthesize(text, voiceId, key) {
-    const res = await fetch(`${API}/text-to-speech/${encodeURIComponent(voiceId)}?output_format=${FORMAT}`, {
+export async function synthesize(text, voiceId, key, api) {
+    const res = await fetch(`${api}/text-to-speech/${encodeURIComponent(voiceId)}?output_format=${FORMAT}`, {
         method: "POST",
         headers: { "xi-api-key": key, "content-type": "application/json", accept: "audio/mpeg" },
         body: JSON.stringify({ text, model_id: MODEL }),

package/dist-server/server/tts/fish.js

@@ -1,7 +1,6 @@
-// Fish Audio text to speech. The API key stays on the harness: the renderer
-// receives only voice metadata and synthesized audio bytes.
 const API = (process.env.OMB_FISH_AUDIO_API || "https://api.fish.audio").replace(/\/+$/, "");
-const MODEL = "s2.1-pro";
+/** Used when no model is saved, so existing setups keep their behavior. */
+export const DEFAULT_FISH_MODEL = "s2.1-pro";
 const MAX_ERROR_LENGTH = 240;
 const PAGE_SIZE = 100;
 const MAX_OWNED_PAGES = 100;
@@ -124,7 +123,7 @@ export async function listVoices(key) {
     });
     return [...new Map(voices.map((voice) => [voice.id, voice])).values()];
 }
-export async function synthesize(text, voiceId, key) {
+export async function synthesize(text, voiceId, key, model = DEFAULT_FISH_MODEL) {
     let res;
     try {
         res = await fetch(`${API}/v1/tts`, {
@@ -133,7 +132,7 @@ export async function synthesize(text, voiceId, key) {
                 authorization: `Bearer ${key}`,
                 "content-type": "application/json",
                 accept: "audio/mpeg",
-                model: MODEL,
+                model,
             },
             body: JSON.stringify({
                 text,

package/dist-server/server/tts/index.js

@@ -1,3 +1,4 @@
+import { voiceCredential } from "../included-services.js";
 import * as chatterbox from "./chatterbox.js";
 import * as elevenlabs from "./elevenlabs.js";
 import * as grok from "./grok.js";
@@ -16,6 +17,9 @@ export class NoVoiceConfigured extends Error {
         this.reason = reason;
     }
 }
+/** The ElevenLabs credential in use: the person's own key, else the one
+ * included with Cloud Pro. Settings' own-key flows read cfg.tts.key instead. */
+const elevenLabs = (cfg) => voiceCredential(cfg.tts?.key);
 export function voiceProvider(cfg) {
     const provider = cfg.tts?.provider;
     return provider === "xai" || provider === "fish" || provider === "system" || provider === "chatterbox" ? provider : "elevenlabs";
@@ -33,7 +37,7 @@ export function providerConfigured(cfg) {
         return Boolean(cfg.tts?.baseUrl?.trim());
     if (provider === "fish")
         return Boolean(cfg.tts?.fishKey);
-    return Boolean(cfg.tts?.key);
+    return Boolean(elevenLabs(cfg));
 }
 export function voiceConfigured(cfg) {
     const provider = voiceProvider(cfg);
@@ -46,7 +50,7 @@ export function voiceConfigured(cfg) {
         return Boolean(cfg.tts?.baseUrl?.trim() && cfg.tts?.voice);
     if (provider === "fish")
         return Boolean(cfg.tts?.fishKey && cfg.tts?.voice);
-    return Boolean(cfg.tts?.key && cfg.tts?.voice);
+    return Boolean(elevenLabs(cfg) && cfg.tts?.voice);
 }
 /** A per-bot voice is a complete choice too; it should not be blocked just
  * because the app-wide fallback has not been selected yet. */
@@ -61,13 +65,16 @@ export function voiceReady(cfg, voiceId) {
         return Boolean(cfg.tts?.baseUrl?.trim() && (voiceId || cfg.tts?.voice));
     if (provider === "fish")
         return Boolean(cfg.tts?.fishKey && (voiceId || cfg.tts?.voice));
-    return Boolean(cfg.tts?.key && (voiceId || cfg.tts?.voice));
+    return Boolean(elevenLabs(cfg) && (voiceId || cfg.tts?.voice));
 }
 /** What the settings panel needs. Never includes the key — same write-only
  * rule as every other credential. baseUrl and model are Chatterbox
- * settings, not credentials, so they come back in full. */
+ * settings, not credentials, so they come back in full; `fishModel` is the
+ * Fish Audio speech model, resolved to its default when unset. `included`
+ * says the voice is Cloud Pro's, not a saved key. */
 export function describeVoice(cfg) {
     const provider = voiceProvider(cfg);
+    const included = provider === "elevenlabs" && elevenLabs(cfg)?.included === true;
     return {
         configured: providerConfigured(cfg),
         ready: voiceConfigured(cfg),
@@ -75,6 +82,8 @@ export function describeVoice(cfg) {
         provider,
         baseUrl: provider === "chatterbox" ? (cfg.tts?.baseUrl ?? "") : "",
         model: provider === "chatterbox" ? (cfg.tts?.model ?? "") : "",
+        ...(provider === "fish" ? { fishModel: cfg.tts?.fishModel ?? fish.DEFAULT_FISH_MODEL } : {}),
+        ...(included ? { included: true } : {}),
     };
 }
 export function verifyKey(provider, key) {
@@ -94,10 +103,10 @@ export async function listVoices(cfg, run) {
         const key = cfg.tts?.fishKey;
         return key ? fish.listVoices(key) : [];
     }
-    const key = cfg.tts?.key;
-    if (!key)
+    const credential = elevenLabs(cfg);
+    if (!credential)
         return [];
-    return elevenlabs.listVoices(key);
+    return elevenlabs.listVoices(credential.token, credential.api);
 }
 /** Synthesize one utterance. Throws NoVoiceConfigured when there is nothing
  * to speak with, which the route turns into a 409 the client can explain. */
@@ -140,13 +149,13 @@ export function speak(cfg, text, voiceId, run) {
         const voice = voiceId || cfg.tts?.voice;
         if (!voice)
             throw new NoVoiceConfigured("voice");
-        return fish.synthesize(text, voice, key);
+        return fish.synthesize(text, voice, key, cfg.tts?.fishModel);
     }
-    const key = cfg.tts?.key;
-    if (!key)
+    const credential = elevenLabs(cfg);
+    if (!credential)
         throw new NoVoiceConfigured("key");
     const voice = voiceId || cfg.tts?.voice;
     if (!voice)
         throw new NoVoiceConfigured("voice");
-    return elevenlabs.synthesize(text, voice, key);
+    return elevenlabs.synthesize(text, voice, credential.token, credential.api);
 }

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

@@ -85,6 +85,8 @@ const SCREENSHOT_CLEANUP_BUDGET_MS = 10_000;
 const PREPARATION_LOCK_TIMEOUT_MS = SCREENSHOT_BUDGET_MS + LOCK_ACQUIRE_TIMEOUT_MS;
 const pendingScreenshots = new Map();
 const viewerConnections = new Map();
+const REMOTE_VIEWER_GRACE_MS = 30_000;
+const NATIVE_VIEWER_LIFETIME_MS = 8 * 60 * 60_000;
 const desktopTunnels = new Map();
 function invalidateVpsStatus(key) {
     statusCache.delete(key);
@@ -198,12 +200,53 @@ function stopDesktopTunnel(botId) {
     return true;
 }
 export function closeVpsDesktopTunnel(botId) {
+    const tunnel = desktopTunnels.get(botId);
+    // Remote tabs still hold the tunnel; drop only the native claim and let
+    // the last tab's release start the grace period.
+    if (tunnel?.viewers) {
+        tunnel.localViewer = false;
+        clearTimeout(tunnel.expiry);
+        return { closed: false };
+    }
     return { closed: stopDesktopTunnel(botId) };
 }
 export function closeAllVpsDesktopTunnels() {
     for (const botId of desktopTunnels.keys())
         stopDesktopTunnel(botId);
 }
+/** Resolve only a tunnel opened by the authenticated join route. Multiple
+ * remote tabs share it; the final tab releases it unless a native viewer owns it. */
+export function vpsDesktopConnection(botId) {
+    const tunnel = desktopTunnels.get(botId);
+    if (!tunnel || tunnel.child.exitCode !== null || tunnel.child.killed)
+        return;
+    const url = new URL(tunnel.joinUrl);
+    return {
+        port: Number(url.port),
+        password: new URLSearchParams(url.hash.slice(1)).get("password"),
+        live: () => desktopTunnels.get(botId) === tunnel && tunnel.child.exitCode === null && !tunnel.child.killed,
+        retain: () => {
+            tunnel.viewers++;
+            if (!tunnel.localViewer)
+                clearTimeout(tunnel.expiry);
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                tunnel.viewers--;
+                if (!tunnel.viewers && !tunnel.localViewer && desktopTunnels.get(botId) === tunnel) {
+                    // A short grace period lets a reload/reconnect reuse the tunnel.
+                    tunnel.expiry = setTimeout(() => {
+                        if (desktopTunnels.get(botId) === tunnel)
+                            stopDesktopTunnel(botId);
+                    }, REMOTE_VIEWER_GRACE_MS);
+                    tunnel.expiry.unref();
+                }
+            };
+        },
+    };
+}
 const STREAM_CAP_CHARS = 16 * 1024 * 1024;
 /** Keeps the LAST 16MB of a stream without rebuilding one giant string per
  * chunk (a 10-minute `docker build` stream made that rebuild quadratic).
@@ -317,7 +360,7 @@ function emptyStatus(botId, alias) {
         desktopReady: false,
         desktop_error: null,
         ready: false,
-        problem: alias ? "Docker over SSH is not reachable" : "Configure a VPS SSH alias in App Settings → Connections",
+        problem: alias ? "Docker over SSH is not reachable" : "Configure a VPS SSH alias in Settings → API keys",
         image_ref: VPS_IMAGE,
         base_image_ref: BASE_IMAGE,
         driver_version: CUA_DRIVER_VERSION,
@@ -335,6 +378,9 @@ function isMissingObjectMessage(message) {
     return /no such (object|image|container)/i.test(message);
 }
 function transportFailure(message) {
+    if (/timed out/i.test(message)) {
+        return "Docker over SSH failed while checking the VPS: the connection timed out. Check that the VPS is online, SSH is reachable from this computer, and Docker is running on the VPS, then retry. No computer was reset.";
+    }
     return `Docker over SSH failed while checking the VPS: ${message.trim().slice(0, 200) || "unknown transport error"}`;
 }
 function privateDockerIpv4(value) {
@@ -371,7 +417,7 @@ function hasNoPublishedPorts(config, networks) {
 }
 function statusProblem(status) {
     if (!status.configured)
-        return "Configure a VPS SSH alias in App Settings → Connections";
+        return "Configure a VPS SSH alias in Settings → API keys";
     if (!status.daemonUp)
         return "Docker over SSH could not reach the VPS; check the SSH alias and Docker on the VPS";
     if (!status.image)
@@ -412,9 +458,23 @@ async function computeVpsComputerStatus(cfg, botId, runner) {
         return status;
     viewerConnections.delete(`${alias}:${status.container_name}`);
     const run = (args, timeoutMs = 10_000, input) => runner(vpsDockerArgs(alias, args), { timeoutMs, input });
+    // Only repeat read-only Docker inspections, never an exec or lifecycle
+    // mutation whose outcome is unknown after a lost connection. Awaiting the
+    // runner also lets its owned SSH process finish cleanup before retrying.
+    const inspect = async (args) => {
+        try {
+            return await run(args);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/timed out|connection reset by peer|broken pipe/i.test(message))
+                throw error;
+            return run(args);
+        }
+    };
     let inspectedImageId = null;
     try {
-        const inspected = JSON.parse((await run(["image", "inspect", VPS_IMAGE])).stdout);
+        const inspected = JSON.parse((await inspect(["image", "inspect", VPS_IMAGE])).stdout);
         status.daemonUp = true;
         const image = inspected[0];
         const labels = image?.Config?.Labels ?? image?.config?.Labels ?? image?.config?.labels;
@@ -434,7 +494,7 @@ async function computeVpsComputerStatus(cfg, botId, runner) {
         status.image = false;
     }
     try {
-        const inspected = JSON.parse((await run(["inspect", status.container_name])).stdout);
+        const inspected = JSON.parse((await inspect(["inspect", status.container_name])).stdout);
         const detail = inspected[0];
         const labels = detail?.Config?.Labels;
         const containerId = detail?.Id ?? detail?.id;
@@ -897,7 +957,7 @@ export async function removeManagedVpsComputer(cfg, owners, containerName, confi
     cfg = snapshotVpsConfig(cfg);
     const alias = vpsSshAlias(cfg);
     if (!alias) {
-        throw Object.assign(new Error("VPS is not configured — add an SSH config alias in Connections"), { status: 409 });
+        throw Object.assign(new Error("VPS is not configured — add an SSH config alias in Settings → API keys"), { status: 409 });
     }
     if (!MANAGED_VPS_CONTAINER_NAME.test(containerName)) {
         throw Object.assign(new Error("invalid managed VPS computer name"), { status: 400 });
@@ -948,7 +1008,7 @@ export async function vpsComputerAction(action, cfg, botId, runner = defaultRunn
     cfg = snapshotVpsConfig(cfg);
     const alias = vpsSshAlias(cfg);
     if (!alias)
-        throw Object.assign(new Error("VPS is not configured — add an SSH config alias in App Settings → Connections"), { status: 409 });
+        throw Object.assign(new Error("VPS is not configured — add an SSH config alias in Settings → API keys"), { status: 409 });
     const key = `${alias}:${vpsContainerName(botId)}`;
     const pending = action === "provision" ? pendingProvisions.get(key) : undefined;
     if (pending)
@@ -1054,13 +1114,20 @@ export async function inspectVpsForAuto(cfg, botId, runner = defaultRunner) {
  * returned URL is loopback-only and contains the per-container password in
  * its fragment (never sent in HTTP). Closing the app viewer calls the paired
  * close endpoint, and process shutdown closes every remaining child. */
-export async function vpsComputerJoin(cfg, botId, runner = defaultRunner) {
+export async function vpsComputerJoin(cfg, botId, runner = defaultRunner, remoteViewer = false) {
     cfg = snapshotVpsConfig(cfg);
     const alias = vpsSshAlias(cfg);
     if (!alias)
         throw Object.assign(new Error("VPS is not configured"), { status: 409 });
     const existing = desktopTunnels.get(botId);
     if (existing && existing.child.exitCode === null && !existing.child.killed) {
+        if (!remoteViewer)
+            existing.localViewer = true;
+        if (!existing.viewers || existing.localViewer) {
+            clearTimeout(existing.expiry);
+            existing.expiry = setTimeout(() => stopDesktopTunnel(botId), existing.localViewer ? NATIVE_VIEWER_LIFETIME_MS : REMOTE_VIEWER_GRACE_MS);
+            existing.expiry.unref();
+        }
         return { joinUrl: existing.joinUrl, state: "running" };
     }
     stopDesktopTunnel(botId);
@@ -1114,11 +1181,11 @@ export async function vpsComputerJoin(cfg, botId, runner = defaultRunner) {
         throw Object.assign(new Error(`Could not open the VPS live desktop: ${detail}`), { status: 502 });
     }
     const joinUrl = `http://127.0.0.1:${localPort}/vnc.html#autoconnect=true&resize=scale&password=${encodeURIComponent(connection.password)}`;
-    // Viewer-close is the normal cleanup. This unref'd ceiling is a backstop
-    // for a renderer crash or an old browser client that cannot signal close.
-    const expiry = setTimeout(() => stopDesktopTunnel(botId), 8 * 60 * 60_000);
+    // Remote tabs retain the tunnel when their WebSocket opens. Reclaim an
+    // abandoned join promptly; native windows retain the existing close/ceiling.
+    const expiry = setTimeout(() => stopDesktopTunnel(botId), remoteViewer ? REMOTE_VIEWER_GRACE_MS : NATIVE_VIEWER_LIFETIME_MS);
     expiry.unref?.();
-    desktopTunnels.set(botId, { child, joinUrl, expiry });
+    desktopTunnels.set(botId, { child, joinUrl, expiry, viewers: 0, localViewer: !remoteViewer });
     return { joinUrl, state: "running" };
 }
 export function vpsContainerMcpArgs(alias, containerName) {
@@ -1142,7 +1209,7 @@ export function vpsDriverError(driverKind, computerMcp) {
         return "The Computer engine runs its agent on Boat and cannot use a self-hosted VPS — choose Claude or an ACP engine";
     }
     if (!computerMcp) {
-        return "This model engine cannot mount a self-hosted VPS computer — choose Claude or an ACP engine";
+        return "This model cannot mount a self-hosted VPS computer — choose Claude or an ACP model provider";
     }
     return null;
 }

package/dist-server/server/webhooks.js

@@ -51,6 +51,10 @@ const storedWebhookSchema = z.object({
     updatedAt: z.number().finite().nonnegative(),
     lastReceivedAt: z.number().finite().nonnegative().optional(),
     lastRunId: z.string().optional(),
+    /** delivery:"post" only: the stable destination thread, resolved once
+     *  via WebhookManagerOptions.resolvePostThread and reused forever
+     *  after -- see the `post`/`resolvePostThread` doc comments above. */
+    resultsThreadId: z.string().min(1).optional(),
     deliveryCount: z.number().int().nonnegative(),
     verificationPending: z.boolean().optional(),
     verifiedAt: z.number().finite().nonnegative().optional(),
@@ -429,9 +433,22 @@ export class WebhookManager {
             // without a post sink is a configuration error, not a run request.
             if (!this.options.post)
                 fail(503, "This server cannot post webhook messages to chat");
+            // Resolved on every dispatch, exactly like routines.ts's newRun calls
+            // resolveResultsThread on every run -- the resolver owns the
+            // reuse-vs-allocate decision from trigger.resultsThreadId, so a host
+            // without resolvePostThread wired can only fail closed here, never
+            // silently fall back to whatever thread the bot happens to have
+            // selected right now (the bug this replaces -- issue #2071).
+            const threadId = this.options.resolvePostThread?.(trigger, false);
+            if (!threadId)
+                fail(503, "This server could not resolve a destination thread for this delivery");
+            if (threadId !== trigger.resultsThreadId) {
+                trigger.resultsThreadId = threadId;
+                trigger.updatedAt = now;
+            }
             const raw = event.payload;
             const text = raw && typeof raw === "object" && typeof raw.text === "string" && raw.text.trim() ? raw.text : serializePayload(event.payload);
-            this.options.post(trigger.botId, text.slice(0, 20000));
+            this.options.post(trigger.botId, threadId, text.slice(0, 20000));
             this.deliveries.push({ key: `${trigger.endpointId}:${deliveryId}`, runId: "post", at: now });
             if (this.deliveries.length > MAX_DELIVERIES)
                 this.deliveries.splice(0, this.deliveries.length - MAX_DELIVERIES);

package/dist-server/server/workspace-backup-policy.js

@@ -12,19 +12,38 @@ export function portableWorkspaceConfig(value) {
     const config = parseStoredConfig(value);
     return Object.fromEntries(PORTABLE_CONFIG_KEYS.filter((key) => config[key] !== undefined).map((key) => [key, config[key]]));
 }
+// Switches that belong to the machine even inside a portable section.
+// Computer sharing (lending a computer to this server) opens routes and a
+// desktop connector here, so a restored workspace never turns it on or off.
+const DESTINATION_FEATURES = ["sharedComputers"];
 export function restoredWorkspaceConfig(portable, destination) {
     if (!destination || typeof destination !== "object" || Array.isArray(destination))
         throw new Error("Invalid destination workspace configuration; connections were not changed.");
     const merged = { ...destination };
     for (const key of PORTABLE_CONFIG_KEYS)
         delete merged[key];
-    return { ...merged, ...portableWorkspaceConfig(portable) };
+    const restored = { ...merged, ...portableWorkspaceConfig(portable) };
+    const own = destination.features ?? {};
+    const features = { ...restored.features };
+    for (const key of DESTINATION_FEATURES) {
+        delete features[key];
+        if (own[key] !== undefined)
+            features[key] = own[key];
+    }
+    if (Object.keys(features).length)
+        restored.features = features;
+    else
+        delete restored.features;
+    return restored;
 }
 /** Exact app-owned authentication paths, not a scan of user document text. */
 export function excludedWorkspaceAuthPath(path) {
     // Machine/provider-specific execution grants are not portable template data.
     if (/^command-allowlist\.json(?:$|\.\d+\.[0-9a-f-]+\.tmp$)/.test(path))
         return true;
+    // MCP sign-in tokens belong to this machine's browser sign-ins.
+    if (/^mcp-oauth\.json(?:$|\.\d+\.[0-9a-f-]+\.tmp$)/.test(path))
+        return true;
     return /^(?:(?:providers|caddy|chrome-profile|\.agent-browser)(?:\/|$)|workspace-credentials\.json$|external-runtimes\.json$|browser-engine-key$)/.test(path) ||
         /^(?:config\.json|webhooks\.json|workspace-credentials\.json|external-runtimes\.json|browser-engine-key|sessions\.json|tunnel-account\.json)\.\d+(?:\.[0-9a-f-]+)?\.tmp$/.test(path) ||
         /^(?:vm-home|vm-homes\/[^/]+)\/\.browser-profiles(?:\/|$)/.test(path);
@@ -41,7 +60,10 @@ export function redownloadedOrgLibraryPath(path) {
 /** Per-turn engine hook bearers (`hook-tokens/<digest>.token`, written by the
  * Claude driver). They are dead once their turn settles, so they are never
  * exported. Unlike the saved auth paths above they are not refused on import:
- * v0.1.85 did export them, and such a backup must still restore, without them. */
+ * v0.1.85 did export them, and such a backup must still restore, without them.
+ * The same holds for the session registry's open marker: it describes the
+ * process that wrote it, so it is never exported or installed, and a restore
+ * leaves the destination's own marker where it is (workspace-backup.ts). */
 export function ephemeralWorkspaceTokenPath(path) {
-    return /^hook-tokens(?:\/|$)/.test(path);
+    return /^(?:hook-tokens(?:\/|$)|sessions\.json\.open$)/.test(path);
 }