@jackwener/opencli 0.3.0 → 0.4.1

package/src/browser.ts

@@ -104,8 +104,13 @@ export class Page implements IPage {
     await this.call('tools/call', { name: 'browser_press_key', arguments: { key } });
   }
 
-  async wait(seconds: number): Promise<void> {
-    await this.call('tools/call', { name: 'browser_wait_for', arguments: { time: seconds } });
+  async wait(options: number | { text?: string; time?: number; timeout?: number }): Promise<void> {
+    if (typeof options === 'number') {
+      await this.call('tools/call', { name: 'browser_wait_for', arguments: { time: options } });
+    } else {
+      // Pass directly to native wait_for, which supports natively awaiting text strings without heavy DOM polling
+      await this.call('tools/call', { name: 'browser_wait_for', arguments: options });
+    }
   }
 
   async tabs(): Promise<any> {
@@ -139,10 +144,32 @@ export class Page implements IPage {
   async autoScroll(options: { times?: number; delayMs?: number } = {}): Promise<void> {
     const times = options.times ?? 3;
     const delayMs = options.delayMs ?? 2000;
-    for (let i = 0; i < times; i++) {
-        await this.evaluate('() => window.scrollTo(0, document.body.scrollHeight)');
-        await this.wait(delayMs / 1000);
-    }
+    const js = `
+      async () => {
+        const maxTimes = ${times};
+        const maxWaitMs = ${delayMs};
+        for (let i = 0; i < maxTimes; i++) {
+          const lastHeight = document.body.scrollHeight;
+          window.scrollTo(0, lastHeight);
+          await new Promise(resolve => {
+            let timeoutId;
+            const observer = new MutationObserver(() => {
+              if (document.body.scrollHeight > lastHeight) {
+                clearTimeout(timeoutId);
+                observer.disconnect();
+                setTimeout(resolve, 100); // Small debounce for rendering
+              }
+            });
+            observer.observe(document.body, { childList: true, subtree: true });
+            timeoutId = setTimeout(() => {
+              observer.disconnect();
+              resolve(null);
+            }, maxWaitMs);
+          });
+        }
+      }
+    `;
+    await this.evaluate(js);
   }
 
   async installInterceptor(pattern: string): Promise<void> {

package/src/build-manifest.ts

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/**
+ * Build-time CLI manifest compiler.
+ *
+ * Scans all YAML/TS CLI definitions and pre-compiles them into a single
+ * manifest.json for instant cold-start registration (no runtime YAML parsing).
+ *
+ * Usage: npx tsx src/build-manifest.ts
+ * Output: dist/cli-manifest.json
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'js-yaml';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLIS_DIR = path.resolve(__dirname, 'clis');
+const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
+
+interface ManifestEntry {
+  site: string;
+  name: string;
+  description: string;
+  domain?: string;
+  strategy: string;
+  browser: boolean;
+  args: Array<{
+    name: string;
+    type?: string;
+    default?: any;
+    required?: boolean;
+    help?: string;
+    choices?: string[];
+  }>;
+  columns?: string[];
+  pipeline?: any[];
+  timeout?: number;
+  /** 'yaml' or 'ts' — determines how executeCommand loads the handler */
+  type: 'yaml' | 'ts';
+  /** Relative path from clis/ dir, e.g. 'bilibili/hot.yaml' or 'bilibili/search.js' */
+  modulePath?: string;
+}
+
+function scanYaml(filePath: string, site: string): ManifestEntry | null {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const def = yaml.load(raw) as any;
+    if (!def || typeof def !== 'object') return null;
+
+    const strategyStr = def.strategy ?? (def.browser === false ? 'public' : 'cookie');
+    const strategy = strategyStr.toUpperCase();
+    const browser = def.browser ?? (strategy !== 'PUBLIC');
+
+    const args: ManifestEntry['args'] = [];
+    if (def.args && typeof def.args === 'object') {
+      for (const [argName, argDef] of Object.entries(def.args as Record<string, any>)) {
+        args.push({
+          name: argName,
+          type: argDef?.type ?? 'str',
+          default: argDef?.default,
+          required: argDef?.required ?? false,
+          help: argDef?.description ?? argDef?.help ?? '',
+          choices: argDef?.choices,
+        });
+      }
+    }
+
+    return {
+      site: def.site ?? site,
+      name: def.name ?? path.basename(filePath, path.extname(filePath)),
+      description: def.description ?? '',
+      domain: def.domain,
+      strategy: strategy.toLowerCase(),
+      browser,
+      args,
+      columns: def.columns,
+      pipeline: def.pipeline,
+      timeout: def.timeout,
+      type: 'yaml',
+    };
+  } catch (err: any) {
+    process.stderr.write(`Warning: failed to parse ${filePath}: ${err.message}\n`);
+    return null;
+  }
+}
+
+function scanTs(filePath: string, site: string): ManifestEntry {
+  // TS adapters self-register via cli() at import time.
+  // We record their module path for lazy dynamic import.
+  const baseName = path.basename(filePath, path.extname(filePath));
+  const relativePath = `${site}/${baseName}.js`;
+  return {
+    site,
+    name: baseName,
+    description: '',
+    strategy: 'cookie',
+    browser: true,
+    args: [],
+    type: 'ts',
+    modulePath: relativePath,
+  };
+}
+
+// Main
+const manifest: ManifestEntry[] = [];
+
+if (fs.existsSync(CLIS_DIR)) {
+  for (const site of fs.readdirSync(CLIS_DIR)) {
+    const siteDir = path.join(CLIS_DIR, site);
+    if (!fs.statSync(siteDir).isDirectory()) continue;
+    for (const file of fs.readdirSync(siteDir)) {
+      const filePath = path.join(siteDir, file);
+      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+        const entry = scanYaml(filePath, site);
+        if (entry) manifest.push(entry);
+      } else if (
+        (file.endsWith('.ts') && !file.endsWith('.d.ts') && file !== 'index.ts') ||
+        (file.endsWith('.js') && !file.endsWith('.d.js') && file !== 'index.js')
+      ) {
+        manifest.push(scanTs(filePath, site));
+      }
+    }
+  }
+}
+
+// Ensure output directory exists
+fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
+fs.writeFileSync(OUTPUT, JSON.stringify(manifest, null, 2));
+
+const yamlCount = manifest.filter(e => e.type === 'yaml').length;
+const tsCount = manifest.filter(e => e.type === 'ts').length;
+console.log(`✅ Manifest compiled: ${manifest.length} entries (${yamlCount} YAML, ${tsCount} TS) → ${OUTPUT}`);

package/src/clis/bilibili/following.ts

@@ -0,0 +1,50 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchJson, getSelfUid, resolveUid } from '../../bilibili.js';
+
+cli({
+  site: 'bilibili',
+  name: 'following',
+  description: '获取 Bilibili 用户的关注列表',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'uid', required: false, help: '目标用户 ID（默认为当前登录用户）' },
+    { name: 'page', type: 'int', required: false, default: 1, help: '页码' },
+    { name: 'limit', type: 'int', required: false, default: 50, help: '每页数量 (最大 50)' },
+  ],
+  columns: ['mid', 'name', 'sign', 'following', 'fans'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+
+    // 1. Resolve UID (default to self)
+    const uid = kwargs.uid
+      ? await resolveUid(page, kwargs.uid)
+      : await getSelfUid(page);
+
+    const pn = kwargs.page ?? 1;
+    const ps = Math.min(kwargs.limit ?? 50, 50);
+
+    // 2. Fetch following list (standard Cookie API, no Wbi signing needed)
+    const payload = await fetchJson(page,
+      `https://api.bilibili.com/x/relation/followings?vmid=${uid}&pn=${pn}&ps=${ps}&order=desc`
+    );
+
+    if (payload.code !== 0) {
+      throw new Error(`获取关注列表失败: ${payload.message} (${payload.code})`);
+    }
+
+    const list = payload.data?.list || [];
+    if (list.length === 0) {
+      return [{ mid: '-', name: `共 ${payload.data?.total ?? 0} 人关注，当前页无数据`, sign: '', following: '', fans: '' }];
+    }
+
+    // 3. Map to output
+    return list.map((u: any) => ({
+      mid: u.mid,
+      name: u.uname,
+      sign: (u.sign || '').slice(0, 40),
+      following: u.attribute === 6 ? '互相关注' : '已关注',
+      fans: u.official_verify?.desc || '',
+    }));
+  },
+});

