@jackwener/opencli 1.7.3 → 1.7.5

package/clis/deepseek/utils.js

@@ -0,0 +1,208 @@
+export const DEEPSEEK_DOMAIN = 'chat.deepseek.com';
+export const DEEPSEEK_URL = 'https://chat.deepseek.com/';
+export const TEXTAREA_SELECTOR = 'textarea[placeholder*="DeepSeek"]';
+export const MESSAGE_SELECTOR = '.ds-message';
+
+export async function isOnDeepSeek(page) {
+    const url = await page.evaluate('window.location.href').catch(() => '');
+    if (typeof url !== 'string' || !url) return false;
+    try {
+        const h = new URL(url).hostname;
+        return h === 'deepseek.com' || h.endsWith('.deepseek.com');
+    } catch {
+        return false;
+    }
+}
+
+export async function ensureOnDeepSeek(page) {
+    if (!(await isOnDeepSeek(page))) {
+        await page.goto(DEEPSEEK_URL);
+        await page.wait(3);
+    }
+}
+
+export async function getPageState(page) {
+    return page.evaluate(`(() => {
+        const url = window.location.href;
+        const title = document.title;
+        const textarea = document.querySelector('${TEXTAREA_SELECTOR}');
+        const avatar = document.querySelector('img[src*="user-avatar"]');
+        return {
+            url,
+            title,
+            hasTextarea: !!textarea,
+            isLoggedIn: !!avatar,
+        };
+    })()`);
+}
+
+export async function selectModel(page, modelName) {
+    return page.evaluate(`(() => {
+        const radios = document.querySelectorAll('div[role="radio"]');
+        for (const radio of radios) {
+            const span = radio.querySelector('span');
+            if (span && span.textContent.trim().toLowerCase() === '${modelName}'.toLowerCase()) {
+                const alreadySelected = radio.getAttribute('aria-checked') === 'true';
+                if (!alreadySelected) radio.click();
+                return { ok: true, toggled: !alreadySelected };
+            }
+        }
+        return { ok: false };
+    })()`);
+}
+
+export async function setFeature(page, featureName, enabled) {
+    return page.evaluate(`(() => {
+        const btns = document.querySelectorAll('div[role="button"]');
+        for (const btn of btns) {
+            const span = btn.querySelector('span');
+            if (span && span.textContent.trim() === '${featureName}') {
+                const isActive = btn.classList.contains('ds-toggle-button--selected');
+                if (${enabled} !== isActive) btn.click();
+                return { ok: true, toggled: ${enabled} !== isActive };
+            }
+        }
+        return { ok: false };
+    })()`);
+}
+
+export async function sendMessage(page, prompt) {
+    const promptJson = JSON.stringify(prompt);
+    return page.evaluate(`(async () => {
+        const box = document.querySelector('${TEXTAREA_SELECTOR}');
+        if (!box) return { ok: false, reason: 'textarea not found' };
+
+        box.focus();
+        box.value = '';
+        document.execCommand('selectAll');
+        document.execCommand('insertText', false, ${promptJson});
+        await new Promise(r => setTimeout(r, 800));
+
+        const btns = document.querySelectorAll('div[role="button"]');
+        for (const btn of btns) {
+            if (btn.getAttribute('aria-disabled') === 'false') {
+                const svgs = btn.querySelectorAll('svg');
+                if (svgs.length > 0 && btn.closest('div')?.querySelector('textarea')) {
+                    btn.click();
+                    return { ok: true };
+                }
+            }
+        }
+
+        box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+        return { ok: true, method: 'enter' };
+    })()`);
+}
+
+export async function getBubbleCount(page) {
+    const count = await page.evaluate(`(() => {
+        return document.querySelectorAll('${MESSAGE_SELECTOR}').length;
+    })()`);
+    return count || 0;
+}
+
+export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
+    const startTime = Date.now();
+    let lastText = '';
+    let stableCount = 0;
+
+    while (Date.now() - startTime < timeoutMs) {
+        await page.wait(3);
+
+        let result;
+        try {
+            result = await page.evaluate(`(() => {
+                const bubbles = document.querySelectorAll('${MESSAGE_SELECTOR}');
+                const texts = Array.from(bubbles).map(b => (b.innerText || '').trim()).filter(Boolean);
+                return { count: texts.length, last: texts[texts.length - 1] || '' };
+            })()`);
+        } catch {
+            continue;
+        }
+
+        if (!result) continue;
+
+        const candidate = result.last;
+        if (candidate && result.count > baselineCount && candidate !== prompt.trim()) {
+            if (candidate === lastText) {
+                stableCount++;
+                if (stableCount >= 3) return candidate;
+            } else {
+                stableCount = 0;
+            }
+            lastText = candidate;
+        }
+    }
+
+    return lastText || null;
+}
+
+export async function getVisibleMessages(page) {
+    const result = await page.evaluate(`(() => {
+        const msgs = document.querySelectorAll('${MESSAGE_SELECTOR}');
+        return Array.from(msgs).map(m => {
+            // User messages carry an extra hash-class alongside ds-message
+            const isUser = m.className.split(/\\s+/).length > 2;
+            return {
+                Role: isUser ? 'user' : 'assistant',
+                Text: (m.innerText || '').trim(),
+            };
+        }).filter(m => m.Text);
+    })()`);
+    return Array.isArray(result) ? result : [];
+}
+
+export async function getConversationList(page) {
+    await ensureOnDeepSeek(page);
+    // Expand sidebar if collapsed
+    await page.evaluate(`(() => {
+        if (document.querySelectorAll('a[href*="/a/chat/s/"]').length === 0) {
+            const btn = document.querySelector('div[tabindex="0"][role="button"]');
+            if (btn) btn.click();
+        }
+    })()`);
+    // Poll for sidebar history links to render
+    for (let attempt = 0; attempt < 5; attempt++) {
+        await page.wait(2);
+        const items = await page.evaluate(`(() => {
+            const items = [];
+            const links = document.querySelectorAll('a[href*="/a/chat/s/"]');
+            links.forEach((link, i) => {
+                const titleEl = link.querySelector('div');
+                const title = titleEl ? titleEl.textContent.trim() : '';
+                const href = link.getAttribute('href') || '';
+                const idMatch = href.match(/\\/s\\/([a-f0-9-]+)/);
+                items.push({
+                    Index: i + 1,
+                    Id: idMatch ? idMatch[1] : href,
+                    Title: title || '(untitled)',
+                    Url: 'https://chat.deepseek.com' + href,
+                });
+            });
+            return items;
+        })()`);
+        if (Array.isArray(items) && items.length > 0) return items;
+    }
+    return [];
+}
+
+// Retries on CDP "Promise was collected" errors caused by DeepSeek's SPA router transitions.
+export async function withRetry(fn, retries = 2) {
+    for (let i = 0; i <= retries; i++) {
+        try {
+            return await fn();
+        } catch (err) {
+            const msg = String(err?.message || err);
+            if (i < retries && msg.includes('Promise was collected')) {
+                await new Promise(r => setTimeout(r, 2000));
+                continue;
+            }
+            throw err;
+        }
+    }
+}
+
+export function parseBoolFlag(value) {
+    if (typeof value === 'boolean') return value;
+    return String(value ?? '').trim().toLowerCase() === 'true';
+}

