@jackwener/opencli 1.4.0 → 1.5.0

package/dist/clis/weixin/download.js

@@ -46,6 +46,87 @@ export function normalizeWechatUrl(raw) {
     }
     return s;
 }
+/**
+ * Format a WeChat article timestamp as a UTC+8 datetime string.
+ * Accepts either Unix seconds or milliseconds.
+ */
+export function formatWechatTimestamp(rawTimestamp) {
+    const ts = Number.parseInt(rawTimestamp, 10);
+    if (!Number.isFinite(ts) || ts <= 0)
+        return '';
+    const timestampMs = rawTimestamp.length === 13 ? ts : ts * 1000;
+    const d = new Date(timestampMs);
+    const pad = (n) => String(n).padStart(2, '0');
+    const utc8 = new Date(d.getTime() + 8 * 3600 * 1000);
+    return (`${utc8.getUTCFullYear()}-` +
+        `${pad(utc8.getUTCMonth() + 1)}-` +
+        `${pad(utc8.getUTCDate())} ` +
+        `${pad(utc8.getUTCHours())}:` +
+        `${pad(utc8.getUTCMinutes())}:` +
+        `${pad(utc8.getUTCSeconds())}`);
+}
+/**
+ * Extract the raw create_time value from supported WeChat inline script formats.
+ */
+export function extractWechatCreateTimeValue(htmlStr) {
+    const jsDecodeMatch = htmlStr.match(/create_time\s*:\s*JsDecode\('([^']+)'\)(?=[\s,;}]|$)/);
+    if (jsDecodeMatch)
+        return jsDecodeMatch[1];
+    const directValueMatch = htmlStr.match(/create_time\s*[:=]\s*(?:"([^"]+)"|'([^']+)'|([0-9A-Za-z]+))(?=[\s,;}]|$)/);
+    if (!directValueMatch)
+        return '';
+    return directValueMatch[1] || directValueMatch[2] || directValueMatch[3] || '';
+}
+/**
+ * Extract the publish time from DOM text first, then fall back to numeric create_time values.
+ */
+export function extractWechatPublishTime(publishTimeText, htmlStr) {
+    const normalizedPublishTime = (publishTimeText || '').trim();
+    if (normalizedPublishTime)
+        return normalizedPublishTime;
+    const rawCreateTime = extractWechatCreateTimeValue(htmlStr);
+    if (!/^\d{10}$|^\d{13}$/.test(rawCreateTime))
+        return '';
+    return formatWechatTimestamp(rawCreateTime);
+}
+/**
+ * Build a self-contained helper for execution inside page.evaluate().
+ */
+export function buildExtractWechatPublishTimeJs() {
+    return `(${function extractWechatPublishTimeInPage(publishTimeText, htmlStr) {
+        function formatWechatTimestamp(rawTimestamp) {
+            const ts = Number.parseInt(rawTimestamp, 10);
+            if (!Number.isFinite(ts) || ts <= 0)
+                return '';
+            const timestampMs = rawTimestamp.length === 13 ? ts : ts * 1000;
+            const d = new Date(timestampMs);
+            const pad = (n) => String(n).padStart(2, '0');
+            const utc8 = new Date(d.getTime() + 8 * 3600 * 1000);
+            return (`${utc8.getUTCFullYear()}-` +
+                `${pad(utc8.getUTCMonth() + 1)}-` +
+                `${pad(utc8.getUTCDate())} ` +
+                `${pad(utc8.getUTCHours())}:` +
+                `${pad(utc8.getUTCMinutes())}:` +
+                `${pad(utc8.getUTCSeconds())}`);
+        }
+        function extractWechatCreateTimeValue(html) {
+            const jsDecodeMatch = html.match(/create_time\s*:\s*JsDecode\('([^']+)'\)(?=[\s,;}]|$)/);
+            if (jsDecodeMatch)
+                return jsDecodeMatch[1];
+            const directValueMatch = html.match(/create_time\s*[:=]\s*(?:"([^"]+)"|'([^']+)'|([0-9A-Za-z]+))(?=[\s,;}]|$)/);
+            if (!directValueMatch)
+                return '';
+            return directValueMatch[1] || directValueMatch[2] || directValueMatch[3] || '';
+        }
+        const normalizedPublishTime = (publishTimeText || '').trim();
+        if (normalizedPublishTime)
+            return normalizedPublishTime;
+        const rawCreateTime = extractWechatCreateTimeValue(htmlStr);
+        if (!/^\d{10}$|^\d{13}$/.test(rawCreateTime))
+            return '';
+        return formatWechatTimestamp(rawCreateTime);
+    }.toString()})`;
+}
 // ============================================================
 // CLI Registration
 // ============================================================
