@jackwener/opencli 0.1.0

package/dist/browser.js

@@ -0,0 +1,261 @@
+/**
+ * Browser interaction via Playwright MCP Bridge extension.
+ * Connects to an existing Chrome browser through the extension's stdio JSON-RPC.
+ */
+import { spawn, execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { formatSnapshot } from './snapshotFormatter.js';
+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);
+const LOCK_DIR = path.join(os.tmpdir(), 'opencli-mcp-lock');
+// JSON-RPC helpers
+let _nextId = 1;
+function jsonRpcRequest(method, params = {}) {
+    return JSON.stringify({ jsonrpc: '2.0', id: _nextId++, method, params }) + '\n';
+}
+/**
+ * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
+ */
+export class Page {
+    _send;
+    _recv;
+    constructor(_send, _recv) {
+        this._send = _send;
+        this._recv = _recv;
+    }
+    async call(method, params = {}) {
+        this._send(jsonRpcRequest(method, params));
+        const resp = await this._recv();
+        if (resp.error)
+            throw new Error(`page.${method}: ${resp.error.message ?? JSON.stringify(resp.error)}`);
+        // Extract text content from MCP result
+        const result = resp.result;
+        if (result?.content) {
+            const textParts = result.content.filter((c) => c.type === 'text');
+            if (textParts.length === 1) {
+                const text = textParts[0].text;
+                try {
+                    return JSON.parse(text);
+                }
+                catch {
+                    return text;
+                }
+            }
+        }
+        return result;
+    }
+    // --- High-level methods ---
+    async goto(url) {
+        await this.call('tools/call', { name: 'browser_navigate', arguments: { url } });
+    }
+    async evaluate(js) {
+        return this.call('tools/call', { name: 'browser_evaluate', arguments: { function: js } });
+    }
+    async snapshot(opts = {}) {
+        const raw = await this.call('tools/call', { name: 'browser_snapshot', arguments: {} });
+        if (opts.raw)
+            return raw;
+        if (typeof raw === 'string')
+            return formatSnapshot(raw, opts);
+        return raw;
+    }
+    async click(ref) {
+        await this.call('tools/call', { name: 'browser_click', arguments: { element: 'click target', ref } });
+    }
+    async typeText(ref, text) {
+        await this.call('tools/call', { name: 'browser_type', arguments: { element: 'type target', ref, text } });
+    }
+    async pressKey(key) {
+        await this.call('tools/call', { name: 'browser_press_key', arguments: { key } });
+    }
+    async wait(seconds) {
+        await this.call('tools/call', { name: 'browser_wait_for', arguments: { time: seconds } });
+    }
+    async tabs() {
+        return this.call('tools/call', { name: 'browser_tabs', arguments: { action: 'list' } });
+    }
+    async closeTab(index) {
+        await this.call('tools/call', { name: 'browser_tabs', arguments: { action: 'close', ...(index !== undefined ? { index } : {}) } });
+    }
+    async newTab() {
+        await this.call('tools/call', { name: 'browser_tabs', arguments: { action: 'new' } });
+    }
+    async selectTab(index) {
+        await this.call('tools/call', { name: 'browser_tabs', arguments: { action: 'select', index } });
+    }
+    async networkRequests(includeStatic = false) {
+        return this.call('tools/call', { name: 'browser_network_requests', arguments: { includeStatic } });
+    }
+    async consoleMessages(level = 'info') {
+        return this.call('tools/call', { name: 'browser_console_messages', arguments: { level } });
+    }
+    async scroll(direction = 'down', amount = 500) {
+        await this.call('tools/call', { name: 'browser_press_key', arguments: { key: direction === 'down' ? 'PageDown' : 'PageUp' } });
+    }
+}
+/**
+ * Playwright MCP process manager.
+ */
+export class PlaywrightMCP {
+    _proc = null;
+    _buffer = '';
+    _waiters = [];
+    _lockAcquired = false;
+    _initialTabCount = 0;
+    async connect(opts = {}) {
+        await this._acquireLock();
+        const timeout = opts.timeout ?? CONNECT_TIMEOUT;
+        const mcpPath = findMcpServerPath();
+        if (!mcpPath)
+            throw new Error('Playwright MCP server not found. Install: npm install -D @playwright/mcp');
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`Timed out connecting to browser (${timeout}s)`)), timeout * 1000);
+            this._proc = spawn('node', [mcpPath, '--extension'], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env, ...(process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN ? { PLAYWRIGHT_MCP_EXTENSION_TOKEN: process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN } : {}) },
+            });
+            // Increase max listeners to avoid warnings
+            this._proc.setMaxListeners(20);
+            if (this._proc.stdout)
+                this._proc.stdout.setMaxListeners(20);
+            const page = new Page((msg) => { if (this._proc?.stdin?.writable)
+                this._proc.stdin.write(msg); }, () => new Promise((res) => { this._waiters.push(res); }));
+            this._proc.stdout?.on('data', (chunk) => {
+                this._buffer += chunk.toString();
+                const lines = this._buffer.split('\n');
+                this._buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const parsed = JSON.parse(line);
+                        const waiter = this._waiters.shift();
+                        if (waiter)
+                            waiter(parsed);
+                    }
+                    catch { }
+                }
+            });
+            this._proc.stderr?.on('data', () => { });
+            this._proc.on('error', (err) => { clearTimeout(timer); reject(err); });
+            // Initialize: send initialize request
+            const initMsg = jsonRpcRequest('initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'opencli', version: '0.1.0' },
+            });
+            this._proc.stdin?.write(initMsg);
+            // Wait for initialize response, then send initialized notification
+            const origRecv = () => new Promise((res) => { this._waiters.push(res); });
+            origRecv().then((resp) => {
+                if (resp.error) {
+                    clearTimeout(timer);
+                    reject(new Error(`MCP init failed: ${resp.error.message}`));
+                    return;
+                }
+                this._proc?.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+                // Get initial tab count for cleanup
+                page.tabs().then((tabs) => {
+                    if (typeof tabs === 'string') {
+                        this._initialTabCount = (tabs.match(/Tab \d+/g) || []).length;
+                    }
+                    else if (Array.isArray(tabs)) {
+                        this._initialTabCount = tabs.length;
+                    }
+                    clearTimeout(timer);
+                    resolve(page);
+                }).catch(() => { clearTimeout(timer); resolve(page); });
+            }).catch((err) => { clearTimeout(timer); reject(err); });
+        });
+    }
+    async close() {
+        try {
+            if (this._proc && !this._proc.killed) {
+                this._proc.kill('SIGTERM');
+                await new Promise((res) => { this._proc?.on('exit', () => res()); setTimeout(res, 3000); });
+            }
+        }
+        finally {
+            this._releaseLock();
+        }
+    }
+    async _acquireLock() {
+        const start = Date.now();
+        while (true) {
+            try {
+                fs.mkdirSync(LOCK_DIR, { recursive: false });
+                this._lockAcquired = true;
+                return;
+            }
+            catch (e) {
+                if (e.code !== 'EEXIST')
+                    throw e;
+                if ((Date.now() - start) / 1000 > EXTENSION_LOCK_TIMEOUT) {
+                    // Force remove stale lock
+                    try {
+                        fs.rmdirSync(LOCK_DIR);
+                    }
+                    catch { }
+                    continue;
+                }
+                await new Promise(r => setTimeout(r, EXTENSION_LOCK_POLL * 1000));
+            }
+        }
+    }
+    _releaseLock() {
+        if (this._lockAcquired) {
+            try {
+                fs.rmdirSync(LOCK_DIR);
+            }
+            catch { }
+            this._lockAcquired = false;
+        }
+    }
+}
+function findMcpServerPath() {
+    // Check local node_modules first (@playwright/mcp is the modern package)
+    const localMcp = path.resolve('node_modules', '@playwright', 'mcp', 'cli.js');
+    if (fs.existsSync(localMcp))
+        return localMcp;
+    // Check project-relative path
+    const __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+    const projectMcp = path.resolve(__dirname2, '..', 'node_modules', '@playwright', 'mcp', 'cli.js');
+    if (fs.existsSync(projectMcp))
+        return projectMcp;
+    // Check common locations
+    const candidates = [
+        path.join(os.homedir(), '.npm', '_npx'),
+        path.join(os.homedir(), 'node_modules', '.bin'),
+        '/usr/local/lib/node_modules',
+    ];
+    // Try npx resolution (legacy package name)
+    try {
+        const result = execSync('npx -y --package=@playwright/mcp which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 10000 }).trim();
+        if (result && fs.existsSync(result))
+            return result;
+    }
+    catch { }
+    // Try which
+    try {
+        const result = execSync('which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 5000 }).trim();
+        if (result && fs.existsSync(result))
+            return result;
+    }
+    catch { }
+    // Search in common npx cache
+    for (const base of candidates) {
+        if (!fs.existsSync(base))
+            continue;
+        try {
+            const found = execSync(`find "${base}" -name "cli.js" -path "*playwright*mcp*" 2>/dev/null | head -1`, { encoding: 'utf-8', timeout: 5000 }).trim();
+            if (found)
+                return found;
+        }
+        catch { }
+    }
+    return null;
+}

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

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

package/dist/clis/bilibili/favorite.js

@@ -0,0 +1,39 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet, payloadData } from '../../bilibili.js';
+cli({
+    site: 'bilibili',
+    name: 'favorite',
+    description: '我的默认收藏夹',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+        { name: 'page', type: 'int', default: 1, help: 'Page number' },
+    ],
+    columns: ['rank', 'title', 'author', 'plays', 'url'],
+    func: async (page, kwargs) => {
+        const { limit = 20, page: pageNum = 1 } = kwargs;
+        // Get default favorite folder ID
+        const foldersPayload = await apiGet(page, '/x/v3/fav/folder/created/list-all', {
+            params: { up_mid: 0 },
+            signed: true,
+        });
+        const folders = payloadData(foldersPayload)?.list ?? [];
+        if (!folders.length)
+            return [];
+        const fid = folders[0].id;
+        // Fetch favorite items
+        const payload = await apiGet(page, '/x/v3/fav/resource/list', {
+            params: { media_id: fid, pn: pageNum, ps: Math.min(Number(limit), 40) },
+            signed: true,
+        });
+        const medias = payloadData(payload)?.medias ?? [];
+        return medias.slice(0, Number(limit)).map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            author: item.upper?.name ?? '',
+            plays: item.cnt_info?.play ?? 0,
+            url: item.bvid ? `https://www.bilibili.com/video/${item.bvid}` : '',
+        }));
+    },
+});

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

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

