@jackwener/opencli 0.9.8 → 1.0.1

package/src/browser/daemon-client.ts

@@ -0,0 +1,113 @@
+/**
+ * HTTP client for communicating with the opencli daemon.
+ *
+ * Provides a typed send() function that posts a Command and returns a Result.
+ */
+
+const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? '19825', 10);
+const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
+
+let _idCounter = 0;
+
+function generateId(): string {
+  return `cmd_${Date.now()}_${++_idCounter}`;
+}
+
+export interface DaemonCommand {
+  id: string;
+  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window';
+  tabId?: number;
+  code?: string;
+  url?: string;
+  op?: string;
+  index?: number;
+  domain?: string;
+  format?: 'png' | 'jpeg';
+  quality?: number;
+  fullPage?: boolean;
+}
+
+export interface DaemonResult {
+  id: string;
+  ok: boolean;
+  data?: unknown;
+  error?: string;
+}
+
+/**
+ * Check if daemon is running.
+ */
+export async function isDaemonRunning(): Promise<boolean> {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2000);
+    const res = await fetch(`${DAEMON_URL}/status`, { signal: controller.signal });
+    clearTimeout(timer);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if daemon is running AND the extension is connected.
+ */
+export async function isExtensionConnected(): Promise<boolean> {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2000);
+    const res = await fetch(`${DAEMON_URL}/status`, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return false;
+    const data = await res.json() as { extensionConnected?: boolean };
+    return !!data.extensionConnected;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Send a command to the daemon and wait for a result.
+ * Retries up to 3 times with 500ms delay for transient failures.
+ */
+export async function sendCommand(
+  action: DaemonCommand['action'],
+  params: Omit<DaemonCommand, 'id' | 'action'> = {},
+): Promise<unknown> {
+  const id = generateId();
+  const command: DaemonCommand = { id, action, ...params };
+  const maxRetries = 3;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 30000);
+
+      const res = await fetch(`${DAEMON_URL}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(command),
+        signal: controller.signal,
+      });
+      clearTimeout(timer);
+
+      const result = (await res.json()) as DaemonResult;
+
+      if (!result.ok) {
+        throw new Error(result.error ?? 'Daemon command failed');
+      }
+
+      return result.data;
+    } catch (err) {
+      const isRetryable = err instanceof TypeError  // fetch network error
+        || (err instanceof Error && err.name === 'AbortError');
+      if (isRetryable && attempt < maxRetries) {
+        await new Promise(r => setTimeout(r, 500));
+        continue;
+      }
+      throw err;
+    }
+  }
+  // Unreachable — the loop always returns or throws
+  throw new Error('sendCommand: max retries exhausted');
+}

package/src/browser/discover.ts

@@ -1,241 +1,27 @@
 /**
- * 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: string | null | undefined;
-let _existsSync = fs.existsSync;
-let _execSync = execSync;
-
-function isSupportedMcpEntrypoint(candidate: string): boolean {
-  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: string | null | undefined): string | null {
-  const trimmed = candidate?.trim();
-  if (!trimmed || !_existsSync(trimmed)) return null;
-  return isSupportedMcpEntrypoint(trimmed) ? trimmed : null;
-}
-
-export function resetMcpServerPathCache(): void {
-  _cachedMcpServerPath = undefined;
-}
-
-export function setMcpDiscoveryTestHooks(input?: {
-  existsSync?: typeof fs.existsSync;
-  execSync?: typeof execSync;
-}): void {
-  _existsSync = input?.existsSync ?? fs.existsSync;
-  _execSync = input?.execSync ?? execSync;
-}
-
-export function findMcpServerPath(): string | null {
-  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;
-  }
+import { isDaemonRunning } from './daemon-client.js';
 
-  // 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;
-}
+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(): string | null {
-  const candidates: string[] = [];
-
-  // 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(): { endpoint?: string; requestedCdp: boolean } {
-  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?: { executablePath?: string | null; cdpEndpoint?: string }): string[] {
-  const args: string[] = [];
-
-  // 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);
-  }
-  return args;
-}
-
-export function buildMcpArgs(input: { mcpPath: string; executablePath?: string | null; cdpEndpoint?: string }): string[] {
-  return [input.mcpPath, ...buildRuntimeArgs(input)];
-}
-
-export function buildMcpLaunchSpec(input: { mcpPath?: string | null; executablePath?: string | null; cdpEndpoint?: string }): {
-  command: string;
-  args: string[];
-  usedNpxFallback: boolean;
-} {
-  const runtimeArgs = buildRuntimeArgs(input);
-  if (input.mcpPath) {
-    return {
-      command: 'node',
-      args: [input.mcpPath, ...runtimeArgs],
-      usedNpxFallback: false,
-    };
+export async function checkDaemonStatus(): Promise<{
+  running: boolean;
+  extensionConnected: boolean;
+}> {
+  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() as { ok: boolean; extensionConnected: boolean };
+    return { running: true, extensionConnected: data.extensionConnected };
+  } catch {
+    return { running: false, extensionConnected: false };
   }
-
-  return {
-    command: 'npx',
-    args: ['-y', '@playwright/mcp@latest', ...runtimeArgs],
-    usedNpxFallback: true,
-  };
 }

package/src/browser/errors.ts

@@ -1,105 +1,35 @@
 /**
- * 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 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 function getTokenFingerprint(token: string | undefined): string | null {
-  if (!token) return null;
-  return createHash('sha256').update(token).digest('hex').slice(0, 8);
-}
-
-export function formatBrowserConnectError(input: ConnectFailureInput): Error {
-  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}`);
+export type ConnectFailureKind = 'daemon-not-running' | 'extension-not-connected' | 'command-failed' | 'unknown';
+
+export function formatBrowserConnectError(kind: ConnectFailureKind, detail?: string): Error {
+  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 (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: {
-  hasExtensionToken: boolean;
-  stderr: string;
-  rawMessage?: string;
-  exited?: boolean;
-  isCdpMode?: boolean;
-}): ConnectFailureKind {
-  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';
-  }
-
-  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/src/browser/index.ts

@@ -6,26 +6,15 @@
  */
 
 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';
+export { BrowserBridge, BrowserBridge as PlaywrightMCP } from './mcp.js';
+export { isDaemonRunning } from './daemon-client.js';
 
-// Test-only helpers — exposed for unit tests
-import { createJsonRpcRequest } from './mcp.js';
 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,
 };