specrails-desktop 2.63.1 → 2.64.0

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;

package/server/dist/modules/browser/runtime/preview-targets.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPreviewTargetSource = createPreviewTargetSource;
+const transient_children_1 = require("../../../transient-children");
+const preview_origins_1 = require("../domain/preview-origins");
+/** Background-process statuses whose announced URLs are still served. */
+const LIVE_STATUSES = new Set(['starting', 'running']);
+/** Dev servers announce their URL in the first lines; a long-running process
+ *  can still re-announce after a restart, so scan the full retained tail. */
+const SCAN_LIMIT = 2000;
+const defaultReader = {
+    list: (projectId) => (0, transient_children_1.listBackgroundProcesses)({ projectId }),
+    logs: (process) => (0, transient_children_1.getBackgroundProcessLogs)(process.pid, { projectId: process.projectId, processId: process.processId, limit: SCAN_LIMIT }),
+};
+/**
+ * Derives preview targets from mission background-process logs on demand.
+ * Targets are derived state: nothing is persisted, an exited process simply
+ * stops contributing, and a process recovered after a restart (`interrupted`,
+ * OS state unknown) never does. A per-process memo keyed on the log tail keeps
+ * the per-request navigation guard cheap.
+ */
+function createPreviewTargetSource(reader = defaultReader) {
+    const memo = new Map();
+    const urlsFor = (process) => {
+        let snapshot = null;
+        try {
+            snapshot = reader.logs(process);
+        }
+        catch {
+            return [];
+        }
+        if (!snapshot)
+            return [];
+        const last = snapshot.lines[snapshot.lines.length - 1];
+        const key = `${snapshot.nextSequence}:${last?.sequence ?? 0}:${last?.line.length ?? 0}`;
+        const cached = memo.get(process.processId);
+        if (cached?.key === key)
+            return cached.urls;
+        const urls = (0, preview_origins_1.previewTargetsFromLines)(snapshot.lines.map((line) => line.line));
+        memo.set(process.processId, { projectId: process.projectId, key, urls });
+        return urls;
+    };
+    const live = (projectId) => {
+        let processes = [];
+        try {
+            processes = reader.list(projectId);
+        }
+        catch {
+            return [];
+        }
+        const running = processes.filter((process) => process.projectId === projectId && LIVE_STATUSES.has(process.status));
+        // Drop memo entries of processes that are no longer live so the cache is
+        // bounded by the running set of the projects being previewed.
+        const ids = new Set(running.map((process) => process.processId));
+        for (const [processId, entry] of memo) {
+            if (entry.projectId === projectId && !ids.has(processId))
+                memo.delete(processId);
+        }
+        return running;
+    };
+    const target = (process) => ({ processId: process.processId, chatId: process.chatId, urls: urlsFor(process) });
+    return {
+        list: (projectId) => live(projectId).map(target).filter((entry) => entry.urls.length > 0),
+        forProcess: (projectId, processId) => {
+            const process = live(projectId).find((candidate) => candidate.processId === processId);
+            return process ? target(process) : null;
+        },
+        announcedOrigins: (projectId) => {
+            const origins = new Set();
+            for (const process of live(projectId)) {
+                for (const url of urlsFor(process)) {
+                    const origin = (0, preview_origins_1.previewOrigin)(url);
+                    if (origin)
+                        origins.add(origin);
+                }
+            }
+            return origins;
+        },
+    };
+}

package/server/dist/modules/terminals/runtime/background-process-service.js

@@ -12,6 +12,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const loop_runs_store_1 = require("../../loops/runtime/loop-runs-store");
 const project_repositories_1 = require("../../../project-repositories");
 const transient_children_1 = require("../../../transient-children");
