@jackwener/opencli 1.5.8 → 1.5.9

package/src/commands/daemon.ts

@@ -122,7 +122,7 @@ export async function daemonRestart(): Promise<void> {
   }
 
   // Import BrowserBridge to spawn a new daemon
-  const { BrowserBridge } = await import('../browser/mcp.js');
+  const { BrowserBridge } = await import('../browser/bridge.js');
   const bridge = new BrowserBridge();
   try {
     console.log('Starting daemon...');

package/src/doctor.ts

@@ -1,8 +1,7 @@
 /**
  * opencli doctor — diagnose browser connectivity.
  *
- * Simplified for the daemon-based architecture. No more token management,
- * MCP path discovery, or config file scanning.
+ * Simplified for the daemon-based architecture.
  */
 
 import chalk from 'chalk';
@@ -42,11 +41,11 @@ export type DoctorReport = {
 export async function checkConnectivity(opts?: { timeout?: number }): Promise<ConnectivityResult> {
   const start = Date.now();
   try {
-    const mcp = new BrowserBridge();
-    const page = await mcp.connect({ timeout: opts?.timeout ?? 8 });
+    const bridge = new BrowserBridge();
+    const page = await bridge.connect({ timeout: opts?.timeout ?? 8 });
     // Try a simple eval to verify end-to-end connectivity
     await page.evaluate('1 + 1');
-    await mcp.close();
+    await bridge.close();
     return { ok: true, durationMs: Date.now() - start };
   } catch (err) {
     return { ok: false, error: getErrorMessage(err), durationMs: Date.now() - start };
@@ -58,9 +57,9 @@ export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<Doctor
   let initialStatus = await checkDaemonStatus();
   if (!initialStatus.running) {
     try {
-      const mcp = new BrowserBridge();
-      await mcp.connect({ timeout: 5 });
-      await mcp.close();
+      const bridge = new BrowserBridge();
+      await bridge.connect({ timeout: 5 });
+      await bridge.close();
     } catch {
       // Auto-start failed; we'll report it below.
     }

package/src/explore.ts

@@ -135,7 +135,7 @@ export interface ExploreBundle {
 }
 
 /**
- * Parse raw network output from Playwright MCP.
+ * Parse raw network output from browser page.
  * Handles text format: [GET] url => [200]
  */
 function parseNetworkRequests(raw: unknown): NetworkEntry[] {

package/src/output.test.ts

@@ -89,4 +89,21 @@ describe('render', () => {
     const calls = log.mock.calls.map(c => c[0]);
     expect(calls[1]).toBe('test,');
   });
+
+  it('renders single-field rows in plain mode as the bare value', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([{ response: 'Gemini says hi' }], { fmt: 'plain' });
+    expect(log).toHaveBeenCalledWith('Gemini says hi');
+  });
+
+  it('renders multi-field rows in plain mode as key-value lines', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    render([{ status: 'ok', file: '~/tmp/a.png', link: 'https://example.com' }], { fmt: 'plain' });
+    const calls = log.mock.calls.map(c => c[0]);
+    expect(calls).toEqual([
+      'status: ok',
+      'file: ~/tmp/a.png',
+      'link: https://example.com',
+    ]);
+  });
 });

package/src/output.ts

@@ -33,6 +33,7 @@ export function render(data: unknown, opts: RenderOptions = {}): void {
   }
   switch (fmt) {
     case 'json': renderJson(data); break;
+    case 'plain': renderPlain(data, opts); break;
     case 'md': case 'markdown': renderMarkdown(data, opts); break;
     case 'csv': renderCsv(data, opts); break;
     case 'yaml': case 'yml': renderYaml(data); break;
@@ -74,6 +75,32 @@ function renderTable(data: unknown, opts: RenderOptions): void {
 function renderJson(data: unknown): void {
   console.log(JSON.stringify(data, null, 2));
 }
+function renderPlain(data: unknown, opts: RenderOptions): void {
+  const rows = normalizeRows(data);
+  if (!rows.length) return;
+
+  // Single-row single-field shortcuts for chat-style commands.
+  if (rows.length === 1) {
+    const row = rows[0];
+    const entries = Object.entries(row);
+    if (entries.length === 1) {
+      const [key, value] = entries[0];
+      if (key === 'response' || key === 'content' || key === 'text' || key === 'value') {
+        console.log(String(value ?? ''));
+        return;
+      }
+    }
+  }
+
+  rows.forEach((row, index) => {
+    const entries = Object.entries(row).filter(([, value]) => value !== undefined && value !== null && String(value) !== '');
+    entries.forEach(([key, value]) => {
+      console.log(`${key}: ${value}`);
+    });
+    if (index < rows.length - 1) console.log('');
+  });
+}
+
 
 function renderMarkdown(data: unknown, opts: RenderOptions): void {
   const rows = normalizeRows(data);

package/src/pipeline/executor.ts

@@ -8,6 +8,7 @@ import { getStep, type StepHandler } from './registry.js';
 import { log } from '../logger.js';
 import { ConfigError } from '../errors.js';
 import { BROWSER_ONLY_STEPS } from '../capabilityRouting.js';
+import { isTransientBrowserError } from '../browser/errors.js';
 
 export interface PipelineContext {
   args?: Record<string, unknown>;
@@ -73,13 +74,7 @@ async function executeStepWithRetry(
     } catch (err) {
       if (attempt >= maxRetries) throw err;
       // Only retry on transient browser errors
-      const msg = err instanceof Error ? err.message : '';
-      const isTransient = msg.includes('Extension disconnected')
-        || msg.includes('attach failed')
-        || msg.includes('no longer exists')
-        || msg.includes('CDP connection')
-        || msg.includes('Daemon command failed');
-      if (!isTransient) throw err;
+      if (!isTransientBrowserError(err)) throw err;
       // Brief delay before retry
       await new Promise(resolve => setTimeout(resolve, 1000));
     }

package/src/pipeline/steps/browser.ts

@@ -65,7 +65,7 @@ export async function stepSnapshot(page: IPage | null, params: unknown, _data: u
 export async function stepEvaluate(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
   const js = String(render(params, { args, data }));
   let result: unknown = await page!.evaluate(js);
-  // MCP may return JSON as a string — auto-parse it
+  // Browser may return JSON as a string — auto-parse it
   if (typeof result === 'string') {
     const trimmed = result.trim();
     if ((trimmed.startsWith('[') && trimmed.endsWith(']')) || (trimmed.startsWith('{') && trimmed.endsWith('}'))) {

package/src/pipeline/template.ts

@@ -172,6 +172,10 @@ export function resolvePath(pathStr: string, ctx: RenderContext): unknown {
 /**
  * Evaluate arbitrary JS expressions as a last-resort fallback.
  * Runs inside a `node:vm` sandbox with dynamic code generation disabled.
+ *
+ * Compiled functions are cached by expression string to avoid re-creating
+ * VM contexts on every invocation — critical for loops where the same
+ * expression is evaluated hundreds of times.
  */
 const FORBIDDEN_EXPR_PATTERNS = /\b(constructor|__proto__|prototype|globalThis|process|require|import|eval)\b/;
 
@@ -189,6 +193,25 @@ function sanitizeContext(obj: unknown): unknown {
   }
 }
 
+/** LRU-bounded cache for compiled VM scripts — prevents unbounded memory growth. */
+const MAX_VM_CACHE_SIZE = 256;
+const _vmCache = new Map<string, vm.Script>();
+
+function getOrCompileScript(expr: string): vm.Script {
+  let script = _vmCache.get(expr);
+  if (script) return script;
+
+  // Evict oldest entry when cache is full
+  if (_vmCache.size >= MAX_VM_CACHE_SIZE) {
+    const firstKey = _vmCache.keys().next().value;
+    if (firstKey !== undefined) _vmCache.delete(firstKey);
+  }
+
+  script = new vm.Script(`(${expr})`);
+  _vmCache.set(expr, script);
+  return script;
+}
+
 function evalJsExpr(expr: string, ctx: RenderContext): unknown {
   // Guard against absurdly long expressions that could indicate injection.
   if (expr.length > 2000) return undefined;
@@ -202,8 +225,8 @@ function evalJsExpr(expr: string, ctx: RenderContext): unknown {
   const index = ctx.index ?? 0;
 
   try {
-    return vm.runInNewContext(
-      `(${expr})`,
+    const script = getOrCompileScript(expr);
+    const sandbox = vm.createContext(
       {
         args,
         item,
@@ -220,13 +243,13 @@ function evalJsExpr(expr: string, ctx: RenderContext): unknown {
         Date,
       },
       {
-        timeout: 50,
-        contextCodeGeneration: {
+        codeGeneration: {
           strings: false,
           wasm: false,
         },
       },
     );
+    return script.runInContext(sandbox, { timeout: 50 });
   } catch {
     return undefined;
   }

package/src/record.test.ts

@@ -0,0 +1,362 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  analyzeRecordedRequests,
+  buildWriteRecordedYaml,
+  createRecordedEntry,
+  generateFullCaptureInterceptorJs,
+  generateRecordedCandidates,
+} from './record.js';
+import { render } from './pipeline/template.js';
+
+describe('record request-body capture', () => {
+  it('captures a JSON fetch request body alongside the JSON response body', () => {
+    const entry = createRecordedEntry({
+      url: 'https://api.example.com/tasks',
+      method: 'POST',
+      requestContentType: 'application/json',
+      requestBodyText: '{"title":"Ship #601","priority":"high"}',
+      responseBody: { id: 'task_123', ok: true },
+    });
+
+    expect(entry).toMatchObject({
+      method: 'POST',
+      requestContentType: 'application/json',
+      requestBody: { title: 'Ship #601', priority: 'high' },
+      responseBody: { id: 'task_123', ok: true },
+    });
+  });
+
+  it('captures a JSON request body from fetch(Request)', async () => {
+    class MockXMLHttpRequest {
+      open(): void {}
+      send(): void {}
+      setRequestHeader(): void {}
+      addEventListener(): void {}
+      getResponseHeader(): string | null { return null; }
+      responseText = '';
+    }
+
+    const mockFetch = vi.fn(async () => new Response(
+      JSON.stringify({ id: 'task_123', ok: true }),
+      { headers: { 'content-type': 'application/json' } },
+    ));
+
+    vi.stubGlobal('fetch', mockFetch);
+    vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
+    vi.stubGlobal('window', globalThis);
+
+    // eslint-disable-next-line no-eval
+    eval(generateFullCaptureInterceptorJs());
+
+    const request = new Request('https://api.example.com/tasks', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ title: 'Ship #601' }),
+    });
+
+    await globalThis.fetch(request);
+
+    const recorded = (globalThis as typeof globalThis & { __opencli_record?: Array<{ requestBody: unknown }> }).__opencli_record;
+    expect(recorded).toHaveLength(1);
+    expect(recorded?.[0]?.requestBody).toEqual({ title: 'Ship #601' });
+  });
+
+  it('captures a JSON request body from XHR send()', async () => {
+    class MockXMLHttpRequest {
+      __listeners: Record<string, Array<() => void>> = {};
+      __rec_url?: string;
+      __rec_method?: string;
+      __rec_request_content_type?: string | null;
+      responseText = JSON.stringify({ id: 'task_456', ok: true });
+
+      open(method: string, url: string): void {
+        this.__rec_method = method;
+        this.__rec_url = url;
+      }
+
+      send(): void {
+        for (const listener of this.__listeners.load ?? []) listener.call(this);
+      }
+
+      setRequestHeader(name: string, value: string): void {
+        if (name.toLowerCase() === 'content-type') this.__rec_request_content_type = value;
+      }
+
+      addEventListener(event: string, listener: () => void): void {
+        this.__listeners[event] ??= [];
+        this.__listeners[event].push(listener);
+      }
+
+      getResponseHeader(name: string): string | null {
+        return name.toLowerCase() === 'content-type' ? 'application/json' : null;
+      }
+    }
+
+    const mockFetch = vi.fn(async () => new Response(
+      JSON.stringify({ ok: true }),
+      { headers: { 'content-type': 'application/json' } },
+    ));
+
+    vi.stubGlobal('fetch', mockFetch);
+    vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
+    vi.stubGlobal('window', globalThis);
+
+    // eslint-disable-next-line no-eval
+    eval(generateFullCaptureInterceptorJs());
+
+    const xhr = new XMLHttpRequest();
+    xhr.open('PATCH', 'https://api.example.com/tasks/submit');
+    xhr.setRequestHeader('content-type', 'application/json;charset=utf-8');
+    xhr.send('{"done":true}');
+
+    const recorded = (globalThis as typeof globalThis & { __opencli_record?: Array<{ requestBody: unknown }> }).__opencli_record;
+    expect(recorded).toHaveLength(1);
+    expect(recorded?.[0]?.requestBody).toEqual({ done: true });
+  });
+
+  it('does not interrupt fetch when reading a Request body fails', async () => {
+    class MockXMLHttpRequest {
+      open(): void {}
+      send(): void {}
+      setRequestHeader(): void {}
+      addEventListener(): void {}
+      getResponseHeader(): string | null { return null; }
+      responseText = '';
+    }
+
+    class BrokenRequest extends Request {
+      override clone(): Request {
+        throw new Error('clone failed');
+      }
+    }
+
+    const mockFetch = vi.fn(async () => new Response(
+      JSON.stringify({ id: 'task_123', ok: true }),
+      { headers: { 'content-type': 'application/json' } },
+    ));
+
+    vi.stubGlobal('fetch', mockFetch);
+    vi.stubGlobal('XMLHttpRequest', MockXMLHttpRequest);
+    vi.stubGlobal('window', globalThis);
+
+    // eslint-disable-next-line no-eval
+    eval(generateFullCaptureInterceptorJs());
+
+    const request = new BrokenRequest('https://api.example.com/tasks', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ title: 'Ship #601' }),
+    });
+
+    await expect(globalThis.fetch(request)).resolves.toBeInstanceOf(Response);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('record write candidates', () => {
+  it('keeps a POST request with JSON request body and object response as a write candidate', () => {
+    const result = analyzeRecordedRequests([
+      createRecordedEntry({
+        url: 'https://api.example.com/tasks/create',
+        method: 'POST',
+        requestContentType: 'application/json',
+        requestBodyText: '{"title":"Ship #601"}',
+        responseBody: { id: 'task_123', ok: true },
+      }),
+    ]);
+
+    expect(result.candidates).toHaveLength(1);
+    expect(result.candidates[0]).toMatchObject({
+      kind: 'write',
+      req: { method: 'POST' },
+    });
+  });
+
+  it('accepts vendor JSON content types for write candidates', () => {
+    const result = analyzeRecordedRequests([
+      createRecordedEntry({
+        url: 'https://api.example.com/tasks',
+        method: 'POST',
+        requestContentType: 'application/vnd.api+json',
+        requestBodyText: '{"title":"Ship #601"}',
+        responseBody: { id: 'task_123', ok: true },
+      }),
+    ]);
+
+    expect(result.candidates).toHaveLength(1);
+    expect(result.candidates[0]).toMatchObject({
+      kind: 'write',
+      req: { method: 'POST' },
+    });
+  });
+
+  it('rejects a POST request that has no usable JSON request body', () => {
+    const result = analyzeRecordedRequests([
+      createRecordedEntry({
+        url: 'https://api.example.com/tasks/create',
+        method: 'POST',
+        requestContentType: 'application/json',
+        requestBodyText: '',
+        responseBody: { id: 'task_123', ok: true },
+      }),
+    ]);
+
+    expect(result.candidates).toEqual([]);
+  });
+
+  it('rejects array request and response bodies for first-version write candidates', () => {
+    const result = analyzeRecordedRequests([
+      createRecordedEntry({
+        url: 'https://api.example.com/tasks/batch',
+        method: 'POST',
+        requestContentType: 'application/json',
+        requestBodyText: '[{"title":"Ship #601"}]',
+        responseBody: [{ id: 'task_123' }],
+      }),
+    ]);
+
+    expect(result.candidates).toEqual([]);
+  });
+
+  it('generates a write YAML candidate from a replayable JSON write request', () => {
+    const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
+      createRecordedEntry({
+        url: 'https://api.example.com/tasks/create',
+        method: 'POST',
+        requestContentType: 'application/json',
+        requestBodyText: '{"title":"Ship #601"}',
+        responseBody: { id: 'task_123', ok: true },
+      }),
+    ]);
+
+    expect(candidates).toHaveLength(1);
+    expect(candidates[0]).toMatchObject({
+      kind: 'write',
+      name: 'create',
+      strategy: 'cookie',
+    });
+    expect(JSON.stringify(candidates[0].yaml)).toContain('Ship #601');
+  });
+
+  it('builds a write template that replays the recorded JSON body with application/json', () => {
+    const candidate = buildWriteRecordedYaml(
+      'demo',
+      'https://demo.example.com/app',
+      createRecordedEntry({
+        url: 'https://api.example.com/tasks/create',
+        method: 'POST',
+        requestContentType: 'application/json',
+        requestBodyText: '{"title":"Ship #601"}',
+        responseBody: { id: 'task_123', ok: true },
+      }),
+      'create',
+    );
+
+    expect(candidate.name).toBe('create');
+    expect(JSON.stringify(candidate.yaml)).toContain('method: \\"POST\\"');
+    expect(JSON.stringify(candidate.yaml)).toContain('content-type');
+    expect(JSON.stringify(candidate.yaml)).toContain('Ship #601');
+  });
+});
+
+describe('record read candidates', () => {
+  it('keeps existing read candidates for array responses', () => {
+    const result = analyzeRecordedRequests([
+      {
+        url: 'https://api.example.com/feed',
+        method: 'GET',
+        status: null,
+        requestContentType: null,
+        responseContentType: 'application/json',
+        requestBody: null,
+        responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
+        contentType: 'application/json',
+        body: { items: [{ title: 'A' }, { title: 'B' }] },
+        capturedAt: 1,
+      },
+    ]);
+
+    expect(result.candidates).toHaveLength(1);
+    expect(result.candidates[0]).toMatchObject({ kind: 'read' });
+  });
+
+  it('keeps read YAML generation on the baseline fetch path', () => {
+    const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
+      createRecordedEntry({
+        url: 'https://api.example.com/search?q=test',
+        method: 'GET',
+        responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
+      }),
+    ]);
+
+    const yaml = candidates[0].yaml as { pipeline: Array<{ evaluate?: string }> };
+    expect(yaml.pipeline[1]?.evaluate).toContain(`fetch("https://api.example.com/search?q=`);
+    expect(yaml.pipeline[1]?.evaluate).toContain(`{ credentials: 'include' }`);
+    expect(yaml.pipeline[1]?.evaluate).not.toContain('method: "POST"');
+    expect(yaml.pipeline[1]?.evaluate).not.toContain('body: JSON.stringify');
+  });
+
+  it('renders search and page args into the read YAML fetch URL', () => {
+    const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
+      createRecordedEntry({
+        url: 'https://api.example.com/search?q=test&page=2',
+        method: 'GET',
+        responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
+      }),
+    ]);
+
+    const yaml = candidates[0].yaml as { pipeline: Array<{ evaluate?: string }> };
+    const renderedEvaluate = render(yaml.pipeline[1]?.evaluate, {
+      args: { keyword: 'desk', page: 3 },
+    });
+
+    expect(renderedEvaluate).toContain('https://api.example.com/search?q=desk&page=3');
+  });
+
+  it('keeps GET and POST candidates separate when they share the same URL pattern', () => {
+    const candidates = generateRecordedCandidates('demo', 'https://demo.example.com/app', [
+      createRecordedEntry({
+        url: 'https://api.example.com/tasks',
+        method: 'GET',
+        responseBody: { items: [{ title: 'A' }, { title: 'B' }] },
+      }),
+      createRecordedEntry({
+        url: 'https://api.example.com/tasks',
+        method: 'POST',
+        requestContentType: 'application/json',
+        requestBodyText: '{"title":"Ship #601"}',
+        responseBody: { id: 'task_123', ok: true },
+      }),
+    ]);
+
+    expect(candidates).toHaveLength(2);
+    expect(candidates.some((candidate) => candidate.kind === 'read')).toBe(true);
+    expect(candidates.some((candidate) => candidate.kind === 'write')).toBe(true);
+  });
+});
+
+describe('record noise filtering', () => {
+  it('filters analytics POST noise from write candidates', () => {
+    const result = analyzeRecordedRequests([
+      createRecordedEntry({
+        url: 'https://api.example.com/analytics/event',
+        method: 'POST',
+        requestContentType: 'application/json',
+        requestBodyText: '{"event":"click"}',
+        responseBody: { ok: true, accepted: 1 },
+      }),
+    ]);
+
+    expect(result.candidates).toEqual([]);
+  });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  Reflect.deleteProperty(globalThis as typeof globalThis & { __opencli_record?: unknown }, '__opencli_record');
+  Reflect.deleteProperty(globalThis as typeof globalThis & { __opencli_record_patched?: unknown }, '__opencli_record_patched');
+  Reflect.deleteProperty(globalThis as typeof globalThis & { __opencli_orig_fetch?: unknown }, '__opencli_orig_fetch');
+  Reflect.deleteProperty(globalThis as typeof globalThis & { __opencli_orig_xhr_open?: unknown }, '__opencli_orig_xhr_open');
+  Reflect.deleteProperty(globalThis as typeof globalThis & { __opencli_orig_xhr_send?: unknown }, '__opencli_orig_xhr_send');
+  Reflect.deleteProperty(globalThis as typeof globalThis & { __opencli_orig_xhr_set_request_header?: unknown }, '__opencli_orig_xhr_set_request_header');
+});