@jackwener/opencli 0.1.1 → 0.2.0

package/src/bilibili.ts

@@ -2,6 +2,8 @@
  * Bilibili shared helpers: WBI signing, authenticated fetch, nav data, UID resolution.
  */
 
+import type { IPage } from './types.js';
+
 const MIXIN_KEY_ENC_TAB = [
   46,47,18,2,53,8,23,32,15,50,10,31,58,3,45,35,27,43,5,49,
   33,9,42,19,29,28,14,39,12,38,41,13,37,48,7,16,24,55,40,
@@ -17,7 +19,7 @@ export function payloadData(payload: any): any {
   return payload?.data ?? payload;
 }
 
-async function getNavData(page: any): Promise<any> {
+async function getNavData(page: IPage): Promise<any> {
   return page.evaluate(`
     async () => {
       const res = await fetch('https://api.bilibili.com/x/web-interface/nav', { credentials: 'include' });
@@ -26,7 +28,7 @@ async function getNavData(page: any): Promise<any> {
   `);
 }
 
-async function getWbiKeys(page: any): Promise<{ imgKey: string; subKey: string }> {
+async function getWbiKeys(page: IPage): Promise<{ imgKey: string; subKey: string }> {
   const nav = await getNavData(page);
   const wbiImg = nav?.data?.wbi_img ?? {};
   const imgUrl = wbiImg.img_url ?? '';
@@ -47,7 +49,7 @@ async function md5(text: string): Promise<string> {
 }
 
 export async function wbiSign(
-  page: any,
+  page: IPage,
   params: Record<string, any>,
 ): Promise<Record<string, string>> {
   const { imgKey, subKey } = await getWbiKeys(page);
@@ -65,7 +67,7 @@ export async function wbiSign(
 }
 
 export async function apiGet(
-  page: any,
+  page: IPage,
   path: string,
   opts: { params?: Record<string, any>; signed?: boolean } = {},
 ): Promise<any> {
@@ -81,7 +83,7 @@ export async function apiGet(
   return fetchJson(page, url);
 }
 
-export async function fetchJson(page: any, url: string): Promise<any> {
+export async function fetchJson(page: IPage, url: string): Promise<any> {
   const escapedUrl = url.replace(/"/g, '\\"');
   return page.evaluate(`
     async () => {
@@ -91,14 +93,14 @@ export async function fetchJson(page: any, url: string): Promise<any> {
   `);
 }
 
-export async function getSelfUid(page: any): Promise<string> {
+export async function getSelfUid(page: IPage): Promise<string> {
   const nav = await getNavData(page);
   const mid = nav?.data?.mid;
   if (!mid) throw new Error('Not logged in to Bilibili');
   return String(mid);
 }
 
-export async function resolveUid(page: any, input: string): Promise<string> {
+export async function resolveUid(page: IPage, input: string): Promise<string> {
   if (/^\d+$/.test(input)) return input;
   // Search for user by name
   const payload = await apiGet(page, '/x/web-interface/wbi/search/type', {

package/src/browser.ts

@@ -10,6 +10,10 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { formatSnapshot } from './snapshotFormatter.js';
 
+// Read version from package.json (single source of truth)
+const __browser_dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_VERSION = (() => { try { return JSON.parse(fs.readFileSync(path.resolve(__browser_dirname, '..', 'package.json'), 'utf-8')).version; } catch { return '0.0.0'; } })();
+
 const EXTENSION_LOCK_TIMEOUT = parseInt(process.env.OPENCLI_EXTENSION_LOCK_TIMEOUT ?? '120', 10);
 const EXTENSION_LOCK_POLL = parseInt(process.env.OPENCLI_EXTENSION_LOCK_POLL_INTERVAL ?? '1', 10);
 const CONNECT_TIMEOUT = parseInt(process.env.OPENCLI_BROWSER_CONNECT_TIMEOUT ?? '30', 10);
@@ -21,10 +25,12 @@ function jsonRpcRequest(method: string, params: Record<string, any> = {}): strin
   return JSON.stringify({ jsonrpc: '2.0', id: _nextId++, method, params }) + '\n';
 }
 
+import type { IPage } from './types.js';
+
 /**
  * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
  */
-export class Page {
+export class Page implements IPage {
   constructor(private _send: (msg: string) => void, private _recv: () => Promise<any>) {}
 
   async call(method: string, params: Record<string, any> = {}): Promise<any> {
@@ -61,7 +67,22 @@ export class Page {
   }
 
   async evaluate(js: string): Promise<any> {
-    return this.call('tools/call', { name: 'browser_evaluate', arguments: { function: js } });
+    // Normalize IIFE format to function format expected by MCP browser_evaluate
+    const normalized = this.normalizeEval(js);
+    return this.call('tools/call', { name: 'browser_evaluate', arguments: { function: normalized } });
+  }
+
+  private normalizeEval(source: string): string {
+    const s = source.trim();
+    if (!s) return '() => undefined';
+    // IIFE: (async () => {...})()  →  wrap as () => (...)
+    if (s.startsWith('(') && s.endsWith(')()')) return `() => (${s})`;
+    // Already a function/arrow
+    if (/^(async\s+)?\([^)]*\)\s*=>/.test(s)) return s;
+    if (/^(async\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=>/.test(s)) return s;
+    if (s.startsWith('function ') || s.startsWith('async function ')) return s;
+    // Raw expression → wrap
+    return `() => (${s})`;
   }
 
   async snapshot(opts: { interactive?: boolean; compact?: boolean; maxDepth?: number; raw?: boolean } = {}): Promise<any> {
@@ -173,7 +194,7 @@ export class PlaywrightMCP {
       const initMsg = jsonRpcRequest('initialize', {
         protocolVersion: '2024-11-05',
         capabilities: {},
-        clientInfo: { name: 'opencli', version: '0.1.0' },
+        clientInfo: { name: 'opencli', version: PKG_VERSION },
       });
       this._proc.stdin?.write(initMsg);
 

package/src/cascade.ts

@@ -11,6 +11,7 @@
  */
 
 import { Strategy } from './registry.js';
+import type { IPage } from './types.js';
 
 /** Strategy cascade order (simplest → most complex) */
 const CASCADE_ORDER: Strategy[] = [
@@ -41,7 +42,7 @@ interface CascadeResult {
  * Returns whether the probe succeeded and basic response info.
  */
 export async function probeEndpoint(
-  page: any,
+  page: IPage,
   url: string,
   strategy: Strategy,
   opts: { timeout?: number } = {},
@@ -168,7 +169,7 @@ export async function probeEndpoint(
  * Returns the simplest working strategy.
  */
 export async function cascadeProbe(
-  page: any,
+  page: IPage,
   url: string,
   opts: { maxStrategy?: Strategy; timeout?: number } = {},
 ): Promise<CascadeResult> {

package/src/clis/bbc/news.ts

@@ -0,0 +1,42 @@
+/**
+ * BBC News headlines — public RSS feed, no browser needed.
+ * Source: bb-sites/bbc/news.js
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'bbc',
+  name: 'news',
+  description: 'BBC News headlines (RSS)',
+  domain: 'www.bbc.com',
+  strategy: Strategy.PUBLIC,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of headlines (max 50)' },
+  ],
+  columns: ['rank', 'title', 'description', 'url'],
+  func: async (page, kwargs) => {
+    const count = Math.min(kwargs.limit || 20, 50);
+    const resp = await fetch('https://feeds.bbci.co.uk/news/rss.xml');
+    if (!resp.ok) return [];
+    const xml = await resp.text();
+    // Simple XML parsing without DOMParser (works in Node)
+    const items: any[] = [];
+    const itemRegex = /<item>([\s\S]*?)<\/item>/g;
+    let match;
+    while ((match = itemRegex.exec(xml)) && items.length < count) {
+      const block = match[1];
+      const title = block.match(/<title><!\[CDATA\[(.*?)\]\]>|<title>(.*?)<\/title>/)?.[1] || block.match(/<title>(.*?)<\/title>/)?.[1] || '';
+      const desc = block.match(/<description><!\[CDATA\[(.*?)\]\]>|<description>(.*?)<\/description>/)?.[1] || block.match(/<description>(.*?)<\/description>/)?.[1] || '';
+      const link = block.match(/<link>(.*?)<\/link>/)?.[1] || block.match(/<guid[^>]*>(.*?)<\/guid>/)?.[1] || '';
+      if (title) {
+        items.push({
+          rank: items.length + 1,
+          title: title.trim(),
+          description: desc.trim().substring(0, 200),
+          url: link.trim(),
+        });
+      }
+    }
+    return items;
+  },
+});

package/src/clis/boss/search.ts

@@ -0,0 +1,47 @@
+/**
+ * BOSS直聘 job search — browser cookie API.
+ * Source: bb-sites/boss/search.js
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'boss',
+  name: 'search',
+  description: 'BOSS直聘搜索职位',
+  domain: 'www.zhipin.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'query', required: true, help: 'Search keyword (e.g. AI agent, 前端)' },
+    { name: 'city', default: '101010100', help: 'City code (101010100=北京, 101020100=上海, 101210100=杭州, 101280100=广州)' },
+    { name: 'limit', type: 'int', default: 15, help: 'Number of results' },
+  ],
+  columns: ['name', 'salary', 'company', 'city', 'experience', 'degree', 'boss', 'url'],
+  func: async (page, kwargs) => {
+    await page.goto('https://www.zhipin.com');
+    await page.wait(2);
+    const data = await page.evaluate(`
+      (async () => {
+        const params = new URLSearchParams({
+          scene: '1', query: '${kwargs.query.replace(/'/g, "\\'")}',
+          city: '${kwargs.city || '101010100'}', page: '1', pageSize: '15',
+          experience: '', degree: '', payType: '', partTime: '',
+          industry: '', scale: '', stage: '', position: '',
+          jobType: '', salary: '', multiBusinessDistrict: '', multiSubway: ''
+        });
+        const resp = await fetch('/wapi/zpgeek/search/joblist.json?' + params.toString(), {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const d = await resp.json();
+        if (d.code !== 0) return {error: d.message || 'API error'};
+        const zpData = d.zpData || {};
+        return (zpData.jobList || []).map(j => ({
+          name: j.jobName, salary: j.salaryDesc, company: j.brandName,
+          city: j.cityName, experience: j.jobExperience, degree: j.jobDegree,
+          boss: j.bossName + ' · ' + j.bossTitle,
+          url: j.encryptJobId ? 'https://www.zhipin.com/job_detail/' + j.encryptJobId + '.html' : ''
+        }));
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, kwargs.limit || 15);
+  },
+});

package/src/clis/ctrip/search.ts

@@ -0,0 +1,62 @@
+/**
+ * 携程旅行搜索 — browser cookie, multi-strategy.
+ * Source: bb-sites/ctrip/search.js (simplified to suggestion API)
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'ctrip',
+  name: 'search',
+  description: '携程旅行搜索',
+  domain: 'www.ctrip.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'query', required: true, help: 'Search keyword (city or attraction)' },
+    { name: 'limit', type: 'int', default: 15, help: 'Number of results' },
+  ],
+  columns: ['rank', 'name', 'type', 'score', 'price', 'url'],
+  func: async (page, kwargs) => {
+    const limit = kwargs.limit || 15;
+    await page.goto('https://www.ctrip.com');
+    await page.wait(2);
+    const data = await page.evaluate(`
+      (async () => {
+        const query = '${kwargs.query.replace(/'/g, "\\'")}';
+        const limit = ${limit};
+
+        // Strategy 1: Suggestion API
+        try {
+          const suggestUrl = 'https://m.ctrip.com/restapi/h5api/searchapp/search?action=onekeyali&keyword=' + encodeURIComponent(query);
+          const resp = await fetch(suggestUrl, {credentials: 'include'});
+          if (resp.ok) {
+            const d = await resp.json();
+            const raw = d.data || d.result || d;
+            if (raw && typeof raw === 'object') {
+              // Flatten all result categories
+              const items = [];
+              for (const key of Object.keys(raw)) {
+                const list = Array.isArray(raw[key]) ? raw[key] : [];
+                for (const item of list) {
+                  if (items.length >= limit) break;
+                  items.push({
+                    rank: items.length + 1,
+                    name: item.word || item.name || item.title || '',
+                    type: item.type || item.tpName || key,
+                    score: item.score || '',
+                    price: item.price || item.minPrice || '',
+                    url: item.url || item.surl || '',
+                  });
+                }
+              }
+              if (items.length > 0) return items;
+            }
+          }
+        } catch(e) {}
+
+        return {error: 'No results for: ' + query};
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data;
+  },
+});

package/src/clis/index.ts

@@ -20,3 +20,27 @@ import './zhihu/question.js';
 
 // xiaohongshu
 import './xiaohongshu/search.js';
+
+// bbc
+import './bbc/news.js';
+
+// weibo
+import './weibo/hot.js';
+
+// boss
+import './boss/search.js';
+
+// yahoo-finance
+import './yahoo-finance/quote.js';
+
+// reuters
+import './reuters/search.js';
+
+// smzdm
+import './smzdm/search.js';
+
+// ctrip
+import './ctrip/search.js';
+
+// youtube
+import './youtube/search.js';

package/src/clis/reuters/search.ts

@@ -0,0 +1,52 @@
+/**
+ * Reuters news search — API with HTML fallback.
+ * Source: bb-sites/reuters/search.js
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'reuters',
+  name: 'search',
+  description: 'Reuters 路透社新闻搜索',
+  domain: 'www.reuters.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'query', required: true, help: 'Search query' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of results (max 40)' },
+  ],
+  columns: ['rank', 'title', 'date', 'section', 'url'],
+  func: async (page, kwargs) => {
+    const count = Math.min(kwargs.limit || 10, 40);
+    await page.goto('https://www.reuters.com');
+    await page.wait(2);
+    const data = await page.evaluate(`
+      (async () => {
+        const count = ${count};
+        const apiQuery = JSON.stringify({
+          keyword: '${kwargs.query.replace(/'/g, "\\'")}',
+          offset: 0, orderby: 'display_date:desc', size: count, website: 'reuters'
+        });
+        const apiUrl = 'https://www.reuters.com/pf/api/v3/content/fetch/articles-by-search-v2?query=' + encodeURIComponent(apiQuery);
+        try {
+          const resp = await fetch(apiUrl, {credentials: 'include'});
+          if (resp.ok) {
+            const data = await resp.json();
+            const articles = data.result?.articles || data.articles || [];
+            if (articles.length > 0) {
+              return articles.slice(0, count).map((a, i) => ({
+                rank: i + 1,
+                title: a.title || a.headlines?.basic || '',
+                date: (a.display_date || a.published_time || '').split('T')[0],
+                section: a.taxonomy?.section?.name || '',
+                url: a.canonical_url ? 'https://www.reuters.com' + a.canonical_url : '',
+              }));
+            }
+          }
+        } catch(e) {}
+        return {error: 'Reuters API unavailable'};
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data;
+  },
+});

package/src/clis/smzdm/search.ts

@@ -0,0 +1,66 @@
+/**
+ * 什么值得买搜索好价 — browser cookie, HTML parse.
+ * Source: bb-sites/smzdm/search.js
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'smzdm',
+  name: 'search',
+  description: '什么值得买搜索好价',
+  domain: 'www.smzdm.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'keyword', required: true, help: 'Search keyword' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+  ],
+  columns: ['rank', 'title', 'price', 'mall', 'comments', 'url'],
+  func: async (page, kwargs) => {
+    const q = encodeURIComponent(kwargs.keyword);
+    const limit = kwargs.limit || 20;
+    await page.goto('https://www.smzdm.com');
+    await page.wait(2);
+    const data = await page.evaluate(`
+      (async () => {
+        const q = '${q}';
+        const limit = ${limit};
+        // Try youhui channel first, then home
+        for (const channel of ['youhui', 'home']) {
+          try {
+            const resp = await fetch('https://search.smzdm.com/ajax/?c=' + channel + '&s=' + q + '&p=1&v=b', {
+              credentials: 'include',
+              headers: {'X-Requested-With': 'XMLHttpRequest'}
+            });
+            if (!resp.ok) continue;
+            const html = await resp.text();
+            if (html.indexOf('feed-row-wide') === -1) continue;
+            const parser = new DOMParser();
+            const doc = parser.parseFromString(html, 'text/html');
+            const items = doc.querySelectorAll('li.feed-row-wide');
+            const results = [];
+            items.forEach((li, i) => {
+              if (results.length >= limit) return;
+              const titleEl = li.querySelector('h5.feed-block-title > a')
+                           || li.querySelector('h5 > a');
+              if (!titleEl) return;
+              const title = (titleEl.getAttribute('title') || titleEl.textContent || '').trim();
+              const url = titleEl.getAttribute('href') || '';
+              const priceEl = li.querySelector('.z-highlight');
+              const price = priceEl ? priceEl.textContent.trim() : '';
+              let mall = '';
+              const extrasSpan = li.querySelector('.z-feed-foot-r .feed-block-extras span');
+              if (extrasSpan) mall = extrasSpan.textContent.trim();
+              const commentEl = li.querySelector('.feed-btn-comment');
+              const comments = commentEl ? parseInt(commentEl.textContent.trim()) || 0 : 0;
+              results.push({rank: results.length + 1, title, price, mall, comments, url});
+            });
+            if (results.length > 0) return results;
+          } catch(e) { continue; }
+        }
+        return {error: 'No results'};
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data;
+  },
+});

package/src/clis/weibo/hot.ts

@@ -0,0 +1,41 @@
+/**
+ * Weibo hot search — browser cookie API.
+ * Source: bb-sites/weibo/hot.js
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'weibo',
+  name: 'hot',
+  description: '微博热搜',
+  domain: 'weibo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 30, help: 'Number of items (max 50)' },
+  ],
+  columns: ['rank', 'word', 'hot_value', 'category', 'label', 'url'],
+  func: async (page, kwargs) => {
+    const count = Math.min(kwargs.limit || 30, 50);
+    await page.goto('https://weibo.com');
+    await page.wait(2);
+    const data = await page.evaluate(`
+      (async () => {
+        const resp = await fetch('/ajax/statuses/hot_band', {credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+        const data = await resp.json();
+        if (!data.ok) return {error: 'API error'};
+        const bandList = data.data?.band_list || [];
+        return bandList.map((item, i) => ({
+          rank: item.realpos || (i + 1),
+          word: item.word,
+          hot_value: item.num || 0,
+          category: item.category || '',
+          label: item.label_name || '',
+          url: 'https://s.weibo.com/weibo?q=' + encodeURIComponent('#' + item.word + '#')
+        }));
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, count);
+  },
+});

package/src/clis/yahoo-finance/quote.ts

@@ -0,0 +1,74 @@
+/**
+ * Yahoo Finance stock quote — multi-strategy API fallback.
+ * Source: bb-sites/yahoo-finance/quote.js
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'yahoo-finance',
+  name: 'quote',
+  description: 'Yahoo Finance 股票行情',
+  domain: 'finance.yahoo.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'symbol', required: true, help: 'Stock ticker (e.g. AAPL, MSFT, TSLA)' },
+  ],
+  columns: ['symbol', 'name', 'price', 'change', 'changePercent', 'open', 'high', 'low', 'volume', 'marketCap'],
+  func: async (page, kwargs) => {
+    const symbol = kwargs.symbol.toUpperCase().trim();
+    await page.goto(`https://finance.yahoo.com/quote/${encodeURIComponent(symbol)}/`);
+    await page.wait(3);
+    const data = await page.evaluate(`
+      (async () => {
+        const sym = '${symbol}';
+
+        // Strategy 1: v8 chart API
+        try {
+          const chartUrl = 'https://query1.finance.yahoo.com/v8/finance/chart/' + encodeURIComponent(sym) + '?interval=1d&range=1d';
+          const resp = await fetch(chartUrl);
+          if (resp.ok) {
+            const d = await resp.json();
+            const chart = d?.chart?.result?.[0];
+            if (chart) {
+              const meta = chart.meta || {};
+              const prevClose = meta.previousClose || meta.chartPreviousClose;
+              const price = meta.regularMarketPrice;
+              const change = price != null && prevClose != null ? (price - prevClose) : null;
+              const changePct = change != null && prevClose ? ((change / prevClose) * 100) : null;
+              return {
+                symbol: meta.symbol || sym, name: meta.shortName || meta.longName || sym,
+                price: price != null ? Number(price.toFixed(2)) : null,
+                change: change != null ? change.toFixed(2) : null,
+                changePercent: changePct != null ? changePct.toFixed(2) + '%' : null,
+                open: chart.indicators?.quote?.[0]?.open?.[0] || null,
+                high: meta.regularMarketDayHigh || null,
+                low: meta.regularMarketDayLow || null,
+                volume: meta.regularMarketVolume || null,
+                marketCap: null, currency: meta.currency, exchange: meta.exchangeName,
+              };
+            }
+          }
+        } catch(e) {}
+
+        // Strategy 2: Parse from page
+        const titleEl = document.querySelector('title');
+        const priceEl = document.querySelector('[data-testid="qsp-price"]');
+        const changeEl = document.querySelector('[data-testid="qsp-price-change"]');
+        const changePctEl = document.querySelector('[data-testid="qsp-price-change-percent"]');
+        if (priceEl) {
+          return {
+            symbol: sym,
+            name: titleEl ? titleEl.textContent.split('(')[0].trim() : sym,
+            price: priceEl.textContent.replace(/,/g, ''),
+            change: changeEl ? changeEl.textContent : null,
+            changePercent: changePctEl ? changePctEl.textContent : null,
+            open: null, high: null, low: null, volume: null, marketCap: null,
+          };
+        }
+        return {error: 'Could not fetch quote for ' + sym};
+      })()
+    `);
+    if (!data || data.error) return [];
+    return [data];
+  },
+});

package/src/clis/youtube/search.ts

@@ -0,0 +1,60 @@
+/**
+ * YouTube search — innertube API via browser session.
+ * Source: bb-sites/youtube/search.js
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'youtube',
+  name: 'search',
+  description: 'Search YouTube videos',
+  domain: 'www.youtube.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'query', required: true, help: 'Search query' },
+    { name: 'limit', type: 'int', default: 20, help: 'Max results (max 50)' },
+  ],
+  columns: ['rank', 'title', 'channel', 'views', 'duration', 'url'],
+  func: async (page, kwargs) => {
+    const limit = Math.min(kwargs.limit || 20, 50);
+    await page.goto('https://www.youtube.com');
+    await page.wait(2);
+    const data = await page.evaluate(`
+      (async () => {
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return {error: 'YouTube config not found'};
+
+        const resp = await fetch('/youtubei/v1/search?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST', credentials: 'include',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({context, query: '${kwargs.query.replace(/'/g, "\\'")}'})
+        });
+        if (!resp.ok) return {error: 'HTTP ' + resp.status};
+
+        const data = await resp.json();
+        const contents = data.contents?.twoColumnSearchResultsRenderer?.primaryContents?.sectionListRenderer?.contents || [];
+        const videos = [];
+        for (const section of contents) {
+          for (const item of (section.itemSectionRenderer?.contents || [])) {
+            if (item.videoRenderer && videos.length < ${limit}) {
+              const v = item.videoRenderer;
+              videos.push({
+                rank: videos.length + 1,
+                title: v.title?.runs?.[0]?.text || '',
+                channel: v.ownerText?.runs?.[0]?.text || '',
+                views: v.viewCountText?.simpleText || v.shortViewCountText?.simpleText || '',
+                duration: v.lengthText?.simpleText || 'LIVE',
+                url: 'https://www.youtube.com/watch?v=' + v.videoId
+              });
+            }
+          }
+        }
+        return videos;
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data;
+  },
+});

package/src/engine.ts

@@ -6,6 +6,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { type CliCommand, type Arg, Strategy, registerCommand } from './registry.js';
+import type { IPage } from './types.js';
 import { executePipeline } from './pipeline.js';
 
 export function discoverClis(...dirs: string[]): void {
@@ -72,7 +73,7 @@ function registerYamlCli(filePath: string, defaultSite: string): void {
 
 export async function executeCommand(
   cmd: CliCommand,
-  page: any,
+  page: IPage | null,
   kwargs: Record<string, any>,
   debug: boolean = false,
 ): Promise<any> {

package/src/explore.ts

@@ -477,7 +477,7 @@ export function renderExploreSummary(result: Record<string, any>): string {
   return lines.join('\n');
 }
 
-async function readPageMetadata(page: any): Promise<{ url: string; title: string }> {
+async function readPageMetadata(page: any /* IPage */): Promise<{ url: string; title: string }> {
   try {
     const result = await page.evaluate(`() => ({ url: window.location.href, title: document.title || '' })`);
     if (result && typeof result === 'object') return { url: String(result.url ?? ''), title: String(result.title ?? '') };

package/src/generate.ts

@@ -10,7 +10,9 @@
 
 import { exploreUrl } from './explore.js';
 import { synthesizeFromExplore } from './synthesize.js';
-import { registerCandidates } from './register.js';
+
+// TODO: implement real CLI registration (copy candidate YAML to user clis dir)
+function registerCandidates(_opts: any): any { return { ok: true, count: 0 }; }
 
 const CAPABILITY_ALIASES: Record<string, string[]> = {
   search:    ['search', '搜索', '查找', 'query', 'keyword'],