@jackwener/opencli 1.7.2 → 1.7.4

package/clis/xiaohongshu/note.test.js

@@ -36,6 +36,9 @@ describe('parseNoteId', () => {
     it('extracts ID from /note/ URL', () => {
         expect(parseNoteId('https://www.xiaohongshu.com/note/69c131c9000000002800be4c')).toBe('69c131c9000000002800be4c');
     });
+    it('extracts ID from signed /user/profile/<user>/<note> URL', () => {
+        expect(parseNoteId('https://www.xiaohongshu.com/user/profile/user123/69c131c9000000002800be4c?xsec_token=abc&xsec_source=pc_user')).toBe('69c131c9000000002800be4c');
+    });
     it('returns raw string when no URL pattern matches', () => {
         expect(parseNoteId('69c131c9000000002800be4c')).toBe('69c131c9000000002800be4c');
     });
@@ -48,8 +51,14 @@ describe('buildNoteUrl', () => {
         const url = 'https://www.xiaohongshu.com/search_result/abc123?xsec_token=tok';
         expect(buildNoteUrl(url)).toBe(url);
     });
-    it('constructs /search_result/ URL for bare note ID', () => {
-        expect(buildNoteUrl('abc123')).toBe('https://www.xiaohongshu.com/search_result/abc123');
+    it('rejects signed URLs from non-xiaohongshu hosts', () => {
+        expect(() => buildNoteUrl('https://example.com/?xsec_token=tok')).toThrow(/xiaohongshu/i);
+    });
+    it('rejects signed URLs with an empty xsec_token value', () => {
+        expect(() => buildNoteUrl('https://www.xiaohongshu.com/search_result/69c131c9000000002800be4c?xsec_token=')).toThrow(/xsec_token|signed url/i);
+    });
+    it('rejects bare note IDs because xiaohongshu now requires a signed URL', () => {
+        expect(() => buildNoteUrl('abc123')).toThrow(/xsec_token|signed url/i);
     });
 });
 describe('xiaohongshu note', () => {
@@ -58,7 +67,7 @@ describe('xiaohongshu note', () => {
         expect(command).toBeDefined();
         expect(command.func).toBeTypeOf('function');
     });
-    it('returns note content as field/value rows', async () => {
+    it('returns note content as field/value rows for signed full URLs', async () => {
         const page = createPageMock({
             loginWall: false,
             notFound: false,
@@ -70,8 +79,9 @@ describe('xiaohongshu note', () => {
             comments: '45',
             tags: ['#尚界Z7', '#鸿蒙智行'],
         });
-        const result = (await command.func(page, { 'note-id': '69c131c9000000002800be4c' }));
-        expect(page.goto.mock.calls[0][0]).toContain('/search_result/69c131c9000000002800be4c');
+        const signedUrl = 'https://www.xiaohongshu.com/search_result/69c131c9000000002800be4c?xsec_token=abc';
+        const result = (await command.func(page, { 'note-id': signedUrl }));
+        expect(page.goto.mock.calls[0][0]).toBe(signedUrl);
         expect(result).toEqual([
             { field: 'title', value: '尚界Z7实车体验' },
             { field: 'author', value: '小红薯用户' },
@@ -82,6 +92,18 @@ describe('xiaohongshu note', () => {
             { field: 'tags', value: '#尚界Z7, #鸿蒙智行' },
         ]);
     });
+    it('rejects bare note IDs before browser navigation', async () => {
+        const page = createPageMock({
+            loginWall: false, notFound: false,
+            title: 'Test', desc: '', author: '', likes: '0', collects: '0', comments: '0', tags: [],
+        });
+        await expect(command.func(page, { 'note-id': '69c131c9000000002800be4c' })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: expect.stringContaining('signed URL'),
+            hint: expect.stringContaining('xsec_token'),
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
     it('parses note ID from full /explore/ URL', async () => {
         const page = createPageMock({
             loginWall: false, notFound: false,
@@ -102,13 +124,40 @@ describe('xiaohongshu note', () => {
         // Should navigate to the full URL as-is, not strip the token
         expect(page.goto.mock.calls[0][0]).toBe(fullUrl);
     });
+    it('preserves signed /user/profile/<user>/<note> URLs for navigation', async () => {
+        const page = createPageMock({
+            loginWall: false, notFound: false,
+            title: 'Test', desc: '', author: '', likes: '0', collects: '0', comments: '0', tags: [],
+        });
+        const fullUrl = 'https://www.xiaohongshu.com/user/profile/user123/69c131c9000000002800be4c?xsec_token=abc&xsec_source=pc_user';
+        await command.func(page, { 'note-id': fullUrl });
+        expect(page.goto.mock.calls[0][0]).toBe(fullUrl);
+    });
     it('throws AuthRequiredError on login wall', async () => {
         const page = createPageMock({ loginWall: true, notFound: false });
-        await expect(command.func(page, { 'note-id': 'abc123' })).rejects.toThrow('Note content requires login');
+        await expect(command.func(page, {
+            'note-id': 'https://www.xiaohongshu.com/search_result/abc123?xsec_token=tok',
+        })).rejects.toThrow('Note content requires login');
+    });
+    it('throws SECURITY_BLOCK with retry guidance when a full URL is blocked', async () => {
+        const page = createPageMock({
+            pageUrl: 'https://www.xiaohongshu.com/website-login/error?error_code=300031',
+            securityBlock: true,
+            loginWall: false,
+            notFound: false,
+        });
+        await expect(command.func(page, {
+            'note-id': 'https://www.xiaohongshu.com/search_result/69c131c9000000002800be4c?xsec_token=abc',
+        })).rejects.toMatchObject({
+            code: 'SECURITY_BLOCK',
+            hint: expect.stringContaining('Try again later'),
+        });
     });
     it('throws EmptyResultError when note is not found', async () => {
         const page = createPageMock({ loginWall: false, notFound: true });
-        await expect(command.func(page, { 'note-id': 'abc123' })).rejects.toThrow('returned no data');
+        await expect(command.func(page, {
+            'note-id': 'https://www.xiaohongshu.com/search_result/abc123?xsec_token=tok',
+        })).rejects.toThrow('returned no data');
     });
     it('throws an empty-result error when the note page renders as an empty shell', async () => {
         const page = createPageMock({
@@ -123,7 +172,9 @@ describe('xiaohongshu note', () => {
             tags: [],
         });
         try {
-            await command.func(page, { 'note-id': '69ca3927000000001a020fd5' });
+            await command.func(page, {
+                'note-id': 'https://www.xiaohongshu.com/search_result/69ca3927000000001a020fd5?xsec_token=abc',
+            });
             throw new Error('expected xiaohongshu note to fail on an empty shell page');
         }
         catch (error) {
@@ -165,7 +216,9 @@ describe('xiaohongshu note', () => {
             title: 'New note', desc: 'Just posted', author: 'Author',
             likes: '赞', collects: '收藏', comments: '评论', tags: [],
         });
-        const result = (await command.func(page, { 'note-id': 'abc123' }));
+        const result = (await command.func(page, {
+            'note-id': 'https://www.xiaohongshu.com/search_result/abc123?xsec_token=tok',
+        }));
         expect(result.find((r) => r.field === 'likes').value).toBe('0');
         expect(result.find((r) => r.field === 'collects').value).toBe('0');
         expect(result.find((r) => r.field === 'comments').value).toBe('0');
@@ -175,7 +228,7 @@ describe('xiaohongshu note', () => {
             loginWall: false, notFound: false,
             title: 'Test', desc: '', author: 'Author', likes: '10', collects: '5', comments: '3', tags: [],
         });
-        await command.func(page, { 'note-id': 'abc123' });
+        await command.func(page, { 'note-id': 'https://www.xiaohongshu.com/search_result/abc123?xsec_token=tok' });
         const evaluateScript = page.evaluate.mock.calls[0][0];
         expect(evaluateScript).toContain('.interact-container .like-wrapper .count');
         expect(evaluateScript).toContain('.interact-container .collect-wrapper .count');
@@ -187,7 +240,9 @@ describe('xiaohongshu note', () => {
             title: 'No tags', desc: 'Content', author: 'Author',
             likes: '1', collects: '2', comments: '3', tags: [],
         });
-        const result = (await command.func(page, { 'note-id': 'abc123' }));
+        const result = (await command.func(page, {
+            'note-id': 'https://www.xiaohongshu.com/search_result/abc123?xsec_token=tok',
+        }));
         expect(result.find((r) => r.field === 'tags')).toBeUndefined();
         expect(result).toHaveLength(6);
     });

package/clis/xiaohongshu/publish.js

@@ -333,6 +333,7 @@ cli({
     domain: 'creator.xiaohongshu.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    navigateBefore: false,
     args: [
         { name: 'title', required: true, help: '笔记标题 (最多20字)' },
         { name: 'content', required: true, positional: true, help: '笔记正文' },

package/clis/xiaohongshu/search.js

@@ -53,6 +53,7 @@ cli({
     description: '搜索小红书笔记',
     domain: 'www.xiaohongshu.com',
     strategy: Strategy.COOKIE,
+    navigateBefore: false,
     args: [
         { name: 'query', required: true, positional: true, help: 'Search keyword' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of results' },

package/clis/xiaohongshu/user.js

@@ -26,6 +26,7 @@ cli({
     domain: 'www.xiaohongshu.com',
     strategy: Strategy.COOKIE,
     browser: true,
+    navigateBefore: false,
     args: [
         { name: 'id', type: 'string', required: true, positional: true, help: 'User id or profile URL' },
         { name: 'limit', type: 'int', default: 15, help: 'Number of notes to return' },

package/clis/xiaoyuzhou/auth.js

@@ -0,0 +1,303 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { CliError, CommandExecutionError, ConfigError, EXIT_CODES, getErrorMessage } from '@jackwener/opencli/errors';
+
+export const XIAOYUZHOU_API_BASE_URL = 'https://api.xiaoyuzhoufm.com';
+export const XIAOYUZHOU_TOKEN_TTL_MS = 20 * 60 * 1000;
+export const XIAOYUZHOU_REFRESH_SKEW_MS = 60 * 1000;
+export const XIAOYUZHOU_DEFAULT_DEVICE_ID = '81ADBFD6-6921-482B-9AB9-A29E7CC7BB55';
+export const XIAOYUZHOU_DEFAULT_DEVICE_PROPERTIES = '';
+export const XIAOYUZHOU_DEFAULT_USER_AGENT = 'Xiaoyuzhou/2.98.0 (build:2908; iOS 26.2.1)';
+
+function getNowMs() {
+    return Date.now();
+}
+
+export function getXiaoyuzhouCredentialFile() {
+    return path.join(os.homedir(), '.opencli', 'xiaoyuzhou.json');
+}
+
+function createXiaoyuzhouAuthError(message) {
+    return new CliError('AUTH_REQUIRED', message, `Update ${getXiaoyuzhouCredentialFile()} with fresh Xiaoyuzhou credentials before retrying.`, EXIT_CODES.NOPERM);
+}
+
+function coerceNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export function normalizeXiaoyuzhouCredentials(raw = {}) {
+    const lastUpdatedTs = coerceNumber(raw.last_updated_ts ?? raw.lastUpdatedTs);
+    let expiresAt = coerceNumber(raw.expires_at ?? raw.expiresAt);
+    if (expiresAt > 0 && expiresAt < 10_000_000_000) {
+        expiresAt *= 1000;
+    }
+    if (!expiresAt && lastUpdatedTs > 0) {
+        expiresAt = lastUpdatedTs * 1000 + XIAOYUZHOU_TOKEN_TTL_MS;
+    }
+    return {
+        access_token: String(raw.access_token ?? raw.accessToken ?? '').trim(),
+        refresh_token: String(raw.refresh_token ?? raw.refreshToken ?? '').trim(),
+        expires_at: expiresAt,
+        device_id: String(raw.device_id ?? raw.deviceId ?? XIAOYUZHOU_DEFAULT_DEVICE_ID).trim() || XIAOYUZHOU_DEFAULT_DEVICE_ID,
+        device_properties: String(raw.device_properties ?? raw.deviceProperties ?? XIAOYUZHOU_DEFAULT_DEVICE_PROPERTIES),
+    };
+}
+export function loadXiaoyuzhouCredentials() {
+    const filePath = getXiaoyuzhouCredentialFile();
+    if (fs.existsSync(filePath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            const credentials = normalizeXiaoyuzhouCredentials(parsed);
+            if (!credentials.access_token || !credentials.refresh_token) {
+                throw new ConfigError(`Xiaoyuzhou credential file is missing access_token or refresh_token: ${filePath}`, 'Recreate the file with valid credentials.');
+            }
+            return credentials;
+        }
+        catch (error) {
+            if (error instanceof ConfigError) {
+                throw error;
+            }
+            throw new ConfigError(`Failed to parse Xiaoyuzhou credential file: ${filePath}`, `Ensure ${filePath} contains valid JSON. (${getErrorMessage(error)})`);
+        }
+    }
+    throw new ConfigError(`Missing Xiaoyuzhou credentials. Expected ${filePath}`, `Create ${filePath} with access_token and refresh_token.`);
+}
+
+export function saveXiaoyuzhouCredentials(credentials) {
+    const filePath = getXiaoyuzhouCredentialFile();
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify({
+        access_token: credentials.access_token,
+        refresh_token: credentials.refresh_token,
+        expires_at: credentials.expires_at,
+        device_id: credentials.device_id,
+        device_properties: credentials.device_properties,
+    }, null, 2)}\n`, 'utf-8');
+}
+
+export function shouldRefreshXiaoyuzhouCredentials(credentials, now = getNowMs()) {
+    return Number.isFinite(credentials.expires_at)
+        && credentials.expires_at > 0
+        && now >= credentials.expires_at - XIAOYUZHOU_REFRESH_SKEW_MS;
+}
+
+export function buildXiaoyuzhouHeaders(credentials, options = {}) {
+    const {
+        contentType = 'application/json',
+        includeLocalTime = false,
+        includeRefreshToken = false,
+    } = options;
+    const headers = {
+        'Content-Type': contentType,
+        Host: 'api.xiaoyuzhoufm.com',
+        'User-Agent': XIAOYUZHOU_DEFAULT_USER_AGENT,
+        Market: 'AppStore',
+        'App-BuildNo': '2908',
+        OS: 'ios',
+        Manufacturer: 'Apple',
+        BundleID: 'app.podcast.cosmos',
+        Connection: 'keep-alive',
+        'abtest-info': '{"old_user_discovery_feed":"enable"}',
+        'Accept-Language': 'en-HK;q=1.0, zh-Hans-HK;q=0.9',
+        Model: 'iPhone18,1',
+        'app-permissions': '100000',
+        Accept: '*/*',
+        'App-Version': '2.98.0',
+        WifiConnected: 'true',
+        'OS-Version': '26.2.1',
+        'x-custom-xiaoyuzhou-app-dev': '',
+        'x-jike-device-id': credentials.device_id || XIAOYUZHOU_DEFAULT_DEVICE_ID,
+        'x-jike-device-properties': credentials.device_properties ?? XIAOYUZHOU_DEFAULT_DEVICE_PROPERTIES,
+    };
+    if (credentials.access_token) {
+        headers['x-jike-access-token'] = credentials.access_token;
+    }
+    if (includeRefreshToken && credentials.refresh_token) {
+        headers['x-jike-refresh-token'] = credentials.refresh_token;
+    }
+    if (includeLocalTime) {
+        headers['Local-Time'] = new Date().toISOString();
+        headers.Timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    }
+    return headers;
+}
+
+export async function refreshXiaoyuzhouCredentials(credentials, fetchImpl = fetch) {
+    if (!credentials.refresh_token) {
+        throw createXiaoyuzhouAuthError('Xiaoyuzhou refresh token is missing');
+    }
+    let response;
+    try {
+        response = await fetchImpl(`${XIAOYUZHOU_API_BASE_URL}/app_auth_tokens.refresh`, {
+            method: 'POST',
+            headers: buildXiaoyuzhouHeaders(credentials, {
+                contentType: 'application/x-www-form-urlencoded; charset=utf-8',
+                includeLocalTime: true,
+                includeRefreshToken: true,
+            }),
+            signal: AbortSignal.timeout(20_000),
+        });
+    }
+    catch (error) {
+        throw new CommandExecutionError(`Failed to refresh Xiaoyuzhou credentials: ${getErrorMessage(error)}`);
+    }
+    const bodyText = await response.text();
+    if (!response.ok) {
+        throw createXiaoyuzhouAuthError(`Xiaoyuzhou token refresh failed with HTTP ${response.status}${bodyText ? `: ${bodyText}` : ''}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch (error) {
+        throw new CommandExecutionError(`Xiaoyuzhou refresh returned invalid JSON: ${getErrorMessage(error)}`);
+    }
+    if (!parsed?.success) {
+        throw createXiaoyuzhouAuthError('Xiaoyuzhou refresh API returned success=false');
+    }
+    const nextCredentials = normalizeXiaoyuzhouCredentials({
+        ...credentials,
+        access_token: parsed['x-jike-access-token'] || '',
+        refresh_token: parsed['x-jike-refresh-token'] || '',
+        expires_at: getNowMs() + XIAOYUZHOU_TOKEN_TTL_MS,
+    });
+    if (!nextCredentials.access_token || !nextCredentials.refresh_token) {
+        throw createXiaoyuzhouAuthError('Xiaoyuzhou refresh API returned empty access_token or refresh_token');
+    }
+    saveXiaoyuzhouCredentials(nextCredentials);
+    return nextCredentials;
+}
+
+function buildApiUrl(endpoint, query) {
+    const url = new URL(endpoint, XIAOYUZHOU_API_BASE_URL);
+    if (query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined && value !== null && value !== '') {
+                url.searchParams.set(key, String(value));
+            }
+        }
+    }
+    return url.toString();
+}
+
+async function performXiaoyuzhouJsonRequest(endpoint, options, credentials, fetchImpl) {
+    const {
+        method = 'GET',
+        query,
+        body,
+    } = options;
+    let response;
+    try {
+        response = await fetchImpl(buildApiUrl(endpoint, query), {
+            method,
+            headers: buildXiaoyuzhouHeaders(credentials, {
+                contentType: 'application/json',
+                includeLocalTime: true,
+            }),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(20_000),
+        });
+    }
+    catch (error) {
+        throw new CommandExecutionError(`Failed to reach Xiaoyuzhou API: ${getErrorMessage(error)}`);
+    }
+    return response;
+}
+
+export async function requestXiaoyuzhouJson(endpoint, options = {}, fetchImpl = fetch) {
+    let credentials = options.credentials ?? loadXiaoyuzhouCredentials();
+    if (shouldRefreshXiaoyuzhouCredentials(credentials)) {
+        credentials = await refreshXiaoyuzhouCredentials(credentials, fetchImpl);
+    }
+    let response = await performXiaoyuzhouJsonRequest(endpoint, options, credentials, fetchImpl);
+    if (response.status === 401) {
+        credentials = await refreshXiaoyuzhouCredentials(credentials, fetchImpl);
+        response = await performXiaoyuzhouJsonRequest(endpoint, options, credentials, fetchImpl);
+    }
+    const bodyText = await response.text();
+    if (!response.ok) {
+        throw new CommandExecutionError(`Xiaoyuzhou API request failed with HTTP ${response.status}${bodyText ? `: ${bodyText}` : ''}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch (error) {
+        throw new CommandExecutionError(`Xiaoyuzhou API returned invalid JSON: ${getErrorMessage(error)}`);
+    }
+    if (parsed?.success === false) {
+        throw new CommandExecutionError(parsed?.message || parsed?.msg || 'Xiaoyuzhou API returned success=false');
+    }
+    return {
+        credentials,
+        raw: parsed,
+        data: parsed?.data,
+    };
+}
+
+export async function fetchXiaoyuzhouTranscriptBody(url, fetchImpl = fetch) {
+    let response;
+    try {
+        response = await fetchImpl(url, {
+            method: 'GET',
+            headers: {
+                'User-Agent': XIAOYUZHOU_DEFAULT_USER_AGENT,
+                Accept: '*/*',
+                Market: 'AppStore',
+            },
+            signal: AbortSignal.timeout(20_000),
+        });
+    }
+    catch (error) {
+        throw new CommandExecutionError(`Failed to fetch Xiaoyuzhou transcript content: ${getErrorMessage(error)}`);
+    }
+    const bodyText = await response.text();
+    if (!response.ok) {
+        throw new CommandExecutionError(`Xiaoyuzhou transcript download failed with HTTP ${response.status}${bodyText ? `: ${bodyText}` : ''}`);
+    }
+    return bodyText;
+}
+
+export function extractTranscriptText(transcriptBody) {
+    let parsed;
+    try {
+        parsed = JSON.parse(transcriptBody);
+    }
+    catch {
+        return { text: '', segmentCount: 0 };
+    }
+    let items = [];
+    if (Array.isArray(parsed)) {
+        items = parsed;
+    }
+    else if (parsed && typeof parsed === 'object') {
+        for (const key of ['segments', 'data', 'transcript', 'items']) {
+            if (Array.isArray(parsed[key])) {
+                items = parsed[key];
+                break;
+            }
+        }
+        if (items.length === 0) {
+            const directText = typeof parsed.text === 'string' ? parsed.text.trim() : '';
+            if (directText) {
+                return { text: directText, segmentCount: 1 };
+            }
+        }
+    }
+    const textItems = [];
+    for (const item of items) {
+        if (!item || typeof item !== 'object' || typeof item.text !== 'string') {
+            continue;
+        }
+        const cleaned = item.text.trim();
+        if (cleaned) {
+            textItems.push(cleaned);
+        }
+    }
+    return {
+        text: textItems.join('\n'),
+        segmentCount: textItems.length,
+    };
+}

package/clis/xiaoyuzhou/auth.test.js

@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockExistsSync, mockReadFileSync, mockMkdirSync, mockWriteFileSync, mockHomedir } = vi.hoisted(() => ({
+    mockExistsSync: vi.fn(),
+    mockReadFileSync: vi.fn(),
+    mockMkdirSync: vi.fn(),
+    mockWriteFileSync: vi.fn(),
+    mockHomedir: vi.fn(() => '/Users/tester'),
+}));
+
+vi.mock('node:fs', () => ({
+    existsSync: mockExistsSync,
+    readFileSync: mockReadFileSync,
+    mkdirSync: mockMkdirSync,
+    writeFileSync: mockWriteFileSync,
+}));
+
+vi.mock('node:os', () => ({
+    homedir: mockHomedir,
+}));
+
+const { extractTranscriptText, getXiaoyuzhouCredentialFile, loadXiaoyuzhouCredentials, normalizeXiaoyuzhouCredentials, refreshXiaoyuzhouCredentials, requestXiaoyuzhouJson, shouldRefreshXiaoyuzhouCredentials, XIAOYUZHOU_TOKEN_TTL_MS } = await import('./auth.js');
+
+function createJsonResponse(status, payload) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        text: vi.fn().mockResolvedValue(JSON.stringify(payload)),
+    };
+}
+
+describe('xiaoyuzhou auth helpers', () => {
+    beforeEach(() => {
+        mockExistsSync.mockReset();
+        mockReadFileSync.mockReset();
+        mockMkdirSync.mockReset();
+        mockWriteFileSync.mockReset();
+        vi.useRealTimers();
+    });
+
+    it('loads credentials from the local credential file', () => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({
+            access_token: 'file-access',
+            refresh_token: 'file-refresh',
+            expires_at: 123,
+        }));
+        const credentials = loadXiaoyuzhouCredentials();
+        expect(mockReadFileSync).toHaveBeenCalledWith(getXiaoyuzhouCredentialFile(), 'utf-8');
+        expect(credentials.access_token).toBe('file-access');
+        expect(credentials.refresh_token).toBe('file-refresh');
+    });
+
+    it('refreshes credentials and persists the updated token file', async () => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2026-04-15T00:00:00Z'));
+        const fetchMock = vi.fn().mockResolvedValue(createJsonResponse(200, {
+            success: true,
+            'x-jike-access-token': 'new-access',
+            'x-jike-refresh-token': 'new-refresh',
+        }));
+        const refreshed = await refreshXiaoyuzhouCredentials(normalizeXiaoyuzhouCredentials({
+            access_token: 'old-access',
+            refresh_token: 'old-refresh',
+            device_id: 'device-1',
+            device_properties: 'props',
+        }), fetchMock);
+        expect(refreshed.access_token).toBe('new-access');
+        expect(refreshed.refresh_token).toBe('new-refresh');
+        expect(refreshed.expires_at).toBe(Date.now() + XIAOYUZHOU_TOKEN_TTL_MS);
+        expect(mockMkdirSync).toHaveBeenCalledWith('/Users/tester/.opencli', { recursive: true });
+        expect(mockWriteFileSync).toHaveBeenCalledWith('/Users/tester/.opencli/xiaoyuzhou.json', expect.stringContaining('"access_token": "new-access"'), 'utf-8');
+    });
+
+    it('retries once on 401 using refreshed credentials', async () => {
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: false,
+            status: 401,
+            text: vi.fn().mockResolvedValue('unauthorized'),
+        })
+            .mockResolvedValueOnce(createJsonResponse(200, {
+            success: true,
+            'x-jike-access-token': 'refreshed-access',
+            'x-jike-refresh-token': 'refreshed-refresh',
+        }))
+            .mockResolvedValueOnce(createJsonResponse(200, {
+            success: true,
+            data: { title: 'Transcript Episode' },
+        }));
+        const result = await requestXiaoyuzhouJson('/v1/episode/get', {
+            query: { eid: 'ep123' },
+            credentials: normalizeXiaoyuzhouCredentials({
+                access_token: 'old-access',
+                refresh_token: 'old-refresh',
+            }),
+        }, fetchMock);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        expect(result.data).toEqual({ title: 'Transcript Episode' });
+        expect(result.credentials.access_token).toBe('refreshed-access');
+    });
+
+    it('extracts transcript text from segment arrays and direct text payloads', () => {
+        expect(extractTranscriptText(JSON.stringify({
+            segments: [{ text: 'hello ' }, { text: ' world' }],
+        }))).toEqual({
+            text: 'hello\nworld',
+            segmentCount: 2,
+        });
+        expect(extractTranscriptText(JSON.stringify({ text: 'full transcript' }))).toEqual({
+            text: 'full transcript',
+            segmentCount: 1,
+        });
+    });
+
+    it('detects credentials that are close to expiry', () => {
+        expect(shouldRefreshXiaoyuzhouCredentials({
+            expires_at: Date.now() - 1,
+        })).toBe(true);
+        expect(shouldRefreshXiaoyuzhouCredentials({
+            expires_at: Date.now() + 10 * 60 * 1000,
+        })).toBe(false);
+    });
+});

package/clis/xiaoyuzhou/download.js

@@ -0,0 +1,49 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CliError } from '@jackwener/opencli/errors';
+import { httpDownload, sanitizeFilename } from '@jackwener/opencli/download';
+import { formatBytes } from '@jackwener/opencli/download/progress';
+import { fetchPageProps } from './utils.js';
+
+cli({
+    site: 'xiaoyuzhou',
+    name: 'download',
+    description: 'Download Xiaoyuzhou episode audio',
+    domain: 'www.xiaoyuzhoufm.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Episode ID (eid from podcast-episodes output)' },
+        { name: 'output', default: './xiaoyuzhou-downloads', help: 'Output directory' },
+    ],
+    columns: ['title', 'podcast', 'status', 'size', 'file'],
+    func: async (_page, args) => {
+        const pageProps = await fetchPageProps(`/episode/${args.id}`);
+        const ep = pageProps.episode;
+        if (!ep) {
+            throw new CliError('NOT_FOUND', 'Episode not found', 'Please check the ID');
+        }
+        const audioUrl = ep.media?.source?.url;
+        if (!audioUrl) {
+            throw new CliError('PARSE_ERROR', 'Audio URL not found in episode payload', 'Episode payload does not expose media.source.url');
+        }
+        const output = String(args.output || './xiaoyuzhou-downloads');
+        const ext = path.extname(new URL(audioUrl).pathname) || '.mp3';
+        const title = String(ep.title || 'episode');
+        const filename = `${args.id}_${sanitizeFilename(title, 80) || 'episode'}${ext}`;
+        const outputDir = path.join(output, String(args.id));
+        fs.mkdirSync(outputDir, { recursive: true });
+        const destPath = path.join(outputDir, filename);
+        const result = await httpDownload(audioUrl, destPath, {
+            timeout: 60000,
+        });
+        return [{
+                title,
+                podcast: ep.podcast?.title || '-',
+                status: result.success ? 'success' : 'failed',
+                size: result.success ? formatBytes(result.size) : (result.error || 'unknown error'),
+                file: result.success ? destPath : '-',
+            }];
+    },
+});