@wenrwa/marketplace-cli 0.4.5 → 0.4.6

package/dist/__tests__/bridge-activity-parser.test.d.ts

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

package/dist/__tests__/bridge-activity-tap.test.d.ts

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

package/dist/__tests__/bridge-activity-tap.test.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pucc-int-03 — the bridge's read-only PTY activity tap (ADR-0032).
+ *
+ * Proves the relay client observes Claude Code tool-use in the PTY output and
+ * emits a coalesced `activity` frame ({ filePaths, thinking }) to the relay —
+ * WITHOUT altering the `data` frames forwarded to the browser, and never on a
+ * parse miss. Same faked-PTY / fake-relay harness as bridge-relay-pucc14.test.
+ */
+const ws_1 = require("ws");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+const ESC = '\u001b'; // ESC byte
+class FakePty {
+    opts;
+    written = [];
+    killed = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    write(data) { this.written.push(data); }
+    resize() { }
+    kill() { this.killed = true; }
+    dataCb = null;
+    onData(cb) { this.dataCb = cb; }
+    onExit(_cb) { }
+    emitData(d) { this.dataCb?.(d); }
+}
+const makeFactory = () => {
+    const ptys = [];
+    const factory = { spawn: (o) => { const p = new FakePty(o); ptys.push(p); return p; } };
+    return { factory, ptys };
+};
+function collectFrames(ws) {
+    const frames = [];
+    ws.on('message', (raw) => frames.push(JSON.parse(String(raw))));
+    return frames;
+}
+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()));
+    });
+}
+const settle = () => new Promise((r) => setTimeout(r, 20));
+describe('bridge activity tap (pucc-int-03)', () => {
+    it('emits an activity frame with filePaths/thinking parsed from PTY output', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        // throttle 0 → emit immediately so the assertion is deterministic.
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions, activityThrottleMs: 0,
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        ptys[0].emitData(`${ESC}[1m⏺${ESC}[0m Edit(src/foo.ts)\r\n`);
+        await settle();
+        const activity = frames.find((f) => f.t === 'activity');
+        expect(activity).toMatchObject({ t: 'activity', sessionId: 'agent-A', filePaths: ['src/foo.ts'], thinking: 'Editing foo.ts' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('still forwards the raw data frame to the browser UNALTERED', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions, activityThrottleMs: 0,
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        const raw = `${ESC}[1m⏺${ESC}[0m Read(a.ts)\r\n`;
+        ptys[0].emitData(raw);
+        await settle();
+        // The data frame is byte-identical to the PTY output — the tap did not touch it.
+        const data = frames.find((f) => f.t === 'data');
+        expect(data).toEqual({ t: 'data', sessionId: 'agent-A', data: raw });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('coalesces a burst of tool-use into a single throttled activity frame', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        let clock = 1000;
+        let scheduled = null;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions,
+            activityThrottleMs: 1000,
+            nowFn: () => clock,
+            setTimeoutFn: (cb) => { scheduled = cb; return 1; },
+            clearTimeoutFn: () => { },
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        // First signal fires immediately (lastEmit=0, elapsed >= throttle).
+        ptys[0].emitData('⏺ Edit(one.ts)\n');
+        await settle();
+        // Two more within the SAME window are coalesced behind the timer, not sent.
+        ptys[0].emitData('⏺ Edit(two.ts)\n');
+        ptys[0].emitData('⏺ Read(three.ts)\n');
+        await settle();
+        let activities = frames.filter((f) => f.t === 'activity');
+        expect(activities).toHaveLength(1);
+        expect(activities[0].filePaths).toEqual(['one.ts']);
+        // Advance the clock and fire the pending flush → the coalesced batch emits.
+        clock += 1000;
+        scheduled();
+        await settle();
+        activities = frames.filter((f) => f.t === 'activity');
+        expect(activities).toHaveLength(2);
+        expect(activities[1].filePaths).toEqual(['two.ts', 'three.ts']);
+        expect(activities[1].thinking).toBe('Reading three.ts'); // latest thinking wins
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('a parse miss (ordinary output) emits NO activity frame', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions, activityThrottleMs: 0,
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        ptys[0].emitData('$ ls -la\r\ntotal 24\r\ndrwxr-xr-x  5 me  staff\r\n');
+        await settle();
+        expect(frames.some((f) => f.t === 'activity')).toBe(false);
+        expect(frames.some((f) => f.t === 'data')).toBe(true); // data still flowed
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('emitActivity:false disables the tap entirely (data still flows)', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions, emitActivity: false, activityThrottleMs: 0,
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        ptys[0].emitData('⏺ Edit(src/foo.ts)\n');
+        await settle();
+        expect(frames.some((f) => f.t === 'activity')).toBe(false);
+        expect(frames.some((f) => f.t === 'data')).toBe(true);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});

package/dist/__tests__/bridge-api-client.test.d.ts

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

package/dist/__tests__/bridge-api-client.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-03: bridge/apiClient.ts. A thin, injectable fetch wrapper the
+ * bridge daemon uses to talk to the backend AS ITSELF (Bearer Connect Token)
+ * — distinct from utils/client.ts, which authenticates the interactive CLI
+ * via the legacy X-Wallet-Pubkey login flow (~/.wen-market/config.json).
+ */
+const apiClient_1 = require("../bridge/apiClient");
+const OPTS = { apiUrl: 'https://api.x', connectToken: 'wm_ct_' + 'a'.repeat(64) };
+function fakeFetch(status, body) {
+    const fetchImpl = jest.fn().mockResolvedValue({
+        ok: status >= 200 && status < 300,
+        status,
+        json: async () => body,
+    });
+    return fetchImpl;
+}
+describe('bridge apiClient', () => {
+    it('registerDevice posts to /me/devices with the Bearer connect token', async () => {
+        const fetchImpl = fakeFetch(201, { success: true, device: { id: 'd1', name: 'bunny-mbp' } });
+        const result = await (0, apiClient_1.registerDevice)({ ...OPTS, fetchImpl }, 'bunny-mbp');
+        expect(result.device.id).toBe('d1');
+        const [url, init] = fetchImpl.mock.calls[0];
+        expect(url).toBe('https://api.x/me/devices');
+        expect(init.method).toBe('POST');
+        expect(init.headers.Authorization).toBe(`Bearer ${OPTS.connectToken}`);
+        expect(JSON.parse(init.body)).toEqual({ name: 'bunny-mbp' });
+    });
+    it('listDevices gets /me/devices', async () => {
+        const fetchImpl = fakeFetch(200, { success: true, devices: [{ id: 'd1' }] });
+        const result = await (0, apiClient_1.listDevices)({ ...OPTS, fetchImpl });
+        expect(result.devices).toHaveLength(1);
+        expect(fetchImpl.mock.calls[0][0]).toBe('https://api.x/me/devices');
+        expect(fetchImpl.mock.calls[0][1].method).toBe('GET');
+    });
+    it('revokeDevice deletes /me/devices/:id', async () => {
+        const fetchImpl = fakeFetch(200, { success: true });
+        await (0, apiClient_1.revokeDevice)({ ...OPTS, fetchImpl }, 'd1');
+        expect(fetchImpl.mock.calls[0][0]).toBe('https://api.x/me/devices/d1');
+        expect(fetchImpl.mock.calls[0][1].method).toBe('DELETE');
+    });
+    it('createLocalWorkspace posts kind:local to /workspaces', async () => {
+        const fetchImpl = fakeFetch(201, { success: true, workspace: { id: 'ws-1', name: 'my-app' } });
+        const result = await (0, apiClient_1.createLocalWorkspace)({ ...OPTS, fetchImpl }, { name: 'my-app' });
+        expect(result.workspace.id).toBe('ws-1');
+        const [url, init] = fetchImpl.mock.calls[0];
+        expect(url).toBe('https://api.x/workspaces');
+        expect(JSON.parse(init.body)).toEqual({ name: 'my-app', kind: 'local' });
+    });
+    it('deleteWorkspace deletes /workspaces/:id', async () => {
+        const fetchImpl = fakeFetch(200, { success: true });
+        await (0, apiClient_1.deleteWorkspace)({ ...OPTS, fetchImpl }, 'ws-1');
+        expect(fetchImpl.mock.calls[0][0]).toBe('https://api.x/workspaces/ws-1');
+        expect(fetchImpl.mock.calls[0][1].method).toBe('DELETE');
+    });
+    it('throws a BridgeApiError carrying the backend error code on failure', async () => {
+        const fetchImpl = fakeFetch(401, { success: false, error: { code: 'INVALID_CONNECT_TOKEN', message: 'Connect token is invalid or revoked.' } });
+        await expect((0, apiClient_1.listDevices)({ ...OPTS, fetchImpl })).rejects.toThrow(apiClient_1.BridgeApiError);
+        try {
+            await (0, apiClient_1.listDevices)({ ...OPTS, fetchImpl });
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(apiClient_1.BridgeApiError);
+            expect(err.code).toBe('INVALID_CONNECT_TOKEN');
+            expect(err.status).toBe(401);
+        }
+    });
+});

package/dist/__tests__/bridge-browser-driver.test.d.ts

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

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

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cbs-02 — bridge CDP browser driver.
+ *
+ * The deep module owning headless Chromium: spawn (child_process, NOT
+ * node-pty/SessionManager), a minimal CDP client over `ws`, screencast
+ * frames piped through the cbs-01 keep-newest pacer, and BrowserInputEvent
+ * -> CDP input dispatch. Tested end-to-end against a MockCdpEndpoint
+ * (in-process injectable transport — no real socket, no real Chromium) and
+ * a fake child process (no real spawn).
+ *
+ * docs/prd/cloud-browser-session.md + issues/cbs-02-bridge-cdp-driver.md.
+ */
+const browserDriver_1 = require("../bridge/browserDriver");
+const browserFrames_1 = require("../bridge/browserFrames");
+class FakeChildProcess {
+    killed = false;
+    killCount = 0;
+    stderr = { on: () => { } };
+    exitHandlers = [];
+    on(event, cb) {
+        if (event === 'exit')
+            this.exitHandlers.push(cb);
+    }
+    kill() {
+        this.killed = true;
+        this.killCount += 1;
+    }
+    emitExit(code, signal = null) {
+        for (const cb of this.exitHandlers)
+            cb(code, signal);
+    }
+}
+/** In-process CDP endpoint: scripts command responses and lets the test
+ *  fire raw CDP events, with no real socket involved. */
+class MockCdpEndpoint {
+    sent = [];
+    handlers = new Map();
+    onMessage = null;
+    onCloseCb = null;
+    closed = false;
+    transport = {
+        send: (data) => {
+            const msg = JSON.parse(data);
+            this.sent.push(msg);
+            const handler = this.handlers.get(msg.method);
+            const result = handler ? handler(msg.params ?? {}) : {};
+            queueMicrotask(() => this.onMessage?.(JSON.stringify({ id: msg.id, result })));
+        },
+        close: () => {
+            if (this.closed)
+                return;
+            this.closed = true;
+            queueMicrotask(() => this.onCloseCb?.(undefined));
+        },
+        on: (event, cb) => {
+            if (event === 'open')
+                queueMicrotask(() => cb());
+            else if (event === 'message')
+                this.onMessage = cb;
+            else if (event === 'close')
+                this.onCloseCb = cb;
+            // 'error' intentionally ignored
+        },
+    };
+    on(method, handler) {
+        this.handlers.set(method, handler);
+    }
+    emitEvent(method, params, sessionId) {
+        this.onMessage?.(JSON.stringify({ method, params, ...(sessionId ? { sessionId } : {}) }));
+    }
+    triggerClose(info) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.onCloseCb?.(info);
+    }
+    sentCalls(method) {
+        return this.sent.filter((m) => m.method === method);
+    }
+}
+/** Wires a fresh driver + mock endpoint + fake child, with the standard
+ *  attach handshake pre-scripted (empty target list -> createTarget ->
+ *  attachToTarget). Individual tests add/override handlers as needed. */
+function setup(opts) {
+    const endpoint = new MockCdpEndpoint();
+    const proc = new FakeChildProcess();
+    endpoint.on('Target.getTargets', () => ({
+        targetInfos: opts?.existingPageTargetId ? [{ targetId: opts.existingPageTargetId, type: 'page' }] : [],
+    }));
+    endpoint.on('Target.createTarget', () => ({ targetId: 'target-new' }));
+    endpoint.on('Target.attachToTarget', () => ({ sessionId: 'sess-1' }));
+    const launchChromiumFn = () => ({ proc, wsUrl: Promise.resolve('ws://mock-devtools') });
+    const wsFactory = (_url) => endpoint.transport;
+    const driver = (0, browserDriver_1.createBrowserDriver)({ launchChromiumFn, wsFactory, width: 1280, height: 800, quality: 60 });
+    return { driver, endpoint, proc };
+}
+describe('createBrowserDriver (cbs-02)', () => {
+    it('start(url): attaches to the first page target and enables screencast, then navigates', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 'target-existing' });
+        await driver.start('https://example.com');
+        const methods = endpoint.sent.map((m) => m.method);
+        expect(methods).toEqual([
+            'Target.getTargets',
+            'Target.attachToTarget',
+            'Page.enable',
+            'Page.startScreencast',
+            'Page.navigate',
+        ]);
+        const attach = endpoint.sentCalls('Target.attachToTarget')[0];
+        expect(attach.params).toEqual({ targetId: 'target-existing', flatten: true });
+        const screencast = endpoint.sentCalls('Page.startScreencast')[0];
+        expect(screencast.sessionId).toBe('sess-1');
+        expect(screencast.params).toEqual({ format: 'jpeg', quality: 60, maxWidth: 1280, maxHeight: 800 });
+        const nav = endpoint.sentCalls('Page.navigate')[0];
+        expect(nav.params).toEqual({ url: 'https://example.com' });
+        expect(nav.sessionId).toBe('sess-1');
+    });
+    it('start(url): with no existing page target, creates one before attaching', async () => {
+        const { driver, endpoint } = setup(); // no existingPageTargetId -> empty target list
+        await driver.start('https://example.com');
+        const methods = endpoint.sent.map((m) => m.method);
+        expect(methods.slice(0, 2)).toEqual(['Target.getTargets', 'Target.createTarget']);
+        expect(endpoint.sentCalls('Target.attachToTarget')[0].params).toEqual({ targetId: 'target-new', flatten: true });
+    });
+    it('emits an "opening" state synchronously when start() begins', () => {
+        const { driver } = setup({ existingPageTargetId: 't1' });
+        const states = [];
+        driver.onState((s) => states.push(s));
+        void driver.start('https://example.com');
+        expect(states[0]).toEqual({ state: 'opening' });
+    });
+    it('screencast frames: acks CDP immediately and delivers through onFrame', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        const frames = [];
+        driver.onFrame((f) => frames.push(f));
+        await driver.start('https://example.com');
+        endpoint.emitEvent('Page.screencastFrame', { data: 'BASE64JPEG', sessionId: 42, metadata: { deviceWidth: 1280, deviceHeight: 800 } }, 'sess-1');
+        // CDP ack fires immediately (independent of the pacer/consumer ack).
+        const acks = endpoint.sentCalls('Page.screencastFrameAck');
+        expect(acks).toHaveLength(1);
+        expect(acks[0].params).toEqual({ sessionId: 42 });
+        expect(frames).toHaveLength(1);
+        expect(frames[0]).toEqual({ seq: 1, data: 'BASE64JPEG', w: 1280, h: 800 });
+        expect((0, browserFrames_1.isBrowserScreenFrame)({ t: 'browser-frame', sessionId: 'x', ...frames[0] })).toBe(true);
+    });
+    it('respects the cbs-01 keep-newest pacer under a slow consumer (mock consumer never acks)', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        const frames = [];
+        driver.onFrame((f) => frames.push(f));
+        await driver.start('https://example.com');
+        for (let i = 1; i <= 5; i++) {
+            endpoint.emitEvent('Page.screencastFrame', { data: `frame-${i}`, sessionId: i, metadata: {} }, 'sess-1');
+        }
+        // Only the first frame was delivered — the consumer never called ackFrame().
+        expect(frames.map((f) => f.data)).toEqual(['frame-1']);
+        // Every screencastFrame is CDP-acked regardless of pacer state.
+        expect(endpoint.sentCalls('Page.screencastFrameAck')).toHaveLength(5);
+        driver.ackFrame(); // consumer catches up -> newest queued frame (5) delivers
+        expect(frames.map((f) => f.data)).toEqual(['frame-1', 'frame-5']);
+        driver.ackFrame(); // nothing queued -> no-op
+        expect(frames.map((f) => f.data)).toEqual(['frame-1', 'frame-5']);
+    });
+    it('input: mouse down/up/move dispatch Input.dispatchMouseEvent with exact coords/button/modifiers', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        await driver.start('https://example.com');
+        driver.input({ kind: 'mouse', type: 'down', x: 10, y: 20, button: 'left', modifiers: { shift: true, ctrl: true } });
+        driver.input({ kind: 'mouse', type: 'move', x: 15, y: 25 });
+        driver.input({ kind: 'mouse', type: 'up', x: 10, y: 20, button: 'left' });
+        const calls = endpoint.sentCalls('Input.dispatchMouseEvent');
+        expect(calls).toHaveLength(3);
+        expect(calls[0]).toMatchObject({
+            sessionId: 'sess-1',
+            params: { type: 'mousePressed', x: 10, y: 20, button: 'left', clickCount: 1, modifiers: 10 }, // shift(8)+ctrl(2)
+        });
+        expect(calls[1]).toMatchObject({
+            params: { type: 'mouseMoved', x: 15, y: 25, button: 'none', clickCount: 0, modifiers: 0 },
+        });
+        expect(calls[2]).toMatchObject({
+            params: { type: 'mouseReleased', x: 10, y: 20, button: 'left', clickCount: 1, modifiers: 0 },
+        });
+    });
+    it('input: wheel dispatches Input.dispatchMouseEvent type mouseWheel with deltas', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        await driver.start('https://example.com');
+        driver.input({ kind: 'wheel', x: 5, y: 6, deltaX: 0, deltaY: 120 });
+        const calls = endpoint.sentCalls('Input.dispatchMouseEvent').filter((c) => c.params.type === 'mouseWheel');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].params).toEqual({ type: 'mouseWheel', x: 5, y: 6, deltaX: 0, deltaY: 120 });
+        expect(calls[0].sessionId).toBe('sess-1');
+    });
+    it('input: key down/up dispatch Input.dispatchKeyEvent with key/code and a modifiers bitmask', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        await driver.start('https://example.com');
+        driver.input({ kind: 'key', type: 'down', key: 'a', code: 'KeyA', modifiers: { meta: true, alt: true } });
+        driver.input({ kind: 'key', type: 'up', key: 'a', code: 'KeyA' });
+        const calls = endpoint.sentCalls('Input.dispatchKeyEvent');
+        expect(calls).toHaveLength(2);
+        expect(calls[0].params).toEqual({ type: 'keyDown', key: 'a', code: 'KeyA', modifiers: 5 }); // alt(1)+meta(4)
+        expect(calls[1].params).toEqual({ type: 'keyUp', key: 'a', code: 'KeyA', modifiers: 0 });
+        expect(calls[0].sessionId).toBe('sess-1');
+    });
+    it('input: insertText passes the text straight through to Input.insertText', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        await driver.start('https://example.com');
+        driver.input({ kind: 'insertText', text: 'hunter2' });
+        const calls = endpoint.sentCalls('Input.insertText');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].params).toEqual({ text: 'hunter2' });
+        expect(calls[0].sessionId).toBe('sess-1');
+    });
+    it('navigate(url) after start sends Page.navigate again on the attached target session', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        await driver.start('https://example.com');
+        endpoint.sent.length = 0;
+        await driver.navigate('https://example.com/page2');
+        const calls = endpoint.sentCalls('Page.navigate');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].params).toEqual({ url: 'https://example.com/page2' });
+        expect(calls[0].sessionId).toBe('sess-1');
+    });
+    it('back()/forward() read Page.getNavigationHistory then call Page.navigateToHistoryEntry with the right entry', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        endpoint.on('Page.getNavigationHistory', () => ({
+            currentIndex: 1,
+            entries: [{ id: 100 }, { id: 200 }, { id: 300 }],
+        }));
+        await driver.start('https://example.com');
+        endpoint.sent.length = 0;
+        await driver.back();
+        let calls = endpoint.sentCalls('Page.navigateToHistoryEntry');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].params).toEqual({ entryId: 100 });
+        expect(calls[0].sessionId).toBe('sess-1');
+        endpoint.sent.length = 0;
+        await driver.forward();
+        calls = endpoint.sentCalls('Page.navigateToHistoryEntry');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].params).toEqual({ entryId: 300 });
+    });
+    it('back() at the start of history is a no-op (no entry to navigate to)', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        endpoint.on('Page.getNavigationHistory', () => ({ currentIndex: 0, entries: [{ id: 100 }] }));
+        await driver.start('https://example.com');
+        endpoint.sent.length = 0;
+        await driver.back();
+        expect(endpoint.sentCalls('Page.navigateToHistoryEntry')).toHaveLength(0);
+    });
+    it('reload() sends Page.reload on the attached target session', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        await driver.start('https://example.com');
+        endpoint.sent.length = 0;
+        await driver.reload();
+        expect(endpoint.sentCalls('Page.reload')).toHaveLength(1);
+        expect(endpoint.sentCalls('Page.reload')[0].sessionId).toBe('sess-1');
+    });
+    it('Target.targetInfoChanged for the attached page emits onState open with url/title', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        const states = [];
+        driver.onState((s) => states.push(s));
+        await driver.start('https://example.com');
+        endpoint.emitEvent('Target.targetInfoChanged', { targetInfo: { targetId: 't1', url: 'https://example.com/', title: 'Example' } });
+        // An unrelated target's change must not surface as our session's state.
+        endpoint.emitEvent('Target.targetInfoChanged', { targetInfo: { targetId: 'other-target', url: 'https://evil.example/', title: 'Nope' } });
+        const openStates = states.filter((s) => s.state === 'open');
+        expect(openStates).toEqual([{ state: 'open', url: 'https://example.com/', title: 'Example' }]);
+        expect((0, browserFrames_1.isBrowserStateFrame)({ t: 'browser-state', sessionId: 'x', ...openStates[0] })).toBe(true);
+    });
+    it('transport close emits onState closed with a reason and never hangs', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        const states = [];
+        driver.onState((s) => states.push(s));
+        await driver.start('https://example.com');
+        endpoint.triggerClose({ code: 1006, reason: 'abnormal' });
+        await new Promise((r) => queueMicrotask(() => r()));
+        const closedStates = states.filter((s) => s.state === 'closed');
+        expect(closedStates).toHaveLength(1);
+        expect(closedStates[0].reason).toBeTruthy();
+    });
+    it('a crashed/exited Chromium process surfaces a closed state rather than hanging', async () => {
+        const { driver, proc } = setup({ existingPageTargetId: 't1' });
+        const states = [];
+        driver.onState((s) => states.push(s));
+        await driver.start('https://example.com');
+        proc.emitExit(1, null);
+        const closedStates = states.filter((s) => s.state === 'closed');
+        expect(closedStates).toHaveLength(1);
+        expect(closedStates[0].reason).toBeTruthy();
+    });
+    it('stop() kills the child process and closes the CDP transport; double-stop is safe', async () => {
+        const { driver, proc } = setup({ existingPageTargetId: 't1' });
+        await driver.start('https://example.com');
+        driver.stop();
+        expect(proc.killed).toBe(true);
+        expect(proc.killCount).toBe(1);
+        expect(() => driver.stop()).not.toThrow();
+        expect(proc.killCount).toBe(1); // second stop() did not kill again
+    });
+    it('stop() emits a closed state exactly once even though the transport also closes', async () => {
+        const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+        const states = [];
+        driver.onState((s) => states.push(s));
+        await driver.start('https://example.com');
+        driver.stop();
+        endpoint.triggerClose(); // the mock's close() no-ops after driver already closed it, but simulate a stray event
+        await new Promise((r) => queueMicrotask(() => r()));
+        expect(states.filter((s) => s.state === 'closed')).toHaveLength(1);
+    });
+    // cbs-06 — sleep() is the explicit-💤/idle-close teardown: same physical
+    // kill as stop(), but the wire state is 'asleep' (intentional, resumable)
+    // rather than 'closed' (terminal) — see browserFrames.ts's BrowserSessionState.
+    describe('sleep() (cbs-06)', () => {
+        it('kills the child process and closes the CDP transport, emitting asleep (not closed)', async () => {
+            const { driver, proc, endpoint } = setup({ existingPageTargetId: 't1' });
+            const states = [];
+            driver.onState((s) => states.push(s));
+            await driver.start('https://example.com');
+            endpoint.sent.length = 0;
+            driver.sleep();
+            expect(proc.killed).toBe(true);
+            expect(proc.killCount).toBe(1);
+            const terminal = states.filter((s) => s.state === 'asleep' || s.state === 'closed');
+            expect(terminal).toHaveLength(1);
+            expect(terminal[0].state).toBe('asleep');
+            expect(terminal[0].reason).toBeTruthy();
+            expect((0, browserFrames_1.isBrowserStateFrame)({ t: 'browser-state', sessionId: 'x', ...terminal[0] })).toBe(true);
+        });
+        it('double-sleep is a safe no-op (second call does not re-kill or re-emit)', async () => {
+            const { driver, proc } = setup({ existingPageTargetId: 't1' });
+            const states = [];
+            driver.onState((s) => states.push(s));
+            await driver.start('https://example.com');
+            driver.sleep();
+            expect(() => driver.sleep()).not.toThrow();
+            expect(proc.killCount).toBe(1);
+            expect(states.filter((s) => s.state === 'asleep')).toHaveLength(1);
+        });
+        it('sleep-of-nothing (never started) is a safe no-op that does not throw', () => {
+            const { driver } = setup({ existingPageTargetId: 't1' });
+            expect(() => driver.sleep()).not.toThrow();
+        });
+        it('sleep() then stop() emits only the first terminal state (asleep wins, no closed follows)', async () => {
+            const { driver, proc } = setup({ existingPageTargetId: 't1' });
+            const states = [];
+            driver.onState((s) => states.push(s));
+            await driver.start('https://example.com');
+            driver.sleep();
+            driver.stop();
+            expect(proc.killCount).toBe(1); // stop() after sleep() does not kill again
+            const terminal = states.filter((s) => s.state === 'asleep' || s.state === 'closed');
+            expect(terminal).toHaveLength(1);
+            expect(terminal[0].state).toBe('asleep');
+        });
+        it('stop() then sleep() emits only the first terminal state (closed wins, no asleep follows)', async () => {
+            const { driver, proc } = setup({ existingPageTargetId: 't1' });
+            const states = [];
+            driver.onState((s) => states.push(s));
+            await driver.start('https://example.com');
+            driver.stop();
+            driver.sleep();
+            expect(proc.killCount).toBe(1); // sleep() after stop() does not kill again
+            const terminal = states.filter((s) => s.state === 'asleep' || s.state === 'closed');
+            expect(terminal).toHaveLength(1);
+            expect(terminal[0].state).toBe('closed');
+        });
+        it('a genuine Chromium exit after sleep() does not add a second (closed) state frame', async () => {
+            const { driver, proc } = setup({ existingPageTargetId: 't1' });
+            const states = [];
+            driver.onState((s) => states.push(s));
+            await driver.start('https://example.com');
+            driver.sleep();
+            proc.emitExit(0, null); // process reaping fires after we already killed it
+            const terminal = states.filter((s) => s.state === 'asleep' || s.state === 'closed');
+            expect(terminal).toHaveLength(1);
+            expect(terminal[0].state).toBe('asleep');
+        });
+    });
+});

package/dist/__tests__/bridge-browser-frames.test.d.ts

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