@jackwener/opencli 1.4.1 → 1.5.1

package/dist/clis/douban/download.test.js

@@ -0,0 +1,170 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import path from 'node:path';
+import { getRegistry } from '../../registry.js';
+const { mockHttpDownload, mockLoadDoubanSubjectPhotos, mockMkdirSync } = vi.hoisted(() => ({
+    mockHttpDownload: vi.fn(),
+    mockLoadDoubanSubjectPhotos: vi.fn(),
+    mockMkdirSync: vi.fn(),
+}));
+vi.mock('../../download/index.js', () => ({
+    httpDownload: mockHttpDownload,
+    sanitizeFilename: vi.fn((value) => value.replace(/\s+/g, '_')),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        loadDoubanSubjectPhotos: mockLoadDoubanSubjectPhotos,
+    };
+});
+vi.mock('../../download/progress.js', () => ({
+    formatBytes: vi.fn((size) => `${size} B`),
+}));
+vi.mock('node:fs', () => ({
+    mkdirSync: mockMkdirSync,
+}));
+await import('./download.js');
+let cmd;
+beforeAll(() => {
+    cmd = getRegistry().get('douban/download');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+function toPosixPath(value) {
+    return value.replaceAll(path.sep, '/');
+}
+describe('douban download', () => {
+    beforeEach(() => {
+        mockHttpDownload.mockReset();
+        mockLoadDoubanSubjectPhotos.mockReset();
+        mockMkdirSync.mockReset();
+    });
+    it('downloads douban poster images and merges metadata into the result', async () => {
+        const page = {};
+        mockLoadDoubanSubjectPhotos.mockResolvedValue({
+            subjectId: '30382501',
+            subjectTitle: 'The Wandering Earth 2',
+            type: 'Rb',
+            photos: [
+                {
+                    index: 1,
+                    photoId: '2913450214',
+                    title: 'Main poster',
+                    imageUrl: 'https://img1.doubanio.com/view/photo/l/public/p2913450214.webp',
+                    thumbUrl: 'https://img1.doubanio.com/view/photo/m/public/p2913450214.webp',
+                    detailUrl: 'https://movie.douban.com/photos/photo/2913450214/',
+                    page: 1,
+                },
+                {
+                    index: 2,
+                    photoId: '2913450215',
+                    title: 'Character poster',
+                    imageUrl: 'https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg',
+                    thumbUrl: 'https://img1.doubanio.com/view/photo/m/public/p2913450215.jpg',
+                    detailUrl: 'https://movie.douban.com/photos/photo/2913450215/',
+                    page: 1,
+                },
+            ],
+        });
+        mockHttpDownload
+            .mockResolvedValueOnce({ success: true, size: 1200 })
+            .mockResolvedValueOnce({ success: true, size: 980 });
+        const result = await cmd.func(page, {
+            id: '30382501',
+            type: 'Rb',
+            limit: 20,
+            output: '/tmp/douban-test',
+        });
+        expect(mockLoadDoubanSubjectPhotos).toHaveBeenCalledWith(page, '30382501', {
+            type: 'Rb',
+            limit: 20,
+        });
+        expect(mockMkdirSync).toHaveBeenCalledTimes(1);
+        expect(toPosixPath(mockMkdirSync.mock.calls[0][0])).toBe('/tmp/douban-test/30382501');
+        expect(mockMkdirSync.mock.calls[0][1]).toEqual({ recursive: true });
+        expect(mockHttpDownload).toHaveBeenCalledTimes(2);
+        expect(mockHttpDownload.mock.calls[0]?.[0]).toBe('https://img1.doubanio.com/view/photo/l/public/p2913450214.webp');
+        expect(toPosixPath(mockHttpDownload.mock.calls[0]?.[1])).toBe('/tmp/douban-test/30382501/30382501_001_2913450214_Main_poster.webp');
+        expect(mockHttpDownload.mock.calls[0]?.[2]).toEqual(expect.objectContaining({
+            headers: { Referer: 'https://movie.douban.com/photos/photo/2913450214/' },
+            timeout: 60000,
+        }));
+        expect(mockHttpDownload.mock.calls[1]?.[0]).toBe('https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg');
+        expect(toPosixPath(mockHttpDownload.mock.calls[1]?.[1])).toBe('/tmp/douban-test/30382501/30382501_002_2913450215_Character_poster.jpg');
+        expect(mockHttpDownload.mock.calls[1]?.[2]).toEqual(expect.objectContaining({
+            headers: { Referer: 'https://movie.douban.com/photos/photo/2913450215/' },
+            timeout: 60000,
+        }));
+        expect(result).toEqual([
+            {
+                index: 1,
+                title: 'Main poster',
+                photo_id: '2913450214',
+                image_url: 'https://img1.doubanio.com/view/photo/l/public/p2913450214.webp',
+                detail_url: 'https://movie.douban.com/photos/photo/2913450214/',
+                status: 'success',
+                size: '1200 B',
+            },
+            {
+                index: 2,
+                title: 'Character poster',
+                photo_id: '2913450215',
+                image_url: 'https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg',
+                detail_url: 'https://movie.douban.com/photos/photo/2913450215/',
+                status: 'success',
+                size: '980 B',
+            },
+        ]);
+    });
+    it('downloads only the requested photo when photo-id is provided', async () => {
+        const page = {};
+        mockLoadDoubanSubjectPhotos.mockResolvedValue({
+            subjectId: '30382501',
+            subjectTitle: 'The Wandering Earth 2',
+            type: 'Rb',
+            photos: [
+                {
+                    index: 2,
+                    photoId: '2913450215',
+                    title: 'Character poster',
+                    imageUrl: 'https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg',
+                    thumbUrl: 'https://img1.doubanio.com/view/photo/m/public/p2913450215.jpg',
+                    detailUrl: 'https://movie.douban.com/photos/photo/2913450215/',
+                    page: 1,
+                },
+            ],
+        });
+        mockHttpDownload.mockResolvedValueOnce({ success: true, size: 980 });
+        const result = await cmd.func(page, {
+            id: '30382501',
+            type: 'Rb',
+            'photo-id': '2913450215',
+            output: '/tmp/douban-test',
+        });
+        expect(mockLoadDoubanSubjectPhotos).toHaveBeenCalledWith(page, '30382501', {
+            type: 'Rb',
+            targetPhotoId: '2913450215',
+        });
+        expect(mockHttpDownload).toHaveBeenCalledTimes(1);
+        expect(mockHttpDownload.mock.calls[0]?.[0]).toBe('https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg');
+        expect(toPosixPath(mockHttpDownload.mock.calls[0]?.[1])).toBe('/tmp/douban-test/30382501/30382501_002_2913450215_Character_poster.jpg');
+        expect(mockHttpDownload.mock.calls[0]?.[2]).toEqual(expect.objectContaining({
+            headers: { Referer: 'https://movie.douban.com/photos/photo/2913450215/' },
+            timeout: 60000,
+        }));
+        expect(result).toEqual([
+            {
+                index: 2,
+                title: 'Character poster',
+                photo_id: '2913450215',
+                image_url: 'https://img1.doubanio.com/view/photo/l/public/p2913450215.jpg',
+                detail_url: 'https://movie.douban.com/photos/photo/2913450215/',
+                status: 'success',
+                size: '980 B',
+            },
+        ]);
+    });
+    it('rejects invalid subject ids before attempting browser work', async () => {
+        await expect(cmd.func({}, { id: 'movie-30382501' })).rejects.toThrow('Invalid Douban subject ID');
+        expect(mockHttpDownload).not.toHaveBeenCalled();
+    });
+});

package/dist/clis/douban/photos.d.ts

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

package/dist/clis/douban/photos.js

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '../../registry.js';
+import { loadDoubanSubjectPhotos, normalizeDoubanSubjectId } from './utils.js';
+cli({
+    site: 'douban',
+    name: 'photos',
+    description: '获取电影海报/剧照图片列表',
+    domain: 'movie.douban.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'id', positional: true, required: true, help: '电影 subject ID' },
+        { name: 'type', default: 'Rb', help: '豆瓣 photos 的 type 参数，默认 Rb（海报）' },
+        { name: 'limit', type: 'int', default: 120, help: '最多返回多少张图片' },
+    ],
+    columns: ['index', 'title', 'image_url', 'detail_url'],
+    func: async (page, kwargs) => {
+        const subjectId = normalizeDoubanSubjectId(String(kwargs.id || ''));
+        const data = await loadDoubanSubjectPhotos(page, subjectId, {
+            type: String(kwargs.type || 'Rb'),
+            limit: Number(kwargs.limit) || 120,
+        });
+        return data.photos.map((photo) => ({
+            subject_id: data.subjectId,
+            subject_title: data.subjectTitle,
+            type: data.type,
+            index: photo.index,
+            photo_id: photo.photoId,
+            title: photo.title,
+            image_url: photo.imageUrl,
+            thumb_url: photo.thumbUrl,
+            detail_url: photo.detailUrl,
+            page: photo.page,
+        }));
+    },
+});

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

@@ -2,6 +2,31 @@
  * 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[]>;

package/dist/clis/douban/utils.js

@@ -1,10 +1,15 @@
 /**
  * Douban adapter utilities.
  */
-import { CliError } from '../../errors.js';
+import { ArgumentError, CliError, EmptyResultError } from '../../errors.js';
+const DOUBAN_PHOTO_PAGE_SIZE = 30;
+const MAX_DOUBAN_PHOTOS = 500;
 function clampLimit(limit) {
     return Math.max(1, Math.min(limit || 20, 50));
 }
+function clampPhotoLimit(limit) {
+    return Math.max(1, Math.min(limit || 120, MAX_DOUBAN_PHOTOS));
+}
 async function ensureDoubanReady(page) {
     const state = await page.evaluate(`
     (() => {
@@ -18,6 +23,190 @@ 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.');
     }
 }
+export function normalizeDoubanSubjectId(subjectId) {
+    const normalized = String(subjectId || '').trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw new ArgumentError(`Invalid Douban subject ID: ${subjectId}`);
+    }
+    return normalized;
+}
+export function promoteDoubanPhotoUrl(url, size = 'l') {
+    const normalized = String(url || '').trim();
+    if (!normalized)
+        return '';
+    if (/^[a-z]+:/i.test(normalized) && !/^https?:/i.test(normalized))
+        return '';
+    return normalized.replace(/\/view\/photo\/[^/]+\/public\//, `/view/photo/${size}/public/`);
+}
+export function resolveDoubanPhotoAssetUrl(candidates, baseUrl = '') {
+    for (const candidate of candidates) {
+        const normalized = String(candidate || '').trim();
+        if (!normalized)
+            continue;
+        let resolved = normalized;
+        try {
+            resolved = baseUrl
+                ? new URL(normalized, baseUrl).toString()
+                : new URL(normalized).toString();
+        }
+        catch {
+            resolved = normalized;
+        }
+        if (/^https?:\/\//i.test(resolved)) {
+            return resolved;
+        }
+    }
+    return '';
+}
+export function getDoubanPhotoExtension(url) {
+    const normalized = String(url || '').trim();
+    if (!normalized)
+        return '.jpg';
+    try {
+        const ext = new URL(normalized).pathname.match(/\.(jpe?g|png|gif|webp|avif|bmp)$/i)?.[0];
+        return ext || '.jpg';
+    }
+    catch {
+        const ext = normalized.match(/\.(jpe?g|png|gif|webp|avif|bmp)(?:$|[?#])/i)?.[0];
+        return ext ? ext.replace(/[?#].*$/, '') : '.jpg';
+    }
+}
+export async function loadDoubanSubjectPhotos(page, subjectId, options = {}) {
+    const normalizedId = normalizeDoubanSubjectId(subjectId);
+    const type = String(options.type || 'Rb').trim() || 'Rb';
+    const targetPhotoId = String(options.targetPhotoId || '').trim();
+    const safeLimit = targetPhotoId ? Number.MAX_SAFE_INTEGER : clampPhotoLimit(Number(options.limit) || 120);
+    const resolvePhotoAssetUrlSource = resolveDoubanPhotoAssetUrl.toString();
+    const galleryUrl = `https://movie.douban.com/subject/${normalizedId}/photos?type=${encodeURIComponent(type)}`;
+    await page.goto(galleryUrl);
+    await page.wait(2);
+    await ensureDoubanReady(page);
+    const data = await page.evaluate(`
+    (async () => {
+      const subjectId = ${JSON.stringify(normalizedId)};
+      const type = ${JSON.stringify(type)};
+      const limit = ${safeLimit};
+      const targetPhotoId = ${JSON.stringify(targetPhotoId)};
+      const pageSize = ${DOUBAN_PHOTO_PAGE_SIZE};
+      const resolveDoubanPhotoAssetUrl = ${resolvePhotoAssetUrlSource};
+
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const toAbsoluteUrl = (value) => {
+        if (!value) return '';
+        try {
+          return new URL(value, location.origin).toString();
+        } catch {
+          return value;
+        }
+      };
+      const promotePhotoUrl = (value) => {
+        const absolute = toAbsoluteUrl(value);
+        if (!absolute) return '';
+        if (/^[a-z]+:/i.test(absolute) && !/^https?:/i.test(absolute)) return '';
+        return absolute.replace(/\\/view\\/photo\\/[^/]+\\/public\\//, '/view/photo/l/public/');
+      };
+      const buildPageUrl = (start) => {
+        const url = new URL(location.href);
+        url.searchParams.set('type', type);
+        if (start > 0) url.searchParams.set('start', String(start));
+        else url.searchParams.delete('start');
+        return url.toString();
+      };
+      const getTitle = (doc) => {
+        const raw = normalize(doc.querySelector('#content h1')?.textContent)
+          || normalize(doc.querySelector('title')?.textContent);
+        return raw.replace(/\\s*\\(豆瓣\\)\\s*$/, '');
+      };
+      const extractPhotos = (doc, pageNumber) => {
+        const nodes = Array.from(doc.querySelectorAll('.poster-col3 li, .poster-col3l li, .article li'));
+        const rows = [];
+        for (const node of nodes) {
+          const link = node.querySelector('a[href*="/photos/photo/"]');
+          const img = node.querySelector('img');
+          if (!link || !img) continue;
+
+          const detailUrl = toAbsoluteUrl(link.getAttribute('href') || '');
+          const photoId = detailUrl.match(/\\/photo\\/(\\d+)/)?.[1] || '';
+          const thumbUrl = resolveDoubanPhotoAssetUrl([
+            img.getAttribute('data-origin'),
+            img.getAttribute('data-src'),
+            img.getAttribute('src'),
+          ], location.href);
+          const imageUrl = promotePhotoUrl(thumbUrl);
+          const title = normalize(link.getAttribute('title'))
+            || normalize(img.getAttribute('alt'))
+            || (photoId ? 'photo_' + photoId : 'photo_' + String(rows.length + 1));
+
+          if (!detailUrl || !thumbUrl || !imageUrl) continue;
+
+          rows.push({
+            photoId,
+            title,
+            imageUrl,
+            thumbUrl,
+            detailUrl,
+            page: pageNumber,
+          });
+        }
+        return rows;
+      };
+
+      const subjectTitle = getTitle(document);
+      const seen = new Set();
+      const photos = [];
+
+      for (let pageIndex = 0; photos.length < limit; pageIndex += 1) {
+        let doc = document;
+        if (pageIndex > 0) {
+          const response = await fetch(buildPageUrl(pageIndex * pageSize), { credentials: 'include' });
+          if (!response.ok) break;
+          const html = await response.text();
+          doc = new DOMParser().parseFromString(html, 'text/html');
+        }
+
+        const pagePhotos = extractPhotos(doc, pageIndex + 1);
+        if (!pagePhotos.length) break;
+
+        let appended = 0;
+        let foundTarget = false;
+        for (const photo of pagePhotos) {
+          const key = photo.photoId || photo.detailUrl || photo.imageUrl;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          photos.push({
+            index: photos.length + 1,
+            ...photo,
+          });
+          appended += 1;
+          if (targetPhotoId && photo.photoId === targetPhotoId) {
+            foundTarget = true;
+            break;
+          }
+          if (photos.length >= limit) break;
+        }
+
+        if (foundTarget || pagePhotos.length < pageSize || appended === 0) break;
+      }
+
+      return {
+        subjectId,
+        subjectTitle,
+        type,
+        photos,
+      };
+    })()
+  `);
+    const photos = Array.isArray(data?.photos) ? data.photos : [];
+    if (!photos.length) {
+        throw new EmptyResultError('douban photos', 'No photos found. Try a different subject ID or a different --type value such as Rb.');
+    }
+    return {
+        subjectId: normalizedId,
+        subjectTitle: String(data?.subjectTitle || '').trim(),
+        type,
+        photos,
+    };
+}
 export async function loadDoubanBookHot(page, limit) {
     const safeLimit = clampLimit(limit);
     await page.goto('https://book.douban.com/chart');

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

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

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

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

package/dist/clis/imdb/person.d.ts

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