@jackwener/opencli 1.5.4 → 1.5.6

package/src/clis/doubao/utils.ts

@@ -4,6 +4,12 @@ export const DOUBAO_DOMAIN = 'www.doubao.com';
 export const DOUBAO_CHAT_URL = 'https://www.doubao.com/chat';
 export const DOUBAO_NEW_CHAT_URL = 'https://www.doubao.com/chat/new-thread/create-by-msg';
 
+export interface DoubaoConversation {
+  Id: string;
+  Title: string;
+  Url: string;
+}
+
 export interface DoubaoTurn {
   Role: 'User' | 'Assistant' | 'System';
   Text: string;
@@ -605,6 +611,371 @@ export async function waitForDoubaoResponse(
   return lastCandidate;
 }
 
+function getConversationListScript(): string {
+  return `
+    (() => {
+      const sidebar = document.querySelector('[data-testid="flow_chat_sidebar"]');
+      if (!sidebar) return [];
+
+      const items = Array.from(
+        sidebar.querySelectorAll('a[data-testid="chat_list_thread_item"]')
+      );
+
+      return items
+        .map(a => {
+          const href = a.getAttribute('href') || '';
+          const match = href.match(/\\/chat\\/(\\d{10,})/);
+          if (!match) return null;
+          const id = match[1];
+          const textContent = (a.textContent || a.innerText || '').trim();
+          const title = textContent
+            .replace(/\\s+/g, ' ')
+            .substring(0, 200);
+          return { id, title, href };
+        })
+        .filter(Boolean);
+    })()
+  `;
+}
+
+export async function getDoubaoConversationList(page: IPage): Promise<DoubaoConversation[]> {
+  await ensureDoubaoChatPage(page);
+  const raw = await page.evaluate(getConversationListScript()) as
+    Array<{ id: string; title: string; href: string }>;
+
+  if (!Array.isArray(raw)) return [];
+
+  return raw.map((item) => ({
+    Id: item.id,
+    Title: item.title,
+    Url: `${DOUBAO_CHAT_URL}/${item.id}`,
+  }));
+}
+
+// ---------------------------------------------------------------------------
+// Conversation detail helpers
+// ---------------------------------------------------------------------------
+
+export interface DoubaoMessage {
+  Role: 'User' | 'Assistant' | 'System';
+  Text: string;
+  HasMeetingCard: boolean;
+}
+
+export interface DoubaoMeetingInfo {
+  title: string;
+  time: string;
+}
+
+export function parseDoubaoConversationId(input: string): string {
+  const match = input.match(/(\d{10,})/);
+  return match ? match[1] : input;
+}
+
+function getConversationDetailScript(): string {
+  return `
+    (() => {
+      const clean = (v) => (v || '').replace(/\\u00a0/g, ' ').replace(/\\n{3,}/g, '\\n\\n').trim();
+
+      const messageList = document.querySelector('[data-testid="message-list"]');
+      if (!messageList) return { messages: [], meeting: null };
+
+      const meetingCard = messageList.querySelector('[data-testid="meeting-minutes-card"]');
+      let meeting = null;
+      if (meetingCard) {
+        const raw = clean(meetingCard.textContent || '');
+        const match = raw.match(/^(.+?)(?:会议时间：|\\s*$)(.*)/);
+        meeting = {
+          title: match ? match[1].trim() : raw,
+          time: match && match[2] ? match[2].trim() : '',
+        };
+      }
+
+      const unions = Array.from(messageList.querySelectorAll('[data-testid="union_message"]'));
+      const messages = unions.map(u => {
+        const isSend = !!u.querySelector('[data-testid="send_message"]');
+        const isReceive = !!u.querySelector('[data-testid="receive_message"]');
+        const textEl = u.querySelector('[data-testid="message_text_content"]');
+        const text = textEl ? clean(textEl.innerText || textEl.textContent || '') : '';
+        return {
+          role: isSend ? 'User' : isReceive ? 'Assistant' : 'System',
+          text,
+          hasMeetingCard: !!u.querySelector('[data-testid="meeting-minutes-card"]'),
+        };
+      }).filter(m => m.text);
+
+      return { messages, meeting };
+    })()
+  `;
+}
+
+export async function navigateToConversation(page: IPage, conversationId: string): Promise<void> {
+  const url = `${DOUBAO_CHAT_URL}/${conversationId}`;
+  const currentUrl = await page.evaluate('window.location.href').catch(() => '');
+  if (typeof currentUrl === 'string' && currentUrl.includes(`/chat/${conversationId}`)) {
+    await page.wait(1);
+    return;
+  }
+  await page.goto(url, { waitUntil: 'load', settleMs: 3000 });
+  await page.wait(2);
+}
+
+export async function getConversationDetail(
+  page: IPage,
+  conversationId: string,
+): Promise<{ messages: DoubaoMessage[]; meeting: DoubaoMeetingInfo | null }> {
+  await navigateToConversation(page, conversationId);
+  const raw = await page.evaluate(getConversationDetailScript()) as {
+    messages: Array<{ role: string; text: string; hasMeetingCard: boolean }>;
+    meeting: { title: string; time: string } | null;
+  };
+
+  const messages: DoubaoMessage[] = (raw.messages || []).map((m) => ({
+    Role: m.role as 'User' | 'Assistant' | 'System',
+    Text: m.text,
+    HasMeetingCard: m.hasMeetingCard,
+  }));
+
+  return { messages, meeting: raw.meeting };
+}
+
+// ---------------------------------------------------------------------------
+// Meeting minutes panel helpers
+// ---------------------------------------------------------------------------
+
+function clickMeetingCardScript(): string {
+  return `
+    (() => {
+      const card = document.querySelector('[data-testid="meeting-minutes-card"]');
+      if (!card) return false;
+      card.click();
+      return true;
+    })()
+  `;
+}
+
+function readMeetingSummaryScript(): string {
+  return `
+    (() => {
+      const panel = document.querySelector('[data-testid="canvas_panel_container"]');
+      if (!panel) return { error: 'no panel' };
+
+      const summary = panel.querySelector('[data-testid="meeting-summary-todos"]');
+      const summaryText = summary
+        ? (summary.innerText || summary.textContent || '').trim()
+        : '';
+
+      return { summary: summaryText };
+    })()
+  `;
+}
+
+function clickTextNotesTabScript(): string {
+  return `
+    (() => {
+      const panel = document.querySelector('[data-testid="canvas_panel_container"]');
+      if (!panel) return false;
+      const tabs = panel.querySelectorAll('[role="tab"], .semi-tabs-tab');
+      for (const tab of tabs) {
+        if ((tab.textContent || '').trim().includes('文字')) {
+          tab.click();
+          return true;
+        }
+      }
+      return false;
+    })()
+  `;
+}
+
+function readTextNotesScript(): string {
+  return `
+    (() => {
+      const panel = document.querySelector('[data-testid="canvas_panel_container"]');
+      if (!panel) return '';
+      const textNotes = panel.querySelector('[data-testid="meeting-text-notes"]');
+      if (!textNotes) return '';
+      return (textNotes.innerText || textNotes.textContent || '').trim();
+    })()
+  `;
+}
+
+function normalizeTranscriptLines(text: string): string[] {
+  return text
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean);
+}
+
+function containsLineSequence(haystack: string[], needle: string[]): boolean {
+  if (needle.length === 0) return true;
+  if (needle.length > haystack.length) return false;
+
+  for (let start = 0; start <= haystack.length - needle.length; start += 1) {
+    let matched = true;
+    for (let offset = 0; offset < needle.length; offset += 1) {
+      if (haystack[start + offset] !== needle[offset]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) return true;
+  }
+
+  return false;
+}
+
+export function mergeTranscriptSnapshots(existing: string, incoming: string): string {
+  const currentLines = normalizeTranscriptLines(existing);
+  const nextLines = normalizeTranscriptLines(incoming);
+
+  if (nextLines.length === 0) return currentLines.join('\n');
+  if (currentLines.length === 0) return nextLines.join('\n');
+  if (containsLineSequence(currentLines, nextLines)) return currentLines.join('\n');
+
+  const maxOverlap = Math.min(currentLines.length, nextLines.length);
+  for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+    let matched = true;
+    for (let index = 0; index < overlap; index += 1) {
+      if (currentLines[currentLines.length - overlap + index] !== nextLines[index]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) {
+      return [...currentLines, ...nextLines.slice(overlap)].join('\n');
+    }
+  }
+
+  return [...currentLines, ...nextLines].join('\n');
+}
+
+function clickChapterTabScript(): string {
+  return `
+    (() => {
+      const panel = document.querySelector('[data-testid="canvas_panel_container"]');
+      if (!panel) return false;
+      const tabs = panel.querySelectorAll('[role="tab"], .semi-tabs-tab');
+      for (const tab of tabs) {
+        if ((tab.textContent || '').trim().includes('章节')) {
+          tab.click();
+          return true;
+        }
+      }
+      return false;
+    })()
+  `;
+}
+
+function readChapterScript(): string {
+  return `
+    (() => {
+      const panel = document.querySelector('[data-testid="canvas_panel_container"]');
+      if (!panel) return '';
+      const chapter = panel.querySelector('[data-testid="meeting-ai-chapter"]');
+      if (!chapter) return '';
+      return (chapter.innerText || chapter.textContent || '').trim();
+    })()
+  `;
+}
+
+function triggerTranscriptDownloadScript(): string {
+  return `
+    (() => {
+      const panel = document.querySelector('[data-testid="canvas_panel_container"]');
+      if (!panel) return { error: 'no panel' };
+
+      const downloadIcon = panel.querySelector('[class*="DownloadMeetingAudio"] span[role="img"]');
+      if (!downloadIcon) return { error: 'no download icon' };
+
+      downloadIcon.click();
+      return { clicked: 'icon' };
+    })()
+  `;
+}
+
+function clickTranscriptDownloadBtnScript(): string {
+  return `
+    (() => {
+      const btn = document.querySelector('[data-testid="minutes-download-text-btn"]');
+      if (!btn) return { error: 'no download text btn' };
+      btn.click();
+      return { clicked: 'transcript' };
+    })()
+  `;
+}
+
+export async function openMeetingPanel(page: IPage, conversationId: string): Promise<boolean> {
+  await navigateToConversation(page, conversationId);
+  const clicked = await page.evaluate(clickMeetingCardScript()) as boolean;
+  if (!clicked) return false;
+  await page.wait(2);
+  return true;
+}
+
+export async function getMeetingSummary(page: IPage): Promise<string> {
+  const result = await page.evaluate(readMeetingSummaryScript()) as { summary?: string; error?: string };
+  return result.summary || '';
+}
+
+export async function getMeetingChapters(page: IPage): Promise<string> {
+  await page.evaluate(clickChapterTabScript());
+  await page.wait(1.5);
+  return await page.evaluate(readChapterScript()) as string;
+}
+
+function scrollTextNotesPanelScript(): string {
+  return `
+    (() => {
+      const panel = document.querySelector('[data-testid="canvas_panel_container"]');
+      if (!panel) return 0;
+      const textNotes = panel.querySelector('[data-testid="meeting-text-notes"]');
+      if (!textNotes) return 0;
+
+      const scrollable = textNotes.closest('[class*="overflow"]')
+        || textNotes.parentElement
+        || textNotes;
+      const maxScroll = scrollable.scrollHeight - scrollable.clientHeight;
+      if (maxScroll > 0) {
+        scrollable.scrollTop = scrollable.scrollHeight;
+      }
+      return maxScroll;
+    })()
+  `;
+}
+
+export async function getMeetingTranscript(page: IPage): Promise<string> {
+  await page.evaluate(clickTextNotesTabScript());
+  await page.wait(2);
+
+  let merged = '';
+  let stableRounds = 0;
+  for (let i = 0; i < 10; i++) {
+    await page.evaluate(scrollTextNotesPanelScript());
+    await page.wait(1);
+    const snapshot = await page.evaluate(readTextNotesScript()) as string;
+    const nextMerged = mergeTranscriptSnapshots(merged, snapshot);
+
+    if (nextMerged === merged && snapshot.length > 0) {
+      stableRounds += 1;
+      if (stableRounds >= 2) break;
+    } else {
+      stableRounds = 0;
+      merged = nextMerged;
+    }
+  }
+
+  return merged;
+}
+
+export async function triggerTranscriptDownload(page: IPage): Promise<boolean> {
+  const iconResult = await page.evaluate(triggerTranscriptDownloadScript()) as { clicked?: string; error?: string };
+  if (iconResult.error) return false;
+  await page.wait(1);
+
+  const btnResult = await page.evaluate(clickTranscriptDownloadBtnScript()) as { clicked?: string; error?: string };
+  return !btnResult.error;
+}
+
 export async function startNewDoubaoChat(page: IPage): Promise<string> {
   await ensureDoubaoChatPage(page);
   const clickedLabel = await page.evaluate(clickNewChatScript()) as string;

package/src/clis/douyin/_shared/public-api.ts

@@ -0,0 +1,84 @@
+import type { IPage } from '../../../types.js';
+import { browserFetch } from './browser-fetch.js';
+
+export interface DouyinComment {
+  text?: string;
+  digg_count?: number;
+  user?: {
+    nickname?: string;
+  };
+}
+
+export interface DouyinVideo {
+  aweme_id: string;
+  desc?: string;
+  video?: {
+    duration?: number;
+    play_addr?: {
+      url_list?: string[];
+    };
+  };
+  statistics?: {
+    digg_count?: number;
+  };
+}
+
+export interface DouyinVideoListResponse {
+  aweme_list?: DouyinVideo[];
+}
+
+export interface DouyinCommentListResponse {
+  comments?: DouyinComment[];
+}
+
+export async function fetchDouyinUserVideos(
+  page: IPage,
+  secUid: string,
+  count: number,
+): Promise<DouyinVideo[]> {
+  const params = new URLSearchParams({
+    sec_user_id: secUid,
+    max_cursor: '0',
+    count: String(count),
+    aid: '6383',
+  });
+
+  const data = await browserFetch(
+    page,
+    'GET',
+    `https://www.douyin.com/aweme/v1/web/aweme/post/?${params.toString()}`,
+    {
+      headers: { referer: 'https://www.douyin.com/' },
+    },
+  ) as DouyinVideoListResponse;
+
+  return data.aweme_list || [];
+}
+
+export async function fetchDouyinComments(
+  page: IPage,
+  awemeId: string,
+  count: number,
+): Promise<Array<{ text: string; digg_count: number; nickname: string }>> {
+  const params = new URLSearchParams({
+    aweme_id: awemeId,
+    count: String(count),
+    cursor: '0',
+    aid: '6383',
+  });
+
+  const data = await browserFetch(
+    page,
+    'GET',
+    `https://www.douyin.com/aweme/v1/web/comment/list/?${params.toString()}`,
+    {
+      headers: { referer: 'https://www.douyin.com/' },
+    },
+  ) as DouyinCommentListResponse;
+
+  return (data.comments || []).slice(0, count).map((comment) => ({
+    text: comment.text || '',
+    digg_count: comment.digg_count ?? 0,
+    nickname: comment.user?.nickname || '',
+  }));
+}

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

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { fetchDouyinUserVideosMock, fetchDouyinCommentsMock } = vi.hoisted(() => ({
+  fetchDouyinUserVideosMock: vi.fn(),
+  fetchDouyinCommentsMock: vi.fn(),
+}));
+
+vi.mock('./_shared/public-api.js', () => ({
+  fetchDouyinUserVideos: fetchDouyinUserVideosMock,
+  fetchDouyinComments: fetchDouyinCommentsMock,
+}));
+
+import { getRegistry } from '../../registry.js';
+import { DEFAULT_COMMENT_LIMIT, MAX_USER_VIDEOS_LIMIT, normalizeCommentLimit, normalizeUserVideosLimit } from './user-videos.js';
+
+describe('douyin user-videos', () => {
+  beforeEach(() => {
+    fetchDouyinUserVideosMock.mockReset();
+    fetchDouyinCommentsMock.mockReset();
+  });
+
+  it('registers the command', () => {
+    const registry = getRegistry();
+    const values = [...registry.values()];
+    const command = values.find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+    expect(command).toBeDefined();
+  });
+
+  it('clamps limit to a safe maximum', () => {
+    expect(normalizeUserVideosLimit(100)).toBe(MAX_USER_VIDEOS_LIMIT);
+    expect(normalizeUserVideosLimit(0)).toBe(1);
+    expect(normalizeCommentLimit(99)).toBe(DEFAULT_COMMENT_LIMIT);
+  });
+
+  it('uses shared public-api helpers and applies clamped limits', async () => {
+    const registry = getRegistry();
+    const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+    expect(command?.func).toBeDefined();
+    if (!command?.func) throw new Error('douyin user-videos command not registered');
+
+    fetchDouyinUserVideosMock.mockResolvedValueOnce([
+      {
+        aweme_id: '1',
+        desc: 'test video',
+        video: { duration: 1234, play_addr: { url_list: ['https://example.com/video.mp4'] } },
+        statistics: { digg_count: 9 },
+      },
+    ]);
+    fetchDouyinCommentsMock.mockResolvedValueOnce([
+      { text: 'nice', digg_count: 3, nickname: 'alice' },
+    ]);
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const rows = await command.func(page as any, {
+      sec_uid: 'MS4w-test',
+      limit: 100,
+      comment_limit: 99,
+      with_comments: true,
+    });
+
+    expect(fetchDouyinUserVideosMock).toHaveBeenCalledWith(page, 'MS4w-test', MAX_USER_VIDEOS_LIMIT);
+    expect(fetchDouyinCommentsMock).toHaveBeenCalledWith(page, '1', DEFAULT_COMMENT_LIMIT);
+    expect(rows).toEqual([
+      {
+        index: 1,
+        aweme_id: '1',
+        title: 'test video',
+        duration: 1,
+        digg_count: 9,
+        play_url: 'https://example.com/video.mp4',
+        top_comments: [
+          { text: 'nice', digg_count: 3, nickname: 'alice' },
+        ],
+      },
+    ]);
+  });
+
+  it('skips comment enrichment when with_comments is false', async () => {
+    const registry = getRegistry();
+    const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'user-videos');
+    expect(command?.func).toBeDefined();
+    if (!command?.func) throw new Error('douyin user-videos command not registered');
+
+    fetchDouyinUserVideosMock.mockResolvedValueOnce([
+      {
+        aweme_id: '2',
+        desc: 'plain video',
+        video: { duration: 2000, play_addr: { url_list: ['https://example.com/plain.mp4'] } },
+        statistics: { digg_count: 1 },
+      },
+    ]);
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const rows = await command.func(page as any, {
+      sec_uid: 'MS4w-test',
+      limit: 3,
+      with_comments: false,
+      comment_limit: 5,
+    });
+
+    expect(fetchDouyinCommentsMock).not.toHaveBeenCalled();
+    expect(rows).toEqual([
+      {
+        index: 1,
+        aweme_id: '2',
+        title: 'plain video',
+        duration: 2,
+        digg_count: 1,
+        play_url: 'https://example.com/plain.mp4',
+        top_comments: [],
+      },
+    ]);
+  });
+});

package/src/clis/douyin/user-videos.ts

@@ -0,0 +1,101 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchDouyinComments, fetchDouyinUserVideos, type DouyinVideo } from './_shared/public-api.js';
+
+export const MAX_USER_VIDEOS_LIMIT = 20;
+export const USER_VIDEO_COMMENT_CONCURRENCY = 4;
+export const DEFAULT_COMMENT_LIMIT = 10;
+
+type EnrichedDouyinVideo = DouyinVideo & {
+  top_comments?: Array<{
+    text: string;
+    digg_count: number;
+    nickname: string;
+  }>;
+};
+
+export function normalizeUserVideosLimit(limit: unknown): number {
+  const numeric = Number(limit);
+  if (!Number.isFinite(numeric)) return MAX_USER_VIDEOS_LIMIT;
+  return Math.min(MAX_USER_VIDEOS_LIMIT, Math.max(1, Math.round(numeric)));
+}
+
+export function normalizeCommentLimit(limit: unknown): number {
+  const numeric = Number(limit);
+  if (!Number.isFinite(numeric)) return DEFAULT_COMMENT_LIMIT;
+  return Math.min(DEFAULT_COMMENT_LIMIT, Math.max(1, Math.round(numeric)));
+}
+
+async function mapInBatches<T, R>(
+  items: T[],
+  concurrency: number,
+  mapper: (item: T) => Promise<R>,
+): Promise<R[]> {
+  const results: R[] = [];
+  for (let index = 0; index < items.length; index += concurrency) {
+    const chunk = items.slice(index, index + concurrency);
+    results.push(...(await Promise.all(chunk.map(mapper))));
+  }
+  return results;
+}
+
+async function fetchTopComments(
+  page: IPage,
+  awemeId: string,
+  count: number,
+): Promise<Array<{ text: string; digg_count: number; nickname: string }>> {
+  try {
+    return await fetchDouyinComments(page, awemeId, count);
+  } catch {
+    return [];
+  }
+}
+
+cli({
+  site: 'douyin',
+  name: 'user-videos',
+  description: '获取指定用户的视频列表（含下载地址和热门评论）',
+  domain: 'www.douyin.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'sec_uid', type: 'string', required: true, positional: true, help: '用户 sec_uid（URL 末尾部分）' },
+    { name: 'limit', type: 'int', default: 20, help: '获取数量（最大 20）' },
+    { name: 'with_comments', type: 'bool', default: true, help: '包含热门评论（默认: true）' },
+    { name: 'comment_limit', type: 'int', default: 10, help: '每个视频获取多少条评论（最大 10）' },
+  ],
+  columns: ['index', 'aweme_id', 'title', 'duration', 'digg_count', 'play_url', 'top_comments'],
+  func: async (page: IPage, kwargs) => {
+    const secUid = kwargs.sec_uid as string;
+    const limit = normalizeUserVideosLimit(kwargs.limit);
+    const withComments = kwargs.with_comments !== false;
+    const commentLimit = normalizeCommentLimit(kwargs.comment_limit);
+
+    await page.goto(`https://www.douyin.com/user/${secUid}`);
+    await page.wait(3);
+
+    const awemeList = (await fetchDouyinUserVideos(page, secUid, limit)).slice(0, limit);
+    const videos: EnrichedDouyinVideo[] = withComments
+      ? await mapInBatches(
+          awemeList,
+          USER_VIDEO_COMMENT_CONCURRENCY,
+          async (video) => ({
+            ...video,
+            top_comments: await fetchTopComments(page, video.aweme_id, commentLimit),
+          }),
+        )
+      : awemeList.map((video) => ({ ...video, top_comments: [] }));
+
+    return videos.map((video, index) => {
+      const playUrl = video.video?.play_addr?.url_list?.[0] ?? '';
+      return {
+        index: index + 1,
+        aweme_id: video.aweme_id,
+        title: video.desc ?? '',
+        duration: Math.round((video.video?.duration ?? 0) / 1000),
+        digg_count: video.statistics?.digg_count ?? 0,
+        play_url: playUrl,
+        top_comments: video.top_comments ?? [],
+      };
+    });
+  },
+});