+const preview_origins_1 = require("../../browser/domain/preview-origins");
 /** The same scope and lifecycle policy applies to REST and the mission MCP. */
 function resolveBackgroundCwd(repositoryRoot, cwd) {
     if (cwd !== undefined && typeof cwd !== 'string')
@@ -25,7 +26,29 @@ function resolveBackgroundCwd(repositoryRoot, cwd) {
 function backgroundProcessHooks(broadcast) {
     const publish = (type) => (process) => broadcast({ type, process,
         projectId: process.projectId, timestamp: new Date().toISOString() });
-    return { onStarted: publish('background_process.started'), onUpdated: publish('background_process.updated'), onExited: publish('background_process.exited') };
+    // Companion app preview: announce once per newly seen local origin so phones
+    // refetch the derived targets instead of tailing every log line.
+    const announced = new Set();
+    const onOutput = (event) => {
+        let fresh = false;
+        for (const url of (0, preview_origins_1.extractPreviewUrls)(event.line)) {
+            const origin = (0, preview_origins_1.previewOrigin)(url);
+            if (origin && !announced.has(origin)) {
+                announced.add(origin);
+                fresh = true;
+            }
+        }
+        if (fresh)
+            broadcast({ type: 'background_process.preview_targets', processId: event.processId, chatId: event.chatId,
+                projectId: event.projectId, timestamp: new Date().toISOString() });
+    };
+    const exited = publish('background_process.exited');
+    return {
+        onStarted: publish('background_process.started'),
+        onUpdated: publish('background_process.updated'),
+        onOutput,
+        onExited: (process) => { announced.clear(); exited(process); },
+    };
 }
 function backgroundStartBusyReason(c) {
     const activeJobId = typeof c.queueManager?.getActiveJobId === 'function' ? c.queueManager.getActiveJobId() : null;

package/server/dist/project-registry.js

@@ -30,6 +30,7 @@ const ticket_watcher_1 = require("./modules/specs/runtime/ticket-watcher");
 const terminal_manager_1 = require("./modules/terminals/runtime/terminal-manager");
 const browser_capture_manager_1 = require("./modules/browser/runtime/browser-capture-manager");
 const browser_context_pool_1 = require("./modules/browser/runtime/browser-context-pool");
+const preview_targets_1 = require("./modules/browser/runtime/preview-targets");
 const explore_cwd_manager_1 = require("./modules/conversations/runtime/explore-cwd-manager");
 const hooks_1 = require("./hooks");
 const transient_children_1 = require("./transient-children");
@@ -119,6 +120,9 @@ class ProjectRegistry {
     // Chromium profile under ~/.specrails/browser-profile, so cookies/logins are
     // shared across every project. Launched lazily, disposed once at shutdown().
     _browserContextPool;
+    // Companion app preview: URLs announced by running mission processes,
+    // derived on demand from their logs (shared by every project's browser).
+    _previewTargets = (0, preview_targets_1.createPreviewTargetSource)();
     constructor(broadcast, desktopDbPath, desktopPort) {
         this._broadcast = broadcast;
         this._desktopDb = (0, desktop_db_1.initDesktopDb)(desktopDbPath ?? (0, desktop_db_1.getDesktopDbPath)());
@@ -128,6 +132,9 @@ class ProjectRegistry {
         this._failedProjects = new Map();
         this._browserContextPool = new browser_context_pool_1.SharedBrowserContextPool();
     }
+    get previewTargets() {
+        return this._previewTargets;
+    }
     get desktopDb() {
         return this._desktopDb;
     }
@@ -1136,6 +1143,9 @@ class ProjectRegistry {
             // Share ONE persistent Chromium profile (global cookies/logins) across all
             // projects instead of a per-project profile.
             contextPool: this._browserContextPool,
+            // Only device-owned (Companion preview) sessions may load these loopback
+            // origins; Desktop sessions keep the regular SSRF guard.
+            previewOrigins: () => this._previewTargets.announcedOrigins(project.id),
         });
         // ── Loops engine (the Loops feature) ──────────────────────────────────────
         const railLoopRuns = new Map();