package/src/clis/bilibili/subtitle.ts

@@ -0,0 +1,100 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { apiGet } from '../../bilibili.js';
+
+cli({
+  site: 'bilibili',
+  name: 'subtitle',
+  description: '获取 Bilibili 视频的字幕',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'bvid', required: true },
+    { name: 'lang', required: false, help: '字幕语言代码 (如 zh-CN, en-US, ai-zh)，默认取第一个' },
+  ],
+  columns: ['index', 'from', 'to', 'content'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+    // 1. 先前往视频详情页 (建立有鉴权的 Session，且这里不需要加载完整个视频)
+    await page.goto(`https://www.bilibili.com/video/${kwargs.bvid}/`);
+
+    // 2. 利用 __INITIAL_STATE__ 获取基础信息，拿 CID
+    const cid = await page.evaluate(`(async () => {
+      const state = window.__INITIAL_STATE__ || {};
+      return state?.videoData?.cid;
+    })()`);
+
+    if (!cid) {
+      throw new Error('无法在页面中提取到当前视频的 CID，请检查页面是否正常加载。');
+    }
+
+    // 3. 在 Node 端使用 apiGet 获取带 Wbi 签名的字幕列表
+    // 之前纯靠 evaluate 里的 fetch 会失败，因为 B 站 /wbi/ 开头的接口强校验 w_rid，未签名直接被风控返回 403 HTML
+    const payload = await apiGet(page, '/x/player/wbi/v2', {
+      params: { bvid: kwargs.bvid, cid },
+      signed: true, // 开启 wbi_sign 自动签名
+    });
+
+    if (payload.code !== 0) {
+      throw new Error(`获取视频播放信息失败: ${payload.message} (${payload.code})`);
+    }
+
+    const subtitles = payload.data?.subtitle?.subtitles || [];
+    if (subtitles.length === 0) {
+      throw new Error('此视频没有发现外挂或智能字幕。');
+    }
+
+    // 4. 选择目标字幕语言
+    const target = kwargs.lang
+      ? subtitles.find((s: any) => s.lan === kwargs.lang) || subtitles[0]
+      : subtitles[0];
+
+    const targetSubUrl = target.subtitle_url;
+    if (!targetSubUrl || targetSubUrl === '') {
+      throw new Error('[风控拦截/未登录] 获取到的 subtitle_url 为空！请确保 CLI 已成功登录且风控未封锁此账号。');
+    }
+
+    const finalUrl = targetSubUrl.startsWith('//') ? 'https:' + targetSubUrl : targetSubUrl;
+
+
+    // 5. 解析并拉取 CDN 的 JSON 文件
+    const fetchJs = `
+      (async () => {
+         const url = ${JSON.stringify(finalUrl)};
+         const res = await fetch(url);
+         const text = await res.text();
+         
+         if (text.startsWith('<!DOCTYPE') || text.startsWith('<html')) {
+            return { error: 'HTML', text: text.substring(0, 100), url };
+         }
+         
+         try {
+             const subJson = JSON.parse(text);
+             // B站真实返回格式是 { font_size: 0.4, font_color: "#FFFFFF", background_alpha: 0.5, background_color: "#9C27B0", Stroke: "none", type: "json" , body: [{from: 0, to: 0, content: ""}] }
+             if (Array.isArray(subJson?.body)) return { success: true, data: subJson.body };
+             if (Array.isArray(subJson)) return { success: true, data: subJson };
+             return { error: 'UNKNOWN_JSON', data: subJson };
+         } catch (e) {
+             return { error: 'PARSE_FAILED', text: text.substring(0, 100) };
+         }
+      })()
+    `;
+    const items = await page.evaluate(fetchJs);
+
+    if (items?.error) {
+      throw new Error(`字幕获取失败: ${items.error}${items.text ? ' — ' + items.text : ''}`);
+    }
+
+    const finalItems = items?.data || [];
+    if (!Array.isArray(finalItems)) {
+      throw new Error('解析到的字幕列表对象不符合数组格式');
+    }
+
+    // 6. 数据映射
+    return finalItems.map((item: any, idx: number) => ({
+      index: idx + 1,
+      from: Number(item.from || 0).toFixed(2) + 's',
+      to: Number(item.to || 0).toFixed(2) + 's',
+      content: item.content
+    }));
+  },
+});

