specrails-desktop 2.63.2 → 2.64.1

package/server/dist/mobile/mobile-router.js

@@ -9,6 +9,7 @@ const mobile_auth_1 = require("./mobile-auth");
 const mobile_devices_1 = require("./mobile-devices");
 const mobile_missions_1 = require("./mobile-missions");
 const mobile_code_1 = require("./mobile-code");
+const mobile_preview_1 = require("./mobile-preview");
 // The gateway's authenticated REST surface: the `/v1/*` allow-list. Each route
 // forwards, in-process, via a REAL loopback HTTP request to
 // http://127.0.0.1:<desktopPort> with the master token injected server-side as
@@ -455,7 +456,9 @@ function createMobileRouter(deps) {
             ...(body !== undefined ? { body: JSON.stringify(body) } : {}) });
         return { status: response.status, json: await response.json() };
     };
-    v1.use((0, mobile_missions_1.createMobileMissionsRouter)({ db: deps.db, upstream: mobileUpstream }));
+    v1.use((0, mobile_missions_1.createMobileMissionsRouter)({ db: deps.db, upstream: mobileUpstream, appPreview: () => deps.preview?.available() ?? false }));
+    if (deps.preview)
+        v1.use((0, mobile_preview_1.createMobilePreviewRouter)({ db: deps.db, preview: deps.preview }));
     v1.use((0, mobile_code_1.createMobileCodeRouter)(mobileUpstream));
     router.use('/v1', v1);
     // Any unmatched gateway path → 404 JSON (NEVER falls through to a SPA handler;