package/dist/clis/bilibili/feed.js

@@ -0,0 +1,64 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet, payloadData, stripHtml } from '../../bilibili.js';
+cli({
+    site: 'bilibili',
+    name: 'feed',
+    description: '关注的人的动态时间线',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+        { name: 'type', default: 'all', help: 'Filter: all, video, article' },
+    ],
+    columns: ['rank', 'author', 'title', 'type', 'url'],
+    func: async (page, kwargs) => {
+        const { limit = 20, type = 'all' } = kwargs;
+        const typeMap = { all: 'all', video: 'video', article: 'article' };
+        const updateBaseline = '';
+        const payload = await apiGet(page, '/x/polymer/web-dynamic/v1/feed/all', {
+            params: {
+                timezone_offset: -480,
+                type: typeMap[type] ?? 'all',
+                page: 1,
+                ...(updateBaseline ? { update_baseline: updateBaseline } : {}),
+            },
+        });
+        const items = payloadData(payload)?.items ?? [];
+        const rows = [];
+        for (let i = 0; i < Math.min(items.length, Number(limit)); i++) {
+            const item = items[i];
+            const modules = item.modules ?? {};
+            const authorModule = modules.module_author ?? {};
+            const dynamicModule = modules.module_dynamic ?? {};
+            const major = dynamicModule.major ?? {};
+            let title = '';
+            let url = '';
+            let itemType = item.type ?? '';
+            if (major.archive) {
+                title = major.archive.title ?? '';
+                url = major.archive.jump_url ? `https:${major.archive.jump_url}` : '';
+                itemType = 'video';
+            }
+            else if (major.article) {
+                title = major.article.title ?? '';
+                url = major.article.jump_url ? `https:${major.article.jump_url}` : '';
+                itemType = 'article';
+            }
+            else if (dynamicModule.desc) {
+                title = stripHtml(dynamicModule.desc.text ?? '').slice(0, 60);
+                url = item.id_str ? `https://t.bilibili.com/${item.id_str}` : '';
+                itemType = 'dynamic';
+            }
+            if (!title)
+                continue;
+            rows.push({
+                rank: rows.length + 1,
+                author: authorModule.name ?? '',
+                title,
+                type: itemType,
+                url,
+            });
+        }
+        return rows;
+    },
+});

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

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

