@jackwener/opencli 1.5.6 → 1.5.7

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

@@ -1,8 +1,21 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { browserFetchMock } = vi.hoisted(() => ({
+  browserFetchMock: vi.fn(),
+}));
+
+vi.mock('./_shared/browser-fetch.js', () => ({
+  browserFetch: browserFetchMock,
+}));
+
 import { getRegistry } from '../../registry.js';
 import './hashtag.js';
 
-describe('douyin hashtag registration', () => {
+describe('douyin hashtag', () => {
+  beforeEach(() => {
+    browserFetchMock.mockReset();
+  });
+
   it('registers the hashtag command', () => {
     const registry = getRegistry();
     const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'hashtag');
@@ -25,4 +38,31 @@ describe('douyin hashtag registration', () => {
     const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'hashtag');
     expect(cmd?.strategy).toBe('cookie');
   });
+
+  it('parses the current hotspot recommendation shape', async () => {
+    const registry = getRegistry();
+    const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'hashtag');
+    expect(command?.func).toBeDefined();
+    if (!command?.func) throw new Error('douyin hashtag command not registered');
+
+    browserFetchMock.mockResolvedValueOnce({
+      all_sentences: [
+        {
+          word: '在公园花海里大晒一场',
+          hot_value: 12141172,
+          sentence_id: '2448416',
+        },
+      ],
+    });
+
+    const rows = await command.func({} as any, { action: 'hot', keyword: '', limit: 5 });
+
+    expect(rows).toEqual([
+      {
+        name: '在公园花海里大晒一场',
+        id: '2448416',
+        view_count: 12141172,
+      },
+    ]);
+  });
 });

package/src/clis/douyin/hashtag.ts

@@ -42,11 +42,19 @@ cli({
       const kw = kwargs.keyword as string;
       const url = `https://creator.douyin.com/aweme/v1/hotspot/recommend/?${kw ? `keyword=${encodeURIComponent(kw)}&` : ''}aid=1128`;
       const res = await browserFetch(page, 'GET', url) as {
-        hotspot_list: Array<{ sentence: string; hot_value: number }>
+        hotspot_list?: Array<{ sentence: string; hot_value: number }>;
+        all_sentences?: Array<{ sentence_id?: string; word?: string; hot_value: number }>;
       };
-      return (res.hotspot_list ?? []).slice(0, kwargs.limit as number).map(h => ({
+      const items = res.hotspot_list
+        ?? res.all_sentences?.map(h => ({
+          sentence: h.word ?? '',
+          hot_value: h.hot_value,
+          sentence_id: h.sentence_id ?? '',
+        }))
+        ?? [];
+      return items.slice(0, kwargs.limit as number).map(h => ({
         name: h.sentence,
-        id: '',
+        id: 'sentence_id' in h ? h.sentence_id : '',
         view_count: h.hot_value,
       }));
     }

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

@@ -1,12 +1,54 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { browserFetchMock } = vi.hoisted(() => ({
+  browserFetchMock: vi.fn(),
+}));
+
+vi.mock('./_shared/browser-fetch.js', () => ({
+  browserFetch: browserFetchMock,
+}));
+
 import { getRegistry } from '../../registry.js';
 import './profile.js';
 
 describe('douyin profile registration', () => {
+  beforeEach(() => {
+    browserFetchMock.mockReset();
+  });
+
   it('registers the profile command', () => {
     const registry = getRegistry();
     const values = [...registry.values()];
     const cmd = values.find(c => c.site === 'douyin' && c.name === 'profile');
     expect(cmd).toBeDefined();
   });
+
+  it('maps the current user payload shape returned by creator center', async () => {
+    const registry = getRegistry();
+    const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'profile');
+    expect(cmd?.func).toBeDefined();
+    if (!cmd?.func) throw new Error('douyin profile command not registered');
+
+    browserFetchMock.mockResolvedValueOnce({
+      user: {
+        uid: '100',
+        nickname: 'creator',
+        follower_count: 12,
+        following_count: 3,
+        aweme_count: 7,
+      },
+    });
+
+    const rows = await cmd.func({} as never, {});
+
+    expect(rows).toEqual([
+      {
+        uid: '100',
+        nickname: 'creator',
+        follower_count: 12,
+        following_count: 3,
+        aweme_count: 7,
+      },
+    ]);
+  });
 });

package/src/clis/douyin/profile.ts

@@ -14,7 +14,14 @@ cli({
   func: async (page: IPage, _kwargs) => {
     const url = 'https://creator.douyin.com/web/api/media/user/info/?aid=1128';
     const res = (await browserFetch(page, 'GET', url)) as {
-      user_info: {
+      user_info?: {
+        uid: string;
+        nickname: string;
+        follower_count: number;
+        following_count: number;
+        aweme_count: number;
+      };
+      user?: {
         uid: string;
         nickname: string;
         follower_count: number;
@@ -22,7 +29,7 @@ cli({
         aweme_count: number;
       };
     };
-    const u = res.user_info;
+    const u = res.user_info ?? res.user;
     if (!u) throw new CommandExecutionError('用户信息获取失败，请确认已登录 creator.douyin.com');
     return [
       {

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

@@ -1,12 +1,62 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { browserFetchMock } = vi.hoisted(() => ({
+  browserFetchMock: vi.fn(),
+}));
+
+vi.mock('./_shared/browser-fetch.js', () => ({
+  browserFetch: browserFetchMock,
+}));
+
 import { getRegistry } from '../../registry.js';
 import './videos.js';
 
-describe('douyin videos registration', () => {
+describe('douyin videos', () => {
+  beforeEach(() => {
+    browserFetchMock.mockReset();
+  });
+
   it('registers the videos command', () => {
     const registry = getRegistry();
     const values = [...registry.values()];
     const cmd = values.find(c => c.site === 'douyin' && c.name === 'videos');
     expect(cmd).toBeDefined();
   });
+
+  it('parses the current creator work_list api shape', async () => {
+    const registry = getRegistry();
+    const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'videos');
+    expect(command?.func).toBeDefined();
+    if (!command?.func) throw new Error('douyin videos command not registered');
+
+    browserFetchMock.mockResolvedValueOnce({
+      aweme_list: [
+        {
+          aweme_id: '7000000000000000001',
+          desc: '测试视频标题',
+          create_time: 1581571130,
+          statistics: {
+            play_count: 0,
+            digg_count: 12,
+          },
+          status: {
+            is_private: true,
+          },
+        },
+      ],
+    });
+
+    const rows = await command.func({} as any, { limit: 5, page: 1, status: 'all' });
+
+    expect(rows).toEqual([
+      {
+        aweme_id: '7000000000000000001',
+        title: '测试视频标题',
+        status: 'private',
+        play_count: 0,
+        digg_count: 12,
+        create_time: new Date(1581571130 * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
+      },
+    ]);
+  });
 });

package/src/clis/douyin/videos.ts

@@ -2,6 +2,48 @@ import { cli, Strategy } from '../../registry.js';
 import { browserFetch } from './_shared/browser-fetch.js';
 import type { IPage } from '../../types.js';
 
+interface LegacyWorkItem {
+  aweme_id: string;
+  desc: string;
+  status: number;
+  public_time: number;
+  create_time: number;
+  statistics: { play_count: number; digg_count: number };
+}
+
+interface CurrentWorkItem {
+  aweme_id: string;
+  desc?: string;
+  status?: {
+    in_reviewing?: boolean;
+    is_private?: boolean;
+    is_delete?: boolean;
+    is_prohibited?: boolean;
+  };
+  public_time?: number;
+  create_time?: number;
+  statistics?: { play_count?: number; digg_count?: number };
+}
+
+function normalizeVideoStatus(
+  status: number | {
+    in_reviewing?: boolean;
+    is_private?: boolean;
+    is_delete?: boolean;
+    is_prohibited?: boolean;
+  } | undefined,
+  publicTime: number | undefined,
+): number | string {
+  if (typeof status === 'number') return status;
+  if (!status) return publicTime && publicTime > Date.now() / 1000 ? 'scheduled' : 'published';
+  if (status.is_delete) return 'deleted';
+  if (status.is_prohibited) return 'prohibited';
+  if (status.in_reviewing) return 'reviewing';
+  if (status.is_private) return 'private';
+  if (publicTime && publicTime > Date.now() / 1000) return 'scheduled';
+  return 'published';
+}
+
 cli({
   site: 'douyin',
   name: 'videos',
@@ -19,31 +61,23 @@ cli({
     const statusNum = statusMap[kwargs.status as string] ?? 0;
     const url = `https://creator.douyin.com/janus/douyin/creator/pc/work_list?page_size=${kwargs.limit}&page_num=${kwargs.page}&status=${statusNum}`;
     const res = (await browserFetch(page, 'GET', url)) as {
-      data: {
-        work_list: Array<{
-          aweme_id: string;
-          desc: string;
-          status: number;
-          public_time: number;
-          create_time: number;
-          statistics: { play_count: number; digg_count: number };
-        }>;
-      };
+      data?: { work_list?: LegacyWorkItem[] };
+      aweme_list?: CurrentWorkItem[];
     };
-    let items = res.data?.work_list ?? [];
+    let items: Array<LegacyWorkItem | CurrentWorkItem> = res.data?.work_list ?? res.aweme_list ?? [];
 
     // The API has a bug with status=16 for scheduled, so filter client-side
     if (kwargs.status === 'scheduled') {
-      items = items.filter((v) => v.public_time > Date.now() / 1000);
+      items = items.filter((v) => (v.public_time ?? 0) > Date.now() / 1000);
     }
 
     return items.map((v) => ({
       aweme_id: v.aweme_id,
-      title: v.desc,
-      status: v.status,
+      title: v.desc ?? '',
+      status: normalizeVideoStatus(v.status, v.public_time),
       play_count: v.statistics?.play_count ?? 0,
       digg_count: v.statistics?.digg_count ?? 0,
-      create_time: new Date(v.create_time * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
+      create_time: new Date((v.create_time ?? v.public_time ?? 0) * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
     }));
   },
 });

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

@@ -0,0 +1,70 @@
+/**
+ * Regression test for issue #625.
+ * Facebook search must navigate in the pipeline before DOM extraction.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'js-yaml';
+import { describe, expect, it, vi } from 'vitest';
+import { executePipeline } from '../../pipeline/index.js';
+import type { IPage } from '../../types.js';
+
+interface YamlCommand {
+  pipeline?: Array<Record<string, unknown>>;
+}
+
+/**
+ * Minimal browser mock for pipeline execution tests.
+ * Only methods touched by this adapter path are implemented.
+ */
+function createMockPage(): IPage {
+  return {
+    goto: vi.fn(),
+    evaluate: vi.fn().mockResolvedValue([]),
+    getCookies: vi.fn().mockResolvedValue([]),
+    snapshot: vi.fn().mockResolvedValue(''),
+    click: vi.fn(),
+    typeText: vi.fn(),
+    pressKey: vi.fn(),
+    scrollTo: vi.fn(),
+    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(''),
+    scroll: vi.fn(),
+    autoScroll: vi.fn(),
+    installInterceptor: vi.fn(),
+    getInterceptedRequests: vi.fn().mockResolvedValue([]),
+    waitForCapture: vi.fn().mockResolvedValue(undefined),
+    screenshot: vi.fn().mockResolvedValue(''),
+  };
+}
+
+describe('facebook search pipeline', () => {
+  it('navigates to search results before extracting DOM data', async () => {
+    // Load the YAML adapter directly so the regression test covers the shipped command definition.
+    const filePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'search.yaml');
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const command = yaml.load(raw) as YamlCommand;
+    const pipeline = command.pipeline ?? [];
+    const page = createMockPage();
+
+    await executePipeline(page, pipeline, {
+      args: { query: 'AI agent', limit: 3 },
+    });
+
+    expect(page.goto).toHaveBeenNthCalledWith(1, 'https://www.facebook.com');
+    expect(page.goto).toHaveBeenNthCalledWith(2, 'https://www.facebook.com/search/top?q=AI%20agent', {
+      waitUntil: undefined,
+      settleMs: 4000,
+    });
+    expect(page.evaluate).toHaveBeenCalledTimes(1);
+    expect(String((page.evaluate as ReturnType<typeof vi.fn>).mock.calls[0]?.[0] ?? '')).not.toContain('window.location.href');
+  });
+});

package/src/clis/facebook/search.yaml

@@ -17,12 +17,13 @@ args:
 pipeline:
   - navigate: https://www.facebook.com
 
+  - navigate:
+      url: https://www.facebook.com/search/top?q=${{ args.query | urlencode }}
+      settleMs: 4000
+
   - evaluate: |
       (async () => {
-        const query = ${{ args.query | json }};
         const limit = ${{ args.limit }};
-        window.location.href = 'https://www.facebook.com/search/top?q=' + encodeURIComponent(query);
-        await new Promise(r => setTimeout(r, 4000));
         // Search results are typically in role="article" or role="listitem"
         let items = document.querySelectorAll('[role="article"]');
         if (items.length === 0) {

package/src/clis/instagram/download.test.ts

@@ -0,0 +1,159 @@
+import * as os from 'node:os';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { CliCommand } from '../../registry.js';
+import { getRegistry } from '../../registry.js';
+import { ArgumentError, AuthRequiredError, CliError, CommandExecutionError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+
+const { mockHttpDownload, logSpy } = vi.hoisted(() => ({
+  mockHttpDownload: vi.fn(),
+  logSpy: vi.spyOn(console, 'log').mockImplementation(() => undefined),
+}));
+
+vi.mock('../../download/index.js', async () => {
+  const actual = await vi.importActual<object>('../../download/index.js');
+  return { ...actual, httpDownload: mockHttpDownload };
+});
+
+const {
+  buildInstagramDownloadItems,
+  parseInstagramMediaTarget,
+} = await import('./download.js');
+
+let cmd: CliCommand;
+
+beforeAll(() => {
+  cmd = getRegistry().get('instagram/download')!;
+  expect(cmd?.func).toBeTypeOf('function');
+});
+
+function createPageMock(evaluateResult: unknown): IPage {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(evaluateResult),
+  } as unknown as IPage;
+}
+
+describe('instagram download helpers', () => {
+  it('parses canonical and username-prefixed Instagram media URLs', () => {
+    expect(parseInstagramMediaTarget('https://www.instagram.com/reel/DWg8NuZEj9p/?utm_source=ig_web_copy_link')).toEqual({
+      kind: 'reel',
+      shortcode: 'DWg8NuZEj9p',
+      canonicalUrl: 'https://www.instagram.com/reel/DWg8NuZEj9p/',
+    });
+
+    expect(parseInstagramMediaTarget('https://www.instagram.com/nasa/p/DWUR_azCWbN/?img_index=1')).toEqual({
+      kind: 'p',
+      shortcode: 'DWUR_azCWbN',
+      canonicalUrl: 'https://www.instagram.com/p/DWUR_azCWbN/',
+    });
+  });
+
+  it('rejects unsupported URLs early', () => {
+    expect(() => parseInstagramMediaTarget('https://example.com/p/abc')).toThrow(ArgumentError);
+    expect(() => parseInstagramMediaTarget('https://www.instagram.com/stories/abc/123')).toThrow(ArgumentError);
+  });
+
+  it('builds padded filenames and preserves known file extensions', () => {
+    expect(buildInstagramDownloadItems('DWUR_azCWbN', [
+      { type: 'image', url: 'https://cdn.example.com/photo.webp?foo=1' },
+      { type: 'video', url: 'https://cdn.example.com/video.mp4?bar=2' },
+      { type: 'image', url: 'not-a-valid-url' },
+    ])).toEqual([
+      { type: 'image', url: 'https://cdn.example.com/photo.webp?foo=1', filename: 'DWUR_azCWbN_01.webp' },
+      { type: 'video', url: 'https://cdn.example.com/video.mp4?bar=2', filename: 'DWUR_azCWbN_02.mp4' },
+      { type: 'image', url: 'not-a-valid-url', filename: 'DWUR_azCWbN_03.jpg' },
+    ]);
+  });
+});
+
+describe('instagram download command', () => {
+  beforeEach(() => {
+    mockHttpDownload.mockReset();
+    logSpy.mockClear();
+  });
+
+  it('rejects invalid URLs before browser work', async () => {
+    const page = createPageMock({ ok: true, items: [] });
+    await expect(cmd.func!(page, { url: 'https://example.com/not-instagram' })).rejects.toThrow(ArgumentError);
+    expect((page.goto as any).mock.calls).toHaveLength(0);
+  });
+
+  it('maps auth failures to AuthRequiredError', async () => {
+    const page = createPageMock({ ok: false, errorCode: 'AUTH_REQUIRED', error: 'Instagram login required' });
+    await expect(cmd.func!(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' })).rejects.toThrow(AuthRequiredError);
+    expect(mockHttpDownload).not.toHaveBeenCalled();
+  });
+
+  it('maps rate limit failures to CliError with RATE_LIMITED code', async () => {
+    const page = createPageMock({ ok: false, errorCode: 'RATE_LIMITED', error: 'Please wait a few minutes' });
+    await expect(cmd.func!(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' })).rejects.toMatchObject({ code: 'RATE_LIMITED' } satisfies Partial<CliError>);
+    expect(mockHttpDownload).not.toHaveBeenCalled();
+  });
+
+  it('maps private/unavailable failures to CommandExecutionError', async () => {
+    const page = createPageMock({ ok: false, errorCode: 'PRIVATE_OR_UNAVAILABLE', error: 'Post may be private' });
+    await expect(cmd.func!(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' })).rejects.toThrow(CommandExecutionError);
+    expect(mockHttpDownload).not.toHaveBeenCalled();
+  });
+
+  it('throws when no downloadable media is found', async () => {
+    const page = createPageMock({ ok: true, shortcode: 'DWUR_azCWbN', items: [] });
+    await expect(cmd.func!(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' })).rejects.toThrow(CommandExecutionError);
+    expect(mockHttpDownload).not.toHaveBeenCalled();
+  });
+
+  it('downloads media and prints saved directory', async () => {
+    mockHttpDownload
+      .mockResolvedValueOnce({ success: true, size: 120_000 })
+      .mockResolvedValueOnce({ success: true, size: 8_200_000 });
+
+    const page = createPageMock({
+      ok: true,
+      shortcode: 'DWUR_azCWbN',
+      items: [
+        { type: 'image', url: 'https://cdn.example.com/photo.webp?foo=1' },
+        { type: 'video', url: 'https://cdn.example.com/video.mp4?bar=2' },
+      ],
+    });
+
+    const result = await cmd.func!(page, {
+      url: 'https://www.instagram.com/nasa/p/DWUR_azCWbN/?img_index=1',
+      path: './instagram-test',
+    });
+
+    expect(result).toBeNull();
+    expect((page.goto as any).mock.calls[0]?.[0]).toBe('https://www.instagram.com/p/DWUR_azCWbN/');
+    expect(mockHttpDownload).toHaveBeenNthCalledWith(1,
+      'https://cdn.example.com/photo.webp?foo=1',
+      expect.stringContaining('instagram-test/DWUR_azCWbN/DWUR_azCWbN_01.webp'),
+      expect.objectContaining({ timeout: 60000 }),
+    );
+    expect(mockHttpDownload).toHaveBeenNthCalledWith(2,
+      'https://cdn.example.com/video.mp4?bar=2',
+      expect.stringContaining('instagram-test/DWUR_azCWbN/DWUR_azCWbN_02.mp4'),
+      expect.objectContaining({ timeout: 120000 }),
+    );
+    expect(logSpy).toHaveBeenCalledWith('📁 saved: instagram-test/DWUR_azCWbN');
+  });
+
+  it('uses a cross-platform Downloads default when path is omitted', async () => {
+    mockHttpDownload.mockResolvedValueOnce({ success: true, size: 120_000 });
+
+    const page = createPageMock({
+      ok: true,
+      shortcode: 'DWUR_azCWbN',
+      items: [
+        { type: 'image', url: 'https://cdn.example.com/photo.webp?foo=1' },
+      ],
+    });
+
+    await cmd.func!(page, { url: 'https://www.instagram.com/p/DWUR_azCWbN/' });
+
+    expect(mockHttpDownload).toHaveBeenCalledWith(
+      'https://cdn.example.com/photo.webp?foo=1',
+      expect.stringContaining(`${os.homedir()}/Downloads/Instagram/DWUR_azCWbN/DWUR_azCWbN_01.webp`),
+      expect.objectContaining({ timeout: 60000 }),
+    );
+  });
+});