@@ -472,6 +475,11 @@ exports.MOBILE_ALLOWLIST = [
     { method: 'GET', path: '/v1/projects/:pid/repositories/:rid/code/find' },
     { method: 'GET', path: '/v1/projects/:pid/repositories/:rid/code/file' },
     { method: 'GET', path: '/v1/capabilities' },
+    { method: 'GET', path: '/v1/projects/:pid/missions/:cid/preview-targets' },
+    { method: 'POST', path: '/v1/projects/:pid/preview-sessions' },
+    { method: 'POST', path: '/v1/projects/:pid/preview-sessions/:sid/attach' },
+    { method: 'POST', path: '/v1/projects/:pid/preview-sessions/:sid/navigate' },
+    { method: 'DELETE', path: '/v1/projects/:pid/preview-sessions/:sid' },
     { method: 'GET', path: '/v1/mission-models' },
     { method: 'PATCH', path: '/v1/projects/:pid/missions/:cid/messages/:mid/intent' },
     { method: 'GET', path: '/v1/projects/:pid/repositories' },

package/server/dist/mobile/mobile-webrtc-peer.js

@@ -14,6 +14,9 @@ class MobileWebrtcGateway {
     // answer to whatever happened to be pending. Per-room keying isolates them.
     _pending = new Map();
     _active = new Set();
+    /** The live peer of each authenticated device (latest wins), so Desktop can
+     *  open extra DataChannels (app preview) on the connection it already has. */
+    _byDevice = new Map();
     constructor(_deps) {
         this._deps = _deps;
     }
@@ -48,17 +51,23 @@ class MobileWebrtcGateway {
         //    require a valid existing device token instead, and never mint.
         new mobile_datachannel_1.DataChannelPeer(toChannelLike(dc), {
             registerDevice: async (input) => {
+                let result;
                 if (isReconnect) {
-                    return this._deps.registerDevice({
+                    result = await this._deps.registerDevice({
                         deviceName: input.deviceName,
                         platform: input.platform,
                         token: input.token,
                         requireExistingToken: true,
                     });
                 }
-                return input.secret && (0, auth_1.safeEqual)(input.secret, secret)
-                    ? this._deps.registerDevice({ deviceName: input.deviceName, platform: input.platform, token: input.token })
-                    : { ok: false };
+                else {
+                    result = input.secret && (0, auth_1.safeEqual)(input.secret, secret)
+                        ? await this._deps.registerDevice({ deviceName: input.deviceName, platform: input.platform, token: input.token })
+                        : { ok: false };
+                }
+                if (result.ok)
+                    this._byDevice.set(result.deviceId, pc);
+                return result;
             },
             rpcDispatch: this._deps.rpcDispatch,
             bridge: this._deps.bridge,
@@ -67,6 +76,9 @@ class MobileWebrtcGateway {
             console.log('[webrtc] pc connectionState:', s);
             if (s === 'failed' || s === 'closed' || s === 'disconnected') {
                 this._active.delete(pc);
+                for (const [deviceId, owned] of this._byDevice)
+                    if (owned === pc)
+                        this._byDevice.delete(deviceId);
                 // Drop this pc from whichever room slot still holds it.
                 if (this._pending.get(key)?.pc === pc)
                     this._pending.delete(key);
@@ -101,6 +113,24 @@ class MobileWebrtcGateway {
             return { ok: false };
         }
     }
+    /** Open an ordered, reliable DataChannel on the device's live peer (no SDP
+     *  renegotiation: the SCTP association already exists). Null when the
+     *  device has no connected WebRTC peer. */
+    openChannel(deviceId, label) {
+        const pc = this._byDevice.get(deviceId);
+        if (!pc || pc.connectionState !== 'connected')
+            return null;
+        try {
+            return toPreviewChannel(pc.createDataChannel(label, { ordered: true }));
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Forget a device's peer (revoked). Its channels close with the peer. */
+    forgetDevice(deviceId) {
+        this._byDevice.delete(deviceId);
+    }
     /** Tear down every peer (gateway stopping / disabled). */
     stop() {
         for (const key of [...this._pending.keys()])
@@ -108,6 +138,7 @@ class MobileWebrtcGateway {
         for (const pc of this._active)
             this._close(pc);
         this._active.clear();
+        this._byDevice.clear();
     }
     _close(pc) {
         try {
@@ -137,6 +168,25 @@ function toChannelLike(dc) {
         },
     };
 }
+function toPreviewChannel(dc) {
+    return {
+        get label() { return dc.label; },
+        get readyState() { return dc.readyState; },
+        get bufferedAmount() { return dc.bufferedAmount; },
+        send: (data) => dc.send(data),
+        close: () => dc.close(),
+        onOpen: (cb) => {
+            if (dc.readyState === 'open')
+                queueMicrotask(cb);
+            else
+                dc.stateChanged.subscribe((s) => { if (s === 'open')
+                    cb(); });
+        },
+        onMessage: (cb) => { dc.onMessage.subscribe((d) => cb(d)); },
+        onClose: (cb) => { dc.stateChanged.subscribe((s) => { if (s === 'closed')
+            cb(); }); },
+    };
+}
 /** Vanilla ICE: resolve once gathering completes so the offer SDP carries all
  *  candidates (there's no trickle channel — the SDP travels by QR). */
 function waitIceComplete(pc) {

package/server/dist/mobile/mobile-ws.js

@@ -33,7 +33,8 @@ function topicFor(type) {
         case 'agent_pr_decision':
         case 'background_process.started':
         case 'background_process.updated':
-        case 'background_process.exited': return 'missions';
+        case 'background_process.exited':
+        case 'background_process.preview_targets': return 'missions';
         case 'queue': return 'queue';
         case 'phase': return 'phase';
         case 'ticket_created':
@@ -253,7 +254,8 @@ class MobileWsBridge {
                     continue;
                 const value = msg;
                 const process = value.process;
-                const cid = typeof value.conversationId === 'string' ? value.conversationId : process?.chatId;
+                const cid = typeof value.conversationId === 'string' ? value.conversationId
+                    : typeof value.chatId === 'string' ? value.chatId : process?.chatId;
                 const projectId = cid ? this._missionProjectFor(cid) : null;
                 if (!projectId || !s.projects.has(projectId))
                     continue;

package/server/dist/modules/browser/domain/preview-origins.js

@@ -0,0 +1,117 @@
+"use strict";
+// Pure rules for the Companion app preview: which local URLs a background
+// process announces, how loopback origins are normalised, and which
+// navigations a device-owned preview session may perform. No I/O here — the
+// runtime feeds log lines and the announced-origin set in.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoopbackHost = isLoopbackHost;
+exports.previewOrigin = previewOrigin;
+exports.extractPreviewUrls = extractPreviewUrls;
+exports.previewTargetsFromLines = previewTargetsFromLines;
+exports.isPreviewRequestAllowed = isPreviewRequestAllowed;
+exports.isManualPreviewUrlAllowed = isManualPreviewUrlAllowed;
+const ANSI = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b[@-Z\\-_]/g;
+// Host alternatives a dev server prints for "this machine". Bracketed IPv6
+// forms are matched literally; the wildcard binds are rewritten to localhost.
+const LOCAL_URL = /\bhttps?:\/\/(?:localhost|127(?:\.\d{1,3}){3}|0\.0\.0\.0|\[::1?\])(?::\d{1,5})?(?:\/[^\s'"<>)\]`]*)?/gi;
+const TRAILING_PUNCTUATION = /[.,;:!?]+$/;
+/** A loopback host as dev servers print it (wildcard binds included). */
+function isLoopbackHost(hostname) {
+    const host = hostname.toLowerCase().replace(/^\[/, '').replace(/\]$/, '');
+    return host === 'localhost' || host.endsWith('.localhost') || host === '::1' || host === '::' ||
+        host === '0.0.0.0' || /^127(?:\.\d{1,3}){3}$/.test(host);
+}
+/**
+ * The comparable origin of `raw`, with every loopback spelling collapsed to
+ * `localhost` (so `http://127.0.0.1:5173` and `http://[::1]:5173` match an
+ * announced `http://localhost:5173`). Null for unparsable or non-http(s) URLs.
+ */
+function previewOrigin(raw) {
+    let url;
+    try {
+        url = new URL(raw.trim());
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        return null;
+    const host = isLoopbackHost(url.hostname) ? 'localhost' : url.hostname.toLowerCase();
+    const port = url.port || (url.protocol === 'https:' ? '443' : '80');
+    return `${url.protocol}//${host}:${port}`;
+}
+/** Normalise an announced URL: loopback host → `localhost`, explicit path kept. */
+function normalizeAnnouncedUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw.replace(TRAILING_PUNCTUATION, ''));
+    }
+    catch {
+        return null;
+    }
+    if (!isLoopbackHost(url.hostname))
+        return null;
+    const port = url.port ? Number(url.port) : NaN;
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        return null;
+    url.hostname = 'localhost';
+    url.hash = '';
+    return url.toString();
+}
+/**
+ * Local URLs a log line announces (`➜  Local:   http://localhost:5173/`,
+ * `ready on http://0.0.0.0:3000`), normalised and de-duplicated by origin in
+ * order of appearance. URLs without an explicit port are ignored: a dev server
+ * always prints one, while bare `http://localhost` mentions are usually docs.
+ */
+function extractPreviewUrls(line) {
+    const text = line.replace(ANSI, '');
+    const found = [];
+    const origins = new Set();
+    for (const match of text.matchAll(LOCAL_URL)) {
+        const url = normalizeAnnouncedUrl(match[0]);
+        const origin = url && previewOrigin(url);
+        if (!url || !origin || origins.has(origin))
+            continue;
+        origins.add(origin);
+        found.push(url);
+    }
+    return found;
+}
+/**
+ * Latest-first, origin-unique targets from a process's log lines (oldest first).
+ * A re-announced origin moves to the front with its newest URL.
+ */
+function previewTargetsFromLines(lines) {
+    const byOrigin = new Map();
+    for (const line of lines) {
+        for (const url of extractPreviewUrls(line)) {
+            const origin = previewOrigin(url);
+            byOrigin.delete(origin);
+            byOrigin.set(origin, url);
+        }
+    }
+    return [...byOrigin.values()].reverse();
+}
+/**
+ * Whether a device-owned preview session may load `url` (a navigation or a
+ * subresource request). Announced origins of the project are allowed even
+ * though they are loopback; everything else must pass the regular server-side
+ * guard (`fallback`, i.e. `isNavigableUrl`), which rejects loopback/private
+ * hosts and non-http(s) schemes.
+ */
+function isPreviewRequestAllowed(url, announcedOrigins, fallback) {
+    const origin = previewOrigin(url);
+    if (origin && announcedOrigins.has(origin))
+        return true;
+    return fallback(url);
+}
+/**
+ * Whether a device may *type* `url` (create or manual navigate). Stricter than
+ * the request guard: only paths on announced origins, never an arbitrary
+ * public URL — Desktop must not become a general browser proxy for the phone.
+ */
+function isManualPreviewUrlAllowed(url, announcedOrigins) {
+    const origin = previewOrigin(url);
+    return origin !== null && announcedOrigins.has(origin);
+}

package/server/dist/modules/browser/runtime/browser-capture-manager.js

@@ -10,6 +10,7 @@ const ids_1 = require("../../../ids");
 const attachment_manager_1 = require("../../../attachment-manager");
 const browser_capture_types_1 = require("./browser-capture-types");
 const browser_playwright_1 = require("./browser-playwright");
+const preview_origins_1 = require("../domain/preview-origins");
 const browser_viewport_1 = require("./browser-viewport");
 const WS_OPEN = 1;
 const DEFAULT_VIEWPORT = { width: 1280, height: 800 };
@@ -20,6 +21,14 @@ function isTargetClosedError(err) {
     return /target page, context or browser has been closed|target closed|has been closed/i.test(msg);
 }
 const MAX_SESSIONS_PER_PROJECT = 4;
+/** Companion app-preview sessions have their own budget so a phone can never
+ *  take Desktop's sessions: one per device (a new one replaces it), two per
+ *  project across devices. */
+const MAX_DEVICE_SESSIONS_PER_PROJECT = 2;
+/** The announced-origin set is consulted on every request of a preview page
+ *  (a dev server loads hundreds of modules); re-derive it at most this often. */
+const PREVIEW_ORIGINS_TTL_MS = 1000;
+const DESKTOP_OWNER = { kind: 'desktop' };
 const DEFAULT_SESSION_IDLE_TTL_MS = 10 * 60_000;
 const DEFAULT_SESSION_SWEEP_INTERVAL_MS = 60_000;
 const DOM_HTML_BYTE_CAP = 100_000;
@@ -56,13 +65,15 @@ class BrowserCaptureManager {
     contextPool;
     now;
     sessionIdleTtlMs;
+    previewOrigins;
+    previewOriginsCache = null;
     idleSweepTimer = null;
     context = null;
     contextPromise = null;
     sessions = new Map();
     /** Count of in-flight `create()` calls that have reserved a slot but not yet
      *  committed their session — guards the cap against concurrent creates. */
-    _reserved = 0;
+    _reserved = { desktop: 0, device: 0 };
     disposed = false;
     constructor(opts) {
         this.projectId = opts.projectId;
@@ -72,6 +83,7 @@ class BrowserCaptureManager {
         this.attachments = opts.attachments ?? attachment_manager_1.attachmentManager;
         this.contextPool = opts.contextPool ?? null;
         this.now = opts.now ?? Date.now;
+        this.previewOrigins = opts.previewOrigins ?? (() => new Set());
         const requestedIdleTtlMs = opts.sessionIdleTtlMs;
         this.sessionIdleTtlMs = typeof requestedIdleTtlMs === 'number' && Number.isFinite(requestedIdleTtlMs) && requestedIdleTtlMs > 0
             ? requestedIdleTtlMs
@@ -144,6 +156,7 @@ class BrowserCaptureManager {
             viewportWidth: s.viewport.width,
             viewportHeight: s.viewport.height,
             createdAt: s.createdAt,
+            owner: s.owner,
         };
     }
     listSessions() {
@@ -167,27 +180,46 @@ class BrowserCaptureManager {
         s.activeOperations = Math.max(0, s.activeOperations - 1);
         s.lastActivityAt = this.now();
     }
+    liveCount(kind) {
+        return [...this.sessions.values()].filter((s) => !s.closed && s.owner.kind === kind).length;
+    }
     async create(opts) {
+        const owner = opts?.owner ?? DESKTOP_OWNER;
+        const kind = owner.kind;
+        const limit = kind === 'device' ? MAX_DEVICE_SESSIONS_PER_PROJECT : MAX_SESSIONS_PER_PROJECT;
+        if (owner.kind === 'device') {
+            // A phone may only type announced origins (never an arbitrary URL), and
+            // is validated BEFORE replacing its previous session so a bad request
+            // leaves the current preview alone.
+            const initialUrl = opts?.initialUrl?.trim() ?? '';
+            if (!initialUrl || !(0, preview_origins_1.isManualPreviewUrlAllowed)(initialUrl, this.currentPreviewOrigins(true))) {
+                throw new browser_capture_types_1.BrowserNavigationRejectedError();
+            }
+            for (const existing of [...this.sessions.values()]) {
+                if (!existing.closed && existing.owner.kind === 'device' && existing.owner.deviceId === owner.deviceId) {
+                    await this.kill(existing.id);
+                }
+            }
+        }
         // Reserve the slot SYNCHRONOUSLY before any await so N concurrent creates can't
         // all observe `< MAX` and race past the cap (BUG-BROWSER-02). `_reserved`
-        // counts in-flight (not-yet-inserted) sessions; it's the only state that
-        // mutates synchronously here.
-        const live = [...this.sessions.values()].filter((s) => !s.closed).length;
-        if (live + this._reserved >= MAX_SESSIONS_PER_PROJECT) {
-            throw new browser_capture_types_1.BrowserLimitExceededError(MAX_SESSIONS_PER_PROJECT);
+        // counts in-flight (not-yet-inserted) sessions per budget; it's the only
+        // state that mutates synchronously here.
+        if (this.liveCount(kind) + this._reserved[kind] >= limit) {
+            throw new browser_capture_types_1.BrowserLimitExceededError(limit);
         }
-        this._reserved++;
+        this._reserved[kind]++;
         let page;
         try {
             const ctx = await this.ensureContext();
             page = await ctx.newPage();
         }
         catch (err) {
-            this._reserved--;
+            this._reserved[kind]--;
             throw err;
         }
         if (this.disposed) {
-            this._reserved--;
+            this._reserved[kind]--;
             try {
                 await page.close();
             }
@@ -197,20 +229,37 @@ class BrowserCaptureManager {
         // Re-check AFTER the awaits: another create that started before us may have
         // committed its session in the meantime. If the cap is now exceeded, tear the
         // extra page down and reject rather than silently exceeding the limit.
-        const liveNow = [...this.sessions.values()].filter((s) => !s.closed).length;
-        if (liveNow >= MAX_SESSIONS_PER_PROJECT) {
-            this._reserved--;
+        if (this.liveCount(kind) >= limit) {
+            this._reserved[kind]--;
             try {
                 await page.close();
             }
             catch { /* ignore */ }
-            throw new browser_capture_types_1.BrowserLimitExceededError(MAX_SESSIONS_PER_PROJECT);
+            throw new browser_capture_types_1.BrowserLimitExceededError(limit);
+        }
+        if (kind === 'device') {
+            // Fail closed: a preview page without request interception could reach
+            // any loopback port of this machine.
+            try {
+                if (!page.setRequestGuard)
+                    throw new Error('request guard unsupported');
+                await page.setRequestGuard((url) => this.allowDeviceRequest(url));
+            }
+            catch (err) {
+                this._reserved[kind]--;
+                try {
+                    await page.close();
+                }
+                catch { /* ignore */ }
+                throw new browser_capture_types_1.BrowserLaunchError('failed to secure preview page', err);
+            }
         }
         const id = (0, ids_1.newId)();
         const activityAt = this.now();
         const session = {
             id,
             projectId: this.projectId,
+            owner,
             page,
             popups: [],
             popupView: false,
@@ -229,7 +278,7 @@ class BrowserCaptureManager {
         };
         this.sessions.set(id, session);
         // The reservation is now realised as a committed session — release it.
-        this._reserved--;
+        this._reserved[kind]--;
         // Adopt popups the page opens (OAuth login windows etc.) as secondary pages
         // of this session, and keep the client's URL bar live on in-page navigation
         // (link clicks / redirects the REST navigate path never sees).
@@ -239,7 +288,7 @@ class BrowserCaptureManager {
                 return;
             session.url = url;
             if (url && url !== 'about:blank')
-                this.setLastUrl(url);
+                this.rememberUrl(session, url);
             this.broadcastControl(session, { type: 'nav', url, title: session.title });
         });
         // Start capturing the page's network requests before the first navigation so
@@ -256,7 +305,13 @@ class BrowserCaptureManager {
         // away, so the user watches the page paint progressively instead of staring
         // at "opening…". The URL is set optimistically to the target; the resolved
         // URL/title land via the `nav` control broadcast every client already handles.
-        const target = opts?.initialUrl?.trim() || this.getLastUrl() || 'about:blank';
+        if (opts?.viewport) {
+            try {
+                await this.handleInput(id, { type: 'resize', ...opts.viewport });
+            }
+            catch { /* the default viewport still renders */ }
+        }
+        const target = opts?.initialUrl?.trim() || (kind === 'desktop' ? this.getLastUrl() : null) || 'about:blank';
         session.url = target;
         void this.runInitialNavigation(session, target);
         return this.toMeta(session);
@@ -276,9 +331,34 @@ class BrowserCaptureManager {
         s.url = result.url;
         s.title = result.title;
         if (result.url && result.url !== 'about:blank')
-            this.setLastUrl(result.url);
+            this.rememberUrl(s, result.url);
         this.broadcastControl(s, { type: 'nav', url: result.url, title: result.title });
     }
+    /** Desktop's "last URL" is a Desktop convenience; a phone's preview of a
+     *  loopback origin must never become the next Desktop session's start page. */
+    rememberUrl(s, url) {
+        if (s.owner.kind === 'desktop')
+            this.setLastUrl(url);
+    }
+    currentPreviewOrigins(fresh = false) {
+        const at = this.now();
+        if (!fresh && this.previewOriginsCache && at - this.previewOriginsCache.at < PREVIEW_ORIGINS_TTL_MS) {
+            return this.previewOriginsCache.origins;
+        }
+        let origins;
+        try {
+            origins = this.previewOrigins();
+        }
+        catch {
+            origins = new Set();
+        }
+        this.previewOriginsCache = { at, origins };
+        return origins;
+    }
+    /** The request guard of device-owned pages (documents + subresources). */
+    allowDeviceRequest(url) {
+        return (0, preview_origins_1.isPreviewRequestAllowed)(url, this.currentPreviewOrigins(), browser_playwright_1.isNavigableUrl);
+    }
     // ─── Popup support (OAuth login windows etc.) ───────────────────────────────
     topPopup(s) {
         return s.popups.length > 0 ? s.popups[s.popups.length - 1] : null;
@@ -299,6 +379,22 @@ class BrowserCaptureManager {
             void popup.close().catch(() => { });
             return;
         }
+        if (s.owner.kind === 'device') {
+            // A popup is a new page: install the same guard, and close one that was
+            // opened straight onto a forbidden URL before the guard could see it.
+            const opened = popup.currentUrl();
+            if (opened && opened !== 'about:blank' && !this.allowDeviceRequest(opened)) {
+                void popup.close().catch(() => { });
+                return;
+            }
+            if (!popup.setRequestGuard) {
+                void popup.close().catch(() => { });
+                return;
+            }
+            void popup.setRequestGuard((url) => this.allowDeviceRequest(url)).catch(() => {
+                void popup.close().catch(() => { });
+            });
+        }
         s.popups.push(popup);
         s.popupView = true;
         // Popups inherit the session viewport so coordinate mapping + screencast
@@ -553,7 +649,7 @@ class BrowserCaptureManager {
                 s.url = result.url;
                 s.title = result.title;
                 if (result.url && result.url !== 'about:blank')
-                    this.setLastUrl(result.url);
+                    this.rememberUrl(s, result.url);
                 this.broadcastControl(s, { type: 'nav', url: result.url, title: result.title });
             }
             return result;
@@ -875,6 +971,33 @@ class BrowserCaptureManager {
         this.context = null;
         this.contextPromise = null;
     }
+    /** Owner of a live session, or null when it does not exist. */
+    sessionOwner(sessionId) {
+        return this.getSession(sessionId)?.owner ?? null;
+    }
+    /**
+     * Manual navigation from a device: the session must belong to that device,
+     * and `goto` only accepts paths on announced origins (the page itself may
+     * still follow public links/redirects through the request guard).
+     */
+    async navigateAsDevice(sessionId, deviceId, action, url) {
+        const owner = this.sessionOwner(sessionId);
+        if (!owner || owner.kind !== 'device' || owner.deviceId !== deviceId)
+            return null;
+        if (action === 'goto' && !(url && (0, preview_origins_1.isManualPreviewUrlAllowed)(url, this.currentPreviewOrigins(true)))) {
+            throw new browser_capture_types_1.BrowserNavigationRejectedError();
+        }
+        return this.navigate(sessionId, action, url);
+    }
+    /** Kill every session a device owns (device revoked / unpaired). */
+    async killDeviceSessions(deviceId) {
+        let killed = 0;
+        for (const s of [...this.sessions.values()]) {
+            if (s.owner.kind === 'device' && s.owner.deviceId === deviceId && await this.kill(s.id))
+                killed += 1;
+        }
+        return killed;
+    }
     sessionCount() {
         return [...this.sessions.values()].filter((s) => !s.closed).length;
     }

package/server/dist/modules/browser/runtime/browser-capture-types.js

@@ -6,7 +6,7 @@
 // no real Chromium. The real Playwright/CDP implementation lives in
 // `browser-playwright.ts` and is the ONLY module that imports `playwright`.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrowserLaunchError = exports.BrowserLimitExceededError = void 0;
+exports.BrowserLaunchError = exports.BrowserNavigationRejectedError = exports.BrowserLimitExceededError = void 0;
 // ─── Error classes (mirror terminal-manager's typed errors) ───────────────────
 class BrowserLimitExceededError extends Error {
     limit;
@@ -17,6 +17,15 @@ class BrowserLimitExceededError extends Error {
     }
 }
 exports.BrowserLimitExceededError = BrowserLimitExceededError;
+/** A device-owned preview session was asked to load a URL its origin policy
+ *  rejects (an unannounced loopback port, or any manual non-announced URL). */
+class BrowserNavigationRejectedError extends Error {
+    constructor() {
+        super('browser_navigation_rejected');
+        this.name = 'BrowserNavigationRejectedError';
+    }
+}
+exports.BrowserNavigationRejectedError = BrowserNavigationRejectedError;
 class BrowserLaunchError extends Error {
     cause;
     constructor(message, cause) {

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

@@ -447,6 +447,25 @@ class PlaywrightPageHandle {
             return null;
         }
     }
+    async setRequestGuard(allow) {
+        // Page-scoped (not context-scoped): the shared global context also serves
+        // Desktop sessions, which must keep their own unchanged guard and must not
+        // pay for request interception.
+        await this.page.route('**/*', async (route) => {
+            let url = '';
+            try {
+                url = route.request().url();
+            }
+            catch { /* treat as rejected */ }
+            try {
+                if (url && allow(url))
+                    await route.fallback();
+                else
+                    await route.abort('blockedbyclient');
+            }
+            catch { /* the page or request went away */ }
+        });
+    }
     async enableNetwork() {
         if (this.netEnabled)
             return;