@jackwener/opencli 0.9.8 → 1.0.0

package/dist/browser/discover.js

@@ -1,212 +1,22 @@
 /**
- * MCP server path discovery and argument building.
+ * Daemon discovery — simplified from MCP server path discovery.
+ *
+ * Only needs to check if the daemon is running. No more file system
+ * scanning for @playwright/mcp locations.
  */
-import { execSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-let _cachedMcpServerPath;
-let _existsSync = fs.existsSync;
-let _execSync = execSync;
-function isSupportedMcpEntrypoint(candidate) {
-    const normalized = candidate.replace(/\\/g, '/').toLowerCase();
-    return normalized.endsWith('/@playwright/mcp/cli.js') ||
-        normalized.endsWith('/mcp-server-playwright') ||
-        normalized.endsWith('/mcp-server-playwright.js');
-}
-function resolveSupportedMcpPath(candidate) {
-    const trimmed = candidate?.trim();
-    if (!trimmed || !_existsSync(trimmed))
-        return null;
-    return isSupportedMcpEntrypoint(trimmed) ? trimmed : null;
-}
-export function resetMcpServerPathCache() {
-    _cachedMcpServerPath = undefined;
-}
-export function setMcpDiscoveryTestHooks(input) {
-    _existsSync = input?.existsSync ?? fs.existsSync;
-    _execSync = input?.execSync ?? execSync;
-}
-export function findMcpServerPath() {
-    if (_cachedMcpServerPath !== undefined)
-        return _cachedMcpServerPath;
-    const envMcp = process.env.OPENCLI_MCP_SERVER_PATH;
-    if (envMcp && _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 (_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 (_existsSync(projectMcp)) {
-        _cachedMcpServerPath = projectMcp;
-        return _cachedMcpServerPath;
-    }
-    // Check global npm/yarn locations derived from current Node runtime.
-    const nodePrefix = path.resolve(path.dirname(process.execPath), '..');
-    const globalNodeModules = path.join(nodePrefix, 'lib', 'node_modules');
-    const globalMcp = path.join(globalNodeModules, '@playwright', 'mcp', 'cli.js');
-    if (_existsSync(globalMcp)) {
-        _cachedMcpServerPath = globalMcp;
-        return _cachedMcpServerPath;
-    }
-    // Check npm global root directly.
-    try {
-        const npmRootGlobal = _execSync('npm root -g 2>/dev/null', {
-            encoding: 'utf-8',
-            timeout: 5000,
-        }).trim();
-        const npmGlobalMcp = path.join(npmRootGlobal, '@playwright', 'mcp', 'cli.js');
-        if (npmRootGlobal && _existsSync(npmGlobalMcp)) {
-            _cachedMcpServerPath = npmGlobalMcp;
-            return _cachedMcpServerPath;
-        }
-    }
-    catch { }
-    // Check common locations
-    const candidates = [
-        path.join(os.homedir(), '.npm', '_npx'),
-        path.join(os.homedir(), 'node_modules', '.bin'),
-        '/usr/local/lib/node_modules',
-    ];
-    // 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();
-        const resolved = resolveSupportedMcpPath(result);
-        if (resolved) {
-            _cachedMcpServerPath = resolved;
-            return _cachedMcpServerPath;
-        }
-    }
-    catch { }
-    // Try which
-    try {
-        const result = _execSync('which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 5000 }).trim();
-        const resolved = resolveSupportedMcpPath(result);
-        if (resolved) {
-            _cachedMcpServerPath = resolved;
-            return _cachedMcpServerPath;
-        }
-    }
-    catch { }
-    // Search in common npx cache
-    for (const base of candidates) {
-        if (!_existsSync(base))
-            continue;
-        try {
-            const found = _execSync(`find "${base}" -type f -path "*/@playwright/mcp/cli.js" 2>/dev/null | head -1`, { encoding: 'utf-8', timeout: 5000 }).trim();
-            const resolved = resolveSupportedMcpPath(found);
-            if (resolved) {
-                _cachedMcpServerPath = resolved;
-                return _cachedMcpServerPath;
-            }
-        }
-        catch { }
-    }
-    _cachedMcpServerPath = null;
-    return _cachedMcpServerPath;
-}
+import { isDaemonRunning } from './daemon-client.js';
+export { isDaemonRunning };
 /**
- * Chrome 144+ auto-discovery: read DevToolsActivePort file to get CDP endpoint.
- *
- * Starting with Chrome 144, users can enable remote debugging from
- * chrome://inspect#remote-debugging without any command-line flags.
- * Chrome writes the active port and browser GUID to a DevToolsActivePort file
- * in the user data directory, which we read to construct the WebSocket endpoint.
+ * Check daemon status and return connection info.
  */
-export function discoverChromeEndpoint() {
-    const candidates = [];
-    // User-specified Chrome data dir takes highest priority
-    if (process.env.CHROME_USER_DATA_DIR) {
-        candidates.push(path.join(process.env.CHROME_USER_DATA_DIR, 'DevToolsActivePort'));
-    }
-    // Standard Chrome/Edge user data dirs per platform
-    if (process.platform === 'win32') {
-        const localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
-        candidates.push(path.join(localAppData, 'Google', 'Chrome', 'User Data', 'DevToolsActivePort'));
-        candidates.push(path.join(localAppData, 'Microsoft', 'Edge', 'User Data', 'DevToolsActivePort'));
-    }
-    else if (process.platform === 'darwin') {
-        candidates.push(path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome', 'DevToolsActivePort'));
-        candidates.push(path.join(os.homedir(), 'Library', 'Application Support', 'Microsoft Edge', 'DevToolsActivePort'));
-    }
-    else {
-        candidates.push(path.join(os.homedir(), '.config', 'google-chrome', 'DevToolsActivePort'));
-        candidates.push(path.join(os.homedir(), '.config', 'chromium', 'DevToolsActivePort'));
-        candidates.push(path.join(os.homedir(), '.config', 'microsoft-edge', 'DevToolsActivePort'));
-    }
-    for (const filePath of candidates) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8').trim();
-            const lines = content.split('\n');
-            if (lines.length >= 2) {
-                const port = parseInt(lines[0], 10);
-                const browserPath = lines[1]; // e.g. /devtools/browser/<GUID>
-                if (port > 0 && browserPath.startsWith('/devtools/browser/')) {
-                    return `ws://127.0.0.1:${port}${browserPath}`;
-                }
-            }
-        }
-        catch { }
-    }
-    return null;
-}
-export function resolveCdpEndpoint() {
-    const envVal = process.env.OPENCLI_CDP_ENDPOINT;
-    if (envVal === '1' || envVal?.toLowerCase() === 'true') {
-        const autoDiscovered = discoverChromeEndpoint();
-        return { endpoint: autoDiscovered ?? envVal, requestedCdp: true };
-    }
-    if (envVal) {
-        return { endpoint: envVal, requestedCdp: true };
-    }
-    // Fallback to auto-discovery if not explicitly set
-    const autoDiscovered = discoverChromeEndpoint();
-    if (autoDiscovered) {
-        return { endpoint: autoDiscovered, requestedCdp: true };
-    }
-    return { requestedCdp: false };
-}
-function buildRuntimeArgs(input) {
-    const args = [];
-    // Priority 1: CDP endpoint (remote Chrome debugging or local Auto-Discovery)
-    if (input?.cdpEndpoint) {
-        args.push('--cdp-endpoint', input.cdpEndpoint);
-        return args;
-    }
-    // Priority 2: Extension mode (local Chrome with MCP Bridge extension)
-    if (!process.env.CI) {
-        args.push('--extension');
-    }
-    // CI/standalone mode: @playwright/mcp launches its own browser (headed by default).
-    // xvfb provides a virtual display for headed mode in GitHub Actions.
-    if (input?.executablePath) {
-        args.push('--executable-path', input.executablePath);
+export async function checkDaemonStatus() {
+    try {
+        const port = parseInt(process.env.OPENCLI_DAEMON_PORT ?? '19825', 10);
+        const res = await fetch(`http://127.0.0.1:${port}/status`);
+        const data = await res.json();
+        return { running: true, extensionConnected: data.extensionConnected };
     }
-    return args;
-}
-export function buildMcpArgs(input) {
-    return [input.mcpPath, ...buildRuntimeArgs(input)];
-}
-export function buildMcpLaunchSpec(input) {
-    const runtimeArgs = buildRuntimeArgs(input);
-    if (input.mcpPath) {
-        return {
-            command: 'node',
-            args: [input.mcpPath, ...runtimeArgs],
-            usedNpxFallback: false,
-        };
+    catch {
+        return { running: false, extensionConnected: false };
     }
-    return {
-        command: 'npx',
-        args: ['-y', '@playwright/mcp@latest', ...runtimeArgs],
-        usedNpxFallback: true,
-    };
 }

package/dist/browser/errors.d.ts

@@ -1,22 +1,8 @@
 /**
- * Browser connection error classification and formatting.
+ * Browser connection error helpers.
+ *
+ * Simplified — no more token/extension/CDP classification.
+ * The daemon architecture has a single failure mode: daemon not reachable or extension not connected.
  */
-export type ConnectFailureKind = 'missing-token' | 'extension-timeout' | 'extension-not-installed' | 'mcp-init' | 'process-exit' | 'cdp-connection-failed' | 'unknown';
-export type ConnectFailureInput = {
-    kind: ConnectFailureKind;
-    timeout: number;
-    hasExtensionToken: boolean;
-    tokenFingerprint?: string | null;
-    stderr?: string;
-    exitCode?: number | null;
-    rawMessage?: string;
-};
-export declare function getTokenFingerprint(token: string | undefined): string | null;
-export declare function formatBrowserConnectError(input: ConnectFailureInput): Error;
-export declare function inferConnectFailureKind(args: {
-    hasExtensionToken: boolean;
-    stderr: string;
-    rawMessage?: string;
-    exited?: boolean;
-    isCdpMode?: boolean;
-}): ConnectFailureKind;
+export type ConnectFailureKind = 'daemon-not-running' | 'extension-not-connected' | 'command-failed' | 'unknown';
+export declare function formatBrowserConnectError(kind: ConnectFailureKind, detail?: string): Error;

package/dist/browser/errors.js

@@ -1,67 +1,28 @@
 /**
- * Browser connection error classification and formatting.
+ * Browser connection error helpers.
+ *
+ * Simplified — no more token/extension/CDP classification.
+ * The daemon architecture has a single failure mode: daemon not reachable or extension not connected.
  */
-import { createHash } from 'node:crypto';
-export function getTokenFingerprint(token) {
-    if (!token)
-        return null;
-    return createHash('sha256').update(token).digest('hex').slice(0, 8);
-}
-export function formatBrowserConnectError(input) {
-    const stderr = input.stderr?.trim();
-    const suffix = stderr ? `\n\nMCP stderr:\n${stderr}` : '';
-    const tokenHint = input.tokenFingerprint ? ` Token fingerprint: ${input.tokenFingerprint}.` : '';
-    if (input.kind === 'cdp-connection-failed') {
-        return new Error(`Failed to connect to remote Chrome via CDP endpoint.\n\n` +
-            `Check if Chrome is running with remote debugging enabled (--remote-debugging-port=9222) or DevToolsActivePort is available under chrome://inspect#remote-debugging.\n` +
-            `If you specified OPENCLI_CDP_ENDPOINT=1, auto-discovery might have failed.` +
-            suffix);
-    }
-    if (input.kind === 'missing-token') {
-        return new Error('Failed to connect to Playwright MCP Bridge: PLAYWRIGHT_MCP_EXTENSION_TOKEN is not set.\n\n' +
-            'Without this token, Chrome will show a manual approval dialog for every new MCP connection. ' +
-            'Copy the token from the Playwright MCP Bridge extension and set it in BOTH your shell environment and MCP client config.' +
-            suffix);
-    }
-    if (input.kind === 'extension-not-installed') {
-        return new Error('Failed to connect to Playwright MCP Bridge: the browser extension did not attach.\n\n' +
-            'Make sure Chrome is running and the "Playwright MCP Bridge" extension is installed and enabled. ' +
-            'If Chrome shows an approval dialog, click Allow.' +
-            suffix);
-    }
-    if (input.kind === 'extension-timeout') {
-        const likelyCause = input.hasExtensionToken
-            ? `The most likely cause is that PLAYWRIGHT_MCP_EXTENSION_TOKEN does not match the token currently shown by the browser extension.${tokenHint} Re-copy the token from the extension and update BOTH your shell environment and MCP client config.`
-            : 'PLAYWRIGHT_MCP_EXTENSION_TOKEN is not configured, so the extension may be waiting for manual approval.';
-        return new Error(`Timed out connecting to Playwright MCP Bridge (${input.timeout}s).\n\n` +
-            `${likelyCause} If a browser prompt is visible, click Allow.` +
-            suffix);
-    }
-    if (input.kind === 'mcp-init') {
-        return new Error(`Failed to initialize Playwright MCP: ${input.rawMessage ?? 'unknown error'}${suffix}`);
-    }
-    if (input.kind === 'process-exit') {
-        return new Error(`Playwright MCP process exited before the browser connection was established${input.exitCode == null ? '' : ` (code ${input.exitCode})`}.` +
-            suffix);
-    }
-    return new Error(input.rawMessage ?? 'Failed to connect to browser');
-}
-export function inferConnectFailureKind(args) {
-    const haystack = `${args.rawMessage ?? ''}\n${args.stderr}`.toLowerCase();
-    if (args.isCdpMode) {
-        if (args.rawMessage?.startsWith('MCP init failed:'))
-            return 'mcp-init';
-        if (args.exited)
-            return 'cdp-connection-failed';
-        return 'cdp-connection-failed';
+export function formatBrowserConnectError(kind, detail) {
+    switch (kind) {
+        case 'daemon-not-running':
+            return new Error('Cannot connect to opencli daemon.\n\n' +
+                'The daemon should start automatically. If it doesn\'t, try:\n' +
+                '  node dist/daemon.js\n' +
+                'Make sure port 19825 is available.' +
+                (detail ? `\n\n${detail}` : ''));
+        case 'extension-not-connected':
+            return new Error('opencli Browser Bridge extension is not connected.\n\n' +
+                'Please install the extension:\n' +
+                '  1. Download from GitHub Releases\n' +
+                '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
+                '  3. Click "Load unpacked" → select the extension folder\n' +
+                '  4. Make sure Chrome is running' +
+                (detail ? `\n\n${detail}` : ''));
+        case 'command-failed':
+            return new Error(`Browser command failed: ${detail ?? 'unknown error'}`);
+        default:
+            return new Error(detail ?? 'Failed to connect to browser');
     }
-    if (!args.hasExtensionToken)
-        return 'missing-token';
-    if (haystack.includes('extension connection timeout') || haystack.includes('playwright mcp bridge'))
-        return 'extension-not-installed';
-    if (args.rawMessage?.startsWith('MCP init failed:'))
-        return 'mcp-init';
-    if (args.exited)
-        return 'process-exit';
-    return 'extension-timeout';
 }

package/dist/browser/index.d.ts

@@ -6,22 +6,13 @@
  */
 export { Page } from './page.js';
 export { PlaywrightMCP } from './mcp.js';
-export { getTokenFingerprint, formatBrowserConnectError } from './errors.js';
-export type { ConnectFailureKind, ConnectFailureInput } from './errors.js';
-export { resolveCdpEndpoint } from './discover.js';
-import { createJsonRpcRequest } from './mcp.js';
+export { isDaemonRunning } from './daemon-client.js';
+export declare function getTokenFingerprint(_token: string | undefined): string | null;
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
-import { buildMcpArgs, buildMcpLaunchSpec, findMcpServerPath, resetMcpServerPathCache, setMcpDiscoveryTestHooks } from './discover.js';
 import { withTimeoutMs } from '../runtime.js';
 export declare const __test__: {
-    createJsonRpcRequest: typeof createJsonRpcRequest;
     extractTabEntries: typeof extractTabEntries;
     diffTabIndexes: typeof diffTabIndexes;
     appendLimited: typeof appendLimited;
-    buildMcpArgs: typeof buildMcpArgs;
-    buildMcpLaunchSpec: typeof buildMcpLaunchSpec;
-    findMcpServerPath: typeof findMcpServerPath;
-    resetMcpServerPathCache: typeof resetMcpServerPathCache;
-    setMcpDiscoveryTestHooks: typeof setMcpDiscoveryTestHooks;
     withTimeoutMs: typeof withTimeoutMs;
 };

package/dist/browser/index.js

@@ -6,22 +6,16 @@
  */
 export { Page } from './page.js';
 export { PlaywrightMCP } from './mcp.js';
-export { getTokenFingerprint, formatBrowserConnectError } from './errors.js';
-export { resolveCdpEndpoint } from './discover.js';
-// Test-only helpers — exposed for unit tests
-import { createJsonRpcRequest } from './mcp.js';
+export { isDaemonRunning } from './daemon-client.js';
+// Backward compatibility: getTokenFingerprint is no longer needed but kept as no-op export
+export function getTokenFingerprint(_token) {
+    return null;
+}
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
-import { buildMcpArgs, buildMcpLaunchSpec, findMcpServerPath, resetMcpServerPathCache, setMcpDiscoveryTestHooks } from './discover.js';
 import { withTimeoutMs } from '../runtime.js';
 export const __test__ = {
-    createJsonRpcRequest,
     extractTabEntries,
     diffTabIndexes,
     appendLimited,
-    buildMcpArgs,
-    buildMcpLaunchSpec,
-    findMcpServerPath,
-    resetMcpServerPathCache,
-    setMcpDiscoveryTestHooks,
     withTimeoutMs,
 };

package/dist/browser/mcp.d.ts

@@ -1,33 +1,24 @@
 /**
- * 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 type { IPage } from '../types.js';
 export type PlaywrightMCPState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
-export declare function createJsonRpcRequest(method: string, params?: Record<string, unknown>): {
-    id: number;
-    message: string;
-};
 /**
- * Playwright MCP process manager.
+ * Browser factory: manages daemon lifecycle and provides IPage instances.
+ *
+ * Kept as `PlaywrightMCP` class name for backward compatibility.
  */
 export declare class PlaywrightMCP {
-    private static _activeInsts;
-    private static _cleanupRegistered;
-    private static _registerGlobalCleanup;
-    private _proc;
-    private _buffer;
-    private _pending;
-    private _initialTabIdentities;
-    private _closingPromise;
     private _state;
     private _page;
+    private _daemonProc;
     get state(): PlaywrightMCPState;
-    private _sendRequest;
-    private _rejectPendingRequests;
-    private _resetAfterFailedConnect;
     connect(opts?: {
         timeout?: number;
     }): Promise<IPage>;
     close(): Promise<void>;
+    private _ensureDaemon;
 }