package/dist/clis/bilibili/history.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet, payloadData } from '../../bilibili.js';
+cli({
+    site: 'bilibili',
+    name: 'history',
+    description: '我的观看历史',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'author', 'progress', 'url'],
+    func: async (page, kwargs) => {
+        const { limit = 20 } = kwargs;
+        const payload = await apiGet(page, '/x/web-interface/history/cursor', {
+            params: { ps: Math.min(Number(limit), 30), type: 'archive' },
+        });
+        const list = payloadData(payload)?.list ?? [];
+        return list.slice(0, Number(limit)).map((item, i) => {
+            const progress = item.progress ?? 0;
+            const duration = item.duration ?? 0;
+            let progressStr;
+            if (progress < 0 || progress >= duration) {
+                progressStr = '已看完';
+            }
+            else {
+                const pct = duration > 0 ? Math.round(progress / duration * 100) : 0;
+                progressStr = `${formatDuration(progress)}/${formatDuration(duration)} (${pct}%)`;
+            }
+            return {
+                rank: i + 1,
+                title: item.title ?? '',
+                author: item.author_name ?? '',
+                progress: progressStr,
+                url: item.history?.bvid ? `https://www.bilibili.com/video/${item.history.bvid}` : '',
+            };
+        });
+    },
+});
+function formatDuration(seconds) {
+    const m = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return `${m}:${s.toString().padStart(2, '0')}`;
+}

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

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