package/clis/douban/search.js

@@ -6,6 +6,7 @@ cli({
     description: '搜索豆瓣电影、图书或音乐',
     domain: 'search.douban.com',
     strategy: Strategy.COOKIE,
+    navigateBefore: false,
     args: [
         { name: 'type', default: 'movie', choices: ['movie', 'book', 'music'], help: '搜索类型（movie=电影, book=图书, music=音乐）' },
         { name: 'keyword', required: true, positional: true, help: '搜索关键词' },

package/clis/douban/search.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+
+describe('douban search command', () => {
+    it('skips default pre-navigation because the adapter handles navigation itself', () => {
+        const command = getRegistry().get('douban/search');
+        expect(command).toBeDefined();
+        expect(command?.navigateBefore).toBe(false);
+    });
+});

package/clis/douban/subject.js

@@ -1,18 +1,35 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { loadDoubanSubjectDetail } from './utils.js';
+
 cli({
     site: 'douban',
     name: 'subject',
-    description: '获取电影详情',
+    description: '获取豆瓣条目详情',
     domain: 'movie.douban.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    navigateBefore: false,
     args: [
-        { name: 'id', required: true, positional: true, help: '电影 ID' },
+        { name: 'id', required: true, positional: true, help: '豆瓣条目 ID' },
+        { name: 'type', default: 'movie', choices: ['movie', 'book'], help: '条目类型（movie=电影, book=图书）' },
     ],
     columns: [
         'id',
+        'type',
         'title',
+        'subtitle',
         'originalTitle',
+        'authors',
+        'translators',
+        'publisher',
+        'publishDate',
+        'publishYear',
+        'pageCount',
+        'binding',
+        'price',
+        'series',
+        'isbn10',
+        'isbn13',
         'year',
         'rating',
         'ratingCount',
@@ -24,95 +41,5 @@ cli({
         'summary',
         'url',
     ],
-    pipeline: [
-        { navigate: 'https://movie.douban.com/subject/${{ args.id }}' },
-        { evaluate: `(async () => {
-  const id = '\${{ args.id }}';
-
-  // Wait for page to load
-  await new Promise(r => setTimeout(r, 2000));
-
-  // Extract title - v:itemreviewed contains "中文名 OriginalName"
-  const titleEl = document.querySelector('span[property="v:itemreviewed"]');
-  const fullTitle = titleEl?.textContent?.trim() || '';
-
-  // Split title and originalTitle
-  // Douban format: "中文名 OriginalName" - split by first space that separates CJK from non-CJK
-  let title = fullTitle;
-  let originalTitle = '';
-  const titleMatch = fullTitle.match(/^([\\u4e00-\\u9fff\\u3000-\\u303f\\uff00-\\uffef]+(?:\\s*[\\u4e00-\\u9fff\\u3000-\\u303f\\uff00-\\uffef·：:！？]+)*)\\s+(.+)$/);
-  if (titleMatch) {
-    title = titleMatch[1].trim();
-    originalTitle = titleMatch[2].trim();
-  }
-
-  // Extract year
-  const yearEl = document.querySelector('.year');
-  const year = yearEl?.textContent?.trim().replace(/[()（）]/g, '') || '';
-
-  // Extract rating
-  const ratingEl = document.querySelector('strong[property="v:average"]');
-  const rating = parseFloat(ratingEl?.textContent || '0');
-
-  // Extract rating count
-  const ratingCountEl = document.querySelector('span[property="v:votes"]');
-  const ratingCount = parseInt(ratingCountEl?.textContent || '0', 10);
-
-  // Extract genres
-  const genreEls = document.querySelectorAll('span[property="v:genre"]');
-  const genres = Array.from(genreEls).map(el => el.textContent?.trim()).filter(Boolean).join(',');
-
-  // Extract directors
-  const directorEls = document.querySelectorAll('a[rel="v:directedBy"]');
-  const directors = Array.from(directorEls).map(el => el.textContent?.trim()).filter(Boolean).join(',');
-
-  // Extract casts
-  const castEls = document.querySelectorAll('a[rel="v:starring"]');
-  const casts = Array.from(castEls).slice(0, 5).map(el => el.textContent?.trim()).filter(Boolean);
-
-  // Extract info section for country and duration
-  const infoEl = document.querySelector('#info');
-  const infoText = infoEl?.textContent || '';
-
-  // Extract country/region from #info as list
-  let country = [];
-  const countryMatch = infoText.match(/制片国家\\/地区:\\s*([^\\n]+)/);
-  if (countryMatch) {
-    country = countryMatch[1].trim().split(/\\s*\\/\\s*/).filter(Boolean);
-  }
-
-  // Extract duration from #info as pure number in min
-  const durationEl = document.querySelector('span[property="v:runtime"]');
-  let durationRaw = durationEl?.textContent?.trim() || '';
-  if (!durationRaw) {
-    const durationMatch = infoText.match(/片长:\\s*([^\\n]+)/);
-    if (durationMatch) {
-      durationRaw = durationMatch[1].trim();
-    }
-  }
-  const durationNumMatch = durationRaw.match(/(\\d+)/);
-  const duration = durationNumMatch ? parseInt(durationNumMatch[1], 10) : null;
-
-  // Extract summary
-  const summaryEl = document.querySelector('span[property="v:summary"]');
-  const summary = summaryEl?.textContent?.trim() || '';
-
-  return [{
-    id,
-    title,
-    originalTitle,
-    year,
-    rating,
-    ratingCount,
-    genres,
-    directors,
-    casts,
-    country,
-    duration,
-    summary: summary.substring(0, 200),
-    url: \`https://movie.douban.com/subject/\${id}\`
-  }];
-})()
-` },
-    ],
+    func: async (page, args) => [await loadDoubanSubjectDetail(page, args.id, args.type)],
 });

package/clis/douban/subject.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './subject.js';
+
+describe('douban subject command', () => {
+    it('skips default pre-navigation because the adapter handles subject navigation itself', () => {
+        const command = getRegistry().get('douban/subject');
+        expect(command).toBeDefined();
+        expect(command?.navigateBefore).toBe(false);
+    });
+});

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';
@@ -312,11 +551,13 @@ export function inferDoubanSearchResultType(searchType, item = {}) {
 }
 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 inferDoubanSearchResultTypeSource = inferDoubanSearchResultType.toString();
-    const data = await page.evaluate(`
+    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};
@@ -335,13 +576,13 @@ export async function searchDouban(page, type, keyword, limit) {
         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;
@@ -350,7 +591,7 @@ export async function searchDouban(page, type, keyword, limit) {
         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,
@@ -367,6 +608,7 @@ export async function searchDouban(page, type, keyword, limit) {
       return results;
     })()
   `);
+    });
     return Array.isArray(data) ? data : [];
 }
 /**