@jackwener/opencli 1.6.2 → 1.6.3

package/src/output.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-import { render } from './output.js';
-
-describe('output TTY detection', () => {
-  const originalIsTTY = process.stdout.isTTY;
-  const originalEnv = process.env.OUTPUT;
-  let logSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY, writable: true });
-    if (originalEnv === undefined) delete process.env.OUTPUT;
-    else process.env.OUTPUT = originalEnv;
-    logSpy.mockRestore();
-  });
-
-  it('outputs YAML in non-TTY when format is default table', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-    // commanderAdapter always passes fmt:'table' as default — this must still trigger downgrade
-    render([{ name: 'alice', score: 10 }], { fmt: 'table', columns: ['name', 'score'] });
-    const out = logSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
-    expect(out).toContain('name: alice');
-    expect(out).toContain('score: 10');
-  });
-
-  it('outputs table in TTY when format is default table', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: true, writable: true });
-    render([{ name: 'alice', score: 10 }], { fmt: 'table', columns: ['name', 'score'] });
-    const out = logSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
-    expect(out).toContain('alice');
-  });
-
-  it('respects explicit -f json even in non-TTY', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-    render([{ name: 'alice' }], { fmt: 'json' });
-    const out = logSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
-    expect(JSON.parse(out)).toEqual([{ name: 'alice' }]);
-  });
-
-  it('OUTPUT env var overrides default table in non-TTY', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-    process.env.OUTPUT = 'json';
-    render([{ name: 'alice' }], { fmt: 'table' });
-    const out = logSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
-    expect(JSON.parse(out)).toEqual([{ name: 'alice' }]);
-  });
-
-  it('explicit -f flag takes precedence over OUTPUT env var', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-    process.env.OUTPUT = 'json';
-    render([{ name: 'alice' }], { fmt: 'csv', fmtExplicit: true });
-    const out = logSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
-    expect(out).toContain('name');
-    expect(out).toContain('alice');
-    expect(out).not.toContain('"name"');  // not JSON
-  });
-
-  it('explicit -f table overrides non-TTY auto-downgrade', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-    render([{ name: 'alice' }], { fmt: 'table', fmtExplicit: true, columns: ['name'] });
-    const out = logSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
-    // Should be table output, not YAML
-    expect(out).not.toContain('name: alice');
-    expect(out).toContain('alice');
-  });
-});

package/src/output.ts

