@jackwener/opencli 1.7.17 → 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

@@ -8,34 +8,40 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CliError, EmptyResultError } from '@jackwener/opencli/errors';
 import { parseNoteId, buildNoteUrl } from './note-helpers.js';
-function parseCommentLimit(raw, fallback = 20) {
+export function parseCommentLimit(raw, fallback = 20) {
     const n = Number(raw);
     if (!Number.isFinite(n))
         return fallback;
     return Math.max(1, Math.min(Math.floor(n), 50));
 }
-cli({
-    site: 'xiaohongshu',
-    name: 'comments',
-    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' },
-        { name: 'limit', type: 'int', default: 20, help: 'Number of top-level comments (max 50)' },
-        { name: 'with-replies', type: 'boolean', default: false, help: 'Include nested replies (楼中楼)' },
-    ],
-    columns: ['rank', 'author', 'text', 'likes', 'time', 'is_reply', 'reply_to'],
-    func: async (page, kwargs) => {
-        const limit = parseCommentLimit(kwargs.limit);
-        const withReplies = Boolean(kwargs['with-replies']);
-        const raw = String(kwargs['note-id']);
-        const noteId = parseNoteId(raw);
-        await page.goto(buildNoteUrl(raw, { commandName: 'xiaohongshu comments' }));
-        await page.wait({ time: 2 + Math.random() * 3 });
-        const data = await page.evaluate(`
+
+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))
         const withReplies = ${withReplies}
@@ -59,9 +65,9 @@ cli({
         }
 
         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
@@ -115,7 +121,30 @@ cli({
 
         return { pageUrl: location.href, securityBlock, loginWall, results }
       })()
-    `);
+    `;
+}
+export const command = cli({
+    site: 'xiaohongshu',
+    name: 'comments',
+    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' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of top-level comments (max 50)' },
+        { name: 'with-replies', type: 'boolean', default: false, help: 'Include nested replies (楼中楼)' },
+    ],
+    columns: ['rank', 'author', 'text', 'likes', 'time', 'is_reply', 'reply_to'],
+    func: async (page, kwargs) => {
+        const limit = parseCommentLimit(kwargs.limit);
+        const withReplies = Boolean(kwargs['with-replies']);
+        const raw = String(kwargs['note-id']);
+        const noteId = parseNoteId(raw);
+        await page.goto(buildNoteUrl(raw, { commandName: 'xiaohongshu comments' }));
+        await page.wait({ time: 2 + Math.random() * 3 });
+        const data = await page.evaluate(buildCommentsExtractJs(withReplies));
         if (!data || typeof data !== 'object') {
             throw new EmptyResultError('xiaohongshu/comments', 'Unexpected evaluate response');
         }
@@ -127,6 +156,8 @@ cli({
         if (data.loginWall) {
             throw new AuthRequiredError('www.xiaohongshu.com', 'Note comments require login');
         }
+        // noteId currently unused after parsing — kept for symmetry with the note command
+        void noteId;
         const all = data.results ?? [];
         // When limiting, count only top-level comments; their replies are included for free
         if (withReplies) {

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/download.js

@@ -11,27 +11,15 @@ import { formatCookieHeader } from '@jackwener/opencli/download';
 import { downloadMedia } from '@jackwener/opencli/download/media-download';
 import { CliError } from '@jackwener/opencli/errors';
 import { buildNoteUrl, parseNoteId } from './note-helpers.js';
-cli({
-    site: 'xiaohongshu',
-    name: 'download',
-    access: 'read',
-    description: '下载小红书笔记中的图片和视频',
-    domain: 'www.xiaohongshu.com',
-    strategy: Strategy.COOKIE,
-    navigateBefore: false,
-    args: [
-        { name: 'note-id', positional: true, required: true, help: 'Full Xiaohongshu note URL with xsec_token, or xhslink short link' },
-        { name: 'output', default: './xiaohongshu-downloads', help: 'Output directory' },
-    ],
-    columns: ['index', 'type', 'status', 'size'],
-    func: async (page, kwargs) => {
-        const rawInput = String(kwargs['note-id']);
-        const output = kwargs.output;
-        const noteId = parseNoteId(rawInput);
-        await page.goto(buildNoteUrl(rawInput, { allowShortLink: true, commandName: 'xiaohongshu download' }));
-        await page.wait({ time: 1 + Math.random() * 2 });
-        // Extract note info and media URLs
-        const data = await page.evaluate(`
+/**
+ * Build the media-extraction IIFE. The note id is interpolated as a default
+ * since the IIFE may also resolve it from `location.pathname`. The CDN
+ * substring allowlist includes `rednote` so the rednote adapter can reuse
+ * this script unchanged — image / video URLs on both sites are served from
+ * the same xhscdn family per #1136.
+ */
+export function buildDownloadExtractJs(noteId) {
+    return `
       (() => {
         const bodyText = document.body?.innerText || '';
         const result = {
@@ -79,7 +67,7 @@ cli({
         for (const selector of imageSelectors) {
           document.querySelectorAll(selector).forEach(img => {
             let src = img.src || img.getAttribute('data-src') || '';
-            if (src && (src.includes('xhscdn') || src.includes('xiaohongshu'))) {
+            if (src && (src.includes('xhscdn') || src.includes('xiaohongshu') || src.includes('rednote'))) {
               src = src.split('?')[0];
               src = src.replace(/\\/imageView\\d+\\/\\d+\\/w\\/\\d+/, '');
               imageUrls.add(src);
@@ -154,7 +142,28 @@ cli({
 
         return result;
       })()
-    `);
+    `;
+}
+export const command = cli({
+    site: 'xiaohongshu',
+    name: 'download',
+    access: 'read',
+    description: '下载小红书笔记中的图片和视频',
+    domain: 'www.xiaohongshu.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        { name: 'note-id', positional: true, required: true, help: 'Full Xiaohongshu note URL with xsec_token, or xhslink short link' },
+        { name: 'output', default: './xiaohongshu-downloads', help: 'Output directory' },
+    ],
+    columns: ['index', 'type', 'status', 'size'],
+    func: async (page, kwargs) => {
+        const rawInput = String(kwargs['note-id']);
+        const output = kwargs.output;
+        const noteId = parseNoteId(rawInput);
+        await page.goto(buildNoteUrl(rawInput, { allowShortLink: true, commandName: 'xiaohongshu download' }));
+        await page.wait({ time: 1 + Math.random() * 2 });
+        const data = await page.evaluate(buildDownloadExtractJs(noteId));
         if (data?.securityBlock) {
             throw new CliError('SECURITY_BLOCK', 'Xiaohongshu security block: the note detail page was blocked by risk control.', /^https?:\/\//.test(rawInput)
                 ? 'The page may be temporarily restricted. Try again later or from a different session.'

package/clis/xiaohongshu/feed.js

@@ -1,18 +1,12 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-cli({
-    site: 'xiaohongshu',
-    name: 'feed',
-    access: 'read',
-    description: '小红书首页推荐 Feed (via Pinia Store Action)',
-    domain: 'www.xiaohongshu.com',
-    strategy: Strategy.INTERCEPT,
-    browser: true,
-    args: [
-        { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
-    ],
-    columns: ['id', 'title', 'author', 'likes', 'type', 'url'],
-    pipeline: [
-        { navigate: 'https://www.xiaohongshu.com/explore' },
+/**
+ * Build the home-feed pipeline for the given web host. Exported so the
+ * rednote adapter can register the same pipeline against www.rednote.com
+ * without duplicating the tap/map/limit steps.
+ */
+export function buildFeedPipeline(webHost) {
+    return [
+        { navigate: `https://${webHost}/explore` },
         { tap: {
                 store: 'feed',
                 action: 'fetchFeeds',
@@ -26,8 +20,22 @@ cli({
                 type: '${{ item.note_card.type }}',
                 author: '${{ item.note_card.user.nickname }}',
                 likes: '${{ item.note_card.interact_info.liked_count }}',
-                url: 'https://www.xiaohongshu.com/explore/${{ item.id }}',
+                url: `https://${webHost}/explore/\${{ item.id }}`,
             } },
         { limit: '${{ args.limit | default(20) }}' },
+    ];
+}
+export const command = cli({
+    site: 'xiaohongshu',
+    name: 'feed',
+    access: 'read',
+    description: '小红书首页推荐 Feed (via Pinia Store Action)',
+    domain: 'www.xiaohongshu.com',
+    strategy: Strategy.INTERCEPT,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
     ],
+    columns: ['id', 'title', 'author', 'likes', 'type', 'url'],
+    pipeline: buildFeedPipeline('www.xiaohongshu.com'),
 });

package/clis/xiaohongshu/note-helpers.js

@@ -14,9 +14,9 @@ function isShortLink(input) {
     return /^https?:\/\/xhslink\.com\//i.test(input);
 }
 
-function isXiaohongshuHost(hostname) {
+function isHostMatch(hostname, cookieRoot) {
     const normalized = hostname.toLowerCase();
-    return normalized === 'xiaohongshu.com' || normalized.endsWith('.xiaohongshu.com');
+    return normalized === cookieRoot || normalized.endsWith('.' + cookieRoot);
 }
 
 function isSupportedNotePath(pathname) {
@@ -30,14 +30,24 @@ function isSupportedNotePath(pathname) {
  * XHS note detail pages now require a valid signed URL for reliable access.
  * Bare note IDs no longer resolve deterministically, so callers must provide
  * a full note URL with xsec_token or, for downloads only, an xhslink short link.
+ *
+ * `options.cookieRoot` overrides the default `xiaohongshu.com` cookie root —
+ * the rednote adapter passes `'rednote.com'` so the same validator accepts
+ * `www.rednote.com` URLs without duplicating this function.
+ * `options.signedUrlHint` overrides the default hint surfaced on rejection.
  */
 export function buildNoteUrl(input, options = {}) {
-    const { allowShortLink = false, commandName = 'xiaohongshu note' } = options;
+    const {
+        allowShortLink = false,
+        commandName = 'xiaohongshu note',
+        cookieRoot = 'xiaohongshu.com',
+        signedUrlHint = XHS_SIGNED_URL_HINT,
+    } = options;
     const trimmed = input.trim();
     const message = `${commandName} now requires a full signed URL`;
     const hint = allowShortLink
-        ? `${XHS_SIGNED_URL_HINT} For downloads, xhslink short links are also supported.`
-        : XHS_SIGNED_URL_HINT;
+        ? `${signedUrlHint} For downloads, xhslink short links are also supported.`
+        : signedUrlHint;
 
     if (/^https?:\/\//.test(trimmed)) {
         if (isShortLink(trimmed)) {
@@ -48,7 +58,7 @@ export function buildNoteUrl(input, options = {}) {
         try {
             const url = new URL(trimmed);
             const xsecToken = url.searchParams.get('xsec_token')?.trim();
-            if (isXiaohongshuHost(url.hostname) && isSupportedNotePath(url.pathname) && xsecToken) {
+            if (isHostMatch(url.hostname, cookieRoot) && isSupportedNotePath(url.pathname) && xsecToken) {
                 return trimmed;
             }
         }