@jackwener/opencli 0.9.8 → 1.0.0

package/dist/browser/mcp.js

@@ -1,310 +1,96 @@
 /**
- * Playwright MCP process manager.
- * Handles lifecycle management, JSON-RPC communication, and browser session orchestration.
+ * Browser session manager — auto-spawns daemon and provides IPage.
+ *
+ * Replaces the old PlaywrightMCP class. Still exports as PlaywrightMCP
+ * for backward compatibility with main.ts and other consumers.
  */
 import { spawn } from 'node:child_process';
-import { withTimeoutMs, DEFAULT_BROWSER_CONNECT_TIMEOUT } from '../runtime.js';
-import { PKG_VERSION } from '../version.js';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
 import { Page } from './page.js';
-import { getTokenFingerprint, formatBrowserConnectError, inferConnectFailureKind } from './errors.js';
-import { findMcpServerPath, buildMcpLaunchSpec, resolveCdpEndpoint } from './discover.js';
-import { extractTabIdentities, extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
-const STDERR_BUFFER_LIMIT = 16 * 1024;
-const INITIAL_TABS_TIMEOUT_MS = 1500;
-const TAB_CLEANUP_TIMEOUT_MS = 2000;
-// JSON-RPC helpers
-let _nextId = 1;
-export function createJsonRpcRequest(method, params = {}) {
-    const id = _nextId++;
-    return {
-        id,
-        message: JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n',
-    };
-}
+import { isDaemonRunning, isExtensionConnected } from './daemon-client.js';
+const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
- * Playwright MCP process manager.
+ * Browser factory: manages daemon lifecycle and provides IPage instances.
+ *
+ * Kept as `PlaywrightMCP` class name for backward compatibility.
  */
 export class PlaywrightMCP {
-    static _activeInsts = new Set();
-    static _cleanupRegistered = false;
-    static _registerGlobalCleanup() {
-        if (this._cleanupRegistered)
-            return;
-        this._cleanupRegistered = true;
-        const cleanup = () => {
-            for (const inst of this._activeInsts) {
-                if (inst._proc && !inst._proc.killed) {
-                    try {
-                        inst._proc.kill('SIGKILL');
-                    }
-                    catch { }
-                }
-            }
-        };
-        process.on('exit', cleanup);
-        process.on('SIGINT', () => { cleanup(); process.exit(130); });
-        process.on('SIGTERM', () => { cleanup(); process.exit(143); });
-    }
-    _proc = null;
-    _buffer = '';
-    _pending = new Map();
-    _initialTabIdentities = [];
-    _closingPromise = null;
     _state = 'idle';
     _page = null;
+    _daemonProc = 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 = {}) {
         if (this._state === 'connected' && this._page)
             return this._page;
         if (this._state === 'connecting')
-            throw new Error('Playwright MCP is already connecting');
+            throw new Error('Already connecting');
         if (this._state === 'closing')
-            throw new Error('Playwright MCP is closing');
+            throw new Error('Session is closing');
         if (this._state === 'closed')
-            throw new Error('Playwright MCP session is closed');
-        const mcpPath = findMcpServerPath();
-        PlaywrightMCP._registerGlobalCleanup();
-        PlaywrightMCP._activeInsts.add(this);
+            throw new Error('Session is closed');
         this._state = 'connecting';
-        const timeout = opts.timeout ?? DEFAULT_BROWSER_CONNECT_TIMEOUT;
-        return new Promise((resolve, reject) => {
-            const isDebug = process.env.DEBUG?.includes('opencli:mcp');
-            const debugLog = (msg) => isDebug && console.error(`[opencli:mcp] ${msg}`);
-            const { endpoint: cdpEndpoint, requestedCdp } = resolveCdpEndpoint();
-            const useExtension = !requestedCdp;
-            const extensionToken = process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN;
-            const tokenFingerprint = getTokenFingerprint(extensionToken);
-            let stderrBuffer = '';
-            let settled = false;
-            const settleError = (kind, extra = {}) => {
-                if (settled)
-                    return;
-                settled = true;
-                this._state = 'idle';
-                clearTimeout(timer);
-                this._resetAfterFailedConnect();
-                reject(formatBrowserConnectError({
-                    kind,
-                    timeout,
-                    hasExtensionToken: !!extensionToken,
-                    tokenFingerprint,
-                    stderr: stderrBuffer,
-                    exitCode: extra.exitCode,
-                    rawMessage: extra.rawMessage,
-                }));
-            };
-            const settleSuccess = (pageToResolve) => {
-                if (settled)
-                    return;
-                settled = true;
-                this._state = 'connected';
-                clearTimeout(timer);
-                resolve(pageToResolve);
-            };
-            const timer = setTimeout(() => {
-                debugLog('Connection timed out');
-                settleError(inferConnectFailureKind({
-                    hasExtensionToken: !!extensionToken,
-                    stderr: stderrBuffer,
-                    isCdpMode: requestedCdp,
-                }));
-            }, timeout * 1000);
-            const launchSpec = buildMcpLaunchSpec({
-                mcpPath,
-                executablePath: process.env.OPENCLI_BROWSER_EXECUTABLE_PATH,
-                cdpEndpoint,
-            });
-            if (process.env.OPENCLI_VERBOSE) {
-                console.error(`[opencli] Mode: ${requestedCdp ? 'CDP' : useExtension ? 'extension' : 'standalone'}`);
-                if (useExtension)
-                    console.error(`[opencli] Extension token: fingerprint ${tokenFingerprint}`);
-                if (launchSpec.usedNpxFallback) {
-                    console.error('[opencli] Playwright MCP not found locally; bootstrapping via npx @playwright/mcp@latest');
-                }
-            }
-            debugLog(`Spawning ${launchSpec.command} ${launchSpec.args.join(' ')}`);
-            this._proc = spawn(launchSpec.command, launchSpec.args, {
-                stdio: ['pipe', 'pipe', 'pipe'],
-                env: { ...process.env },
-            });
-            // Increase max listeners to avoid warnings
-            this._proc.setMaxListeners(20);
-            if (this._proc.stdout)
-                this._proc.stdout.setMaxListeners(20);
-            const page = new Page((method, params = {}) => this._sendRequest(method, params));
-            this._page = page;
-            this._proc.stdout?.on('data', (chunk) => {
-                this._buffer += chunk.toString();
-                const lines = this._buffer.split('\n');
-                this._buffer = lines.pop() ?? '';
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    debugLog(`RECV: ${line}`);
-                    try {
-                        const parsed = JSON.parse(line);
-                        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}`);
-                    }
-                }
-            });
-            this._proc.stderr?.on('data', (chunk) => {
-                const text = chunk.toString();
-                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({
-                        hasExtensionToken: !!extensionToken,
-                        stderr: stderrBuffer,
-                        exited: true,
-                        isCdpMode: requestedCdp,
-                    }), { exitCode: code });
-                }
-            });
-            // Initialize: send initialize request
-            debugLog('Waiting for initialize response...');
-            this._sendRequest('initialize', {
-                protocolVersion: '2024-11-05',
-                capabilities: {},
-                clientInfo: { name: 'opencli', version: PKG_VERSION },
-            }).then((resp) => {
-                debugLog('Got initialize response');
-                if (resp.error) {
-                    settleError(inferConnectFailureKind({
-                        hasExtensionToken: !!extensionToken,
-                        stderr: stderrBuffer,
-                        rawMessage: `MCP init failed: ${resp.error.message}`,
-                        isCdpMode: requestedCdp,
-                    }), { rawMessage: resp.error.message });
-                    return;
-                }
-                const initializedMsg = JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n';
-                debugLog(`SEND: ${initializedMsg.trim()}`);
-                this._proc?.stdin?.write(initializedMsg);
-                // Use tabs as a readiness probe and for tab cleanup bookkeeping.
-                debugLog('Fetching initial tabs count...');
-                withTimeoutMs(page.tabs(), INITIAL_TABS_TIMEOUT_MS, 'Timed out fetching initial tabs').then((tabs) => {
-                    debugLog(`Tabs response: ${typeof tabs === 'string' ? tabs : JSON.stringify(tabs)}`);
-                    this._initialTabIdentities = extractTabIdentities(tabs);
-                    settleSuccess(page);
-                }).catch((err) => {
-                    debugLog(`Tabs fetch error: ${err.message}`);
-                    settleSuccess(page);
-                });
-            }).catch((err) => {
-                debugLog(`Init promise rejected: ${err.message}`);
-                settleError('mcp-init', { rawMessage: err.message });
-            });
-        });
+        try {
+            await this._ensureDaemon();
+            this._page = new Page();
+            this._state = 'connected';
+            return this._page;
+        }
+        catch (err) {
+            this._state = 'idle';
+            throw err;
+        }
     }
     async close() {
-        if (this._closingPromise)
-            return this._closingPromise;
         if (this._state === 'closed')
             return;
         this._state = 'closing';
-        this._closingPromise = (async () => {
-            try {
-                // Extension mode opens bridge/session tabs that we can clean up best-effort.
-                if (this._page && this._proc && !this._proc.killed) {
-                    try {
-                        const tabs = await withTimeoutMs(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((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 { }
-                    }
-                }
-            }
-            finally {
-                this._rejectPendingRequests(new Error('Playwright MCP session closed'));
-                this._page = null;
-                this._proc = null;
-                this._state = 'closed';
-                PlaywrightMCP._activeInsts.delete(this);
-            }
-        })();
-        return this._closingPromise;
+        // We don't kill the daemon — it auto-exits on idle.
+        // Just clean up our reference.
+        this._page = null;
+        this._state = 'closed';
+    }
+    async _ensureDaemon() {
+        if (await isDaemonRunning())
+            return;
+        // Find daemon relative to this file — works for both:
+        //   npx tsx src/main.ts  → src/browser/mcp.ts  → src/daemon.ts
+        //   node dist/main.js    → dist/browser/mcp.js → dist/daemon.js
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const parentDir = path.resolve(__dirname, '..');
+        const daemonTs = path.join(parentDir, 'daemon.ts');
+        const daemonJs = path.join(parentDir, 'daemon.js');
+        const isTs = fs.existsSync(daemonTs);
+        const daemonPath = isTs ? daemonTs : daemonJs;
+        if (process.env.OPENCLI_VERBOSE) {
+            console.error(`[opencli] Starting daemon (${isTs ? 'ts' : 'js'})...`);
+        }
+        // Use the current runtime to spawn daemon — avoids slow npx resolution.
+        // If already running under tsx (dev), process.execPath is tsx's node.
+        // If running compiled (node dist/), process.execPath is node.
+        this._daemonProc = spawn(process.execPath, [daemonPath], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env },
+        });
+        this._daemonProc.unref();
+        // Wait for daemon to be ready AND extension to connect
+        const deadline = Date.now() + DAEMON_SPAWN_TIMEOUT;
+        while (Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, 300));
+            if (await isExtensionConnected())
+                return;
+        }
+        // Daemon might be up but extension not connected — give a useful error
+        if (await isDaemonRunning()) {
+            throw new Error('Daemon is running but the Browser Extension is not connected.\n' +
+                'Please install and enable the opencli Browser Bridge extension in Chrome.');
+        }
+        throw new Error('Failed to start opencli daemon. Try running manually:\n' +
+            `  node ${daemonPath}\n` +
+            'Make sure port 19825 is available.');
     }
 }

package/dist/browser/page.d.ts

@@ -1,14 +1,23 @@
 /**
- * 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 type { IPage } from '../types.js';
 /**
- * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
+ * Page — implements IPage by talking to the daemon via HTTP.
  */
 export declare class Page implements IPage {
-    private _request;
-    constructor(_request: (method: string, params?: Record<string, unknown>) => Promise<Record<string, unknown>>);
-    call(method: string, params?: Record<string, unknown>): Promise<any>;
+    /** Active tab ID, set after navigate and used in all subsequent commands */
+    private _tabId;
+    /** Helper: spread tabId into command params if we have one */
+    private _tabOpt;
     goto(url: string): Promise<void>;
     evaluate(js: string): Promise<any>;
     snapshot(opts?: {
@@ -31,7 +40,20 @@ export declare class Page implements IPage {
     selectTab(index: number): Promise<void>;
     networkRequests(includeStatic?: boolean): Promise<any>;
     consoleMessages(level?: string): Promise<any>;
-    scroll(direction?: string, _amount?: number): Promise<void>;
+    /**
+     * 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)
+     */
+    screenshot(options?: {
+        format?: 'png' | 'jpeg';
+        quality?: number;
+        fullPage?: boolean;
+        path?: string;
+    }): Promise<string>;
+    scroll(direction?: string, amount?: number): Promise<void>;
     autoScroll(options?: {
         times?: number;
         delayMs?: number;