@@ -1,145 +0,0 @@
-/**
- * Output formatting: table, JSON, Markdown, CSV, YAML.
- */
-
-import chalk from 'chalk';
-import Table from 'cli-table3';
-import yaml from 'js-yaml';
-
-export interface RenderOptions {
-  fmt?: string;
-  /** True when the user explicitly passed -f on the command line */
-  fmtExplicit?: boolean;
-  columns?: string[];
-  title?: string;
-  elapsed?: number;
-  source?: string;
-  footerExtra?: string;
-}
-
-function normalizeRows(data: unknown): Record<string, unknown>[] {
-  if (Array.isArray(data)) return data;
-  if (data && typeof data === 'object') return [data as Record<string, unknown>];
-  return [{ value: data }];
-}
-
-function resolveColumns(rows: Record<string, unknown>[], opts: RenderOptions): string[] {
-  return opts.columns ?? Object.keys(rows[0] ?? {});
-}
-
-export function render(data: unknown, opts: RenderOptions = {}): void {
-  let fmt = opts.fmt ?? 'table';
-  // Non-TTY auto-downgrade only when format was NOT explicitly passed by user.
-  // Priority: explicit -f (any value) > OUTPUT env var > TTY auto-detect > table
-  if (!opts.fmtExplicit) {
-    const envFmt = process.env.OUTPUT?.trim().toLowerCase();
-    if (envFmt) fmt = envFmt;
-    else if (fmt === 'table' && !process.stdout.isTTY) fmt = 'yaml';
-  }
-  if (data === null || data === undefined) {
-    console.log(data);
-    return;
-  }
-  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;
-    default: renderTable(data, opts); break;
-  }
-}
-
-function renderTable(data: unknown, opts: RenderOptions): void {
-  const rows = normalizeRows(data);
-  if (!rows.length) { console.log(chalk.dim('(no data)')); return; }
-  const columns = resolveColumns(rows, opts);
-
-  const header = columns.map(c => capitalize(c));
-  const table = new Table({
-    head: header.map(h => chalk.bold(h)),
-    style: { head: [], border: [] },
-    wordWrap: true,
-    wrapOnWordBoundary: true,
-  });
-
-  for (const row of rows) {
-    table.push(columns.map(c => {
-      const v = (row as Record<string, unknown>)[c];
-      return v === null || v === undefined ? '' : String(v);
-    }));
-  }
-
-  console.log();
-  if (opts.title) console.log(chalk.dim(`  ${opts.title}`));
-  console.log(table.toString());
-  const footer: string[] = [];
-  footer.push(`${rows.length} items`);
-  if (opts.elapsed) footer.push(`${opts.elapsed.toFixed(1)}s`);
-  if (opts.source) footer.push(opts.source);
-  if (opts.footerExtra) footer.push(opts.footerExtra);
-  console.log(chalk.dim(footer.join(' · ')));
-}
-
-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);
-  if (!rows.length) return;
-  const columns = resolveColumns(rows, opts);
-  console.log('| ' + columns.join(' | ') + ' |');
-  console.log('| ' + columns.map(() => '---').join(' | ') + ' |');
-  for (const row of rows) {
-    console.log('| ' + columns.map(c => String((row as Record<string, unknown>)[c] ?? '')).join(' | ') + ' |');
-  }
-}
-
-function renderCsv(data: unknown, opts: RenderOptions): void {
-  const rows = normalizeRows(data);
-  if (!rows.length) return;
-  const columns = resolveColumns(rows, opts);
-  console.log(columns.join(','));
-  for (const row of rows) {
-    console.log(columns.map(c => {
-      const v = String((row as Record<string, unknown>)[c] ?? '');
-      return v.includes(',') || v.includes('"') || v.includes('\n') || v.includes('\r')
-        ? `"${v.replace(/"/g, '""')}"` : v;
-    }).join(','));
-  }
-}
-
-function renderYaml(data: unknown): void {
-  console.log(yaml.dump(data, { sortKeys: false, lineWidth: 120, noRefs: true }));
-}
-
-function capitalize(s: string): string {
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}

package/src/pipeline/executor.test.ts

