@jackwener/opencli 0.9.6 → 1.0.0

package/dist/browser/page.js

@@ -1,68 +1,70 @@
 /**
- * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
+ * Page abstraction — implements IPage by sending commands to the daemon.
+ *
+ * All browser operations are ultimately 'exec' (JS evaluation via CDP)
+ * plus a few native Chrome Extension APIs (tabs, cookies, navigate).
+ *
+ * IMPORTANT: After goto(), we remember the tabId returned by the navigate
+ * action and pass it to all subsequent commands. This avoids the issue
+ * where resolveTabId() in the extension picks a chrome:// or
+ * chrome-extension:// tab that can't be debugged.
  */
 import { formatSnapshot } from '../snapshotFormatter.js';
-import { normalizeEvaluateSource } from '../pipeline/template.js';
-import { generateInterceptorJs, generateReadInterceptedJs } from '../interceptor.js';
-import { BrowserConnectError } from '../errors.js';
+import { sendCommand } from './daemon-client.js';
 /**
- * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
+ * Page — implements IPage by talking to the daemon via HTTP.
  */
 export class Page {
-    _request;
-    constructor(_request) {
-        this._request = _request;
-    }
-    async call(method, params = {}) {
-        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;
-        if (result?.isError) {
-            const errorText = result.content?.find((c) => c.type === 'text')?.text || 'Unknown MCP Error';
-            throw new BrowserConnectError(errorText, 'Please check if the browser is running or if the Playwright MCP / CDP connection is configured correctly.');
-        }
-        if (result?.content) {
-            const textParts = result.content.filter((c) => c.type === 'text');
-            if (textParts.length >= 1) {
-                let text = textParts[textParts.length - 1].text; // Usually the main output is in the last text block
-                // Some versions of the MCP return error text without the `isError` boolean flag
-                if (typeof text === 'string' && text.trim().startsWith('### Error')) {
-                    throw new BrowserConnectError(text.trim(), 'Please check if the browser is running or if the Playwright MCP / CDP connection is configured correctly.');
-                }
-                // MCP browser_evaluate returns: "[JSON]\n### Ran Playwright code\n```js\n...\n```"
-                // Strip the "### Ran Playwright code" suffix to get clean JSON
-                const codeMarker = text.indexOf('### Ran Playwright code');
-                if (codeMarker !== -1) {
-                    text = text.slice(0, codeMarker).trim();
-                }
-                // Also handle "### Result\n[JSON]" format (some MCP versions)
-                const resultMarker = text.indexOf('### Result\n');
-                if (resultMarker !== -1) {
-                    text = text.slice(resultMarker + '### Result\n'.length).trim();
-                }
-                try {
-                    return JSON.parse(text);
-                }
-                catch {
-                    return text;
-                }
-            }
-        }
-        return result;
+    /** Active tab ID, set after navigate and used in all subsequent commands */
+    _tabId;
+    /** Helper: spread tabId into command params if we have one */
+    _tabOpt() {
+        return this._tabId !== undefined ? { tabId: this._tabId } : {};
     }
-    // --- High-level methods ---
     async goto(url) {
-        await this.call('tools/call', { name: 'browser_navigate', arguments: { url } });
+        const result = await sendCommand('navigate', {
+            url,
+            ...this._tabOpt(),
+        });
+        // Remember the tabId for subsequent exec calls
+        if (result?.tabId) {
+            this._tabId = result.tabId;
+        }
     }
     async evaluate(js) {
-        // Normalize IIFE format to function format expected by MCP browser_evaluate
-        const normalized = normalizeEvaluateSource(js);
-        return this.call('tools/call', { name: 'browser_evaluate', arguments: { function: normalized } });
+        const code = wrapForEval(js);
+        return sendCommand('exec', { code, ...this._tabOpt() });
     }
     async snapshot(opts = {}) {
-        const raw = await this.call('tools/call', { name: 'browser_snapshot', arguments: {} });
+        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._tabOpt() });
         if (opts.raw)
             return raw;
         if (typeof raw === 'string')
@@ -70,52 +72,147 @@ export class Page {
         return raw;
     }
     async click(ref) {
-        await this.call('tools/call', { name: 'browser_click', arguments: { element: 'click target', 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 sendCommand('exec', { code, ...this._tabOpt() });
     }
     async typeText(ref, text) {
-        await this.call('tools/call', { name: 'browser_type', arguments: { element: 'type target', 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 sendCommand('exec', { code, ...this._tabOpt() });
     }
     async pressKey(key) {
-        await this.call('tools/call', { name: 'browser_press_key', arguments: { 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 sendCommand('exec', { code, ...this._tabOpt() });
     }
     async wait(options) {
         if (typeof options === 'number') {
-            await this.call('tools/call', { name: 'browser_wait_for', arguments: { time: options } });
+            await new Promise(resolve => setTimeout(resolve, options * 1000));
+            return;
+        }
+        if (options.time) {
+            await new Promise(resolve => setTimeout(resolve, options.time * 1000));
+            return;
         }
-        else {
-            // Pass directly to native wait_for, which supports natively awaiting text strings without heavy DOM polling
-            await this.call('tools/call', { name: 'browser_wait_for', arguments: options });
+        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 sendCommand('exec', { code, ...this._tabOpt() });
         }
     }
     async tabs() {
-        return this.call('tools/call', { name: 'browser_tabs', arguments: { action: 'list' } });
+        return sendCommand('tabs', { op: 'list' });
     }
     async closeTab(index) {
-        await this.call('tools/call', { name: 'browser_tabs', arguments: { action: 'close', ...(index !== undefined ? { index } : {}) } });
+        await sendCommand('tabs', { op: 'close', ...(index !== undefined ? { index } : {}) });
     }
     async newTab() {
-        await this.call('tools/call', { name: 'browser_tabs', arguments: { action: 'new' } });
+        await sendCommand('tabs', { op: 'new' });
     }
     async selectTab(index) {
-        await this.call('tools/call', { name: 'browser_tabs', arguments: { action: 'select', index } });
+        await sendCommand('tabs', { op: 'select', index });
     }
     async networkRequests(includeStatic = false) {
-        return this.call('tools/call', { name: 'browser_network_requests', arguments: { includeStatic } });
+        const code = `
+      (() => {
+        const entries = performance.getEntriesByType('resource');
+        return entries
+          ${includeStatic ? '' : '.filter(e => !["img", "font", "css", "script"].some(t => e.initiatorType === t))'}
+          .map(e => ({
+            url: e.name,
+            type: e.initiatorType,
+            duration: Math.round(e.duration),
+            size: e.transferSize || 0,
+          }));
+      })()
+    `;
+        return sendCommand('exec', { code, ...this._tabOpt() });
     }
     async consoleMessages(level = 'info') {
-        return this.call('tools/call', { name: 'browser_console_messages', arguments: { level } });
+        // 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');
+        }
+        return [];
     }
-    async scroll(direction = 'down', _amount = 500) {
-        await this.call('tools/call', { name: 'browser_press_key', arguments: { key: direction === 'down' ? 'PageDown' : 'PageUp' } });
+    /**
+     * 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 = {}) {
+        const base64 = await sendCommand('screenshot', {
+            format: options.format,
+            quality: options.quality,
+            fullPage: options.fullPage,
+            ...this._tabOpt(),
+        });
+        if (options.path) {
+            const fs = await import('node:fs');
+            const path = await import('node:path');
+            const dir = path.dirname(options.path);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(options.path, Buffer.from(base64, 'base64'));
+        }
+        return base64;
+    }
+    async scroll(direction = 'down', amount = 500) {
+        const dx = direction === 'left' ? -amount : direction === 'right' ? amount : 0;
+        const dy = direction === 'up' ? -amount : direction === 'down' ? amount : 0;
+        await sendCommand('exec', {
+            code: `window.scrollBy(${dx}, ${dy})`,
+            ...this._tabOpt(),
+        });
     }
     async autoScroll(options = {}) {
         const times = options.times ?? 3;
         const delayMs = options.delayMs ?? 2000;
-        const js = `
-      async () => {
-        const maxTimes = ${times};
-        const maxWaitMs = ${delayMs};
-        for (let i = 0; i < maxTimes; i++) {
+        const code = `
+      (async () => {
+        for (let i = 0; i < ${times}; i++) {
           const lastHeight = document.body.scrollHeight;
           window.scrollTo(0, lastHeight);
           await new Promise(resolve => {
@@ -124,28 +221,56 @@ export class Page {
               if (document.body.scrollHeight > lastHeight) {
                 clearTimeout(timeoutId);
                 observer.disconnect();
-                setTimeout(resolve, 100); // Small debounce for rendering
+                setTimeout(resolve, 100);
               }
             });
             observer.observe(document.body, { childList: true, subtree: true });
-            timeoutId = setTimeout(() => {
-              observer.disconnect();
-              resolve(null);
-            }, maxWaitMs);
+            timeoutId = setTimeout(() => { observer.disconnect(); resolve(null); }, ${delayMs});
           });
         }
-      }
+      })()
     `;
-        await this.evaluate(js);
+        await sendCommand('exec', { code, ...this._tabOpt() });
     }
     async installInterceptor(pattern) {
-        await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {
-            arrayName: '__opencli_xhr',
-            patchGuard: '__opencli_interceptor_patched',
-        }));
+        const { generateInterceptorJs } = await import('../interceptor.js');
+        await sendCommand('exec', {
+            code: generateInterceptorJs(JSON.stringify(pattern), {
+                arrayName: '__opencli_xhr',
+                patchGuard: '__opencli_interceptor_patched',
+            }),
+            ...this._tabOpt(),
+        });
     }
     async getInterceptedRequests() {
-        const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
+        const { generateReadInterceptedJs } = await import('../interceptor.js');
+        const result = await sendCommand('exec', {
+            code: generateReadInterceptedJs('__opencli_xhr'),
+            ...this._tabOpt(),
+        });
         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;
+}

package/dist/browser.test.js

@@ -1,18 +1,6 @@
-import { afterEach, describe, it, expect, vi } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { PlaywrightMCP, __test__ } from './browser/index.js';
-afterEach(() => {
-    __test__.resetMcpServerPathCache();
-    __test__.setMcpDiscoveryTestHooks();
-    delete process.env.OPENCLI_MCP_SERVER_PATH;
-});
 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([
@@ -39,195 +27,9 @@ describe('browser helpers', () => {
     it('keeps only the tail of stderr buffers', () => {
         expect(__test__.appendLimited('12345', '67890', 8)).toBe('34567890');
     });
-    it('builds extension MCP args in local mode (no CI)', () => {
-        const savedCI = process.env.CI;
-        delete process.env.CI;
-        try {
-            expect(__test__.buildMcpArgs({
-                mcpPath: '/tmp/cli.js',
-                executablePath: '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
-            })).toEqual([
-                '/tmp/cli.js',
-                '--extension',
-                '--executable-path',
-                '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
-            ]);
-            expect(__test__.buildMcpArgs({
-                mcpPath: '/tmp/cli.js',
-            })).toEqual([
-                '/tmp/cli.js',
-                '--extension',
-            ]);
-        }
-        finally {
-            if (savedCI !== undefined) {
-                process.env.CI = savedCI;
-            }
-            else {
-                delete process.env.CI;
-            }
-        }
-    });
-    it('builds standalone MCP args in CI mode', () => {
-        const savedCI = process.env.CI;
-        process.env.CI = 'true';
-        try {
-            // CI mode: no --extension — browser launches in standalone headed mode
-            expect(__test__.buildMcpArgs({
-                mcpPath: '/tmp/cli.js',
-            })).toEqual([
-                '/tmp/cli.js',
-            ]);
-            expect(__test__.buildMcpArgs({
-                mcpPath: '/tmp/cli.js',
-                executablePath: '/usr/bin/chromium',
-            })).toEqual([
-                '/tmp/cli.js',
-                '--executable-path',
-                '/usr/bin/chromium',
-            ]);
-        }
-        finally {
-            if (savedCI !== undefined) {
-                process.env.CI = savedCI;
-            }
-            else {
-                delete process.env.CI;
-            }
-        }
-    });
-    it('builds a direct node launch spec when a local MCP path is available', () => {
-        const savedCI = process.env.CI;
-        delete process.env.CI;
-        try {
-            expect(__test__.buildMcpLaunchSpec({
-                mcpPath: '/tmp/cli.js',
-                executablePath: '/usr/bin/google-chrome',
-            })).toEqual({
-                command: 'node',
-                args: ['/tmp/cli.js', '--extension', '--executable-path', '/usr/bin/google-chrome'],
-                usedNpxFallback: false,
-            });
-        }
-        finally {
-            if (savedCI !== undefined) {
-                process.env.CI = savedCI;
-            }
-            else {
-                delete process.env.CI;
-            }
-        }
-    });
-    it('falls back to npx bootstrap when no MCP path is available', () => {
-        const savedCI = process.env.CI;
-        delete process.env.CI;
-        try {
-            expect(__test__.buildMcpLaunchSpec({
-                mcpPath: null,
-            })).toEqual({
-                command: 'npx',
-                args: ['-y', '@playwright/mcp@latest', '--extension'],
-                usedNpxFallback: true,
-            });
-        }
-        finally {
-            if (savedCI !== undefined) {
-                process.env.CI = savedCI;
-            }
-            else {
-                delete process.env.CI;
-            }
-        }
-    });
     it('times out slow promises', async () => {
         await expect(__test__.withTimeoutMs(new Promise(() => { }), 10, 'timeout')).rejects.toThrow('timeout');
     });
-    it('prefers OPENCLI_MCP_SERVER_PATH over discovered locations', () => {
-        process.env.OPENCLI_MCP_SERVER_PATH = '/env/mcp/cli.js';
-        const existsSync = vi.fn((candidate) => candidate === '/env/mcp/cli.js');
-        const execSync = vi.fn();
-        __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync });
-        expect(__test__.findMcpServerPath()).toBe('/env/mcp/cli.js');
-        expect(execSync).not.toHaveBeenCalled();
-        expect(existsSync).toHaveBeenCalledWith('/env/mcp/cli.js');
-    });
-    it('discovers global @playwright/mcp from the current Node runtime prefix', () => {
-        const originalExecPath = process.execPath;
-        const runtimeExecPath = '/opt/homebrew/Cellar/node/25.2.1/bin/node';
-        const runtimeGlobalMcp = '/opt/homebrew/Cellar/node/25.2.1/lib/node_modules/@playwright/mcp/cli.js';
-        Object.defineProperty(process, 'execPath', {
-            value: runtimeExecPath,
-            configurable: true,
-        });
-        const existsSync = vi.fn((candidate) => candidate === runtimeGlobalMcp);
-        const execSync = vi.fn();
-        __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync });
-        try {
-            expect(__test__.findMcpServerPath()).toBe(runtimeGlobalMcp);
-            expect(execSync).not.toHaveBeenCalled();
-            expect(existsSync).toHaveBeenCalledWith(runtimeGlobalMcp);
-        }
-        finally {
-            Object.defineProperty(process, 'execPath', {
-                value: originalExecPath,
-                configurable: true,
-            });
-        }
-    });
-    it('falls back to npm root -g when runtime prefix lookup misses', () => {
-        const originalExecPath = process.execPath;
-        const runtimeExecPath = '/opt/homebrew/Cellar/node/25.2.1/bin/node';
-        const runtimeGlobalMcp = '/opt/homebrew/Cellar/node/25.2.1/lib/node_modules/@playwright/mcp/cli.js';
-        const npmRootGlobal = '/Users/jakevin/.nvm/versions/node/v22.14.0/lib/node_modules';
-        const npmGlobalMcp = '/Users/jakevin/.nvm/versions/node/v22.14.0/lib/node_modules/@playwright/mcp/cli.js';
-        Object.defineProperty(process, 'execPath', {
-            value: runtimeExecPath,
-            configurable: true,
-        });
-        const existsSync = vi.fn((candidate) => candidate === npmGlobalMcp);
-        const execSync = vi.fn((command) => {
-            if (String(command).includes('npm root -g'))
-                return `${npmRootGlobal}\n`;
-            throw new Error(`unexpected command: ${String(command)}`);
-        });
-        __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync });
-        try {
-            expect(__test__.findMcpServerPath()).toBe(npmGlobalMcp);
-            expect(execSync).toHaveBeenCalledOnce();
-            expect(existsSync).toHaveBeenCalledWith(runtimeGlobalMcp);
-            expect(existsSync).toHaveBeenCalledWith(npmGlobalMcp);
-        }
-        finally {
-            Object.defineProperty(process, 'execPath', {
-                value: originalExecPath,
-                configurable: true,
-            });
-        }
-    });
-    it('returns null when new global discovery paths are unavailable', () => {
-        const originalExecPath = process.execPath;
-        const runtimeExecPath = '/opt/homebrew/Cellar/node/25.2.1/bin/node';
-        Object.defineProperty(process, 'execPath', {
-            value: runtimeExecPath,
-            configurable: true,
-        });
-        const existsSync = vi.fn(() => false);
-        const execSync = vi.fn((command) => {
-            if (String(command).includes('npm root -g'))
-                return '/missing/global/node_modules\n';
-            throw new Error(`missing command: ${String(command)}`);
-        });
-        __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync });
-        try {
-            expect(__test__.findMcpServerPath()).toBeNull();
-        }
-        finally {
-            Object.defineProperty(process, 'execPath', {
-                value: originalExecPath,
-                configurable: true,
-            });
-        }
-    });
 });
 describe('PlaywrightMCP state', () => {
     it('transitions to closed after close()', async () => {
@@ -239,16 +41,16 @@ describe('PlaywrightMCP state', () => {
     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');
+        await expect(mcp.connect()).rejects.toThrow('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');
+        await expect(mcp.connect()).rejects.toThrow('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');
+        await expect(mcp.connect()).rejects.toThrow('Session is closing');
     });
 });

package/dist/build-manifest.d.ts

@@ -8,4 +8,30 @@
  * Usage: npx tsx src/build-manifest.ts
  * Output: dist/cli-manifest.json
  */
+interface ManifestEntry {
+    site: string;
+    name: string;
+    description: string;
+    domain?: string;
+    strategy: string;
+    browser: boolean;
+    args: Array<{
+        name: string;
+        type?: string;
+        default?: any;
+        required?: boolean;
+        positional?: boolean;
+        help?: string;
+        choices?: string[];
+    }>;
+    columns?: string[];
+    pipeline?: any[];
+    timeout?: number;
+    /** 'yaml' or 'ts' — determines how executeCommand loads the handler */
+    type: 'yaml' | 'ts';
+    /** Relative path from clis/ dir, e.g. 'bilibili/hot.yaml' or 'bilibili/search.js' */
+    modulePath?: string;
+}
+export declare function parseTsArgsBlock(argsBlock: string): ManifestEntry['args'];
+export declare function buildManifest(): ManifestEntry[];
 export {};