@wenrwa/marketplace-cli 0.4.4 → 0.4.6

package/dist/__tests__/bridge-browser-relay.test.js

@@ -0,0 +1,670 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cbs-02 — relay client wiring for the cloud browser session.
+ *
+ * `browser-open` / `browser-input` (pane -> container) route to a single
+ * per-session BrowserDriver instance (one browser session per container in
+ * v1); driver frames/states forward up as `browser-frame` / `browser-state`
+ * with the sessionId stamped — following exactly the install-bundle /
+ * context-manifest non-PTY precedent (never touches sessions.open / PTY
+ * paths). Uses a FAKE driver (not the real CDP one) — this is a focused
+ * unit test of the new relayClient handler functions, same shape as
+ * bridge-install-bundle-frame.test.ts.
+ */
+const ws_1 = require("ws");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+const browserFrames_1 = require("../bridge/browserFrames");
+class FakePty {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+const makeFactory = () => ({ spawn: (o) => new FakePty(o) });
+class FakeBrowserDriver {
+    startCalls = [];
+    navigateCalls = [];
+    inputCalls = [];
+    stopCalls = 0;
+    sleepCalls = [];
+    ackFrameCalls = 0;
+    frameCb = null;
+    stateCb = null;
+    async start(url) {
+        this.startCalls.push(url);
+    }
+    async navigate(url) {
+        this.navigateCalls.push(url);
+    }
+    input(event) {
+        this.inputCalls.push(event);
+    }
+    async back() { }
+    async forward() { }
+    async reload() { }
+    onFrame(cb) {
+        this.frameCb = cb;
+    }
+    onState(cb) {
+        this.stateCb = cb;
+    }
+    ackFrame() {
+        this.ackFrameCalls += 1;
+    }
+    stop() {
+        this.stopCalls += 1;
+    }
+    sleep(reason) {
+        this.sleepCalls.push(reason);
+        this.emitState({ state: 'asleep', reason });
+    }
+    // test-only helpers to drive the driver from outside
+    emitFrame(f) {
+        this.frameCb?.(f);
+    }
+    emitState(s) {
+        this.stateCb?.(s);
+    }
+}
+class FakeBrowserIdleTracker {
+    onIdle;
+    recordInputCalls = 0;
+    recordAckCalls = 0;
+    startCalls = 0;
+    stopCalls = 0;
+    constructor(onIdle) {
+        this.onIdle = onIdle;
+    }
+    recordInput() {
+        this.recordInputCalls += 1;
+    }
+    recordAck() {
+        this.recordAckCalls += 1;
+    }
+    start() {
+        this.startCalls += 1;
+    }
+    stop() {
+        this.stopCalls += 1;
+    }
+    // test-only helper to fire the idle condition from outside
+    fireIdle() {
+        this.onIdle();
+    }
+}
+function frameQueue(ws) {
+    const frames = [];
+    const waiters = [];
+    ws.on('message', (raw) => {
+        const f = JSON.parse(String(raw));
+        const w = waiters.shift();
+        if (w)
+            w(f);
+        else
+            frames.push(f);
+    });
+    return {
+        next: () => (frames.length > 0 ? Promise.resolve(frames.shift()) : new Promise((r) => waiters.push(r))),
+    };
+}
+function startFakeRelay() {
+    return new Promise((resolve) => {
+        const wss = new ws_1.WebSocketServer({ port: 0, host: '127.0.0.1' });
+        const queue = [];
+        const waiters = [];
+        wss.on('connection', (ws) => {
+            const w = waiters.shift();
+            if (w)
+                w(ws);
+            else
+                queue.push(ws);
+        });
+        wss.on('listening', () => {
+            const addr = wss.address();
+            const port = typeof addr === 'object' && addr ? addr.port : 0;
+            resolve({
+                wss,
+                port,
+                nextConnection: () => (queue.length > 0 ? Promise.resolve(queue.shift()) : new Promise((r) => waiters.push(r))),
+            });
+        });
+    });
+}
+function closeRelay(wss) {
+    return new Promise((resolve, reject) => {
+        for (const client of wss.clients)
+            client.terminate();
+        wss.close((err) => (err ? reject(err) : resolve()));
+    });
+}
+describe('relay client — browser-open/browser-input (cbs-02)', () => {
+    it('browser-open creates a driver via the factory, starts it, and forwards frames/states with sessionId stamped', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20)); // let the async start() microtask settle
+        expect(drivers['browser:c1'].startCalls).toEqual(['https://example.com']);
+        // A browser session must never open a PTY.
+        expect(sessions.list()).toEqual([]);
+        drivers['browser:c1'].emitFrame({ seq: 1, data: 'abc', w: 1280, h: 800 });
+        const frameMsg = await q.next();
+        expect(frameMsg).toEqual({ t: 'browser-frame', sessionId: 'browser:c1', seq: 1, data: 'abc', w: 1280, h: 800 });
+        expect((0, browserFrames_1.isBrowserScreenFrame)(frameMsg)).toBe(true);
+        // cbs-06: the cbs-02 interim policy (self-ack on send) is GONE — the
+        // pacer is only acked by a real browser-frame-ack from the pane (see
+        // the dedicated describe block below). Forwarding a frame must not
+        // ack it on its own.
+        expect(drivers['browser:c1'].ackFrameCalls).toBe(0);
+        drivers['browser:c1'].emitState({ state: 'open', url: 'https://example.com/', title: 'Example' });
+        const stateMsg = await q.next();
+        expect(stateMsg).toEqual({ t: 'browser-state', sessionId: 'browser:c1', state: 'open', url: 'https://example.com/', title: 'Example' });
+        expect((0, browserFrames_1.isBrowserStateFrame)(stateMsg)).toBe(true);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('browser-open on an already-open session navigates the existing driver instead of starting a new one', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => {
+                const d = new FakeBrowserDriver();
+                drivers.push(d);
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com/other' }));
+        await new Promise((r) => setTimeout(r, 20));
+        // Exactly one driver instance for this sessionId (single driver per container session).
+        expect(drivers).toHaveLength(1);
+        expect(drivers[0].startCalls).toEqual(['https://example.com']);
+        expect(drivers[0].navigateCalls).toEqual(['https://example.com/other']);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('browser-input dispatches the event to the session-keyed driver', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        const event = { kind: 'mouse', type: 'down', x: 10, y: 20, button: 'left' };
+        ws.send(JSON.stringify({ t: 'browser-input', sessionId: 'browser:c1', event }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(drivers['browser:c1'].inputCalls).toEqual([event]);
+        // Never opens or touches a PTY session.
+        expect(sessions.list()).toEqual([]);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('browser-input for an unknown sessionId is a safe no-op (no driver, no crash)', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => new FakeBrowserDriver(),
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-input', sessionId: 'browser:never-opened', event: { kind: 'insertText', text: 'x' } }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(sessions.list()).toEqual([]);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('errors (never crashes) when no browser driver factory is wired', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const handle = (0, relayClient_1.startRelayClient)({ relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        expect((await q.next()).t).toBe('error');
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    // cbs-07: this is the exact failure shape a bridge on an OLD image (no
+    // Chromium binary, or any other spawn/launch failure) hits in production —
+    // chromiumLauncher's spawn never throws synchronously on ENOENT, it
+    // rejects the driver's start() promise asynchronously instead. Proves the
+    // ship slice's degrade-gracefully choice (documented in
+    // commands/bridge.ts's createBrowserDriver wiring): a rejecting start()
+    // yields one `error` frame, cleans up bookkeeping, and — the actual point
+    // of this test — never takes the relay connection or the bridge process
+    // down with it (a second frame on a fresh session still works normally).
+    it('a driver whose start() rejects (missing/failed Chromium) errors that one session but never crashes the bridge', async () => {
+        class FailingStartBrowserDriver extends FakeBrowserDriver {
+            async start() {
+                throw new Error('spawn chromium ENOENT');
+            }
+        }
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => new FailingStartBrowserDriver(),
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        const errorFrame = await q.next();
+        expect(errorFrame.t).toBe('error');
+        expect(errorFrame.message).toMatch(/ENOENT/);
+        // The connection (and the bridge) is unaffected — an unrelated frame on
+        // a fresh session still gets a normal reply, proving nothing wedged.
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c2', url: 'https://example.com' }));
+        const secondFrame = await q.next();
+        expect(secondFrame.t).toBe('error');
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});
+describe('relay client — browser-frame-ack: true end-to-end backpressure (cbs-06)', () => {
+    it('a browser-frame-ack frame from the pane calls the driver ackFrame — nothing else does', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        drivers['browser:c1'].emitFrame({ seq: 1, data: 'abc', w: 1280, h: 800 });
+        await q.next(); // the browser-frame forward
+        expect(drivers['browser:c1'].ackFrameCalls).toBe(0);
+        ws.send(JSON.stringify({ t: 'browser-frame-ack', sessionId: 'browser:c1', seq: 1 }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(drivers['browser:c1'].ackFrameCalls).toBe(1);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('browser-frame-ack for an unknown sessionId is a safe no-op', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => new FakeBrowserDriver(),
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-frame-ack', sessionId: 'browser:never-opened', seq: 0 }));
+        await new Promise((r) => setTimeout(r, 20));
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('on socket close, every open driver is ack-flushed so the pacer never wedges waiting for a pane that is gone', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        drivers['browser:c1'].emitFrame({ seq: 1, data: 'abc', w: 1280, h: 800 }); // in flight, never acked by a pane
+        await new Promise((r) => setTimeout(r, 20));
+        expect(drivers['browser:c1'].ackFrameCalls).toBe(0);
+        ws.terminate(); // simulate the pane/relay connection dropping mid-stream
+        await new Promise((r) => setTimeout(r, 30));
+        expect(drivers['browser:c1'].ackFrameCalls).toBe(1);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});
+describe('relay client — browser-sleep (cbs-06)', () => {
+    it('stops the driver (asleep, reason "sleep") and forwards exactly one browser-state frame', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        ws.send(JSON.stringify({ t: 'browser-sleep', sessionId: 'browser:c1' }));
+        const stateMsg = await q.next();
+        expect(stateMsg).toEqual({ t: 'browser-state', sessionId: 'browser:c1', state: 'asleep', reason: 'sleep' });
+        expect((0, browserFrames_1.isBrowserStateFrame)(stateMsg)).toBe(true);
+        expect(drivers['browser:c1'].sleepCalls).toEqual(['sleep']);
+        expect(drivers['browser:c1'].stopCalls).toBe(0); // sleep, not stop — distinct verb
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('sleep-of-nothing (never-opened session) is a safe no-op — no error, no frame', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => new FakeBrowserDriver(),
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-sleep', sessionId: 'browser:never-opened' }));
+        await new Promise((r) => setTimeout(r, 20));
+        // Prove no stray frame followed: open a fresh session and the next frame is its own state.
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c2', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('double browser-sleep is a safe no-op the second time (only one asleep frame total)', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        ws.send(JSON.stringify({ t: 'browser-sleep', sessionId: 'browser:c1' }));
+        await q.next(); // asleep state
+        ws.send(JSON.stringify({ t: 'browser-sleep', sessionId: 'browser:c1' }));
+        await new Promise((r) => setTimeout(r, 20));
+        // Only ever one driver, one sleep() call — the second browser-sleep found
+        // no driver in the map (removed on the first asleep transition).
+        expect(Object.keys(drivers)).toEqual(['browser:c1']);
+        expect(drivers['browser:c1'].sleepCalls).toEqual(['sleep']);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('a stopped (asleep) driver is REPLACED on the next browser-open, not navigated', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => {
+                const d = new FakeBrowserDriver();
+                drivers.push(d);
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        ws.send(JSON.stringify({ t: 'browser-sleep', sessionId: 'browser:c1' }));
+        await q.next(); // asleep state
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com/resumed' }));
+        await new Promise((r) => setTimeout(r, 20));
+        // A SECOND driver instance was created and start()ed with the resume URL
+        // — the first (asleep) driver was never asked to navigate().
+        expect(drivers).toHaveLength(2);
+        expect(drivers[0].startCalls).toEqual(['https://example.com']);
+        expect(drivers[0].navigateCalls).toEqual([]);
+        expect(drivers[1].startCalls).toEqual(['https://example.com/resumed']);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('a closed (crashed) driver is also REPLACED on the next browser-open, not navigated', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => {
+                const d = new FakeBrowserDriver();
+                drivers.push(d);
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        drivers[0].emitState({ state: 'closed', reason: 'chromium-exit code=1' }); // crash, not sleep
+        await q.next(); // closed state
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com/again' }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(drivers).toHaveLength(2);
+        expect(drivers[1].startCalls).toEqual(['https://example.com/again']);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});
+describe('relay client — browser idle timer wiring (cbs-06)', () => {
+    it('creates and starts an idle tracker alongside the driver on browser-open', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const trackers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => new FakeBrowserDriver(),
+            createBrowserIdleTracker: ({ sessionId, onIdle }) => {
+                const t = new FakeBrowserIdleTracker(onIdle);
+                trackers[sessionId] = t;
+                return t;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(trackers['browser:c1']).toBeDefined();
+        expect(trackers['browser:c1'].startCalls).toBe(1);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('browser-input and browser-frame-ack feed the idle tracker liveness signals', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        const trackers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+            createBrowserIdleTracker: ({ sessionId, onIdle }) => {
+                const t = new FakeBrowserIdleTracker(onIdle);
+                trackers[sessionId] = t;
+                return t;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        const event = { kind: 'insertText', text: 'x' };
+        ws.send(JSON.stringify({ t: 'browser-input', sessionId: 'browser:c1', event }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(trackers['browser:c1'].recordInputCalls).toBe(1);
+        ws.send(JSON.stringify({ t: 'browser-frame-ack', sessionId: 'browser:c1', seq: 0 }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(trackers['browser:c1'].recordAckCalls).toBe(1);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('onIdle firing closes the browser (asleep, reason idle-timeout) and stops the tracker', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        const trackers = {};
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+            createBrowserIdleTracker: ({ sessionId, onIdle }) => {
+                const t = new FakeBrowserIdleTracker(onIdle);
+                trackers[sessionId] = t;
+                return t;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        trackers['browser:c1'].fireIdle();
+        const stateMsg = await q.next();
+        expect(stateMsg).toEqual({ t: 'browser-state', sessionId: 'browser:c1', state: 'asleep', reason: 'idle-timeout' });
+        expect((0, browserFrames_1.isBrowserStateFrame)(stateMsg)).toBe(true);
+        expect(drivers['browser:c1'].sleepCalls).toEqual(['idle-timeout']);
+        expect(trackers['browser:c1'].stopCalls).toBe(1);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('the idle tracker is torn down (stopped) and a fresh one created when the session resumes', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const trackers = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => new FakeBrowserDriver(),
+            createBrowserIdleTracker: ({ onIdle }) => {
+                const t = new FakeBrowserIdleTracker(onIdle);
+                trackers.push(t);
+                return t;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        ws.send(JSON.stringify({ t: 'browser-sleep', sessionId: 'browser:c1' }));
+        await q.next(); // asleep
+        expect(trackers[0].stopCalls).toBe(1);
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com/resumed' }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(trackers).toHaveLength(2);
+        expect(trackers[1].startCalls).toBe(1);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('absent createBrowserIdleTracker: browser-open still works, no idle tracking attempted', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => new FakeBrowserDriver(),
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        ws.send(JSON.stringify({ t: 'browser-input', sessionId: 'browser:c1', event: { kind: 'insertText', text: 'x' } }));
+        await new Promise((r) => setTimeout(r, 20));
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});

package/dist/__tests__/bridge-bundle-installer.test.d.ts

@@ -0,0 +1 @@
+export {};