package/dist/clis/bilibili/me.js

@@ -0,0 +1,13 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet, getSelfUid } from '../../bilibili.js';
+cli({
+    site: 'bilibili', name: 'me', description: 'My Bilibili profile info', domain: 'www.bilibili.com', strategy: Strategy.COOKIE,
+    args: [],
+    columns: ['name', 'uid', 'level', 'coins', 'followers', 'following'],
+    func: async (page) => {
+        const uid = await getSelfUid(page);
+        const payload = await apiGet(page, '/x/space/wbi/acc/info', { params: { mid: uid }, signed: true });
+        const data = payload?.data ?? {};
+        return { name: data.name ?? '', uid: data.mid ?? uid, level: data.level ?? 0, coins: data.coins ?? 0, followers: data.follower ?? 0, following: data.following ?? 0 };
+    },
+});

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

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

package/dist/clis/bilibili/search.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet, stripHtml } from '../../bilibili.js';
+cli({
+    site: 'bilibili', name: 'search', description: 'Search Bilibili videos or users', domain: 'www.bilibili.com', strategy: Strategy.COOKIE,
+    args: [
+        { name: 'keyword', required: true, help: 'Search keyword' },
+        { name: 'type', default: 'video', help: 'video or user' },
+        { name: 'page', type: 'int', default: 1, help: 'Result page' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'author', 'score', 'url'],
+    func: async (page, kwargs) => {
+        const { keyword, type = 'video', page: pageNum = 1, limit = 20 } = kwargs;
+        const searchType = type === 'user' ? 'bili_user' : 'video';
+        const payload = await apiGet(page, '/x/web-interface/wbi/search/type', { params: { search_type: searchType, keyword, page: pageNum }, signed: true });
+        const results = payload?.data?.result ?? [];
+        return results.slice(0, Number(limit)).map((item, i) => {
+            if (searchType === 'bili_user') {
+                return { rank: i + 1, title: stripHtml(item.uname ?? ''), author: (item.usign ?? '').trim(), score: item.fans ?? 0, url: item.mid ? `https://space.bilibili.com/${item.mid}` : '' };
+            }
+            return { rank: i + 1, title: stripHtml(item.title ?? ''), author: item.author ?? '', score: item.play ?? 0, url: item.bvid ? `https://www.bilibili.com/video/${item.bvid}` : '' };
+        });
+    },
+});

package/dist/clis/bilibili/user-videos.d.ts

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

package/dist/clis/bilibili/user-videos.js

@@ -0,0 +1,38 @@
+import { cli, Strategy } from '../../registry.js';
+import { apiGet, payloadData, resolveUid } from '../../bilibili.js';
+cli({
+    site: 'bilibili',
+    name: 'user-videos',
+    description: '查看指定用户的投稿视频',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'uid', required: true, help: 'User UID or username' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+        { name: 'order', default: 'pubdate', help: 'Sort: pubdate, click, stow' },
+        { name: 'page', type: 'int', default: 1, help: 'Page number' },
+    ],
+    columns: ['rank', 'title', 'plays', 'likes', 'date', 'url'],
+    func: async (page, kwargs) => {
+        const { uid: uidInput, limit = 20, order = 'pubdate', page: pageNum = 1 } = kwargs;
+        const uid = await resolveUid(page, String(uidInput));
+        const payload = await apiGet(page, '/x/space/wbi/arc/search', {
+            params: {
+                mid: uid,
+                pn: pageNum,
+                ps: Math.min(Number(limit), 50),
+                order,
+            },
+            signed: true,
+        });
+        const vlist = payloadData(payload)?.list?.vlist ?? [];
+        return vlist.slice(0, Number(limit)).map((item, i) => ({
+            rank: i + 1,
+            title: item.title ?? '',
+            plays: item.play ?? 0,
+            likes: item.like ?? 0,
+            date: item.created ? new Date(item.created * 1000).toISOString().slice(0, 10) : '',
+            url: item.bvid ? `https://www.bilibili.com/video/${item.bvid}` : '',
+        }));
+    },
+});

package/dist/clis/github/search.d.ts

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

