@huyuan-ai/cli 1.0.0 → 1.0.2

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

@@ -0,0 +1,106 @@
+import { cli, Strategy } from '../../registry.js';
+import { getSelfUid } from './utils.js';
+cli({
+    site: 'douban',
+    name: 'reviews',
+    description: '导出个人影评',
+    domain: 'movie.douban.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: '导出数量' },
+        { name: 'uid', help: '用户ID，不填则使用当前登录账号' },
+        { name: 'full', type: 'bool', default: false, help: '获取完整影评内容' },
+    ],
+    columns: ['movieTitle', 'title', 'myRating', 'votes', 'content', 'url'],
+    func: async (page, kwargs) => {
+        const { limit = 20, uid: providedUid, full = false } = kwargs;
+        const uid = providedUid || await getSelfUid(page);
+        const reviews = await fetchReviews(page, uid, limit, full);
+        return reviews;
+    },
+});
+async function fetchReviews(page, uid, limit, full) {
+    const reviews = [];
+    let start = 0;
+    const pageSize = 20;
+    while (true) {
+        const url = `https://movie.douban.com/people/${uid}/reviews?start=${start}&sort=time`;
+        await page.goto(url);
+        await page.wait({ time: 1 });
+        const data = await page.evaluate(`
+      () => {
+        const reviews = [];
+        
+        document.querySelectorAll('.tlst').forEach(el => {
+          const movieLinkEl = el.querySelector('.ilst a');
+          const reviewTitleEl = el.querySelector('.nlst a[title]');
+          const ratingEl = el.querySelector('.clst span[class*="allstar"]');
+          const contentEl = el.querySelector('.review-short span');
+          const votesEl = el.querySelector('.review-short .pl span');
+          
+          const movieHref = movieLinkEl?.href || '';
+          const movieId = movieHref.match(/subject\\/(\\d+)/)?.[1] || '';
+          const movieTitle = movieLinkEl?.getAttribute('title') || movieLinkEl?.textContent?.trim() || '';
+          
+          const reviewHref = reviewTitleEl?.href || '';
+          const reviewId = reviewHref.match(/reviews\\/(\\d+)/)?.[1] || '';
+          const title = reviewTitleEl?.textContent?.trim() || '';
+          
+          let myRating = 0;
+          if (ratingEl) {
+            const cls = ratingEl.className || '';
+            const ratingMatch = cls.match(/allstar(\\d)0/);
+            if (ratingMatch) {
+              myRating = parseInt(ratingMatch[1], 10) * 2;
+            }
+          }
+          
+          const votesText = votesEl?.textContent || '';
+          const votesMatch = votesText.match(/(\\d+)/);
+          const votes = votesMatch ? parseInt(votesMatch[1], 10) : 0;
+          
+          reviews.push({
+            reviewId,
+            movieId,
+            movieTitle,
+            title,
+            content: contentEl?.textContent?.trim() || '',
+            myRating,
+            createdAt: '',
+            votes,
+            url: reviewHref,
+          });
+        });
+        
+        return reviews;
+      }
+    `);
+        reviews.push(...data);
+        if (data.length < pageSize)
+            break;
+        if (limit > 0 && reviews.length >= limit)
+            break;
+        start += pageSize;
+    }
+    const result = reviews.slice(0, limit > 0 ? limit : undefined);
+    if (full && result.length > 0) {
+        for (const review of result) {
+            if (review.url) {
+                const fullContent = await fetchFullReview(page, review.url);
+                review.content = fullContent;
+            }
+        }
+    }
+    return result;
+}
+async function fetchFullReview(page, reviewUrl) {
+    await page.goto(reviewUrl);
+    await page.wait({ time: 1 });
+    const content = await page.evaluate(`
+    () => {
+      const contentEl = document.querySelector('.review-content');
+      return contentEl?.textContent?.trim() || '';
+    }
+  `);
+    return content;
+}

package/vendor/opencli/dist/clis/douban/search.d.ts

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

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

@@ -0,0 +1,16 @@
+import { cli, Strategy } from '../../registry.js';
+import { searchDouban } from './utils.js';
+cli({
+    site: 'douban',
+    name: 'search',
+    description: '搜索豆瓣电影、图书或音乐',
+    domain: 'search.douban.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'type', default: 'movie', choices: ['movie', 'book', 'music'], help: '搜索类型（movie=电影, book=图书, music=音乐）' },
+        { name: 'keyword', required: true, positional: true, help: '搜索关键词' },
+        { name: 'limit', type: 'int', default: 20, help: '返回结果数量' },
+    ],
+    columns: ['rank', 'title', 'rating', 'abstract', 'url'],
+    func: async (page, args) => searchDouban(page, args.type, args.keyword, Number(args.limit) || 20),
+});

