@jackwener/opencli 0.3.0 → 0.4.1

package/dist/clis/bilibili/following.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/bilibili/following.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '../../registry.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, kwargs) => {
+        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) => ({
+            mid: u.mid,
+            name: u.uname,
+            sign: (u.sign || '').slice(0, 40),
+            following: u.attribute === 6 ? '互相关注' : '已关注',
+            fans: u.official_verify?.desc || '',
+        }));
+    },
+});

package/dist/clis/bilibili/subtitle.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/bilibili/subtitle.js

@@ -0,0 +1,86 @@
+import { cli, Strategy } from '../../registry.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, kwargs) => {
+        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) => 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, idx) => ({
+            index: idx + 1,
+            from: Number(item.from || 0).toFixed(2) + 's',
+            to: Number(item.to || 0).toFixed(2) + 's',
+            content: item.content
+        }));
+    },
+});

package/dist/engine.d.ts

@@ -1,7 +1,20 @@
 /**
  * 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 { type CliCommand } from './registry.js';
 import type { IPage } from './types.js';
+/**
+ * Discover and register CLI commands.
+ * Uses pre-compiled manifest when available for instant startup.
+ */
 export declare function discoverClis(...dirs: string[]): Promise<void>;
+/**
+ * Execute a CLI command. Handles lazy-loading of TS modules.
+ */
 export declare function executeCommand(cmd: CliCommand, page: IPage | null, kwargs: Record<string, any>, debug?: boolean): Promise<any>;

package/dist/engine.js

@@ -1,31 +1,110 @@
 /**
  * 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';
 import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { Strategy, registerCommand } from './registry.js';
 import { executePipeline } from './pipeline.js';
+/** Set of TS module paths that have been loaded */
+const _loadedModules = new Set();
+/**
+ * Discover and register CLI commands.
+ * Uses pre-compiled manifest when available for instant startup.
+ */
 export async function discoverClis(...dirs) {
-    const promises = [];
+    // Fast path: try manifest first (production / post-build)
     for (const dir of dirs) {
-        if (!fs.existsSync(dir))
+        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, clisDir) {
+    try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        for (const entry of manifest) {
+            if (entry.type === 'yaml') {
+                // YAML pipelines fully inlined in manifest — register directly
+                const strategy = Strategy[entry.strategy.toUpperCase()] ?? Strategy.COOKIE;
+                const cmd = {
+                    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[(entry.strategy ?? 'cookie').toUpperCase()] ?? Strategy.COOKIE;
+                const modulePath = path.resolve(clisDir, entry.modulePath);
+                const cmd = {
+                    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) {
+        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) {
+    if (!fs.existsSync(dir))
+        return;
+    const promises = [];
+    for (const site of fs.readdirSync(dir)) {
+        const siteDir = path.join(dir, site);
+        if (!fs.statSync(siteDir).isDirectory())
             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) => {
-                        process.stderr.write(`Warning: failed to load module ${filePath}: ${err.message}\n`);
-                    }));
-                }
+        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) => {
+                    process.stderr.write(`Warning: failed to load module ${filePath}: ${err.message}\n`);
+                }));
             }
         }
     }
@@ -74,7 +153,33 @@ function registerYamlCli(filePath, defaultSite) {
         process.stderr.write(`Warning: failed to load ${filePath}: ${err.message}\n`);
     }
 }
+/**
+ * Execute a CLI command. Handles lazy-loading of TS modules.
+ */
 export async function executeCommand(cmd, page, kwargs, debug = false) {
+    // Lazy-load TS module on first execution
+    if (cmd._lazy && cmd._modulePath) {
+        const modulePath = cmd._modulePath;
+        if (!_loadedModules.has(modulePath)) {
+            try {
+                await import(`file://${modulePath}`);
+                _loadedModules.add(modulePath);
+            }
+            catch (err) {
+                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/dist/explore.js

@@ -175,6 +175,9 @@ function scoreEndpoint(ep) {
         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;
 }
 function inferCapabilityName(url, goal) {
@@ -266,6 +269,28 @@ const STORE_DISCOVER_JS = `
     return stores;
   }
 `;
+// ── 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(url, opts) {
     const waitSeconds = opts.waitSeconds ?? 3.0;
@@ -283,6 +308,31 @@ export async function exploreUrl(url, opts) {
                 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);
             // Step 4: Capture network traffic

package/dist/main.js

@@ -56,8 +56,8 @@ program.command('validate').description('Validate CLI definitions').argument('[t
     .action(async (target) => { const { validateClisWithTarget, renderValidationReport } = await import('./validate.js'); console.log(renderValidationReport(validateClisWithTarget([BUILTIN_CLIS, USER_CLIS], target))); });
 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) => 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) }))); });
 program.command('generate').description('One-shot: explore → synthesize → register').argument('<url>').option('--goal <text>').option('--site <name>')

