@jackwener/opencli 0.9.8 → 1.0.0

package/src/daemon.ts

@@ -0,0 +1,217 @@
+/**
+ * opencli micro-daemon — HTTP + WebSocket bridge between CLI and Chrome Extension.
+ *
+ * Architecture:
+ *   CLI → HTTP POST /command → daemon → WebSocket → Extension
+ *   Extension → WebSocket result → daemon → HTTP response → CLI
+ *
+ * Lifecycle:
+ *   - Auto-spawned by opencli on first browser command
+ *   - Auto-exits after 5 minutes of idle
+ *   - Listens on localhost:19825
+ */
+
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { WebSocketServer, WebSocket } from 'ws';
+
+const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? '19825', 10);
+const IDLE_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+
+// ─── State ───────────────────────────────────────────────────────────
+
+let extensionWs: WebSocket | null = null;
+const pending = new Map<string, {
+  resolve: (data: unknown) => void;
+  reject: (error: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}>();
+let idleTimer: ReturnType<typeof setTimeout> | null = null;
+
+// Extension log ring buffer
+interface LogEntry { level: string; msg: string; ts: number; }
+const LOG_BUFFER_SIZE = 200;
+const logBuffer: LogEntry[] = [];
+
+function pushLog(entry: LogEntry): void {
+  logBuffer.push(entry);
+  if (logBuffer.length > LOG_BUFFER_SIZE) logBuffer.shift();
+}
+
+// ─── Idle auto-exit ──────────────────────────────────────────────────
+
+function resetIdleTimer(): void {
+  if (idleTimer) clearTimeout(idleTimer);
+  idleTimer = setTimeout(() => {
+    console.error('[daemon] Idle timeout, shutting down');
+    process.exit(0);
+  }, IDLE_TIMEOUT);
+}
+
+// ─── HTTP Server ─────────────────────────────────────────────────────
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (c: Buffer) => chunks.push(c));
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    req.on('error', reject);
+  });
+}
+
+function jsonResponse(res: ServerResponse, status: number, data: unknown): void {
+  res.writeHead(status, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+  res.end(JSON.stringify(data));
+}
+
+async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+  if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+
+  const url = req.url ?? '/';
+  const pathname = url.split('?')[0];
+
+  if (req.method === 'GET' && pathname === '/status') {
+    jsonResponse(res, 200, {
+      ok: true,
+      extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
+      pending: pending.size,
+    });
+    return;
+  }
+
+  if (req.method === 'GET' && pathname === '/logs') {
+    const params = new URL(url, `http://localhost:${PORT}`).searchParams;
+    const level = params.get('level');
+    const filtered = level
+      ? logBuffer.filter(e => e.level === level)
+      : logBuffer;
+    jsonResponse(res, 200, { ok: true, logs: filtered });
+    return;
+  }
+
+  if (req.method === 'DELETE' && pathname === '/logs') {
+    logBuffer.length = 0;
+    jsonResponse(res, 200, { ok: true });
+    return;
+  }
+
+  if (req.method === 'POST' && url === '/command') {
+    resetIdleTimer();
+    try {
+      const body = JSON.parse(await readBody(req));
+      if (!body.id) {
+        jsonResponse(res, 400, { ok: false, error: 'Missing command id' });
+        return;
+      }
+
+      if (!extensionWs || extensionWs.readyState !== WebSocket.OPEN) {
+        jsonResponse(res, 503, { id: body.id, ok: false, error: 'Extension not connected. Please install the opencli Browser Bridge extension.' });
+        return;
+      }
+
+      const result = await new Promise<unknown>((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(body.id);
+          reject(new Error('Command timeout (30s)'));
+        }, 30000);
+        pending.set(body.id, { resolve, reject, timer });
+        extensionWs!.send(JSON.stringify(body));
+      });
+
+      jsonResponse(res, 200, result);
+    } catch (err) {
+      jsonResponse(res, err instanceof Error && err.message.includes('timeout') ? 408 : 400, {
+        ok: false,
+        error: err instanceof Error ? err.message : 'Invalid request',
+      });
+    }
+    return;
+  }
+
+  jsonResponse(res, 404, { error: 'Not found' });
+}
+
+// ─── WebSocket for Extension ─────────────────────────────────────────
+
+const httpServer = createServer((req, res) => { handleRequest(req, res).catch(() => { res.writeHead(500); res.end(); }); });
+const wss = new WebSocketServer({ server: httpServer, path: '/ext' });
+
+wss.on('connection', (ws) => {
+  console.error('[daemon] Extension connected');
+  extensionWs = ws;
+
+  ws.on('message', (data) => {
+    try {
+      const msg = JSON.parse(data.toString());
+
+      // Handle log messages from extension
+      if (msg.type === 'log') {
+        const prefix = msg.level === 'error' ? '❌' : msg.level === 'warn' ? '⚠️' : '📋';
+        console.error(`${prefix} [ext] ${msg.msg}`);
+        pushLog({ level: msg.level, msg: msg.msg, ts: msg.ts ?? Date.now() });
+        return;
+      }
+
+      // Handle command results
+      const p = pending.get(msg.id);
+      if (p) {
+        clearTimeout(p.timer);
+        pending.delete(msg.id);
+        p.resolve(msg);
+      }
+    } catch {
+      // Ignore malformed messages
+    }
+  });
+
+  ws.on('close', () => {
+    console.error('[daemon] Extension disconnected');
+    if (extensionWs === ws) {
+      extensionWs = null;
+      // Reject all pending requests since the extension is gone
+      for (const [id, p] of pending) {
+        clearTimeout(p.timer);
+        p.reject(new Error('Extension disconnected'));
+      }
+      pending.clear();
+    }
+  });
+
+  ws.on('error', () => {
+    if (extensionWs === ws) extensionWs = null;
+  });
+});
+
+// ─── Start ───────────────────────────────────────────────────────────
+
+httpServer.listen(PORT, '127.0.0.1', () => {
+  console.error(`[daemon] Listening on http://127.0.0.1:${PORT}`);
+  resetIdleTimer();
+});
+
+httpServer.on('error', (err: NodeJS.ErrnoException) => {
+  if (err.code === 'EADDRINUSE') {
+    console.error(`[daemon] Port ${PORT} already in use — another daemon is likely running. Exiting.`);
+    process.exit(0);
+  }
+  console.error('[daemon] Server error:', err.message);
+  process.exit(1);
+});
+
+// Graceful shutdown
+function shutdown(): void {
+  // Reject all pending requests so CLI doesn't hang
+  for (const [, p] of pending) {
+    clearTimeout(p.timer);
+    p.reject(new Error('Daemon shutting down'));
+  }
+  pending.clear();
+  if (extensionWs) extensionWs.close();
+  httpServer.close();
+  process.exit(0);
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);