@@ -1,191 +0,0 @@
-/**
- * Tests for pipeline/executor.ts: pipeline execution with mock page.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { executePipeline } from './index.js';
-import { ConfigError } from '../errors.js';
-import type { IPage } from '../types.js';
-
-/** Create a minimal mock page for testing */
-function createMockPage(overrides: Partial<IPage> = {}): IPage {
-  return {
-    goto: vi.fn(),
-    evaluate: vi.fn().mockResolvedValue(null),
-    getCookies: vi.fn().mockResolvedValue([]),
-    snapshot: vi.fn().mockResolvedValue(''),
-    click: vi.fn(),
-    typeText: vi.fn(),
-    pressKey: vi.fn(),
-    getFormState: vi.fn().mockResolvedValue({}),
-    wait: vi.fn(),
-    tabs: vi.fn().mockResolvedValue([]),
-    selectTab: vi.fn(),
-    networkRequests: vi.fn().mockResolvedValue([]),
-    consoleMessages: vi.fn().mockResolvedValue(''),
-    scroll: vi.fn(),
-    scrollTo: vi.fn(),
-    autoScroll: vi.fn(),
-    installInterceptor: vi.fn(),
-    getInterceptedRequests: vi.fn().mockResolvedValue([]),
-    screenshot: vi.fn().mockResolvedValue(''),
-    waitForCapture: vi.fn().mockResolvedValue(undefined),
-    ...overrides,
-  };
-}
-
-describe('executePipeline', () => {
-  it('returns null for empty pipeline', async () => {
-    const result = await executePipeline(null, []);
-    expect(result).toBeNull();
-  });
-
-  it('skips null/invalid steps', async () => {
-    const result = await executePipeline(null, [null, undefined, 42] as any);
-    expect(result).toBeNull();
-  });
-
-  it('executes navigate step', async () => {
-    const page = createMockPage();
-    await executePipeline(page, [
-      { navigate: 'https://example.com' },
-    ]);
-    expect(page.goto).toHaveBeenCalledWith('https://example.com');
-  });
-
-  it('executes evaluate + select pipeline', async () => {
-    const page = createMockPage({
-      evaluate: vi.fn().mockResolvedValue({ data: { list: [{ name: 'a' }, { name: 'b' }] } }),
-    });
-    const result = await executePipeline(page, [
-      { evaluate: '() => ({ data: { list: [{name: "a"}, {name: "b"}] } })' },
-      { select: 'data.list' },
-    ]);
-    expect(result).toEqual([{ name: 'a' }, { name: 'b' }]);
-  });
-
-  it('executes map step to transform items', async () => {
-    const page = createMockPage({
-      evaluate: vi.fn().mockResolvedValue([
-        { title: 'Hello', count: 10 },
-        { title: 'World', count: 20 },
-      ]),
-    });
-    const result = await executePipeline(page, [
-      { evaluate: 'test' },
-      { map: { name: '${{ item.title }}', score: '${{ item.count }}' } },
-    ]);
-    expect(result).toEqual([
-      { name: 'Hello', score: 10 },
-      { name: 'World', score: 20 },
-    ]);
-  });
-
-  it('runs inline select inside map step', async () => {
-    const page = createMockPage({
-      evaluate: vi.fn().mockResolvedValue({
-        posts: [
-          { title: 'First', rank: 1 },
-          { title: 'Second', rank: 2 },
-        ],
-      }),
-    });
-    const result = await executePipeline(page, [
-      { evaluate: 'test' },
-      {
-        map: {
-          select: 'posts',
-          title: '${{ item.title }}',
-          rank: '${{ item.rank }}',
-        },
-      },
-    ]);
-
-    expect(result).toEqual([
-      { title: 'First', rank: 1 },
-      { title: 'Second', rank: 2 },
-    ]);
-  });
-
-  it('executes limit step', async () => {
-    const page = createMockPage({
-      evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
-    });
-    const result = await executePipeline(page, [
-      { evaluate: 'test' },
-      { limit: '3' },
-    ]);
-    expect(result).toEqual([1, 2, 3]);
-  });
-
-  it('executes sort step', async () => {
-    const page = createMockPage({
-      evaluate: vi.fn().mockResolvedValue([{ n: 3 }, { n: 1 }, { n: 2 }]),
-    });
-    const result = await executePipeline(page, [
-      { evaluate: 'test' },
-      { sort: { by: 'n', order: 'asc' } },
-    ]);
-    expect(result).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
-  });
-
-  it('executes sort step with desc order', async () => {
-    const page = createMockPage({
-      evaluate: vi.fn().mockResolvedValue([{ n: 1 }, { n: 3 }, { n: 2 }]),
-    });
-    const result = await executePipeline(page, [
-      { evaluate: 'test' },
-      { sort: { by: 'n', order: 'desc' } },
-    ]);
-    expect(result).toEqual([{ n: 3 }, { n: 2 }, { n: 1 }]);
-  });
-
-  it('executes wait step with number', async () => {
-    const page = createMockPage();
-    await executePipeline(page, [
-      { wait: 2 },
-    ]);
-    expect(page.wait).toHaveBeenCalledWith(2);
-  });
-
-  it('fails fast on unknown steps', async () => {
-    await expect(executePipeline(null, [
-      { unknownStep: 'test' },
-    ], { debug: true })).rejects.toBeInstanceOf(ConfigError);
-    await expect(executePipeline(null, [
-      { unknownStep: 'test' },
-    ], { debug: true })).rejects.toThrow('Unknown pipeline step "unknownStep"');
-  });
-
-  it('passes args through template rendering', async () => {
-    const page = createMockPage({
-      evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
-    });
-    const result = await executePipeline(page, [
-      { evaluate: 'test' },
-      { limit: '${{ args.count }}' },
-    ], { args: { count: 2 } });
-    expect(result).toEqual([1, 2]);
-  });
-
-  it('click step calls page.click', async () => {
-    const page = createMockPage();
-    await executePipeline(page, [
-      { click: '@5' },
-    ]);
-    expect(page.click).toHaveBeenCalledWith('5');
-  });
-
-  it('navigate preserves existing data through pipeline', async () => {
-    const page = createMockPage({
-      evaluate: vi.fn().mockResolvedValue([{ a: 1 }]),
-    });
-    const result = await executePipeline(page, [
-      { evaluate: 'test' },
-      { navigate: 'https://example.com' },
-    ]);
-    // navigate should preserve existing data
-    expect(result).toEqual([{ a: 1 }]);
-    expect(page.goto).toHaveBeenCalledWith('https://example.com');
-  });
-});

