@jackwener/opencli 1.7.17 → 1.7.19

package/clis/xiaohongshu/note.js

@@ -9,25 +9,12 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CliError, EmptyResultError } from '@jackwener/opencli/errors';
 import { parseNoteId, buildNoteUrl } from './note-helpers.js';
-cli({
-    site: 'xiaohongshu',
-    name: 'note',
-    access: 'read',
-    description: '获取小红书笔记正文和互动数据',
-    domain: 'www.xiaohongshu.com',
-    strategy: Strategy.COOKIE,
-    navigateBefore: false,
-    args: [
-        { name: 'note-id', required: true, positional: true, help: 'Full Xiaohongshu note URL with xsec_token' },
-    ],
-    columns: ['field', 'value'],
-    func: async (page, kwargs) => {
-        const raw = String(kwargs['note-id']);
-        const noteId = parseNoteId(raw);
-        const url = buildNoteUrl(raw, { commandName: 'xiaohongshu note' });
-        await page.goto(url);
-        await page.wait({ time: 2 + Math.random() * 3 });
-        const data = await page.evaluate(`
+/**
+ * Host-agnostic IIFE that scrapes note title / author / counts / tags from a
+ * rendered note detail page. Exported so the rednote adapter can reuse the
+ * exact same selector set without copying it.
+ */
+export const NOTE_EXTRACT_JS = `
       (() => {
         const bodyText = document.body?.innerText || ''
         const loginWall = /登录后查看|请登录/.test(bodyText)
@@ -58,7 +45,26 @@ cli({
 
         return { pageUrl: location.href, securityBlock, loginWall, notFound, title, desc, author, likes, collects, comments, tags }
       })()
-    `);
+    `;
+export const command = cli({
+    site: 'xiaohongshu',
+    name: 'note',
+    access: 'read',
+    description: '获取小红书笔记正文和互动数据',
+    domain: 'www.xiaohongshu.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        { name: 'note-id', required: true, positional: true, help: 'Full Xiaohongshu note URL with xsec_token' },
+    ],
+    columns: ['field', 'value'],
+    func: async (page, kwargs) => {
+        const raw = String(kwargs['note-id']);
+        const noteId = parseNoteId(raw);
+        const url = buildNoteUrl(raw, { commandName: 'xiaohongshu note' });
+        await page.goto(url);
+        await page.wait({ time: 2 + Math.random() * 3 });
+        const data = await page.evaluate(NOTE_EXTRACT_JS);
         if (!data || typeof data !== 'object') {
             throw new EmptyResultError('xiaohongshu/note', 'Unexpected evaluate response');
         }

package/clis/xiaohongshu/notifications.js

@@ -1,23 +1,11 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-cli({
-    site: 'xiaohongshu',
-    name: 'notifications',
-    access: 'read',
-    description: '小红书通知 (mentions/likes/connections)',
-    domain: 'www.xiaohongshu.com',
-    strategy: Strategy.INTERCEPT,
-    browser: true,
-    args: [
-        {
-            name: 'type',
-            default: 'mentions',
-            help: 'Notification type: mentions, likes, or connections',
-        },
-        { name: 'limit', type: 'int', default: 20, help: 'Number of notifications to return' },
-    ],
-    columns: ['rank', 'user', 'action', 'content', 'note', 'time'],
-    pipeline: [
-        { navigate: 'https://www.xiaohongshu.com/notification' },
+/**
+ * Build the notifications pipeline for the given web host. Exported so the
+ * rednote adapter can register the same pipeline against www.rednote.com.
+ */
+export function buildNotificationsPipeline(webHost) {
+    return [
+        { navigate: `https://${webHost}/notification` },
         { tap: {
                 store: 'notification',
                 action: 'getNotification',
@@ -35,5 +23,24 @@ cli({
                 time: '${{ item.time }}',
             } },
         { limit: '${{ args.limit | default(20) }}' },
+    ];
+}
+export const command = cli({
+    site: 'xiaohongshu',
+    name: 'notifications',
+    access: 'read',
+    description: '小红书通知 (mentions/likes/connections)',
+    domain: 'www.xiaohongshu.com',
+    strategy: Strategy.INTERCEPT,
+    browser: true,
+    args: [
+        {
+            name: 'type',
+            default: 'mentions',
+            help: 'Notification type: mentions, likes, or connections',
+        },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of notifications to return' },
     ],
+    columns: ['rank', 'user', 'action', 'content', 'note', 'time'],
+    pipeline: buildNotificationsPipeline('www.xiaohongshu.com'),
 });

package/clis/xiaohongshu/search.js

@@ -6,16 +6,24 @@
  * Ref: https://github.com/jackwener/opencli/issues/10
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { AuthRequiredError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError } from '@jackwener/opencli/errors';
 /**
  * Wait for search results or login wall using MutationObserver (max 5s).
  * Returns 'content' if note items appeared, 'login_wall' if login gate
  * detected, or 'timeout' if neither appeared within the deadline.
+ *
+ * Note-item detection tries the legacy `section.note-item` class first
+ * (still observed in many sessions, including rednote) and falls back to
+ * a `<section>` element containing a `/search_result/` or `/explore/`
+ * link. Issue #1506 reports the class being dropped on some xhs renders.
  */
 const WAIT_FOR_CONTENT_JS = `
   new Promise((resolve) => {
+    const findNoteCard = () => document.querySelector(
+      'section.note-item, section:has(a[href*="/search_result/"]), section:has(a[href*="/explore/"])'
+    );
     const detect = () => {
-      if (document.querySelector('section.note-item')) return 'content';
+      if (findNoteCard()) return 'content';
       if (/登录后查看搜索结果/.test(document.body?.innerText || '')) return 'login_wall';
       return null;
     };
@@ -52,49 +60,146 @@ export function stripXhsAuthorDateSuffix(value) {
     const stripped = text.replace(/\s*(?:\d{1,2}天前|\d+小时前|\d+分钟前|\d+秒前|刚刚|昨天|前天|\d+周前|\d+个月前|\d{1,2}-\d{1,2}|\d{4}-\d{1,2}-\d{1,2})$/u, '').trim();
     return stripped || text;
 }
-cli({
-    site: 'xiaohongshu',
-    name: 'search',
-    access: 'read',
-    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' },
-    ],
-    columns: ['rank', 'title', 'author', 'likes', 'published_at', 'url'],
-    func: async (page, kwargs) => {
-        const keyword = encodeURIComponent(kwargs.query);
-        await page.goto(`https://www.xiaohongshu.com/search_result?keyword=${keyword}&source=web_search_result_notes`);
-        // Wait for search results to render (or login wall to appear).
-        // Uses MutationObserver to resolve as soon as content appears,
-        // instead of a fixed delay + blind retry.
-        const waitResult = await page.evaluate(WAIT_FOR_CONTENT_JS);
-        if (waitResult === 'login_wall') {
-            throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
+export function parseLimit(raw) {
+    const parsed = Number(raw ?? 20);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be an integer between 1 and 100, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < 1 || parsed > 100) {
+        throw new ArgumentError(`--limit must be between 1 and 100, got ${parsed}`);
+    }
+    return parsed;
+}
+/**
+ * Build a "scroll until enough or plateaued" IIFE used in place of a fixed
+ * `autoScroll({ times: N })`. Xiaohongshu's search results page lazy-loads
+ * ~5-7 notes per scroll, so the previous `times: 2` capped extraction at
+ * ~13 items regardless of `--limit` (see #1471). This helper drives scrolls
+ * dynamically:
+ *
+ *   - count visible `section.note-item` rows (excluding related-search
+ *     `.query-note-item` rows)
+ *   - if count >= targetCount → break (got enough)
+ *   - if two consecutive scrolls add no new rows → break (DOM plateaued,
+ *     no more lazy-load available)
+ *   - hard cap at `maxScrolls` iterations (default 15) to bound runtime
+ *
+ * Exported so the rednote adapter (same DOM shape) can reuse it.
+ */
+export function buildScrollUntilJs(targetCount, maxScrolls = 15) {
+    if (!Number.isSafeInteger(targetCount) || targetCount < 1) {
+        throw new ArgumentError(`targetCount must be a positive integer, got ${JSON.stringify(targetCount)}`);
+    }
+    if (!Number.isSafeInteger(maxScrolls) || maxScrolls < 1) {
+        throw new ArgumentError(`maxScrolls must be a positive integer, got ${JSON.stringify(maxScrolls)}`);
+    }
+    return `
+      (async () => {
+        const isVisibleNote = (el) => {
+          if (el.classList.contains('query-note-item')) return false;
+          const rect = el.getBoundingClientRect();
+          if (rect.width <= 0 || rect.height <= 0) return false;
+          const style = getComputedStyle(el);
+          return style.display !== 'none' && style.visibility !== 'hidden';
+        };
+        // Note containers: legacy \`section.note-item\` first, fallback to
+        // any \`<section>\` that wraps a search-result/explore note link
+        // (#1506 reports the class being dropped on some xhs renders).
+        const collectNoteCards = () => {
+          const classMatches = document.querySelectorAll('section.note-item');
+          if (classMatches.length > 0) return classMatches;
+          const sections = new Set();
+          for (const a of document.querySelectorAll('a[href*="/search_result/"], a[href*="/explore/"]')) {
+            const section = a.closest('section');
+            if (section) sections.add(section);
+          }
+          return sections;
+        };
+        const countItems = () => {
+          let count = 0;
+          for (const el of collectNoteCards()) {
+            if (isVisibleNote(el)) count++;
+          }
+          return count;
+        };
+
+        let lastCount = countItems();
+        let plateauRounds = 0;
+        for (let i = 0; i < ${maxScrolls}; i++) {
+          if (countItems() >= ${targetCount}) break;
+          const lastHeight = document.body.scrollHeight;
+          window.scrollTo(0, lastHeight);
+          await new Promise((resolve) => {
+            let to;
+            const ob = new MutationObserver(() => {
+              if (document.body.scrollHeight > lastHeight) {
+                clearTimeout(to);
+                ob.disconnect();
+                setTimeout(resolve, 200);
+              }
+            });
+            ob.observe(document.body, { childList: true, subtree: true });
+            to = setTimeout(() => { ob.disconnect(); resolve(null); }, 2500);
+          });
+          const newCount = countItems();
+          if (newCount === lastCount) {
+            plateauRounds++;
+            if (plateauRounds >= 2) break;
+          } else {
+            plateauRounds = 0;
+            lastCount = newCount;
+          }
         }
-        // Scroll a couple of times to load more results
-        await page.autoScroll({ times: 2 });
-        const payload = await page.evaluate(`
+        return countItems();
+      })()
+    `;
+}
+/**
+ * Build the search-result extraction IIFE. The web host is baked into the
+ * `normalizeUrl` fallback so relative `/explore/...` hrefs resolve to a full
+ * URL on the calling site. Exported so the rednote adapter can call it with
+ * `www.rednote.com` without duplicating the selector logic.
+ */
+export function buildSearchExtractJs(webHost) {
+    return `
       (() => {
         const normalizeUrl = (href) => {
           if (!href) return '';
           if (href.startsWith('http://') || href.startsWith('https://')) return href;
-          if (href.startsWith('/')) return 'https://www.xiaohongshu.com' + href;
+          if (href.startsWith('/')) return 'https://${webHost}' + href;
           return '';
         };
 
         const cleanText = (value) => (value || '').replace(/\\s+/g, ' ').trim();
         const stripXhsAuthorDateSuffix = ${stripXhsAuthorDateSuffix.toString()};
+        const isVisibleNote = (el) => {
+          const rect = el.getBoundingClientRect();
+          if (rect.width <= 0 || rect.height <= 0) return false;
+          const style = getComputedStyle(el);
+          return style.display !== 'none' && style.visibility !== 'hidden';
+        };
 
         const results = [];
         const seen = new Set();
 
-        document.querySelectorAll('section.note-item').forEach(el => {
+        // Note containers: legacy \`section.note-item\` first, fallback to any
+        // \`<section>\` wrapping a search-result/explore link (#1506 reports the
+        // class being dropped on some xhs renders).
+        const collectNoteCards = () => {
+          const classMatches = document.querySelectorAll('section.note-item');
+          if (classMatches.length > 0) return classMatches;
+          const sections = new Set();
+          for (const a of document.querySelectorAll('a[href*="/search_result/"], a[href*="/explore/"]')) {
+            const section = a.closest('section');
+            if (section) sections.add(section);
+          }
+          return sections;
+        };
+
+        for (const el of collectNoteCards()) {
           // Skip "related searches" sections
-          if (el.classList.contains('query-note-item')) return;
+          if (el.classList?.contains('query-note-item')) continue;
+          if (!isVisibleNote(el)) continue;
 
           const titleEl = el.querySelector('.title, .note-title, a.title, .footer .title span');
           const nameEl = el.querySelector('a.author .name, .author-name, .nick-name, .name');
@@ -114,28 +219,87 @@ cli({
           const authorLinkEl = el.querySelector('a.author, a[href*="/user/profile/"]');
 
           const url = normalizeUrl(detailLinkEl?.getAttribute('href') || '');
-          if (!url) return;
+          if (!url) continue;
 
           const key = url;
-          if (seen.has(key)) return;
+          if (seen.has(key)) continue;
           seen.add(key);
 
+          // Fallback title: the new bare-section render keeps the note caption
+          // inside the search_result anchor's first span, not in a class-named
+          // .title element. Pull from there when the class-based pick is empty.
+          let title = cleanText(titleEl?.textContent || '');
+          if (!title) {
+            const captionSpan = detailLinkEl?.querySelector('span');
+            title = cleanText(captionSpan?.textContent || '');
+          }
+
           results.push({
-            title: cleanText(titleEl?.textContent || ''),
+            title,
             author,
             likes: cleanText(likesEl?.textContent || '0'),
             url,
             author_url: normalizeUrl(authorLinkEl?.getAttribute('href') || ''),
           });
-        });
+        }
 
         return results;
       })()
-    `);
-        const data = Array.isArray(payload) ? payload : [];
+    `;
+}
+export const command = cli({
+    site: 'xiaohongshu',
+    name: 'search',
+    access: 'read',
+    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' },
+    ],
+    columns: ['rank', 'title', 'author', 'likes', 'published_at', 'url'],
+    func: async (page, kwargs) => {
+        const limit = parseLimit(kwargs.limit);
+        const keyword = encodeURIComponent(kwargs.query);
+        await page.goto(`https://www.xiaohongshu.com/search_result?keyword=${keyword}&source=web_search_result_notes`);
+        // Wait for search results to render (or login wall to appear).
+        // Uses MutationObserver to resolve as soon as content appears,
+        // instead of a fixed delay + blind retry.
+        const waitResult = await page.evaluate(WAIT_FOR_CONTENT_JS);
+        if (waitResult === 'login_wall') {
+            throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
+        }
+        // Extract before scrolling. Xiaohongshu uses a virtualized masonry
+        // layout, so scrolling to the bottom can evict the initially visible
+        // note cards from the DOM and make extraction return [] even though the
+        // browser rendered results correctly.
+        const initialPayload = await page.evaluate(buildSearchExtractJs('www.xiaohongshu.com'));
+        let payload = Array.isArray(initialPayload) ? initialPayload : [];
+        if (payload.length < limit) {
+            // Scroll until enough rows are rendered or the lazy-load plateaus.
+            // Replaces the previous fixed `autoScroll({ times: 2 })` which capped
+            // extraction at ~13 notes regardless of `--limit` (#1471).
+            await page.evaluate(buildScrollUntilJs(limit));
+            const scrolledPayload = await page.evaluate(buildSearchExtractJs('www.xiaohongshu.com'));
+            if (Array.isArray(scrolledPayload)) {
+                const seen = new Set(payload.map((item) => item.url).filter(Boolean));
+                for (const item of scrolledPayload) {
+                    if (item?.url && seen.has(item.url))
+                        continue;
+                    if (item?.url)
+                        seen.add(item.url);
+                    payload.push(item);
+                    if (payload.length >= limit)
+                        break;
+                }
+            }
+        }
+        const data = payload;
         return data
             .filter((item) => item.title)
-            .slice(0, kwargs.limit)
+            .slice(0, limit)
             .map((item, i) => ({
             rank: i + 1,
             ...item,

package/clis/xiaohongshu/search.test.js

@@ -1,7 +1,11 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { JSDOM } from 'jsdom';
-import { __test__, noteIdToDate } from './search.js';
+import { __test__, buildScrollUntilJs, noteIdToDate } from './search.js';
+
+function markVisible(el) {
+    el.getBoundingClientRect = () => ({ width: 100, height: 100 });
+}
 function createPageMock(evaluateResults) {
     const evaluate = vi.fn();
     for (const result of evaluateResults) {
@@ -31,6 +35,16 @@ function createPageMock(evaluateResults) {
     };
 }
 describe('xiaohongshu search', () => {
+    it('rejects invalid limit before browser navigation', async () => {
+        const cmd = getRegistry().get('xiaohongshu/search');
+        const page = createPageMock([]);
+
+        await expect(cmd.func(page, { query: '特斯拉', limit: 0 })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: expect.stringContaining('--limit'),
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
     it('throws a clear error when the search page is blocked by a login wall', async () => {
         const cmd = getRegistry().get('xiaohongshu/search');
         expect(cmd?.func).toBeTypeOf('function');
@@ -39,7 +53,8 @@ describe('xiaohongshu search', () => {
             'login_wall',
         ]);
         await expect(cmd.func(page, { query: '特斯拉', limit: 5 })).rejects.toThrow('Xiaohongshu search results are blocked behind a login wall');
-        // autoScroll must NOT be called when a login wall is detected early
+        // No scroll-until / autoScroll call when a login wall is detected early.
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
         expect(page.autoScroll).not.toHaveBeenCalled();
     });
     it('returns ranked results with search_result url and author_url preserved', async () => {
@@ -50,7 +65,7 @@ describe('xiaohongshu search', () => {
         const page = createPageMock([
             // First evaluate: MutationObserver wait (content appeared)
             'content',
-            // Second evaluate: main DOM extraction (returns array directly)
+            // Second evaluate: initial DOM extraction (already enough results)
             [
                 {
                     title: '某鱼买FSD被坑了4万',
@@ -82,7 +97,7 @@ describe('xiaohongshu search', () => {
         const page = createPageMock([
             // First evaluate: MutationObserver wait (content appeared)
             'content',
-            // Second evaluate: main DOM extraction (returns array directly)
+            // Second evaluate: initial DOM extraction (already enough valid rows)
             [
                 {
                     title: 'Result A',
@@ -118,15 +133,36 @@ describe('xiaohongshu search', () => {
         const page = createPageMock([
             // First evaluate: MutationObserver wait (content appeared)
             'content',
-            // Second evaluate: extraction (returns empty array)
+            // Second evaluate: initial extraction (no rows rendered)
             [],
         ]);
         const result = (await cmd.func(page, { query: '测试等待', limit: 5 }));
         expect(result).toHaveLength(0);
         // Only one navigation, no retry
         expect(page.goto).toHaveBeenCalledTimes(1);
-        // Two evaluate calls: wait + extraction
-        expect(page.evaluate).toHaveBeenCalledTimes(2);
+        // Four evaluate calls: wait, initial extraction, scroll-until, post-scroll extraction.
+        expect(page.evaluate).toHaveBeenCalledTimes(4);
+    });
+    it('scrolls only when the initial extraction has fewer rows than requested', async () => {
+        const cmd = getRegistry().get('xiaohongshu/search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            'content',
+            [
+                { title: 'Result A', author: 'UserA', likes: '10', url: 'https://www.xiaohongshu.com/search_result/aaa', author_url: '' },
+            ],
+            3,
+            [
+                { title: 'Result A', author: 'UserA', likes: '10', url: 'https://www.xiaohongshu.com/search_result/aaa', author_url: '' },
+                { title: 'Result B', author: 'UserB', likes: '5', url: 'https://www.xiaohongshu.com/search_result/bbb', author_url: '' },
+            ],
+        ]);
+
+        const result = (await cmd.func(page, { query: '测试等待', limit: 2 }));
+
+        expect(result).toHaveLength(2);
+        expect(result.map((item) => item.title)).toEqual(['Result A', 'Result B']);
+        expect(page.evaluate).toHaveBeenCalledTimes(4);
     });
     it('separates fallback author text from appended relative date', async () => {
         const cmd = getRegistry().get('xiaohongshu/search');
@@ -141,9 +177,10 @@ describe('xiaohongshu search', () => {
             <span class="count">8</span>
           </section>
         `, { url: 'https://www.xiaohongshu.com/search_result?keyword=test' });
+        markVisible(dom.window.document.querySelector('section.note-item'));
         const page = createPageMock([]);
         page.evaluate.mockImplementationOnce(async () => 'content');
-        page.evaluate.mockImplementationOnce(async (script) => Function('document', `return (${script})`)(dom.window.document));
+        page.evaluate.mockImplementationOnce(async (script) => Function('document', 'getComputedStyle', `return (${script})`)(dom.window.document, dom.window.getComputedStyle.bind(dom.window)));
 
         const result = await cmd.func(page, { query: '测试', limit: 1 });
 
@@ -155,6 +192,43 @@ describe('xiaohongshu search', () => {
         });
     });
 });
+describe('buildScrollUntilJs', () => {
+    it('inlines the target count and default maxScrolls into the generated IIFE', () => {
+        const js = buildScrollUntilJs(40);
+        // Target count must drive the early-exit check (#1471: --limit > 13 was capped).
+        expect(js).toContain('countItems() >= 40');
+        // Default safety cap of 15 to bound runtime on infinite-scroll pages.
+        expect(js).toContain('i < 15');
+        // Plateau detection so the loop exits early when XHS stops lazy-loading
+        // instead of spinning all 15 iterations against an exhausted feed.
+        expect(js).toContain('plateauRounds');
+        // Related-search rows must not count toward the target.
+        expect(js).toContain("classList.contains('query-note-item')");
+    });
+    it('respects a custom maxScrolls override', () => {
+        const js = buildScrollUntilJs(100, 5);
+        expect(js).toContain('countItems() >= 100');
+        expect(js).toContain('i < 5');
+    });
+    it('counts only visible real note rows', async () => {
+        const dom = new JSDOM(`
+          <section class="note-item" id="visible"></section>
+          <section class="note-item query-note-item" id="query"></section>
+          <section class="note-item" id="hidden" style="display:none"></section>
+        `, { url: 'https://www.xiaohongshu.com/search_result?keyword=test' });
+        markVisible(dom.window.document.querySelector('#visible'));
+        markVisible(dom.window.document.querySelector('#query'));
+        markVisible(dom.window.document.querySelector('#hidden'));
+
+        const result = await Function('document', 'window', 'MutationObserver', 'getComputedStyle', `return (${buildScrollUntilJs(1)})`)(dom.window.document, dom.window, dom.window.MutationObserver, dom.window.getComputedStyle.bind(dom.window));
+
+        expect(result).toBe(1);
+    });
+    it('rejects unsafe helper arguments instead of interpolating them into code', () => {
+        expect(() => buildScrollUntilJs(0)).toThrow(/targetCount/);
+        expect(() => buildScrollUntilJs(10, 0)).toThrow(/maxScrolls/);
+    });
+});
 describe('stripXhsAuthorDateSuffix', () => {
     it('only strips trailing date suffixes and preserves date-like author text', () => {
         expect(__test__.stripXhsAuthorDateSuffix('作者名 3天前')).toBe('作者名');

package/clis/xiaohongshu/user-helpers.js

@@ -27,12 +27,17 @@ export function flattenXhsNoteGroups(noteGroups) {
     }
     return notes;
 }
-export function buildXhsNoteUrl(userId, noteId, xsecToken) {
+/**
+ * Build a signed user-profile note URL on the given web host (defaults to
+ * `www.xiaohongshu.com`). The rednote adapter passes `'www.rednote.com'` so
+ * the same builder works for both sites.
+ */
+export function buildXhsNoteUrl(userId, noteId, xsecToken, webHost = 'www.xiaohongshu.com') {
     const cleanUserId = toCleanString(userId);
     const cleanNoteId = toCleanString(noteId);
     if (!cleanUserId || !cleanNoteId)
         return '';
-    const url = new URL(`https://www.xiaohongshu.com/user/profile/${cleanUserId}/${cleanNoteId}`);
+    const url = new URL(`https://${webHost}/user/profile/${cleanUserId}/${cleanNoteId}`);
     const cleanToken = toCleanString(xsecToken);
     if (cleanToken) {
         url.searchParams.set('xsec_token', cleanToken);
@@ -40,7 +45,11 @@ export function buildXhsNoteUrl(userId, noteId, xsecToken) {
     }
     return url.toString();
 }
-export function extractXhsUserNotes(snapshot, fallbackUserId) {
+/**
+ * Normalise a Pinia user-store snapshot into CLI rows. `webHost` is forwarded
+ * to `buildXhsNoteUrl` so the resulting URLs point at the calling site.
+ */
+export function extractXhsUserNotes(snapshot, fallbackUserId, webHost = 'www.xiaohongshu.com') {
     const notes = flattenXhsNoteGroups(snapshot.noteGroups);
     const rows = [];
     const seen = new Set();
@@ -62,7 +71,7 @@ export function extractXhsUserNotes(snapshot, fallbackUserId) {
             type: toCleanString(noteCard.type),
             likes,
             cover,
-            url: buildXhsNoteUrl(userId || fallbackUserId, noteId, xsecToken),
+            url: buildXhsNoteUrl(userId || fallbackUserId, noteId, xsecToken, webHost),
         });
     }
     return rows;

package/clis/xiaohongshu/user-helpers.test.js

@@ -20,6 +20,9 @@ describe('buildXhsNoteUrl', () => {
     it('includes xsec token when available', () => {
         expect(buildXhsNoteUrl('user123', 'note456', 'token789')).toBe('https://www.xiaohongshu.com/user/profile/user123/note456?xsec_token=token789&xsec_source=pc_user');
     });
+    it('emits a rednote URL when webHost is overridden', () => {
+        expect(buildXhsNoteUrl('user123', 'note456', 'token789', 'www.rednote.com')).toBe('https://www.rednote.com/user/profile/user123/note456?xsec_token=token789&xsec_source=pc_user');
+    });
 });
 describe('extractXhsUserNotes', () => {
     it('normalizes grouped note cards into CLI rows', () => {
@@ -96,4 +99,21 @@ describe('extractXhsUserNotes', () => {
         expect(rows).toHaveLength(1);
         expect(rows[0]?.title).toBe('keep me');
     });
+    it('emits rednote-hosted URLs when webHost is overridden', () => {
+        const rows = extractXhsUserNotes({
+            noteGroups: [
+                [
+                    {
+                        xsecToken: 'tok',
+                        noteCard: {
+                            noteId: 'note-red',
+                            displayTitle: 'rednote note',
+                            user: { userId: 'user-red' },
+                        },
+                    },
+                ],
+            ],
+        }, 'fallback-user', 'www.rednote.com');
+        expect(rows[0]?.url).toBe('https://www.rednote.com/user/profile/user-red/note-red?xsec_token=tok&xsec_source=pc_user');
+    });
 });