@jackwener/opencli 1.7.3 → 1.7.5

package/clis/antigravity/serve.js

@@ -54,6 +54,20 @@ function jsonResponse(res, status, data) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+function parseTimeoutValue(val, label, fallback) {
+    if (val === undefined) {
+        return fallback;
+    }
+    const parsed = typeof val === 'number' ? val : parseInt(String(val), 10);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        console.error(`[serve] Invalid ${label}="${val}", using default ${fallback}s`);
+        return fallback;
+    }
+    return parsed;
+}
+function parseEnvTimeout(envVar, fallback) {
+    return parseTimeoutValue(process.env[envVar], envVar, fallback);
+}
 // ─── DOM helpers ─────────────────────────────────────────────────────
 /**
  * Click the 'New Conversation' button to reset context.
@@ -267,41 +281,65 @@ async function waitForReply(page, beforeText, opts = {}) {
     let lastText = beforeText;
     let stableCount = 0;
     const stableThreshold = 4; // 4 * 500ms = 2s of stability fallback
+    let reconnectCount = 0;
     while (Date.now() < deadline) {
-        const generating = await isGenerating(page);
-        const currentText = await getConversationText(page);
-        const textChanged = currentText !== beforeText && currentText.length > 0;
-        if (generating) {
-            hasStartedGenerating = true;
-            stableCount = 0; // Reset stability while generating
-        }
-        else {
-            if (hasStartedGenerating) {
-                // It actively generated and now it stopped -> DONE
-                // Provide a small buffer to let React render the final message fully
-                await sleep(500);
-                return;
+        try {
+            const generating = await isGenerating(page);
+            const currentText = await getConversationText(page);
+            const textChanged = currentText !== beforeText && currentText.length > 0;
+            if (generating) {
+                hasStartedGenerating = true;
+                stableCount = 0; // Reset stability while generating
             }
-            // Fallback: If it never showed "Generating/Cancel", but text changed and is stable
-            if (textChanged) {
-                if (currentText === lastText) {
-                    stableCount++;
-                    if (stableCount >= stableThreshold) {
-                        return; // Text has been stable for 2 seconds -> DONE
+            else {
+                if (hasStartedGenerating) {
+                    // It actively generated and now it stopped -> DONE
+                    // Provide a small buffer to let React render the final message fully
+                    await sleep(500);
+                    return page;
+                }
+                // Fallback: If it never showed "Generating/Cancel", but text changed and is stable
+                if (textChanged) {
+                    if (currentText === lastText) {
+                        stableCount++;
+                        if (stableCount >= stableThreshold) {
+                            return page; // Text has been stable for 2 seconds -> DONE
+                        }
+                    }
+                    else {
+                        stableCount = 0;
+                        lastText = currentText;
                     }
                 }
-                else {
+            }
+        }
+        catch (err) {
+            const msg = err.message || String(err);
+            const isSessionLoss = /closed|lost|not open|websocket/i.test(msg);
+            if (opts.reconnect && isSessionLoss && reconnectCount < 2) {
+                reconnectCount++;
+                console.error(`[serve] CDP session loss detected (${msg}), attempting to reconnect (${reconnectCount}/2)...`);
+                try {
+                    page = await opts.reconnect();
+                    // Reset stability tracking after reconnect
                     stableCount = 0;
-                    lastText = currentText;
+                    lastText = beforeText;
+                    continue;
+                }
+                catch (reconnectErr) {
+                    console.error(`[serve] Reconnection failed: ${reconnectErr.message}`);
+                    throw err; // Throw original error if reconnection itself fails
                 }
             }
+            throw err;
         }
         await sleep(pollInterval);
     }
-    throw new Error('Timeout waiting for Antigravity reply');
+    throw new Error(`Timeout waiting for Antigravity reply after ${timeout / 1000}s`);
 }
 // ─── Request Handlers ────────────────────────────────────────────────
-async function handleMessages(body, page, bridge) {
+async function handleMessages(body, page, opts = {}) {
+    const { bridge, timeout, reconnect } = opts;
     // Extract the last user message
     const userMessages = body.messages.filter(m => m.role === 'user');
     if (userMessages.length === 0) {
@@ -328,7 +366,7 @@ async function handleMessages(body, page, bridge) {
     await sendMessage(page, userText, bridge);
     // Poll for reply (change detection)
     console.error('[serve] Waiting for reply...');
-    await waitForReply(page, beforeText);
+    page = await waitForReply(page, beforeText, { timeout, reconnect });
     // Extract the actual reply text precisely from the DOM
     const replyText = await getLastAssistantReply(page, userText);
     console.error(`[serve] Got reply: "${replyText.slice(0, 80)}${replyText.length > 80 ? '...' : ''}"`);
@@ -349,6 +387,10 @@ async function handleMessages(body, page, bridge) {
 // ─── Server ──────────────────────────────────────────────────────────
 export async function startServe(opts = {}) {
     const port = opts.port ?? 8082;
+    const envTimeoutSeconds = parseEnvTimeout('OPENCLI_ANTIGRAVITY_TIMEOUT', 120);
+    const effectiveTimeoutSeconds = parseTimeoutValue(opts.timeout, '--timeout', envTimeoutSeconds);
+    const effectiveTimeout = effectiveTimeoutSeconds * 1000;
+    console.error(`[serve] Starting Antigravity API proxy on port ${port} (timeout: ${effectiveTimeout / 1000}s)`);
     // Lazy CDP connection — connect when first request comes in
     let cdp = null;
     let page = null;
@@ -462,7 +504,11 @@ export async function startServe(opts = {}) {
                     }
                     // Lazy connect on first request
                     const activePage = await ensureConnected();
-                    const response = await handleMessages(body, activePage, cdp ?? undefined);
+                    const response = await handleMessages(body, activePage, {
+                        bridge: cdp,
+                        timeout: effectiveTimeout,
+                        reconnect: ensureConnected,
+                    });
                     jsonResponse(res, 200, response);
                 }
                 finally {

package/clis/baidu-scholar/search.js

@@ -0,0 +1,87 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { clampInt, requireNonEmptyQuery } from '../_shared/common.js';
+
+cli({
+    site: 'baidu-scholar',
+    name: 'search',
+    description: '百度学术搜索',
+    domain: 'xueshu.baidu.com',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'query', positional: true, required: true, help: '搜索关键词' },
+        { name: 'limit', type: 'int', default: 10, help: '返回结果数量 (max 20)' },
+    ],
+    columns: ['rank', 'title', 'authors', 'journal', 'year', 'cited', 'url'],
+    navigateBefore: false,
+    func: async (page, kwargs) => {
+        const limit = clampInt(kwargs.limit, 10, 1, 20);
+        const query = requireNonEmptyQuery(kwargs.query);
+        await page.goto(`https://xueshu.baidu.com/s?wd=${encodeURIComponent(query)}&pn=0&tn=SE_baiduxueshu_c1gjeupa`);
+        await page.wait(5);
+        const data = await page.evaluate(`
+      (async () => {
+        const normalize = v => (v || '').replace(/\\s+/g, ' ').trim();
+        for (let i = 0; i < 20; i++) {
+          if (document.querySelectorAll('.result').length > 0) break;
+          await new Promise(r => setTimeout(r, 500));
+        }
+        const results = [];
+        for (const el of document.querySelectorAll('.result')) {
+          const titleEl = el.querySelector('h3 a, .paper-title a, .t a');
+          const title = normalize(titleEl?.textContent);
+          if (!title) continue;
+
+          let url = titleEl?.getAttribute('href') || '';
+          if (url && !url.startsWith('http')) url = 'https://xueshu.baidu.com' + url;
+
+          const infoEl = el.querySelector('.paper-info');
+          const infoText = normalize(infoEl?.textContent);
+          const spans = infoEl ? Array.from(infoEl.querySelectorAll('span')) : [];
+
+          let journal = '';
+          let year = '';
+          let cited = '0';
+          const authorParts = [];
+
+          for (const span of spans) {
+            const text = normalize(span.textContent);
+            if (!text || text === '，' || text === ',') continue;
+            if (text.startsWith('《') || text.startsWith('〈')) {
+              journal = text.replace(/[《》〈〉]/g, '');
+              continue;
+            }
+            if (/^被引量[：:]/.test(text)) {
+              cited = text.match(/(\\d+)/)?.[1] || '0';
+              continue;
+            }
+            if (/^-\\s*(\\d{4})/.test(text) || /^\\d{4}年?$/.test(text)) {
+              year = text.match(/(\\d{4})/)?.[1] || '';
+              continue;
+            }
+            if (!journal && !/^被引/.test(text) && !text.startsWith('-')) {
+              authorParts.push(text);
+            }
+          }
+
+          if (!year) year = infoText.match(/(19|20)\\d{2}/)?.[0] || '';
+          if (!cited || cited === '0') cited = infoText.match(/被引量[：:]\\s*(\\d+)/)?.[1] || '0';
+
+          results.push({
+            rank: results.length + 1,
+            title,
+            authors: authorParts.join(', ').slice(0, 80),
+            journal,
+            year,
+            cited,
+            url,
+          });
+
+          if (results.length >= ${limit}) break;
+        }
+        return results;
+      })()
+    `);
+        return Array.isArray(data) ? data : [];
+    },
+});

package/clis/baidu-scholar/search.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+
+describe('baidu-scholar search command', () => {
+    const command = getRegistry().get('baidu-scholar/search');
+
+    it('registers as a public browser command', () => {
+        expect(command).toBeDefined();
+        expect(command.site).toBe('baidu-scholar');
+        expect(command.strategy).toBe('public');
+        expect(command.browser).toBe(true);
+    });
+
+    it('rejects empty queries before browser navigation', async () => {
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, { query: '   ' })).rejects.toMatchObject({
+            name: 'ArgumentError',
+            code: 'ARGUMENT',
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});

package/clis/bilibili/favorite.js

@@ -3,27 +3,32 @@ import { apiGet, payloadData, getSelfUid } from './utils.js';
 cli({
     site: 'bilibili',
     name: 'favorite',
-    description: '我的默认收藏夹',
+    description: '我的收藏夹',
     domain: 'www.bilibili.com',
     strategy: Strategy.COOKIE,
     args: [
+        { name: 'fid', type: 'int', required: false, help: 'Favorite folder ID (defaults to first folder)' },
         { 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 current user's UID
-        const uid = await getSelfUid(page);
-        // Get default favorite folder ID
-        const foldersPayload = await apiGet(page, '/x/v3/fav/folder/created/list-all', {
-            params: { up_mid: uid },
-            signed: true,
-        });
-        const folders = payloadData(foldersPayload)?.list ?? [];
-        if (!folders.length)
-            return [];
-        const fid = folders[0].id;
+        const { fid: favoriteId, limit = 20, page: pageNum = 1 } = kwargs;
+        let fid;
+        if (favoriteId) {
+            fid = Number(favoriteId);
+        } else {
+            // Fall back to the default (first) favorite folder
+            const uid = await getSelfUid(page);
+            const foldersPayload = await apiGet(page, '/x/v3/fav/folder/created/list-all', {
+                params: { up_mid: uid },
+                signed: true,
+            });
+            const folders = payloadData(foldersPayload)?.list ?? [];
+            if (!folders.length)
+                return [];
+            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) },

package/clis/binance/depth.js

@@ -3,7 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
   site: 'binance',
   name: 'depth',
-  description: 'Order book bid prices for a trading pair',
+  description: 'Order book bid and ask prices for a trading pair',
   domain: 'data-api.binance.vision',
   strategy: Strategy.PUBLIC,
   browser: false,
@@ -11,11 +11,10 @@ cli({
     { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
     { name: 'limit', type: 'int', default: 10, help: 'Number of price levels (5, 10, 20, 50, 100)' },
   ],
-  columns: ['rank', 'bid_price', 'bid_qty'],
+  columns: ['rank', 'bid_price', 'bid_qty', 'ask_price', 'ask_qty'],
   pipeline: [
     { fetch: { url: 'https://data-api.binance.vision/api/v3/depth?symbol=${{ args.symbol }}&limit=${{ args.limit }}' } },
-    { select: 'bids' },
-    { map: { rank: '${{ index + 1 }}', bid_price: '${{ item.0 }}', bid_qty: '${{ item.1 }}' } },
+    { map: { select: 'bids', rank: '${{ index + 1 }}', bid_price: '${{ item[0] }}', bid_qty: '${{ item[1] }}', ask_price: '${{ root.asks[index]?.[0] ?? "" }}', ask_qty: '${{ root.asks[index]?.[1] ?? "" }}' } },
     { limit: '${{ args.limit }}' },
   ],
 });

package/clis/boss/utils.js

@@ -214,11 +214,10 @@ export async function typeAndSendMessage(page, text) {
     return true;
 }
 /**
- * Verbose log helper — prints when OPENCLI_VERBOSE is set, with DEBUG=opencli
- * kept as a compatibility fallback.
+ * Verbose log helper — prints when OPENCLI_VERBOSE is set.
  */
 export function verbose(msg) {
-    if (process.env.OPENCLI_VERBOSE || process.env.DEBUG?.includes('opencli')) {
+    if (process.env.OPENCLI_VERBOSE) {
         console.error(`[opencli:boss] ${msg}`);
     }
 }

package/clis/chatgpt-app/ax.js

@@ -121,11 +121,14 @@ let args = CommandLine.arguments
 let target = args.count > 1 ? args[1] : ""
 let needsLegacy = args.count > 2 && args[2] == "legacy"
 
-// Step 1: Click the "Options" button to open the popover
-guard let optionsBtn = findByDesc(win, "Options") else {
+// Step 1: Click the "Options" button to open the popover (support both English and Chinese UI)
+var optionsBtn: AXUIElement? = nil
+if let btn = findByDesc(win, "Options") { optionsBtn = btn }
+else if let btn = findByDesc(win, "选项") { optionsBtn = btn }
+guard let options = optionsBtn else {
     fputs("Could not find Options button\\n", stderr); exit(1)
 }
-press(optionsBtn)
+press(options)
 Thread.sleep(forTimeInterval: 0.8)
 
 // Step 2: Find the popover that appeared, search ONLY within it

package/clis/deepseek/ask.js

@@ -0,0 +1,74 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    DEEPSEEK_DOMAIN, DEEPSEEK_URL, ensureOnDeepSeek, selectModel, setFeature,
+    sendMessage, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
+} from './utils.js';
+
+export const askCommand = cli({
+    site: 'deepseek',
+    name: 'ask',
+    description: 'Send a prompt to DeepSeek and get the response',
+    domain: DEEPSEEK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    timeoutSeconds: 180,
+    args: [
+        { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
+        { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for response' },
+        { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending' },
+        { name: 'model', default: 'instant', choices: ['instant', 'expert'], help: 'Model to use: instant or expert' },
+        { name: 'think', type: 'boolean', default: false, help: 'Enable DeepThink mode' },
+        { name: 'search', type: 'boolean', default: false, help: 'Enable web search' },
+    ],
+    columns: ['response'],
+
+    func: async (page, kwargs) => {
+        const prompt = kwargs.prompt;
+        const timeoutMs = (kwargs.timeout || 120) * 1000;
+        const wantThink = parseBoolFlag(kwargs.think);
+        const wantSearch = parseBoolFlag(kwargs.search);
+
+        if (parseBoolFlag(kwargs.new)) {
+            await page.goto(DEEPSEEK_URL);
+            await page.wait(3);
+        } else {
+            await ensureOnDeepSeek(page);
+        }
+
+        await page.wait(2);
+
+        const wantModel = kwargs.model || 'instant';
+        const modelResult = await withRetry(() => selectModel(page, wantModel));
+        if (!modelResult?.ok) {
+            throw new CommandExecutionError(`Could not switch to ${wantModel} model`);
+        }
+        if (modelResult.toggled) await page.wait(0.5);
+
+        const thinkResult = await withRetry(() => setFeature(page, 'DeepThink', wantThink));
+        if (!thinkResult?.ok) {
+            throw new CommandExecutionError('Could not toggle DeepThink');
+        }
+
+        const searchResult = await withRetry(() => setFeature(page, 'Search', wantSearch));
+        if (!searchResult?.ok) {
+            throw new CommandExecutionError('Could not toggle Search');
+        }
+
+        if (thinkResult.toggled || searchResult.toggled) await page.wait(0.5);
+
+        const baseline = await withRetry(() => getBubbleCount(page));
+        const sendResult = await withRetry(() => sendMessage(page, prompt));
+        if (!sendResult?.ok) {
+            throw new CommandExecutionError(sendResult?.reason || 'Failed to send message');
+        }
+
+        const response = await waitForResponse(page, baseline, prompt, timeoutMs);
+        if (!response) {
+            return [{ response: `[NO RESPONSE] No reply within ${kwargs.timeout}s.` }];
+        }
+
+        return [{ response }];
+    },
+});

package/clis/deepseek/history.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { DEEPSEEK_DOMAIN, getConversationList } from './utils.js';
+
+export const historyCommand = cli({
+    site: 'deepseek',
+    name: 'history',
+    description: 'List conversation history from DeepSeek sidebar',
+    domain: DEEPSEEK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Max conversations to show' },
+    ],
+    columns: ['Index', 'Title', 'Url'],
+
+    func: async (page, kwargs) => {
+        const limit = Math.max(1, kwargs.limit || 20);
+        const conversations = await getConversationList(page);
+        if (conversations.length === 0) {
+            return [{ Index: 0, Title: 'No conversation history found.', Url: '' }];
+        }
+        return conversations.slice(0, limit);
+    },
+});

package/clis/deepseek/new.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { DEEPSEEK_DOMAIN, DEEPSEEK_URL } from './utils.js';
+
+export const newCommand = cli({
+    site: 'deepseek',
+    name: 'new',
+    description: 'Start a new conversation in DeepSeek',
+    domain: DEEPSEEK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['Status'],
+
+    func: async (page) => {
+        await page.goto(DEEPSEEK_URL);
+        await page.wait(2);
+        return [{ Status: 'New chat started' }];
+    },
+});

package/clis/deepseek/read.js

@@ -0,0 +1,22 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { DEEPSEEK_DOMAIN, ensureOnDeepSeek, getVisibleMessages } from './utils.js';
+
+export const readCommand = cli({
+    site: 'deepseek',
+    name: 'read',
+    description: 'Read the current DeepSeek conversation',
+    domain: DEEPSEEK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['Role', 'Text'],
+
+    func: async (page) => {
+        await ensureOnDeepSeek(page);
+        await page.wait(5);
+        const messages = await getVisibleMessages(page);
+        if (messages.length > 0) return messages;
+        return [{ Role: 'system', Text: 'No visible messages found.' }];
+    },
+});

package/clis/deepseek/status.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { DEEPSEEK_DOMAIN, ensureOnDeepSeek, getPageState } from './utils.js';
+
+export const statusCommand = cli({
+    site: 'deepseek',
+    name: 'status',
+    description: 'Check DeepSeek page availability and login state',
+    domain: DEEPSEEK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['Status', 'Login', 'Url'],
+
+    func: async (page) => {
+        await ensureOnDeepSeek(page);
+        const state = await getPageState(page);
+        return [{
+            Status: state.hasTextarea ? 'Connected' : 'Page not ready',
+            Login: state.isLoggedIn ? 'Yes' : 'No',
+            Url: state.url,
+        }];
+    },
+});