package/src/pipeline/executor.ts

@@ -1,110 +0,0 @@
-/**
- * Pipeline executor: runs YAML pipeline steps sequentially.
- */
-
-
-import type { IPage } from '../types.js';
-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>;
-  debug?: boolean;
-  /** Max retry attempts per step (default: 2 for browser steps, 0 for others) */
-  stepRetries?: number;
-}
-
-export async function executePipeline(
-  page: IPage | null,
-  pipeline: unknown[],
-  ctx: PipelineContext = {},
-): Promise<unknown> {
-  const args = ctx.args ?? {};
-  const debug = ctx.debug ?? false;
-  let data: unknown = null;
-  const total = pipeline.length;
-
-  try {
-    for (let i = 0; i < pipeline.length; i++) {
-      const step = pipeline[i];
-      if (!step || typeof step !== 'object') continue;
-      for (const [op, params] of Object.entries(step)) {
-        if (debug) debugStepStart(i + 1, total, op, params);
-
-        const handler = getStep(op);
-        if (handler) {
-          data = await executeStepWithRetry(handler, page, params, data, args, op, ctx.stepRetries);
-        } else {
-          throw new ConfigError(
-            `Unknown pipeline step "${op}" at index ${i}.`,
-            'Check the YAML pipeline step name or register the custom step before execution.',
-          );
-        }
-
-        if (debug) debugStepResult(op, data);
-      }
-    }
-  } catch (err) {
-    // Attempt cleanup: close automation window on pipeline failure
-    if (page?.closeWindow) {
-      try { await page.closeWindow(); } catch { /* ignore */ }
-    }
-    throw err;
-  }
-  return data;
-}
-
-async function executeStepWithRetry(
-  handler: StepHandler,
-  page: IPage | null,
-  params: unknown,
-  data: unknown,
-  args: Record<string, unknown>,
-  op: string,
-  configRetries?: number,
-): Promise<unknown> {
-  const maxRetries = configRetries ?? (BROWSER_ONLY_STEPS.has(op) ? 2 : 0);
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await handler(page, params, data, args);
-    } catch (err) {
-      if (attempt >= maxRetries) throw err;
-      // Only retry on transient browser errors
-      if (!isTransientBrowserError(err)) throw err;
-      // Brief delay before retry
-      await new Promise(resolve => setTimeout(resolve, 1000));
-    }
-  }
-  // Unreachable
-  throw new Error(`Step "${op}" failed after ${maxRetries} retries`);
-}
-
-function debugStepStart(stepNum: number, total: number, op: string, params: unknown): void {
-  let preview = '';
-  if (typeof params === 'string') {
-    preview = params.length <= 80 ? ` → ${params}` : ` → ${params.slice(0, 77)}...`;
-  } else if (params && typeof params === 'object' && !Array.isArray(params)) {
-    preview = ` (${Object.keys(params).join(', ')})`;
-  }
-  log.step(stepNum, total, op, preview);
-}
-
-function debugStepResult(op: string, data: unknown): void {
-  if (data === null || data === undefined) {
-    log.stepResult('(no data)');
-  } else if (Array.isArray(data)) {
-    log.stepResult(`${data.length} items`);
-  } else if (typeof data === 'object') {
-    const keys = Object.keys(data).slice(0, 5);
-    log.stepResult(`dict (${keys.join(', ')}${Object.keys(data).length > 5 ? '...' : ''})`);
-  } else if (typeof data === 'string') {
-    const p = data.slice(0, 60).replace(/\n/g, '\\n');
-    log.stepResult(`"${p}${data.length > 60 ? '...' : ''}"`);
-  } else {
-    log.stepResult(`${typeof data}`);
-  }
-}

package/src/pipeline/registry.ts