@@ -90,26 +171,13 @@ cli({
         const authorEl = document.querySelector('#js_name');
         result.author = authorEl ? authorEl.textContent.trim() : '';
 
-        // Publish time: extract create_time from script tags
-        const htmlStr = document.documentElement.innerHTML;
-        let timeMatch = htmlStr.match(/create_time\\s*:\\s*JsDecode\\('([^']+)'\\)/);
-        if (!timeMatch) timeMatch = htmlStr.match(/create_time\\s*:\\s*'(\\d+)'/);
-        if (!timeMatch) timeMatch = htmlStr.match(/create_time\\s*[:=]\\s*["']?(\\d+)["']?/);
-        if (timeMatch) {
-          const ts = parseInt(timeMatch[1], 10);
-          if (ts > 0) {
-            const d = new Date(ts * 1000);
-            const pad = n => String(n).padStart(2, '0');
-            const utc8 = new Date(d.getTime() + 8 * 3600 * 1000);
-            result.publishTime =
-              utc8.getUTCFullYear() + '-' +
-              pad(utc8.getUTCMonth() + 1) + '-' +
-              pad(utc8.getUTCDate()) + ' ' +
-              pad(utc8.getUTCHours()) + ':' +
-              pad(utc8.getUTCMinutes()) + ':' +
-              pad(utc8.getUTCSeconds());
-          }
-        }
+        // Publish time: prefer the rendered DOM text, then fall back to numeric create_time values.
+        const publishTimeEl = document.querySelector('#publish_time');
+        const extractWechatPublishTime = ${buildExtractWechatPublishTimeJs()};
+        result.publishTime = extractWechatPublishTime(
+          publishTimeEl ? publishTimeEl.textContent : '',
+          document.documentElement.innerHTML,
+        );
 
         // Content processing
         const contentEl = document.querySelector('#js_content');

package/dist/clis/weread/book.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { fetchWithPage } from './utils.js';
+import { fetchPrivateApi } from './utils.js';
 cli({
     site: 'weread',
     name: 'book',
@@ -11,7 +11,7 @@ cli({
     ],
     columns: ['title', 'author', 'publisher', 'intro', 'category', 'rating'],
     func: async (page, args) => {
-        const data = await fetchWithPage(page, '/book/info', { bookId: args.bookId });
+        const data = await fetchPrivateApi(page, '/book/info', { bookId: args['book-id'] });
         // newRating is 0-1000 scale per community docs; needs runtime verification
         const rating = data.newRating ? `${(data.newRating / 10).toFixed(1)}%` : '-';
         return [{

package/dist/clis/weread/commands.test.d.ts

@@ -0,0 +1,3 @@
+import './book.js';
+import './highlights.js';
+import './notes.js';

package/dist/clis/weread/commands.test.js

@@ -0,0 +1,43 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockFetchPrivateApi } = vi.hoisted(() => ({
+    mockFetchPrivateApi: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        fetchPrivateApi: mockFetchPrivateApi,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './book.js';
+import './highlights.js';
+import './notes.js';
+describe('weread book-id positional args', () => {
+    const book = getRegistry().get('weread/book');
+    const highlights = getRegistry().get('weread/highlights');
+    const notes = getRegistry().get('weread/notes');
+    beforeEach(() => {
+        mockFetchPrivateApi.mockReset();
+    });
+    it('passes the positional book-id to book details', async () => {
+        mockFetchPrivateApi.mockResolvedValue({ title: 'Three Body', newRating: 880 });
+        await book.func({}, { 'book-id': '12345' });
+        expect(mockFetchPrivateApi).toHaveBeenCalledWith({}, '/book/info', { bookId: '12345' });
+    });
+    it('passes the positional book-id to highlights', async () => {
+        mockFetchPrivateApi.mockResolvedValue({ updated: [] });
+        await highlights.func({}, { 'book-id': 'abc', limit: 5 });
+        expect(mockFetchPrivateApi).toHaveBeenCalledWith({}, '/book/bookmarklist', { bookId: 'abc' });
+    });
+    it('passes the positional book-id to notes', async () => {
+        mockFetchPrivateApi.mockResolvedValue({ reviews: [] });
+        await notes.func({}, { 'book-id': 'xyz', limit: 5 });
+        expect(mockFetchPrivateApi).toHaveBeenCalledWith({}, '/review/list', {
+            bookId: 'xyz',
+            listType: '11',
+            mine: '1',
+            synckey: '0',
+        });
+    });
+});

package/dist/clis/weread/highlights.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { fetchWithPage, formatDate } from './utils.js';
+import { fetchPrivateApi, formatDate } from './utils.js';
 cli({
     site: 'weread',
     name: 'highlights',
@@ -12,7 +12,7 @@ cli({
     ],
     columns: ['chapter', 'text', 'createTime'],
     func: async (page, args) => {
-        const data = await fetchWithPage(page, '/book/bookmarklist', { bookId: args.bookId });
+        const data = await fetchPrivateApi(page, '/book/bookmarklist', { bookId: args['book-id'] });
         const items = data?.updated ?? [];
         return items.slice(0, Number(args.limit)).map((item) => ({
             chapter: item.chapterName ?? '',

package/dist/clis/weread/notebooks.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { fetchWithPage } from './utils.js';
+import { fetchPrivateApi } from './utils.js';
 cli({
     site: 'weread',
     name: 'notebooks',
@@ -8,7 +8,7 @@ cli({
     strategy: Strategy.COOKIE,
     columns: ['title', 'author', 'noteCount', 'bookId'],
     func: async (page, _args) => {
-        const data = await fetchWithPage(page, '/user/notebooks');
+        const data = await fetchPrivateApi(page, '/user/notebooks');
         const books = data?.books ?? [];
         return books.map((item) => ({
             title: item.book?.title ?? '',

package/dist/clis/weread/notes.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { fetchWithPage, formatDate } from './utils.js';
+import { fetchPrivateApi, formatDate } from './utils.js';
 cli({
     site: 'weread',
     name: 'notes',
@@ -12,8 +12,8 @@ cli({
     ],
     columns: ['chapter', 'text', 'review', 'createTime'],
     func: async (page, args) => {
-        const data = await fetchWithPage(page, '/review/list', {
-            bookId: args.bookId,
+        const data = await fetchPrivateApi(page, '/review/list', {
+            bookId: args['book-id'],
             listType: '11',
             mine: '1',
             synckey: '0',

package/dist/clis/weread/search.js

@@ -11,15 +11,16 @@ cli({
         { name: 'query', positional: true, required: true, help: 'Search keyword' },
         { name: 'limit', type: 'int', default: 10, help: 'Max results' },
     ],
-    columns: ['rank', 'title', 'author', 'bookId'],
+    columns: ['rank', 'title', 'author', 'bookId', 'url'],
     func: async (_page, args) => {
-        const data = await fetchWebApi('/search/global', { keyword: args.keyword });
+        const data = await fetchWebApi('/search/global', { keyword: args.query });
         const books = data?.books ?? [];
         return books.slice(0, Number(args.limit)).map((item, i) => ({
             rank: i + 1,
             title: item.bookInfo?.title ?? '',
             author: item.bookInfo?.author ?? '',
             bookId: item.bookInfo?.bookId ?? '',
+            url: item.bookInfo?.bookId ? 'https://weread.qq.com/web/bookDetail/' + item.bookInfo.bookId : '',
         }));
     },
 });

package/dist/clis/weread/shelf.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { fetchWithPage } from './utils.js';
+import { fetchPrivateApi } from './utils.js';
 cli({
     site: 'weread',
     name: 'shelf',
@@ -11,7 +11,7 @@ cli({
     ],
     columns: ['title', 'author', 'progress', 'bookId'],
     func: async (page, args) => {
-        const data = await fetchWithPage(page, '/shelf/sync', { synckey: '0', lectureSynckey: '0' });
+        const data = await fetchPrivateApi(page, '/shelf/sync', { synckey: '0', lectureSynckey: '0' });
         const books = data?.books ?? [];
         return books.slice(0, Number(args.limit)).map((item) => ({
             title: item.bookInfo?.title ?? item.title ?? '',

package/dist/clis/weread/utils.d.ts

@@ -3,7 +3,7 @@
  *
  * Two API domains:
  * - WEB_API (weread.qq.com/web/*): public, Node.js fetch
- * - API (i.weread.qq.com/*): private, browser page.evaluate with cookies
+ * - API (i.weread.qq.com/*): private, Node.js fetch with cookies from browser
  */
 import type { IPage } from '../../types.js';
 /**
@@ -12,9 +12,9 @@ import type { IPage } from '../../types.js';
  */
 export declare function fetchWebApi(path: string, params?: Record<string, string>): Promise<any>;
 /**
- * Fetch a private WeRead API endpoint via browser page.evaluate.
- * Automatically carries cookies for authenticated requests.
+ * Fetch a private WeRead API endpoint with cookies extracted from the browser.
+ * The HTTP request itself runs in Node.js to avoid page-context CORS failures.
  */
-export declare function fetchWithPage(page: IPage, path: string, params?: Record<string, string>): Promise<any>;
+export declare function fetchPrivateApi(page: IPage, path: string, params?: Record<string, string>): Promise<any>;
 /** Format a Unix timestamp (seconds) to YYYY-MM-DD in UTC+8. Returns '-' for invalid input. */
 export declare function formatDate(ts: number | undefined | null): string;

package/dist/clis/weread/utils.js

@@ -3,12 +3,15 @@
  *
  * Two API domains:
  * - WEB_API (weread.qq.com/web/*): public, Node.js fetch
- * - API (i.weread.qq.com/*): private, browser page.evaluate with cookies
+ * - API (i.weread.qq.com/*): private, Node.js fetch with cookies from browser
  */
 import { CliError } from '../../errors.js';
 const WEB_API = 'https://weread.qq.com/web';
 const API = 'https://i.weread.qq.com';
 const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+function buildCookieHeader(cookies) {
+    return cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join('; ');
+}
 /**
  * Fetch a public WeRead web endpoint (Node.js direct fetch).
  * Used by search and ranking commands (browser: false).
@@ -33,30 +36,45 @@ export async function fetchWebApi(path, params) {
     }
 }
 /**
- * Fetch a private WeRead API endpoint via browser page.evaluate.
- * Automatically carries cookies for authenticated requests.
+ * Fetch a private WeRead API endpoint with cookies extracted from the browser.
+ * The HTTP request itself runs in Node.js to avoid page-context CORS failures.
  */
-export async function fetchWithPage(page, path, params) {
+export async function fetchPrivateApi(page, path, params) {
     const url = new URL(`${API}${path}`);
     if (params) {
         for (const [k, v] of Object.entries(params))
             url.searchParams.set(k, v);
     }
     const urlStr = url.toString();
-    const data = await page.evaluate(`
-    async () => {
-      const res = await fetch(${JSON.stringify(urlStr)}, { credentials: "include" });
-      if (!res.ok) return { _httpError: String(res.status) };
-      try { return await res.json(); }
-      catch { return { _httpError: 'JSON parse error (status ' + res.status + ')' }; }
+    const cookies = await page.getCookies({ url: urlStr });
+    const cookieHeader = buildCookieHeader(cookies);
+    let resp;
+    try {
+        resp = await fetch(urlStr, {
+            headers: {
+                'User-Agent': UA,
+                'Origin': 'https://weread.qq.com',
+                'Referer': 'https://weread.qq.com/',
+                ...(cookieHeader ? { 'Cookie': cookieHeader } : {}),
+            },
+        });
+    }
+    catch (error) {
+        throw new CliError('FETCH_ERROR', `Failed to fetch ${path}: ${error instanceof Error ? error.message : String(error)}`, 'WeRead API may be temporarily unavailable');
+    }
+    let data;
+    try {
+        data = await resp.json();
     }
-  `);
-    if (data?._httpError) {
-        throw new CliError('FETCH_ERROR', `HTTP ${data._httpError} for ${path}`, 'WeRead API may be temporarily unavailable');
+    catch {
+        throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
     }
-    if (data?.errcode === -2010) {
+    if (resp.status === 401 || data?.errcode === -2010) {
         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');
+    }
     if (data?.errcode != null && data.errcode !== 0) {
         throw new CliError('API_ERROR', data.errmsg ?? `WeRead API error ${data.errcode}`);
     }

package/dist/clis/weread/utils.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { formatDate, fetchWebApi, fetchWithPage } from './utils.js';
+import { formatDate, fetchWebApi } from './utils.js';
 describe('formatDate', () => {
     it('formats a typical Unix timestamp in UTC+8', () => {
         // 1705276800 = 2024-01-15 00:00:00 UTC = 2024-01-15 08:00:00 Beijing
@@ -56,30 +56,3 @@ describe('fetchWebApi', () => {
         await expect(fetchWebApi('/search/global')).rejects.toThrow('Invalid JSON');
     });
 });
-describe('fetchWithPage', () => {
-    it('throws AUTH_REQUIRED on errcode -2010', async () => {
-        const mockPage = {
-            evaluate: vi.fn().mockResolvedValue({ errcode: -2010, errmsg: '用户不存在' }),
-        };
-        await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('Not logged in');
-    });
-    it('throws API_ERROR on unknown errcode', async () => {
-        const mockPage = {
-            evaluate: vi.fn().mockResolvedValue({ errcode: -1, errmsg: 'unknown error' }),
-        };
-        await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('unknown error');
-    });
-    it('returns data on success (errcode 0 or absent)', async () => {
-        const mockPage = {
-            evaluate: vi.fn().mockResolvedValue({ title: 'Test Book', errcode: 0 }),
-        };
-        const result = await fetchWithPage(mockPage, '/book/info');
-        expect(result.title).toBe('Test Book');
-    });
-    it('throws FETCH_ERROR on HTTP error', async () => {
-        const mockPage = {
-            evaluate: vi.fn().mockResolvedValue({ _httpError: '403' }),
-        };
-        await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('HTTP 403');
-    });
-});

package/dist/clis/xiaohongshu/comments.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Xiaohongshu comments — DOM extraction from note detail page.
+ * XHS API requires signed requests, so we scrape the rendered DOM instead.
+ */
+export {};

package/dist/clis/xiaohongshu/comments.js

@@ -0,0 +1,74 @@
+/**
+ * Xiaohongshu comments — DOM extraction from note detail page.
+ * XHS API requires signed requests, so we scrape the rendered DOM instead.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError, EmptyResultError } from '../../errors.js';
+cli({
+    site: 'xiaohongshu',
+    name: 'comments',
+    description: '获取小红书笔记评论（仅主评论，不含楼中楼）',
+    domain: 'www.xiaohongshu.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'note-id', required: true, positional: true, help: 'Note ID or full /explore/<id> URL' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of comments (max 50)' },
+    ],
+    columns: ['rank', 'author', 'text', 'likes', 'time'],
+    func: async (page, kwargs) => {
+        const limit = Math.min(Number(kwargs.limit) || 20, 50);
+        let noteId = String(kwargs['note-id']).trim();
+        // Accept full URLs: /explore/<id> or /note/<id>
+        const urlMatch = noteId.match(/\/explore\/([a-f0-9]+)/) || noteId.match(/\/note\/([a-f0-9]+)/);
+        if (urlMatch)
+            noteId = urlMatch[1];
+        await page.goto(`https://www.xiaohongshu.com/explore/${noteId}`);
+        await page.wait(3);
+        const data = await page.evaluate(`
+      (async () => {
+        const wait = (ms) => new Promise(r => setTimeout(r, ms))
+
+        // Check login state
+        const loginWall = /登录后查看|请登录/.test(document.body.innerText || '')
+
+        // Scroll the note container to trigger comment loading
+        const scroller = document.querySelector('.note-scroller') || document.querySelector('.container')
+        if (scroller) {
+          for (let i = 0; i < 3; i++) {
+            scroller.scrollTo(0, scroller.scrollHeight)
+            await wait(1000)
+          }
+        }
+
+        const clean = (el) => (el?.textContent || '').replace(/\\s+/g, ' ').trim()
+
+        const results = []
+        const parents = document.querySelectorAll('.parent-comment')
+        for (const p of parents) {
+          const item = p.querySelector('.comment-item')
+          if (!item) continue
+
+          const author = clean(item.querySelector('.author-wrapper .name, .user-name'))
+          const text = clean(item.querySelector('.content, .note-text'))
+          // XHS shows text "赞" when likes = 0; only shows a number when > 0
+          const likesRaw = clean(item.querySelector('.count'))
+          const likes = /^\\d+$/.test(likesRaw) ? Number(likesRaw) : 0
+          const time = clean(item.querySelector('.date, .time'))
+
+          if (!text) continue
+          results.push({ author, text, likes, time })
+        }
+
+        return { loginWall, results }
+      })()
+    `);
+        if (!data || typeof data !== 'object') {
+            throw new EmptyResultError('xiaohongshu/comments', 'Unexpected evaluate response');
+        }
+        if (data.loginWall) {
+            throw new AuthRequiredError('www.xiaohongshu.com', 'Note comments require login');
+        }
+        const results = data.results ?? [];
+        return results.slice(0, limit).map((c, i) => ({ rank: i + 1, ...c }));
+    },
+});

package/dist/clis/xiaohongshu/comments.test.d.ts

@@ -0,0 +1 @@
+import './comments.js';

package/dist/clis/xiaohongshu/comments.test.js

@@ -0,0 +1,79 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './comments.js';
+function createPageMock(evaluateResult) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue(undefined),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        getCookies: vi.fn().mockResolvedValue([]),
+        screenshot: vi.fn().mockResolvedValue(''),
+    };
+}
+describe('xiaohongshu comments', () => {
+    const command = getRegistry().get('xiaohongshu/comments');
+    it('returns ranked comment rows', async () => {
+        const page = createPageMock({
+            loginWall: false,
+            results: [
+                { author: 'Alice', text: 'Great note!', likes: 10, time: '2024-01-01' },
+                { author: 'Bob', text: 'Very helpful', likes: 0, time: '2024-01-02' },
+            ],
+        });
+        const result = (await command.func(page, { 'note-id': '69aadbcb000000002202f131', limit: 5 }));
+        expect(page.goto.mock.calls[0][0]).toContain('/explore/69aadbcb000000002202f131');
+        expect(result).toEqual([
+            { rank: 1, author: 'Alice', text: 'Great note!', likes: 10, time: '2024-01-01' },
+            { rank: 2, author: 'Bob', text: 'Very helpful', likes: 0, time: '2024-01-02' },
+        ]);
+        expect(result[0]).not.toHaveProperty('loginWall');
+    });
+    it('strips /explore/ prefix from full URL input', async () => {
+        const page = createPageMock({
+            loginWall: false,
+            results: [{ author: 'Alice', text: 'Nice', likes: 1, time: '2024-01-01' }],
+        });
+        await command.func(page, {
+            'note-id': 'https://www.xiaohongshu.com/explore/69aadbcb000000002202f131',
+            limit: 5,
+        });
+        expect(page.goto.mock.calls[0][0]).toContain('/explore/69aadbcb000000002202f131');
+    });
+    it('throws AuthRequiredError when login wall is detected', async () => {
+        const page = createPageMock({ loginWall: true, results: [] });
+        await expect(command.func(page, { 'note-id': 'abc123', limit: 5 })).rejects.toThrow('Note comments require login');
+    });
+    it('returns empty array when no comments are found', async () => {
+        const page = createPageMock({ loginWall: false, results: [] });
+        await expect(command.func(page, { 'note-id': 'abc123', limit: 5 })).resolves.toEqual([]);
+    });
+    it('respects the limit', async () => {
+        const manyComments = Array.from({ length: 10 }, (_, i) => ({
+            author: `User${i}`,
+            text: `Comment ${i}`,
+            likes: i,
+            time: '2024-01-01',
+        }));
+        const page = createPageMock({ loginWall: false, results: manyComments });
+        const result = (await command.func(page, { 'note-id': 'abc123', limit: 3 }));
+        expect(result).toHaveLength(3);
+        expect(result[0].rank).toBe(1);
+        expect(result[2].rank).toBe(3);
+    });
+});