@jackwener/opencli 1.7.5 → 1.7.7

package/clis/bilibili/video.js

@@ -0,0 +1,68 @@
+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');
+    }
+
+    // Resolve BV ID from three advertised input forms:
+    //   1. Bare "BV..." id
+    //   2. Full bilibili.com/video/<BV>... URL (with or without query string / www / m.)
+    //   3. b23.tv short link (delegated to resolveBvid)
+    // resolveBvid() alone handles (1) and (3) but not (2), so we pre-extract
+    // from bilibili URLs before falling through.
+    const input = String(kwargs.bvid ?? '').trim();
+    const bilibiliUrlMatch = input.match(/bilibili\.com\/(?:video|bangumi\/play)\/(BV[A-Za-z0-9]+)/i);
+    const bvid = bilibiliUrlMatch ? bilibiliUrlMatch[1] : await resolveBvid(input);
+
+    // 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;
+
+    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: d.desc ?? '' },
+    ];
+  },
+});

package/clis/bilibili/video.test.js

@@ -0,0 +1,132 @@
+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),
+    );
+  });
+
+  it('extracts BV ID from full bilibili.com URL input', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: { bvid: 'BV1xx411c7mD', stat: {}, owner: {}, desc: '' },
+    });
+
+    await command.func(page, { bvid: 'https://www.bilibili.com/video/BV1xx411c7mD/' });
+
+    expect(page.goto).toHaveBeenCalledWith('https://www.bilibili.com/video/BV1xx411c7mD/');
+    expect(mockApiGet).toHaveBeenCalledWith(page, '/x/web-interface/view', { params: { bvid: 'BV1xx411c7mD' } });
+  });
+
+  it('extracts BV ID from bilibili URL with trailing query string', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: { bvid: 'BV1Je9EBnEha', stat: {}, owner: {}, desc: '' },
+    });
+
+    await command.func(page, {
+      bvid: 'https://www.bilibili.com/video/BV1Je9EBnEha/?spm_id_from=333.1007&vd_source=abc',
+    });
+
+    expect(mockApiGet).toHaveBeenCalledWith(page, '/x/web-interface/view', { params: { bvid: 'BV1Je9EBnEha' } });
+  });
+
+  it('extracts BV ID from m.bilibili.com mobile URL', async () => {
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: { bvid: 'BV1xx411c7mD', stat: {}, owner: {}, desc: '' },
+    });
+
+    await command.func(page, { bvid: 'https://m.bilibili.com/video/BV1xx411c7mD' });
+
+    expect(mockApiGet).toHaveBeenCalledWith(page, '/x/web-interface/view', { params: { bvid: 'BV1xx411c7mD' } });
+  });
+
+  it('returns full description without truncation or whitespace collapse', async () => {
+    const longDesc = '第一行描述\n\n第二段，有多个空格   和换行\n\n' + 'x'.repeat(500);
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: { bvid: 'BV1xx411c7mD', stat: {}, owner: {}, desc: longDesc },
+    });
+
+    const rows = await command.func(page, { bvid: 'BV1xx411c7mD' });
+    const byField = Object.fromEntries(rows.map((r) => [r.field, r.value]));
+    // JSON/YAML consumers must receive the complete description verbatim,
+    // including original whitespace and length > 200 chars.
+    expect(byField.description).toBe(longDesc);
+    expect(byField.description.length).toBeGreaterThan(200);
+  });
+});

package/clis/chatgpt/image.js

