@jackwener/opencli 1.7.18 → 1.7.19

package/clis/twitter/tweets.test.js

@@ -1,5 +1,6 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError } from '@jackwener/opencli/errors';
 import { __test__ } from './tweets.js';
 
 describe('twitter tweets helpers', () => {
@@ -8,6 +9,140 @@ describe('twitter tweets helpers', () => {
         expect(cmd?.columns).toEqual(['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls']);
     });
 
+    it('makes the username argument optional so it can default to the logged-in user', () => {
+        const cmd = getRegistry().get('twitter/tweets');
+        const usernameArg = cmd?.args?.find((arg) => arg.name === 'username');
+        expect(usernameArg).toBeDefined();
+        expect(usernameArg?.required).not.toBe(true);
+        expect(usernameArg?.help || '').toMatch(/default/i);
+        expect(cmd?.description || '').toMatch(/default/i);
+    });
+
+    it('detects the logged-in user via AppTabBar_Profile_Link when no username is given', async () => {
+        const cmd = getRegistry().get('twitter/tweets');
+        const evaluatedScripts = [];
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn(async () => [{ name: 'ct0', value: 'token' }]),
+            evaluate: vi.fn(async (script) => {
+                const text = typeof script === 'function' ? script.toString() : String(script);
+                evaluatedScripts.push(text);
+                if (text.includes('AppTabBar_Profile_Link')) return '/viewer';
+                if (text.includes('operationName')) return null; // operation metadata resolver
+                if (text.includes('/UserByScreenName')) return '42';
+                if (text.includes('/UserTweets')) {
+                    return {
+                        data: {
+                            user: {
+                                result: {
+                                    timeline_v2: {
+                                        timeline: {
+                                            instructions: [
+                                                {
+                                                    entries: [
+                                                        {
+                                                            entryId: 'tweet-1',
+                                                            content: {
+                                                                itemContent: {
+                                                                    tweet_results: {
+                                                                        result: {
+                                                                            rest_id: '1',
+                                                                            legacy: {
+                                                                                full_text: 'own post',
+                                                                                favorite_count: 0,
+                                                                                retweet_count: 0,
+                                                                                reply_count: 0,
+                                                                                created_at: 'now',
+                                                                            },
+                                                                            core: {
+                                                                                user_results: {
+                                                                                    result: {
+                                                                                        legacy: { screen_name: 'viewer', name: 'Viewer' },
+                                                                                    },
+                                                                                },
+                                                                            },
+                                                                        },
+                                                                    },
+                                                                },
+                                                            },
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    };
+                }
+                return null;
+            }),
+        };
+        const rows = await cmd.func(page, { limit: 1 });
+        // Navigated home to read the logged-in user
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/home');
+        // AppTabBar_Profile_Link probe happened before any GraphQL fetch
+        const probeIdx = evaluatedScripts.findIndex((t) => t.includes('AppTabBar_Profile_Link'));
+        const graphqlIdx = evaluatedScripts.findIndex((t) => t.includes('/UserByScreenName'));
+        expect(probeIdx).toBeGreaterThanOrEqual(0);
+        expect(graphqlIdx).toBeGreaterThan(probeIdx);
+        // The detected handle ('viewer') was used for the UserByScreenName lookup
+        const lookup = evaluatedScripts.find((t) => t.includes('/UserByScreenName')) || '';
+        expect(decodeURIComponent(lookup)).toContain('"screen_name":"viewer"');
+        expect(rows).toHaveLength(1);
+        expect(rows[0]).toMatchObject({ id: '1', author: 'viewer', url: 'https://x.com/viewer/status/1' });
+    });
+
+    it('throws AuthRequiredError when no username is given and the logged-in user cannot be detected', async () => {
+        const cmd = getRegistry().get('twitter/tweets');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn(async () => []),
+            evaluate: vi.fn(async (script) => {
+                const text = typeof script === 'function' ? script.toString() : String(script);
+                if (text.includes('AppTabBar_Profile_Link')) return null;
+                return null;
+            }),
+        };
+        await expect(cmd.func(page, {})).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('rejects invalid explicit username before navigation', async () => {
+        const cmd = getRegistry().get('twitter/tweets');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn(async () => [{ name: 'ct0', value: 'token' }]),
+            evaluate: vi.fn(),
+        };
+
+        await expect(cmd.func(page, { username: 'viewer/extra' })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.getCookies).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('rejects non-profile AppTabBar hrefs instead of querying route names as users', async () => {
+        const cmd = getRegistry().get('twitter/tweets');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn(async () => [{ name: 'ct0', value: 'token' }]),
+            evaluate: vi.fn(async (script) => {
+                const text = typeof script === 'function' ? script.toString() : String(script);
+                if (text.includes('AppTabBar_Profile_Link')) return '/home';
+                throw new Error(`Unexpected evaluate: ${text.slice(0, 80)}`);
+            }),
+        };
+
+        await expect(cmd.func(page, {})).rejects.toBeInstanceOf(AuthRequiredError);
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/home');
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+
     it('falls back when queryId contains unsafe characters', () => {
         expect(__test__.sanitizeQueryId('safe_Query-123', 'fallback')).toBe('safe_Query-123');
         expect(__test__.sanitizeQueryId('bad"id', 'fallback')).toBe('fallback');
@@ -60,6 +195,18 @@ describe('twitter tweets helpers', () => {
         expect(b.is_retweet).toBe(true);
     });
 
+    it('unwraps TweetWithVisibilityResults', () => {
+        const tweet = __test__.extractTweet({
+            __typename: 'TweetWithVisibilityResults',
+            tweet: {
+                rest_id: '42',
+                legacy: { full_text: 'visible post', favorite_count: 2, retweet_count: 0, reply_count: 0, created_at: 'now' },
+                core: { user_results: { result: { legacy: { screen_name: 'alice', name: 'Alice' } } } },
+            },
+        }, new Set());
+        expect(tweet).toMatchObject({ id: '42', author: 'alice', text: 'visible post' });
+    });
+
     it('parses chronological tweets and skips pinned instruction', () => {
         const chronEntry = {
             entryId: 'tweet-1',
@@ -122,4 +269,94 @@ describe('twitter tweets helpers', () => {
             url: 'https://x.com/alice/status/1',
         });
     });
+
+    it('recursively parses tweets nested in timeline modules', () => {
+        const payload = {
+            data: {
+                user: {
+                    result: {
+                        timeline_v2: {
+                            timeline: {
+                                instructions: [
+                                    {
+                                        type: 'TimelineAddEntries',
+                                        entries: [
+                                            {
+                                                entryId: 'profile-conversation-1',
+                                                content: {
+                                                    entryType: 'TimelineTimelineModule',
+                                                    items: [
+                                                        {
+                                                            item: {
+                                                                itemContent: {
+                                                                    tweet_results: {
+                                                                        result: {
+                                                                            rest_id: '2',
+                                                                            legacy: { full_text: 'nested post', favorite_count: 1, retweet_count: 0, reply_count: 0, created_at: 'now' },
+                                                                            core: { user_results: { result: { legacy: { screen_name: 'alice', name: 'Alice' } } } },
+                                                                        },
+                                                                    },
+                                                                },
+                                                            },
+                                                        },
+                                                    ],
+                                                },
+                                            },
+                                            {
+                                                entryId: 'cursor-bottom-2',
+                                                content: { entryType: 'TimelineTimelineCursor', cursorType: 'Bottom', value: 'next' },
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const result = __test__.parseUserTweets(payload, new Set());
+        expect(result.nextCursor).toBe('next');
+        expect(result.tweets).toHaveLength(1);
+        expect(result.tweets[0]).toMatchObject({ id: '2', text: 'nested post' });
+    });
+
+    it('uses populated timeline instructions when timeline_v2 is present but empty', () => {
+        const payload = {
+            data: {
+                user: {
+                    result: {
+                        timeline_v2: { timeline: { instructions: [] } },
+                        timeline: {
+                            timeline: {
+                                instructions: [
+                                    {
+                                        type: 'TimelineAddEntries',
+                                        entries: [
+                                            {
+                                                content: {
+                                                    itemContent: {
+                                                        tweet_results: {
+                                                            result: {
+                                                                rest_id: '3',
+                                                                legacy: { full_text: 'fallback timeline post', favorite_count: 0, retweet_count: 0, reply_count: 0, created_at: 'now' },
+                                                                core: { user_results: { result: { legacy: { screen_name: 'alice', name: 'Alice' } } } },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const result = __test__.parseUserTweets(payload, new Set());
+        expect(result.tweets).toHaveLength(1);
+        expect(result.tweets[0]).toMatchObject({ id: '3', text: 'fallback timeline post' });
+    });
 });

package/clis/xiaohongshu/comments.js

@@ -14,12 +14,33 @@ export function parseCommentLimit(raw, fallback = 20) {
         return fallback;
     return Math.max(1, Math.min(Math.floor(n), 50));
 }
+
+export function parseXhsLikeCountText(value) {
+    const integerRe = /^(?:\d+|\d{1,3}(?:[,，]\d{3})+)\+?$/u;
+    const shortformRe = /^((?:\d+|\d{1,3}(?:[,，]\d{3})+)(?:\.\d+)?)([wWkK万千])\+?$/u;
+    const raw = String(value ?? '').replace(/\s+/g, '');
+    if (!raw)
+        return 0;
+    if (integerRe.test(raw))
+        return Number(raw.replace(/[,+，]/g, ''));
+    const short = raw.match(shortformRe);
+    if (!short)
+        return 0;
+    const numeric = Number(short[1].replace(/[,，]/g, ''));
+    if (!Number.isFinite(numeric))
+        return 0;
+    const unit = short[2].toLowerCase();
+    const multiplier = unit === 'w' || unit === '万' ? 10000 : 1000;
+    return Math.round(numeric * multiplier);
+}
+
 /**
  * Host-agnostic IIFE that scrolls a note's comment list and extracts
  * top-level comments (and optionally nested 楼中楼 replies). Exported so
  * the rednote adapter can reuse the exact same selector chain.
  */
 export function buildCommentsExtractJs(withReplies) {
+    const parseLikeCountText = parseXhsLikeCountText.toString();
     return `
       (async () => {
         const wait = (ms) => new Promise(r => setTimeout(r, ms))
@@ -44,9 +65,9 @@ export function buildCommentsExtractJs(withReplies) {
         }
 
         const clean = (el) => (el?.textContent || '').replace(/\\s+/g, ' ').trim()
+        const parseLikeCountText = ${parseLikeCountText}
         const parseLikes = (el) => {
-          const raw = clean(el)
-          return /^\\d+$/.test(raw) ? Number(raw) : 0
+          return parseLikeCountText(clean(el))
         }
         const expandReplyThreads = async (root) => {
           if (!withReplies || !root) return

package/clis/xiaohongshu/comments.test.js

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
+import { JSDOM } from 'jsdom';
 import { getRegistry } from '@jackwener/opencli/registry';
-import './comments.js';
+import { buildCommentsExtractJs, parseXhsLikeCountText } from './comments.js';
 function createPageMock(evaluateResult) {
     return {
         goto: vi.fn().mockResolvedValue(undefined),
@@ -25,6 +26,41 @@ function createPageMock(evaluateResult) {
         waitForCapture: vi.fn().mockResolvedValue(undefined),
     };
 }
+
+async function runCommentsExtract(html) {
+    const dom = new JSDOM(html, { url: 'https://www.xiaohongshu.com/search_result/abc123?xsec_token=tok' });
+    const previousDocument = globalThis.document;
+    const previousLocation = globalThis.location;
+    globalThis.document = dom.window.document;
+    globalThis.location = dom.window.location;
+    try {
+        return await eval(buildCommentsExtractJs(false));
+    } finally {
+        globalThis.document = previousDocument;
+        globalThis.location = previousLocation;
+    }
+}
+
+describe('parseXhsLikeCountText', () => {
+    it('parses exact integer and shortform like counts', () => {
+        expect(parseXhsLikeCountText('0')).toBe(0);
+        expect(parseXhsLikeCountText('42')).toBe(42);
+        expect(parseXhsLikeCountText('1,234')).toBe(1234);
+        expect(parseXhsLikeCountText('1，234+')).toBe(1234);
+        expect(parseXhsLikeCountText('2.1w')).toBe(21000);
+        expect(parseXhsLikeCountText('1.5万')).toBe(15000);
+        expect(parseXhsLikeCountText('1.2k')).toBe(1200);
+        expect(parseXhsLikeCountText('3千')).toBe(3000);
+        expect(parseXhsLikeCountText(' 2.1 w + ')).toBe(21000);
+    });
+
+    it('returns 0 for unknown shapes without overparsing arbitrary text', () => {
+        for (const raw of ['', null, undefined, '赞', 'likes 2.1w', '2w人', '1,23', '1.2.3k', '.', '1.5']) {
+            expect(parseXhsLikeCountText(raw)).toBe(0);
+        }
+    });
+});
+
 describe('xiaohongshu comments', () => {
     const command = getRegistry().get('xiaohongshu/comments');
     it('returns ranked comment rows for signed full URLs', async () => {
@@ -120,6 +156,32 @@ describe('xiaohongshu comments', () => {
         expect(script).toContain("const afterCount = scroller.querySelectorAll('.parent-comment').length");
         expect(script).toContain('if (afterCount <= beforeCount) break');
     });
+    it('extracts shortform like counts from the shared xiaohongshu/rednote DOM script', async () => {
+        const data = await runCommentsExtract(`
+          <main>
+            <section class="parent-comment">
+              <div class="comment-item">
+                <div class="author-wrapper"><span class="name">Alice</span></div>
+                <div class="content">Great note</div>
+                <span class="count">2.1w</span>
+                <span class="date">today</span>
+              </div>
+            </section>
+            <section class="parent-comment">
+              <div class="comment-item">
+                <span class="user-name">Bob</span>
+                <div class="note-text">Malformed count</div>
+                <span class="count">likes 2.1w</span>
+              </div>
+            </section>
+          </main>
+        `);
+
+        expect(data.results).toEqual([
+            { author: 'Alice', text: 'Great note', likes: 21000, time: 'today', is_reply: false, reply_to: '' },
+            { author: 'Bob', text: 'Malformed count', likes: 0, time: '', is_reply: false, reply_to: '' },
+        ]);
+    });
     it('respects the limit for top-level comments', async () => {
         const manyComments = Array.from({ length: 10 }, (_, i) => ({
             author: `User${i}`,

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,6 +60,100 @@ 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;
 }
+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;
+          }
+        }
+        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
@@ -70,13 +172,34 @@ export function buildSearchExtractJs(webHost) {
 
         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');
@@ -96,20 +219,29 @@ export function buildSearchExtractJs(webHost) {
           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;
       })()
@@ -129,6 +261,7 @@ export const command = cli({
     ],
     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).
@@ -138,13 +271,35 @@ export const command = cli({
         if (waitResult === 'login_wall') {
             throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
         }
-        // Scroll a couple of times to load more results
-        await page.autoScroll({ times: 2 });
-        const payload = await page.evaluate(buildSearchExtractJs('www.xiaohongshu.com'));
-        const data = Array.isArray(payload) ? payload : [];
+        // 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,