@jackwener/opencli 0.4.3 → 0.4.4

package/src/browser.test.ts

@@ -1,51 +1,77 @@
-import { describe, expect, it } from 'vitest';
-import { formatBrowserConnectError, getTokenFingerprint } from './browser.js';
+import { describe, it, expect } from 'vitest';
+import { PlaywrightMCP, __test__ } from './browser.js';
 
-describe('getTokenFingerprint', () => {
-  it('returns null for empty token', () => {
-    expect(getTokenFingerprint(undefined)).toBeNull();
+describe('browser helpers', () => {
+  it('creates JSON-RPC requests with unique ids', () => {
+    const first = __test__.createJsonRpcRequest('tools/call', { name: 'browser_tabs' });
+    const second = __test__.createJsonRpcRequest('tools/call', { name: 'browser_snapshot' });
+
+    expect(second.id).toBe(first.id + 1);
+    expect(first.message).toContain(`"id":${first.id}`);
+    expect(second.message).toContain(`"id":${second.id}`);
+  });
+
+  it('extracts tab entries from string snapshots', () => {
+    const entries = __test__.extractTabEntries('Tab 0 https://example.com\nTab 1 Chrome Extension');
+
+    expect(entries).toEqual([
+      { index: 0, identity: 'https://example.com' },
+      { index: 1, identity: 'Chrome Extension' },
+    ]);
   });
 
-  it('returns stable short fingerprint for token', () => {
-    expect(getTokenFingerprint('abc123')).toBe('6ca13d52');
+  it('closes only tabs that were opened during the session', () => {
+    const tabsToClose = __test__.diffTabIndexes(
+      ['https://example.com', 'Chrome Extension'],
+      [
+        { index: 0, identity: 'https://example.com' },
+        { index: 1, identity: 'Chrome Extension' },
+        { index: 2, identity: 'https://target.example/page' },
+        { index: 3, identity: 'chrome-extension://bridge' },
+      ],
+    );
+
+    expect(tabsToClose).toEqual([3, 2]);
+  });
+
+  it('keeps only the tail of stderr buffers', () => {
+    expect(__test__.appendLimited('12345', '67890', 8)).toBe('34567890');
+  });
+
+  it('times out slow promises', async () => {
+    await expect(__test__.withTimeout(new Promise(() => {}), 10, 'timeout')).rejects.toThrow('timeout');
   });
 });
 
-describe('formatBrowserConnectError', () => {
-  it('explains missing extension token clearly', () => {
-    const err = formatBrowserConnectError({
-      kind: 'missing-token',
-      mode: 'extension',
-      timeout: 30,
-      hasExtensionToken: false,
-    });
-
-    expect(err.message).toContain('PLAYWRIGHT_MCP_EXTENSION_TOKEN is not set');
-    expect(err.message).toContain('manual approval dialog');
-  });
-
-  it('mentions token mismatch as likely cause for extension timeout', () => {
-    const err = formatBrowserConnectError({
-      kind: 'extension-timeout',
-      mode: 'extension',
-      timeout: 30,
-      hasExtensionToken: true,
-      tokenFingerprint: 'deadbeef',
-    });
-
-    expect(err.message).toContain('does not match the token currently shown by the browser extension');
-    expect(err.message).toContain('deadbeef');
-  });
-
-  it('keeps CDP timeout guidance separate', () => {
-    const err = formatBrowserConnectError({
-      kind: 'cdp-timeout',
-      mode: 'cdp',
-      timeout: 30,
-      hasExtensionToken: false,
-    });
-
-    expect(err.message).toContain('via CDP');
-    expect(err.message).toContain('chrome://inspect#remote-debugging');
+describe('PlaywrightMCP state', () => {
+  it('transitions to closed after close()', async () => {
+    const mcp = new PlaywrightMCP();
+
+    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();
+    await mcp.close();
+
+    await expect(mcp.connect()).rejects.toThrow('Playwright MCP session is closed');
+  });
+
+  it('rejects connect() while already connecting', async () => {
+    const mcp = new PlaywrightMCP();
+    (mcp as any)._state = 'connecting';
+
+    await expect(mcp.connect()).rejects.toThrow('Playwright MCP is already connecting');
+  });
+
+  it('rejects connect() while closing', async () => {
+    const mcp = new PlaywrightMCP();
+    (mcp as any)._state = 'closing';
+
+    await expect(mcp.connect()).rejects.toThrow('Playwright MCP is closing');
   });
 });

package/src/browser.ts

@@ -80,12 +80,13 @@ export async function discoverChromeEndpoint(): Promise<string | null> {
 const __browser_dirname = path.dirname(fileURLToPath(import.meta.url));
 const PKG_VERSION = (() => { try { return JSON.parse(fs.readFileSync(path.resolve(__browser_dirname, '..', 'package.json'), 'utf-8')).version; } catch { return '0.0.0'; } })();
 
-const EXTENSION_LOCK_TIMEOUT = parseInt(process.env.OPENCLI_EXTENSION_LOCK_TIMEOUT ?? '120', 10);
-const EXTENSION_LOCK_POLL = parseInt(process.env.OPENCLI_EXTENSION_LOCK_POLL_INTERVAL ?? '1', 10);
 const CONNECT_TIMEOUT = parseInt(process.env.OPENCLI_BROWSER_CONNECT_TIMEOUT ?? '30', 10);
-const LOCK_DIR = path.join(os.tmpdir(), 'opencli-mcp-lock');
+const STDERR_BUFFER_LIMIT = 16 * 1024;
+const TAB_CLEANUP_TIMEOUT_MS = 2000;
+let _cachedMcpServerPath: string | null | undefined;
 
 type ConnectFailureKind = 'missing-token' | 'extension-timeout' | 'extension-not-installed' | 'cdp-timeout' | 'mcp-init' | 'process-exit' | 'unknown';
+type PlaywrightMCPState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
 
 type ConnectFailureInput = {
   kind: ConnectFailureKind;
@@ -187,8 +188,12 @@ function inferConnectFailureKind(args: {
 
 // JSON-RPC helpers
 let _nextId = 1;
-function jsonRpcRequest(method: string, params: Record<string, any> = {}): string {
-  return JSON.stringify({ jsonrpc: '2.0', id: _nextId++, method, params }) + '\n';
+function createJsonRpcRequest(method: string, params: Record<string, any> = {}): { id: number; message: string } {
+  const id = _nextId++;
+  return {
+    id,
+    message: JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n',
+  };
 }
 
 import type { IPage } from './types.js';
@@ -197,11 +202,10 @@ import type { IPage } from './types.js';
  * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
  */
 export class Page implements IPage {
-  constructor(private _send: (msg: string) => void, private _recv: () => Promise<any>) {}
+  constructor(private _request: (method: string, params?: Record<string, any>) => Promise<any>) {}
 
   async call(method: string, params: Record<string, any> = {}): Promise<any> {
-    this._send(jsonRpcRequest(method, params));
-    const resp = await this._recv();
+    const resp = await this._request(method, params);
     if (resp.error) throw new Error(`page.${method}: ${resp.error.message ?? JSON.stringify(resp.error)}`);
     // Extract text content from MCP result
     const result = resp.result;
@@ -405,10 +409,6 @@ export class PlaywrightMCP {
     this._cleanupRegistered = true;
     const cleanup = () => {
       for (const inst of this._activeInsts) {
-        if (inst._lockAcquired) {
-          try { fs.rmdirSync(LOCK_DIR); } catch {}
-          inst._lockAcquired = false;
-        }
         if (inst._proc && !inst._proc.killed) {
           try { inst._proc.kill('SIGKILL'); } catch {}
         }
@@ -421,18 +421,66 @@ export class PlaywrightMCP {
 
   private _proc: ChildProcess | null = null;
   private _buffer = '';
-  private _waiters: Array<(data: any) => void> = [];
-  private _lockAcquired = false;
-  private _initialTabCount = 0;
+  private _pending = new Map<number, { resolve: (data: any) => void; reject: (error: Error) => void }>();
+  private _initialTabIdentities: string[] = [];
+  private _closingPromise: Promise<void> | null = null;
+  private _state: PlaywrightMCPState = 'idle';
 
   private _page: Page | null = null;
 
+  get state(): PlaywrightMCPState {
+    return this._state;
+  }
+
+  private _sendRequest(method: string, params: Record<string, any> = {}): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      if (!this._proc?.stdin?.writable) {
+        reject(new Error('Playwright MCP process is not writable'));
+        return;
+      }
+      const { id, message } = createJsonRpcRequest(method, params);
+      this._pending.set(id, { resolve, reject });
+      this._proc.stdin.write(message, (err) => {
+        if (!err) return;
+        this._pending.delete(id);
+        reject(err);
+      });
+    });
+  }
+
+  private _rejectPendingRequests(error: Error): void {
+    const pending = [...this._pending.values()];
+    this._pending.clear();
+    for (const waiter of pending) waiter.reject(error);
+  }
+
+  private _resetAfterFailedConnect(): void {
+    const proc = this._proc;
+    this._page = null;
+    this._proc = null;
+    this._buffer = '';
+    this._initialTabIdentities = [];
+    this._rejectPendingRequests(new Error('Playwright MCP connect failed'));
+    PlaywrightMCP._activeInsts.delete(this);
+    if (proc && !proc.killed) {
+      try { proc.kill('SIGKILL'); } catch {}
+    }
+  }
+
   async connect(opts: { timeout?: number; forceExtension?: boolean } = {}): Promise<Page> {
-    await this._acquireLock();
-    const timeout = opts.timeout ?? CONNECT_TIMEOUT;
+    if (this._state === 'connected' && this._page) return this._page;
+    if (this._state === 'connecting') throw new Error('Playwright MCP is already connecting');
+    if (this._state === 'closing') throw new Error('Playwright MCP is closing');
+    if (this._state === 'closed') throw new Error('Playwright MCP session is closed');
+
     const mcpPath = findMcpServerPath();
     if (!mcpPath) throw new Error('Playwright MCP server not found. Install: npm install -D @playwright/mcp');
 
+    PlaywrightMCP._registerGlobalCleanup();
+    PlaywrightMCP._activeInsts.add(this);
+    this._state = 'connecting';
+    const timeout = opts.timeout ?? CONNECT_TIMEOUT;
+
     // Connection priority:
     // 1. OPENCLI_CDP_ENDPOINT env var → explicit CDP endpoint
     // 2. OPENCLI_USE_CDP=1 → auto-discover via DevToolsActivePort
@@ -460,7 +508,9 @@ export class PlaywrightMCP {
       const settleError = (kind: ConnectFailureKind, extra: { rawMessage?: string; exitCode?: number | null } = {}) => {
         if (settled) return;
         settled = true;
+        this._state = 'idle';
         clearTimeout(timer);
+        this._resetAfterFailedConnect();
         reject(formatBrowserConnectError({
           kind,
           mode,
@@ -476,6 +526,7 @@ export class PlaywrightMCP {
       const settleSuccess = (pageToResolve: Page) => {
         if (settled) return;
         settled = true;
+        this._state = 'connected';
         clearTimeout(timer);
         resolve(pageToResolve);
       };
@@ -515,10 +566,7 @@ export class PlaywrightMCP {
       this._proc.setMaxListeners(20);
       if (this._proc.stdout) this._proc.stdout.setMaxListeners(20);
 
-      const page = new Page(
-        (msg) => { if (this._proc?.stdin?.writable) this._proc.stdin.write(msg); },
-        () => new Promise<any>((res) => { this._waiters.push(res); }),
-      );
+      const page = new Page((method, params = {}) => this._sendRequest(method, params));
       this._page = page;
 
       this._proc.stdout?.on('data', (chunk: Buffer) => {
@@ -530,8 +578,13 @@ export class PlaywrightMCP {
           debugLog(`RECV: ${line}`);
           try {
             const parsed = JSON.parse(line);
-            const waiter = this._waiters.shift();
-            if (waiter) waiter(parsed);
+            if (typeof parsed?.id === 'number') {
+              const waiter = this._pending.get(parsed.id);
+              if (waiter) {
+                this._pending.delete(parsed.id);
+                waiter.resolve(parsed);
+              }
+            }
           } catch (e) {
             debugLog(`Parse error: ${e}`);
           }
@@ -540,15 +593,17 @@ export class PlaywrightMCP {
 
       this._proc.stderr?.on('data', (chunk: Buffer) => {
         const text = chunk.toString();
-        stderrBuffer += text;
+        stderrBuffer = appendLimited(stderrBuffer, text, STDERR_BUFFER_LIMIT);
         debugLog(`STDERR: ${text}`);
       });
       this._proc.on('error', (err) => {
         debugLog(`Subprocess error: ${err.message}`);
+        this._rejectPendingRequests(new Error(`Playwright MCP process error: ${err.message}`));
         settleError('process-exit', { rawMessage: err.message });
       });
       this._proc.on('close', (code) => {
         debugLog(`Subprocess closed with code ${code}`);
+        this._rejectPendingRequests(new Error(`Playwright MCP process exited before response${code == null ? '' : ` (code ${code})`}`));
         if (!settled) {
           settleError(inferConnectFailureKind({
             mode,
@@ -560,18 +615,12 @@ export class PlaywrightMCP {
       });
 
       // Initialize: send initialize request
-      const initMsg = jsonRpcRequest('initialize', {
+      debugLog('Waiting for initialize response...');
+      this._sendRequest('initialize', {
         protocolVersion: '2024-11-05',
         capabilities: {},
         clientInfo: { name: 'opencli', version: PKG_VERSION },
-      });
-      debugLog(`SEND: ${initMsg.trim()}`);
-      this._proc.stdin?.write(initMsg);
-
-      // Wait for initialize response, then send initialized notification
-      const origRecv = () => new Promise<any>((res) => { this._waiters.push(res); });
-      debugLog('Waiting for initialize response...');
-      origRecv().then((resp) => {
+      }).then((resp) => {
         debugLog('Got initialize response');
         if (resp.error) {
           settleError(inferConnectFailureKind({
@@ -591,11 +640,7 @@ export class PlaywrightMCP {
         debugLog('Fetching initial tabs count...');
         page.tabs().then((tabs: any) => {
           debugLog(`Tabs response: ${typeof tabs === 'string' ? tabs : JSON.stringify(tabs)}`);
-          if (typeof tabs === 'string') {
-            this._initialTabCount = (tabs.match(/Tab \d+/g) || []).length;
-          } else if (Array.isArray(tabs)) {
-            this._initialTabCount = tabs.length;
-          }
+          this._initialTabIdentities = extractTabIdentities(tabs);
           settleSuccess(page);
         }).catch((err) => {
           debugLog(`Tabs fetch error: ${err.message}`);
@@ -609,68 +654,159 @@ export class PlaywrightMCP {
   }
 
   async close(): Promise<void> {
-    try {
-      // Close tabs opened during this session (site tabs + extension tabs)
-      if (this._page && this._proc && !this._proc.killed) {
-        try {
-          const tabs = await this._page.tabs();
-          const tabStr = typeof tabs === 'string' ? tabs : JSON.stringify(tabs);
-          const allTabs = tabStr.match(/Tab (\d+)/g) || [];
-          const currentTabCount = allTabs.length;
-
-          // Close tabs in reverse order to avoid index shifting issues
-          // Keep the original tabs that existed before the command started
-          if (currentTabCount > this._initialTabCount && this._initialTabCount > 0) {
-            for (let i = currentTabCount - 1; i >= this._initialTabCount; i--) {
-              try { await this._page.closeTab(i); } catch {}
+    if (this._closingPromise) return this._closingPromise;
+    if (this._state === 'closed') return;
+    this._state = 'closing';
+    this._closingPromise = (async () => {
+      try {
+        // Close tabs opened during this session (site tabs + extension tabs)
+        if (this._page && this._proc && !this._proc.killed) {
+          try {
+            const tabs = await withTimeout(this._page.tabs(), TAB_CLEANUP_TIMEOUT_MS, 'Timed out fetching tabs during cleanup');
+            const tabEntries = extractTabEntries(tabs);
+            const tabsToClose = diffTabIndexes(this._initialTabIdentities, tabEntries);
+            for (const index of tabsToClose) {
+              try { await this._page.closeTab(index); } catch {}
             }
+          } catch {}
+        }
+        if (this._proc && !this._proc.killed) {
+          this._proc.kill('SIGTERM');
+          const exited = await new Promise<boolean>((res) => {
+            let done = false;
+            const finish = (value: boolean) => {
+              if (done) return;
+              done = true;
+              res(value);
+            };
+            this._proc?.once('exit', () => finish(true));
+            setTimeout(() => finish(false), 3000);
+          });
+          if (!exited && this._proc && !this._proc.killed) {
+            try { this._proc.kill('SIGKILL'); } catch {}
           }
-        } catch {}
-      }
-      if (this._proc && !this._proc.killed) {
-        this._proc.kill('SIGTERM');
-        await new Promise<void>((res) => { this._proc?.on('exit', () => res()); setTimeout(res, 3000); });
+        }
+      } finally {
+        this._rejectPendingRequests(new Error('Playwright MCP session closed'));
+        this._page = null;
+        this._proc = null;
+        this._state = 'closed';
+        PlaywrightMCP._activeInsts.delete(this);
       }
-    } finally {
-      this._page = null;
-      this._releaseLock();
-      PlaywrightMCP._activeInsts.delete(this);
-    }
+    })();
+    return this._closingPromise;
   }
+}
 
-  private async _acquireLock(): Promise<void> {
-    const start = Date.now();
-    while (true) {
-      try { fs.mkdirSync(LOCK_DIR, { recursive: false }); this._lockAcquired = true; return; }
-      catch (e: any) {
-        if (e.code !== 'EEXIST') throw e;
-        if ((Date.now() - start) / 1000 > EXTENSION_LOCK_TIMEOUT) {
-          // Force remove stale lock
-          try { fs.rmdirSync(LOCK_DIR); } catch {}
-          continue;
-        }
-        await new Promise(r => setTimeout(r, EXTENSION_LOCK_POLL * 1000));
-      }
-    }
+function extractTabEntries(raw: any): Array<{ index: number; identity: string }> {
+  if (Array.isArray(raw)) {
+    return raw.map((tab: any, index: number) => ({
+      index,
+      identity: [
+        tab?.id ?? '',
+        tab?.url ?? '',
+        tab?.title ?? '',
+        tab?.name ?? '',
+      ].join('|'),
+    }));
+  }
+
+  if (typeof raw === 'string') {
+    return raw
+      .split('\n')
+      .map(line => line.trim())
+      .filter(Boolean)
+      .map(line => {
+        const match = line.match(/Tab\s+(\d+)\s*(.*)$/);
+        if (!match) return null;
+        return {
+          index: parseInt(match[1], 10),
+          identity: match[2].trim() || `tab-${match[1]}`,
+        };
+      })
+      .filter((entry): entry is { index: number; identity: string } => entry !== null);
+  }
+
+  return [];
+}
+
+function extractTabIdentities(raw: any): string[] {
+  return extractTabEntries(raw).map(tab => tab.identity);
+}
+
+function diffTabIndexes(initialIdentities: string[], currentTabs: Array<{ index: number; identity: string }>): number[] {
+  if (initialIdentities.length === 0 || currentTabs.length === 0) return [];
+  const remaining = new Map<string, number>();
+  for (const identity of initialIdentities) {
+    remaining.set(identity, (remaining.get(identity) ?? 0) + 1);
   }
 
-  private _releaseLock(): void {
-    if (this._lockAcquired) {
-      try { fs.rmdirSync(LOCK_DIR); } catch {}
-      this._lockAcquired = false;
+  const tabsToClose: number[] = [];
+  for (const tab of currentTabs) {
+    const count = remaining.get(tab.identity) ?? 0;
+    if (count > 0) {
+      remaining.set(tab.identity, count - 1);
+      continue;
     }
+    tabsToClose.push(tab.index);
   }
+
+  return tabsToClose.sort((a, b) => b - a);
+}
+
+function appendLimited(current: string, chunk: string, limit: number): string {
+  const next = current + chunk;
+  if (next.length <= limit) return next;
+  return next.slice(-limit);
+}
+
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      },
+    );
+  });
 }
 
+export const __test__ = {
+  createJsonRpcRequest,
+  extractTabEntries,
+  diffTabIndexes,
+  appendLimited,
+  withTimeout,
+};
+
 function findMcpServerPath(): string | null {
+  if (_cachedMcpServerPath !== undefined) return _cachedMcpServerPath;
+
+  const envMcp = process.env.OPENCLI_MCP_SERVER_PATH;
+  if (envMcp && fs.existsSync(envMcp)) {
+    _cachedMcpServerPath = envMcp;
+    return _cachedMcpServerPath;
+  }
+
   // Check local node_modules first (@playwright/mcp is the modern package)
   const localMcp = path.resolve('node_modules', '@playwright', 'mcp', 'cli.js');
-  if (fs.existsSync(localMcp)) return localMcp;
+  if (fs.existsSync(localMcp)) {
+    _cachedMcpServerPath = localMcp;
+    return _cachedMcpServerPath;
+  }
 
   // Check project-relative path
   const __dirname2 = path.dirname(fileURLToPath(import.meta.url));
   const projectMcp = path.resolve(__dirname2, '..', 'node_modules', '@playwright', 'mcp', 'cli.js');
-  if (fs.existsSync(projectMcp)) return projectMcp;
+  if (fs.existsSync(projectMcp)) {
+    _cachedMcpServerPath = projectMcp;
+    return _cachedMcpServerPath;
+  }
 
   // Check common locations
   const candidates = [
@@ -682,13 +818,19 @@ function findMcpServerPath(): string | null {
   // Try npx resolution (legacy package name)
   try {
     const result = execSync('npx -y --package=@playwright/mcp which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 10000 }).trim();
-    if (result && fs.existsSync(result)) return result;
+    if (result && fs.existsSync(result)) {
+      _cachedMcpServerPath = result;
+      return _cachedMcpServerPath;
+    }
   } catch {}
 
   // Try which
   try {
     const result = execSync('which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 5000 }).trim();
-    if (result && fs.existsSync(result)) return result;
+    if (result && fs.existsSync(result)) {
+      _cachedMcpServerPath = result;
+      return _cachedMcpServerPath;
+    }
   } catch {}
 
   // Search in common npx cache
@@ -696,9 +838,13 @@ function findMcpServerPath(): string | null {
     if (!fs.existsSync(base)) continue;
     try {
       const found = execSync(`find "${base}" -name "cli.js" -path "*playwright*mcp*" 2>/dev/null | head -1`, { encoding: 'utf-8', timeout: 5000 }).trim();
-      if (found) return found;
+      if (found) {
+        _cachedMcpServerPath = found;
+        return _cachedMcpServerPath;
+      }
     } catch {}
   }
 
-  return null;
+  _cachedMcpServerPath = null;
+  return _cachedMcpServerPath;
 }