@@ -41,7 +41,7 @@ export const imageCommand = cli({
     timeoutSeconds: 240,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Image prompt to send to ChatGPT' },
-        { name: 'op', default: path.join(os.homedir(), 'Pictures', 'chatgpt'), help: 'Output directory' },
+        { name: 'op', default: '~/Pictures/chatgpt', help: 'Output directory' },
         { name: 'sd', type: 'boolean', default: false, help: 'Skip download shorthand; only show ChatGPT link' },
     ],
     columns: ['status', 'file', 'link'],

package/clis/deepseek/ask.js

@@ -2,7 +2,7 @@ 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,
+    sendMessage, sendWithFile, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
 } from './utils.js';
 
 export const askCommand = cli({
@@ -21,8 +21,9 @@ export const askCommand = cli({
         { 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'],
+    // columns omitted: derived from row keys so non-think output shows only 'response'
 
     func: async (page, kwargs) => {
         const prompt = kwargs.prompt;
@@ -44,19 +45,41 @@ export const askCommand = cli({
         if (!modelResult?.ok) {
             throw new CommandExecutionError(`Could not switch to ${wantModel} model`);
         }
-        if (modelResult.toggled) await page.wait(0.5);
+        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');
+        if (!thinkResult?.ok && wantThink) {
+            throw new CommandExecutionError('Could not enable DeepThink');
         }
 
         const searchResult = await withRetry(() => setFeature(page, 'Search', wantSearch));
-        if (!searchResult?.ok) {
-            throw new CommandExecutionError('Could not toggle Search');
+        if (!searchResult?.ok && wantSearch) {
+            throw new CommandExecutionError('Could not enable Search');
         }
 
-        if (thinkResult.toggled || searchResult.toggled) await page.wait(0.5);
+        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 result = await waitForResponse(page, baseline, prompt, timeoutMs, wantThink);
+            if (!result) {
+                return [{ response: `[NO RESPONSE] No reply within ${kwargs.timeout}s.` }];
+            }
+            if (wantThink && typeof result === 'object' && result.response !== undefined) {
+                return [result];
+            }
+            return [{ response: result }];
+        }
 
         const baseline = await withRetry(() => getBubbleCount(page));
         const sendResult = await withRetry(() => sendMessage(page, prompt));
@@ -64,11 +87,14 @@ export const askCommand = cli({
             throw new CommandExecutionError(sendResult?.reason || 'Failed to send message');
         }
 
-        const response = await waitForResponse(page, baseline, prompt, timeoutMs);
-        if (!response) {
+        const result = await waitForResponse(page, baseline, prompt, timeoutMs, wantThink);
+        if (!result) {
             return [{ response: `[NO RESPONSE] No reply within ${kwargs.timeout}s.` }];
         }
 
-        return [{ response }];
+        if (wantThink && typeof result === 'object' && result.response !== undefined) {
+            return [result];
+        }
+        return [{ response: result }];
     },
 });

package/clis/deepseek/ask.test.js

@@ -0,0 +1,165 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+
+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, false);
+  });
+
+  it('still fails when explicit instant model selection cannot be verified', async () => {
+    mockSelectModel.mockResolvedValue({ ok: false });
+
+    await expect(askCommand.func(page, {
+      prompt: 'summarize this',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    })).rejects.toThrow(new CommandExecutionError('Could not switch to instant model'));
+  });
+});
+
+describe('deepseek ask --think', () => {
+  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 });
+    mockSendMessage.mockResolvedValue({ ok: true });
+    mockGetBubbleCount.mockResolvedValue(5);
+  });
+
+  it('returns separate thinking and response fields when --think is enabled', async () => {
+    mockWaitForResponse.mockResolvedValue({
+      response: 'The answer is 42.',
+      thinking: 'Let me analyze this...',
+      thinking_time: '2.5',
+    });
+
+    const rows = await askCommand.func(page, {
+      prompt: 'what is the answer?',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: true,
+      search: false,
+    });
+
+    expect(rows).toEqual([{
+      response: 'The answer is 42.',
+      thinking: 'Let me analyze this...',
+      thinking_time: '2.5',
+    }]);
+    expect(mockWaitForResponse).toHaveBeenCalledWith(page, 5, 'what is the answer?', 120000, true);
+  });
+
+  it('returns plain response when --think is disabled', async () => {
+    mockWaitForResponse.mockResolvedValue('The answer is 42.');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'what is the answer?',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    expect(rows).toEqual([{ response: 'The answer is 42.' }]);
+    expect(mockWaitForResponse).toHaveBeenCalledWith(page, 5, 'what is the answer?', 120000, false);
+  });
+
+  it('does not declare static columns (derived from row keys)', () => {
+    // columns should be undefined so the renderer infers from row keys,
+    // avoiding empty trailing columns on non-think output.
+    expect(askCommand.columns).toBeUndefined();
+  });
+
+  it('non-think rows only contain response key', async () => {
+    mockWaitForResponse.mockResolvedValue('Plain answer.');
+
+    const rows = await askCommand.func(page, {
+      prompt: 'hello',
+      timeout: 120,
+      new: false,
+      model: 'instant',
+      think: false,
+      search: false,
+    });
+
+    // Row keys drive rendered columns; no thinking/thinking_time present.
+    expect(Object.keys(rows[0])).toEqual(['response']);
+  });
+});