@jackwener/opencli 1.5.8 → 1.5.9

package/dist/doctor.js

@@ -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';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
@@ -17,11 +16,11 @@ import { getRuntimeLabel } from './runtime-detect.js';
 export async function checkConnectivity(opts) {
     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) {
@@ -33,9 +32,9 @@ export async function runBrowserDoctor(opts = {}) {
     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/dist/explore.js

@@ -46,7 +46,7 @@ export function slugify(value) {
     return value.trim().toLowerCase().replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-|-$/g, '') || 'site';
 }
 /**
- * Parse raw network output from Playwright MCP.
+ * Parse raw network output from browser page.
  * Handles text format: [GET] url => [200]
  */
 function parseNetworkRequests(raw) {

package/dist/output.js

@@ -24,6 +24,9 @@ export function render(data, opts = {}) {
         case 'json':
             renderJson(data);
             break;
+        case 'plain':
+            renderPlain(data, opts);
+            break;
         case 'md':
         case 'markdown':
             renderMarkdown(data, opts);
@@ -77,6 +80,31 @@ function renderTable(data, opts) {
 function renderJson(data) {
     console.log(JSON.stringify(data, null, 2));
 }
+function renderPlain(data, opts) {
+    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, opts) {
     const rows = normalizeRows(data);
     if (!rows.length)

package/dist/output.test.js

@@ -77,4 +77,19 @@ 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/dist/pipeline/executor.js

@@ -5,6 +5,7 @@ import { getStep } 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 async function executePipeline(page, pipeline, ctx = {}) {
     const args = ctx.args ?? {};
     const debug = ctx.debug ?? false;
@@ -52,13 +53,7 @@ async function executeStepWithRetry(handler, page, params, data, args, op, confi
             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)
+            if (!isTransientBrowserError(err))
                 throw err;
             // Brief delay before retry
             await new Promise(resolve => setTimeout(resolve, 1000));

package/dist/pipeline/steps/browser.js

@@ -62,7 +62,7 @@ export async function stepSnapshot(page, params, _data, _args) {
 export async function stepEvaluate(page, params, data, args) {
     const js = String(render(params, { args, data }));
     let result = 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/dist/pipeline/template.js

@@ -179,6 +179,10 @@ export function resolvePath(pathStr, ctx) {
 /**
  * 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/;
 /**
@@ -197,6 +201,23 @@ function sanitizeContext(obj) {
         return {};
     }
 }
+/** LRU-bounded cache for compiled VM scripts — prevents unbounded memory growth. */
+const MAX_VM_CACHE_SIZE = 256;
+const _vmCache = new Map();
+function getOrCompileScript(expr) {
+    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, ctx) {
     // Guard against absurdly long expressions that could indicate injection.
     if (expr.length > 2000)
@@ -209,7 +230,8 @@ function evalJsExpr(expr, ctx) {
     const data = sanitizeContext(ctx.data);
     const index = ctx.index ?? 0;
     try {
-        return vm.runInNewContext(`(${expr})`, {
+        const script = getOrCompileScript(expr);
+        const sandbox = vm.createContext({
             args,
             item,
             data,
@@ -224,12 +246,12 @@ function evalJsExpr(expr, ctx) {
             Array,
             Date,
         }, {
-            timeout: 50,
-            contextCodeGeneration: {
+            codeGeneration: {
                 strings: false,
                 wasm: false,
             },
         });
+        return script.runInContext(sandbox, { timeout: 50 });
     }
     catch {
         return undefined;

package/dist/record.d.ts

@@ -12,10 +12,19 @@
  * Uses existing exec + navigate actions only.
  */
 import type { IPage } from './types.js';
+import { findArrayPath } from './analysis.js';
 export interface RecordedRequest {
     url: string;
     method: string;
     status: number | null;
+    /** Request content type captured at record time, if available. */
+    requestContentType: string | null;
+    /** Response content type captured at record time, if available. */
+    responseContentType: string | null;
+    /** Parsed JSON request body for replayable write requests. */
+    requestBody: unknown;
+    /** Parsed JSON response body captured from the network call. */
+    responseBody: unknown;
     contentType: string;
     body: unknown;
     capturedAt: number;
@@ -32,6 +41,46 @@ export interface RecordResult {
         strategy: string;
     }>;
 }
+type RecordedCandidateKind = 'read' | 'write';
+export interface RecordedCandidate {
+    kind: RecordedCandidateKind;
+    req: RecordedRequest;
+    score: number;
+    arrayResult: ReturnType<typeof findArrayPath> | null;
+}
+interface GeneratedRecordedCandidate {
+    kind: RecordedCandidateKind;
+    name: string;
+    strategy: string;
+    yaml: unknown;
+}
+/** Build one normalized recorded entry from captured request and response values. */
+export declare function createRecordedEntry(input: {
+    url: string;
+    method: string;
+    requestContentType?: string | null;
+    requestBodyText?: string | null;
+    responseBody: unknown;
+    responseContentType?: string | null;
+    status?: number | null;
+    capturedAt?: number;
+}): RecordedRequest;
+/**
+ * Generates a full-capture interceptor that stores {url, method, status, body}
+ * for every JSON response. No URL pattern filter — captures everything.
+ */
+export declare function generateFullCaptureInterceptorJs(): string;
+/** Analyze recorded requests into read and write candidates. */
+export declare function analyzeRecordedRequests(requests: RecordedRequest[]): {
+    candidates: RecordedCandidate[];
+};
+/** Build a minimal YAML candidate for replayable JSON write requests. */
+export declare function buildWriteRecordedYaml(site: string, pageUrl: string, req: RecordedRequest, capName: string): {
+    name: string;
+    yaml: unknown;
+};
+/** Turn recorded requests into YAML-ready read and write candidates. */
+export declare function generateRecordedCandidates(site: string, pageUrl: string, requests: RecordedRequest[]): GeneratedRecordedCandidate[];
 export interface RecordOptions {
     BrowserFactory: new () => {
         connect(o?: unknown): Promise<IPage>;
@@ -45,3 +94,4 @@ export interface RecordOptions {
 }
 export declare function recordSession(opts: RecordOptions): Promise<RecordResult>;
 export declare function renderRecordSummary(result: RecordResult): string;
+export {};