@jackwener/opencli 0.7.11 → 0.9.0

package/src/clis/antigravity/watch.ts

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '../../registry.js';
+
+export const watchCommand = cli({
+  site: 'antigravity',
+  name: 'watch',
+  description: 'Stream new chat messages from Antigravity in real-time',
+  domain: 'localhost',
+  strategy: Strategy.UI,
+  browser: true,
+  args: [],
+  timeoutSeconds: 86400, // Run for up to 24 hours
+  columns: [], // We use direct stdout streaming
+  func: async (page) => {
+    console.log('Watching Antigravity chat... (Press Ctrl+C to stop)');
+    
+    let lastLength = 0;
+    
+    // Loop until process gets killed
+    while (true) {
+      const text = await page.evaluate(`
+        async () => {
+          const container = document.getElementById('conversation');
+          return container ? container.innerText : '';
+        }
+      `);
+      
+      const currentLength = text.length;
+      if (currentLength > lastLength) {
+        // Delta mode
+        const newSegment = text.substring(lastLength);
+        if (newSegment.trim().length > 0) {
+          process.stdout.write(newSegment);
+        }
+        lastLength = currentLength;
+      } else if (currentLength < lastLength) {
+        // The conversation was cleared or updated significantly
+        lastLength = currentLength;
+        console.log('\\n--- Conversation Cleared/Changed ---\\n');
+        process.stdout.write(text);
+      }
+      
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+  },
+});

package/src/clis/barchart/flow.ts

@@ -30,81 +30,80 @@ cli({
       (async () => {
         const limit = ${limit};
         const typeFilter = '${optionType}'.toLowerCase();
-        const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
-        const headers = { 'X-CSRF-TOKEN': csrf };
 
+        // Wait for CSRF token to appear (Angular may inject it after initial render)
+        let csrf = '';
+        for (let i = 0; i < 10; i++) {
+          csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+          if (csrf) break;
+          await new Promise(r => setTimeout(r, 500));
+        }
+        if (!csrf) return { error: 'no-csrf' };
+
+        const headers = { 'X-CSRF-TOKEN': csrf };
         const fields = [
           'baseSymbol','strikePrice','expirationDate','optionType',
           'lastPrice','volume','openInterest','volumeOpenInterestRatio','volatility',
         ].join(',');
 
-        // Fetch extra rows when filtering by type since server-side filter may not work
+        // Fetch extra rows when filtering by type since server-side filter doesn't work
         const fetchLimit = typeFilter !== 'all' ? limit * 3 : limit;
-        try {
-          const url = '/proxies/core-api/v1/options/get?list=options.unusual_activity.stocks.us'
-            + '&fields=' + fields
-            + '&orderBy=volumeOpenInterestRatio&orderDir=desc'
-            + '&raw=1&limit=' + fetchLimit;
 
-          const resp = await fetch(url, { credentials: 'include', headers });
-          if (resp.ok) {
+        // Try unusual_activity first, fall back to mostActive (unusual_activity is
+        // empty outside market hours)
+        const lists = [
+          'options.unusual_activity.stocks.us',
+          'options.mostActive.us',
+        ];
+
+        for (const list of lists) {
+          try {
+            const url = '/proxies/core-api/v1/options/get?list=' + list
+              + '&fields=' + fields
+              + '&orderBy=volumeOpenInterestRatio&orderDir=desc'
+              + '&raw=1&limit=' + fetchLimit;
+
+            const resp = await fetch(url, { credentials: 'include', headers });
+            if (!resp.ok) continue;
             const d = await resp.json();
             let items = d?.data || [];
-            if (items.length > 0) {
-              // Apply client-side type filter
-              if (typeFilter !== 'all') {
-                items = items.filter(i => {
-                  const t = ((i.raw || i).optionType || '').toLowerCase();
-                  return t === typeFilter;
-                });
-              }
-              return items.slice(0, limit).map(i => {
-                const r = i.raw || i;
-                return {
-                  symbol: r.baseSymbol || r.symbol,
-                  type: r.optionType,
-                  strike: r.strikePrice,
-                  expiration: r.expirationDate,
-                  last: r.lastPrice,
-                  volume: r.volume,
-                  openInterest: r.openInterest,
-                  volOiRatio: r.volumeOpenInterestRatio,
-                  iv: r.volatility,
-                };
+            if (items.length === 0) continue;
+
+            // Apply client-side type filter
+            if (typeFilter !== 'all') {
+              items = items.filter(i => {
+                const t = ((i.raw || i).optionType || '').toLowerCase();
+                return t === typeFilter;
               });
             }
-          }
-        } catch(e) {}
-
-        // Fallback: parse from DOM table
-        try {
-          const rows = document.querySelectorAll('tr[data-ng-repeat], tbody tr');
-          const results = [];
-          for (const row of rows) {
-            const cells = row.querySelectorAll('td');
-            if (cells.length < 6) continue;
-            const getText = (idx) => cells[idx]?.textContent?.trim() || null;
-            results.push({
-              symbol: getText(0),
-              type: getText(1),
-              strike: getText(2),
-              expiration: getText(3),
-              last: getText(4),
-              volume: getText(5),
-              openInterest: cells.length > 6 ? getText(6) : null,
-              volOiRatio: cells.length > 7 ? getText(7) : null,
-              iv: cells.length > 8 ? getText(8) : null,
+            return items.slice(0, limit).map(i => {
+              const r = i.raw || i;
+              return {
+                symbol: r.baseSymbol || r.symbol,
+                type: r.optionType,
+                strike: r.strikePrice,
+                expiration: r.expirationDate,
+                last: r.lastPrice,
+                volume: r.volume,
+                openInterest: r.openInterest,
+                volOiRatio: r.volumeOpenInterestRatio,
+                iv: r.volatility,
+              };
             });
-            if (results.length >= limit) break;
-          }
-          return results;
-        } catch(e) {
-          return [];
+          } catch(e) {}
         }
+
+        return [];
       })()
     `);
 
-    if (!data || !Array.isArray(data)) return [];
+    if (!data) return [];
+
+    if (data.error === 'no-csrf') {
+      throw new Error('Could not extract CSRF token from barchart.com. Make sure you are logged in.');
+    }
+
+    if (!Array.isArray(data)) return [];
 
     return data.slice(0, limit).map(r => ({
       symbol: r.symbol || '',

package/src/clis/xiaoyuzhou/episode.ts

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { fetchPageProps, formatDuration, formatDate } from './utils.js';
+
+cli({
+  site: 'xiaoyuzhou',
+  name: 'episode',
+  description: 'View details of a Xiaoyuzhou podcast episode',
+  domain: 'www.xiaoyuzhoufm.com',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [{ name: 'id', positional: true, required: true, help: 'Episode ID (eid from podcast-episodes output)' }],
+  columns: ['title', 'podcast', 'duration', 'plays', 'comments', 'likes', 'date'],
+  func: async (_page, args) => {
+    const pageProps = await fetchPageProps(`/episode/${args.id}`);
+    const ep = pageProps.episode;
+    if (!ep) throw new CliError('NOT_FOUND', 'Episode not found', 'Please check the ID');
+    return [{
+      title: ep.title,
+      podcast: ep.podcast?.title,
+      duration: formatDuration(ep.duration),
+      plays: ep.playCount,
+      comments: ep.commentCount,
+      likes: ep.clapCount,
+      date: formatDate(ep.pubDate),
+    }];
+  },
+});

package/src/clis/xiaoyuzhou/podcast-episodes.ts

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { fetchPageProps, formatDuration, formatDate } from './utils.js';
+
+cli({
+  site: 'xiaoyuzhou',
+  name: 'podcast-episodes',
+  description: 'List recent episodes of a Xiaoyuzhou podcast (up to 15, SSR limit)',
+  domain: 'www.xiaoyuzhoufm.com',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'id', positional: true, required: true, help: 'Podcast ID (from xiaoyuzhoufm.com URL)' },
+    { name: 'limit', type: 'int', default: 15, help: 'Max episodes to show (up to 15, SSR limit)' },
+  ],
+  columns: ['eid', 'title', 'duration', 'plays', 'date'],
+  func: async (_page, args) => {
+    const pageProps = await fetchPageProps(`/podcast/${args.id}`);
+    const podcast = pageProps.podcast;
+    if (!podcast) throw new CliError('NOT_FOUND', 'Podcast not found', 'Please check the ID');
+    const allEpisodes = podcast.episodes ?? [];
+    const requestedLimit = Number(args.limit);
+    if (!Number.isInteger(requestedLimit) || requestedLimit < 1) {
+      throw new CliError('INVALID_ARGUMENT', 'limit must be a positive integer', 'Example: --limit 5');
+    }
+    const limit = Math.min(requestedLimit, allEpisodes.length);
+    const episodes = allEpisodes.slice(0, limit);
+    return episodes.map((ep: any) => ({
+      eid: ep.eid,
+      title: ep.title,
+      duration: formatDuration(ep.duration),
+      plays: ep.playCount,
+      date: formatDate(ep.pubDate),
+    }));
+  },
+});

package/src/clis/xiaoyuzhou/podcast.ts

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { fetchPageProps, formatDate } from './utils.js';
+
+cli({
+  site: 'xiaoyuzhou',
+  name: 'podcast',
+  description: 'View a Xiaoyuzhou podcast profile',
+  domain: 'www.xiaoyuzhoufm.com',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [{ name: 'id', positional: true, required: true, help: 'Podcast ID (from xiaoyuzhoufm.com URL)' }],
+  columns: ['title', 'author', 'description', 'subscribers', 'episodes', 'updated'],
+  func: async (_page, args) => {
+    const pageProps = await fetchPageProps(`/podcast/${args.id}`);
+    const p = pageProps.podcast;
+    if (!p) throw new CliError('NOT_FOUND', 'Podcast not found', 'Please check the ID');
+    return [{
+      title: p.title,
+      author: p.author,
+      description: p.brief,
+      subscribers: p.subscriptionCount,
+      episodes: p.episodeCount,
+      updated: formatDate(p.latestEpisodePubDate),
+    }];
+  },
+});

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

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatDuration, formatDate, fetchPageProps } from './utils.js';
+
+describe('formatDuration', () => {
+  it('formats typical duration', () => {
+    expect(formatDuration(3890)).toBe('64:50');
+  });
+
+  it('formats zero seconds', () => {
+    expect(formatDuration(0)).toBe('0:00');
+  });
+
+  it('pads single-digit seconds', () => {
+    expect(formatDuration(65)).toBe('1:05');
+  });
+
+  it('formats exact minutes', () => {
+    expect(formatDuration(3600)).toBe('60:00');
+  });
+
+  it('rounds floating-point seconds', () => {
+    expect(formatDuration(3890.7)).toBe('64:51');
+  });
+
+  it('returns dash for NaN', () => {
+    expect(formatDuration(NaN)).toBe('-');
+  });
+
+  it('returns dash for negative', () => {
+    expect(formatDuration(-1)).toBe('-');
+  });
+});
+
+describe('formatDate', () => {
+  it('extracts YYYY-MM-DD from ISO string', () => {
+    expect(formatDate('2026-03-13T11:00:06.686Z')).toBe('2026-03-13');
+  });
+
+  it('handles date-only string', () => {
+    expect(formatDate('2025-01-01')).toBe('2025-01-01');
+  });
+
+  it('returns dash for undefined/empty', () => {
+    expect(formatDate('')).toBe('-');
+    expect(formatDate(undefined as any)).toBe('-');
+  });
+});
+
+describe('fetchPageProps', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('extracts pageProps from valid HTML', async () => {
+    const mockHtml = `<html><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"podcast":{"title":"Test"}}}}</script></html>`;
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      text: () => Promise.resolve(mockHtml),
+    }));
+
+    const result = await fetchPageProps('/podcast/abc123');
+    expect(result).toEqual({ podcast: { title: 'Test' } });
+  });
+
+  it('throws on HTTP error', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 404,
+      text: () => Promise.resolve('Not Found'),
+    }));
+
+    await expect(fetchPageProps('/podcast/invalid')).rejects.toThrow('HTTP 404');
+  });
+
+  it('throws when __NEXT_DATA__ is missing', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      text: () => Promise.resolve('<html><body>No data here</body></html>'),
+    }));
+
+    await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Failed to extract');
+  });
+
+  it('throws when pageProps is empty', async () => {
+    const mockHtml = `<script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}}}</script>`;
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      text: () => Promise.resolve(mockHtml),
+    }));
+
+    await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Resource not found');
+  });
+
+  it('throws on malformed JSON in __NEXT_DATA__', async () => {
+    const mockHtml = `<script id="__NEXT_DATA__" type="application/json">{broken json</script>`;
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      text: () => Promise.resolve(mockHtml),
+    }));
+
+    await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Malformed __NEXT_DATA__');
+  });
+
+  it('handles multiline JSON in __NEXT_DATA__', async () => {
+    const mockHtml = `<script id="__NEXT_DATA__" type="application/json">
+{
+  "props": {
+    "pageProps": {
+      "episode": {"title": "Multiline Test"}
+    }
+  }
+}
+</script>`;
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      text: () => Promise.resolve(mockHtml),
+    }));
+
+    const result = await fetchPageProps('/episode/abc');
+    expect(result).toEqual({ episode: { title: 'Multiline Test' } });
+  });
+});

package/src/clis/xiaoyuzhou/utils.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared Xiaoyuzhou utilities — page data extraction and formatting.
+ *
+ * Xiaoyuzhou (小宇宙) is a Next.js app that embeds full page data in
+ * <script id="__NEXT_DATA__">. We fetch the HTML and extract that JSON
+ * instead of using their authenticated API.
+ */
+
+import { CliError } from '../../errors.js';
+
+/**
+ * Fetch a Xiaoyuzhou page and extract __NEXT_DATA__.props.pageProps.
+ * @param path - URL path, e.g. '/podcast/xxx' or '/episode/xxx'
+ */
+export async function fetchPageProps(path: string): Promise<any> {
+  const url = `https://www.xiaoyuzhoufm.com${path}`;
+  // Node.js fetch sends UA "node" which gets blocked; use a browser-like UA
+  const resp = await fetch(url, {
+    headers: { 'User-Agent': 'Mozilla/5.0 (compatible; opencli)' },
+  });
+  if (!resp.ok) {
+    throw new CliError(
+      'FETCH_ERROR',
+      `HTTP ${resp.status} for ${path}`,
+      'Please check the ID — you can find it in xiaoyuzhoufm.com URLs',
+    );
+  }
+  const html = await resp.text();
+  // [\s\S]*? for multiline safety (JSON may span lines)
+  const match = html.match(/<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/);
+  if (!match) {
+    throw new CliError(
+      'PARSE_ERROR',
+      'Failed to extract __NEXT_DATA__',
+      'Page structure may have changed',
+    );
+  }
+  let parsed: any;
+  try { parsed = JSON.parse(match[1]); }
+  catch { throw new CliError('PARSE_ERROR', 'Malformed __NEXT_DATA__ JSON', 'Page structure may have changed'); }
+  const pageProps = parsed.props?.pageProps;
+  if (!pageProps || Object.keys(pageProps).length === 0) {
+    throw new CliError(
+      'NOT_FOUND',
+      'Resource not found',
+      'Please check the ID — you can find it in xiaoyuzhoufm.com URLs',
+    );
+  }
+  return pageProps;
+}
+
+/** Format seconds to mm:ss (e.g. 3890 → "64:50"). Returns '-' for invalid input. */
+export function formatDuration(seconds: number): string {
+  if (!Number.isFinite(seconds) || seconds < 0) return '-';
+  seconds = Math.round(seconds);
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  return `${m}:${String(s).padStart(2, '0')}`;
+}
+
+/** Format ISO date string to YYYY-MM-DD. Returns '-' for missing input. */
+export function formatDate(iso: string): string {
+  if (!iso) return '-';
+  return iso.slice(0, 10);
+}

package/src/doctor.ts

@@ -591,6 +591,15 @@ export function renderBrowserDoctorReport(report: DoctorReport): string {
   const hasMismatch = uniqueFingerprints.length > 1;
   const lines = [chalk.bold(`opencli v${report.cliVersion ?? 'unknown'} doctor`), ''];
 
+  // CDP endpoint mode (for remote/server environments)
+  const cdpEndpoint = process.env.OPENCLI_CDP_ENDPOINT;
+  if (cdpEndpoint) {
+    lines.push(statusLine('OK', `CDP endpoint: ${chalk.cyan(cdpEndpoint)}`));
+    lines.push(chalk.dim('  → Remote Chrome mode: extension token not required'));
+    lines.push('');
+    return lines.join('\n');
+  }
+
   const installStatus: ReportStatus = report.extensionInstalled ? 'OK' : 'MISSING';
   const installDetail = report.extensionInstalled
     ? `Extension installed (${report.extensionBrowsers.join(', ')})`

package/src/engine.ts

@@ -164,15 +164,72 @@ function registerYamlCli(filePath: string, defaultSite: string): void {
   }
 }
 
+/**
+ * Validates and coerces arguments based on the command's Arg definitions.
+ */
+function coerceAndValidateArgs(cmdArgs: Arg[], kwargs: Record<string, any>): Record<string, any> {
+  const result: Record<string, any> = { ...kwargs };
+
+  for (const argDef of cmdArgs) {
+    const val = result[argDef.name];
+    
+    // 1. Check required
+    if (argDef.required && (val === undefined || val === null || val === '')) {
+      throw new Error(`Argument "${argDef.name}" is required.\n${argDef.help ? `Hint: ${argDef.help}` : ''}`);
+    }
+
+    if (val !== undefined && val !== null) {
+      // 2. Type coercion
+      if (argDef.type === 'int' || argDef.type === 'number') {
+        const num = Number(val);
+        if (Number.isNaN(num)) {
+          throw new Error(`Argument "${argDef.name}" must be a valid number. Received: "${val}"`);
+        }
+        result[argDef.name] = num;
+      } else if (argDef.type === 'boolean' || argDef.type === 'bool') {
+        if (typeof val === 'string') {
+          const lower = val.toLowerCase();
+          if (lower === 'true' || lower === '1') result[argDef.name] = true;
+          else if (lower === 'false' || lower === '0') result[argDef.name] = false;
+          else throw new Error(`Argument "${argDef.name}" must be a boolean (true/false). Received: "${val}"`);
+        } else {
+          result[argDef.name] = Boolean(val);
+        }
+      }
+
+      // 3. Choices validation
+      const coercedVal = result[argDef.name];
+      if (argDef.choices && argDef.choices.length > 0) {
+        // Only stringent check for string/number types against choices array
+        if (!argDef.choices.map(String).includes(String(coercedVal))) {
+          throw new Error(`Argument "${argDef.name}" must be one of: ${argDef.choices.join(', ')}. Received: "${coercedVal}"`);
+        }
+      }
+    } else if (argDef.default !== undefined) {
+      // Set default if value is missing
+      result[argDef.name] = argDef.default;
+    }
+  }
+  return result;
+}
+
 /**
  * Execute a CLI command. Handles lazy-loading of TS modules.
  */
 export async function executeCommand(
   cmd: CliCommand,
   page: IPage | null,
-  kwargs: Record<string, any>,
+  rawKwargs: Record<string, any>,
   debug: boolean = false,
 ): Promise<any> {
+  let kwargs: Record<string, any>;
+  try {
+    kwargs = coerceAndValidateArgs(cmd.args, rawKwargs);
+  } catch (err: any) {
+    // Re-throw validation errors clearly
+    throw new Error(`[Argument Validation Error]\n${err.message}`);
+  }
+
   // Lazy-load TS module on first execution
   const internal = cmd as InternalCliCommand;
   if (internal._lazy && internal._modulePath) {

package/src/main.ts

@@ -189,19 +189,21 @@ for (const [, cmd] of registry) {
     const actionOpts = actionArgs[positionalArgs.length] ?? {};
     const startTime = Date.now();
     const kwargs: Record<string, any> = {};
+    
     // Collect positional args
     for (let i = 0; i < positionalArgs.length; i++) {
       const arg = positionalArgs[i];
       const v = actionArgs[i];
-      if (v !== undefined) kwargs[arg.name] = coerce(v, arg.type ?? 'str');
-      else if (arg.default != null) kwargs[arg.name] = arg.default;
+      if (v !== undefined) kwargs[arg.name] = v;
     }
+    
     // Collect named options
     for (const arg of cmd.args) {
       if (arg.positional) continue;
-      const v = actionOpts[arg.name]; if (v !== undefined) kwargs[arg.name] = coerce(v, arg.type ?? 'str');
-      else if (arg.default != null) kwargs[arg.name] = arg.default;
+      const v = actionOpts[arg.name]; 
+      if (v !== undefined) kwargs[arg.name] = v;
     }
+
     try {
       if (actionOpts.verbose) process.env.OPENCLI_VERBOSE = '1';
       let result: any;
@@ -226,11 +228,4 @@ for (const [, cmd] of registry) {
   });
 }
 
-function coerce(v: any, t: string): any {
-  if (t === 'bool') return ['1', 'true', 'yes', 'on'].includes(String(v).toLowerCase());
-  if (t === 'int') return parseInt(String(v), 10);
-  if (t === 'float') return parseFloat(String(v));
-  return String(v);
-}
-
 program.parse();

package/src/pipeline/executor.ts

@@ -4,11 +4,7 @@
 
 import chalk from 'chalk';
 import type { IPage } from '../types.js';
-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 { getStep, type StepHandler } from './registry.js';
 import { log } from '../logger.js';
 
 export interface PipelineContext {
@@ -16,28 +12,6 @@ export interface PipelineContext {
   debug?: boolean;
 }
 
-/** Step handler: all steps conform to (page, params, data, args) => Promise<any> */
-type StepHandler = (page: IPage | null, params: any, data: any, args: Record<string, any>) => Promise<any>;
-
-/** Registry of all available step handlers */
-const STEP_HANDLERS: Record<string, StepHandler> = {
-  navigate: stepNavigate,
-  fetch: stepFetch,
-  select: stepSelect,
-  evaluate: stepEvaluate,
-  snapshot: stepSnapshot,
-  click: stepClick,
-  type: stepType,
-  wait: stepWait,
-  press: stepPress,
-  map: stepMap,
-  filter: stepFilter,
-  sort: stepSort,
-  limit: stepLimit,
-  intercept: stepIntercept,
-  tap: stepTap,
-};
-
 export async function executePipeline(
   page: IPage | null,
   pipeline: any[],
@@ -54,7 +28,7 @@ export async function executePipeline(
     for (const [op, params] of Object.entries(step)) {
       if (debug) debugStepStart(i + 1, total, op, params);
 
-      const handler = STEP_HANDLERS[op];
+      const handler = getStep(op);
       if (handler) {
         data = await handler(page, params, data, args);
       } else {