openmausbot 0.1.92 → 0.1.93

package/dist-server/server/index.js

@@ -63,7 +63,7 @@ import { createMemoryUpkeep, upkeepEnabled } from "./memory-upkeep.js";
 import { appendAboutMe, commitLearned, planLearned } from "./profile-learned.js";
 import { canAccessTeam, canReachPeer, coordinatorSupervises, livePeerRoster, livePeerRosterBlock, peerAllowed, peerName, peerRosterSystemPrompt, peerStatus, peerStatusWords, reachablePeers, resolveTeammate, roomPeerRosterSystemPrompt, roomRosterLine, PEER_ACCESS_HELP } from "./peer-roster.js";
 import { openMausStatusSystemPrompt } from "./openmaus-status-capsule.js";
-import { containerComputerAction, containerComputerExists, containerComputerFrame, containerComputerMcp, containerComputerScreenshot, containerComputerStatus, containerExec, containerRuntimeStatus, localVmRecreatableOnDemand, localVmWorkspaceExists, perBotLocalVmTarget, poolLocalVmTarget, SHARED_LOCAL_VM_TARGET, setupCommands, VM_WORKSPACE_GUEST, } from "./container-computer.js";
+import { containerComputerAction, containerComputerExists, containerComputerFrame, containerComputerMcp, containerComputerScreenshot, containerComputerStatus, containerExec, containerRuntimeStatus, localVmWakeAction, localVmWorkspaceExists, perBotLocalVmTarget, poolLocalVmTarget, SHARED_LOCAL_VM_TARGET, setupCommands, VM_WORKSPACE_GUEST, } from "./container-computer.js";
 import { attachForTurn, saveBotAttachment } from "./bot-attachment.js";
 import { ensureDirs, instanceConfigs, loadConfig, providerReloadKeys, localVmIdleTimeoutMinutes, localVmMaxInstances, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, threadEventLogMaxBytes, maxConcurrentBotThreads, threadEventLogRetentionDays, saveConfig, showToolCallsEnabled, routinesInConversationEnabled, claudeUserMcpEnabled, skillAuthoringEnabled, autoRecallEnabled, captureQuietMs, tidyHour, sharedComputersEnabled, builtInBrowserEnabled, llmThreadTitlesEnabled, computerClaimIdleReleaseEnabled, cloudOverflowAllowlistedThreads, cloudOverflowEnabled, cloudOverflowIdleStopMs, cloudOverflowPerSecondCostUsd, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, stripWorkspaceCredentialEnv, PROVIDER_CREDENTIAL_ENV, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, browserEngineAttachCdpUrl, DATA_DIR, EVENTS_DIR, NATIVE_DIR, customMcpServers, roomHandoffLimits, onConfigSaved, CLAUDE_API_INSTANCE, } from "./config.js";
 import { sweepThreadEventLogs } from "./thread-retention.js";
@@ -145,6 +145,7 @@ import { checkSoulDrift, readSoulDrift, soulFile, writeSoulMirror } from "./bot-
 import { buildSystemPrompt, userProfileSystemPrompt, cloudHomePrompt, computerPrompt, composioSystemPrompt, customMcpPrompt, CREDENTIAL_PROMPT, mentionPrompt, THREADS_PROMPT, LEARN_PROMPT, PROFILE_PROMPT, ROUTINE_PROMPT, ROUTINE_EXECUTION_PROMPT, WEBHOOK_PROMPT, resolveComputerPromptKind, } from "./system-prompt.js";
 import { readCuaConnection, readCuaUnavailableReason, gatedLocalComputer } from "./local-computer.js";
 import { discoverExistingPerBotLocalVms, discoverExistingPoolLocalVms, localVmInventoryEntry, shouldArmLocalVmIdle, } from "./local-vm-inventory.js";
+import { localVmStopReason, recordLocalVmIdleStop } from "./local-vm-stop-reason.js";
 import { LocalVmIdleTimer } from "./local-vm-idle.js";
 import { LocalVmLeasePool } from "./local-vm-lease.js";
 import { LocalVmSeatPool } from "./local-vm-seat-pool.js";
