specrails-desktop 2.63.1 → 2.64.0

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreviewInboundLimiter = exports.PreviewChannelClient = exports.PREVIEW_INBOUND_MAX_BYTES = exports.PREVIEW_INBOUND_MAX_PER_MINUTE = exports.PREVIEW_MAX_MESSAGE_BYTES = exports.PREVIEW_CHUNK_HEADER_BYTES = exports.PREVIEW_CHANNEL_PREFIX = void 0;
+exports.encodeFrameChunks = encodeFrameChunks;
+exports.parsePreviewInbound = parsePreviewInbound;
+// Companion app preview: one WebRTC DataChannel per browser session, labelled
+// `preview:<sessionId>`, opened by Desktop on the device's EXISTING peer (a new
+// channel on an established SCTP association needs no SDP renegotiation). It is
+// separate from the `mobile` RPC channel so JPEG frames never queue ahead of RPC.
+//
+// Wire format (Desktop → Companion):
+//   - text:   JSON control (`ready`, `nav`, `popup`, `closed`) — always small.
+//   - binary: screencast frame fragments, each `u32 frameSeq | u16 index |
+//             u16 count` (big-endian) + payload. A frame renders only once all
+//             of its fragments arrived; a newer `frameSeq` discards an older
+//             incomplete one.
+// Wire format (Companion → Desktop): JSON text `{type:'input', event}` and
+// `{type:'navigate', action, url?}`.
+exports.PREVIEW_CHANNEL_PREFIX = 'preview:';
+exports.PREVIEW_CHUNK_HEADER_BYTES = 8;
+/** Same per-message budget the `mobile` channel's text chunking proved safe
+ *  across werift, libwebrtc (native companion) and browsers (web companion). */
+exports.PREVIEW_MAX_MESSAGE_BYTES = 16000;
+const MAX_CHUNKS = 0xffff;
+const WS_OPEN = 1;
+const WS_CLOSED = 3;
+/** Mirrors the PTY-tuned cap of `/ws/browser/:id` (BUG-MOBILE-07). */
+exports.PREVIEW_INBOUND_MAX_PER_MINUTE = 6000;
+exports.PREVIEW_INBOUND_MAX_BYTES = 64 * 1024;
+/** Split one JPEG frame into header-prefixed binary fragments. */
+function encodeFrameChunks(frameSeq, frame, maxMessageBytes = exports.PREVIEW_MAX_MESSAGE_BYTES) {
+    const payload = maxMessageBytes - exports.PREVIEW_CHUNK_HEADER_BYTES;
+    if (payload <= 0)
+        throw new RangeError('maxMessageBytes too small');
+    const count = Math.max(1, Math.ceil(frame.length / payload));
+    if (count > MAX_CHUNKS)
+        throw new RangeError('frame too large');
+    const seq = frameSeq >>> 0;
+    const chunks = [];
+    for (let index = 0; index < count; index++) {
+        const part = frame.subarray(index * payload, (index + 1) * payload);
+        const chunk = Buffer.allocUnsafe(exports.PREVIEW_CHUNK_HEADER_BYTES + part.length);
+        chunk.writeUInt32BE(seq, 0);
+        chunk.writeUInt16BE(index, 4);
+        chunk.writeUInt16BE(count, 6);
+        part.copy(chunk, exports.PREVIEW_CHUNK_HEADER_BYTES);
+        chunks.push(chunk);
+    }
+    return chunks;
+}
+/**
+ * Presents a preview DataChannel to `BrowserCaptureManager` as a
+ * `BrowserWsClient`, so attach/detach, popup state and the newest-wins
+ * screencast fan-out (which checks `bufferedAmount` BEFORE handing over a
+ * frame) are reused unchanged. A frame is always sent whole: conflation runs
+ * per frame, never per fragment, so a partial frame never goes out.
+ */
+class PreviewChannelClient {
+    channel;
+    frameSeq = 0;
+    constructor(channel) {
+        this.channel = channel;
+    }
+    get readyState() {
+        return this.channel.readyState === 'open' ? WS_OPEN : WS_CLOSED;
+    }
+    get bufferedAmount() {
+        return this.channel.bufferedAmount;
+    }
+    send(data) {
+        if (typeof data === 'string') {
+            this.channel.send(data);
+            return;
+        }
+        const seq = this.frameSeq;
+        this.frameSeq = (this.frameSeq + 1) >>> 0;
+        for (const chunk of encodeFrameChunks(seq, data))
+            this.channel.send(chunk);
+    }
+    close(_code, reason) {
+        try {
+            if (this.channel.readyState === 'open')
+                this.channel.send(JSON.stringify({ type: 'closed', reason: reason ?? 'session_closed' }));
+        }
+        catch { /* the channel is already going away */ }
+        try {
+            this.channel.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+exports.PreviewChannelClient = PreviewChannelClient;
+const finite = (value) => typeof value === 'number' && Number.isFinite(value);
+const modifiers = (value) => Number.isInteger(value) && value >= 0 && value <= 15 ? value : undefined;
+const BUTTONS = new Set(['left', 'middle', 'right']);
+function parseEvent(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const e = raw;
+    switch (e.type) {
+        case 'mouse': {
+            if (!['move', 'down', 'up'].includes(e.action) || !finite(e.x) || !finite(e.y) || e.x < 0 || e.y < 0)
+                return null;
+            const button = typeof e.button === 'string' && BUTTONS.has(e.button) ? e.button : undefined;
+            const clickCount = Number.isInteger(e.clickCount) && e.clickCount >= 1 && e.clickCount <= 3 ? e.clickCount : undefined;
+            return { type: 'mouse', action: e.action, x: e.x, y: e.y, ...(button ? { button } : {}), ...(clickCount ? { clickCount } : {}), ...(modifiers(e.modifiers) !== undefined ? { modifiers: modifiers(e.modifiers) } : {}) };
+        }
+        case 'wheel': {
+            if (!finite(e.x) || !finite(e.y) || !finite(e.deltaX) || !finite(e.deltaY) || e.x < 0 || e.y < 0)
+                return null;
+            const clamp = (v) => Math.max(-10_000, Math.min(10_000, v));
+            return { type: 'wheel', x: e.x, y: e.y, deltaX: clamp(e.deltaX), deltaY: clamp(e.deltaY), ...(modifiers(e.modifiers) !== undefined ? { modifiers: modifiers(e.modifiers) } : {}) };
+        }
+        case 'key': {
+            if (!['down', 'up'].includes(e.action) || typeof e.key !== 'string' || e.key.length === 0 || e.key.length > 32)
+                return null;
+            const code = typeof e.code === 'string' && e.code.length <= 32 ? e.code : undefined;
+            const text = typeof e.text === 'string' && e.text.length <= 8 ? e.text : undefined;
+            return { type: 'key', action: e.action, key: e.key, ...(code ? { code } : {}), ...(text !== undefined ? { text } : {}), ...(modifiers(e.modifiers) !== undefined ? { modifiers: modifiers(e.modifiers) } : {}) };
+        }
+        case 'resize': {
+            if (!finite(e.width) || !finite(e.height) || e.width <= 0 || e.height <= 0)
+                return null;
+            return { type: 'resize', width: e.width, height: e.height, ...(finite(e.deviceScaleFactor) ? { deviceScaleFactor: e.deviceScaleFactor } : {}) };
+        }
+        default:
+            return null;
+    }
+}
+/** Validate one inbound control message; anything malformed is dropped. */
+function parsePreviewInbound(text) {
+    if (text.length > exports.PREVIEW_INBOUND_MAX_BYTES)
+        return null;
+    let msg;
+    try {
+        msg = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!msg || typeof msg !== 'object')
+        return null;
+    if (msg.type === 'input') {
+        const event = parseEvent(msg.event);
+        return event ? { type: 'input', event } : null;
+    }
+    if (msg.type === 'navigate') {
+        const action = msg.action ?? 'goto';
+        if (!['goto', 'back', 'forward', 'reload'].includes(action))
+            return null;
+        if (action === 'goto' && (typeof msg.url !== 'string' || msg.url.length > 2048))
+            return null;
+        return { type: 'navigate', action: action, ...(action === 'goto' ? { url: msg.url } : {}) };
+    }
+    return null;
+}
+/** Sliding one-minute message budget for one channel. */
+class PreviewInboundLimiter {
+    now;
+    maxPerMinute;
+    windowStart = 0;
+    count = 0;
+    constructor(now = Date.now, maxPerMinute = exports.PREVIEW_INBOUND_MAX_PER_MINUTE) {
+        this.now = now;
+        this.maxPerMinute = maxPerMinute;
+    }
+    take() {
+        const at = this.now();
+        if (at - this.windowStart >= 60_000) {
+            this.windowStart = at;
+            this.count = 0;
+        }
+        if (this.count >= this.maxPerMinute)
+            return false;
+        this.count += 1;
+        return true;
+    }
+}
+exports.PreviewInboundLimiter = PreviewInboundLimiter;

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

@@ -0,0 +1,366 @@
+"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/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) {