@jackwener/opencli 1.4.1 → 1.5.0

package/dist/clis/chatgpt/ask.js

@@ -1,7 +1,7 @@
 import { execSync, spawnSync } from 'node:child_process';
 import { cli, Strategy } from '../../registry.js';
 import { ConfigError } from '../../errors.js';
-import { getVisibleChatMessages } from './ax.js';
+import { activateChatGPT, getVisibleChatMessages, selectModel, MODEL_CHOICES, isGenerating } from './ax.js';
 export const askCommand = cli({
     site: 'chatgpt',
     name: 'ask',
@@ -11,6 +11,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'],
@@ -19,7 +20,13 @@ export const askCommand = cli({
             throw new ConfigError('ChatGPT Desktop integration requires macOS (osascript is not available on this platform)');
         }
         const text = kwargs.text;
+        const model = kwargs.model;
         const timeout = parseInt(kwargs.timeout, 10) || 30;
+        // Switch model before sending if requested
+        if (model) {
+            activateChatGPT();
+            selectModel(model);
+        }
         // Backup clipboard
         let clipBackup = '';
         try {
@@ -29,8 +36,7 @@ export const askCommand = cli({
         const messagesBefore = getVisibleChatMessages();
         // 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\"' " +
             "-e 'keystroke \"v\" using command down' " +
@@ -41,23 +47,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 messagesNow = getVisibleChatMessages();
-            if (messagesNow.length <= messagesBefore.length)
+            const generating = isGenerating();
+            if (generating) {
+                generationStarted = true;
                 continue;
-            const newMessages = messagesNow.slice(messagesBefore.length);
-            const candidate = [...newMessages].reverse().find((message) => message !== text);
-            if (candidate) {
-                response = candidate;
-                break;
             }
+            // 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) {
+                const newMessages = messagesNow.slice(messagesBefore.length);
+                const candidate = [...newMessages].reverse().find((message) => message !== text);
+                if (candidate)
+                    response = candidate;
+            }
+            break;
         }
         if (!response) {
             return [

package/dist/clis/chatgpt/ax.d.ts

@@ -1 +1,7 @@
+type ModelChoice = 'auto' | 'instant' | 'thinking' | '5.2-instant' | '5.2-thinking';
+export declare const MODEL_CHOICES: ModelChoice[];
+export declare function activateChatGPT(delaySeconds?: number): void;
+export declare function selectModel(model: string): string;
+export declare function isGenerating(): boolean;
 export declare function getVisibleChatMessages(): string[];
+export {};

package/dist/clis/chatgpt/ax.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'node:child_process';
+import { execFileSync, execSync } from 'node:child_process';
 const AX_READ_SCRIPT = `
 import Cocoa
 import ApplicationServices
@@ -60,6 +60,177 @@ for list in lists {
 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")
+`;
+const MODEL_MAP = {
+    '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);
+export function activateChatGPT(delaySeconds = 0.5) {
+    execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+    execSync(`osascript -e 'delay ${delaySeconds}'`);
+}
+export function selectModel(model) {
+    const entry = MODEL_MAP[model];
+    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() {
+    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() {
     const output = execFileSync('swift', ['-'], {
         input: AX_READ_SCRIPT,

package/dist/clis/chatgpt/model.d.ts

@@ -0,0 +1 @@
+export declare const modelCommand: import("../../registry.js").CliCommand;

package/dist/clis/chatgpt/model.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '../../registry.js';
+import { ConfigError } from '../../errors.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, kwargs) => {
+        if (process.platform !== 'darwin') {
+            throw new ConfigError('ChatGPT Desktop integration requires macOS');
+        }
+        const model = kwargs.model;
+        activateChatGPT();
+        const result = selectModel(model);
+        return [{ Status: 'Success', Model: result }];
+    },
+});

package/dist/clis/chatgpt/send.js

@@ -1,6 +1,7 @@
 import { execSync, spawnSync } from 'node:child_process';
 import { cli, Strategy } from '../../registry.js';
 import { getErrorMessage } from '../../errors.js';
+import { activateChatGPT, selectModel, MODEL_CHOICES } from './ax.js';
 export const sendCommand = cli({
     site: 'chatgpt',
     name: 'send',
@@ -8,11 +9,20 @@ 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, kwargs) => {
         const text = kwargs.text;
+        const model = kwargs.model;
         try {
+            // Switch model before sending if requested
+            if (model) {
+                activateChatGPT();
+                selectModel(model);
+            }
             // Backup current clipboard content
             let clipBackup = '';
             try {
@@ -21,8 +31,7 @@ export const sendCommand = cli({
             catch { /* clipboard may be empty */ }
             // 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' " +

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

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

package/dist/clis/douban/download.js

@@ -0,0 +1,67 @@
+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 { getDoubanPhotoExtension, loadDoubanSubjectPhotos, normalizeDoubanSubjectId } from './utils.js';
+function buildDoubanPhotoFilename(subjectId, photo) {
+    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 = {
+            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 = [];
+        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/dist/clis/douban/download.test.d.ts

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

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[]>;