package/src/engine.ts

@@ -1,5 +1,11 @@
 /**
  * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ *
+ * Supports two modes:
+ * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
+ *    registers all YAML commands instantly without runtime YAML parsing.
+ *    TS modules are loaded lazily only when their command is executed.
+ * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 
 import * as fs from 'node:fs';
@@ -9,25 +15,99 @@ import { type CliCommand, type Arg, Strategy, registerCommand } from './registry
 import type { IPage } from './types.js';
 import { executePipeline } from './pipeline.js';
 
+/** Set of TS module paths that have been loaded */
+const _loadedModules = new Set<string>();
+
+/**
+ * Discover and register CLI commands.
+ * Uses pre-compiled manifest when available for instant startup.
+ */
 export async function discoverClis(...dirs: string[]): Promise<void> {
-  const promises: Promise<any>[] = [];
+  // Fast path: try manifest first (production / post-build)
   for (const dir of dirs) {
-    if (!fs.existsSync(dir)) continue;
-    for (const site of fs.readdirSync(dir)) {
-      const siteDir = path.join(dir, site);
-      if (!fs.statSync(siteDir).isDirectory()) continue;
-      for (const file of fs.readdirSync(siteDir)) {
-        const filePath = path.join(siteDir, file);
-        if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-          registerYamlCli(filePath, site);
-        } else if (file.endsWith('.js')) {
-          // Dynamic import of compiled adapter modules
-          promises.push(
-            import(`file://${filePath}`).catch((err: any) => {
-              process.stderr.write(`Warning: failed to load module ${filePath}: ${err.message}\n`);
-            })
-          );
-        }
+    const manifestPath = path.resolve(dir, '..', 'cli-manifest.json');
+    if (fs.existsSync(manifestPath)) {
+      loadFromManifest(manifestPath, dir);
+      continue; // Skip filesystem scan for this directory
+    }
+    // Fallback: runtime filesystem scan (development)
+    await discoverClisFromFs(dir);
+  }
+}
+
+/**
+ * Fast-path: register commands from pre-compiled manifest.
+ * YAML pipelines are inlined — zero YAML parsing at runtime.
+ * TS modules are deferred — loaded lazily on first execution.
+ */
+function loadFromManifest(manifestPath: string, clisDir: string): void {
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as any[];
+    for (const entry of manifest) {
+      if (entry.type === 'yaml') {
+        // YAML pipelines fully inlined in manifest — register directly
+        const strategy = (Strategy as any)[entry.strategy.toUpperCase()] ?? Strategy.COOKIE;
+        const cmd: CliCommand = {
+          site: entry.site,
+          name: entry.name,
+          description: entry.description ?? '',
+          domain: entry.domain,
+          strategy,
+          browser: entry.browser,
+          args: entry.args ?? [],
+          columns: entry.columns,
+          pipeline: entry.pipeline,
+          timeoutSeconds: entry.timeout,
+          source: `manifest:${entry.site}/${entry.name}`,
+        };
+        registerCommand(cmd);
+      } else if (entry.type === 'ts' && entry.modulePath) {
+        // TS adapters: register a lightweight stub.
+        // The actual module is loaded lazily on first executeCommand().
+        const strategy = (Strategy as any)[(entry.strategy ?? 'cookie').toUpperCase()] ?? Strategy.COOKIE;
+        const modulePath = path.resolve(clisDir, entry.modulePath);
+        const cmd: CliCommand = {
+          site: entry.site,
+          name: entry.name,
+          description: entry.description ?? '',
+          domain: entry.domain,
+          strategy,
+          browser: entry.browser ?? true,
+          args: entry.args ?? [],
+          columns: entry.columns,
+          timeoutSeconds: entry.timeout,
+          source: modulePath,
+          // Mark as lazy — executeCommand will load the module before running
+          _lazy: true,
+          _modulePath: modulePath,
+        };
+        registerCommand(cmd);
+      }
+    }
+  } catch (err: any) {
+    process.stderr.write(`Warning: failed to load manifest ${manifestPath}: ${err.message}\n`);
+  }
+}
+
+/**
+ * Fallback: traditional filesystem scan (used during development with tsx).
+ */
+async function discoverClisFromFs(dir: string): Promise<void> {
+  if (!fs.existsSync(dir)) return;
+  const promises: Promise<any>[] = [];
+  for (const site of fs.readdirSync(dir)) {
+    const siteDir = path.join(dir, site);
+    if (!fs.statSync(siteDir).isDirectory()) continue;
+    for (const file of fs.readdirSync(siteDir)) {
+      const filePath = path.join(siteDir, file);
+      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+        registerYamlCli(filePath, site);
+      } else if (file.endsWith('.js') && !file.endsWith('.d.js')) {
+        promises.push(
+          import(`file://${filePath}`).catch((err: any) => {
+            process.stderr.write(`Warning: failed to load module ${filePath}: ${err.message}\n`);
+          })
+        );
       }
     }
   }
