@jackwener/opencli 1.6.0 → 1.6.2

package/src/clis/douban/subject.yaml

@@ -18,46 +18,75 @@ pipeline:
   - evaluate: |
       (async () => {
         const id = '${{ args.id }}';
-        
+
         // Wait for page to load
         await new Promise(r => setTimeout(r, 2000));
-        
-        // Extract title
+
+        // Extract title - v:itemreviewed contains "中文名 OriginalName"
         const titleEl = document.querySelector('span[property="v:itemreviewed"]');
-        const title = titleEl?.textContent?.trim() || '';
-        
-        // Extract original title
-        const ogTitleEl = document.querySelector('span[property="v:originalTitle"]');
-        const originalTitle = ogTitleEl?.textContent?.trim() || '';
-        
+        const fullTitle = titleEl?.textContent?.trim() || '';
+
+        // Split title and originalTitle
+        // Douban format: "中文名 OriginalName" - split by first space that separates CJK from non-CJK
+        let title = fullTitle;
+        let originalTitle = '';
+        const titleMatch = fullTitle.match(/^([\u4e00-\u9fff\u3000-\u303f\uff00-\uffef]+(?:\s*[\u4e00-\u9fff\u3000-\u303f\uff00-\uffef·：:！？]+)*)\s+(.+)$/);
+        if (titleMatch) {
+          title = titleMatch[1].trim();
+          originalTitle = titleMatch[2].trim();
+        }
+
         // Extract year
         const yearEl = document.querySelector('.year');
-        const year = yearEl?.textContent?.trim() || '';
-        
+        const year = yearEl?.textContent?.trim().replace(/[()（）]/g, '') || '';
+
         // Extract rating
         const ratingEl = document.querySelector('strong[property="v:average"]');
         const rating = parseFloat(ratingEl?.textContent || '0');
-        
+
         // Extract rating count
         const ratingCountEl = document.querySelector('span[property="v:votes"]');
         const ratingCount = parseInt(ratingCountEl?.textContent || '0', 10);
-        
+
         // Extract genres
         const genreEls = document.querySelectorAll('span[property="v:genre"]');
         const genres = Array.from(genreEls).map(el => el.textContent?.trim()).filter(Boolean).join(',');
-        
+
         // Extract directors
         const directorEls = document.querySelectorAll('a[rel="v:directedBy"]');
         const directors = Array.from(directorEls).map(el => el.textContent?.trim()).filter(Boolean).join(',');
-        
+
         // Extract casts
         const castEls = document.querySelectorAll('a[rel="v:starring"]');
-        const casts = Array.from(castEls).slice(0, 5).map(el => el.textContent?.trim()).filter(Boolean).join(',');
-        
+        const casts = Array.from(castEls).slice(0, 5).map(el => el.textContent?.trim()).filter(Boolean);
+
+        // Extract info section for country and duration
+        const infoEl = document.querySelector('#info');
+        const infoText = infoEl?.textContent || '';
+
+        // Extract country/region from #info as list
+        let country = [];
+        const countryMatch = infoText.match(/制片国家\/地区:\s*([^\n]+)/);
+        if (countryMatch) {
+          country = countryMatch[1].trim().split(/\s*\/\s*/).filter(Boolean);
+        }
+
+        // Extract duration from #info as pure number in min
+        const durationEl = document.querySelector('span[property="v:runtime"]');
+        let durationRaw = durationEl?.textContent?.trim() || '';
+        if (!durationRaw) {
+          const durationMatch = infoText.match(/片长:\s*([^\n]+)/);
+          if (durationMatch) {
+            durationRaw = durationMatch[1].trim();
+          }
+        }
+        const durationNumMatch = durationRaw.match(/(\d+)/);
+        const duration = durationNumMatch ? parseInt(durationNumMatch[1], 10) : null;
+
         // Extract summary
         const summaryEl = document.querySelector('span[property="v:summary"]');
         const summary = summaryEl?.textContent?.trim() || '';
-        
+
         return [{
           id,
           title,
@@ -68,9 +97,11 @@ pipeline:
           genres,
           directors,
           casts,
+          country,
+          duration,
           summary: summary.substring(0, 200),
           url: `https://movie.douban.com/subject/${id}`
         }];
       })()
 
-columns: [id, title, originalTitle, year, rating, ratingCount, genres, directors, casts, summary, url]
+columns: [id, title, originalTitle, year, rating, ratingCount, genres, directors, casts, country, duration, summary, url]

package/src/clis/doubao/utils.ts

@@ -149,33 +149,53 @@ function getTurnsScript(): string {
         return '';
       };
 
