@jackwener/opencli 1.7.2 → 1.7.4

package/clis/douban/utils.js

@@ -7,6 +7,79 @@ 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);
+const DOUBAN_SEARCH_READY_SELECTOR = '.item-root .title-text, .item-root .title a, .result-list .result-item h3 a';
+const normalizeText = (value) => String(value || '').replace(/\s+/g, ' ').trim();
+function firstNonEmpty(values) {
+    for (const value of values) {
+        const normalized = normalizeText(value);
+        if (normalized)
+            return normalized;
+    }
+    return '';
+}
+function splitDoubanPeople(value) {
+    return normalizeText(value)
+        .split(/\s*\/\s*/)
+        .map((entry) => normalizeText(entry))
+        .filter(Boolean);
+}
+function parseDoubanBookInfoText(infoText) {
+    const lines = String(infoText || '')
+        .replace(/\r/g, '\n')
+        .split('\n')
+        .map((line) => normalizeText(line))
+        .filter(Boolean);
+    const map = {};
+    for (const line of lines) {
+        const match = line.match(/^([^:：]+)\s*[:：]\s*(.*)$/);
+        if (!match)
+            continue;
+        const label = normalizeText(match[1]);
+        const value = normalizeText(match[2]);
+        if (!label)
+            continue;
+        map[label] = value;
+    }
+    return map;
+}
+function parseDoubanRating(value) {
+    const normalized = normalizeText(value);
+    if (!normalized)
+        return 0;
+    const parsed = Number.parseFloat(normalized);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function parseDoubanCount(value) {
+    const normalized = normalizeText(value).replace(/[^\d]/g, '');
+    if (!normalized)
+        return 0;
+    const parsed = Number.parseInt(normalized, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function parseDoubanPageCount(value) {
+    const match = normalizeText(value).match(/(\d+)/);
+    if (!match)
+        return null;
+    const parsed = Number.parseInt(match[1], 10);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function extractDoubanPublishYear(value) {
+    const match = normalizeText(value).match(/\b(19|20)\d{2}\b/);
+    return match?.[0] || '';
+}
+function splitDoubanTitle(fullTitle) {
+    const normalized = normalizeText(fullTitle);
+    if (!normalized)
+        return { title: '', originalTitle: '' };
+    const match = normalized.match(/^([\u4e00-\u9fff\u3000-\u303f\uff00-\uffef]+(?:\s*[\u4e00-\u9fff\u3000-\u303f\uff00-\uffef·：:！？]+)*)\s+(.+)$/);
+    if (!match) {
+        return { title: normalized, originalTitle: '' };
+    }
+    return {
+        title: normalizeText(match[1]),
+        originalTitle: normalizeText(match[2]),
+    };
+}
 async function ensureDoubanReady(page) {
     const state = await page.evaluate(`
     (() => {
@@ -20,6 +93,34 @@ async function ensureDoubanReady(page) {
         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.');
     }
 }
+function isDetachedPageError(error) {
+    const message = error instanceof Error ? error.message : String(error || '');
+    return /Detached while handling command|Debugger is not attached to the tab|Target closed|No tab with id/i.test(message);
+}
+async function withDetachedRetry(task, options = {}) {
+    const attempts = Math.max(1, options.attempts || 2);
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            return await task();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= attempts - 1 || !isDetachedPageError(error)) {
+                throw error;
+            }
+        }
+    }
+    throw lastError;
+}
+function buildDoubanSearchUrl(type, keyword) {
+    const url = new URL(`https://search.douban.com/${encodeURIComponent(type)}/subject_search`);
+    url.searchParams.set('search_text', String(keyword || ''));
+    if (String(type || '').trim() === 'book') {
+        url.searchParams.set('cat', '1001');
+    }
+    return url.toString();
+}
 export function normalizeDoubanSubjectId(subjectId) {
     const normalized = String(subjectId || '').trim();
     if (!/^\d+$/.test(normalized)) {
@@ -68,6 +169,144 @@ export function getDoubanPhotoExtension(url) {
         return ext ? ext.replace(/[?#].*$/, '') : '.jpg';
     }
 }
+export function normalizeDoubanBookSubject(raw) {
+    const info = parseDoubanBookInfoText(raw?.infoText);
+    const title = firstNonEmpty([raw?.title]);
+    const subtitle = firstNonEmpty([raw?.subtitle, info['副标题']]);
+    const originalTitle = firstNonEmpty([raw?.originalTitle, info['原作名']]);
+    const authors = splitDoubanPeople(firstNonEmpty([info['作者']]));
+    const translators = splitDoubanPeople(firstNonEmpty([info['译者']]));
+    const publisher = firstNonEmpty([info['出版社'], info['出品方']]);
+    const publishDate = firstNonEmpty([info['出版年']]);
+    const publishYear = extractDoubanPublishYear(publishDate);
+    const pageCount = parseDoubanPageCount(info['页数']);
+    const binding = firstNonEmpty([info['装帧']]);
+    const price = firstNonEmpty([info['定价']]);
+    const series = firstNonEmpty([info['丛书']]);
+    const isbnRaw = firstNonEmpty([info['ISBN']]).replace(/[^\dxX]/g, '');
+    const isbn10 = isbnRaw.length === 10 ? isbnRaw : '';
+    const isbn13 = isbnRaw.length === 13 ? isbnRaw : '';
+    return {
+        id: normalizeDoubanSubjectId(raw?.id),
+        type: 'book',
+        title,
+        subtitle,
+        originalTitle,
+        authors,
+        translators,
+        publisher,
+        publishDate,
+        publishYear,
+        pageCount,
+        binding,
+        price,
+        series,
+        isbn10,
+        isbn13,
+        rating: parseDoubanRating(raw?.rating),
+        ratingCount: parseDoubanCount(raw?.ratingCount),
+        summary: normalizeText(raw?.summary),
+        cover: firstNonEmpty([raw?.cover]),
+        url: firstNonEmpty([raw?.url]),
+    };
+}
+async function loadDoubanMovieSubject(page, subjectId) {
+    const normalizedId = normalizeDoubanSubjectId(subjectId);
+    const data = await withDetachedRetry(async () => {
+        await page.goto(`https://movie.douban.com/subject/${normalizedId}/`, { waitUntil: 'load', settleMs: 1500 });
+        await ensureDoubanReady(page);
+        await page.wait({ selector: 'span[property="v:itemreviewed"], #info', timeout: 8 }).catch(() => { });
+        return page.evaluate(`
+    (() => {
+      const id = ${JSON.stringify(normalizedId)};
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const { title, originalTitle } = (${splitDoubanTitle.toString()})(normalize(document.querySelector('span[property="v:itemreviewed"]')?.textContent || ''));
+      const year = normalize(document.querySelector('.year')?.textContent).replace(/[()（）]/g, '');
+      const rating = parseFloat(normalize(document.querySelector('strong[property="v:average"]')?.textContent || '0')) || 0;
+      const ratingCount = parseInt(normalize(document.querySelector('span[property="v:votes"]')?.textContent || '0'), 10) || 0;
+      const genres = Array.from(document.querySelectorAll('span[property="v:genre"]'))
+        .map((node) => normalize(node.textContent))
+        .filter(Boolean)
+        .join(',');
+      const directors = Array.from(document.querySelectorAll('a[rel="v:directedBy"]'))
+        .map((node) => normalize(node.textContent))
+        .filter(Boolean)
+        .join(',');
+      const casts = Array.from(document.querySelectorAll('a[rel="v:starring"]'))
+        .slice(0, 5)
+        .map((node) => normalize(node.textContent))
+        .filter(Boolean);
+      const infoText = document.querySelector('#info')?.textContent || '';
+      let country = [];
+      const countryMatch = infoText.match(/制片国家\\/地区:\\s*([^\\n]+)/);
+      if (countryMatch) {
+        country = countryMatch[1].trim().split(/\\s*\\/\\s*/).filter(Boolean);
+      }
+      const durationRaw = normalize(document.querySelector('span[property="v:runtime"]')?.textContent || '');
+      const durationMatch = durationRaw.match(/(\\d+)/);
+      const summary = normalize(document.querySelector('span[property="v:summary"]')?.textContent || '');
+      return {
+        id,
+        type: 'movie',
+        title,
+        originalTitle,
+        year,
+        rating,
+        ratingCount,
+        genres,
+        directors,
+        casts,
+        country,
+        duration: durationMatch ? parseInt(durationMatch[1], 10) : null,
+        summary: summary.slice(0, 200),
+        url: 'https://movie.douban.com/subject/' + id + '/',
+      };
+    })()
+  `);
+    });
+    return data;
+}
+async function loadDoubanBookSubject(page, subjectId) {
+    const normalizedId = normalizeDoubanSubjectId(subjectId);
+    const data = await withDetachedRetry(async () => {
+        await page.goto(`https://book.douban.com/subject/${normalizedId}/`, { waitUntil: 'load', settleMs: 1500 });
+        await ensureDoubanReady(page);
+        await page.wait({ selector: 'h1 span, #info', timeout: 8 }).catch(() => { });
+        return page.evaluate(`
+    (() => {
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const pickSummary = () => {
+        const nodes = Array.from(document.querySelectorAll('#link-report .intro, .related_info .intro'));
+        for (let i = nodes.length - 1; i >= 0; i -= 1) {
+          const text = normalize(nodes[i]?.textContent);
+          if (text) return text;
+        }
+        return '';
+      };
+      return {
+        id: ${JSON.stringify(normalizedId)},
+        title: normalize(document.querySelector('h1 span')?.textContent || document.querySelector('h1')?.textContent || ''),
+        subtitle: '',
+        originalTitle: '',
+        infoText: document.querySelector('#info')?.innerText || document.querySelector('#info')?.textContent || '',
+        rating: normalize(document.querySelector('strong.rating_num, strong[property="v:average"]')?.textContent || ''),
+        ratingCount: normalize(document.querySelector('a.rating_people > span, span[property="v:votes"]')?.textContent || ''),
+        summary: pickSummary(),
+        cover: document.querySelector('#mainpic img')?.getAttribute('src') || '',
+        url: location.href,
+      };
+    })()
+  `);
+    });
+    return normalizeDoubanBookSubject(data);
+}
+export async function loadDoubanSubjectDetail(page, subjectId, subjectType = 'movie') {
+    const type = String(subjectType || 'movie').trim() === 'book' ? 'book' : 'movie';
+    if (type === 'book') {
+        return loadDoubanBookSubject(page, subjectId);
+    }
+    return loadDoubanMovieSubject(page, subjectId);
+}
 export async function loadDoubanSubjectPhotos(page, subjectId, options = {}) {
     const normalizedId = normalizeDoubanSubjectId(subjectId);
     const type = String(options.type || 'Rb').trim() || 'Rb';
@@ -293,42 +532,71 @@ export async function loadDoubanMovieHot(page, limit) {
   `);
     return Array.isArray(data) ? data : [];
 }
+export function inferDoubanSearchResultType(searchType, item = {}) {
+    const fallbackType = String(searchType || '').trim() || 'movie';
+    if (fallbackType !== 'movie') {
+        return fallbackType;
+    }
+    const moreUrl = String(item.moreUrl || item.more_url || '').trim();
+    const isTv = moreUrl.match(/is_tv:\s*['"]?([01])['"]?/)?.[1] || '';
+    if (isTv === '1') {
+        return 'tvshow';
+    }
+    const labels = Array.isArray(item.labels)
+        ? item.labels
+            .map((label) => typeof label === 'string' ? label.trim() : String(label?.text || '').trim())
+            .filter(Boolean)
+        : [];
+    return labels.includes('剧集') ? 'tvshow' : fallbackType;
+}
 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(`
+    const inferDoubanSearchResultTypeSource = inferDoubanSearchResultType.toString();
+    const searchUrl = buildDoubanSearchUrl(type, keyword);
+    const data = await withDetachedRetry(async () => {
+        await page.goto(searchUrl, { waitUntil: 'load', settleMs: 1500 });
+        await ensureDoubanReady(page);
+        await page.wait({ selector: DOUBAN_SEARCH_READY_SELECTOR, timeout: 8 }).catch(() => { });
+        return page.evaluate(`
     (async () => {
       const type = ${JSON.stringify(type)};
+      const inferDoubanSearchResultType = ${inferDoubanSearchResultTypeSource};
       const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
       const seen = new Set();
       const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      const rawItems = Array.isArray(window.__DATA__?.items) ? window.__DATA__.items : [];
+      const rawItemsById = new Map(
+        rawItems
+          .map((item) => [String(item?.id || '').trim(), item])
+          .filter(([id]) => id),
+      );
 
       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 items = Array.from(document.querySelectorAll('.item-root, .result-list .result-item'));
 
       const results = [];
       for (const el of items) {
-        const titleEl = el.querySelector('.title-text, .title a, a[title]');
+        const titleEl = el.querySelector('.title-text, .title a, .title h3 a, h3 a, a[title]');
         const title = normalize(titleEl?.textContent) || normalize(titleEl?.getAttribute('title'));
-        let url = titleEl?.getAttribute('href') || '';
+        let url = titleEl?.getAttribute('href') || el.querySelector('a[href*="/subject/"]')?.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 id = url.match(/subject\\/(\\d+)/)?.[1] || '';
+        const rawItem = rawItemsById.get(id) || {};
         const ratingText = normalize(el.querySelector('.rating_nums')?.textContent);
         const abstract = normalize(
-          el.querySelector('.meta.abstract, .meta, .abstract, p')?.textContent,
+          el.querySelector('.meta.abstract, .meta, .abstract, .subject-abstract, p')?.textContent,
         );
         results.push({
           rank: results.length + 1,
-          id: url.match(/subject\\/(\\d+)/)?.[1] || '',
-          type,
+          id,
+          type: inferDoubanSearchResultType(type, rawItem),
           title,
           rating: ratingText.includes('.') ? parseFloat(ratingText) : 0,
           abstract: abstract.slice(0, 100) + (abstract.length > 100 ? '...' : ''),
@@ -340,6 +608,7 @@ export async function searchDouban(page, type, keyword, limit) {
       return results;
     })()
   `);
+    });
     return Array.isArray(data) ? data : [];
 }
 /**

package/clis/douban/utils.test.js

@@ -1,19 +1,105 @@
+import vm from 'node:vm';
 import { describe, expect, it, vi } from 'vitest';
-import { getDoubanPhotoExtension, loadDoubanSubjectPhotos, normalizeDoubanSubjectId, promoteDoubanPhotoUrl, resolveDoubanPhotoAssetUrl, } from './utils.js';
+import {
+    getDoubanPhotoExtension,
+    inferDoubanSearchResultType,
+    loadDoubanSubjectDetail,
+    loadDoubanSubjectPhotos,
+    normalizeDoubanBookSubject,
+    normalizeDoubanSubjectId,
+    promoteDoubanPhotoUrl,
+    resolveDoubanPhotoAssetUrl,
+    searchDouban,
+} from './utils.js';
+
+function createFakeNode(text = '', attrs = {}) {
+    return {
+        textContent: text,
+        getAttribute(name) {
+            return attrs[name] || '';
+        },
+    };
+}
+
+function createFakeSearchItem({ title, url, rating, abstract, cover }) {
+    return {
+        querySelector(selector) {
+            if (selector === '.title-text, .title a, .title h3 a, h3 a, a[title]') {
+                return createFakeNode(title, { href: url, title });
+            }
+            if (selector === '.rating_nums') {
+                return createFakeNode(rating);
+            }
+            if (selector === '.meta.abstract, .meta, .abstract, .subject-abstract, p') {
+                return createFakeNode(abstract);
+            }
+            if (selector === 'a[href*="/subject/"]') {
+                return createFakeNode('', { href: url });
+            }
+            if (selector === 'img') {
+                return createFakeNode('', { src: cover });
+            }
+            return null;
+        },
+    };
+}
+
+async function runSearchEvaluate(script, rawItems, domItems) {
+    const document = {
+        querySelector(selector) {
+            if (selector === '.item-root .title-text, .item-root .title a') {
+                return domItems[0]?.querySelector('.title-text, .title a, .title h3 a, h3 a, a[title]') || null;
+            }
+            if (selector === '.item-root .title-text, .item-root .title a, .result-list .result-item h3 a') {
+                return domItems[0]?.querySelector('.title-text, .title a, .title h3 a, h3 a, a[title]') || null;
+            }
+            return null;
+        },
+        querySelectorAll(selector) {
+            if (selector === '.item-root') {
+                return domItems;
+            }
+            if (selector === '.item-root, .result-list .result-item') {
+                return domItems;
+            }
+            return [];
+        },
+    };
+
+    return vm.runInNewContext(script, {
+        Map,
+        Promise,
+        document,
+        window: { __DATA__: { items: rawItems } },
+        location: {
+            href: 'https://search.douban.com/movie/subject_search?search_text=%E5%B0%84%E9%9B%95%E8%8B%B1%E9%9B%84%E4%BC%A0',
+            origin: 'https://search.douban.com',
+        },
+        setTimeout(fn) {
+            fn();
+            return 0;
+        },
+    });
+}
+
 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([
             '',
@@ -21,9 +107,11 @@ describe('douban utils', () => {
             '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' })
@@ -57,8 +145,215 @@ describe('douban utils', () => {
         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');
     });
+
+    it('maps tv series results to tvshow in searchDouban output', async () => {
+        const domItems = [
+            createFakeSearchItem({
+                title: '射雕英雄传‎ (2017)',
+                url: 'https://movie.douban.com/subject/26663086/',
+                rating: '7.9',
+                abstract: '中国大陆 / 剧情 / 武侠 / 古装 / 45分钟',
+                cover: 'https://img1.doubanio.com/view/photo/s_ratio_poster/public/p2411844029.webp',
+            }),
+            createFakeSearchItem({
+                title: '射雕英雄传：侠之大者‎ (2025)',
+                url: 'https://movie.douban.com/subject/36289423/',
+                rating: '5.2',
+                abstract: '中国大陆 / 武侠 / 146分钟',
+                cover: 'https://img1.doubanio.com/view/photo/s_ratio_poster/public/p2917502509.webp',
+            }),
+        ];
+        const rawItems = [
+            {
+                id: 26663086,
+                labels: [{ text: '剧集' }, { text: '可播放' }],
+                more_url: "onclick=\"moreurl(this,{from:'mv_subject_search',subject_id:'26663086',is_tv:'1'})\"",
+            },
+            {
+                id: 36289423,
+                labels: [{ text: '可播放' }],
+                more_url: "onclick=\"moreurl(this,{from:'mv_subject_search',subject_id:'36289423',is_tv:'0'})\"",
+            },
+        ];
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ blocked: false, title: '射雕英雄传 - 电影 - 豆瓣搜索', href: 'https://search.douban.com/movie/subject_search?search_text=%E5%B0%84%E9%9B%95%E8%8B%B1%E9%9B%84%E4%BC%A0' })
+                .mockImplementationOnce((script) => runSearchEvaluate(script, rawItems, domItems)),
+        };
+        await expect(searchDouban(page, 'movie', '射雕英雄传', 20)).resolves.toMatchObject([
+            { id: '26663086', type: 'tvshow', title: '射雕英雄传‎ (2017)' },
+            { id: '36289423', type: 'movie', title: '射雕英雄传：侠之大者‎ (2025)' },
+        ]);
+    });
+
+    it('normalizes douban book subject raw data into structured fields', () => {
+        const normalized = normalizeDoubanBookSubject({
+            id: '2567698',
+            title: '小狗钱钱',
+            subtitle: '让孩子和家长共同成长的财商童话',
+            originalTitle: 'Ein Hund namens Money',
+            infoText: `
+作者: [德] 博多·舍费尔
+出版社: 南海出版公司
+副标题: 让孩子和家长共同成长的财商童话
+原作名: Ein Hund namens Money
+译者: 王钟欣 / 余茜
+出版年: 2014-1-1
+页数: 208
+定价: 26.00元
+装帧: 平装
+丛书: 新经典文库·爱心树童书
+ISBN: 9787544270871
+      `,
+            rating: '8.9',
+            ratingCount: '12345',
+            summary: '理财启蒙故事',
+            cover: 'https://img9.doubanio.com/view/subject/l/public/s29618581.jpg',
+            url: 'https://book.douban.com/subject/2567698/',
+        });
+        expect(normalized).toMatchObject({
+            id: '2567698',
+            type: 'book',
+            title: '小狗钱钱',
+            subtitle: '让孩子和家长共同成长的财商童话',
+            originalTitle: 'Ein Hund namens Money',
+            authors: ['[德] 博多·舍费尔'],
+            translators: ['王钟欣', '余茜'],
+            publisher: '南海出版公司',
+            publishDate: '2014-1-1',
+            publishYear: '2014',
+            pageCount: 208,
+            binding: '平装',
+            price: '26.00元',
+            series: '新经典文库·爱心树童书',
+            isbn13: '9787544270871',
+            rating: 8.9,
+            ratingCount: 12345,
+            summary: '理财启蒙故事',
+            cover: 'https://img9.doubanio.com/view/subject/l/public/s29618581.jpg',
+            url: 'https://book.douban.com/subject/2567698/',
+        });
+    });
+
+    it('loads book subject details from book.douban.com when type=book', async () => {
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ blocked: false, title: '小狗钱钱 (豆瓣)', href: 'https://book.douban.com/subject/2567698/' })
+                .mockResolvedValueOnce({
+                id: '2567698',
+                title: '小狗钱钱',
+                subtitle: '',
+                originalTitle: '',
+                infoText: `
+作者: [德] 博多·舍费尔
+出版社: 南海出版公司
+出版年: 2014-1-1
+ISBN: 9787544270871
+        `,
+                rating: '8.9',
+                ratingCount: '12345',
+                summary: '理财启蒙故事',
+                cover: 'https://img9.doubanio.com/view/subject/l/public/s29618581.jpg',
+                url: 'https://book.douban.com/subject/2567698/',
+            }),
+        };
+        const detail = await loadDoubanSubjectDetail(page, '2567698', 'book');
+        expect(page.goto).toHaveBeenCalledWith('https://book.douban.com/subject/2567698/', {
+            waitUntil: 'load',
+            settleMs: 1500,
+        });
+        expect(page.wait).toHaveBeenCalledWith({ selector: 'h1 span, #info', timeout: 8 });
+        expect(detail).toMatchObject({
+            id: '2567698',
+            type: 'book',
+            title: '小狗钱钱',
+            authors: ['[德] 博多·舍费尔'],
+            publisher: '南海出版公司',
+            isbn13: '9787544270871',
+            rating: 8.9,
+            ratingCount: 12345,
+            url: 'https://book.douban.com/subject/2567698/',
+        });
+    });
+
+    it('retries transient detached navigation errors when loading douban search results', async () => {
+        const page = {
+            goto: vi.fn()
+                .mockRejectedValueOnce(new Error('Detached while handling command'))
+                .mockResolvedValueOnce(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                blocked: false,
+                title: '经济学思维 - 豆瓣搜索',
+                href: 'https://search.douban.com/book/subject_search?search_text=%E7%BB%8F%E6%B5%8E%E5%AD%A6%E6%80%9D%E7%BB%B4&cat=1001',
+            })
+                .mockResolvedValueOnce([
+                {
+                    rank: 1,
+                    id: '26895402',
+                    type: 'book',
+                    title: '经济学思维',
+                    rating: 7.9,
+                    abstract: '李子畅 / 中信出版社 / 2016-7',
+                    url: 'https://book.douban.com/subject/26895402/',
+                    cover: 'https://img1.doubanio.com/view/subject/m/public/s29000000.jpg',
+                },
+            ]),
+        };
+        const results = await searchDouban(page, 'book', '经济学思维', 3);
+        expect(page.goto).toHaveBeenNthCalledWith(1, 'https://search.douban.com/book/subject_search?search_text=%E7%BB%8F%E6%B5%8E%E5%AD%A6%E6%80%9D%E7%BB%B4&cat=1001', {
+            waitUntil: 'load',
+            settleMs: 1500,
+        });
+        expect(page.goto).toHaveBeenCalledTimes(2);
+        expect(page.wait).toHaveBeenCalledWith({
+            selector: '.item-root .title-text, .item-root .title a, .result-list .result-item h3 a',
+            timeout: 8,
+        });
+        expect(results).toEqual([
+            {
+                rank: 1,
+                id: '26895402',
+                type: 'book',
+                title: '经济学思维',
+                rating: 7.9,
+                abstract: '李子畅 / 中信出版社 / 2016-7',
+                url: 'https://book.douban.com/subject/26895402/',
+                cover: 'https://img1.doubanio.com/view/subject/m/public/s29000000.jpg',
+            },
+        ]);
+    });
+});
+
+describe('inferDoubanSearchResultType', () => {
+    it('returns tvshow for movie search results marked as TV', () => {
+        expect(inferDoubanSearchResultType('movie', {
+            moreUrl: "onclick=\"moreurl(this,{is_tv:'1'})\"",
+            labels: [{ text: '剧集' }],
+        })).toBe('tvshow');
+    });
+
+    it('returns movie when a movie search result has no TV signal', () => {
+        expect(inferDoubanSearchResultType('movie', {
+            moreUrl: "onclick=\"moreurl(this,{is_tv:'0'})\"",
+            labels: [{ text: '可播放' }],
+        })).toBe('movie');
+    });
+
+    it('preserves non-movie search types', () => {
+        expect(inferDoubanSearchResultType('book', {
+            moreUrl: '',
+            labels: [{ text: '图书' }],
+        })).toBe('book');
+    });
 });