@jackwener/opencli 1.0.0 → 1.0.3

package/dist/browser/cdp.js

@@ -0,0 +1,295 @@
+/**
+ * CDP client — implements IPage by connecting directly to a Chrome/Electron CDP WebSocket.
+ */
+import { WebSocket } from 'ws';
+import { wrapForEval } from './utils.js';
+export class CDPBridge {
+    _ws = null;
+    _idCounter = 0;
+    _pending = new Map();
+    async connect(opts) {
+        const endpoint = process.env.OPENCLI_CDP_ENDPOINT;
+        if (!endpoint)
+            throw new Error('OPENCLI_CDP_ENDPOINT is not set');
+        // If it's a direct ws:// URL, use it. Otherwise, fetch the /json endpoint to find a page.
+        let wsUrl = endpoint;
+        if (endpoint.startsWith('http')) {
+            const res = await fetch(`${endpoint.replace(/\/$/, '')}/json`);
+            if (!res.ok)
+                throw new Error(`Failed to fetch CDP targets: ${res.statusText}`);
+            const targets = await res.json();
+            const target = selectCDPTarget(targets);
+            if (!target || !target.webSocketDebuggerUrl) {
+                throw new Error('No inspectable targets found at CDP endpoint');
+            }
+            wsUrl = target.webSocketDebuggerUrl;
+        }
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(wsUrl);
+            const timeout = setTimeout(() => reject(new Error('CDP connect timeout')), opts?.timeout ?? 10000);
+            ws.on('open', () => {
+                clearTimeout(timeout);
+                this._ws = ws;
+                resolve(new CDPPage(this));
+            });
+            ws.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.id && this._pending.has(msg.id)) {
+                        const { resolve, reject } = this._pending.get(msg.id);
+                        this._pending.delete(msg.id);
+                        if (msg.error) {
+                            reject(new Error(msg.error.message));
+                        }
+                        else {
+                            resolve(msg.result);
+                        }
+                    }
+                }
+                catch (e) {
+                    // ignore parsing errors
+                }
+            });
+        });
+    }
+    async close() {
+        if (this._ws) {
+            this._ws.close();
+            this._ws = null;
+        }
+        for (const p of this._pending.values()) {
+            p.reject(new Error('CDP connection closed'));
+        }
+        this._pending.clear();
+    }
+    async send(method, params = {}) {
+        if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
+            throw new Error('CDP connection is not open');
+        }
+        const id = ++this._idCounter;
+        return new Promise((resolve, reject) => {
+            this._pending.set(id, { resolve, reject });
+            this._ws.send(JSON.stringify({ id, method, params }));
+        });
+    }
+}
+class CDPPage {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    async goto(url) {
+        await this.bridge.send('Page.navigate', { url });
+        await new Promise(r => setTimeout(r, 1000));
+    }
+    async evaluate(js) {
+        const expression = wrapForEval(js);
+        const result = await this.bridge.send('Runtime.evaluate', {
+            expression,
+            returnByValue: true,
+            awaitPromise: true
+        });
+        if (result.exceptionDetails) {
+            throw new Error('Evaluate error: ' + (result.exceptionDetails.exception?.description || 'Unknown exception'));
+        }
+        return result.result?.value;
+    }
+    async snapshot(opts) {
+        throw new Error('Method not implemented.');
+    }
+    async click(ref) {
+        const safeRef = JSON.stringify(ref);
+        const code = `
+      (() => {
+        const ref = ${safeRef};
+        const el = document.querySelector('[data-ref="' + ref + '"]')
+          || document.querySelectorAll('a, button, input, [role="button"], [tabindex]')[parseInt(ref, 10) || 0];
+        if (!el) throw new Error('Element not found: ' + ref);
+        el.scrollIntoView({ behavior: 'instant', block: 'center' });
+        el.click();
+        return 'clicked';
+      })()
+    `;
+        await this.evaluate(code);
+    }
+    async typeText(ref, text) {
+        const safeRef = JSON.stringify(ref);
+        const safeText = JSON.stringify(text);
+        const code = `
+      (() => {
+        const ref = ${safeRef};
+        const el = document.querySelector('[data-ref="' + ref + '"]')
+          || document.querySelectorAll('input, textarea, [contenteditable]')[parseInt(ref, 10) || 0];
+        if (!el) throw new Error('Element not found: ' + ref);
+        el.focus();
+        el.value = ${safeText};
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+        return 'typed';
+      })()
+    `;
+        await this.evaluate(code);
+    }
+    async pressKey(key) {
+        const code = `
+      (() => {
+        const el = document.activeElement || document.body;
+        el.dispatchEvent(new KeyboardEvent('keydown', { key: ${JSON.stringify(key)}, bubbles: true }));
+        el.dispatchEvent(new KeyboardEvent('keyup', { key: ${JSON.stringify(key)}, bubbles: true }));
+        return 'pressed';
+      })()
+    `;
+        await this.evaluate(code);
+    }
+    async wait(options) {
+        if (typeof options === 'number') {
+            await new Promise(resolve => setTimeout(resolve, options * 1000));
+            return;
+        }
+        if (options.time) {
+            await new Promise(resolve => setTimeout(resolve, options.time * 1000));
+            return;
+        }
+        if (options.text) {
+            const timeout = (options.timeout ?? 30) * 1000;
+            const code = `
+        new Promise((resolve, reject) => {
+          const deadline = Date.now() + ${timeout};
+          const check = () => {
+            if (document.body.innerText.includes(${JSON.stringify(options.text)})) return resolve('found');
+            if (Date.now() > deadline) return reject(new Error('Text not found: ' + ${JSON.stringify(options.text)}));
+            setTimeout(check, 200);
+          };
+          check();
+        })
+      `;
+            await this.evaluate(code);
+        }
+    }
+    async tabs() {
+        throw new Error('Method not implemented.');
+    }
+    async closeTab(index) {
+        throw new Error('Method not implemented.');
+    }
+    async newTab() {
+        throw new Error('Method not implemented.');
+    }
+    async selectTab(index) {
+        throw new Error('Method not implemented.');
+    }
+    async networkRequests(includeStatic) {
+        throw new Error('Method not implemented.');
+    }
+    async consoleMessages(level) {
+        throw new Error('Method not implemented.');
+    }
+    async scroll(direction, amount) {
+        throw new Error('Method not implemented.');
+    }
+    async autoScroll(options) {
+        throw new Error('Method not implemented.');
+    }
+    async installInterceptor(pattern) {
+        throw new Error('Method not implemented.');
+    }
+    async getInterceptedRequests() {
+        throw new Error('Method not implemented.');
+    }
+    async screenshot(options) {
+        throw new Error('Method not implemented.');
+    }
+}
+function selectCDPTarget(targets) {
+    const preferredPattern = compilePreferredPattern(process.env.OPENCLI_CDP_TARGET);
+    const ranked = targets
+        .map((target, index) => ({ target, index, score: scoreCDPTarget(target, preferredPattern) }))
+        .filter(({ score }) => Number.isFinite(score))
+        .sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return a.index - b.index;
+    });
+    return ranked[0]?.target;
+}
+function scoreCDPTarget(target, preferredPattern) {
+    if (!target.webSocketDebuggerUrl)
+        return Number.NEGATIVE_INFINITY;
+    const type = (target.type ?? '').toLowerCase();
+    const url = (target.url ?? '').toLowerCase();
+    const title = (target.title ?? '').toLowerCase();
+    const haystack = `${title} ${url}`;
+    if (!haystack.trim() && !type)
+        return Number.NEGATIVE_INFINITY;
+    if (haystack.includes('devtools'))
+        return Number.NEGATIVE_INFINITY;
+    let score = 0;
+    if (preferredPattern && preferredPattern.test(haystack))
+        score += 1000;
+    if (type === 'app')
+        score += 120;
+    else if (type === 'webview')
+        score += 100;
+    else if (type === 'page')
+        score += 80;
+    else if (type === 'iframe')
+        score += 20;
+    if (url.startsWith('http://localhost') || url.startsWith('https://localhost'))
+        score += 90;
+    if (url.startsWith('file://'))
+        score += 60;
+    if (url.startsWith('http://127.0.0.1') || url.startsWith('https://127.0.0.1'))
+        score += 50;
+    if (url.startsWith('about:blank'))
+        score -= 120;
+    if (url === '' || url === 'about:blank')
+        score -= 40;
+    if (title && title !== 'devtools')
+        score += 25;
+    if (title.includes('antigravity'))
+        score += 120;
+    if (title.includes('codex'))
+        score += 120;
+    if (title.includes('cursor'))
+        score += 120;
+    if (title.includes('chatwise'))
+        score += 120;
+    if (title.includes('notion'))
+        score += 120;
+    if (title.includes('discord'))
+        score += 120;
+    if (title.includes('netease'))
+        score += 120;
+    if (url.includes('antigravity'))
+        score += 100;
+    if (url.includes('codex'))
+        score += 100;
+    if (url.includes('cursor'))
+        score += 100;
+    if (url.includes('chatwise'))
+        score += 100;
+    if (url.includes('notion'))
+        score += 100;
+    if (url.includes('discord'))
+        score += 100;
+    if (url.includes('netease'))
+        score += 100;
+    return score;
+}
+function compilePreferredPattern(raw) {
+    const value = raw?.trim();
+    if (!value)
+        return undefined;
+    return new RegExp(escapeRegExp(value.toLowerCase()));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export const __test__ = {
+    selectCDPTarget,
+    scoreCDPTarget,
+};

package/dist/browser/daemon-client.d.ts

@@ -5,7 +5,7 @@
  */
 export interface DaemonCommand {
     id: string;
-    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot';
+    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window';
     tabId?: number;
     code?: string;
     url?: string;

package/dist/browser/index.d.ts

@@ -5,9 +5,9 @@
  * External code should import from './browser/index.js' (or './browser.js' via Node resolution).
  */
 export { Page } from './page.js';
-export { PlaywrightMCP } from './mcp.js';
+export { BrowserBridge, BrowserBridge as PlaywrightMCP } from './mcp.js';
+export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
-export declare function getTokenFingerprint(_token: string | undefined): string | null;
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
 import { withTimeoutMs } from '../runtime.js';
 export declare const __test__: {
@@ -15,4 +15,6 @@ export declare const __test__: {
     diffTabIndexes: typeof diffTabIndexes;
     appendLimited: typeof appendLimited;
     withTimeoutMs: typeof withTimeoutMs;
+    selectCDPTarget: (targets: import("./cdp.js").CDPTarget[]) => import("./cdp.js").CDPTarget | undefined;
+    scoreCDPTarget: (target: import("./cdp.js").CDPTarget, preferredPattern?: RegExp) => number;
 };

package/dist/browser/index.js

@@ -5,17 +5,17 @@
  * External code should import from './browser/index.js' (or './browser.js' via Node resolution).
  */
 export { Page } from './page.js';
-export { PlaywrightMCP } from './mcp.js';
+export { BrowserBridge, BrowserBridge as PlaywrightMCP } from './mcp.js';
+export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
-// Backward compatibility: getTokenFingerprint is no longer needed but kept as no-op export
-export function getTokenFingerprint(_token) {
-    return null;
-}
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
+import { __test__ as cdpTest } from './cdp.js';
 import { withTimeoutMs } from '../runtime.js';
 export const __test__ = {
     extractTabEntries,
     diffTabIndexes,
     appendLimited,
     withTimeoutMs,
+    selectCDPTarget: cdpTest.selectCDPTarget,
+    scoreCDPTarget: cdpTest.scoreCDPTarget,
 };

package/dist/browser/mcp.d.ts

@@ -1,24 +1,21 @@
 /**
  * Browser session manager — auto-spawns daemon and provides IPage.
- *
- * Replaces the old PlaywrightMCP class. Still exports as PlaywrightMCP
- * for backward compatibility with main.ts and other consumers.
  */
 import type { IPage } from '../types.js';
-export type PlaywrightMCPState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
+export type BrowserBridgeState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
- *
- * Kept as `PlaywrightMCP` class name for backward compatibility.
  */
-export declare class PlaywrightMCP {
+export declare class BrowserBridge {
     private _state;
     private _page;
     private _daemonProc;
-    get state(): PlaywrightMCPState;
+    get state(): BrowserBridgeState;
     connect(opts?: {
         timeout?: number;
     }): Promise<IPage>;
     close(): Promise<void>;
     private _ensureDaemon;
 }
+/** @deprecated Use BrowserBridge instead */
+export declare const PlaywrightMCP: typeof BrowserBridge;

package/dist/browser/mcp.js

@@ -1,8 +1,5 @@
 /**
  * Browser session manager — auto-spawns daemon and provides IPage.
- *
- * Replaces the old PlaywrightMCP class. Still exports as PlaywrightMCP
- * for backward compatibility with main.ts and other consumers.
  */
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
@@ -13,10 +10,8 @@ import { isDaemonRunning, isExtensionConnected } from './daemon-client.js';
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
- *
- * Kept as `PlaywrightMCP` class name for backward compatibility.
  */
-export class PlaywrightMCP {
+export class BrowserBridge {
     _state = 'idle';
     _page = null;
     _daemonProc = null;
@@ -68,10 +63,12 @@ export class PlaywrightMCP {
         if (process.env.OPENCLI_VERBOSE) {
             console.error(`[opencli] Starting daemon (${isTs ? 'ts' : 'js'})...`);
         }
-        // Use the current runtime to spawn daemon — avoids slow npx resolution.
-        // If already running under tsx (dev), process.execPath is tsx's node.
-        // If running compiled (node dist/), process.execPath is node.
-        this._daemonProc = spawn(process.execPath, [daemonPath], {
+        // For compiled .js, use the current node binary directly (fast).
+        // For .ts dev mode, node can't run .ts files — use tsx via --import.
+        const spawnArgs = isTs
+            ? [process.execPath, '--import', 'tsx/esm', daemonPath]
+            : [process.execPath, daemonPath];
+        this._daemonProc = spawn(spawnArgs[0], spawnArgs.slice(1), {
             detached: true,
             stdio: 'ignore',
             env: { ...process.env },
@@ -94,3 +91,5 @@ export class PlaywrightMCP {
             'Make sure port 19825 is available.');
     }
 }
+/** @deprecated Use BrowserBridge instead */
+export const PlaywrightMCP = BrowserBridge;

package/dist/browser/page.d.ts

@@ -19,6 +19,8 @@ export declare class Page implements IPage {
     /** Helper: spread tabId into command params if we have one */
     private _tabOpt;
     goto(url: string): Promise<void>;
+    /** Close the automation window in the extension */
+    closeWindow(): Promise<void>;
     evaluate(js: string): Promise<any>;
     snapshot(opts?: {
         interactive?: boolean;
@@ -39,7 +41,12 @@ export declare class Page implements IPage {
     newTab(): Promise<void>;
     selectTab(index: number): Promise<void>;
     networkRequests(includeStatic?: boolean): Promise<any>;
-    consoleMessages(level?: string): Promise<any>;
+    /**
+     * Console messages are not available in lightweight daemon mode.
+     * Would require CDP Runtime.consoleAPICalled event listener.
+     * @returns Always returns empty array.
+     */
+    consoleMessages(_level?: string): Promise<any>;
     /**
      * Capture a screenshot via CDP Page.captureScreenshot.
      * @param options.format - 'png' (default) or 'jpeg'

package/dist/browser/page.js

@@ -11,6 +11,7 @@
  */
 import { formatSnapshot } from '../snapshotFormatter.js';
 import { sendCommand } from './daemon-client.js';
+import { wrapForEval } from './utils.js';
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
@@ -31,6 +32,15 @@ export class Page {
             this._tabId = result.tabId;
         }
     }
+    /** Close the automation window in the extension */
+    async closeWindow() {
+        try {
+            await sendCommand('close-window', {});
+        }
+        catch {
+            // Window may already be closed or daemon may be down
+        }
+    }
     async evaluate(js) {
         const code = wrapForEval(js);
         return sendCommand('exec', { code, ...this._tabOpt() });
@@ -168,12 +178,12 @@ export class Page {
     `;
         return sendCommand('exec', { code, ...this._tabOpt() });
     }
-    async consoleMessages(level = 'info') {
-        // Console messages can't be retrospectively read via CDP Runtime.evaluate.
-        // Would need Runtime.consoleAPICalled event listener, which is not yet implemented.
-        if (process.env.OPENCLI_VERBOSE) {
-            console.error('[page] consoleMessages() not supported in lightweight mode — returning empty');
-        }
+    /**
+     * Console messages are not available in lightweight daemon mode.
+     * Would require CDP Runtime.consoleAPICalled event listener.
+     * @returns Always returns empty array.
+     */
+    async consoleMessages(_level = 'info') {
         return [];
     }
     /**
@@ -234,43 +244,18 @@ export class Page {
     }
     async installInterceptor(pattern) {
         const { generateInterceptorJs } = await import('../interceptor.js');
-        await sendCommand('exec', {
-            code: generateInterceptorJs(JSON.stringify(pattern), {
-                arrayName: '__opencli_xhr',
-                patchGuard: '__opencli_interceptor_patched',
-            }),
-            ...this._tabOpt(),
-        });
+        // Must use evaluate() so wrapForEval() converts the arrow function into an IIFE;
+        // sendCommand('exec') sends the code as-is, and CDP never executes a bare arrow.
+        await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {
+            arrayName: '__opencli_xhr',
+            patchGuard: '__opencli_interceptor_patched',
+        }));
     }
     async getInterceptedRequests() {
         const { generateReadInterceptedJs } = await import('../interceptor.js');
-        const result = await sendCommand('exec', {
-            code: generateReadInterceptedJs('__opencli_xhr'),
-            ...this._tabOpt(),
-        });
+        // Same as installInterceptor: must go through evaluate() for IIFE wrapping
+        const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
         return result || [];
     }
 }
-// ─── Helpers ─────────────────────────────────────────────────────────
-/**
- * Wrap JS code for CDP Runtime.evaluate:
- * - Already an IIFE `(...)()` → send as-is
- * - Arrow/function literal → wrap as IIFE `(code)()`
- * - `new Promise(...)` or raw expression → send as-is (expression)
- */
-function wrapForEval(js) {
-    const code = js.trim();
-    if (!code)
-        return 'undefined';
-    // Already an IIFE: `(async () => { ... })()` or `(function() {...})()`
-    if (/^\([\s\S]*\)\s*\(.*\)\s*$/.test(code))
-        return code;
-    // Arrow function: `() => ...` or `async () => ...`
-    if (/^(async\s+)?(\([^)]*\)|[A-Za-z_]\w*)\s*=>/.test(code))
-        return `(${code})()`;
-    // Function declaration: `function ...` or `async function ...`
-    if (/^(async\s+)?function[\s(]/.test(code))
-        return `(${code})()`;
-    // Everything else: bare expression, `new Promise(...)`, etc. → evaluate directly
-    return code;
-}
+// (End of file)

package/dist/browser/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utility functions for browser operations
+ */
+/**
+ * Wrap JS code for CDP Runtime.evaluate:
+ * - Already an IIFE `(...)()` → send as-is
+ * - Arrow/function literal → wrap as IIFE `(code)()`
+ * - `new Promise(...)` or raw expression → send as-is (expression)
+ */
+export declare function wrapForEval(js: string): string;

package/dist/browser/utils.js

@@ -0,0 +1,27 @@
+/**
+ * Utility functions for browser operations
+ */
+/**
+ * Wrap JS code for CDP Runtime.evaluate:
+ * - Already an IIFE `(...)()` → send as-is
+ * - Arrow/function literal → wrap as IIFE `(code)()`
+ * - `new Promise(...)` or raw expression → send as-is (expression)
+ */
+export function wrapForEval(js) {
+    if (typeof js !== 'string')
+        return 'undefined';
+    const code = js.trim();
+    if (!code)
+        return 'undefined';
+    // Already an IIFE: `(async () => { ... })()` or `(function() {...})()`
+    if (/^\([\s\S]*\)\s*\(.*\)\s*$/.test(code))
+        return code;
+    // Arrow function: `() => ...` or `async () => ...`
+    if (/^(async\s+)?(\([^)]*\)|[A-Za-z_]\w*)\s*=>/.test(code))
+        return `(${code})()`;
+    // Function declaration: `function ...` or `async function ...`
+    if (/^(async\s+)?function[\s(]/.test(code))
+        return `(${code})()`;
+    // Everything else: bare expression, `new Promise(...)`, etc. → evaluate directly
+    return code;
+}

package/dist/browser.test.js

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest';
-import { PlaywrightMCP, __test__ } from './browser/index.js';
+import { describe, it, expect, vi } from 'vitest';
+import { BrowserBridge, __test__ } from './browser/index.js';
 describe('browser helpers', () => {
     it('extracts tab entries from string snapshots', () => {
         const entries = __test__.extractTabEntries('Tab 0 https://example.com\nTab 1 Chrome Extension');
@@ -30,26 +30,67 @@ describe('browser helpers', () => {
     it('times out slow promises', async () => {
         await expect(__test__.withTimeoutMs(new Promise(() => { }), 10, 'timeout')).rejects.toThrow('timeout');
     });
+    it('prefers the real Electron app target over DevTools and blank pages', () => {
+        const target = __test__.selectCDPTarget([
+            {
+                type: 'page',
+                title: 'DevTools - localhost:9224',
+                url: 'devtools://devtools/bundled/inspector.html',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/devtools',
+            },
+            {
+                type: 'page',
+                title: '',
+                url: 'about:blank',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/blank',
+            },
+            {
+                type: 'app',
+                title: 'Antigravity',
+                url: 'http://localhost:3000/',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9224/app',
+            },
+        ]);
+        expect(target?.webSocketDebuggerUrl).toBe('ws://127.0.0.1:9224/app');
+    });
+    it('honors OPENCLI_CDP_TARGET when multiple inspectable targets exist', () => {
+        vi.stubEnv('OPENCLI_CDP_TARGET', 'codex');
+        const target = __test__.selectCDPTarget([
+            {
+                type: 'app',
+                title: 'Cursor',
+                url: 'http://localhost:3000/cursor',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9226/cursor',
+            },
+            {
+                type: 'app',
+                title: 'OpenAI Codex',
+                url: 'http://localhost:3000/codex',
+                webSocketDebuggerUrl: 'ws://127.0.0.1:9226/codex',
+            },
+        ]);
+        expect(target?.webSocketDebuggerUrl).toBe('ws://127.0.0.1:9226/codex');
+    });
 });
-describe('PlaywrightMCP state', () => {
+describe('BrowserBridge state', () => {
     it('transitions to closed after close()', async () => {
-        const mcp = new PlaywrightMCP();
+        const mcp = new BrowserBridge();
         expect(mcp.state).toBe('idle');
         await mcp.close();
         expect(mcp.state).toBe('closed');
     });
     it('rejects connect() after the session has been closed', async () => {
-        const mcp = new PlaywrightMCP();
+        const mcp = new BrowserBridge();
         await mcp.close();
         await expect(mcp.connect()).rejects.toThrow('Session is closed');
     });
     it('rejects connect() while already connecting', async () => {
-        const mcp = new PlaywrightMCP();
+        const mcp = new BrowserBridge();
         mcp._state = 'connecting';
         await expect(mcp.connect()).rejects.toThrow('Already connecting');
     });
     it('rejects connect() while closing', async () => {
-        const mcp = new PlaywrightMCP();
+        const mcp = new BrowserBridge();
         mcp._state = 'closing';
         await expect(mcp.connect()).rejects.toThrow('Session is closing');
     });