package/vendor/opencli/dist/clis/douban/subject.yaml

@@ -0,0 +1,107 @@
+site: douban
+name: subject
+description: 获取电影详情
+domain: movie.douban.com
+strategy: cookie
+browser: true
+
+args:
+  id:
+    positional: true
+    required: true
+    type: str
+    description: 电影 ID
+
+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}`
+        }];
+      })()
+
+columns: [id, title, originalTitle, year, rating, ratingCount, genres, directors, casts, country, duration, summary, url]

package/vendor/opencli/dist/clis/douban/top250.yaml

@@ -0,0 +1,70 @@
+site: douban
+name: top250
+description: 豆瓣电影 Top250
+domain: movie.douban.com
+strategy: cookie
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 250
+    description: 返回结果数量
+
+pipeline:
+  - navigate: https://movie.douban.com/top250
+
+  - evaluate: |
+      async () => {
+        const results = [];
+        const limit = ${{ args.limit }};
+
+        const parsePage = (doc) => {
+          const items = doc.querySelectorAll('.item');
+          for (const item of items) {
+            if (results.length >= limit) break;
+
+            const rankEl = item.querySelector('.pic em');
+            const linkEl = item.querySelector('a');
+            const titleEl = item.querySelector('.title');
+            const ratingEl = item.querySelector('.rating_num');
+
+            const href = linkEl?.href || '';
+            const matchResult = href.match(/subject\/(\d+)/);
+            const id = matchResult ? matchResult[1] : '';
+
+            const title = titleEl?.textContent?.trim() || '';
+            const rank = parseInt(rankEl?.textContent || '0', 10);
+            const rating = ratingEl?.textContent?.trim() || '';
+
+            if (id && title) {
+              results.push({
+                rank: rank || results.length + 1,
+                id,
+                title,
+                rating: rating ? parseFloat(rating) : 0,
+                url: href
+              });
+            }
+          }
+        };
+
+        parsePage(document);
+
+        for (let start = 25; start < 250 && results.length < limit; start += 25) {
+          const resp = await fetch(`https://movie.douban.com/top250?start=${start}`);
+          if (!resp.ok) break;
+          const html = await resp.text();
+          if (!html) break;
+
+          const doc = new DOMParser().parseFromString(html, 'text/html');
+          parsePage(doc);
+          await new Promise(r => setTimeout(r, 150));
+        }
+
+        return results;
+      }
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, id, title, rating, url]

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

@@ -0,0 +1,63 @@
+/**
+ * Douban adapter utilities.
+ */
+import type { IPage } from '../../types.js';
+export interface DoubanSubjectPhoto {
+    index: number;
+    photoId: string;
+    title: string;
+    imageUrl: string;
+    thumbUrl: string;
+    detailUrl: string;
+    page: number;
+}
+export interface DoubanSubjectPhotosResult {
+    subjectId: string;
+    subjectTitle: string;
+    type: string;
+    photos: DoubanSubjectPhoto[];
+}
+export interface LoadDoubanSubjectPhotosOptions {
+    type?: string;
+    limit?: number;
+    targetPhotoId?: string;
+}
+export declare function normalizeDoubanSubjectId(subjectId: string): string;
+export declare function promoteDoubanPhotoUrl(url: string, size?: 's' | 'm' | 'l'): string;
+export declare function resolveDoubanPhotoAssetUrl(candidates: Array<string | null | undefined>, baseUrl?: string): string;
+export declare function getDoubanPhotoExtension(url: string): string;
+export declare function loadDoubanSubjectPhotos(page: IPage, subjectId: string, options?: LoadDoubanSubjectPhotosOptions): Promise<DoubanSubjectPhotosResult>;
+export declare function loadDoubanBookHot(page: IPage, limit: number): Promise<any[]>;
+export declare function loadDoubanMovieHot(page: IPage, limit: number): Promise<any[]>;
+export declare function searchDouban(page: IPage, type: string, keyword: string, limit: number): Promise<any[]>;
+/**
+ * Get current user's Douban ID from movie.douban.com/mine page
+ */
+export declare function getSelfUid(page: IPage): Promise<string>;
+/**
+ * Douban mark (viewing record) interface
+ */
+export interface DoubanMark {
+    movieId: string;
+    title: string;
+    year: string;
+    myRating: number | null;
+    myStatus: 'collect' | 'wish' | 'do';
+    myComment: string;
+    myDate: string;
+    url: string;
+}
+/**
+ * Douban review interface
+ */
+export interface DoubanReview {
+    reviewId: string;
+    movieId: string;
+    movieTitle: string;
+    title: string;
+    content: string;
+    myRating: number;
+    createdAt: string;
+    votes: number;
+    url: string;
+}