package/dist/pipeline/steps/browser.js

@@ -27,14 +27,10 @@ export async function stepWait(page, params, data, args) {
         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));

package/dist/pipeline/steps/fetch.js

@@ -2,6 +2,20 @@
  * Pipeline step: fetch — HTTP API requests.
  */
 import { render } from '../template.js';
+/** Simple async concurrency limiter */
+async function mapConcurrent(items, limit, fn) {
+    const results = new Array(items.length);
+    let index = 0;
+    async function worker() {
+        while (index < items.length) {
+            const i = index++;
+            results[i] = await fn(items[i], i);
+        }
+    }
+    const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
 /** Single URL fetch helper */
 async function fetchSingle(page, url, method, queryParams, headers, args, data) {
     const renderedParams = {};
@@ -30,6 +44,42 @@ async function fetchSingle(page, url, method, queryParams, headers, args, data)
     }
   `);
 }
+/**
+ * Batch fetch: send all URLs into the browser as a single evaluate() call.
+ * This eliminates N-1 cross-process IPC round trips, performing all fetches
+ * inside the V8 engine and returning results as one JSON array.
+ */
+async function fetchBatchInBrowser(page, urls, method, headers, concurrency) {
+    const headersJs = JSON.stringify(headers);
+    const urlsJs = JSON.stringify(urls);
+    return page.evaluate(`
+    async () => {
+      const urls = ${urlsJs};
+      const method = "${method}";
+      const headers = ${headersJs};
+      const concurrency = ${concurrency};
+
+      const results = new Array(urls.length);
+      let idx = 0;
+
+      async function worker() {
+        while (idx < urls.length) {
+          const i = idx++;
+          try {
+            const resp = await fetch(urls[i], { method, headers, credentials: "include" });
+            results[i] = await resp.json();
+          } catch (e) {
+            results[i] = { error: e.message };
+          }
+        }
+      }
+
+      const workers = Array.from({ length: Math.min(concurrency, urls.length) }, () => worker());
+      await Promise.all(workers);
+      return results;
+    }
+  `);
+}
 export async function stepFetch(page, params, data, args) {
     const urlOrObj = typeof params === 'string' ? params : (params?.url ?? '');
     const method = params?.method ?? 'GET';
@@ -38,12 +88,31 @@ export async function stepFetch(page, params, data, args) {
     const urlTemplate = String(urlOrObj);
     // Per-item fetch when data is array and URL references item
     if (Array.isArray(data) && urlTemplate.includes('item')) {
-        const results = [];
-        for (let i = 0; i < data.length; i++) {
-            const itemUrl = String(render(urlTemplate, { args, data, item: data[i], index: i }));
-            results.push(await fetchSingle(page, itemUrl, method, queryParams, headers, args, data));
+        const concurrency = typeof params?.concurrency === 'number' ? params.concurrency : 5;
+        // Render all URLs upfront
+        const renderedHeaders = {};
+        for (const [k, v] of Object.entries(headers))
+            renderedHeaders[k] = String(render(v, { args, data }));
+        const renderedParams = {};
+        for (const [k, v] of Object.entries(queryParams))
+            renderedParams[k] = String(render(v, { args, data }));
+        const urls = data.map((item, index) => {
+            let url = String(render(urlTemplate, { args, data, item, index }));
+            if (Object.keys(renderedParams).length > 0) {
+                const qs = new URLSearchParams(renderedParams).toString();
+                url = `${url}${url.includes('?') ? '&' : '?'}${qs}`;
+            }
+            return url;
+        });
+        // BATCH IPC: if browser is available, batch all fetches into a single evaluate() call
+        if (page !== null) {
+            return fetchBatchInBrowser(page, urls, method.toUpperCase(), renderedHeaders, concurrency);
         }
-        return results;
+        // Non-browser: use concurrent pool (already optimized)
+        return mapConcurrent(data, concurrency, async (item, index) => {
+            const itemUrl = String(render(urlTemplate, { args, data, item, index }));
+            return fetchSingle(null, itemUrl, method, queryParams, headers, args, data);
+        });
     }
     const url = render(urlOrObj, { args, data });
     return fetchSingle(page, String(url), method, queryParams, headers, args, data);

package/dist/pipeline/steps/tap.js

@@ -36,6 +36,8 @@ export async function stepTap(page, params, data, args) {
     async () => {
       // ── 1. Setup capture proxy (fetch + XHR dual interception) ──
       let captured = null;
+      let captureResolve;
+      const capturePromise = new Promise(r => { captureResolve = r; });
       const capturePattern = ${JSON.stringify(capturePattern)};
 
       // Intercept fetch API
@@ -46,7 +48,7 @@ export async function stepTap(page, params, data, args) {
           const url = typeof fetchArgs[0] === 'string' ? fetchArgs[0]
             : fetchArgs[0] instanceof Request ? fetchArgs[0].url : String(fetchArgs[0]);
           if (capturePattern && url.includes(capturePattern) && !captured) {
-            try { captured = await resp.clone().json(); } catch {}
+            try { captured = await resp.clone().json(); captureResolve(); } catch {}
           }
         } catch {}
         return resp;
@@ -65,13 +67,13 @@ export async function stepTap(page, params, data, args) {
           const origHandler = xhr.onreadystatechange;
           xhr.onreadystatechange = function() {
             if (xhr.readyState === 4 && !captured) {
-              try { captured = JSON.parse(xhr.responseText); } catch {}
+              try { captured = JSON.parse(xhr.responseText); captureResolve(); } catch {}
             }
             if (origHandler) origHandler.apply(this, arguments);
           };
           const origOnload = xhr.onload;
           xhr.onload = function() {
-            if (!captured) { try { captured = JSON.parse(xhr.responseText); } catch {} }
+            if (!captured) { try { captured = JSON.parse(xhr.responseText); captureResolve(); } catch {} }
             if (origOnload) origOnload.apply(this, arguments);
           };
         }
@@ -111,9 +113,9 @@ export async function stepTap(page, params, data, args) {
         await ${actionCall};
 
         // ── 4. Wait for network response ──
-        const deadline = Date.now() + ${timeout} * 1000;
-        while (!captured && Date.now() < deadline) {
-          await new Promise(r => setTimeout(r, 200));
+        if (!captured) {
+          const timeoutPromise = new Promise(r => setTimeout(r, ${timeout} * 1000));
+          await Promise.race([capturePromise, timeoutPromise]);
         }
       } finally {
         // ── 5. Always restore originals ──

package/dist/registry.d.ts

@@ -30,6 +30,9 @@ export interface CliCommand {
     pipeline?: any[];
     timeoutSeconds?: number;
     source?: string;
+    /** Internal: lazy-loaded TS module support */
+    _lazy?: boolean;
+    _modulePath?: string;
 }
 export interface CliOptions {
     site: string;

package/dist/types.d.ts

@@ -16,7 +16,11 @@ export interface IPage {
     click(ref: string): Promise<void>;
     typeText(ref: string, text: string): Promise<void>;
     pressKey(key: string): Promise<void>;
-    wait(seconds: number): Promise<void>;
+    wait(options: number | {
+        text?: string;
+        time?: number;
+        timeout?: number;
+    }): Promise<void>;
     tabs(): Promise<any>;
     closeTab(index?: number): Promise<void>;
     newTab(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "publishConfig": {
     "access": "public"
   },
@@ -12,7 +12,8 @@
   },
   "scripts": {
     "dev": "tsx src/main.ts",
-    "build": "tsc && npm run clean-yaml && npm run copy-yaml",
+    "build": "tsc && npm run clean-yaml && npm run copy-yaml && npm run build-manifest",
+    "build-manifest": "node dist/build-manifest.js || true",
     "clean-yaml": "find dist/clis -name '*.yaml' -o -name '*.yml' 2>/dev/null | xargs rm -f",
     "copy-yaml": "find src/clis -name '*.yaml' -o -name '*.yml' | while read f; do d=\"dist/${f#src/}\"; mkdir -p \"$(dirname \"$d\")\"; cp \"$f\" \"$d\"; done",
     "start": "node dist/main.js",