@jackwener/opencli 1.7.3 → 1.7.4

package/clis/doubao/utils.test.js

@@ -1,5 +1,41 @@
-import { describe, expect, it } from 'vitest';
-import { mergeTranscriptSnapshots, parseDoubaoConversationId } from './utils.js';
+import { describe, expect, it, vi } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    __test__,
+    collectDoubaoTranscriptAdditions,
+    mergeTranscriptSnapshots,
+    parseDoubaoConversationId,
+    sendDoubaoMessage,
+    waitForDoubaoResponse,
+} from './utils.js';
+
+function createPageMock() {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn(),
+        getCookies: vi.fn().mockResolvedValue([]),
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({}),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+        nativeType: vi.fn().mockResolvedValue(undefined),
+        nativeKeyPress: vi.fn().mockResolvedValue(undefined),
+    };
+}
+
 describe('parseDoubaoConversationId', () => {
     it('extracts the numeric id from a full conversation URL', () => {
         expect(parseDoubaoConversationId('https://www.doubao.com/chat/1234567890123')).toBe('1234567890123');
@@ -8,6 +44,209 @@ describe('parseDoubaoConversationId', () => {
         expect(parseDoubaoConversationId('1234567890123')).toBe('1234567890123');
     });
 });
+describe('doubao send strategy', () => {
+    it('prefers native CDP text insertion and button submission when a send button is available', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        const nativeType = vi.mocked(page.nativeType);
+        const nativeKeyPress = vi.mocked(page.nativeKeyPress);
+        evaluate
+            .mockResolvedValueOnce('https://www.doubao.com/chat')
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ hasText: true, text: '你好' })
+            .mockResolvedValueOnce({ hasText: true, text: '你好' })
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce({ detected: false });
+        const result = await sendDoubaoMessage(page, '你好');
+        expect(nativeType).toHaveBeenCalledWith('你好');
+        expect(nativeKeyPress).not.toHaveBeenCalled();
+        expect(result).toBe('button');
+    });
+    it('falls back to DOM insertion when native insertion does not update the composer', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        const nativeType = vi.mocked(page.nativeType);
+        evaluate
+            .mockResolvedValueOnce('https://www.doubao.com/chat')
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ hasText: false, text: '' })
+            .mockResolvedValueOnce({ hasText: false, text: '' })
+            .mockResolvedValueOnce({ hasText: true, text: '你好' })
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce({ detected: false });
+        const result = await sendDoubaoMessage(page, '你好');
+        expect(nativeType).toHaveBeenCalledWith('你好');
+        expect(evaluate).toHaveBeenCalledTimes(7);
+        expect(result).toBe('button');
+    });
+    it('falls back to DOM insertion when native insertion text does not match the requested prompt', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://www.doubao.com/chat')
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ hasText: true, text: '你' })
+            .mockResolvedValueOnce({ hasText: true, text: '你好' })
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce({ detected: false });
+        const result = await sendDoubaoMessage(page, '你好');
+        expect(result).toBe('button');
+    });
+    it('falls back to native Enter when no clickable submit button is found', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        const nativeKeyPress = vi.mocked(page.nativeKeyPress);
+        evaluate
+            .mockResolvedValueOnce('https://www.doubao.com/chat')
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ hasText: true, text: '你好' })
+            .mockResolvedValueOnce({ hasText: true, text: '你好' })
+            .mockResolvedValueOnce(false)
+            .mockResolvedValueOnce({ detected: false });
+        const result = await sendDoubaoMessage(page, '你好');
+        expect(nativeKeyPress).toHaveBeenCalledWith('Enter');
+        expect(result).toBe('enter');
+    });
+    it('does not throw verification errors just because the prompt mentions verification terms', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://www.doubao.com/chat')
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ hasText: true, text: '请解释 CAPTCHA verification 是什么' })
+            .mockResolvedValueOnce({ hasText: true, text: '请解释 CAPTCHA verification 是什么' })
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce({ detected: false, reason: '' });
+        await expect(sendDoubaoMessage(page, '请解释 CAPTCHA verification 是什么')).resolves.toBe('button');
+    });
+    it('does not throw verification errors for ordinary chinese prompts mentioning security terms', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://www.doubao.com/chat')
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ hasText: true, text: '请解释人机验证和完成安全验证的区别' })
+            .mockResolvedValueOnce({ hasText: true, text: '请解释人机验证和完成安全验证的区别' })
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce({ detected: false, reason: '' });
+        await expect(sendDoubaoMessage(page, '请解释人机验证和完成安全验证的区别')).resolves.toBe('button');
+    });
+    it('throws a command error when Doubao shows a verification challenge after submit', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://www.doubao.com/chat')
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ hasText: true, text: '你好' })
+            .mockResolvedValueOnce({ hasText: true, text: '你好' })
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce({ detected: true, reason: '请完成安全验证' });
+        await expect(sendDoubaoMessage(page, '你好')).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+});
+describe('collectDoubaoTranscriptAdditions', () => {
+    it('ignores landing-page capability chips that are not assistant content', () => {
+        const before = ['older'];
+        const current = [
+            'older',
+            '测试一下，只回复OK快速视频生成深入研究图像生成帮我写作音乐生成更多',
+            '测试一下，只回复OK',
+        ];
+        expect(collectDoubaoTranscriptAdditions(before, current, '测试一下，只回复OK')).toBe('');
+    });
+    it('filters prompt-contaminated chip lines for arbitrary prompts', () => {
+        const before = ['older'];
+        const current = [
+            'older',
+            '你好快速视频生成深入研究图像生成帮我写作音乐生成更多',
+        ];
+        expect(collectDoubaoTranscriptAdditions(before, current, '你好')).toBe('');
+    });
+    it('filters whitespace-normalized multiline prompt echoes and prompt-plus-chip artifacts', () => {
+        const before = ['older'];
+        const prompt = '第一行\n第二行';
+        expect(collectDoubaoTranscriptAdditions(before, ['older', '第一行 第二行'], prompt)).toBe('');
+        expect(collectDoubaoTranscriptAdditions(before, ['older', '第一行 第二行快速视频生成深入研究图像生成帮我写作音乐生成更多'], prompt)).toBe('');
+    });
+    it('keeps legitimate replies that discuss Doubao features', () => {
+        const before = ['older'];
+        const current = [
+            'older',
+            '图像生成和音乐生成目前都支持，但适用场景不同。',
+        ];
+        expect(collectDoubaoTranscriptAdditions(before, current, 'irrelevant prompt')).toBe('图像生成和音乐生成目前都支持，但适用场景不同。');
+    });
+    it('keeps an exact chip string when it is the assistant reply rather than prompt contamination', () => {
+        const before = ['older'];
+        const current = [
+            'older',
+            '快速视频生成深入研究图像生成帮我写作音乐生成更多',
+        ];
+        expect(collectDoubaoTranscriptAdditions(before, current, '测试一下，只回复OK')).toBe('快速视频生成深入研究图像生成帮我写作音乐生成更多');
+    });
+    it('filters combined sidebar chrome that appears as a new transcript line', () => {
+        const before = ['older'];
+        const current = [
+            'older',
+            'AI 创作云盘更多历史对话',
+        ];
+        expect(collectDoubaoTranscriptAdditions(before, current, '测试一下，只回复OK')).toBe('');
+    });
+    it('filters transcript lines that only differ because the prompt was appended to existing page chrome', () => {
+        const before = [
+            '有什么我能帮你的吗？资讯：韩国三大运营商允许超流量用基本数据服务快速视频生成深入研究图像生成帮我写作音乐生成更多',
+        ];
+        const current = [
+            '有什么我能帮你的吗？资讯：韩国三大运营商允许超流量用基本数据服务快速视频生成深入研究图像生成帮我写作音乐生成更多测试一下，只回复OK',
+        ];
+        expect(collectDoubaoTranscriptAdditions(before, current, '测试一下，只回复OK', (value) => value.replace('测试一下，只回复OK', '').trim())).toBe('');
+    });
+    it('treats only the exact landing-page chip string as UI noise', () => {
+        expect(__test__.clickSendButtonScript()).not.toContain('document,');
+        expect(__test__.clickSendButtonScript()).toContain('bestScore >= 200');
+        expect(__test__.clickSendButtonScript()).not.toContain("|| !!button.closest('.chat-input-button')");
+        expect(__test__.clickSendButtonScript()).toContain("button.getAttribute('type') === 'submit') score += 1200");
+        expect(__test__.composerStateScript()).toContain("(composer.innerText || '').trim() || (composer.textContent || '').trim()");
+        expect(__test__.detectDoubaoVerificationScript()).not.toContain('document.body?.innerText');
+        expect(__test__.detectDoubaoVerificationScript()).not.toContain('[class*=\"verify\"]');
+        expect(__test__.detectDoubaoVerificationScript()).not.toContain('[class*=\"captcha\"]');
+        expect(__test__.detectDoubaoVerificationScript()).not.toContain('document.body?.children');
+    });
+});
+describe('waitForDoubaoResponse', () => {
+    it('allows transcript fallback on local chat urls when new transcript lines appear', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        const wait = vi.mocked(page.wait);
+        evaluate
+            .mockResolvedValueOnce({ detected: false })
+            .mockResolvedValueOnce('https://www.doubao.com/chat/local_123')
+            .mockResolvedValueOnce([])
+            .mockResolvedValueOnce('https://www.doubao.com/chat/local_123')
+            .mockResolvedValueOnce(['older', '真正的回答']);
+        const result = await waitForDoubaoResponse(page, ['older'], [], '测试一下，只回复OK', 2);
+        expect(wait).toHaveBeenCalled();
+        expect(result).toBe('真正的回答');
+    });
+    it('does not suppress assistant turns that happen to match landing-page chip text', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce({ detected: false })
+            .mockResolvedValueOnce('https://www.doubao.com/chat')
+            .mockResolvedValueOnce([
+            { Role: 'Assistant', Text: '快速视频生成深入研究图像生成帮我写作音乐生成更多' },
+        ]);
+        const result = await waitForDoubaoResponse(page, [], [], '测试一下，只回复OK', 2);
+        expect(result).toBe('快速视频生成深入研究图像生成帮我写作音乐生成更多');
+    });
+    it('raises a command error when a verification challenge appears during polling', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate.mockResolvedValueOnce({ detected: true, reason: '请完成安全验证' });
+        await expect(waitForDoubaoResponse(page, [], [], '你好', 2)).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+});
 describe('mergeTranscriptSnapshots', () => {
     it('extends the transcript when the next snapshot overlaps with the tail', () => {
         const merged = mergeTranscriptSnapshots('Alice 00:00\nHello team\nBob 00:05\nHi', 'Bob 00:05\nHi\nAlice 00:10\nNext topic');

package/clis/eastmoney/hot-rank.js

@@ -0,0 +1,50 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+cli({
+  site: 'eastmoney',
+  name: 'hot-rank',
+  description: '东方财富热股榜',
+  domain: 'guba.eastmoney.com',
+  strategy: Strategy.COOKIE,
+  navigateBefore: true,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: '返回数量' },
+  ],
+  columns: ['rank', 'symbol', 'name', 'price', 'changePercent', 'heat', 'url'],
+  func: async (page, kwargs) => {
+    await page.goto('https://guba.eastmoney.com/rank/');
+    await page.wait({ selector: '#rankCont', timeout: 15000 });
+    const data = await page.evaluate(`
+      (() => {
+        const cleanText = (el) => (el?.textContent || '').replace(/\\s+/g, ' ').trim();
+        const rows = document.querySelectorAll('table.rank_table tbody tr');
+        const results = [];
+        const seen = new Set();
+        let rank = 0;
+        rows.forEach((row) => {
+          const codeEl = row.querySelector('a.stock_code');
+          const href = codeEl?.getAttribute('href') || '';
+          const symbolMatch = href.match(/(\\d{6})/);
+          if (!symbolMatch) return;
+          const symbol = symbolMatch[1];
+          if (seen.has(symbol)) return;
+          seen.add(symbol);
+          rank++;
+          const tds = row.querySelectorAll('td');
+          results.push({
+            rank,
+            symbol,
+            name: row.querySelector('td.nametd a[title]')?.getAttribute('title') || cleanText(row.querySelector('td.nametd')),
+            price: tds[6] ? cleanText(tds[6]) : '',
+            changePercent: tds[8] ? cleanText(tds[8]) : '',
+            heat: cleanText(row.querySelector('td.fans')),
+            url: 'https://guba.eastmoney.com/list,' + symbol + '.html',
+          });
+        });
+        return results;
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, kwargs.limit);
+  },
+});

package/clis/eastmoney/hot-rank.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './hot-rank.js';
+
+describe('eastmoney hot-rank command', () => {
+  it('registers the command with correct metadata', () => {
+    const command = getRegistry().get('eastmoney/hot-rank');
+    expect(command).toBeDefined();
+    expect(command).toMatchObject({
+      site: 'eastmoney',
+      name: 'hot-rank',
+      description: expect.stringContaining('东方财富'),
+      domain: 'guba.eastmoney.com',
+      navigateBefore: true,
+    });
+  });
+
+  it('returns hot stock data from the page', async () => {
+    const command = getRegistry().get('eastmoney/hot-rank');
+    const mockData = [
+      { rank: 1, symbol: '600519', name: '贵州茅台', price: '1680.00', changePercent: '+2.35%', heat: '28.5万', url: 'https://guba.eastmoney.com/list,600519.html' },
+      { rank: 2, symbol: '000001', name: '平安银行', price: '12.50', changePercent: '-0.80%', heat: '15.2万', url: 'https://guba.eastmoney.com/list,000001.html' },
+    ];
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(mockData),
+    };
+    const result = await command.func(page, { limit: 20 });
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual(mockData[0]);
+    expect(page.goto).toHaveBeenCalledWith('https://guba.eastmoney.com/rank/');
+  });
+
+  it('respects the limit parameter', async () => {
+    const command = getRegistry().get('eastmoney/hot-rank');
+    const mockData = Array.from({ length: 30 }, (_, i) => ({
+      rank: i + 1, symbol: `${i}`, name: `stock${i}`, price: '0', changePercent: '0%', heat: '0', url: '',
+    }));
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(mockData),
+    };
+    const result = await command.func(page, { limit: 10 });
+    expect(result).toHaveLength(10);
+  });
+
+  it('returns empty array when evaluate returns non-array', async () => {
+    const command = getRegistry().get('eastmoney/hot-rank');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(null),
+    };
+    const result = await command.func(page, { limit: 20 });
+    expect(result).toEqual([]);
+  });
+});

package/clis/grok/image.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+import type { IPage } from '@jackwener/opencli/types';
+import { __test__ } from './image.js';
+
+describe('grok image helpers', () => {
+  describe('isOnGrok', () => {
+    const fakePage = (url: string | Error): IPage =>
+      ({ evaluate: () => url instanceof Error ? Promise.reject(url) : Promise.resolve(url) }) as unknown as IPage;
+
+    it('returns true for grok.com URLs', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://grok.com/'))).toBe(true);
+      expect(await __test__.isOnGrok(fakePage('https://grok.com/chat/abc123'))).toBe(true);
+    });
+
+    it('returns true for grok.com subdomains', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://assets.grok.com/foo'))).toBe(true);
+    });
+
+    it('returns false for non-grok domains', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://fakegrok.com/'))).toBe(false);
+      expect(await __test__.isOnGrok(fakePage('about:blank'))).toBe(false);
+    });
+
+    it('returns false when evaluate throws (detached tab)', async () => {
+      expect(await __test__.isOnGrok(fakePage(new Error('detached')))).toBe(false);
+    });
+  });
+
+  it('normalizes boolean flags', () => {
+    expect(__test__.normalizeBooleanFlag(true)).toBe(true);
+    expect(__test__.normalizeBooleanFlag('true')).toBe(true);
+    expect(__test__.normalizeBooleanFlag('1')).toBe(true);
+    expect(__test__.normalizeBooleanFlag('yes')).toBe(true);
+    expect(__test__.normalizeBooleanFlag('on')).toBe(true);
+
+    expect(__test__.normalizeBooleanFlag(false)).toBe(false);
+    expect(__test__.normalizeBooleanFlag('false')).toBe(false);
+    expect(__test__.normalizeBooleanFlag(undefined)).toBe(false);
+  });
+
+  it('dedupes images by src', () => {
+    const deduped = __test__.dedupeBySrc([
+      { src: 'https://a.example/1.jpg', w: 500, h: 500 },
+      { src: 'https://a.example/1.jpg', w: 500, h: 500 },
+      { src: 'https://a.example/2.jpg', w: 500, h: 500 },
+      { src: '', w: 500, h: 500 },
+    ]);
+    expect(deduped.map(i => i.src)).toEqual([
+      'https://a.example/1.jpg',
+      'https://a.example/2.jpg',
+    ]);
+  });
+
+  it('builds a deterministic-ish signature order-independent by src', () => {
+    const sigA = __test__.imagesSignature([
+      { src: 'https://a.example/1.jpg', w: 1, h: 1 },
+      { src: 'https://a.example/2.jpg', w: 1, h: 1 },
+    ]);
+    const sigB = __test__.imagesSignature([
+      { src: 'https://a.example/2.jpg', w: 1, h: 1 },
+      { src: 'https://a.example/1.jpg', w: 1, h: 1 },
+    ]);
+    expect(sigA).toBe(sigB);
+  });
+
+  it('maps content-type to sensible image extensions', () => {
+    expect(__test__.extFromContentType('image/png')).toBe('png');
+    expect(__test__.extFromContentType('image/webp')).toBe('webp');
+    expect(__test__.extFromContentType('image/gif')).toBe('gif');
+    expect(__test__.extFromContentType('image/jpeg')).toBe('jpg');
+    expect(__test__.extFromContentType(undefined)).toBe('jpg');
+    expect(__test__.extFromContentType('')).toBe('jpg');
+  });
+
+  it('builds filenames with a stable sha1 slice tied to the src', () => {
+    const a1 = __test__.buildFilename('https://a.example/1.jpg', 'image/jpeg');
+    const a2 = __test__.buildFilename('https://a.example/1.jpg', 'image/jpeg');
+    const b1 = __test__.buildFilename('https://a.example/2.jpg', 'image/png');
+    // Same URL → same 12-char hash slice (timestamps may differ).
+    expect(a1.split('-')[2].split('.')[0]).toBe(a2.split('-')[2].split('.')[0]);
+    expect(a1.split('-')[2].split('.')[0]).not.toBe(b1.split('-')[2].split('.')[0]);
+    expect(a1.endsWith('.jpg')).toBe(true);
+    expect(b1.endsWith('.png')).toBe(true);
+  });
+
+  it('only accepts image bubbles that appeared after the baseline', () => {
+    const candidate = __test__.pickLatestImageCandidate([
+      [{ src: 'https://a.example/stale.jpg', w: 512, h: 512 }],
+      [],
+      [{ src: 'https://a.example/fresh.jpg', w: 1024, h: 1024 }],
+    ], 1);
+
+    expect(candidate).toEqual([
+      { src: 'https://a.example/fresh.jpg', w: 1024, h: 1024 },
+    ]);
+  });
+
+  it('does not reuse stale images when no new image bubble appears after baseline', () => {
+    const candidate = __test__.pickLatestImageCandidate([
+      [{ src: 'https://a.example/stale.jpg', w: 512, h: 512 }],
+      [],
+      [],
+    ], 1);
+
+    expect(candidate).toEqual([]);
+  });
+});