@jackwener/opencli 1.4.0 → 1.5.0

package/src/clis/chatgpt/ask.ts

@@ -2,7 +2,7 @@ import { execSync, spawnSync } from 'node:child_process';
 import { cli, Strategy } from '../../registry.js';
 import { ConfigError } from '../../errors.js';
 import type { IPage } from '../../types.js';
-import { getVisibleChatMessages } from './ax.js';
+import { activateChatGPT, getVisibleChatMessages, selectModel, MODEL_CHOICES, isGenerating } from './ax.js';
 
 export const askCommand = cli({
   site: 'chatgpt',
@@ -13,6 +13,7 @@ export const askCommand = cli({
   browser: false,
   args: [
     { name: 'text', required: true, positional: true, help: 'Prompt to send' },
+    { name: 'model', required: false, help: 'Model/mode to use: auto, instant, thinking, 5.2-instant, 5.2-thinking', choices: MODEL_CHOICES },
     { name: 'timeout', required: false, help: 'Max seconds to wait for response (default: 30)', default: '30' },
   ],
   columns: ['Role', 'Text'],
@@ -22,8 +23,15 @@ export const askCommand = cli({
     }
 
     const text = kwargs.text as string;
+    const model = kwargs.model as string | undefined;
     const timeout = parseInt(kwargs.timeout as string, 10) || 30;
 
+    // Switch model before sending if requested
+    if (model) {
+      activateChatGPT();
+      selectModel(model);
+    }
+
     // Backup clipboard
     let clipBackup = '';
     try { clipBackup = execSync('pbpaste', { encoding: 'utf-8' }); } catch {}
@@ -31,8 +39,7 @@ export const askCommand = cli({
 
     // Send the message
     spawnSync('pbcopy', { input: text });
-    execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
-    execSync("osascript -e 'delay 0.5'");
+    activateChatGPT();
 
     const cmd = "osascript " +
                 "-e 'tell application \"System Events\"' " +
@@ -45,25 +52,32 @@ export const askCommand = cli({
     // Restore clipboard after the prompt is sent.
     if (clipBackup) spawnSync('pbcopy', { input: clipBackup });
 
-    // Wait for response, then read the latest visible assistant message from the AX tree.
-    const pollInterval = 1;
+    // Wait for response: poll until ChatGPT stops generating ("Stop generating" button disappears),
+    // then read the final response text.
+    const pollInterval = 2;
     const maxPolls = Math.ceil(timeout / pollInterval);
     let response = '';
+    let generationStarted = false;
 
     for (let i = 0; i < maxPolls; i++) {
       execSync(`sleep ${pollInterval}`);
-      execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
-      execSync("osascript -e 'delay 0.2'");
+      const generating = isGenerating();
+      if (generating) {
+        generationStarted = true;
+        continue;
+      }
+      // Generation finished (or never started yet)
+      if (!generationStarted && i < 3) continue; // give it a moment to start
 
+      // Read final response
+      activateChatGPT(0.3);
       const messagesNow = getVisibleChatMessages();
-      if (messagesNow.length <= messagesBefore.length) continue;
-
-      const newMessages = messagesNow.slice(messagesBefore.length);
-      const candidate = [...newMessages].reverse().find((message) => message !== text);
-      if (candidate) {
-        response = candidate;
-        break;
+      if (messagesNow.length > messagesBefore.length) {
+        const newMessages = messagesNow.slice(messagesBefore.length);
+        const candidate = [...newMessages].reverse().find((message) => message !== text);
+        if (candidate) response = candidate;
       }
+      break;
     }
 
     if (!response) {

package/src/clis/chatgpt/ax.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from 'node:child_process';
+import { execFileSync, execSync } from 'node:child_process';
 
 const AX_READ_SCRIPT = `
 import Cocoa
@@ -62,6 +62,185 @@ let data = try! JSONSerialization.data(withJSONObject: best, options: [])
 print(String(data: data, encoding: .utf8)!)
 `;
 
+const AX_MODEL_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String, !v.isEmpty { return v }
+    return nil
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func press(_ el: AXUIElement) {
+    AXUIElementPerformAction(el, kAXPressAction as CFString)
+}
+
+func findByDesc(_ el: AXUIElement, _ target: String, prefix: Bool = false, depth: Int = 0) -> AXUIElement? {
+    guard depth < 20 else { return nil }
+    let desc = s(el, kAXDescriptionAttribute as String) ?? ""
+    if prefix ? desc.hasPrefix(target) : (desc == target) { return el }
+    for c in children(el) {
+        if let found = findByDesc(c, target, prefix: prefix, depth: depth + 1) { return found }
+    }
+    return nil
+}
+
+func findPopover(_ el: AXUIElement, depth: Int = 0) -> AXUIElement? {
+    guard depth < 20 else { return nil }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if role == "AXPopover" { return el }
+    for c in children(el) {
+        if let found = findPopover(c, depth: depth + 1) { return found }
+    }
+    return nil
+}
+
+func pressEscape() {
+    let src = CGEventSource(stateID: .combinedSessionState)
+    if let esc = CGEvent(keyboardEventSource: src, virtualKey: 0x35, keyDown: true) { esc.post(tap: .cghidEventTap) }
+    if let esc = CGEvent(keyboardEventSource: src, virtualKey: 0x35, keyDown: false) { esc.post(tap: .cghidEventTap) }
+}
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    fputs("ChatGPT not running\\n", stderr); exit(1)
+}
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    fputs("No focused ChatGPT window\\n", stderr); exit(1)
+}
+
+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 {
+    fputs("Could not find Options button\\n", stderr); exit(1)
+}
+press(optionsBtn)
+Thread.sleep(forTimeInterval: 0.8)
+
+// Step 2: Find the popover that appeared, search ONLY within it
+guard let popover = findPopover(win) else {
+    pressEscape()
+    fputs("Popover did not appear\\n", stderr); exit(1)
+}
+
+// Step 3: If legacy, click "Legacy models" to expand submenu
+if needsLegacy {
+    guard let legacyBtn = findByDesc(popover, "Legacy models") else {
+        pressEscape()
+        fputs("Could not find Legacy models button\\n", stderr); exit(1)
+    }
+    press(legacyBtn)
+    Thread.sleep(forTimeInterval: 0.8)
+}
+
+// Step 4: Click the target model button within the popover (prefix match)
+guard let modelBtn = findByDesc(popover, target, prefix: true) else {
+    pressEscape()
+    fputs("Could not find button starting with '\\(target)' in popover\\n", stderr); exit(1)
+}
+press(modelBtn)
+print("Selected: \\(target)")
+`;
+
+const AX_GENERATING_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String, !v.isEmpty { return v }
+    return nil
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func hasButton(_ el: AXUIElement, desc target: String, depth: Int = 0) -> Bool {
+    guard depth < 15 else { return false }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    let desc = s(el, kAXDescriptionAttribute as String) ?? ""
+    if role == "AXButton" && desc == target { return true }
+    for c in children(el) {
+        if hasButton(c, desc: target, depth: depth + 1) { return true }
+    }
+    return false
+}
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    print("false"); exit(0)
+}
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    print("false"); exit(0)
+}
+print(hasButton(win, desc: "Stop generating") ? "true" : "false")
+`;
+
+type ModelChoice = 'auto' | 'instant' | 'thinking' | '5.2-instant' | '5.2-thinking';
+
+const MODEL_MAP: Record<ModelChoice, { desc: string; legacy?: boolean }> = {
+  'auto':         { desc: 'Auto' },
+  'instant':      { desc: 'Instant' },
+  'thinking':     { desc: 'Thinking' },
+  '5.2-instant':  { desc: 'GPT-5.2 Instant',  legacy: true },
+  '5.2-thinking': { desc: 'GPT-5.2 Thinking', legacy: true },
+};
+
+export const MODEL_CHOICES = Object.keys(MODEL_MAP) as ModelChoice[];
+
+export function activateChatGPT(delaySeconds: number = 0.5): void {
+  execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+  execSync(`osascript -e 'delay ${delaySeconds}'`);
+}
+
+export function selectModel(model: string): string {
+  const entry = MODEL_MAP[model as ModelChoice];
+  if (!entry) {
+    throw new Error(`Unknown model "${model}". Choose from: ${MODEL_CHOICES.join(', ')}`);
+  }
+  const swiftArgs = ['-', entry.desc];
+  if (entry.legacy) swiftArgs.push('legacy');
+
+  const output = execFileSync('swift', swiftArgs, {
+    input: AX_MODEL_SCRIPT,
+    encoding: 'utf-8',
+    maxBuffer: 10 * 1024 * 1024,
+  }).trim();
+  return output;
+}
+
+export function isGenerating(): boolean {
+  try {
+    const output = execFileSync('swift', ['-'], {
+      input: AX_GENERATING_SCRIPT,
+      encoding: 'utf-8',
+      maxBuffer: 10 * 1024 * 1024,
+    }).trim();
+    return output === 'true';
+  } catch {
+    return false;
+  }
+}
+
 export function getVisibleChatMessages(): string[] {
   const output = execFileSync('swift', ['-'], {
     input: AX_READ_SCRIPT,

package/src/clis/chatgpt/model.ts

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../registry.js';
+import { ConfigError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+import { activateChatGPT, selectModel, MODEL_CHOICES } from './ax.js';
+
+export const modelCommand = cli({
+  site: 'chatgpt',
+  name: 'model',
+  description: 'Switch ChatGPT Desktop model/mode (auto, instant, thinking, 5.2-instant, 5.2-thinking)',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'model', required: true, positional: true, help: 'Model to switch to', choices: MODEL_CHOICES },
+  ],
+  columns: ['Status', 'Model'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (process.platform !== 'darwin') {
+      throw new ConfigError('ChatGPT Desktop integration requires macOS');
+    }
+
+    const model = kwargs.model as string;
+    activateChatGPT();
+    const result = selectModel(model);
+    return [{ Status: 'Success', Model: result }];
+  },
+});

package/src/clis/chatgpt/send.ts

@@ -2,6 +2,7 @@ import { execSync, spawnSync } from 'node:child_process';
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
 import { getErrorMessage } from '../../errors.js';
+import { activateChatGPT, selectModel, MODEL_CHOICES } from './ax.js';
 
 export const sendCommand = cli({
   site: 'chatgpt',
@@ -10,11 +11,21 @@ export const sendCommand = cli({
   domain: 'localhost',
   strategy: Strategy.PUBLIC,
   browser: false,
-  args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
+  args: [
+    { name: 'text', required: true, positional: true, help: 'Message to send' },
+    { name: 'model', required: false, help: 'Model/mode to use: auto, instant, thinking, 5.2-instant, 5.2-thinking', choices: MODEL_CHOICES },
+  ],
   columns: ['Status'],
   func: async (page: IPage | null, kwargs: any) => {
     const text = kwargs.text as string;
+    const model = kwargs.model as string | undefined;
     try {
+      // Switch model before sending if requested
+      if (model) {
+        activateChatGPT();
+        selectModel(model);
+      }
+
       // Backup current clipboard content
       let clipBackup = '';
       try {
@@ -23,17 +34,16 @@ export const sendCommand = cli({
 
       // Copy text to clipboard
       spawnSync('pbcopy', { input: text });
-      
-      execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
-      execSync("osascript -e 'delay 0.5'");
-      
+
+      activateChatGPT();
+
       const cmd = "osascript " +
                   "-e 'tell application \"System Events\"' " +
                   "-e 'keystroke \"v\" using command down' " +
                   "-e 'delay 0.2' " +
                   "-e 'keystroke return' " +
                   "-e 'end tell'";
-                     
+
       execSync(cmd);
 
       // Restore original clipboard content

package/src/clis/ctrip/search.ts

@@ -1,6 +1,5 @@
 /**
  * 携程旅行搜索 — browser cookie, multi-strategy.
- * Source: bb-sites/ctrip/search.js (simplified to suggestion API)
  */
 import { cli, Strategy } from '../../registry.js';
 

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,
+    }));
+  },
+});