@jackwener/opencli 0.9.8 → 1.0.1

package/src/clis/weread/utils.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatDate, fetchWebApi, fetchWithPage } from './utils.js';
+
+describe('formatDate', () => {
+  it('formats a typical Unix timestamp in UTC+8', () => {
+    // 1705276800 = 2024-01-15 00:00:00 UTC = 2024-01-15 08:00:00 Beijing
+    expect(formatDate(1705276800)).toBe('2024-01-15');
+  });
+
+  it('handles UTC midnight edge case with UTC+8 offset', () => {
+    // 1705190399 = 2024-01-13 23:59:59 UTC = 2024-01-14 07:59:59 Beijing
+    expect(formatDate(1705190399)).toBe('2024-01-14');
+  });
+
+  it('returns dash for zero', () => {
+    expect(formatDate(0)).toBe('-');
+  });
+
+  it('returns dash for negative', () => {
+    expect(formatDate(-1)).toBe('-');
+  });
+
+  it('returns dash for NaN', () => {
+    expect(formatDate(NaN)).toBe('-');
+  });
+
+  it('returns dash for Infinity', () => {
+    expect(formatDate(Infinity)).toBe('-');
+  });
+
+  it('returns dash for undefined', () => {
+    expect(formatDate(undefined)).toBe('-');
+  });
+
+  it('returns dash for null', () => {
+    expect(formatDate(null)).toBe('-');
+  });
+});
+
+describe('fetchWebApi', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns parsed JSON for successful response', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ books: [{ title: 'Test' }] }),
+    }));
+
+    const result = await fetchWebApi('/search/global', { keyword: 'test' });
+    expect(result).toEqual({ books: [{ title: 'Test' }] });
+  });
+
+  it('throws CliError on HTTP error', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 403,
+      json: () => Promise.resolve({}),
+    }));
+
+    await expect(fetchWebApi('/search/global')).rejects.toThrow('HTTP 403');
+  });
+
+  it('throws PARSE_ERROR on non-JSON response', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.reject(new SyntaxError('Unexpected token <')),
+    }));
+
+    await expect(fetchWebApi('/search/global')).rejects.toThrow('Invalid JSON');
+  });
+});
+
+describe('fetchWithPage', () => {
+  it('throws AUTH_REQUIRED on errcode -2010', async () => {
+    const mockPage = {
+      evaluate: vi.fn().mockResolvedValue({ errcode: -2010, errmsg: '用户不存在' }),
+    } as any;
+    await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('Not logged in');
+  });
+
+  it('throws API_ERROR on unknown errcode', async () => {
+    const mockPage = {
+      evaluate: vi.fn().mockResolvedValue({ errcode: -1, errmsg: 'unknown error' }),
+    } as any;
+    await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('unknown error');
+  });
+
+  it('returns data on success (errcode 0 or absent)', async () => {
+    const mockPage = {
+      evaluate: vi.fn().mockResolvedValue({ title: 'Test Book', errcode: 0 }),
+    } as any;
+    const result = await fetchWithPage(mockPage, '/book/info');
+    expect(result.title).toBe('Test Book');
+  });
+
+  it('throws FETCH_ERROR on HTTP error', async () => {
+    const mockPage = {
+      evaluate: vi.fn().mockResolvedValue({ _httpError: '403' }),
+    } as any;
+    await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('HTTP 403');
+  });
+});

package/src/clis/weread/utils.ts

@@ -0,0 +1,74 @@
+/**
+ * WeRead shared helpers: fetch wrappers and formatting.
+ *
+ * Two API domains:
+ * - WEB_API (weread.qq.com/web/*): public, Node.js fetch
+ * - API (i.weread.qq.com/*): private, browser page.evaluate with cookies
+ */
+
+import { CliError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+
+const WEB_API = 'https://weread.qq.com/web';
+const API = 'https://i.weread.qq.com';
+const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+
+/**
+ * Fetch a public WeRead web endpoint (Node.js direct fetch).
+ * Used by search and ranking commands (browser: false).
+ */
+export async function fetchWebApi(path: string, params?: Record<string, string>): Promise<any> {
+  const url = new URL(`${WEB_API}${path}`);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
+  }
+  const resp = await fetch(url.toString(), {
+    headers: { 'User-Agent': UA },
+  });
+  if (!resp.ok) {
+    throw new CliError('FETCH_ERROR', `HTTP ${resp.status} for ${path}`, 'WeRead API may be temporarily unavailable');
+  }
+  try {
+    return await resp.json();
+  } catch {
+    throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
+  }
+}
+
+/**
+ * Fetch a private WeRead API endpoint via browser page.evaluate.
+ * Automatically carries cookies for authenticated requests.
+ */
+export async function fetchWithPage(page: IPage, path: string, params?: Record<string, string>): Promise<any> {
+  const url = new URL(`${API}${path}`);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
+  }
+  const urlStr = url.toString();
+  const data = await page.evaluate(`
+    async () => {
+      const res = await fetch(${JSON.stringify(urlStr)}, { credentials: "include" });
+      if (!res.ok) return { _httpError: String(res.status) };
+      try { return await res.json(); }
+      catch { return { _httpError: 'JSON parse error (status ' + res.status + ')' }; }
+    }
+  `);
+  if (data?._httpError) {
+    throw new CliError('FETCH_ERROR', `HTTP ${data._httpError} for ${path}`, 'WeRead API may be temporarily unavailable');
+  }
+  if (data?.errcode === -2010) {
+    throw new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first');
+  }
+  if (data?.errcode != null && data.errcode !== 0) {
+    throw new CliError('API_ERROR', data.errmsg ?? `WeRead API error ${data.errcode}`);
+  }
+  return data;
+}
+
+/** Format a Unix timestamp (seconds) to YYYY-MM-DD in UTC+8. Returns '-' for invalid input. */
+export function formatDate(ts: number | undefined | null): string {
+  if (!Number.isFinite(ts) || (ts as number) <= 0) return '-';
+  // WeRead timestamps are China-centric; offset to UTC+8 to avoid off-by-one near midnight
+  const d = new Date((ts as number) * 1000 + 8 * 3600_000);
+  return d.toISOString().slice(0, 10);
+}

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 (120s)'));
+        }, 120000);
+        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)');
   });
 });
-