@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/douban/utils.js

@@ -0,0 +1,389 @@
+/**
+ * Douban adapter utilities.
+ */
+import { ArgumentError, CliError, EmptyResultError } from '../../errors.js';
+import { clamp } from '../_shared/common.js';
+const DOUBAN_PHOTO_PAGE_SIZE = 30;
+const MAX_DOUBAN_PHOTOS = 500;
+const clampLimit = (limit) => clamp(limit || 20, 1, 50);
+const clampPhotoLimit = (limit) => clamp(limit || 120, 1, MAX_DOUBAN_PHOTOS);
+async function ensureDoubanReady(page) {
+    const state = await page.evaluate(`
+    (() => {
+      const title = (document.title || '').trim();
+      const href = (location.href || '').trim();
+      const blocked = href.includes('sec.douban.com') || /登录跳转/.test(title) || /异常请求/.test(document.body?.innerText || '');
+      return { blocked, title, href };
+    })()
+  `);
+    if (state?.blocked) {
+        throw new CliError('AUTH_REQUIRED', 'Douban requires a logged-in browser session before these commands can load data.', 'Please sign in to douban.com in the browser that opencli reuses, then rerun the command.');
+    }
+}
+export function normalizeDoubanSubjectId(subjectId) {
+    const normalized = String(subjectId || '').trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw new ArgumentError(`Invalid Douban subject ID: ${subjectId}`);
+    }
+    return normalized;
+}
+export function promoteDoubanPhotoUrl(url, size = 'l') {
+    const normalized = String(url || '').trim();
+    if (!normalized)
+        return '';
+    if (/^[a-z]+:/i.test(normalized) && !/^https?:/i.test(normalized))
+        return '';
+    return normalized.replace(/\/view\/photo\/[^/]+\/public\//, `/view/photo/${size}/public/`);
+}
+export function resolveDoubanPhotoAssetUrl(candidates, baseUrl = '') {
+    for (const candidate of candidates) {
+        const normalized = String(candidate || '').trim();
+        if (!normalized)
+            continue;
+        let resolved = normalized;
+        try {
+            resolved = baseUrl
+                ? new URL(normalized, baseUrl).toString()
+                : new URL(normalized).toString();
+        }
+        catch {
+            resolved = normalized;
+        }
+        if (/^https?:\/\//i.test(resolved)) {
+            return resolved;
+        }
+    }
+    return '';
+}
+export function getDoubanPhotoExtension(url) {
+    const normalized = String(url || '').trim();
+    if (!normalized)
+        return '.jpg';
+    try {
+        const ext = new URL(normalized).pathname.match(/\.(jpe?g|png|gif|webp|avif|bmp)$/i)?.[0];
+        return ext || '.jpg';
+    }
+    catch {
+        const ext = normalized.match(/\.(jpe?g|png|gif|webp|avif|bmp)(?:$|[?#])/i)?.[0];
+        return ext ? ext.replace(/[?#].*$/, '') : '.jpg';
+    }
+}
+export async function loadDoubanSubjectPhotos(page, subjectId, options = {}) {
+    const normalizedId = normalizeDoubanSubjectId(subjectId);
+    const type = String(options.type || 'Rb').trim() || 'Rb';
+    const targetPhotoId = String(options.targetPhotoId || '').trim();
+    const safeLimit = targetPhotoId ? Number.MAX_SAFE_INTEGER : clampPhotoLimit(Number(options.limit) || 120);
+    const resolvePhotoAssetUrlSource = resolveDoubanPhotoAssetUrl.toString();
+    const galleryUrl = `https://movie.douban.com/subject/${normalizedId}/photos?type=${encodeURIComponent(type)}`;
+    await page.goto(galleryUrl);
+    await page.wait(2);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (async () => {
+      const subjectId = ${JSON.stringify(normalizedId)};
+      const type = ${JSON.stringify(type)};
+      const limit = ${safeLimit};
+      const targetPhotoId = ${JSON.stringify(targetPhotoId)};
+      const pageSize = ${DOUBAN_PHOTO_PAGE_SIZE};
+      const resolveDoubanPhotoAssetUrl = ${resolvePhotoAssetUrlSource};
+
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const toAbsoluteUrl = (value) => {
+        if (!value) return '';
+        try {
+          return new URL(value, location.origin).toString();
+        } catch {
+          return value;
+        }
+      };
+      const promotePhotoUrl = (value) => {
+        const absolute = toAbsoluteUrl(value);
+        if (!absolute) return '';
+        if (/^[a-z]+:/i.test(absolute) && !/^https?:/i.test(absolute)) return '';
+        return absolute.replace(/\\/view\\/photo\\/[^/]+\\/public\\//, '/view/photo/l/public/');
+      };
+      const buildPageUrl = (start) => {
+        const url = new URL(location.href);
+        url.searchParams.set('type', type);
+        if (start > 0) url.searchParams.set('start', String(start));
+        else url.searchParams.delete('start');
+        return url.toString();
+      };
+      const getTitle = (doc) => {
+        const raw = normalize(doc.querySelector('#content h1')?.textContent)
+          || normalize(doc.querySelector('title')?.textContent);
+        return raw.replace(/\\s*\\(豆瓣\\)\\s*$/, '');
+      };
+      const extractPhotos = (doc, pageNumber) => {
+        const nodes = Array.from(doc.querySelectorAll('.poster-col3 li, .poster-col3l li, .article li'));
+        const rows = [];
+        for (const node of nodes) {
+          const link = node.querySelector('a[href*="/photos/photo/"]');
+          const img = node.querySelector('img');
+          if (!link || !img) continue;
+
+          const detailUrl = toAbsoluteUrl(link.getAttribute('href') || '');
+          const photoId = detailUrl.match(/\\/photo\\/(\\d+)/)?.[1] || '';
+          const thumbUrl = resolveDoubanPhotoAssetUrl([
+            img.getAttribute('data-origin'),
+            img.getAttribute('data-src'),
+            img.getAttribute('src'),
+          ], location.href);
+          const imageUrl = promotePhotoUrl(thumbUrl);
+          const title = normalize(link.getAttribute('title'))
+            || normalize(img.getAttribute('alt'))
+            || (photoId ? 'photo_' + photoId : 'photo_' + String(rows.length + 1));
+
+          if (!detailUrl || !thumbUrl || !imageUrl) continue;
+
+          rows.push({
+            photoId,
+            title,
+            imageUrl,
+            thumbUrl,
+            detailUrl,
+            page: pageNumber,
+          });
+        }
+        return rows;
+      };
+
+      const subjectTitle = getTitle(document);
+      const seen = new Set();
+      const photos = [];
+
+      for (let pageIndex = 0; photos.length < limit; pageIndex += 1) {
+        let doc = document;
+        if (pageIndex > 0) {
+          const response = await fetch(buildPageUrl(pageIndex * pageSize), { credentials: 'include' });
+          if (!response.ok) break;
+          const html = await response.text();
+          doc = new DOMParser().parseFromString(html, 'text/html');
+        }
+
+        const pagePhotos = extractPhotos(doc, pageIndex + 1);
+        if (!pagePhotos.length) break;
+
+        let appended = 0;
+        let foundTarget = false;
+        for (const photo of pagePhotos) {
+          const key = photo.photoId || photo.detailUrl || photo.imageUrl;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          photos.push({
+            index: photos.length + 1,
+            ...photo,
+          });
+          appended += 1;
+          if (targetPhotoId && photo.photoId === targetPhotoId) {
+            foundTarget = true;
+            break;
+          }
+          if (photos.length >= limit) break;
+        }
+
+        if (foundTarget || pagePhotos.length < pageSize || appended === 0) break;
+      }
+
+      return {
+        subjectId,
+        subjectTitle,
+        type,
+        photos,
+      };
+    })()
+  `);
+    const photos = Array.isArray(data?.photos) ? data.photos : [];
+    if (!photos.length) {
+        throw new EmptyResultError('douban photos', 'No photos found. Try a different subject ID or a different --type value such as Rb.');
+    }
+    return {
+        subjectId: normalizedId,
+        subjectTitle: String(data?.subjectTitle || '').trim(),
+        type,
+        photos,
+    };
+}
+export async function loadDoubanBookHot(page, limit) {
+    const safeLimit = clampLimit(limit);
+    await page.goto('https://book.douban.com/chart');
+    await page.wait(4);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const books = [];
+      for (const el of Array.from(document.querySelectorAll('.media.clearfix'))) {
+        try {
+          const titleEl = el.querySelector('h2 a[href*="/subject/"]');
+          const title = normalize(titleEl?.textContent);
+          let url = titleEl?.getAttribute('href') || '';
+          if (!title || !url) continue;
+          if (!url.startsWith('http')) url = 'https://book.douban.com' + url;
+
+          const info = normalize(el.querySelector('.subject-abstract, .pl, .pub')?.textContent);
+          const infoParts = info.split('/').map((part) => part.trim()).filter(Boolean);
+          const ratingText = normalize(el.querySelector('.subject-rating .font-small, .rating_nums, .rating')?.textContent);
+          const quote = Array.from(el.querySelectorAll('.subject-tags .tag'))
+            .map((node) => normalize(node.textContent))
+            .filter(Boolean)
+            .join(' / ');
+
+          books.push({
+            rank: parseInt(normalize(el.querySelector('.green-num-box')?.textContent), 10) || books.length + 1,
+            title,
+            rating: parseFloat(ratingText) || 0,
+            quote,
+            author: infoParts[0] || '',
+            publisher: infoParts.find((part) => /出版社|出版公司|Press/i.test(part)) || infoParts[2] || '',
+            year: infoParts.find((part) => /\\d{4}(?:-\\d{1,2})?/.test(part))?.match(/\\d{4}/)?.[0] || '',
+            price: infoParts.find((part) => /元|USD|\\$|￥/.test(part)) || '',
+            url,
+            cover: el.querySelector('img')?.getAttribute('src') || '',
+          });
+        } catch {}
+      }
+      return books.slice(0, ${safeLimit});
+    })()
+  `);
+    return Array.isArray(data) ? data : [];
+}
+export async function loadDoubanMovieHot(page, limit) {
+    const safeLimit = clampLimit(limit);
+    await page.goto('https://movie.douban.com/chart');
+    await page.wait(4);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const results = [];
+      for (const el of Array.from(document.querySelectorAll('.item'))) {
+        const titleEl = el.querySelector('.pl2 a');
+        const title = normalize(titleEl?.textContent);
+        let url = titleEl?.getAttribute('href') || '';
+        if (!title || !url) continue;
+        if (!url.startsWith('http')) url = 'https://movie.douban.com' + url;
+
+        const info = normalize(el.querySelector('.pl2 p')?.textContent);
+        const infoParts = info.split('/').map((part) => part.trim()).filter(Boolean);
+        const releaseIndex = (() => {
+          for (let i = infoParts.length - 1; i >= 0; i -= 1) {
+            if (/\\d{4}-\\d{2}-\\d{2}|\\d{4}\\/\\d{2}\\/\\d{2}/.test(infoParts[i])) return i;
+          }
+          return -1;
+        })();
+        const directorPart = releaseIndex >= 1 ? infoParts[releaseIndex - 1] : '';
+        const regionPart = releaseIndex >= 2 ? infoParts[releaseIndex - 2] : '';
+        const yearMatch = info.match(/\\b(19|20)\\d{2}\\b/);
+        results.push({
+          rank: results.length + 1,
+          title,
+          rating: parseFloat(normalize(el.querySelector('.rating_nums')?.textContent)) || 0,
+          quote: normalize(el.querySelector('.inq')?.textContent),
+          director: directorPart.replace(/^导演:\\s*/, ''),
+          year: yearMatch?.[0] || '',
+          region: regionPart,
+          url,
+          cover: el.querySelector('img')?.getAttribute('src') || '',
+        });
+        if (results.length >= ${safeLimit}) break;
+      }
+      return results;
+    })()
+  `);
+    return Array.isArray(data) ? data : [];
+}
+export async function searchDouban(page, type, keyword, limit) {
+    const safeLimit = clampLimit(limit);
+    await page.goto(`https://search.douban.com/${encodeURIComponent(type)}/subject_search?search_text=${encodeURIComponent(keyword)}`);
+    await page.wait(2);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (async () => {
+      const type = ${JSON.stringify(type)};
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const seen = new Set();
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+      for (let i = 0; i < 20; i += 1) {
+        if (document.querySelector('.item-root .title-text, .item-root .title a')) break;
+        await sleep(300);
+      }
+
+      const items = Array.from(document.querySelectorAll('.item-root'));
+
+      const results = [];
+      for (const el of items) {
+        const titleEl = el.querySelector('.title-text, .title a, a[title]');
+        const title = normalize(titleEl?.textContent) || normalize(titleEl?.getAttribute('title'));
+        let url = titleEl?.getAttribute('href') || '';
+        if (!title || !url) continue;
+        if (!url.startsWith('http')) url = 'https://search.douban.com' + url;
+        if (!url.includes('/subject/') || seen.has(url)) continue;
+        seen.add(url);
+        const ratingText = normalize(el.querySelector('.rating_nums')?.textContent);
+        const abstract = normalize(
+          el.querySelector('.meta.abstract, .meta, .abstract, p')?.textContent,
+        );
+        results.push({
+          rank: results.length + 1,
+          id: url.match(/subject\\/(\\d+)/)?.[1] || '',
+          type,
+          title,
+          rating: ratingText.includes('.') ? parseFloat(ratingText) : 0,
+          abstract: abstract.slice(0, 100) + (abstract.length > 100 ? '...' : ''),
+          url,
+          cover: el.querySelector('img')?.getAttribute('src') || '',
+        });
+        if (results.length >= ${safeLimit}) break;
+      }
+      return results;
+    })()
+  `);
+    return Array.isArray(data) ? data : [];
+}
+/**
+ * Get current user's Douban ID from movie.douban.com/mine page
+ */
+export async function getSelfUid(page) {
+    await page.goto('https://movie.douban.com/mine');
+    await page.wait({ time: 2 });
+    const uid = await page.evaluate(`
+    (() => {
+      // 方案1: 尝试从全局变量获取
+      if (window.__DATA__ && window.__DATA__.uid) {
+        return window.__DATA__.uid;
+      }
+      
+      // 方案2: 从导航栏用户链接获取
+      const navUserLink = document.querySelector('.nav-user-account a');
+      if (navUserLink) {
+        const href = navUserLink.href || '';
+        const match = href.match(/people\\/([^/]+)/);
+        if (match) return match[1];
+      }
+      
+      // 方案3: 从页面中的个人主页链接获取
+      const profileLink = document.querySelector('a[href*="/people/"]');
+      if (profileLink) {
+        const href = profileLink.getAttribute('href') || profileLink.href || '';
+        const match = href.match(/people\\/([^/]+)/);
+        if (match) return match[1];
+      }
+      
+      // 方案4: 从头部用户名区域获取
+      const userLink = document.querySelector('.global-nav-items a[href*="/people/"]');
+      if (userLink) {
+        const href = userLink.getAttribute('href') || userLink.href || '';
+        const match = href.match(/people\\/([^/]+)/);
+        if (match) return match[1];
+      }
+      
+      return '';
+    })()
+  `);
+    if (!uid) {
+        throw new Error('Not logged in to Douban. Please login in Chrome first.');
+    }
+    return uid;
+}

package/vendor/opencli/dist/clis/douban/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/douban/utils.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getDoubanPhotoExtension, loadDoubanSubjectPhotos, normalizeDoubanSubjectId, promoteDoubanPhotoUrl, resolveDoubanPhotoAssetUrl, } from './utils.js';
+describe('douban utils', () => {
+    it('normalizes valid subject ids', () => {
+        expect(normalizeDoubanSubjectId(' 30382501 ')).toBe('30382501');
+    });
+    it('rejects invalid subject ids', () => {
+        expect(() => normalizeDoubanSubjectId('tt30382501')).toThrow('Invalid Douban subject ID');
+    });
+    it('promotes thumbnail urls to large photo urls', () => {
+        expect(promoteDoubanPhotoUrl('https://img1.doubanio.com/view/photo/m/public/p2913450214.webp')).toBe('https://img1.doubanio.com/view/photo/l/public/p2913450214.webp');
+        expect(promoteDoubanPhotoUrl('https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2578474613.jpg')).toBe('https://img9.doubanio.com/view/photo/l/public/p2578474613.jpg');
+    });
+    it('rejects non-http photo urls during promotion', () => {
+        expect(promoteDoubanPhotoUrl('data:image/gif;base64,abc')).toBe('');
+    });
+    it('prefers lazy-loaded photo urls over data placeholders', () => {
+        expect(resolveDoubanPhotoAssetUrl([
+            '',
+            'https://img1.doubanio.com/view/photo/m/public/p2913450214.webp',
+            'data:image/gif;base64,abc',
+        ], 'https://movie.douban.com/subject/30382501/photos?type=Rb')).toBe('https://img1.doubanio.com/view/photo/m/public/p2913450214.webp');
+    });
+    it('drops unsupported non-http photo urls when no real image url exists', () => {
+        expect(resolveDoubanPhotoAssetUrl(['data:image/gif;base64,abc', 'blob:https://movie.douban.com/example'], 'https://movie.douban.com/subject/30382501/photos?type=Rb')).toBe('');
+    });
+    it('removes the default photo cap when scanning for an exact photo id', async () => {
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce({ blocked: false, title: 'Some Movie', href: 'https://movie.douban.com/subject/30382501/photos?type=Rb' })
+            .mockResolvedValueOnce({
+            subjectId: '30382501',
+            subjectTitle: 'The Wandering Earth 2',
+            type: 'Rb',
+            photos: [
+                {
+                    index: 731,
+                    photoId: '2913450215',
+                    title: 'Character poster',
+                    imageUrl: 'https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg',
+                    thumbUrl: 'https://img1.doubanio.com/view/photo/m/public/p2913450215.jpg',
+                    detailUrl: 'https://movie.douban.com/photos/photo/2913450215/',
+                    page: 25,
+                },
+            ],
+        });
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+        };
+        await loadDoubanSubjectPhotos(page, '30382501', {
+            type: 'Rb',
+            targetPhotoId: '2913450215',
+        });
+        const scanScript = evaluate.mock.calls[1]?.[0];
+        expect(scanScript).toContain('const targetPhotoId = "2913450215";');
+        expect(scanScript).toContain(`const limit = ${Number.MAX_SAFE_INTEGER};`);
+        expect(scanScript).toContain('for (let pageIndex = 0; photos.length < limit; pageIndex += 1)');
+    });
+    it('keeps image extensions when download urls contain query params', () => {
+        expect(getDoubanPhotoExtension('https://img1.doubanio.com/view/photo/l/public/p2913450214.webp?foo=1')).toBe('.webp');
+        expect(getDoubanPhotoExtension('https://img1.doubanio.com/view/photo/l/public/p2913450214.jpeg')).toBe('.jpeg');
+    });
+});

package/vendor/opencli/dist/clis/doubao/ask.d.ts

@@ -0,0 +1 @@
+export declare const askCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao/ask.js

@@ -0,0 +1,35 @@
+import { cli, Strategy } from '../../registry.js';
+import { DOUBAO_DOMAIN, getDoubaoTranscriptLines, getDoubaoVisibleTurns, sendDoubaoMessage, waitForDoubaoResponse } from './utils.js';
+export const askCommand = cli({
+    site: 'doubao',
+    name: 'ask',
+    description: 'Send a prompt and wait for the Doubao response',
+    domain: DOUBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    timeoutSeconds: 180,
+    args: [
+        { name: 'text', required: true, positional: true, help: 'Prompt to send' },
+        { name: 'timeout', required: false, help: 'Max seconds to wait (default: 60)', default: '60' },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        const timeout = parseInt(kwargs.timeout, 10) || 60;
+        const beforeTurns = await getDoubaoVisibleTurns(page);
+        const beforeLines = await getDoubaoTranscriptLines(page);
+        await sendDoubaoMessage(page, text);
+        const response = await waitForDoubaoResponse(page, beforeLines, beforeTurns, text, timeout);
+        if (!response) {
+            return [
+                { Role: 'User', Text: text },
+                { Role: 'System', Text: `No response within ${timeout}s. Doubao may still be generating.` },
+            ];
+        }
+        return [
+            { Role: 'User', Text: text },
+            { Role: 'Assistant', Text: response },
+        ];
+    },
+});

package/vendor/opencli/dist/clis/doubao/detail.d.ts

@@ -0,0 +1 @@
+export declare const detailCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao/detail.js

@@ -0,0 +1,33 @@
+import { cli, Strategy } from '../../registry.js';
+import { DOUBAO_DOMAIN, getConversationDetail, parseDoubaoConversationId } from './utils.js';
+export const detailCommand = cli({
+    site: 'doubao',
+    name: 'detail',
+    description: 'Read a specific Doubao conversation by ID',
+    domain: DOUBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Conversation ID (numeric or full URL)' },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const conversationId = parseDoubaoConversationId(kwargs.id);
+        const { messages, meeting } = await getConversationDetail(page, conversationId);
+        if (messages.length === 0 && !meeting) {
+            return [{ Role: 'System', Text: 'No messages found. Verify the conversation ID.' }];
+        }
+        const result = [];
+        if (meeting) {
+            result.push({
+                Role: 'Meeting',
+                Text: `${meeting.title}${meeting.time ? ` (${meeting.time})` : ''}`,
+            });
+        }
+        for (const m of messages) {
+            result.push({ Role: m.Role, Text: m.Text });
+        }
+        return result;
+    },
+});

package/vendor/opencli/dist/clis/doubao/detail.test.d.ts

@@ -0,0 +1 @@
+import './detail.js';

package/vendor/opencli/dist/clis/doubao/detail.test.js

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockGetConversationDetail } = vi.hoisted(() => ({
+    mockGetConversationDetail: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        getConversationDetail: mockGetConversationDetail,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './detail.js';
+describe('doubao detail', () => {
+    const detail = getRegistry().get('doubao/detail');
+    beforeEach(() => {
+        mockGetConversationDetail.mockReset();
+    });
+    it('returns meeting metadata even when the conversation has no chat messages', async () => {
+        mockGetConversationDetail.mockResolvedValue({
+            messages: [],
+            meeting: {
+                title: 'Weekly Sync',
+                time: '2026-03-28 10:00',
+            },
+        });
+        const result = await detail.func({}, { id: '1234567890' });
+        expect(result).toEqual([
+            { Role: 'Meeting', Text: 'Weekly Sync (2026-03-28 10:00)' },
+        ]);
+    });
+    it('still returns an error row for a truly empty conversation', async () => {
+        mockGetConversationDetail.mockResolvedValue({
+            messages: [],
+            meeting: null,
+        });
+        const result = await detail.func({}, { id: '1234567890' });
+        expect(result).toEqual([
+            { Role: 'System', Text: 'No messages found. Verify the conversation ID.' },
+        ]);
+    });
+});

package/vendor/opencli/dist/clis/doubao/history.d.ts

@@ -0,0 +1 @@
+export declare const historyCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/doubao/history.js

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import { DOUBAO_DOMAIN, getDoubaoConversationList } from './utils.js';
+export const historyCommand = cli({
+    site: 'doubao',
+    name: 'history',
+    description: 'List conversation history from Doubao sidebar',
+    domain: DOUBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'limit', required: false, help: 'Max number of conversations to show', default: '50' },
+    ],
+    columns: ['Index', 'Id', 'Title', 'Url'],
+    func: async (page, kwargs) => {
+        const limit = parseInt(kwargs.limit, 10) || 50;
+        const conversations = await getDoubaoConversationList(page);
+        if (conversations.length === 0) {
+            return [{ Index: 0, Id: '', Title: 'No conversation history found. Make sure you are logged in.', Url: '' }];
+        }
+        return conversations.slice(0, limit).map((conv, i) => ({
+            Index: i + 1,
+            Id: conv.Id,
+            Title: conv.Title,
+            Url: conv.Url,
+        }));
+    },
+});

package/vendor/opencli/dist/clis/doubao/history.test.d.ts

@@ -0,0 +1 @@
+import './history.js';

package/vendor/opencli/dist/clis/doubao/history.test.js

@@ -0,0 +1,37 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockGetDoubaoConversationList } = vi.hoisted(() => ({
+    mockGetDoubaoConversationList: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        getDoubaoConversationList: mockGetDoubaoConversationList,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './history.js';
+describe('doubao history', () => {
+    const history = getRegistry().get('doubao/history');
+    beforeEach(() => {
+        mockGetDoubaoConversationList.mockReset();
+    });
+    it('includes the conversation id in the tabular output', async () => {
+        mockGetDoubaoConversationList.mockResolvedValue([
+            {
+                Id: '1234567890123',
+                Title: 'Weekly Sync',
+                Url: 'https://www.doubao.com/chat/1234567890123',
+            },
+        ]);
+        const result = await history.func({}, {});
+        expect(result).toEqual([
+            {
+                Index: 1,
+                Id: '1234567890123',
+                Title: 'Weekly Sync',
+                Url: 'https://www.doubao.com/chat/1234567890123',
+            },
+        ]);
+    });
+});

package/vendor/opencli/dist/clis/doubao/meeting-summary.d.ts

@@ -0,0 +1 @@
+export declare const meetingSummaryCommand: import("../../registry.js").CliCommand;