@@ -1,62 +0,0 @@
-/**
- * Dynamic registry for pipeline steps.
- * Allows core and third-party plugins to register custom YAML operations.
- */
-
-import type { IPage } from '../types.js';
-
-// Import core steps
-import { stepNavigate, stepClick, stepType, stepWait, stepPress, stepSnapshot, stepEvaluate } from './steps/browser.js';
-import { stepFetch } from './steps/fetch.js';
-import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
-import { stepIntercept } from './steps/intercept.js';
-import { stepTap } from './steps/tap.js';
-import { stepDownload } from './steps/download.js';
-
-/** 
- * Step handler: all pipeline steps conform to this generic interface.
- * TData is the type of the `data` state flowing into the step.
- * TResult is the expected return type.
- */
-export type StepHandler<TData = unknown, TResult = unknown, TParams = unknown> = (
-  page: IPage | null,
-  params: TParams,
-  data: TData,
-  args: Record<string, unknown>
-) => Promise<TResult>;
-
-const _stepRegistry = new Map<string, StepHandler>();
-
-/**
- * Get a registered step handler by name.
- */
-export function getStep(name: string): StepHandler | undefined {
-  return _stepRegistry.get(name);
-}
-
-/**
- * Register a new custom step handler for the YAML pipeline.
- */
-export function registerStep(name: string, handler: StepHandler): void {
-  _stepRegistry.set(name, handler);
-}
-
-// -------------------------------------------------------------
-// Auto-Register Core Steps
-// -------------------------------------------------------------
-registerStep('navigate', stepNavigate);
-registerStep('fetch', stepFetch);
-registerStep('select', stepSelect);
-registerStep('evaluate', stepEvaluate);
-registerStep('snapshot', stepSnapshot);
-registerStep('click', stepClick);
-registerStep('type', stepType);
-registerStep('wait', stepWait);
-registerStep('press', stepPress);
-registerStep('map', stepMap);
-registerStep('filter', stepFilter);
-registerStep('sort', stepSort);
-registerStep('limit', stepLimit);
-registerStep('intercept', stepIntercept);
-registerStep('tap', stepTap);
-registerStep('download', stepDownload);

package/src/pipeline/steps/browser.ts

@@ -1,76 +0,0 @@
-/**
- * Pipeline step: navigate, click, type, wait, press, snapshot.
- * Browser interaction primitives.
- */
-
-import type { IPage } from '../../types.js';
-import { render } from '../template.js';
-
-import { isRecord } from '../../utils.js';
-
-export async function stepNavigate(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
-  if (isRecord(params) && 'url' in params) {
-    const url = String(render(params.url, { args, data }));
-    await page!.goto(url, { waitUntil: params.waitUntil as 'load' | 'none' | undefined, settleMs: typeof params.settleMs === 'number' ? params.settleMs : undefined });
-  } else {
-    const url = render(params, { args, data });
-    await page!.goto(String(url));
-  }
-  return data;
-}
-
-export async function stepClick(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
-  await page!.click(String(render(params, { args, data })).replace(/^@/, ''));
-  return data;
-}
-
-export async function stepType(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
-  if (isRecord(params)) {
-    const ref = String(render(params.ref ?? '', { args, data })).replace(/^@/, '');
-    const text = String(render(params.text ?? '', { args, data }));
-    await page!.typeText(ref, text);
-    if (params.submit) await page!.pressKey('Enter');
-  }
-  return data;
-}
-
-export async function stepWait(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
-  if (typeof params === 'number') await page!.wait(params);
-  else if (isRecord(params)) {
-    if ('text' in params) {
-      await page!.wait({
-        text: String(render(params.text, { args, data })),
-        timeout: typeof params.timeout === 'number' ? params.timeout : undefined,
-      });
-    } else if ('time' in params) await page!.wait(Number(params.time));
-  } else if (typeof params === 'string') await page!.wait(Number(render(params, { args, data })));
-  return data;
-}
-
-export async function stepPress(page: IPage | null, params: unknown, data: unknown, args: Record<string, unknown>): Promise<unknown> {
-  await page!.pressKey(String(render(params, { args, data })));
-  return data;
-}
-
-export async function stepSnapshot(page: IPage | null, params: unknown, _data: unknown, _args: Record<string, unknown>): Promise<unknown> {
-  const opts = isRecord(params) ? params : {};
-  return page!.snapshot({
-    interactive: typeof opts.interactive === 'boolean' ? opts.interactive : false,
-    compact: typeof opts.compact === 'boolean' ? opts.compact : false,
-    maxDepth: typeof opts.max_depth === 'number' ? opts.max_depth : undefined,
-    raw: typeof opts.raw === 'boolean' ? opts.raw : false,
-  });
-}
-
-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);
-  // 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('}'))) {
-      try { result = JSON.parse(trimmed); } catch {}
-    }
-  }
-  return result;
-}