@jackwener/opencli 1.7.4 → 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/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,
+        }];
+    },
+});

package/clis/deepseek/utils.js

@@ -0,0 +1,208 @@
+export const DEEPSEEK_DOMAIN = 'chat.deepseek.com';
+export const DEEPSEEK_URL = 'https://chat.deepseek.com/';
+export const TEXTAREA_SELECTOR = 'textarea[placeholder*="DeepSeek"]';
+export const MESSAGE_SELECTOR = '.ds-message';
+
+export async function isOnDeepSeek(page) {
+    const url = await page.evaluate('window.location.href').catch(() => '');
+    if (typeof url !== 'string' || !url) return false;
+    try {
+        const h = new URL(url).hostname;
+        return h === 'deepseek.com' || h.endsWith('.deepseek.com');
+    } catch {
+        return false;
+    }
+}
+
+export async function ensureOnDeepSeek(page) {
+    if (!(await isOnDeepSeek(page))) {
+        await page.goto(DEEPSEEK_URL);
+        await page.wait(3);
+    }
+}
+
+export async function getPageState(page) {
+    return page.evaluate(`(() => {
+        const url = window.location.href;
+        const title = document.title;
+        const textarea = document.querySelector('${TEXTAREA_SELECTOR}');
+        const avatar = document.querySelector('img[src*="user-avatar"]');
+        return {
+            url,
+            title,
+            hasTextarea: !!textarea,
+            isLoggedIn: !!avatar,
+        };
+    })()`);
+}
+
+export async function selectModel(page, modelName) {
+    return page.evaluate(`(() => {
+        const radios = document.querySelectorAll('div[role="radio"]');
+        for (const radio of radios) {
+            const span = radio.querySelector('span');
+            if (span && span.textContent.trim().toLowerCase() === '${modelName}'.toLowerCase()) {
+                const alreadySelected = radio.getAttribute('aria-checked') === 'true';
+                if (!alreadySelected) radio.click();
+                return { ok: true, toggled: !alreadySelected };
+            }
+        }
+        return { ok: false };
+    })()`);
+}
+
+export async function setFeature(page, featureName, enabled) {
+    return page.evaluate(`(() => {
+        const btns = document.querySelectorAll('div[role="button"]');
+        for (const btn of btns) {
+            const span = btn.querySelector('span');
+            if (span && span.textContent.trim() === '${featureName}') {
+                const isActive = btn.classList.contains('ds-toggle-button--selected');
+                if (${enabled} !== isActive) btn.click();
+                return { ok: true, toggled: ${enabled} !== isActive };
+            }
+        }
+        return { ok: false };
+    })()`);
+}
+
+export async function sendMessage(page, prompt) {
+    const promptJson = JSON.stringify(prompt);
+    return page.evaluate(`(async () => {
+        const box = document.querySelector('${TEXTAREA_SELECTOR}');
+        if (!box) return { ok: false, reason: 'textarea not found' };
+
+        box.focus();
+        box.value = '';
+        document.execCommand('selectAll');
+        document.execCommand('insertText', false, ${promptJson});
+        await new Promise(r => setTimeout(r, 800));
+
+        const btns = document.querySelectorAll('div[role="button"]');
+        for (const btn of btns) {
+            if (btn.getAttribute('aria-disabled') === 'false') {
+                const svgs = btn.querySelectorAll('svg');
+                if (svgs.length > 0 && btn.closest('div')?.querySelector('textarea')) {
+                    btn.click();
+                    return { ok: true };
+                }
+            }
+        }
+
+        box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+        return { ok: true, method: 'enter' };
+    })()`);
+}
+
+export async function getBubbleCount(page) {
+    const count = await page.evaluate(`(() => {
+        return document.querySelectorAll('${MESSAGE_SELECTOR}').length;
+    })()`);
+    return count || 0;
+}
+
+export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
+    const startTime = Date.now();
+    let lastText = '';
+    let stableCount = 0;
+
+    while (Date.now() - startTime < timeoutMs) {
+        await page.wait(3);
+
+        let result;
+        try {
+            result = await page.evaluate(`(() => {
+                const bubbles = document.querySelectorAll('${MESSAGE_SELECTOR}');
+                const texts = Array.from(bubbles).map(b => (b.innerText || '').trim()).filter(Boolean);
+                return { count: texts.length, last: texts[texts.length - 1] || '' };
+            })()`);
+        } catch {
+            continue;
+        }
+
+        if (!result) continue;
+
+        const candidate = result.last;
+        if (candidate && result.count > baselineCount && candidate !== prompt.trim()) {
+            if (candidate === lastText) {
+                stableCount++;
+                if (stableCount >= 3) return candidate;
+            } else {
+                stableCount = 0;
+            }
+            lastText = candidate;
+        }
+    }
+
+    return lastText || null;
+}
+
+export async function getVisibleMessages(page) {
+    const result = await page.evaluate(`(() => {
+        const msgs = document.querySelectorAll('${MESSAGE_SELECTOR}');
+        return Array.from(msgs).map(m => {
+            // User messages carry an extra hash-class alongside ds-message
+            const isUser = m.className.split(/\\s+/).length > 2;
+            return {
+                Role: isUser ? 'user' : 'assistant',
+                Text: (m.innerText || '').trim(),
+            };
+        }).filter(m => m.Text);
+    })()`);
+    return Array.isArray(result) ? result : [];
+}
+
+export async function getConversationList(page) {
+    await ensureOnDeepSeek(page);
+    // Expand sidebar if collapsed
+    await page.evaluate(`(() => {
+        if (document.querySelectorAll('a[href*="/a/chat/s/"]').length === 0) {
+            const btn = document.querySelector('div[tabindex="0"][role="button"]');
+            if (btn) btn.click();
+        }
+    })()`);
+    // Poll for sidebar history links to render
+    for (let attempt = 0; attempt < 5; attempt++) {
+        await page.wait(2);
+        const items = await page.evaluate(`(() => {
+            const items = [];
+            const links = document.querySelectorAll('a[href*="/a/chat/s/"]');
+            links.forEach((link, i) => {
+                const titleEl = link.querySelector('div');
+                const title = titleEl ? titleEl.textContent.trim() : '';
+                const href = link.getAttribute('href') || '';
+                const idMatch = href.match(/\\/s\\/([a-f0-9-]+)/);
+                items.push({
+                    Index: i + 1,
+                    Id: idMatch ? idMatch[1] : href,
+                    Title: title || '(untitled)',
+                    Url: 'https://chat.deepseek.com' + href,
+                });
+            });
+            return items;
+        })()`);
+        if (Array.isArray(items) && items.length > 0) return items;
+    }
+    return [];
+}
+
+// Retries on CDP "Promise was collected" errors caused by DeepSeek's SPA router transitions.
+export async function withRetry(fn, retries = 2) {
+    for (let i = 0; i <= retries; i++) {
+        try {
+            return await fn();
+        } catch (err) {
+            const msg = String(err?.message || err);
+            if (i < retries && msg.includes('Promise was collected')) {
+                await new Promise(r => setTimeout(r, 2000));
+                continue;
+            }
+            throw err;
+        }
+    }
+}
+
+export function parseBoolFlag(value) {
+    if (typeof value === 'boolean') return value;
+    return String(value ?? '').trim().toLowerCase() === 'true';
+}