@@ -3466,6 +3467,9 @@ function handleDesktopTrustedApprovalMessage(raw) {
             if (bot.approvalGrant.allThreads && mode === "full") {
                 store.setAllThreadApprovalMode(botId, mode);
             }
+            else if (bot.approvalGrant.refreshPermissions && bot.approvalGrant.threadId) {
+                store.refreshTaskPermissions(botId, bot.approvalGrant.threadId);
+            }
             else if (bot.approvalGrant.threadId) {
                 store.patchTask(botId, bot.approvalGrant.threadId, { approvalMode: mode, autoApprove: false });
             }
@@ -3671,6 +3675,39 @@ function handleDesktopTrustedApprovalMessage(raw) {
         respond({ ok: false, error: "Invalid thread approval scope" });
         return true;
     }
+    if (message.refreshPermissions !== undefined && message.refreshPermissions !== true) {
+        respond({ ok: false, error: "Invalid permission refresh" });
+        return true;
+    }
+    if (message.refreshPermissions === true) {
+        const target = typeof threadId === "string" ? store.projectBotForTask(botId, threadId) : null;
+        const savedMode = approvalModeFor({ ...existing, approvalGrant: undefined });
+        if (message.threadOnly !== true || !target || message.allThreads === true || message.modelSelection !== undefined || message.updateBotDefault !== undefined || savedMode !== mode) {
+            respond({ ok: false, error: "Choose this bot's approval level in bot settings before refreshing a thread" });
+            return true;
+        }
+        if (existing.approvalGrant || threadBusy(botId, target.threadId)) {
+            respond({ ok: false, error: "Stop this thread and finish its pending approval change first" });
+            return true;
+        }
+        if (!supportsApprovalMode(target.modelSelection, mode)) {
+            respond({ ok: false, error: "This thread's provider does not support that approval level" });
+            return true;
+        }
+        if (mode === "auto" && target.computer === "local" && approvalModeFor(target) !== "auto" && message.acknowledgeLocalAuto !== true) {
+            respond({ ok: false, error: "Auto mode on this computer requires confirming the warning" });
+            return true;
+        }
+        if (mode === "full" || mode === "custom") {
+            store.patchBot(botId, { approvalGrant: { requestId, mode, phase: "prepared", threadId: target.threadId, threadOnly: true, refreshPermissions: true } });
+        }
+        else if (!store.refreshTaskPermissions(botId, target.threadId)) {
+            respond({ ok: false, error: "That thread is no longer available" });
+            return true;
+        }
+        respond({ ok: true, bot: wireTrustedApprovalBot(store.bot(botId)) });
+        return true;
+    }
     if (message.threadOnly === true) {
         const target = typeof threadId === "string" ? store.projectBotForTask(botId, threadId) : null;
         if (!target || message.modelSelection !== undefined || message.updateBotDefault !== undefined) {
@@ -4864,6 +4901,18 @@ const desktopViewer = createDesktopViewer({
         });
     },
     live: auth => auth.kind === "loopback" || sessions.isLive(auth.session.id),
+    // A phone paired with this server directly drives a bot's Local VM through
+    // this proxy under its control lease (see the local-computer join route).
+    // The lease must hold the bot's computer, and that computer must be the
+    // desktop being viewed: a lease on one bot opens no other bot's VM.
+    lease: (id, botId, controlLeaseId, threadId) => {
+        const bot = store.bot(botId);
+        if (!bot || viewerTargetId(localVmTargetForStatus(bot.id, threadId)) !== id)
+            return;
+        const key = botComputerControlKey(bot);
+        const holds = () => computerControl.ownsLease(key, controlLeaseId);
+        return holds() ? holds : undefined;
+    },
 });
 function closeSessionStreams(sessionId) {
     browserLive.closeForOwner(sessionId);
@@ -5012,7 +5061,7 @@ const askMessageByRequest = new Map(); // threadId:requestId -> messageId
 const pendingCommandRules = new Map();
 function commandRememberRefusal(auth, threadId, requestId, behavior) {
     if (!canManageCommandAllowlist(auth))
-        return "Only the workspace owner or an admin can save bot-wide command permissions.";
+        return "Only the owner or an admin can save bot-wide command permissions.";
     if (behavior !== "allow" || !pendingCommandRules.has(`${threadId}:${requestId}`)) {
         return "This live request does not contain a command that can be saved. Allow it once instead.";
     }
@@ -5199,10 +5248,9 @@ const watchdog = new TurnWatchdog({
     onStall: (turn) => {
         const stalledResourceOwner = turnResourceOwners.get(turn.threadId);
         const stalledGeneration = directTurnGenerationByThread.get(turn.threadId);
+        const stalledProviderTurn = directRequestOwners.get(turn.threadId);
         cancelDirectTurnDispatch(turn.botId, turn.threadId);
-        // Room targets carry an invocation identity; only those claims belong
-        // to the room grace cleanup added here.
-        const stalledVmTarget = groupSpeakers.has(turn.threadId) ? localVmThreadTargets.get(turn.threadId) : undefined;
+        const stalledVmTarget = localVmThreadTargets.get(turn.threadId);
         revokeInternalCapabilitiesForThread(turn.threadId);
         repeats.settle(turn.threadId);
         const bot = botForThread(turn.botId, turn.threadId);
@@ -5240,6 +5288,9 @@ const watchdog = new TurnWatchdog({
                 return;
             if (stalledResourceOwner && turnResourceOwners.get(turn.threadId)?.generation !== stalledResourceOwner.generation)
                 return;
+            if (stalledGeneration && stalledProviderTurn?.generation === stalledGeneration && stalledProviderTurn.turnId) {
+                retireProviderTurn(stalledProviderTurn.turnId);
+            }
             // A goal coordinator can stall before sendTurn reveals its provider
             // turn id. Reusing the room during that ambiguous pre-id window would
             // make old and replacement events indistinguishable. Keep ownership
@@ -5254,7 +5305,8 @@ const watchdog = new TurnWatchdog({
             }
             const group = store.groupByThread(turn.threadId);
             const speaker = groupSpeakers.get(turn.threadId);
-            if (group && group.busyBotId === turn.botId && speaker?.botId === turn.botId) {
+            const stalledRoomSpeaker = group && group.busyBotId === turn.botId && speaker?.botId === turn.botId;
+            if (stalledRoomSpeaker) {
                 groupSpeakers.delete(turn.threadId);
                 store.patchGroup(group.id, { busyBotId: null, unread: true });
             }
@@ -5262,7 +5314,7 @@ const watchdog = new TurnWatchdog({
             // computer claim. The generation checks above protect replacements.
             releaseTurnResources(stalledResourceOwner);
             const currentBot = store.bot(turn.botId);
-            if (currentBot?.busy) {
+            if (currentBot?.busy && (threadBusy(currentBot.id, turn.threadId) || stalledRoomSpeaker)) {
                 stopScreenPoller(currentBot.id, turn.threadId);
                 vpsThreadEnded(currentBot.id, turn.threadId);
                 if (store.taskByThread(currentBot.id, turn.threadId))
@@ -6378,11 +6430,11 @@ function localVmIdleFor(target) {
         localVmLifecycleBusy.add(target.key);
         try {
             const status = await containerComputerStatus(undefined, undefined, target);
-            // The desktop leaves a stale X lock after stop, so idle cleanup
-            // removes only the disposable container. Its target-specific durable
-            // workspace and the shared prepared image remain.
-            if (status.container === "running") {
-                await containerComputerAction("remove", undefined, undefined, target);
+            // The pinned VNC startup clears stale X locks. Keep the container's
+            // home and installed software so inactivity is a reversible stop.
+            if (status.container === "running" && status.managed) {
+                const stopped = await containerComputerAction("stop", undefined, undefined, target);
+                recordLocalVmIdleStop(target.key, stopped.stopped_at);
             }
         }
         finally {
@@ -6424,7 +6476,7 @@ function releaseLocalVmThread(threadId) {
 // Browser, This computer, Auto, or Off does not delete its old Local VM.
 void (async () => {
     if (localVmMode(cfg) === "pool") {
-        // Same restore rule as per-bot: idle cleanup removes the container, not
+        // Same restore rule as per-bot: idle shutdown preserves the container and
         // its provisioned workspace, so every surviving seat stays Auto-eligible.
         const seats = localVmMaxInstances(cfg);
         for (let seat = 0; seat < seats; seat += 1) {
@@ -8759,7 +8811,7 @@ async function startTurn(botId, text, opts) {
              * desktop, not whatever localVmTargetForBot resolves to by the time
              * the first screen call arrives. */
             const claimAutoLocalVm = async (claimThreadId, pinnedTarget) => {
-                const localVmTarget = pinnedTarget ?? localVmTargetForThread(bot.id, claimThreadId);
+                const localVmTarget = pinnedTarget ?? localVmThreadTargets.get(claimThreadId) ?? { ...localVmTargetForThread(bot.id, claimThreadId) };
                 await bindTurnComputer(resourceOwner, `computer:vm:${localVmTarget.key}`, true);
                 if (localVmImageBusy || localVmModeChangeBusy || localVmLifecycleBusy.has(localVmTarget.key)) {
                     throw new Error("this Local VM is being started, stopped, or replaced — wait for setup to finish");
@@ -8783,6 +8835,8 @@ async function startTurn(botId, text, opts) {
                 // without this the exclusive lease would sit held for the rest of a
                 // turn that never got the VM — the very serialisation #1361 removes.
                 const dropLease = () => {
+                    if (localVmThreadTargets.get(claimThreadId) !== localVmTarget)
+                        return;
                     localVmLeaseFor(localVmTarget).release(claimThreadId);
                     if (localVmActiveThreads.get(localVmTarget.key) === claimThreadId)
                         localVmActiveThreads.delete(localVmTarget.key);
@@ -8876,7 +8930,7 @@ async function startTurn(botId, text, opts) {
                     if (!localVmSeen.has(poolCandidate.key) && !opts?.automationSource)
                         return false;
                 }
-                const localVmTarget = localVmTargetForThread(bot.id, threadId);
+                const localVmTarget = { ...localVmTargetForThread(bot.id, threadId) };
                 let lazyReadyVm = null;
                 if (!strict) {
                     // Nothing this process has ever seen for this target, and nobody is
@@ -8941,7 +8995,8 @@ async function startTurn(botId, text, opts) {
                 catch (error) {
                     if (strict)
                         throw error;
-                    releaseLocalVmThread(threadId);
+                    if (directTurnGenerationByThread.get(threadId) === dispatchClaimId)
+                        releaseLocalVmThread(threadId);
                     return false;
                 }
             };
@@ -10414,7 +10469,7 @@ async function resolveAndSendTeamSetup(res, args, ownerReview) {
     if (!card)
         return false;
     if (args.behavior === "allow" && !ownerReview) {
-        json(res, 403, { error: "Approve team setup or deletion from the desktop app or a paired owner device. In a local browser, wait until every bot is idle." });
+        json(res, 403, { error: "Approve team setup or deletion from the desktop app or a paired Full-access device. In a local browser, wait until every bot is idle." });
         return true;
     }
     if (args.behavior === "allow" && !card.answered && !card.dismissed && !card.expired) {
@@ -13183,34 +13238,15 @@ async function localVmPayload(target, auth) {
     const status = await containerComputerStatus(undefined, undefined, target);
     return {
         ...localVmViewerStatus(status, auth),
+        stop_reason: localVmStopReason(target.key, status),
         commands: setupCommands(status.runtime, process.platform, target),
         idle_timeout_ms: localVmIdleMs(),
         mode: localVmMode(cfg),
         max_instances: localVmMaxInstances(cfg),
     };
 }
-/** The Local VM a turn is about to use, recreated if the idle timer took it.
- *
- * `LocalVmIdleTimer` REMOVES an unused Local VM rather than pausing it. The
- * turn then failed with "Create the Local VM (App Settings → Local VM)" —
- * which reads like a fault the person must repair by hand, for a container the
- * app itself deleted eight hours earlier. Someone who steps away overnight
- * comes back to an error on their first message.
- *
- * The cloud branch below already does the opposite: an absent boat is
- * provisioned on first use behind a `provisioning` broadcast. This gives the
- * Local VM the same lifecycle for the same reason.
- *
- * Only `missing` is recovered, and only when a fresh `run` is all it takes.
- * Every other problem still surfaces: no runtime installed, no image pulled,
- * `create_supported` false, or an existing container that is stale, unmanaged
- * or unsafe. Those need a decision — install podman, download 1.4 GB, replace
- * a container someone else made — and a stopped container is deliberately not
- * resumed here, because `localVmProblem` says this desktop image cannot safely
- * resume and asks for a recreate rather than a start. Per-bot mode keeps its
- * instance cap; creating past it would quietly do what the lifecycle route
- * refuses.
- */
+/** Wake an idle desktop, or recreate a missing one from an already prepared
+ * image. Incompatible or unsafe containers still require an explicit decision. */
 async function readyLocalVmForTurn(botId, target, isCurrent = () => true) {
     localVmLifecycleBusy.add(target.key);
     // Fence this target, and the cross-target capacity decision for creates,
@@ -13230,21 +13266,22 @@ async function readyLocalVmForTurn(botId, target, isCurrent = () => true) {
         noteLocalVmSeen(target, status);
         if (!isCurrent())
             return status;
-        if (status.ready || !localVmRecreatableOnDemand(status))
+        const action = localVmWakeAction(status);
+        if (status.ready || !action || !status.runtime)
             return status;
         // Another creation is already mid-flight and its container is not yet
         // visible to a count, so the safe answer is the inspected status —
         // exactly what the over-cap path below returns.
-        if (!pooled && !ownsProvision)
+        if (action === "run" && !pooled && !ownsProvision)
             return status;
-        if (target.key.startsWith("bot:")) {
+        if (action === "run" && target.key.startsWith("bot:")) {
             const count = await existingPerBotLocalVmCount(status.runtime);
             if (!isCurrent() || count >= localVmMaxInstances(cfg))
                 return status;
         }
         broadcast({ kind: "computer", botId, state: "provisioning" });
         try {
-            status = await containerComputerAction("run", undefined, undefined, target);
+            status = await containerComputerAction(action, undefined, undefined, target);
         }
         catch {
             // Keep the inspected status: its `problem` names the real obstacle,
@@ -13312,6 +13349,7 @@ function configStatus() {
     return {
         xai: { configured: Boolean(cfg.xai?.key) },
         mistral: { configured: Boolean(cfg.mistral?.key) },
+        cerebras: { configured: Boolean(cfg.cerebras?.key) },
         anthropic: { configured: Boolean(cfg.anthropic?.key), everyClaudeBot: cfg.anthropic?.everyClaudeBot !== false },
         openai: { configured: Boolean(cfg.openai?.key) },
         openrouter: { configured: Boolean(cfg.openrouter?.key) },
@@ -19045,7 +19083,7 @@ const handleRequest = async (req, res) => {
         m = path.match(/^\/api\/bots\/([\w-]+)\/command-allowlist(?:\/([\w-]+))?$/);
         if (m && ["GET", "POST", "DELETE"].includes(method)) {
             if (!canManageCommandAllowlist(auth))
-                return json(res, 403, { error: "Only the workspace owner or an admin can manage command permissions." });
+                return json(res, 403, { error: "Only the owner or an admin can manage command permissions." });
             const bot = requestedTaskBot(m[1], url.searchParams.get("threadId") ?? undefined);
             if (method === "GET" && !m[2])
                 return json(res, 200, commandAllowlistResponse(bot));
@@ -19529,7 +19567,7 @@ const handleRequest = async (req, res) => {
             // come from local scripts only when all bots are idle; paired owners
             // and the packaged desktop's private capability can grant it mid-turn.
             if (loosened.includes("managedSections") && auth.kind === "loopback" && !DESKTOP_MANAGED && store.bots.some(bot => bot.busy)) {
-                return json(res, 409, { error: "Stop running bots before granting access to another team, or use the desktop app or a paired owner session." });
+                return json(res, 409, { error: "Stop running bots before granting access to another team, or use the desktop app or a paired Full-access session." });
             }
             if (body.peers !== undefined && Array.isArray(existingBot?.peers)) {
                 const nextPeers = patch.peers;
@@ -20867,7 +20905,7 @@ const handleRequest = async (req, res) => {
             const current = store.projectBotForTask(m[1], m[2]);
             if (!current)
                 return json(res, 404, { error: "no such task" });
-            const allowed = new Set(["title", "projectId", "modelSelection", "updateBotDefault", "resetApprovalToAsk", "approvalMode", "autoApprove", "requireAvailableModel", "pinnedMessageId", "acknowledgeLocalAuto", "archivedAt", "pinned", "snoozedUntil", "surface"]);
+            const allowed = new Set(["title", "projectId", "modelSelection", "updateBotDefault", "resetApprovalToAsk", "approvalMode", "autoApprove", "requireAvailableModel", "pinnedMessageId", "acknowledgeLocalAuto", "archivedAt", "pinned", "snoozedUntil", "surface", "refreshPermissions"]);
             if (Object.keys(body).some((key) => !allowed.has(key)))
                 return json(res, 400, { error: "unsupported thread setting" });
             const notYours = cloudThreadRefusal(auth, m[2]);
@@ -20877,7 +20915,7 @@ const handleRequest = async (req, res) => {
             // asking them, even in a conversation someone else started, and what
             // the bot itself defaults to.
             if (CLOUD_HOME && !cloudOwnerSession(auth) &&
-                (body.approvalMode !== undefined || body.autoApprove !== undefined || body.acknowledgeLocalAuto !== undefined || body.updateBotDefault === true)) {
+                (body.approvalMode !== undefined || body.autoApprove !== undefined || body.acknowledgeLocalAuto !== undefined || body.updateBotDefault === true || body.refreshPermissions === true)) {
                 return json(res, 403, { error: "On this Cloud only its owner can change how a bot asks for approval, or its default model." });
             }
             for (const key of ["requireAvailableModel", "acknowledgeLocalAuto", "updateBotDefault", "resetApprovalToAsk"]) {
@@ -20892,6 +20930,50 @@ const handleRequest = async (req, res) => {
                 (body.approvalMode !== undefined && body.approvalMode !== "ask") || body.autoApprove === true)) {
                 return json(res, 400, { error: "resetApprovalToAsk requires a model selection and cannot be combined with another approval mode" });
             }
+            if (body.refreshPermissions !== undefined && body.refreshPermissions !== true) {
+                return json(res, 400, { error: "refreshPermissions must be true" });
+            }
+            if (body.refreshPermissions === true) {
+                const extra = Object.keys(body).filter((key) => key !== "refreshPermissions" && key !== "acknowledgeLocalAuto");
+                if (extra.length)
+                    return json(res, 400, { error: "refreshPermissions cannot be combined with other thread settings" });
+                const profile = store.bot(m[1]);
+                if (!profile)
+                    return json(res, 404, { error: "no such bot" });
+                if (profile.approvalGrant)
+                    return json(res, 409, { error: "the bot's approval mode is still being confirmed" });
+                if (threadBusy(profile.id, m[2]))
+                    return json(res, 409, { error: "stop this thread before changing its approval mode" });
+                const nextMode = approvalModeFor({ ...profile, approvalGrant: undefined });
+                // Full and Custom never travel over the bot-reachable HTTP surface.
+                // The desktop's private channel copies those levels, and it is also
+                // the only way to leave Custom.
+                if (nextMode === "full" || nextMode === "custom") {
+                    return json(res, 403, { error: "Refresh Full or Custom access from the packaged desktop app" });
+                }
+                if (approvalModeFor(current) === "custom") {
+                    return json(res, 403, { error: "Leaving Custom approval requires the packaged desktop app" });
+                }
+                if (!supportsApprovalMode(current.modelSelection, nextMode)) {
+                    return json(res, 400, { error: "This provider does not support the selected approval level" });
+                }
+                if (nextMode === "auto" && current.computer === "local" && approvalModeFor(current) !== "auto" && body.acknowledgeLocalAuto !== true) {
+                    return json(res, 400, { error: "Auto mode on this computer requires confirming the warning first (acknowledgeLocalAuto)" });
+                }
+                const approvalRank = { ask: 0, edits: 1, auto: 2, full: 3, custom: 4 };
+                const widensMode = approvalRank[nextMode] > approvalRank[approvalModeFor(current)];
+                const nextAllow = profile.alwaysAllow ?? [];
+                const widensAllow = nextAllow.some((key) => !(current.alwaysAllow ?? []).includes(key));
+                if ((widensMode || widensAllow) && auth.kind === "loopback" && !DESKTOP_MANAGED && !req.headers.origin && store.bots.some((bot) => bot.busy)) {
+                    return json(res, 409, { error: "Change approval mode from the app or a paired device while bots are working." });
+                }
+                const task = store.refreshTaskPermissions(profile.id, m[2]);
+                if (!task)
+                    return json(res, 404, { error: "no such task" });
+                const fresh = botWithThread(store.bot(profile.id));
+                broadcast({ kind: "bot", bot: fresh });
+                return json(res, 200, { task: wireTask(task), bot: fresh });
+            }
             const patch = {};
             if (body.projectId !== undefined) {
                 if (body.projectId === null)
@@ -21311,8 +21393,10 @@ const handleRequest = async (req, res) => {
                 localVmLifecycleBusy.add(SHARED_LOCAL_VM_TARGET.key);
             try {
                 const status = await containerComputerAction(action, undefined, undefined, SHARED_LOCAL_VM_TARGET);
-                if (action === "run" || action === "start")
+                if (action === "run" || action === "start") {
+                    localVmSeen.add(SHARED_LOCAL_VM_TARGET.key);
                     localVmIdleFor(SHARED_LOCAL_VM_TARGET).touch();
+                }
                 if (action === "stop" || action === "remove")
                     localVmIdleFor(SHARED_LOCAL_VM_TARGET).cancel();
                 return json(res, 200, {
@@ -21344,7 +21428,7 @@ const handleRequest = async (req, res) => {
                 return json(res, 404, { error: "no such bot" });
             return json(res, 200, await localVmPayload(localVmTargetForStatus(bot.id, bot.threadId), auth));
         }
-        m = path.match(/^\/api\/bots\/([\w-]+)\/local-computer\/(run|stop|remove)$/);
+        m = path.match(/^\/api\/bots\/([\w-]+)\/local-computer\/(run|start|stop|remove)$/);
         if (m && method === "POST") {
             if (!String(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
                 return json(res, 415, { error: "content-type must be application/json" });
@@ -21355,7 +21439,7 @@ const handleRequest = async (req, res) => {
             if (boatLifecycleBusyBots.has(bot.id)) {
                 return json(res, 409, { error: "this bot's computer is being changed or deleted — wait for it to finish" });
             }
-            const action = z.enum(["run", "stop", "remove"]).parse(m[2]);
+            const action = z.enum(["run", "start", "stop", "remove"]).parse(m[2]);
             const target = localVmTargetForBot(bot.id);
             if (target.key === SHARED_LOCAL_VM_TARGET.key) {
                 return json(res, 409, { error: "Shared mode manages this desktop in App Settings → Computers" });
@@ -21394,8 +21478,10 @@ const handleRequest = async (req, res) => {
                     }
                 }
                 const status = await containerComputerAction(action, undefined, undefined, target);
-                if (action === "run")
+                if (action === "run" || action === "start") {
+                    localVmSeen.add(target.key);
                     localVmIdleFor(target).touch();
+                }
                 if (action === "stop" || action === "remove")
                     localVmIdleFor(target).cancel();
                 return json(res, 200, {
@@ -21427,6 +21513,61 @@ const handleRequest = async (req, res) => {
                 image: await containerComputerScreenshot(undefined, undefined, target),
             });
         }
+        // The Local VM's live desktop for a phone, granted only to the control
+        // lease that holds this bot's computer right now. Two callers:
+        //
+        // The companion sidecar (a loopback caller) gets the VM's own noVNC
+        // address, VNC password included, relays it to a paired phone the owner
+        // has allowed computer access, keeps re-checking the lease with
+        // `action: "check"`, and cuts the relay when it no longer holds.
+        //
+        // A phone paired with this server directly (`openmausbot serve`, no
+        // sidecar) never sees that address. It gets this server's own
+        // authenticated desktop proxy, bound to its lease: the proxy re-checks
+        // the lease and the session every few seconds and closes the socket when
+        // either lapses. Reaching here at all took the admin scope, which a
+        // chat-only pairing (`openmausbot pair --client`) does not have, so
+        // computer access is the same explicit choice the owner's browser makes.
+        m = path.match(/^\/api\/bots\/([\w-]+)\/local-computer\/join$/);
+        if (m && method === "POST") {
+            if (!String(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
+                return json(res, 415, { error: "content-type must be application/json" });
+            }
+            const bot = computerPreviewBot(m[1], url);
+            if (!bot)
+                return json(res, 404, { error: "no such bot" });
+            const threadId = url.searchParams.has("threadId") ? bot.threadId : undefined;
+            if (threadId && await computerPreviewSurface(bot, threadId) !== "vm") {
+                return json(res, 409, { error: "This conversation is not using the Local VM" });
+            }
+            // A bot's human-control hold does not reserve a shared desktop or pool
+            // seat. Another bot could drive it while the phone is holding this bot.
+            if (localVmMode(cfg) !== "per-bot") {
+                return json(res, 409, { error: "Phone control requires a per-bot Local VM. Select per-bot mode in Settings → Computers." });
+            }
+            const lease = controlLeaseIdSchema.safeParse(url.searchParams.get("controlLeaseId") ?? undefined);
+            if (!lease.success)
+                return json(res, 400, { error: "controlLeaseId is required" });
+            const controlBot = store.bot(bot.id);
+            if (!controlBot || !computerControl.ownsLease(botComputerControlKey(controlBot), lease.data)) {
+                return json(res, 409, { error: "Take control of this computer first" });
+            }
+            const target = localVmTargetForStatus(bot.id, threadId);
+            const status = await containerComputerStatus(undefined, undefined, target);
+            if (!status.ready || !status.managed || status.container !== "running" || status.network !== "loopback"
+                || !status.viewer_url) {
+                return json(res, 409, { error: status.problem ?? "The Local VM is not ready" });
+            }
+            localVmIdleFor(target).touch();
+            res.setHeader("cache-control", "private, no-store");
+            if (auth.kind === "loopback")
+                return json(res, 200, { joinUrl: status.viewer_url });
+            const socket = new URLSearchParams({ botId: bot.id, ...(threadId ? { threadId } : {}), controlLeaseId: lease.data });
+            return json(res, 200, {
+                socketPath: `api/desktop-viewer/${viewerTargetId(target)}/websockify?${socket}`,
+                password: new URLSearchParams(new URL(status.viewer_url).hash.slice(1)).get("password"),
+            });
+        }
         // identity handshake for the packaged app's port fallback: the forked
         // child proves it is OURS by echoing its pid (a stray dev server has
         // the same API shape but a different pid)
@@ -21566,7 +21707,7 @@ const handleRequest = async (req, res) => {
                 return json(res, 400, { error: `provider must be one of ${PROVIDER_KEY_KINDS.join(", ")}` });
             }
             const kind = provider;
-            const saved = { anthropic: cfg.anthropic, openai: cfg.openai, openrouter: cfg.openrouter, openaiCompat: cfg.openaiCompat, mistral: cfg.mistral, xai: cfg.xai }[kind];
+            const saved = { anthropic: cfg.anthropic, openai: cfg.openai, openrouter: cfg.openrouter, openaiCompat: cfg.openaiCompat, mistral: cfg.mistral, cerebras: cfg.cerebras, xai: cfg.xai }[kind];
             if (body?.key !== undefined && typeof body.key !== "string") {
                 return json(res, 400, { error: "key must be a string" });
             }
@@ -21907,8 +22048,8 @@ const handleRequest = async (req, res) => {
                     return json(res, 400, { error: "Account settings are currently available for Claude only." });
                 }
                 if (body.tools !== undefined) {
-                    if (!["openai-compat", "grok", "minimax", "mistral"].includes(entry.driver)) {
-                        return json(res, 400, { error: "The tools setting is available for OpenAI-compatible, Grok API, MiniMax API and Mistral API instances only." });
+                    if (!["openai-compat", "grok", "minimax", "mistral", "cerebras"].includes(entry.driver)) {
+                        return json(res, 400, { error: "The tools setting is available for OpenAI-compatible, Grok API, MiniMax API, Mistral API and Cerebras API instances only." });
                     }
                     entry.config = { ...entry.config, tools: body.tools };
                 }
@@ -22187,7 +22328,7 @@ const handleRequest = async (req, res) => {
         }
         if ((method === "PUT" || method === "PATCH") && path === "/api/config") {
             const body = await readBody(req);
-            if (hostedModels && ["instances", "anthropic", "openai", "openrouter", "openaiCompat", "xai", "mistral", "opencodeGo"].some(key => Object.hasOwn(body, key)))
+            if (hostedModels && ["instances", "anthropic", "openai", "openrouter", "openaiCompat", "xai", "mistral", "cerebras", "opencodeGo"].some(key => Object.hasOwn(body, key)))
                 return json(res, 403, { error: HOSTED_PROVIDER_SETTINGS_ERROR });
             const patch = parseConfigPatch(body);
             // A Cloud home is personal: nobody is invited to sign in to it.
@@ -23065,13 +23206,19 @@ const handleRequest = async (req, res) => {
                     const result = computerControl.releaseLease(controlKey, controlLeaseId);
                     return json(res, 200, { ...result.snapshot, released: result.released });
                 }
+                // Read-only: does this lease still hold the wheel? The companion
+                // sidecar asks this while it relays a phone's live Local VM desktop,
+                // and cuts the relay the moment the answer is no.
+                if (action === "check" && controlLeaseId) {
+                    return json(res, 200, { ...computerControl.snapshot(controlKey), owned: computerControl.ownsLease(controlKey, controlLeaseId) });
+                }
                 if (action === "take")
                     return json(res, 200, computerControl.take(controlKey));
                 if (action === "release")
                     return json(res, 200, computerControl.release(controlKey));
                 if (action === "dismiss-help")
                     return json(res, 200, computerControl.dismissHelp(controlKey));
-                return json(res, 400, { error: "action must be take, release, or dismiss-help" });
+                return json(res, 400, { error: "action must be take, release, check, or dismiss-help" });
             }
             return json(res, 405, { error: "method not allowed" });
         }
@@ -23083,7 +23230,13 @@ const handleRequest = async (req, res) => {
             if (!String(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
                 return json(res, 415, { error: "content-type must be application/json" });
             }
-            return json(res, 200, bot.cloudBackend === "vps" ? vps.closeVpsDesktopTunnel(bot.id) : { closed: false });
+            // A directly paired phone's Local VM desktop runs through this server's
+            // own proxy under its lease on this bot; hand-back closes it here, ahead
+            // of the lease re-check. The session's other viewers are left alone.
+            const closedViewers = auth.kind === "session" ? desktopViewer.closeForOwner(auth.session.id, bot.id) : 0;
+            if (bot.cloudBackend === "vps")
+                return json(res, 200, vps.closeVpsDesktopTunnel(bot.id));
+            return json(res, 200, { closed: closedViewers > 0 });
         }
         m = path.match(/^\/api\/bots\/([\w-]+)\/computer\/(provision|join|sleep|exec|screenshot|remove)$/);
         if (m && method === "POST") {

package/dist-server/server/local-vm-stop-reason.js

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "./atomic.js";
+import { DATA_DIR } from "./config.js";
+function recordPath(key, dataDir) {
+    return join(dataDir, "local-vm-stops", `${createHash("sha256").update(key).digest("hex")}.json`);
+}
+/** Record the runtime's actual finish timestamp. An external stop later gets
+ * a different timestamp and must not be misreported as OMB's idle shutdown. */
+export function recordLocalVmIdleStop(key, stoppedAt, dataDir = DATA_DIR) {
+    if (!stoppedAt)
+        return;
+    mkdirSync(join(dataDir, "local-vm-stops"), { recursive: true, mode: 0o700 });
+    writeFileAtomic(recordPath(key, dataDir), JSON.stringify({ stoppedAt }), { mode: 0o600 });
+}
+export function localVmStopReason(key, status, dataDir = DATA_DIR) {
+    if (status.container !== "stopped" || !status.stopped_at)
+        return null;
+    try {
+        return JSON.parse(readFileSync(recordPath(key, dataDir), "utf8")).stoppedAt === status.stopped_at ? "idle" : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist-server/server/provider-key-check.js

@@ -1,4 +1,4 @@
-export const PROVIDER_KEY_KINDS = ["anthropic", "openai", "openrouter", "openaiCompat", "xai", "mistral"];
+export const PROVIDER_KEY_KINDS = ["anthropic", "openai", "openrouter", "openaiCompat", "xai", "mistral", "cerebras"];
 const DEFAULT_URLS = {
     anthropic: "https://api.anthropic.com",
     openai: "https://api.openai.com/v1",
@@ -6,6 +6,7 @@ const DEFAULT_URLS = {
     openaiCompat: "https://openrouter.ai/api/v1",
     xai: "https://api.x.ai/v1",
     mistral: "https://api.mistral.ai/v1",
+    cerebras: "https://api.cerebras.ai/v1",
 };
 const MAX_MODELS = 5;
 function isLoopback(hostname) {