specrails-desktop 2.64.2 → 2.65.1

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

@@ -1,366 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MobilePreviewService = exports.PreviewError = void 0;
-exports.createMobilePreviewRouter = createMobilePreviewRouter;
-const express_1 = require("express");
-const browser_capture_types_1 = require("../modules/browser/runtime/browser-capture-types");
-const preview_origins_1 = require("../modules/browser/domain/preview-origins");
-const agent_store_1 = require("../modules/agents/runtime/agent-store");
-const mobile_missions_1 = require("./mobile-missions");
-const mobile_preview_channel_1 = require("./mobile-preview-channel");
-class PreviewError extends Error {
-    status;
-    code;
-    constructor(status, code, message) {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.name = 'PreviewError';
-    }
-}
-exports.PreviewError = PreviewError;
-/**
- * Companion app-preview use cases. Owns only the channel bindings; sessions,
- * budgets and the origin policy live in BrowserCaptureManager, targets in the
- * process-log source. A binding is replaced on re-attach (new peer after a
- * Wi-Fi drop) and detached — never killed — when its channel closes, so the
- * idle sweep reclaims abandoned previews.
- */
-class MobilePreviewService {
-    deps;
-    bindings = new Map();
-    now;
-    constructor(deps) {
-        this.deps = deps;
-        this.now = deps.now ?? Date.now;
-    }
-    available() {
-        return this.deps.enabled();
-    }
-    /** Targets of a mission's running processes. */
-    targetsForMission(projectId, chatId) {
-        if (!this.available())
-            return [];
-        return this.deps.targets.list(projectId).filter((target) => target.chatId === chatId);
-    }
-    async open(device, projectId, input) {
-        const browser = this.requireBrowser(projectId);
-        const target = this.deps.targets.forProcess(projectId, input.processId);
-        if (!target || target.chatId !== input.chatId)
-            throw new PreviewError(404, 'preview_target_gone', 'This process is no longer running or announced no URL.');
-        const origin = (0, preview_origins_1.previewOrigin)(input.url);
-        if (!origin || !target.urls.some((url) => (0, preview_origins_1.previewOrigin)(url) === origin)) {
-            throw new PreviewError(400, 'preview_url_not_announced', 'Only URLs announced by this process can be previewed.');
-        }
-        let meta;
-        try {
-            meta = await browser.create({ initialUrl: input.url, owner: { kind: 'device', deviceId: device.id, deviceName: device.name }, viewport: input.viewport });
-        }
-        catch (err) {
-            throw translateBrowserError(err);
-        }
-        try {
-            const opened = { sessionId: meta.id, channel: this.bind(projectId, device.id, browser, meta.id), url: input.url };
-            this.changed();
-            return opened;
-        }
-        catch (err) {
-            await browser.kill(meta.id);
-            throw err;
-        }
-    }
-    /** Re-attach a live session after the peer reconnected. */
-    attach(device, projectId, sessionId) {
-        const browser = this.requireBrowser(projectId);
-        this.requireOwner(browser, device.id, sessionId);
-        return { sessionId, channel: this.bind(projectId, device.id, browser, sessionId) };
-    }
-    async navigate(device, projectId, sessionId, action, url) {
-        const browser = this.requireBrowser(projectId);
-        this.requireOwner(browser, device.id, sessionId);
-        try {
-            const result = await browser.navigateAsDevice(sessionId, device.id, action, url);
-            if (!result)
-                throw new PreviewError(404, 'preview_session_closed', 'This preview session has ended.');
-            return { url: result.url, title: result.title };
-        }
-        catch (err) {
-            throw translateBrowserError(err);
-        }
-    }
-    async close(device, projectId, sessionId) {
-        const browser = this.requireBrowser(projectId);
-        this.requireOwner(browser, device.id, sessionId);
-        this.unbind(sessionId);
-        await browser.kill(sessionId);
-        this.changed();
-    }
-    /** Live device-owned sessions across projects (Desktop indicator). */
-    listDeviceSessions() {
-        if (!this.available())
-            return [];
-        const sessions = [];
-        for (const browser of this.deps.allBrowsers()) {
-            for (const meta of browser.listSessions()) {
-                if (meta.owner.kind !== 'device')
-                    continue;
-                sessions.push({ projectId: meta.projectId, sessionId: meta.id, deviceId: meta.owner.deviceId, deviceName: meta.owner.deviceName,
-                    url: meta.url, title: meta.title, createdAt: meta.createdAt });
-            }
-        }
-        return sessions.sort((a, b) => b.createdAt - a.createdAt);
-    }
-    /** The Desktop user ends a phone's preview; the viewer shows "session closed". */
-    async endFromDesktop(projectId, sessionId) {
-        const browser = this.deps.browserFor(projectId);
-        if (!browser || browser.sessionOwner(sessionId)?.kind !== 'device')
-            return false;
-        // Kill first so the attached channel client receives `closed` before the
-        // binding is dropped.
-        const killed = await browser.kill(sessionId);
-        this.unbind(sessionId);
-        if (killed)
-            this.changed();
-        return killed;
-    }
-    /** Device revoked/unpaired: end every preview it owns, in every project. */
-    async closeForDevice(deviceId) {
-        for (const [sessionId, binding] of [...this.bindings])
-            if (binding.deviceId === deviceId)
-                this.unbind(sessionId);
-        for (const browser of this.deps.allBrowsers()) {
-            try {
-                await browser.killDeviceSessions(deviceId);
-            }
-            catch { /* best-effort per project */ }
-        }
-        this.changed();
-    }
-    changed() {
-        try {
-            this.deps.onChange?.();
-        }
-        catch { /* a notification failure never fails the use case */ }
-    }
-    requireBrowser(projectId) {
-        if (!this.available())
-            throw new PreviewError(404, 'preview_unavailable', 'App preview requires browser capture to be enabled on Desktop.');
-        const browser = this.deps.browserFor(projectId);
-        if (!browser)
-            throw new PreviewError(404, 'unknown_project', 'Unknown project');
-        return browser;
-    }
-    requireOwner(browser, deviceId, sessionId) {
-        const owner = browser.sessionOwner(sessionId);
-        // A session of another device or of Desktop is indistinguishable from a
-        // missing one: never confirm its existence to this device.
-        if (!owner || owner.kind !== 'device' || owner.deviceId !== deviceId) {
-            throw new PreviewError(404, 'preview_session_closed', 'This preview session has ended.');
-        }
-    }
-    bind(projectId, deviceId, browser, sessionId) {
-        const label = `${mobile_preview_channel_1.PREVIEW_CHANNEL_PREFIX}${sessionId}`;
-        const channel = this.deps.openChannel(deviceId, label);
-        if (!channel)
-            throw new PreviewError(409, 'preview_requires_webrtc', 'Reconnect Companion to Desktop to preview apps.');
-        this.unbind(sessionId);
-        const client = new mobile_preview_channel_1.PreviewChannelClient(channel);
-        const binding = { projectId, deviceId, channel, client };
-        this.bindings.set(sessionId, binding);
-        const limiter = new mobile_preview_channel_1.PreviewInboundLimiter(this.now);
-        const current = () => this.bindings.get(sessionId) === binding;
-        channel.onOpen(() => {
-            if (!current())
-                return;
-            void browser.attach(sessionId, client).then((meta) => {
-                if (!meta)
-                    client.close(1000, 'session_closed');
-            });
-        });
-        channel.onMessage((data) => {
-            if (!current() || !limiter.take())
-                return;
-            const msg = (0, mobile_preview_channel_1.parsePreviewInbound)(typeof data === 'string' ? data : data.toString('utf8'));
-            if (!msg)
-                return;
-            if (msg.type === 'input') {
-                void browser.handleInput(sessionId, msg.event).catch(() => { });
-            }
-            else {
-                void browser.navigateAsDevice(sessionId, deviceId, msg.action, msg.url).catch(() => {
-                    // A rejected or failed navigation keeps the current page; tell the
-                    // viewer so it can restore its address field.
-                    try {
-                        channel.send(JSON.stringify({ type: 'nav_rejected' }));
-                    }
-                    catch { /* ignore */ }
-                });
-            }
-        });
-        channel.onClose(() => {
-            browser.detach(sessionId, client);
-            if (current())
-                this.bindings.delete(sessionId);
-        });
-        return label;
-    }
-    unbind(sessionId) {
-        const binding = this.bindings.get(sessionId);
-        if (!binding)
-            return;
-        this.bindings.delete(sessionId);
-        try {
-            binding.channel.close();
-        }
-        catch { /* ignore */ }
-    }
-}
-exports.MobilePreviewService = MobilePreviewService;
-function translateBrowserError(err) {
-    if (err instanceof PreviewError)
-        return err;
-    if (err instanceof browser_capture_types_1.BrowserNavigationRejectedError)
-        return new PreviewError(400, 'preview_url_not_announced', 'Only URLs announced by this project can be opened in a preview.');
-    if (err instanceof browser_capture_types_1.BrowserLimitExceededError)
-        return new PreviewError(429, 'preview_limit', `Up to ${err.limit} phones can preview this project at once. Close another preview and retry.`);
-    return new PreviewError(502, 'preview_failed', 'Desktop could not open the preview. Retry in a moment.');
-}
-const ID = /^[A-Za-z0-9_-]{1,160}$/;
-const ACTIONS = new Set(['goto', 'back', 'forward', 'reload']);
-function viewportFrom(raw) {
-    if (!raw || typeof raw !== 'object')
-        return undefined;
-    const v = raw;
-    const ok = (n) => typeof n === 'number' && Number.isFinite(n) && n > 0;
-    if (!ok(v.width) || !ok(v.height))
-        return undefined;
-    return { width: v.width, height: v.height, ...(ok(v.deviceScaleFactor) ? { deviceScaleFactor: v.deviceScaleFactor } : {}) };
-}
-/**
- * Gateway routes. Preview targets come from mission processes, so they follow
- * the mission rule: an all-projects device grant (`mobile-mission-control`).
- */
-function createMobilePreviewRouter({ db, preview }) {
-    const router = (0, express_1.Router)();
-    const segment = (value) => typeof value === 'string' ? value : '';
-    const device = (req) => {
-        const row = req.mobileDevice;
-        return { id: row.id, name: row.name };
-    };
-    const fail = (res, err) => {
-        if (err instanceof PreviewError) {
-            res.status(err.status).json({ error: err.message, code: err.code });
-            return;
-        }
-        res.status(500).json({ error: 'Preview failed', code: 'preview_failed' });
-    };
-    const gate = (req, res) => {
-        const pid = segment(req.params.pid);
-        if (!ID.test(pid)) {
-            res.status(400).json({ error: 'Invalid parameter' });
-            return null;
-        }
-        if (!(0, mobile_missions_1.mobileCapabilities)(db, device(req).id).features.missions) {
-            res.status(403).json({ error: mobile_missions_1.MISSION_ACCESS_REASON });
-            return null;
-        }
-        if (!preview.available()) {
-            res.status(404).json({ error: 'App preview is unavailable on Desktop.', code: 'preview_unavailable' });
-            return null;
-        }
-        return pid;
-    };
-    const mission = (res, pid, cid) => {
-        if (!ID.test(cid)) {
-            res.status(400).json({ error: 'Invalid mission identity' });
-            return false;
-        }
-        const conversation = (0, agent_store_1.getAgentConversation)(db, cid);
-        if (!conversation || conversation.pinned_project_id !== pid) {
-            res.status(404).json({ error: 'Mission not found in this project' });
-            return false;
-        }
-        return true;
-    };
-    router.get('/projects/:pid/missions/:cid/preview-targets', (req, res) => {
-        const pid = gate(req, res);
-        if (!pid)
-            return;
-        const cid = segment(req.params.cid);
-        if (!mission(res, pid, cid))
-            return;
-        res.json({ targets: preview.targetsForMission(pid, cid).map(({ processId, urls }) => ({ processId, urls })) });
-    });
-    router.post('/projects/:pid/preview-sessions', async (req, res) => {
-        const pid = gate(req, res);
-        if (!pid)
-            return;
-        const body = (req.body ?? {});
-        const cid = segment(body.missionId), processId = segment(body.processId), url = segment(body.url);
-        if (!mission(res, pid, cid))
-            return;
-        if (!ID.test(processId) || !url || url.length > 2048) {
-            res.status(400).json({ error: 'processId and url are required' });
-            return;
-        }
-        try {
-            res.status(201).json(await preview.open(device(req), pid, { chatId: cid, processId, url, viewport: viewportFrom(body.viewport) }));
-        }
-        catch (err) {
-            fail(res, err);
-        }
-    });
-    router.post('/projects/:pid/preview-sessions/:sid/attach', (req, res) => {
-        const pid = gate(req, res);
-        if (!pid)
-            return;
-        const sid = segment(req.params.sid);
-        if (!ID.test(sid)) {
-            res.status(400).json({ error: 'Invalid parameter' });
-            return;
-        }
-        try {
-            res.json(preview.attach(device(req), pid, sid));
-        }
-        catch (err) {
-            fail(res, err);
-        }
-    });
-    router.post('/projects/:pid/preview-sessions/:sid/navigate', async (req, res) => {
-        const pid = gate(req, res);
-        if (!pid)
-            return;
-        const sid = segment(req.params.sid);
-        const body = (req.body ?? {});
-        const action = segment(body.action) || 'goto';
-        const url = typeof body.url === 'string' ? body.url : undefined;
-        if (!ID.test(sid) || !ACTIONS.has(action) || (action === 'goto' && (!url || url.length > 2048))) {
-            res.status(400).json({ error: 'Invalid navigation' });
-            return;
-        }
-        try {
-            res.json(await preview.navigate(device(req), pid, sid, action, url));
-        }
-        catch (err) {
-            fail(res, err);
-        }
-    });
-    router.delete('/projects/:pid/preview-sessions/:sid', async (req, res) => {
-        const pid = gate(req, res);
-        if (!pid)
-            return;
-        const sid = segment(req.params.sid);
-        if (!ID.test(sid)) {
-            res.status(400).json({ error: 'Invalid parameter' });
-            return;
-        }
-        try {
-            await preview.close(device(req), pid, sid);
-            res.json({ ok: true });
-        }
-        catch (err) {
-            fail(res, err);
-        }
-    });
-    return router;
-}

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

@@ -1,117 +0,0 @@
-"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/preview-targets.js

@@ -1,80 +0,0 @@
-"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;
-        },
-    };
-}