package/dist/clis/github/search.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'github', name: 'search', description: 'Search GitHub repositories', domain: 'github.com', strategy: Strategy.PUBLIC, browser: false,
+    args: [
+        { name: 'keyword', required: true, help: 'Search keyword' },
+        { name: 'sort', default: 'stars', help: 'Sort by: stars, forks, updated' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'name', 'stars', 'language', 'description'],
+    func: async (_page, kwargs) => {
+        const { keyword, sort = 'stars', limit = 20 } = kwargs;
+        const resp = await fetch(`https://api.github.com/search/repositories?${new URLSearchParams({ q: keyword, sort, order: 'desc', per_page: String(Math.min(Number(limit), 100)) })}`, {
+            headers: { Accept: 'application/vnd.github.v3+json', 'User-Agent': 'opencli/0.1' },
+        });
+        const data = await resp.json();
+        return (data.items ?? []).slice(0, Number(limit)).map((item, i) => ({
+            rank: i + 1, name: item.full_name, stars: item.stargazers_count, language: item.language ?? '', description: (item.description ?? '').slice(0, 80),
+        }));
+    },
+});

package/dist/clis/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Import all TypeScript CLI adapters so they self-register.
+ *
+ * Each TS adapter calls cli() on import, which adds itself to the global registry.
+ */
+import './bilibili/search.js';
+import './bilibili/me.js';
+import './bilibili/favorite.js';
+import './bilibili/history.js';
+import './bilibili/feed.js';
+import './bilibili/user-videos.js';
+import './github/search.js';
+import './zhihu/search.js';

package/dist/clis/index.js

@@ -0,0 +1,16 @@
+/**
+ * Import all TypeScript CLI adapters so they self-register.
+ *
+ * Each TS adapter calls cli() on import, which adds itself to the global registry.
+ */
+// bilibili
+import './bilibili/search.js';
+import './bilibili/me.js';
+import './bilibili/favorite.js';
+import './bilibili/history.js';
+import './bilibili/feed.js';
+import './bilibili/user-videos.js';
+// github
+import './github/search.js';
+// zhihu
+import './zhihu/search.js';

package/dist/clis/zhihu/search.d.ts

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

package/dist/clis/zhihu/search.js

@@ -0,0 +1,58 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchJson } from '../../bilibili.js';
+cli({
+    site: 'zhihu',
+    name: 'search',
+    description: '搜索知乎问题和回答',
+    domain: 'www.zhihu.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'keyword', required: true, help: 'Search keyword' },
+        { name: 'type', default: 'general', help: 'general, article, video' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'author', 'type', 'url'],
+    func: async (page, kwargs) => {
+        const { keyword, type = 'general', limit = 20 } = kwargs;
+        // Navigate to zhihu to ensure cookie context
+        await page.goto('https://www.zhihu.com');
+        const qs = new URLSearchParams({ q: keyword, type, limit: String(limit) });
+        const payload = await fetchJson(page, `https://www.zhihu.com/api/v4/search_v3?${qs}`);
+        const data = payload?.data ?? [];
+        const rows = [];
+        for (let i = 0; i < Math.min(data.length, Number(limit)); i++) {
+            const item = data[i];
+            const obj = item.object ?? item;
+            const itemType = item.type ?? obj.type ?? 'unknown';
+            let title = '';
+            let author = '';
+            let url = '';
+            if (itemType === 'search_result') {
+                const highlight = obj.highlight ?? {};
+                title = (highlight.title ?? obj.title ?? '').replace(/<[^>]+>/g, '');
+                author = obj.author?.name ?? '';
+                url = obj.url ?? '';
+            }
+            else if (obj.question) {
+                title = (obj.question.title ?? obj.title ?? '').replace(/<[^>]+>/g, '');
+                author = obj.author?.name ?? '';
+                url = obj.question.url ? `https://www.zhihu.com/question/${obj.question.id}` : '';
+            }
+            else {
+                title = (obj.title ?? obj.name ?? '').replace(/<[^>]+>/g, '');
+                author = obj.author?.name ?? '';
+                url = obj.url ?? '';
+            }
+            if (!title)
+                continue;
+            rows.push({
+                rank: rows.length + 1,
+                title: title.slice(0, 60),
+                author,
+                type: itemType.replace('search_result', 'result'),
+                url,
+            });
+        }
+        return rows;
+    },
+});

package/dist/engine.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ */
+import { type CliCommand } from './registry.js';
+export declare function discoverClis(...dirs: string[]): void;
+export declare function executeCommand(cmd: CliCommand, page: any, kwargs: Record<string, any>, debug?: boolean): Promise<any>;