@jackwener/opencli 0.4.3 → 0.4.4

package/dist/browser.js

@@ -79,10 +79,10 @@ const PKG_VERSION = (() => { try {
 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;
 export function getTokenFingerprint(token) {
     if (!token)
         return null;
@@ -146,22 +146,23 @@ function inferConnectFailureKind(args) {
 }
 // JSON-RPC helpers
 let _nextId = 1;
-function jsonRpcRequest(method, params = {}) {
-    return JSON.stringify({ jsonrpc: '2.0', id: _nextId++, method, params }) + '\n';
+function createJsonRpcRequest(method, params = {}) {
+    const id = _nextId++;
+    return {
+        id,
+        message: JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n',
+    };
 }
 /**
  * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
  */
 export class Page {
-    _send;
-    _recv;
-    constructor(_send, _recv) {
-        this._send = _send;
-        this._recv = _recv;
+    _request;
+    constructor(_request) {
+        this._request = _request;
     }
     async call(method, params = {}) {
-        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
@@ -359,13 +360,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');
@@ -380,16 +374,67 @@ export class PlaywrightMCP {
     }
     _proc = null;
     _buffer = '';
-    _waiters = [];
-    _lockAcquired = false;
-    _initialTabCount = 0;
+    _pending = new Map();
+    _initialTabIdentities = [];
+    _closingPromise = null;
+    _state = 'idle';
     _page = null;
+    get state() {
+        return this._state;
+    }
+    _sendRequest(method, params = {}) {
+        return new Promise((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);
+            });
+        });
+    }
+    _rejectPendingRequests(error) {
+        const pending = [...this._pending.values()];
+        this._pending.clear();
+        for (const waiter of pending)
+            waiter.reject(error);
+    }
+    _resetAfterFailedConnect() {
+        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 = {}) {
-        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
@@ -417,7 +462,9 @@ export class PlaywrightMCP {
                 if (settled)
                     return;
                 settled = true;
+                this._state = 'idle';
                 clearTimeout(timer);
+                this._resetAfterFailedConnect();
                 reject(formatBrowserConnectError({
                     kind,
                     mode,
@@ -433,6 +480,7 @@ export class PlaywrightMCP {
                 if (settled)
                     return;
                 settled = true;
+                this._state = 'connected';
                 clearTimeout(timer);
                 resolve(pageToResolve);
             };
@@ -469,8 +517,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((res) => { this._waiters.push(res); }));
+            const page = new Page((method, params = {}) => this._sendRequest(method, params));
             this._page = page;
             this._proc.stdout?.on('data', (chunk) => {
                 this._buffer += chunk.toString();
@@ -482,9 +529,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}`);
@@ -493,15 +544,17 @@ export class PlaywrightMCP {
             });
             this._proc.stderr?.on('data', (chunk) => {
                 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,
@@ -512,17 +565,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((res) => { this._waiters.push(res); });
-            debugLog('Waiting for initialize response...');
-            origRecv().then((resp) => {
+            }).then((resp) => {
                 debugLog('Got initialize response');
                 if (resp.error) {
                     settleError(inferConnectFailureKind({
@@ -540,12 +588,7 @@ export class PlaywrightMCP {
                 debugLog('Fetching initial tabs count...');
                 page.tabs().then((tabs) => {
                     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}`);
@@ -558,81 +601,157 @@ export class PlaywrightMCP {
         });
     }
     async close() {
-        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--) {
+        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(i);
+                                await this._page.closeTab(index);
                             }
                             catch { }
                         }
                     }
+                    catch { }
                 }
-                catch { }
-            }
-            if (this._proc && !this._proc.killed) {
-                this._proc.kill('SIGTERM');
-                await new Promise((res) => { this._proc?.on('exit', () => res()); setTimeout(res, 3000); });
-            }
-        }
-        finally {
-            this._page = null;
-            this._releaseLock();
-            PlaywrightMCP._activeInsts.delete(this);
-        }
-    }
-    async _acquireLock() {
-        const start = Date.now();
-        while (true) {
-            try {
-                fs.mkdirSync(LOCK_DIR, { recursive: false });
-                this._lockAcquired = true;
-                return;
-            }
-            catch (e) {
-                if (e.code !== 'EEXIST')
-                    throw e;
-                if ((Date.now() - start) / 1000 > EXTENSION_LOCK_TIMEOUT) {
-                    // Force remove stale lock
-                    try {
-                        fs.rmdirSync(LOCK_DIR);
+                if (this._proc && !this._proc.killed) {
+                    this._proc.kill('SIGTERM');
+                    const exited = await new Promise((res) => {
+                        let done = false;
+                        const finish = (value) => {
+                            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 { }
-                    continue;
                 }
-                await new Promise(r => setTimeout(r, EXTENSION_LOCK_POLL * 1000));
             }
-        }
-    }
-    _releaseLock() {
-        if (this._lockAcquired) {
-            try {
-                fs.rmdirSync(LOCK_DIR);
+            finally {
+                this._rejectPendingRequests(new Error('Playwright MCP session closed'));
+                this._page = null;
+                this._proc = null;
+                this._state = 'closed';
+                PlaywrightMCP._activeInsts.delete(this);
             }
-            catch { }
-            this._lockAcquired = false;
+        })();
+        return this._closingPromise;
+    }
+}
+function extractTabEntries(raw) {
+    if (Array.isArray(raw)) {
+        return raw.map((tab, index) => ({
+            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 !== null);
+    }
+    return [];
+}
+function extractTabIdentities(raw) {
+    return extractTabEntries(raw).map(tab => tab.identity);
+}
+function diffTabIndexes(initialIdentities, currentTabs) {
+    if (initialIdentities.length === 0 || currentTabs.length === 0)
+        return [];
+    const remaining = new Map();
+    for (const identity of initialIdentities) {
+        remaining.set(identity, (remaining.get(identity) ?? 0) + 1);
+    }
+    const tabsToClose = [];
+    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, chunk, limit) {
+    const next = current + chunk;
+    if (next.length <= limit)
+        return next;
+    return next.slice(-limit);
+}
+function withTimeout(promise, timeoutMs, message) {
+    return new Promise((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() {
+    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 = [
         path.join(os.homedir(), '.npm', '_npx'),
@@ -642,15 +761,19 @@ function findMcpServerPath() {
     // 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
@@ -659,10 +782,13 @@ function findMcpServerPath() {
             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;
 }

package/dist/browser.test.js

@@ -1,43 +1,56 @@
-import { describe, expect, it } from 'vitest';
-import { formatBrowserConnectError, getTokenFingerprint } from './browser.js';
-describe('getTokenFingerprint', () => {
-    it('returns null for empty token', () => {
-        expect(getTokenFingerprint(undefined)).toBeNull();
+import { describe, it, expect } from 'vitest';
+import { PlaywrightMCP, __test__ } from './browser.js';
+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('returns stable short fingerprint for token', () => {
-        expect(getTokenFingerprint('abc123')).toBe('6ca13d52');
+    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('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._state = 'connecting';
+        await expect(mcp.connect()).rejects.toThrow('Playwright MCP is already connecting');
+    });
+    it('rejects connect() while closing', async () => {
+        const mcp = new PlaywrightMCP();
+        mcp._state = 'closing';
+        await expect(mcp.connect()).rejects.toThrow('Playwright MCP is closing');
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "publishConfig": {
     "access": "public"
   },