@@ -80,12 +160,38 @@ function registerYamlCli(filePath: string, defaultSite: string): void {
   }
 }
 
+/**
+ * Execute a CLI command. Handles lazy-loading of TS modules.
+ */
 export async function executeCommand(
   cmd: CliCommand,
   page: IPage | null,
   kwargs: Record<string, any>,
   debug: boolean = false,
 ): Promise<any> {
+  // Lazy-load TS module on first execution
+  if ((cmd as any)._lazy && (cmd as any)._modulePath) {
+    const modulePath = (cmd as any)._modulePath;
+    if (!_loadedModules.has(modulePath)) {
+      try {
+        await import(`file://${modulePath}`);
+        _loadedModules.add(modulePath);
+      } catch (err: any) {
+        throw new Error(`Failed to load adapter module ${modulePath}: ${err.message}`);
+      }
+    }
+    // After loading, the module's cli() call will have updated the registry
+    // with the real func/pipeline. Re-fetch the command.
+    const { getRegistry, fullName } = await import('./registry.js');
+    const updated = getRegistry().get(fullName(cmd));
+    if (updated && updated.func) {
+      return updated.func(page, kwargs, debug);
+    }
+    if (updated && updated.pipeline) {
+      return executePipeline(page, updated.pipeline, { args: kwargs, debug });
+    }
+  }
+
   if (cmd.func) {
     return cmd.func(page, kwargs, debug);
   }

package/src/explore.ts

@@ -184,6 +184,8 @@ function scoreEndpoint(ep: { contentType: string; responseAnalysis: any; pattern
   if (ep.hasPaginationParam) s += 2;
   if (ep.hasLimitParam) s += 2;
   if (ep.status === 200) s += 2;
+  // Anti-Bot Empty Value Detection: penalize JSON endpoints returning empty data
+  if (ep.responseAnalysis && ep.responseAnalysis.itemCount === 0 && ep.contentType.includes('json')) s -= 3;
   return s;
 }
 
@@ -277,6 +279,30 @@ export interface DiscoveredStore {
   stateKeys: string[];
 }
 
+// ── Auto-Interaction (Fuzzing) ─────────────────────────────────────────────
+
+const INTERACT_FUZZ_JS = `
+  async () => {
+    const sleep = ms => new Promise(r => setTimeout(r, ms));
+    const clickables = Array.from(document.querySelectorAll(
+      'button, [role="button"], [role="tab"], .tab, .btn, a[href="javascript:void(0)"], a[href="#"]'
+    )).slice(0, 15); // limit to 15 to avoid endless loops
+
+    let clicked = 0;
+    for (const el of clickables) {
+      try {
+        const rect = el.getBoundingClientRect();
+        if (rect.width > 0 && rect.height > 0) {
+          el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+          clicked++;
+          await sleep(300); // give it time to trigger network
+        }
+      } catch {}
+    }
+    return clicked;
+  }
+`;
+
 // ── Main explore function ──────────────────────────────────────────────────
 
 export async function exploreUrl(
@@ -300,6 +326,31 @@ export async function exploreUrl(
       // Step 2: Auto-scroll to trigger lazy loading (use keyboard since page.scroll may not exist)
       for (let i = 0; i < 3; i++) { try { await page.pressKey('End'); } catch {} await page.wait(1); }
 
+      // Step 2.5: Interactive Fuzzing (if requested)
+      if (opts.auto) {
+         try {
+           // First: targeted clicks by label (e.g. "字幕", "CC", "评论")
+           if (opts.clickLabels?.length) {
+             for (const label of opts.clickLabels) {
+               const safeLabel = label.replace(/'/g, "\\'");
+               await page.evaluate(`
+                 (() => {
+                   const el = [...document.querySelectorAll('button, [role="button"], [role="tab"], a, span')]
+                     .find(e => e.textContent && e.textContent.trim().includes('${safeLabel}'));
+                   if (el) el.click();
+                 })()
+               `);
+               await page.wait(1);
+             }
+           }
+           // Then: blind fuzzing on generic interactive elements
+           const clicks = await page.evaluate(INTERACT_FUZZ_JS);
+           await page.wait(2); // wait for XHRs to settle
+         } catch (e) {
+           // fuzzing is best-effort, don't fail the whole explore
+         }
+      }
+
       // Step 3: Read page metadata
       const metadata = await readPageMetadata(page);
 

package/src/main.ts

@@ -53,8 +53,8 @@ program.command('validate').description('Validate CLI definitions').argument('[t
 program.command('verify').description('Validate + smoke test').argument('[target]').option('--smoke', 'Run smoke tests', false)
   .action(async (target, opts) => { const { verifyClis, renderVerifyReport } = await import('./verify.js'); const r = await verifyClis({ builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, target, smoke: opts.smoke }); console.log(renderVerifyReport(r)); process.exitCode = r.ok ? 0 : 1; });
 
-program.command('explore').alias('probe').description('Explore a website: discover APIs, stores, and recommend strategies').argument('<url>').option('--site <name>').option('--goal <text>').option('--wait <s>', '', '3')
-  .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: PlaywrightMCP, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait) }))); });
+program.command('explore').alias('probe').description('Explore a website: discover APIs, stores, and recommend strategies').argument('<url>').option('--site <name>').option('--goal <text>').option('--wait <s>', '', '3').option('--auto', 'Enable interactive fuzzing (simulate clicks to trigger lazy APIs)').option('--click <labels>', 'Comma-separated labels to click before fuzzing (e.g. "字幕,CC,评论")')
+  .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); const clickLabels = opts.click ? opts.click.split(',').map((s: string) => s.trim()) : undefined; console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: PlaywrightMCP, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait), auto: opts.auto, clickLabels }))); });
 
 program.command('synthesize').description('Synthesize CLIs from explore').argument('<target>').option('--top <n>', '', '3')
   .action(async (target, opts) => { const { synthesizeFromExplore, renderSynthesizeSummary } = await import('./synthesize.js'); console.log(renderSynthesizeSummary(synthesizeFromExplore(target, { top: parseInt(opts.top) }))); });

package/src/pipeline/steps/browser.ts

@@ -31,13 +31,10 @@ export async function stepWait(page: IPage, params: any, data: any, args: Record
   if (typeof params === 'number') await page.wait(params);
   else if (typeof params === 'object' && params) {
     if ('text' in params) {
-      const timeout = params.timeout ?? 10;
-      const start = Date.now();
-      while ((Date.now() - start) / 1000 < timeout) {
-        const snap = await page.snapshot({ raw: true });
-        if (typeof snap === 'string' && snap.includes(params.text)) break;
-        await page.wait(0.5);
-      }
+      await page.wait({
+        text: String(render(params.text, { args, data })),
+        timeout: params.timeout
+      });
     } 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;