@jackwener/opencli 1.7.4 → 1.7.6

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/video.js

@@ -0,0 +1,61 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { apiGet, resolveBvid } from './utils.js';
+
+cli({
+  site: 'bilibili',
+  name: 'video',
+  description: 'Get Bilibili video metadata (title, author, duration, stats, etc.)',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'bvid', required: true, positional: true, help: 'BV ID, video URL, or b23.tv short link' },
+  ],
+  columns: ['field', 'value'],
+  func: async (page, kwargs) => {
+    if (!page) {
+      throw new CommandExecutionError('Browser session required for bilibili video');
+    }
+    const bvid = await resolveBvid(kwargs.bvid);
+
+    // Navigate to video page first so subsequent api call shares a primed session.
+    await page.goto(`https://www.bilibili.com/video/${bvid}/`);
+
+    const payload = await apiGet(page, '/x/web-interface/view', {
+      params: { bvid },
+    });
+    if (payload.code !== 0) {
+      throw new CommandExecutionError(`Bilibili view API failed: ${payload.message} (${payload.code})`);
+    }
+
+    const d = payload.data || {};
+    const stat = d.stat || {};
+    const owner = d.owner || {};
+
+    const pubDate = d.pubdate ? new Date(d.pubdate * 1000).toISOString().slice(0, 16).replace('T', ' ') : '';
+    const dur = d.duration || 0;
+    const mm = Math.floor(dur / 60);
+    const ss = dur % 60;
+    const desc = (d.desc || '').replace(/\s+/g, ' ').trim();
+    const descTrunc = desc.length > 200 ? desc.slice(0, 200) + '…' : desc;
+
+    return [
+      { field: 'bvid',         value: d.bvid ?? '' },
+      { field: 'aid',          value: String(d.aid ?? '') },
+      { field: 'title',        value: d.title ?? '' },
+      { field: 'author',       value: owner.name ? `${owner.name} (mid: ${owner.mid})` : '' },
+      { field: 'category',     value: d.tname_v2 || d.tname || '' },
+      { field: 'publish_time', value: pubDate },
+      { field: 'duration',     value: dur ? `${mm}m${ss}s (${dur}s)` : '' },
+      { field: 'view',         value: String(stat.view ?? '') },
+      { field: 'danmaku',      value: String(stat.danmaku ?? '') },
+      { field: 'reply',        value: String(stat.reply ?? '') },
+      { field: 'like',         value: String(stat.like ?? '') },
+      { field: 'coin',         value: String(stat.coin ?? '') },
+      { field: 'favorite',     value: String(stat.favorite ?? '') },
+      { field: 'share',        value: String(stat.share ?? '') },
+      { field: 'parts',        value: String(d.videos ?? 1) },
+      { field: 'thumbnail',    value: d.pic ?? '' },
+      { field: 'description',  value: descTrunc },
+    ];
+  },
+});

package/clis/bilibili/video.test.js

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+
+const { mockApiGet } = vi.hoisted(() => ({
+  mockApiGet: vi.fn(),
+}));
+
+vi.mock('./utils.js', async (importOriginal) => ({
+  ...(await importOriginal()),
+  apiGet: mockApiGet,
+}));
+
+import { getRegistry } from '@jackwener/opencli/registry';
+import './video.js';
+
+describe('bilibili video', () => {
+  const command = getRegistry().get('bilibili/video');
+  const page = {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(),
+  };
+
+  beforeEach(() => {
+    mockApiGet.mockReset();
+    page.goto.mockClear();
+    page.evaluate.mockReset();
+  });
+
+  it('returns a field/value table of video metadata on success', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        bvid: 'BV1xx411c7mD',
+        aid: 12345678,
+        title: '三层结构笔记法',
+        tname: '教程',
+        pubdate: 1775053078, // 2026-04-01 14:17:58 UTC
+        duration: 434,
+        videos: 1,
+        pic: 'https://i1.hdslb.com/some.jpg',
+        desc: 'Obsidian 教程',
+        owner: { mid: 507578555, name: 'IOI科技' },
+        stat: { view: 6128, danmaku: 0, reply: 21, like: 162, coin: 48, favorite: 564, share: 26 },
+      },
+    });
+
+    const rows = await command.func(page, { bvid: 'BV1xx411c7mD' });
+
+    // Every row has { field, value }
+    expect(Array.isArray(rows)).toBe(true);
+    for (const row of rows) {
+      expect(row).toHaveProperty('field');
+      expect(row).toHaveProperty('value');
+    }
+
+    const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
+    expect(byField.bvid).toBe('BV1xx411c7mD');
+    expect(byField.title).toBe('三层结构笔记法');
+    expect(byField.author).toBe('IOI科技 (mid: 507578555)');
+    expect(byField.duration).toBe('7m14s (434s)');
+    expect(byField.view).toBe('6128');
+    expect(byField.like).toBe('162');
+
+    // Navigation primes the session
+    expect(page.goto).toHaveBeenCalledWith('https://www.bilibili.com/video/BV1xx411c7mD/');
+    // API called without signing
+    expect(mockApiGet).toHaveBeenCalledWith(page, '/x/web-interface/view', { params: { bvid: 'BV1xx411c7mD' } });
+  });
+
+  it('throws CommandExecutionError when bilibili view API returns non-zero code', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: -404,
+      message: '啥都木有',
+      data: null,
+    });
+
+    await expect(command.func(page, { bvid: 'BV1xx411c7mD' })).rejects.toSatisfy(
+      (err) => err instanceof CommandExecutionError && /啥都木有|-404/.test(err.message),
+    );
+  });
+});

