@jackwener/opencli 1.7.3 → 1.7.4

package/clis/bilibili/favorite.js

@@ -3,27 +3,32 @@ import { apiGet, payloadData, getSelfUid } from './utils.js';
 cli({
     site: 'bilibili',
     name: 'favorite',
-    description: '我的默认收藏夹',
+    description: '我的收藏夹',
     domain: 'www.bilibili.com',
     strategy: Strategy.COOKIE,
     args: [
+        { name: 'fid', type: 'int', required: false, help: 'Favorite folder ID (defaults to first folder)' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
         { name: 'page', type: 'int', default: 1, help: 'Page number' },
     ],
     columns: ['rank', 'title', 'author', 'plays', 'url'],
     func: async (page, kwargs) => {
-        const { limit = 20, page: pageNum = 1 } = kwargs;
-        // Get current user's UID
-        const uid = await getSelfUid(page);
-        // Get default favorite folder ID
-        const foldersPayload = await apiGet(page, '/x/v3/fav/folder/created/list-all', {
-            params: { up_mid: uid },
-            signed: true,
-        });
-        const folders = payloadData(foldersPayload)?.list ?? [];
-        if (!folders.length)
-            return [];
-        const fid = folders[0].id;
+        const { fid: favoriteId, limit = 20, page: pageNum = 1 } = kwargs;
+        let fid;
+        if (favoriteId) {
+            fid = Number(favoriteId);
+        } else {
+            // Fall back to the default (first) favorite folder
+            const uid = await getSelfUid(page);
+            const foldersPayload = await apiGet(page, '/x/v3/fav/folder/created/list-all', {
+                params: { up_mid: uid },
+                signed: true,
+            });
+            const folders = payloadData(foldersPayload)?.list ?? [];
+            if (!folders.length)
+                return [];
+            fid = folders[0].id;
+        }
         // Fetch favorite items
         const payload = await apiGet(page, '/x/v3/fav/resource/list', {
             params: { media_id: fid, pn: pageNum, ps: Math.min(Number(limit), 40) },

package/clis/binance/depth.js

@@ -3,7 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
   site: 'binance',
   name: 'depth',
-  description: 'Order book bid prices for a trading pair',
+  description: 'Order book bid and ask prices for a trading pair',
   domain: 'data-api.binance.vision',
   strategy: Strategy.PUBLIC,
   browser: false,
@@ -11,11 +11,10 @@ cli({
     { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
     { name: 'limit', type: 'int', default: 10, help: 'Number of price levels (5, 10, 20, 50, 100)' },
   ],
-  columns: ['rank', 'bid_price', 'bid_qty'],
+  columns: ['rank', 'bid_price', 'bid_qty', 'ask_price', 'ask_qty'],
   pipeline: [
     { fetch: { url: 'https://data-api.binance.vision/api/v3/depth?symbol=${{ args.symbol }}&limit=${{ args.limit }}' } },
-    { select: 'bids' },
-    { map: { rank: '${{ index + 1 }}', bid_price: '${{ item.0 }}', bid_qty: '${{ item.1 }}' } },
+    { map: { select: 'bids', rank: '${{ index + 1 }}', bid_price: '${{ item[0] }}', bid_qty: '${{ item[1] }}', ask_price: '${{ root.asks[index]?.[0] ?? "" }}', ask_qty: '${{ root.asks[index]?.[1] ?? "" }}' } },
     { limit: '${{ args.limit }}' },
   ],
 });

package/clis/boss/utils.js

@@ -214,11 +214,10 @@ export async function typeAndSendMessage(page, text) {
     return true;
 }
 /**
- * Verbose log helper — prints when OPENCLI_VERBOSE is set, with DEBUG=opencli
- * kept as a compatibility fallback.
+ * Verbose log helper — prints when OPENCLI_VERBOSE is set.
  */
 export function verbose(msg) {
-    if (process.env.OPENCLI_VERBOSE || process.env.DEBUG?.includes('opencli')) {
+    if (process.env.OPENCLI_VERBOSE) {
         console.error(`[opencli:boss] ${msg}`);
     }
 }

package/clis/chatgpt-app/ax.js

@@ -121,11 +121,14 @@ let args = CommandLine.arguments
 let target = args.count > 1 ? args[1] : ""
 let needsLegacy = args.count > 2 && args[2] == "legacy"
 
-// Step 1: Click the "Options" button to open the popover
-guard let optionsBtn = findByDesc(win, "Options") else {
+// Step 1: Click the "Options" button to open the popover (support both English and Chinese UI)
+var optionsBtn: AXUIElement? = nil
+if let btn = findByDesc(win, "Options") { optionsBtn = btn }
+else if let btn = findByDesc(win, "选项") { optionsBtn = btn }
+guard let options = optionsBtn else {
     fputs("Could not find Options button\\n", stderr); exit(1)
 }
-press(optionsBtn)
+press(options)
 Thread.sleep(forTimeInterval: 0.8)
 
 // Step 2: Find the popover that appeared, search ONLY within it

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 : [];
 }
 /**