package/src/doctor.test.ts

@@ -1,223 +1,62 @@
 import { describe, expect, it } from 'vitest';
-import {
-  readTokenFromShellContent,
-  renderBrowserDoctorReport,
-  upsertShellToken,
-  readTomlConfigToken,
-  upsertTomlConfigToken,
-  upsertJsonConfigToken,
-} from './doctor.js';
-
-describe('shell token helpers', () => {
-  it('reads token from shell export', () => {
-    expect(readTokenFromShellContent('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="abc123"\n')).toBe('abc123');
-  });
-
-  it('appends token export when missing', () => {
-    const next = upsertShellToken('export PATH="/usr/bin"\n', 'abc123');
-    expect(next).toContain('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="abc123"');
-  });
-
-  it('replaces token export when present', () => {
-    const next = upsertShellToken('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="old"\n', 'new');
-    expect(next).toContain('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="new"');
-    expect(next).not.toContain('"old"');
-  });
-});
-
-describe('toml token helpers', () => {
-  it('reads token from playwright env section', () => {
-    const content = `
-[mcp_servers.playwright.env]
-PLAYWRIGHT_MCP_EXTENSION_TOKEN = "abc123"
-`;
-    expect(readTomlConfigToken(content)).toBe('abc123');
-  });
-
-  it('updates token inside existing env section', () => {
-    const content = `
-[mcp_servers.playwright.env]
-PLAYWRIGHT_MCP_EXTENSION_TOKEN = "old"
-`;
-    const next = upsertTomlConfigToken(content, 'new');
-    expect(next).toContain('PLAYWRIGHT_MCP_EXTENSION_TOKEN = "new"');
-    expect(next).not.toContain('"old"');
-  });
-
-  it('creates env section when missing', () => {
-    const content = `
-[mcp_servers.playwright]
-type = "stdio"
-`;
-    const next = upsertTomlConfigToken(content, 'abc123');
-    expect(next).toContain('[mcp_servers.playwright.env]');
-    expect(next).toContain('PLAYWRIGHT_MCP_EXTENSION_TOKEN = "abc123"');
-  });
-});
-
-describe('json token helpers', () => {
-  it('writes token into standard mcpServers config', () => {
-    const next = upsertJsonConfigToken(JSON.stringify({
-      mcpServers: {
-        playwright: {
-          command: 'npx',
-          args: ['-y', '@playwright/mcp@latest', '--extension'],
-        },
-      },
-    }), 'abc123');
-    const parsed = JSON.parse(next);
-    expect(parsed.mcpServers.playwright.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-  });
-
-  it('writes token into opencode mcp config', () => {
-    const next = upsertJsonConfigToken(JSON.stringify({
-      $schema: 'https://opencode.ai/config.json',
-      mcp: {
-        playwright: {
-          command: ['npx', '-y', '@playwright/mcp@latest', '--extension'],
-          enabled: true,
-          type: 'local',
-        },
-      },
-    }), 'abc123');
-    const parsed = JSON.parse(next);
-    expect(parsed.mcp.playwright.environment.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-  });
-
-  it('creates standard mcpServers format for empty file (not OpenCode)', () => {
-    const next = upsertJsonConfigToken('', 'abc123');
-    const parsed = JSON.parse(next);
-    expect(parsed.mcpServers.playwright.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-    expect(parsed.mcp).toBeUndefined();
-  });
-
-  it('creates OpenCode format when filePath contains opencode', () => {
-    const next = upsertJsonConfigToken('', 'abc123', '/home/user/.config/opencode/opencode.json');
-    const parsed = JSON.parse(next);
-    expect(parsed.mcp.playwright.environment.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-    expect(parsed.mcpServers).toBeUndefined();
-  });
-
-  it('creates standard format when filePath is claude.json', () => {
-    const next = upsertJsonConfigToken('', 'abc123', '/home/user/.claude.json');
-    const parsed = JSON.parse(next);
-    expect(parsed.mcpServers.playwright.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-  });
-});
-
-describe('fish shell support', () => {
-  it('generates fish set -gx syntax for fish config path', () => {
-    const next = upsertShellToken('', 'abc123', '/home/user/.config/fish/config.fish');
-    expect(next).toContain('set -gx PLAYWRIGHT_MCP_EXTENSION_TOKEN "abc123"');
-    expect(next).not.toContain('export');
-  });
-
-  it('replaces existing fish set line', () => {
-    const content = 'set -gx PLAYWRIGHT_MCP_EXTENSION_TOKEN "old"\n';
-    const next = upsertShellToken(content, 'new', '/home/user/.config/fish/config.fish');
-    expect(next).toContain('set -gx PLAYWRIGHT_MCP_EXTENSION_TOKEN "new"');
-    expect(next).not.toContain('"old"');
-  });
-
-  it('appends fish syntax to existing fish config', () => {
-    const content = 'set -gx PATH /usr/bin\n';
-    const next = upsertShellToken(content, 'abc123', '/home/user/.config/fish/config.fish');
-    expect(next).toContain('set -gx PLAYWRIGHT_MCP_EXTENSION_TOKEN "abc123"');
-    expect(next).toContain('set -gx PATH /usr/bin');
-  });
-
-  it('uses export syntax for zshrc even with filePath', () => {
-    const next = upsertShellToken('', 'abc123', '/home/user/.zshrc');
-    expect(next).toContain('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="abc123"');
-    expect(next).not.toContain('set -gx');
-  });
-});
+import { renderBrowserDoctorReport } from './doctor.js';
 
 describe('doctor report rendering', () => {
   const strip = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, '');
 
-  it('renders OK-style report when tokens match', () => {
+  it('renders OK-style report when daemon and extension connected', () => {
     const text = strip(renderBrowserDoctorReport({
-      envToken: 'abc123',
-      envFingerprint: 'fp1',
-      extensionToken: 'abc123',
-      extensionFingerprint: 'fp1',
-      extensionInstalled: true,
-      extensionBrowsers: ['Chrome'],
-      shellFiles: [{ path: '/tmp/.zshrc', exists: true, token: 'abc123', fingerprint: 'fp1' }],
-      configs: [{ path: '/tmp/mcp.json', exists: true, format: 'json', token: 'abc123', fingerprint: 'fp1', writable: true }],
-      recommendedToken: 'abc123',
-      recommendedFingerprint: 'fp1',
-      warnings: [],
+      daemonRunning: true,
+      extensionConnected: true,
       issues: [],
     }));
 
-    expect(text).toContain('[OK] Extension installed (Chrome)');
-    expect(text).toContain('[OK] Environment token: configured (fp1)');
-    expect(text).toContain('[OK] /tmp/mcp.json');
-    expect(text).toContain('configured (fp1)');
+    expect(text).toContain('[OK] Daemon: running on port 19825');
+    expect(text).toContain('[OK] Extension: connected');
+    expect(text).toContain('Everything looks good!');
+  });
+
+  it('renders MISSING when daemon not running', () => {
+    const text = strip(renderBrowserDoctorReport({
+      daemonRunning: false,
+      extensionConnected: false,
+      issues: ['Daemon is not running.'],
+    }));
+
+    expect(text).toContain('[MISSING] Daemon: not running');
+    expect(text).toContain('[MISSING] Extension: not connected');
+    expect(text).toContain('Daemon is not running.');
   });
 
-  it('renders MISMATCH-style report when fingerprints differ', () => {
+  it('renders extension not connected when daemon is running', () => {
     const text = strip(renderBrowserDoctorReport({
-      envToken: 'abc123',
-      envFingerprint: 'fp1',
-      extensionToken: null,
-      extensionFingerprint: null,
-      extensionInstalled: false,
-      extensionBrowsers: [],
-      shellFiles: [{ path: '/tmp/.zshrc', exists: true, token: 'def456', fingerprint: 'fp2' }],
-      configs: [{ path: '/tmp/mcp.json', exists: true, format: 'json', token: 'abc123', fingerprint: 'fp1', writable: true }],
-      recommendedToken: 'abc123',
-      recommendedFingerprint: 'fp1',
-      warnings: [],
-      issues: ['Detected inconsistent Playwright MCP tokens across env/config files.'],
+      daemonRunning: true,
+      extensionConnected: false,
+      issues: ['Daemon is running but the Chrome extension is not connected.'],
     }));
 
-    expect(text).toContain('[MISSING] Extension not installed in any browser');
-    expect(text).toContain('[MISMATCH] Environment token: configured (fp1)');
-    expect(text).toContain('[MISMATCH] /tmp/.zshrc');
-    expect(text).toContain('configured (fp2)');
-    expect(text).toContain('[MISMATCH] Recommended token fingerprint: fp1');
+    expect(text).toContain('[OK] Daemon: running on port 19825');
+    expect(text).toContain('[MISSING] Extension: not connected');
   });
 
   it('renders connectivity OK when live test succeeds', () => {
     const text = strip(renderBrowserDoctorReport({
-      envToken: 'abc123',
-      envFingerprint: 'fp1',
-      extensionToken: 'abc123',
-      extensionFingerprint: 'fp1',
-      extensionInstalled: true,
-      extensionBrowsers: ['Chrome'],
-      shellFiles: [],
-      configs: [],
-      recommendedToken: 'abc123',
-      recommendedFingerprint: 'fp1',
+      daemonRunning: true,
+      extensionConnected: true,
       connectivity: { ok: true, durationMs: 1234 },
-      warnings: [],
       issues: [],
     }));
 
-    expect(text).toContain('[OK] Browser connectivity: connected in 1.2s');
+    expect(text).toContain('[OK] Connectivity: connected in 1.2s');
   });
 
-  it('renders connectivity WARN when not tested', () => {
+  it('renders connectivity SKIP when not tested', () => {
     const text = strip(renderBrowserDoctorReport({
-      envToken: 'abc123',
-      envFingerprint: 'fp1',
-      extensionToken: 'abc123',
-      extensionFingerprint: 'fp1',
-      extensionInstalled: true,
-      extensionBrowsers: ['Chrome'],
-      shellFiles: [],
-      configs: [],
-      recommendedToken: 'abc123',
-      recommendedFingerprint: 'fp1',
-      warnings: [],
+      daemonRunning: true,
+      extensionConnected: true,
       issues: [],
     }));
 
-    expect(text).toContain('[WARN] Browser connectivity: not tested (use --live)');
+    expect(text).toContain('[SKIP] Connectivity: not tested (use --live)');
   });
 });
-