package/clis/deepseek/ask.js

@@ -0,0 +1,94 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    DEEPSEEK_DOMAIN, DEEPSEEK_URL, ensureOnDeepSeek, selectModel, setFeature,
+    sendMessage, sendWithFile, 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' },
+        { name: 'file', help: 'Attach a file (PDF, image, text) with the prompt' },
+    ],
+    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);
+
+        if (kwargs.file) {
+            const baseline = await withRetry(() => getBubbleCount(page));
+            try {
+                const fileResult = await sendWithFile(page, kwargs.file, prompt);
+                if (fileResult && !fileResult.ok) {
+                    throw new CommandExecutionError(fileResult.reason || 'Failed to attach file');
+                }
+            } catch (err) {
+                // SPA navigates after send; "Promise was collected" means send succeeded
+                if (!String(err?.message || err).includes('Promise was collected')) throw err;
+            }
+            await page.wait(3);
+            const response = await waitForResponse(page, baseline, prompt, timeoutMs);
+            if (!response) {
+                return [{ response: `[NO RESPONSE] No reply within ${kwargs.timeout}s.` }];
+            }
+            return [{ response }];
+        }
+
+        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/ask.test.js

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  mockEnsureOnDeepSeek,
+  mockSelectModel,
+  mockSetFeature,
+  mockSendMessage,
+  mockSendWithFile,
+  mockGetBubbleCount,
+  mockWaitForResponse,
+  mockParseBoolFlag,
+  mockWithRetry,
+} = vi.hoisted(() => ({
+  mockEnsureOnDeepSeek: vi.fn(),
+  mockSelectModel: vi.fn(),
+  mockSetFeature: vi.fn(),
+  mockSendMessage: vi.fn(),
+  mockSendWithFile: vi.fn(),
+  mockGetBubbleCount: vi.fn(),
+  mockWaitForResponse: vi.fn(),
+  mockParseBoolFlag: vi.fn((v) => v === true || v === 'true'),
+  mockWithRetry: vi.fn(async (fn) => fn()),
+}));
+
+vi.mock('./utils.js', () => ({
+  DEEPSEEK_DOMAIN: 'chat.deepseek.com',
+  DEEPSEEK_URL: 'https://chat.deepseek.com/',
+  ensureOnDeepSeek: mockEnsureOnDeepSeek,
+  selectModel: mockSelectModel,
+  setFeature: mockSetFeature,
+  sendMessage: mockSendMessage,
+  sendWithFile: mockSendWithFile,
+  getBubbleCount: mockGetBubbleCount,
+  waitForResponse: mockWaitForResponse,
+  parseBoolFlag: mockParseBoolFlag,
+  withRetry: mockWithRetry,
+}));
+
+import { askCommand } from './ask.js';
+
+describe('deepseek ask --file', () => {
+  const page = {
+    wait: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEnsureOnDeepSeek.mockResolvedValue(undefined);
+    mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
+    mockSetFeature.mockResolvedValue({ ok: true, toggled: false });
+    mockSendWithFile.mockResolvedValue({ ok: true });
+    mockGetBubbleCount.mockResolvedValue(7);
+    mockWaitForResponse.mockResolvedValue('new reply');
+  });
+
+  it('captures the existing baseline before sending a file prompt', async () => {
+    const rows = await askCommand.func(page, {
+      prompt: 'summarize this',
+      timeout: 120,
+      file: './report.pdf',
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'new reply' }]);
+    expect(mockGetBubbleCount).toHaveBeenCalledTimes(1);
+    expect(mockSendWithFile).toHaveBeenCalledWith(page, './report.pdf', 'summarize this');
+    expect(mockWaitForResponse).toHaveBeenCalledWith(page, 7, 'summarize this', 120000);
+  });
+});

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,
+        }];
+    },
+});