@jackwener/opencli 1.5.8 → 1.6.0

package/src/browser/daemon-client.ts

@@ -7,9 +7,11 @@
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import type { BrowserSessionInfo } from '../types.js';
 import { sleep } from '../utils.js';
+import { isTransientBrowserError } from './errors.js';
 
 const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
+const OPENCLI_HEADERS = { 'X-OpenCLI': '1' };
 
 let _idCounter = 0;
 
@@ -19,7 +21,7 @@ function generateId(): string {
 
 export interface DaemonCommand {
   id: string;
-  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'bind-current';
+  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'cdp';
   tabId?: number;
   code?: string;
   workspace?: string;
@@ -27,15 +29,16 @@ export interface DaemonCommand {
   op?: string;
   index?: number;
   domain?: string;
-  matchDomain?: string;
-  matchPathPrefix?: string;
   format?: 'png' | 'jpeg';
   quality?: number;
   fullPage?: boolean;
+
   /** Local file paths for set-file-input action */
   files?: string[];
   /** CSS selector for file input element (set-file-input action) */
   selector?: string;
+  cdpMethod?: string;
+  cdpParams?: Record<string, unknown>;
 }
 
 export interface DaemonResult {
@@ -45,42 +48,65 @@ export interface DaemonResult {
   error?: string;
 }
 
-/**
- * Check if daemon is running.
- */
-export async function isDaemonRunning(): Promise<boolean> {
+export interface DaemonStatus {
+  ok: boolean;
+  pid: number;
+  uptime: number;
+  extensionConnected: boolean;
+  extensionVersion?: string;
+  pending: number;
+  lastCliRequestTime: number;
+  memoryMB: number;
+  port: number;
+}
+
+async function requestDaemon(pathname: string, init?: RequestInit & { timeout?: number }): Promise<Response> {
+  const { timeout = 2000, headers, ...rest } = init ?? {};
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
   try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 2000);
-    const res = await fetch(`${DAEMON_URL}/status`, {
-      headers: { 'X-OpenCLI': '1' },
+    return await fetch(`${DAEMON_URL}${pathname}`, {
+      ...rest,
+      headers: { ...OPENCLI_HEADERS, ...headers },
       signal: controller.signal,
     });
+  } finally {
     clearTimeout(timer);
+  }
+}
+
+export async function fetchDaemonStatus(opts?: { timeout?: number }): Promise<DaemonStatus | null> {
+  try {
+    const res = await requestDaemon('/status', { timeout: opts?.timeout ?? 2000 });
+    if (!res.ok) return null;
+    return await res.json() as DaemonStatus;
+  } catch {
+    return null;
+  }
+}
+
+export async function requestDaemonShutdown(opts?: { timeout?: number }): Promise<boolean> {
+  try {
+    const res = await requestDaemon('/shutdown', { method: 'POST', timeout: opts?.timeout ?? 5000 });
     return res.ok;
   } catch {
     return false;
   }
 }
 
+/**
+ * Check if daemon is running.
+ */
+export async function isDaemonRunning(): Promise<boolean> {
+  return (await fetchDaemonStatus()) !== null;
+}
+
 /**
  * Check if daemon is running AND the extension is connected.
  */
 export async function isExtensionConnected(): Promise<boolean> {
-  try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 2000);
-    const res = await fetch(`${DAEMON_URL}/status`, {
-      headers: { 'X-OpenCLI': '1' },
-      signal: controller.signal,
-    });
-    clearTimeout(timer);
-    if (!res.ok) return false;
-    const data = await res.json() as { extensionConnected?: boolean };
-    return !!data.extensionConnected;
-  } catch {
-    return false;
-  }
+  const status = await fetchDaemonStatus();
+  return !!status?.extensionConnected;
 }
 
 /**
@@ -99,27 +125,18 @@ export async function sendCommand(
     const id = generateId();
     const command: DaemonCommand = { id, action, ...params };
     try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), 30000);
-
-      const res = await fetch(`${DAEMON_URL}/command`, {
+      const res = await requestDaemon('/command', {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'X-OpenCLI': '1' },
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(command),
-        signal: controller.signal,
+        timeout: 30000,
       });
-      clearTimeout(timer);
 
       const result = (await res.json()) as DaemonResult;
 
       if (!result.ok) {
         // Check if error is a transient extension issue worth retrying
-        const errMsg = result.error ?? '';
-        const isTransient = errMsg.includes('Extension disconnected')
-          || errMsg.includes('Extension not connected')
-          || errMsg.includes('attach failed')
-          || errMsg.includes('no longer exists');
-        if (isTransient && attempt < maxRetries) {
+        if (isTransientBrowserError(new Error(result.error ?? '')) && attempt < maxRetries) {
           // Longer delay for extension recovery (service worker restart)
           await sleep(1500);
           continue;
@@ -146,8 +163,3 @@ export async function listSessions(): Promise<BrowserSessionInfo[]> {
   const result = await sendCommand('sessions');
   return Array.isArray(result) ? result : [];
 }
-
-export async function bindCurrentTab(workspace: string, opts: { matchDomain?: string; matchPathPrefix?: string } = {}): Promise<unknown> {
-  return sendCommand('bind-current', { workspace, ...opts });
-}
-

package/src/browser/discover.ts

@@ -1,12 +1,8 @@
 /**
- * Daemon discovery — simplified from MCP server path discovery.
- *
- * Only needs to check if the daemon is running. No more file system
- * scanning for @playwright/mcp locations.
+ * Daemon discovery — checks if the daemon is running.
  */
 
-import { DEFAULT_DAEMON_PORT } from '../constants.js';
-import { isDaemonRunning } from './daemon-client.js';
+import { fetchDaemonStatus, isDaemonRunning } from './daemon-client.js';
 
 export { isDaemonRunning };
 
@@ -18,21 +14,13 @@ export async function checkDaemonStatus(opts?: { timeout?: number }): Promise<{
   extensionConnected: boolean;
   extensionVersion?: string;
 }> {
-  try {
-    const port = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), opts?.timeout ?? 2000);
-    try {
-      const res = await fetch(`http://127.0.0.1:${port}/status`, {
-        headers: { 'X-OpenCLI': '1' },
-        signal: controller.signal,
-      });
-      const data = await res.json() as { ok: boolean; extensionConnected: boolean; extensionVersion?: string };
-      return { running: true, extensionConnected: data.extensionConnected, extensionVersion: data.extensionVersion };
-    } finally {
-      clearTimeout(timer);
-    }
-  } catch {
+  const status = await fetchDaemonStatus({ timeout: opts?.timeout ?? 2000 });
+  if (!status) {
     return { running: false, extensionConnected: false };
   }
+  return {
+    running: true,
+    extensionConnected: status.extensionConnected,
+    extensionVersion: status.extensionVersion,
+  };
 }

package/src/browser/errors.ts

@@ -8,6 +8,28 @@
 import { BrowserConnectError, type BrowserConnectKind } from '../errors.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 
+/**
+ * Transient browser error patterns — shared across daemon-client, pipeline executor,
+ * and page retry logic. These errors indicate temporary conditions (extension restart,
+ * service worker cycle, tab navigation) that are worth retrying.
+ */
+const TRANSIENT_ERROR_PATTERNS = [
+  'Extension disconnected',
+  'Extension not connected',
+  'attach failed',
+  'no longer exists',
+  'CDP connection',
+  'Daemon command failed',
+] as const;
+
+/**
+ * Check if an error message indicates a transient browser error worth retrying.
+ */
+export function isTransientBrowserError(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  return TRANSIENT_ERROR_PATTERNS.some(pattern => msg.includes(pattern));
+}
+
 // Re-export so callers don't need to import from two places
 export type ConnectFailureKind = BrowserConnectKind;
 

package/src/browser/index.ts

@@ -6,7 +6,7 @@
  */
 
 export { Page } from './page.js';
-export { BrowserBridge } from './mcp.js';
+export { BrowserBridge } from './bridge.js';
 export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';

package/src/browser/page.ts

@@ -10,25 +10,13 @@
  * chrome-extension:// tab that can't be debugged.
  */
 
-import { formatSnapshot } from '../snapshotFormatter.js';
-import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
+import type { BrowserCookie, ScreenshotOptions } from '../types.js';
 import { sendCommand } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
 import { saveBase64ToFile } from '../utils.js';
-import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 import { generateStealthJs } from './stealth.js';
-import {
-  clickJs,
-  typeTextJs,
-  pressKeyJs,
-  waitForTextJs,
-  waitForCaptureJs,
-  waitForSelectorJs,
-  scrollJs,
-  autoScrollJs,
-  networkRequestsJs,
-  waitForDomStableJs,
-} from './dom-helpers.js';
+import { waitForDomStableJs } from './dom-helpers.js';
+import { BasePage } from './base-page.js';
 
 export function isRetryableSettleError(err: unknown): boolean {
   const message = err instanceof Error ? err.message : String(err);
@@ -39,13 +27,13 @@ export function isRetryableSettleError(err: unknown): boolean {
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
-export class Page implements IPage {
-  constructor(private readonly workspace: string = 'default') {}
+export class Page extends BasePage {
+  constructor(private readonly workspace: string = 'default') {
+    super();
+  }
 
   /** Active tab ID, set after navigate and used in all subsequent commands */
   private _tabId: number | undefined;
-  /** Last navigated URL, tracked in-memory to avoid extra round-trips */
-  private _lastUrl: string | null = null;
 
   /** Helper: spread workspace into command params */
   private _wsOpt(): { workspace: string } {
@@ -107,27 +95,8 @@ export class Page implements IPage {
     }
   }
 
-  async getCurrentUrl(): Promise<string | null> {
-    if (this._lastUrl) return this._lastUrl;
-    try {
-      const current = await this.evaluate('window.location.href');
-      if (typeof current === 'string' && current) {
-        this._lastUrl = current;
-        return current;
-      }
-    } catch {
-      // Best-effort: some commands may run before a debuggable tab is ready.
-    }
-    return null;
-  }
-
-  /** Close the automation window in the extension */
-  async closeWindow(): Promise<void> {
-    try {
-      await sendCommand('close-window', { ...this._wsOpt() });
-    } catch {
-      // Window may already be closed or daemon may be down
-    }
+  getActiveTabId(): number | undefined {
+    return this._tabId;
   }
 
   async evaluate(js: string): Promise<unknown> {
@@ -146,124 +115,12 @@ export class Page implements IPage {
     return Array.isArray(result) ? result : [];
   }
 
-  async snapshot(opts: SnapshotOptions = {}): Promise<unknown> {
-    // Primary: use the advanced DOM snapshot engine with multi-layer pruning
-    const snapshotJs = generateSnapshotJs({
-      viewportExpand: opts.viewportExpand ?? 800,
-      maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
-      interactiveOnly: opts.interactive ?? false,
-      maxTextLength: opts.maxTextLength ?? 120,
-      includeScrollInfo: true,
-      bboxDedup: true,
-    });
-
+  /** Close the automation window in the extension */
+  async closeWindow(): Promise<void> {
     try {
-      const result = await sendCommand('exec', { code: snapshotJs, ...this._cmdOpts() });
-      // The advanced engine already produces a clean, pruned, LLM-friendly output.
-      // Do NOT pass through formatSnapshot — its format is incompatible.
-      return result;
+      await sendCommand('close-window', { ...this._wsOpt() });
     } catch {
-      // Fallback: basic DOM snapshot (original implementation)
-      return this._basicSnapshot(opts);
-    }
-  }
-
-  /** Fallback basic snapshot — original buildTree approach */
-  private async _basicSnapshot(opts: Pick<SnapshotOptions, 'interactive' | 'compact' | 'maxDepth' | 'raw'> = {}): Promise<unknown> {
-    const maxDepth = Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200));
-    const code = `
-      (async () => {
-        function buildTree(node, depth) {
-          if (depth > ${maxDepth}) return '';
-          const role = node.getAttribute?.('role') || node.tagName?.toLowerCase() || 'generic';
-          const name = node.getAttribute?.('aria-label') || node.getAttribute?.('alt') || node.textContent?.trim().slice(0, 80) || '';
-          const isInteractive = ['a', 'button', 'input', 'select', 'textarea'].includes(node.tagName?.toLowerCase()) || node.getAttribute?.('tabindex') != null;
-
-          ${opts.interactive ? 'if (!isInteractive && !node.children?.length) return "";' : ''}
-
-          let indent = '  '.repeat(depth);
-          let line = indent + role;
-          if (name) line += ' "' + name.replace(/"/g, '\\\\\\"') + '"';
-          if (node.tagName?.toLowerCase() === 'a' && node.href) line += ' [' + node.href + ']';
-          if (node.tagName?.toLowerCase() === 'input') line += ' [' + (node.type || 'text') + ']';
-
-          let result = line + '\\n';
-          if (node.children) {
-            for (const child of node.children) {
-              result += buildTree(child, depth + 1);
-            }
-          }
-          return result;
-        }
-        return buildTree(document.body, 0);
-      })()
-    `;
-    const raw = await sendCommand('exec', { code, ...this._cmdOpts() });
-    if (opts.raw) return raw;
-    if (typeof raw === 'string') return formatSnapshot(raw, opts);
-    return raw;
-  }
-
-  async click(ref: string): Promise<void> {
-    const code = clickJs(ref);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async typeText(ref: string, text: string): Promise<void> {
-    const code = typeTextJs(ref, text);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async pressKey(key: string): Promise<void> {
-    const code = pressKeyJs(key);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async scrollTo(ref: string): Promise<unknown> {
-    const code = scrollToRefJs(ref);
-    return sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async getFormState(): Promise<Record<string, unknown>> {
-    const code = getFormStateJs();
-    return (await sendCommand('exec', { code, ...this._cmdOpts() })) as Record<string, unknown>;
-  }
-
-  async wait(options: number | WaitOptions): Promise<void> {
-    if (typeof options === 'number') {
-      if (options >= 1) {
-        // For waits >= 1s, use DOM-stable check: return early when the page
-        // stops mutating, with the original wait time as the hard cap.
-        // This turns e.g. `page.wait(5)` from a fixed 5s sleep into
-        // "wait until DOM is stable, max 5s" — often completing in <1s.
-        try {
-          const maxMs = options * 1000;
-          await sendCommand('exec', {
-            code: waitForDomStableJs(maxMs, Math.min(500, maxMs)),
-            ...this._cmdOpts(),
-          });
-          return;
-        } catch {
-          // Fallback: fixed sleep (e.g. if page has no DOM yet)
-        }
-      }
-      await new Promise(resolve => setTimeout(resolve, options * 1000));
-      return;
-    }
-    if (typeof options.time === 'number') {
-      await new Promise(resolve => setTimeout(resolve, options.time! * 1000));
-      return;
-    }
-    if (options.selector) {
-      const timeout = (options.timeout ?? 10) * 1000;
-      const code = waitForSelectorJs(options.selector, timeout);
-      await sendCommand('exec', { code, ...this._cmdOpts() });
-      return;
-    }
-    if (options.text) {
-      const timeout = (options.timeout ?? 30) * 1000;
-      const code = waitForTextJs(options.text, timeout);
-      await sendCommand('exec', { code, ...this._cmdOpts() });
+      // Window may already be closed or daemon may be down
     }
   }
 
@@ -289,27 +146,8 @@ export class Page implements IPage {
     if (result?.selected) this._tabId = result.selected;
   }
 
-  async networkRequests(includeStatic: boolean = false): Promise<unknown[]> {
-    const code = networkRequestsJs(includeStatic);
-    const result = await sendCommand('exec', { code, ...this._cmdOpts() });
-    return Array.isArray(result) ? result : [];
-  }
-
-  /**
-   * Console messages are not available in lightweight daemon mode.
-   * Would require CDP Runtime.consoleAPICalled event listener.
-   * @returns Always returns empty array.
-   */
-  async consoleMessages(_level: string = 'info'): Promise<unknown[]> {
-    return [];
-  }
-
   /**
    * Capture a screenshot via CDP Page.captureScreenshot.
-   * @param options.format - 'png' (default) or 'jpeg'
-   * @param options.quality - JPEG quality 0-100
-   * @param options.fullPage - capture full scrollable page
-   * @param options.path - save to file path (returns base64 if omitted)
    */
   async screenshot(options: ScreenshotOptions = {}): Promise<string> {
     const base64 = await sendCommand('screenshot', {
@@ -326,35 +164,6 @@ export class Page implements IPage {
     return base64;
   }
 
-  async scroll(direction: string = 'down', amount: number = 500): Promise<void> {
-    const code = scrollJs(direction, amount);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async autoScroll(options: { times?: number; delayMs?: number } = {}): Promise<void> {
-    const times = options.times ?? 3;
-    const delayMs = options.delayMs ?? 2000;
-    const code = autoScrollJs(times, delayMs);
-    await sendCommand('exec', { code, ...this._cmdOpts() });
-  }
-
-  async installInterceptor(pattern: string): Promise<void> {
-    const { generateInterceptorJs } = await import('../interceptor.js');
-    // 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(): Promise<unknown[]> {
-    const { generateReadInterceptedJs } = await import('../interceptor.js');
-    // Same as installInterceptor: must go through evaluate() for IIFE wrapping
-    const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
-    return Array.isArray(result) ? result : [];
-  }
-
   /**
    * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
    * Chrome reads the files directly from the local filesystem, avoiding the
@@ -371,13 +180,52 @@ export class Page implements IPage {
     }
   }
 
-  async waitForCapture(timeout: number = 10): Promise<void> {
-    const maxMs = timeout * 1000;
-    await sendCommand('exec', {
-      code: waitForCaptureJs(maxMs),
+  async cdp(method: string, params: Record<string, unknown> = {}): Promise<unknown> {
+    return sendCommand('cdp', {
+      cdpMethod: method,
+      cdpParams: params,
       ...this._cmdOpts(),
     });
   }
+
+  async nativeClick(x: number, y: number): Promise<void> {
+    await this.cdp('Input.dispatchMouseEvent', {
+      type: 'mousePressed',
+      x, y,
+      button: 'left',
+      clickCount: 1,
+    });
+    await this.cdp('Input.dispatchMouseEvent', {
+      type: 'mouseReleased',
+      x, y,
+      button: 'left',
+      clickCount: 1,
+    });
+  }
+
+  async nativeType(text: string): Promise<void> {
+    // Use Input.insertText for reliable Unicode/CJK text insertion
+    await this.cdp('Input.insertText', { text });
+  }
+
+  async nativeKeyPress(key: string, modifiers: string[] = []): Promise<void> {
+    let modifierFlags = 0;
+    for (const mod of modifiers) {
+      if (mod === 'Alt') modifierFlags |= 1;
+      if (mod === 'Ctrl') modifierFlags |= 2;
+      if (mod === 'Meta') modifierFlags |= 4;
+      if (mod === 'Shift') modifierFlags |= 8;
+    }
+    await this.cdp('Input.dispatchKeyEvent', {
+      type: 'keyDown',
+      key,
+      modifiers: modifierFlags,
+    });
+    await this.cdp('Input.dispatchKeyEvent', {
+      type: 'keyUp',
+      key,
+      modifiers: modifierFlags,
+    });
+  }
 }
 
-// (End of file)

package/src/browser/tabs.ts

@@ -21,12 +21,12 @@ export function extractTabEntries(raw: unknown): Array<{ index: number; identity
       .map(line => line.trim())
       .filter(Boolean)
       .map(line => {
-        // Match actual Playwright MCP format: "- 0: (current) [title](url)"  or  "- 1: [title](url)"
-        const mcpMatch = line.match(/^-\s+(\d+):\s*(.*)$/);
-        if (mcpMatch) {
+        // Match tab list format: "- 0: (current) [title](url)"  or  "- 1: [title](url)"
+        const tabMatch = line.match(/^-\s+(\d+):\s*(.*)$/);
+        if (tabMatch) {
           return {
-            index: parseInt(mcpMatch[1], 10),
-            identity: mcpMatch[2].trim() || `tab-${mcpMatch[1]}`,
+            index: parseInt(tabMatch[1], 10),
+            identity: tabMatch[2].trim() || `tab-${tabMatch[1]}`,
           };
         }
         // Legacy format: "Tab 0 ..."

package/src/browser.test.ts

@@ -104,43 +104,43 @@ describe('browser helpers', () => {
 
 describe('BrowserBridge state', () => {
   it('transitions to closed after close()', async () => {
-    const mcp = new BrowserBridge();
+    const bridge = new BrowserBridge();
 
-    expect(mcp.state).toBe('idle');
+    expect(bridge.state).toBe('idle');
 
-    await mcp.close();
+    await bridge.close();
 
-    expect(mcp.state).toBe('closed');
+    expect(bridge.state).toBe('closed');
   });
 
   it('rejects connect() after the session has been closed', async () => {
-    const mcp = new BrowserBridge();
-    await mcp.close();
+    const bridge = new BrowserBridge();
+    await bridge.close();
 
-    await expect(mcp.connect()).rejects.toThrow('Session is closed');
+    await expect(bridge.connect()).rejects.toThrow('Session is closed');
   });
 
   it('rejects connect() while already connecting', async () => {
-    const mcp = new BrowserBridge();
-    (mcp as any)._state = 'connecting';
+    const bridge = new BrowserBridge();
+    (bridge as any)._state = 'connecting';
 
-    await expect(mcp.connect()).rejects.toThrow('Already connecting');
+    await expect(bridge.connect()).rejects.toThrow('Already connecting');
   });
 
   it('rejects connect() while closing', async () => {
-    const mcp = new BrowserBridge();
-    (mcp as any)._state = 'closing';
+    const bridge = new BrowserBridge();
+    (bridge as any)._state = 'closing';
 
-    await expect(mcp.connect()).rejects.toThrow('Session is closing');
+    await expect(bridge.connect()).rejects.toThrow('Session is closing');
   });
 
   it('fails fast when daemon is running but extension is disconnected', async () => {
     vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
     vi.spyOn(daemonClient, 'isDaemonRunning').mockResolvedValue(true);
 
-    const mcp = new BrowserBridge();
+    const bridge = new BrowserBridge();
 
-    await expect(mcp.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
+    await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
   });
 });