@jackwener/opencli 1.7.5 → 1.7.7

package/clis/web/read.js

@@ -15,7 +15,7 @@
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { downloadArticle } from '@jackwener/opencli/download/article-download';
-cli({
+const command = cli({
     site: 'web',
     name: 'read',
     description: 'Fetch any web page and export as Markdown',
@@ -26,6 +26,7 @@ cli({
         { name: 'output', default: './web-articles', help: 'Output directory' },
         { name: 'download-images', type: 'boolean', default: true, help: 'Download images locally' },
         { name: 'wait', type: 'int', default: 3, help: 'Seconds to wait after page load' },
+        { name: 'stdout', type: 'boolean', default: false, help: 'Print markdown to stdout instead of saving to a file' },
     ],
     columns: ['title', 'author', 'publish_time', 'status', 'size', 'saved'],
     func: async (page, kwargs) => {
@@ -162,14 +163,26 @@ cli({
           if (el.children && el.children.length > 2) dedup(el);
         });
 
+        // --- Lazy-load image src rewrite ---
+        // Many sites render <img src="placeholder.gif" data-src="real.jpg">.
+        // Promote the real URL onto src so both the markdown body and the
+        // image download list reference the same URL.
+        clone.querySelectorAll('img').forEach(img => {
+          const srcset = img.getAttribute('data-srcset') || '';
+          const srcsetFirst = srcset.split(',')[0]?.trim().split(' ')[0] || '';
+          const real = img.getAttribute('data-src')
+            || img.getAttribute('data-original')
+            || img.getAttribute('data-lazy-src')
+            || srcsetFirst;
+          if (real) img.setAttribute('src', real);
+        });
+
         result.contentHtml = clone.innerHTML;
 
         // --- Image extraction ---
         const seen = new Set();
         clone.querySelectorAll('img').forEach(img => {
-          const src = img.getAttribute('data-src')
-            || img.getAttribute('data-original')
-            || img.getAttribute('src');
+          const src = img.getAttribute('src') || '';
           if (src && !src.startsWith('data:') && !seen.has(src)) {
             seen.add(src);
             result.imageUrls.push(src);
@@ -186,7 +199,7 @@ cli({
             referer = parsed.origin + '/';
         }
         catch { /* ignore */ }
-        return downloadArticle({
+        const result = await downloadArticle({
             title: data?.title || 'untitled',
             author: data?.author,
             publishTime: data?.publishTime,
@@ -197,6 +210,13 @@ cli({
             output: kwargs.output,
             downloadImages: kwargs['download-images'],
             imageHeaders: referer ? { Referer: referer } : undefined,
+            stdout: kwargs.stdout,
         });
+        // `--stdout` is a content-streaming mode. The markdown body already went
+        // to process.stdout inside downloadArticle(), so returning rows here
+        // would make Commander append table/JSON output to the same stdout
+        // stream and break piping.
+        return kwargs.stdout ? null : result;
     },
 });
+export const __test__ = { command };

package/clis/web/read.test.js

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockDownloadArticle } = vi.hoisted(() => ({
+    mockDownloadArticle: vi.fn(),
+}));
+
+vi.mock('@jackwener/opencli/download/article-download', () => ({
+    downloadArticle: mockDownloadArticle,
+}));
+
+const { __test__ } = await import('./read.js');
+
+describe('web/read stdout behavior', () => {
+    const read = __test__.command;
+    const page = {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue({
+            title: 'Example Article',
+            author: 'Author',
+            publishTime: '2026-04-22',
+            contentHtml: '<p>hello</p>',
+            imageUrls: ['https://example.com/a.jpg'],
+        }),
+    };
+
+    beforeEach(() => {
+        mockDownloadArticle.mockReset();
+        mockDownloadArticle.mockResolvedValue([{
+            title: 'Example Article',
+            author: 'Author',
+            publish_time: '2026-04-22',
+            status: 'success',
+            size: '1 KB',
+            saved: '-',
+        }]);
+        page.goto.mockClear();
+        page.wait.mockClear();
+        page.evaluate.mockClear();
+    });
+
+    it('returns null in --stdout mode so the CLI does not append result rows to stdout', async () => {
+        const result = await read.func(page, {
+            url: 'https://example.com/article',
+            output: '/tmp/out',
+            'download-images': false,
+            stdout: true,
+        });
+
+        expect(result).toBeNull();
+        expect(mockDownloadArticle).toHaveBeenCalledWith(
+            expect.objectContaining({
+                title: 'Example Article',
+                sourceUrl: 'https://example.com/article',
+            }),
+            expect.objectContaining({
+                output: '/tmp/out',
+                stdout: true,
+            }),
+        );
+    });
+
+    it('still returns the saved-row payload when writing to disk', async () => {
+        const rows = [{ title: 'Example Article', saved: '/tmp/out/Example Article/example.md' }];
+        mockDownloadArticle.mockResolvedValue(rows);
+
+        const result = await read.func(page, {
+            url: 'https://example.com/article',
+            output: '/tmp/out',
+            'download-images': false,
+            stdout: false,
+        });
+
+        expect(result).toBe(rows);
+    });
+});

package/clis/weread/ai-outline.js

@@ -0,0 +1,170 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CliError } from '@jackwener/opencli/errors';
+import { WEREAD_UA, WEREAD_WEB_ORIGIN, WEREAD_DOMAIN } from './utils.js';
+
+const WEB_API = `${WEREAD_WEB_ORIGIN}/web`;
+
+function buildCookieHeader(cookies) {
+    return cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+}
+
+async function postWebApiWithCookies(page, path, body) {
+    const url = `${WEB_API}${path}`;
+    const [apiCookies, domainCookies] = await Promise.all([
+        page.getCookies({ url }),
+        page.getCookies({ domain: WEREAD_DOMAIN }),
+    ]);
+    const merged = new Map();
+    for (const c of domainCookies) merged.set(c.name, c);
+    for (const c of apiCookies) merged.set(c.name, c);
+    const cookieHeader = buildCookieHeader(Array.from(merged.values()));
+
+    const resp = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'User-Agent': WEREAD_UA,
+            'Content-Type': 'application/json',
+            'Origin': WEREAD_WEB_ORIGIN,
+            'Referer': `${WEREAD_WEB_ORIGIN}/`,
+            ...(cookieHeader ? { 'Cookie': cookieHeader } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+
+    if (resp.status === 401) {
+        throw new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first');
+    }
+
+    let data;
+    try {
+        data = await resp.json();
+    } catch {
+        throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
+    }
+
+    if (data?.errcode === -2010 || data?.errcode === -2012) {
+        throw new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first');
+    }
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `HTTP ${resp.status} for ${path}`, 'WeRead API may be temporarily unavailable');
+    }
+    return data;
+}
+
+async function postWebApi(path, body) {
+    const url = `${WEB_API}${path}`;
+    const resp = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'User-Agent': WEREAD_UA,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `HTTP ${resp.status} for ${path}`, 'WeRead API may be temporarily unavailable');
+    }
+    try {
+        return await resp.json();
+    } catch {
+        throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
+    }
+}
+
+cli({
+    site: 'weread',
+    name: 'ai-outline',
+    description: 'Get AI-generated outline for a book',
+    domain: 'weread.qq.com',
+    strategy: Strategy.COOKIE,
+    defaultFormat: 'plain',
+    args: [
+        { name: 'book-id', positional: true, required: true, help: 'Book ID (from shelf or search results)' },
+        { name: 'limit', type: 'int', default: 200, help: 'Max outline items to return' },
+        { name: 'depth', type: 'int', default: 4, help: 'Max outline depth (2=topics, 3=key points, 4=details)' },
+        { name: 'raw', type: 'boolean', default: false, help: 'Output structured rows (chapter/idx/level/text) for programmatic use' },
+    ],
+    columns: undefined,
+    func: async (page, args) => {
+        const bookId = String(args['book-id'] || '').trim();
+        const rawMode = Boolean(args.raw);
+
+        const chapterData = await postWebApiWithCookies(page, '/book/chapterInfos', {
+            bookIds: [bookId],
+            sinces: [0],
+        });
+        const chapters = chapterData?.data?.[0]?.updated ?? [];
+        if (chapters.length === 0) {
+            throw new CliError('NOT_FOUND', 'No chapters found for this book', 'Check that the book ID is correct');
+        }
+
+        const chapterUids = chapters.map((c) => c.chapterUid);
+        const chapterNameMap = new Map();
+        for (const c of chapters) {
+            chapterNameMap.set(c.chapterUid, c.title ?? '');
+        }
+
+        const outlineData = await postWebApi('/book/outline', {
+            bookId,
+            chapterUids,
+        });
+
+        const itemsArray = outlineData?.itemsArray ?? [];
+        const maxDepth = Number(args.depth);
+        const rawRows = [];
+
+        for (const entry of itemsArray) {
+            const items = entry.items;
+            if (!Array.isArray(items) || items.length === 0) continue;
+
+            const chapterName = chapterNameMap.get(entry.chapterUid) ?? `Chapter ${entry.chapterUid}`;
+            let lastL3Idx = '';
+            let l4Counter = 0;
+
+            for (const item of items) {
+                const level = item.level ?? 1;
+                if (level <= 1) continue;
+                if (level > maxDepth) continue;
+
+                let idx = item.uiIdx ?? '';
+                if (level === 3 && idx) {
+                    lastL3Idx = idx;
+                    l4Counter = 0;
+                }
+                if (level === 4 && !idx && lastL3Idx) {
+                    l4Counter++;
+                    idx = `${lastL3Idx}.${l4Counter}`;
+                }
+
+                rawRows.push({ chapter: chapterName, idx, level, text: item.text ?? '' });
+            }
+        }
+
+        if (rawRows.length === 0) {
+            throw new CliError('NOT_FOUND', 'No AI outline available for this book', 'AI outlines may not be generated for all books');
+        }
+
+        if (rawMode) {
+            return rawRows.slice(0, Number(args.limit));
+        }
+
+        const grouped = new Map();
+        for (const row of rawRows) {
+            if (!grouped.has(row.chapter)) grouped.set(row.chapter, []);
+            grouped.get(row.chapter).push(row);
+        }
+
+        const results = [];
+        for (const [chapter, rows] of grouped) {
+            const lines = [`📖 ${chapter}`];
+            for (const row of rows) {
+                const indent = '  '.repeat(row.level - 2);
+                const prefix = row.level === 2 ? `${row.idx}. ` : `${row.idx} `;
+                lines.push(`${indent}${prefix}${row.text}`);
+            }
+            results.push({ outline: lines.join('\n') });
+        }
+
+        return results.slice(0, Number(args.limit));
+    },
+});

package/clis/weread/ai-outline.test.js

@@ -0,0 +1,83 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './ai-outline.js';
+
+describe('weread ai-outline', () => {
+    const command = getRegistry().get('weread/ai-outline');
+
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it('registers ai-outline with plain default output', () => {
+        expect(command?.defaultFormat).toBe('plain');
+    });
+
+    it('maps chapterInfos auth-expired responses to AUTH_REQUIRED', async () => {
+        expect(command?.func).toBeTypeOf('function');
+        const page = {
+            getCookies: vi.fn()
+                .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid123', domain: '.weread.qq.com' }])
+                .mockResolvedValueOnce([{ name: 'wr_name', value: 'alice', domain: '.weread.qq.com' }]),
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ errcode: -2012, errmsg: '登录超时' }),
+        }));
+        await expect(command.func(page, { 'book-id': 'book-1' })).rejects.toMatchObject({
+            code: 'AUTH_REQUIRED',
+            message: 'Not logged in to WeRead',
+        });
+    });
+
+    it('returns structured rows for --raw and respects depth filtering', async () => {
+        expect(command?.func).toBeTypeOf('function');
+        const page = {
+            getCookies: vi.fn()
+                .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid123', domain: '.weread.qq.com' }])
+                .mockResolvedValueOnce([{ name: 'wr_name', value: 'alice', domain: '.weread.qq.com' }]),
+        };
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({
+                data: [{
+                        updated: [
+                            { chapterUid: 'c1', title: '第一章' },
+                        ],
+                    }],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({
+                itemsArray: [{
+                        chapterUid: 'c1',
+                        items: [
+                            { level: 2, uiIdx: '1', text: '主题一' },
+                            { level: 3, uiIdx: '1.1', text: '要点一' },
+                            { level: 4, text: '细节一' },
+                        ],
+                    }],
+            }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const rows = await command.func(page, { 'book-id': 'book-1', raw: true, depth: 3, limit: 10 });
+        expect(rows).toEqual([
+            { chapter: '第一章', idx: '1', level: 2, text: '主题一' },
+            { chapter: '第一章', idx: '1.1', level: 3, text: '要点一' },
+        ]);
+        expect(fetchMock).toHaveBeenNthCalledWith(1, 'https://weread.qq.com/web/book/chapterInfos', expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+                Cookie: 'wr_name=alice; wr_vid=vid123',
+            }),
+        }));
+        expect(fetchMock).toHaveBeenNthCalledWith(2, 'https://weread.qq.com/web/book/outline', expect.objectContaining({
+            method: 'POST',
+        }));
+    });
+});

package/clis/weread/book.js

@@ -37,6 +37,61 @@ function countSearchIdentities(entries) {
     }
     return counts;
 }