-      const extractText = (root) => {
-        const selectors = [
-          '[data-testid="message_text_content"]',
-          '[data-testid="message_content"]',
-          '[data-testid*="message_text"]',
-          '[data-testid*="message_content"]',
-          '[class*="message-text"]',
-          '[class*="message-content"]',
-        ];
+      const messageTextSelectors = [
+        '[data-testid="message_text_content"]',
+        '[data-testid="message_content"]',
+        '[data-testid*="message_text"]',
+        '[data-testid*="message_content"]',
+        '[class*="message-text"]',
+        '[class*="message-content"]',
+      ];
+      const messageImageSelector = messageTextSelectors.map((s) => s + ' img').join(', ');
 
+      const extractTextChunks = (root) => {
         const chunks = [];
         const seen = new Set();
-        for (const selector of selectors) {
+        for (const selector of messageTextSelectors) {
           const nodes = Array.from(root.querySelectorAll(selector))
             .filter((el) => isVisible(el))
             .map((el) => clean(el.innerText || el.textContent || ''))
             .filter(Boolean);
+
           for (const nodeText of nodes) {
             if (seen.has(nodeText)) continue;
             seen.add(nodeText);
             chunks.push(nodeText);
           }
+
           if (chunks.length > 0) break;
         }
+        return chunks;
+      };
+
+      const extractImageLines = (root) => Array.from(root.querySelectorAll(messageImageSelector))
+          .filter((el) => el instanceof HTMLImageElement && isVisible(el))
+          .map((el) => {
+            const width = el.naturalWidth || el.width || 0;
+            const height = el.naturalHeight || el.height || 0;
+            if (width > 0 && height > 0 && width <= 48 && height <= 48) return '';
+            const url = clean(el.currentSrc || el.src || '');
+            return /^https?:\\/\\//i.test(url) ? 'Image: ' + url : '';
+          })
+          .filter((line, index, items) => Boolean(line) && items.indexOf(line) === index);
 
-        if (chunks.length > 0) return clean(chunks.join('\\n'));
-        return clean(root.innerText || root.textContent || '');
+      const extractText = (root) => {
+        const chunks = extractTextChunks(root);
+        const text = chunks.length > 0 ? clean(chunks.join('\\n')) : clean(root.innerText || root.textContent || '');
+        const imageLines = extractImageLines(root);
+        if (imageLines.length === 0) return text;
+        return text ? text + '\\n' + imageLines.join('\\n') : imageLines.join('\\n');
       };
 
       const messageList = document.querySelector('[data-testid="message-list"]');

package/src/clis/douyin/_shared/browser-fetch.test.ts

@@ -8,7 +8,6 @@ function makePage(result: unknown): IPage {
     getCookies: vi.fn(), snapshot: vi.fn(), click: vi.fn(),
     typeText: vi.fn(), pressKey: vi.fn(), scrollTo: vi.fn(),
     getFormState: vi.fn(), wait: vi.fn(), tabs: vi.fn(),
-    closeTab: vi.fn(), newTab: vi.fn(), selectTab: vi.fn(),
     networkRequests: vi.fn(), consoleMessages: vi.fn(),
     scroll: vi.fn(), autoScroll: vi.fn(),
     installInterceptor: vi.fn(), getInterceptedRequests: vi.fn(),

package/src/clis/douyin/_shared/transcode.test.ts

@@ -19,8 +19,6 @@ function makePage(): IPage {
     getFormState: vi.fn(),
     wait: vi.fn(),
     tabs: vi.fn(),
-    closeTab: vi.fn(),
-    newTab: vi.fn(),
     selectTab: vi.fn(),
     networkRequests: vi.fn(),
     consoleMessages: vi.fn(),

package/src/clis/douyin/draft.test.ts

@@ -86,8 +86,6 @@ function createPageMock(
     getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
     wait: vi.fn().mockResolvedValue(undefined),
     tabs: vi.fn().mockResolvedValue([]),
-    closeTab: vi.fn().mockResolvedValue(undefined),
-    newTab: vi.fn().mockResolvedValue(undefined),
     selectTab: vi.fn().mockResolvedValue(undefined),
     networkRequests: vi.fn().mockResolvedValue([]),
     consoleMessages: vi.fn().mockResolvedValue([]),

package/src/clis/facebook/search.test.ts

@@ -32,8 +32,6 @@ function createMockPage(): IPage {
     getFormState: vi.fn().mockResolvedValue({}),
     wait: vi.fn(),
     tabs: vi.fn().mockResolvedValue([]),
-    closeTab: vi.fn(),
-    newTab: vi.fn(),
     selectTab: vi.fn(),
     networkRequests: vi.fn().mockResolvedValue([]),
     consoleMessages: vi.fn().mockResolvedValue(''),

package/src/clis/gemini/ask.test.ts

@@ -0,0 +1,116 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IPage } from '../../types.js';
+
+const baseline = {
+  turns: [{ Role: 'Assistant', Text: '旧回答' }],
+  transcriptLines: ['baseline'],
+  composerHasText: true,
+  isGenerating: false,
+  structuredTurnsTrusted: true,
+};
+
+const submission = {
+  snapshot: {
+    turns: [
+      { Role: 'Assistant', Text: '旧回答' },
+      { Role: 'User', Text: '请只回复：OK' },
+    ],
+    transcriptLines: ['baseline', '请只回复：OK'],
+    composerHasText: false,
+    isGenerating: true,
+    structuredTurnsTrusted: true,
+  },
+  preSendAssistantCount: 1,
+  userAnchorTurn: { Role: 'User', Text: '请只回复：OK' },
+  reason: 'user_turn' as const,
+};
+
+const mocks = vi.hoisted(() => ({
+  readGeminiSnapshot: vi.fn(),
+  sendGeminiMessage: vi.fn(),
+  startNewGeminiChat: vi.fn(),
+  waitForGeminiSubmission: vi.fn(),
+  waitForGeminiResponse: vi.fn(),
+}));
+
+vi.mock('./utils.js', async () => {
+  const actual = await vi.importActual<typeof import('./utils.js')>('./utils.js');
+  return {
+    ...actual,
+    readGeminiSnapshot: mocks.readGeminiSnapshot,
+    sendGeminiMessage: mocks.sendGeminiMessage,
+    startNewGeminiChat: mocks.startNewGeminiChat,
+    waitForGeminiSubmission: mocks.waitForGeminiSubmission,
+    waitForGeminiResponse: mocks.waitForGeminiResponse,
+  };
+});
+
+import { askCommand } from './ask.js';
+
+function createPageMock(): IPage {
+  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),
+  } as unknown as IPage;
+}
+
+describe('gemini ask orchestration', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('captures baseline, sends, waits for confirmed submission, then waits with the remaining timeout', async () => {
+    vi.spyOn(Date, 'now')
+      .mockReturnValueOnce(0)
+      .mockReturnValueOnce(2000);
+
+    const page = createPageMock();
+    mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+    mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+    mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+    mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+    const result = await askCommand.func!(page, { prompt: '请只回复：OK', timeout: '20', new: 'false' });
+
+    expect(mocks.readGeminiSnapshot).toHaveBeenCalledWith(page);
+    expect(mocks.waitForGeminiSubmission).toHaveBeenCalledWith(page, baseline, 20);
+    expect(mocks.waitForGeminiResponse).toHaveBeenCalledWith(page, submission, '请只回复：OK', 18);
+    expect(result).toEqual([{ response: '💬 OK' }]);
+  });
+
+  it('does not spend extra response wait time after submission has already consumed the full timeout budget', async () => {
+    vi.spyOn(Date, 'now')
+      .mockReturnValueOnce(0)
+      .mockReturnValueOnce(20000);
+
+    const page = createPageMock();
+    mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+    mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+    mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+    mocks.waitForGeminiResponse.mockResolvedValueOnce('');
+
+    await askCommand.func!(page, { prompt: '请只回复：OK', timeout: '20', new: 'false' });
+
+    expect(mocks.waitForGeminiResponse).toHaveBeenCalledWith(page, submission, '请只回复：OK', 0);
+  });
+});

package/src/clis/gemini/ask.ts

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { GEMINI_DOMAIN, getGeminiTranscriptLines, sendGeminiMessage, startNewGeminiChat, waitForGeminiResponse } from './utils.js';
+import { GEMINI_DOMAIN, readGeminiSnapshot, sendGeminiMessage, startNewGeminiChat, waitForGeminiResponse, waitForGeminiSubmission } from './utils.js';
 
 function normalizeBooleanFlag(value: unknown): boolean {
   if (typeof value === 'boolean') return value;
@@ -33,9 +33,16 @@ export const askCommand = cli({
 
     if (startFresh) await startNewGeminiChat(page);
 
-    const beforeLines = await getGeminiTranscriptLines(page);
+    const before = await readGeminiSnapshot(page);
     await sendGeminiMessage(page, prompt);
-    const response = await waitForGeminiResponse(page, beforeLines, prompt, timeout);
+    const submissionStartedAt = Date.now();
+    const submitted = await waitForGeminiSubmission(page, before, timeout);
+    if (!submitted) {
+      return [{ response: `💬 ${NO_RESPONSE_PREFIX} No Gemini response within ${timeout}s.` }];
+    }
+
+    const remainingTimeoutSeconds = Math.max(0, timeout - Math.ceil((Date.now() - submissionStartedAt) / 1000));
+    const response = await waitForGeminiResponse(page, submitted, prompt, remainingTimeoutSeconds);
 
     if (!response) {
       return [{ response: `💬 ${NO_RESPONSE_PREFIX} No Gemini response within ${timeout}s.` }];