@jackwener/opencli 1.4.1 → 1.5.1

package/src/clis/douban/download.test.ts

@@ -0,0 +1,196 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import path from 'node:path';
+import type { CliCommand } from '../../registry.js';
+import { getRegistry } from '../../registry.js';
+import type { IPage } from '../../types.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: string) => value.replace(/\s+/g, '_')),
+}));
+
+vi.mock('./utils.js', async () => {
+  const actual = await vi.importActual<typeof import('./utils.js')>('./utils.js');
+  return {
+    ...actual,
+    loadDoubanSubjectPhotos: mockLoadDoubanSubjectPhotos,
+  };
+});
+
+vi.mock('../../download/progress.js', () => ({
+  formatBytes: vi.fn((size: number) => `${size} B`),
+}));
+
+vi.mock('node:fs', () => ({
+  mkdirSync: mockMkdirSync,
+}));
+
+await import('./download.js');
+
+let cmd: CliCommand;
+
+beforeAll(() => {
+  cmd = getRegistry().get('douban/download')!;
+  expect(cmd?.func).toBeTypeOf('function');
+});
+
+function toPosixPath(value: string): string {
+  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 = {} as IPage;
+    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',
+    }) as Array<Record<string, unknown>>;
+
+    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 = {} as IPage;
+    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',
+    }) as Array<Record<string, unknown>>;
+
+    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!({} as IPage, { id: 'movie-30382501' }),
+    ).rejects.toThrow('Invalid Douban subject ID');
+
+    expect(mockHttpDownload).not.toHaveBeenCalled();
+  });
+});

package/src/clis/douban/download.ts

@@ -0,0 +1,78 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { formatBytes } from '../../download/progress.js';
+import { httpDownload, sanitizeFilename } from '../../download/index.js';
+import { EmptyResultError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import type { DoubanSubjectPhoto, LoadDoubanSubjectPhotosOptions } from './utils.js';
+import { getDoubanPhotoExtension, loadDoubanSubjectPhotos, normalizeDoubanSubjectId } from './utils.js';
+
+function buildDoubanPhotoFilename(subjectId: string, photo: DoubanSubjectPhoto): string {
+  const index = String(photo.index).padStart(3, '0');
+  const suffix = sanitizeFilename(photo.title || photo.photoId || 'photo', 80) || 'photo';
+  return `${subjectId}_${index}_${photo.photoId || 'photo'}_${suffix}${getDoubanPhotoExtension(photo.imageUrl)}`;
+}
+
+cli({
+  site: 'douban',
+  name: 'download',
+  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: '最多下载多少张图片' },
+    { name: 'photo-id', help: '只下载指定 photo_id 的图片' },
+    { name: 'output', default: './douban-downloads', help: '输出目录' },
+  ],
+  columns: ['index', 'title', 'status', 'size'],
+  func: async (page, kwargs) => {
+    const subjectId = normalizeDoubanSubjectId(String(kwargs.id || ''));
+    const output = String(kwargs.output || './douban-downloads');
+    const requestedPhotoId = String(kwargs['photo-id'] || '').trim();
+    const loadOptions: LoadDoubanSubjectPhotosOptions = {
+      type: String(kwargs.type || 'Rb'),
+    };
+    if (requestedPhotoId) loadOptions.targetPhotoId = requestedPhotoId;
+    else loadOptions.limit = Number(kwargs.limit) || 120;
+
+    const data = await loadDoubanSubjectPhotos(page, subjectId, loadOptions);
+
+    const photos = requestedPhotoId
+      ? data.photos.filter((photo) => photo.photoId === requestedPhotoId)
+      : data.photos;
+
+    if (requestedPhotoId && !photos.length) {
+      throw new EmptyResultError(
+        'douban download',
+        `Photo ID ${requestedPhotoId} was not found under subject ${subjectId}. Try "douban photos ${subjectId} -f json" first.`,
+      );
+    }
+
+    const outputDir = path.join(output, subjectId);
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    const results: Array<Record<string, unknown>> = [];
+    for (const photo of photos) {
+      const filename = buildDoubanPhotoFilename(subjectId, photo);
+      const destPath = path.join(outputDir, filename);
+      const result = await httpDownload(photo.imageUrl, destPath, {
+        headers: { Referer: photo.detailUrl || `https://movie.douban.com/subject/${subjectId}/photos?type=${encodeURIComponent(String(kwargs.type || 'Rb'))}` },
+        timeout: 60000,
+      });
+
+      results.push({
+        index: photo.index,
+        title: photo.title,
+        photo_id: photo.photoId,
+        image_url: photo.imageUrl,
+        detail_url: photo.detailUrl,
+        status: result.success ? 'success' : 'failed',
+        size: result.success ? formatBytes(result.size) : (result.error || 'unknown error'),
+      });
+    }
+
+    return results;
+  },
+});

package/src/clis/douban/photos.ts

@@ -0,0 +1,36 @@
+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/src/clis/douban/utils.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IPage } from '../../types.js';
+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,
+    } as unknown as IPage;
+
+    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/src/clis/douban/utils.ts

@@ -2,13 +2,20 @@
  * Douban adapter utilities.
  */
 
-import { CliError } from '../../errors.js';
+import { ArgumentError, CliError, EmptyResultError } from '../../errors.js';
 import type { IPage } from '../../types.js';
 
+const DOUBAN_PHOTO_PAGE_SIZE = 30;
+const MAX_DOUBAN_PHOTOS = 500;
+
 function clampLimit(limit: number): number {
   return Math.max(1, Math.min(limit || 20, 50));
 }
 
+function clampPhotoLimit(limit: number): number {
+  return Math.max(1, Math.min(limit || 120, MAX_DOUBAN_PHOTOS));
+}
+
 async function ensureDoubanReady(page: IPage): Promise<void> {
   const state = await page.evaluate(`
     (() => {
@@ -27,6 +34,230 @@ async function ensureDoubanReady(page: IPage): Promise<void> {
   }
 }
 
+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 function normalizeDoubanSubjectId(subjectId: string): string {
+  const normalized = String(subjectId || '').trim();
+  if (!/^\d+$/.test(normalized)) {
+    throw new ArgumentError(`Invalid Douban subject ID: ${subjectId}`);
+  }
+  return normalized;
+}
+
+export function promoteDoubanPhotoUrl(url: string, size: 's' | 'm' | 'l' = 'l'): string {
+  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: Array<string | null | undefined>,
+  baseUrl = '',
+): string {
+  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: string): string {
+  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: IPage,
+  subjectId: string,
+  options: LoadDoubanSubjectPhotosOptions = {},
+): Promise<DoubanSubjectPhotosResult> {
+  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: IPage, limit: number): Promise<any[]> {
   const safeLimit = clampLimit(limit);
   await page.goto('https://book.douban.com/chart');