+export function strictTitleFromWereadDocumentTitle(rawTitle) {
+    const suffix = ' - 微信读书';
+    const normalized = String(rawTitle || '').trim();
+    if (!normalized.endsWith(suffix))
+        return '';
+    const base = normalized.slice(0, -suffix.length).trim();
+    // Only accept the title when WeRead exposes the strict "<title> - 微信读书"
+    // shape. If extra separators remain, the page title is ambiguous.
+    return base.includes(' - ') ? '' : base;
+}
+export function extractReaderFallbackMetadata(doc) {
+    const text = (node) => node?.textContent?.trim() || '';
+    const firstText = (...sels) => { for (const s of sels) {
+        const v = text(doc.querySelector(s));
+        if (v)
+            return v;
+    } return ''; };
+    const bodyText = doc.body?.innerText?.replace(/\s+/g, ' ').trim() || '';
+    const extractRating = () => {
+        const match = bodyText.match(/微信读书推荐值\s*([0-9.]+%)/);
+        return match ? match[1] : '';
+    };
+    const extractPublisher = () => {
+        const direct = text(doc.querySelector('.introDialog_content_pub_line'));
+        return direct.startsWith('出版社') ? direct.replace(/^出版社\s*/, '').trim() : '';
+    };
+    const extractIntro = () => {
+        const selectors = [
+            '.horizontalReaderCoverPage_content_bookInfo_intro',
+            '.wr_flyleaf_page_bookIntro_content',
+            '.introDialog_content_intro_para',
+        ];
+        for (const selector of selectors) {
+            const value = text(doc.querySelector(selector));
+            if (value)
+                return value;
+        }
+        return '';
+    };
+    const categorySource = Array.from(doc.scripts || [])
+        .map((script) => script.textContent || '')
+        .find((scriptText) => scriptText.includes('"category"')) || '';
+    const categoryMatch = categorySource.match(/"category"\s*:\s*"([^"]+)"/);
+    const title = firstText('.horizontalReaderCoverPage_content_bookTitle', '.wr_flyleaf_page_bookInfo_bookTitle', '.outline_book_detail_header_title', '.readerTopBar_title_link') || strictTitleFromWereadDocumentTitle(doc.title || '');
+    const author = firstText('.horizontalReaderCoverPage_content_author', '.wr_flyleaf_page_bookInfo_author', '.outline_book_detail_header_author');
+    return {
+        title,
+        author,
+        publisher: extractPublisher(),
+        intro: extractIntro(),
+        category: categoryMatch ? categoryMatch[1].trim() : '',
+        rating: extractRating(),
+        metadataReady: Boolean(title || author),
+    };
+}
 /**
  * Reuse the public search page as a last-resort reader URL source when the
  * cached shelf page cannot provide a trustworthy bookId-to-reader mapping.
@@ -108,51 +163,9 @@ async function resolveSearchReaderUrl(title, author) {
  */
 async function loadReaderFallbackResult(page, readerUrl) {
     await page.goto(readerUrl);
-    await page.wait({ selector: '.horizontalReaderCoverPage_content_bookTitle, .wr_flyleaf_page_bookInfo_bookTitle', timeout: 10 });
+    await page.wait({ selector: '.horizontalReaderCoverPage_content_bookTitle, .wr_flyleaf_page_bookInfo_bookTitle, .readerTopBar_title_link', timeout: 10 });
     const result = await page.evaluate(`
-    (() => {
-      const text = (node) => node?.textContent?.trim() || '';
-      const bodyText = document.body?.innerText?.replace(/\\s+/g, ' ').trim() || '';
-      const titleSelector = '.horizontalReaderCoverPage_content_bookTitle, .wr_flyleaf_page_bookInfo_bookTitle';
-      const authorSelector = '.horizontalReaderCoverPage_content_author, .wr_flyleaf_page_bookInfo_author';
-      const extractRating = () => {
-        const match = bodyText.match(/微信读书推荐值\\s*([0-9.]+%)/);
-        return match ? match[1] : '';
-      };
-      const extractPublisher = () => {
-        const direct = text(document.querySelector('.introDialog_content_pub_line'));
-        return direct.startsWith('出版社') ? direct.replace(/^出版社\\s*/, '').trim() : '';
-      };
-      const extractIntro = () => {
-        const selectors = [
-          '.horizontalReaderCoverPage_content_bookInfo_intro',
-          '.wr_flyleaf_page_bookIntro_content',
-          '.introDialog_content_intro_para',
-        ];
-        for (const selector of selectors) {
-          const value = text(document.querySelector(selector));
-          if (value) return value;
-        }
-        return '';
-      };
-
-      const categorySource = Array.from(document.scripts)
-        .map((script) => script.textContent || '')
-        .find((scriptText) => scriptText.includes('"category"')) || '';
-      const categoryMatch = categorySource.match(/"category"\\s*:\\s*"([^"]+)"/);
-      const title = text(document.querySelector(titleSelector));
-      const author = text(document.querySelector(authorSelector));
-
-      return {
-        title,
-        author,
-        publisher: extractPublisher(),
-        intro: extractIntro(),
-        category: categoryMatch ? categoryMatch[1].trim() : '',
-        rating: extractRating(),
-        metadataReady: Boolean(title || author),
-      };
-    })()
+    (${extractReaderFallbackMetadata.toString()})(document)
   `);
     return {
         title: String(result?.title || '').trim(),

package/clis/weread/commands.test.js

@@ -14,6 +14,7 @@ import { getRegistry } from '@jackwener/opencli/registry';
 import './book.js';
 import './highlights.js';
 import './notes.js';
+import { extractReaderFallbackMetadata, strictTitleFromWereadDocumentTitle } from './book.js';
 describe('weread book-id positional args', () => {
     const book = getRegistry().get('weread/book');
     const highlights = getRegistry().get('weread/highlights');
@@ -356,6 +357,29 @@ describe('weread book-id positional args', () => {
             message: 'Not logged in to WeRead',
         });
     });
+    it('does not guess author from document.title when the reader page skips cover metadata', async () => {
+        const nodes = new Map([
+            ['.readerTopBar_title_link', { textContent: 'Part 1 - Part 2' }],
+            ['.introDialog_content_pub_line', { textContent: '出版社 测试出版社' }],
+            ['.introDialog_content_intro_para', { textContent: '测试简介。' }],
+        ]);
+        const mockDocument = {
+            title: 'Part 1 - Part 2 - 作者甲 - 微信读书',
+            body: { innerText: '微信读书推荐值 88.8%' },
+            scripts: [],
+            querySelector: (selector) => nodes.get(selector) || null,
+        };
+        expect(strictTitleFromWereadDocumentTitle(mockDocument.title)).toBe('');
+        expect(extractReaderFallbackMetadata(mockDocument)).toEqual({
+            title: 'Part 1 - Part 2',
+            author: '',
+            publisher: '测试出版社',
+            intro: '测试简介。',
+            category: '',
+            rating: '88.8%',
+            metadataReady: true,
+        });
+    });
     it('passes the positional book-id to highlights', async () => {
         mockFetchPrivateApi.mockResolvedValue({ updated: [] });
         await highlights.func({}, { 'book-id': 'abc', limit: 5 });

package/clis/xiaoyuzhou/podcast-episodes.js

@@ -20,9 +20,9 @@ cli({
             throw new CliError('INVALID_ARGUMENT', 'limit must be a positive integer', 'Example: --limit 5');
         }
         const credentials = loadXiaoyuzhouCredentials();
-        const response = await requestXiaoyuzhouJson('/v1/podcast/listEpisode', {
+        const response = await requestXiaoyuzhouJson('/v1/episode/list', {
             method: 'POST',
-            body: { pid: args.id, limit: requestedLimit },
+            body: { pid: args.id, order: 'desc', limit: requestedLimit },
             credentials,
         });
         const episodes = response.data ?? [];

package/clis/xiaoyuzhou/podcast-episodes.test.js

@@ -0,0 +1,78 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+
+const { mockRequestJson, mockLoadCredentials } = vi.hoisted(() => ({
+    mockRequestJson: vi.fn(),
+    mockLoadCredentials: vi.fn(),
+}));
+
+vi.mock('./auth.js', async () => {
+    const actual = await vi.importActual('./auth.js');
+    return {
+        ...actual,
+        requestXiaoyuzhouJson: mockRequestJson,
+        loadXiaoyuzhouCredentials: mockLoadCredentials,
+    };
+});
+
+await import('./podcast-episodes.js');
+
+let cmd;
+
+beforeAll(() => {
+    cmd = getRegistry().get('xiaoyuzhou/podcast-episodes');
+    expect(cmd?.func).toBeTypeOf('function');
+});
+
+describe('xiaoyuzhou podcast-episodes', () => {
+    beforeEach(() => {
+        mockRequestJson.mockReset();
+        mockLoadCredentials.mockReset();
+        mockLoadCredentials.mockReturnValue({ access_token: 'access', refresh_token: 'refresh' });
+    });
+
+    it('calls the fixed episode list endpoint with desc ordering', async () => {
+        mockRequestJson.mockResolvedValue({
+            data: [
+                {
+                    eid: 'ep-1',
+                    title: 'Episode 1',
+                    duration: 3661,
+                    playCount: 42,
+                    pubDate: '2026-04-20T10:00:00.000Z',
+                },
+            ],
+        });
+
+        const result = await cmd.func(null, {
+            id: 'podcast-1',
+            limit: 3,
+        });
+
+        expect(mockRequestJson).toHaveBeenCalledWith('/v1/episode/list', {
+            method: 'POST',
+            body: { pid: 'podcast-1', order: 'desc', limit: 3 },
+            credentials: { access_token: 'access', refresh_token: 'refresh' },
+        });
+        expect(result).toEqual([
+            {
+                eid: 'ep-1',
+                title: 'Episode 1',
+                duration: '61:01',
+                plays: 42,
+                date: '2026-04-20',
+            },
+        ]);
+    });
+
+    it('rejects non-positive limits before hitting the API', async () => {
+        await expect(cmd.func(null, {
+            id: 'podcast-1',
+            limit: 0,
+        })).rejects.toMatchObject({
+            code: 'INVALID_ARGUMENT',
+            message: 'limit must be a positive integer',
+        });
+        expect(mockRequestJson).not.toHaveBeenCalled();
+    });
+});