@jackwener/opencli 1.7.17 → 1.7.18

package/clis/rednote/rednote.test.js

@@ -0,0 +1,157 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockDownloadMedia, mockFormatCookieHeader } = vi.hoisted(() => ({
+    mockDownloadMedia: vi.fn(),
+    mockFormatCookieHeader: vi.fn(() => 'sid=secret'),
+}));
+
+vi.mock('@jackwener/opencli/download/media-download', () => ({
+    downloadMedia: mockDownloadMedia,
+}));
+
+vi.mock('@jackwener/opencli/download', () => ({
+    formatCookieHeader: mockFormatCookieHeader,
+}));
+
+import { getRegistry } from '@jackwener/opencli/registry';
+import './comments.js';
+import './download.js';
+import './feed.js';
+import './notifications.js';
+import './note.js';
+import './search.js';
+import './user.js';
+
+function createPageMock(evaluateResult) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+        wait: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        getCookies: vi.fn().mockResolvedValue([{ name: 'sid', value: 'secret', domain: 'www.rednote.com' }]),
+    };
+}
+
+describe('rednote note URL identity', () => {
+    const download = getRegistry().get('rednote/download');
+    const comments = getRegistry().get('rednote/comments');
+
+    beforeEach(() => {
+        mockDownloadMedia.mockReset();
+        mockDownloadMedia.mockResolvedValue([{ index: 1, type: 'image', status: 'success', size: '1 KB' }]);
+        mockFormatCookieHeader.mockClear();
+    });
+
+    it('rejects xhslink short links before browser navigation', async () => {
+        const page = createPageMock({ media: [] });
+        await expect(download.func(page, {
+            'note-id': 'https://xhslink.com/o/4MKEjsZnhCz',
+            output: './out',
+        })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: expect.stringContaining('signed URL'),
+            hint: expect.stringContaining('rednote.com'),
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(mockDownloadMedia).not.toHaveBeenCalled();
+    });
+
+    it('rejects signed xiaohongshu URLs before browser navigation', async () => {
+        const page = createPageMock({ media: [] });
+        await expect(comments.func(page, {
+            'note-id': 'https://www.xiaohongshu.com/search_result/69aadbcb000000002202f131?xsec_token=abc',
+            limit: 20,
+        })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: expect.stringContaining('signed URL'),
+            hint: expect.stringContaining('rednote.com'),
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('uses URL-scoped rednote cookies when downloading media', async () => {
+        const page = createPageMock({
+            noteId: '69bc166f000000001a02069a',
+            media: [{ type: 'image', url: 'https://ci.rednote.com/example.jpg' }],
+        });
+        await download.func(page, {
+            'note-id': 'https://www.rednote.com/search_result/69bc166f000000001a02069a?xsec_token=abc',
+            output: './out',
+        });
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://www.rednote.com' });
+        expect(mockDownloadMedia).toHaveBeenCalledWith([{ type: 'image', url: 'https://ci.rednote.com/example.jpg' }], expect.objectContaining({
+            cookies: 'sid=secret',
+            subdir: '69bc166f000000001a02069a',
+        }));
+    });
+
+    it('throws empty-result instead of returning a failed success row when no media exists', async () => {
+        const page = createPageMock({ noteId: '69bc166f000000001a02069a', media: [] });
+        let caught;
+        try {
+            await download.func(page, {
+                'note-id': 'https://www.rednote.com/search_result/69bc166f000000001a02069a?xsec_token=abc',
+                output: './out',
+            });
+        }
+        catch (error) {
+            caught = error;
+        }
+        expect(caught).toMatchObject({ code: 'EMPTY_RESULT' });
+        expect(caught?.hint).toContain('No downloadable media');
+        expect(mockDownloadMedia).not.toHaveBeenCalled();
+    });
+});
+
+describe('rednote argument validation', () => {
+    const comments = getRegistry().get('rednote/comments');
+    const feed = getRegistry().get('rednote/feed');
+    const notifications = getRegistry().get('rednote/notifications');
+    const user = getRegistry().get('rednote/user');
+
+    it.each([
+        ['rednote/comments', comments, { 'note-id': 'https://www.rednote.com/search_result/69aadbcb000000002202f131?xsec_token=abc', limit: 0 }],
+        ['rednote/feed', feed, { limit: 0 }],
+        ['rednote/notifications', notifications, { limit: 0 }],
+        ['rednote/user', user, { id: 'user123', limit: 0 }],
+    ])('%s rejects invalid --limit before browser navigation', async (_name, command, kwargs) => {
+        const page = createPageMock({});
+        await expect(command.func(page, kwargs)).rejects.toMatchObject({ code: 'ARGUMENT' });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('rejects unknown notification types before browser navigation', async () => {
+        const page = createPageMock({});
+        await expect(notifications.func(page, { type: 'all', limit: 20 })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: expect.stringContaining('--type'),
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});
+
+describe('rednote Pinia store failures', () => {
+    it('maps feed store read failure to CommandExecutionError', async () => {
+        const command = getRegistry().get('rednote/feed');
+        const page = createPageMock({ error: 'no_pinia' });
+        await expect(command.func(page, { limit: 20 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('no_pinia'),
+        });
+    });
+
+    it('maps notification action failure to CommandExecutionError', async () => {
+        const command = getRegistry().get('rednote/notifications');
+        const page = createPageMock({ error: 'action_failed', detail: 'blocked' });
+        await expect(command.func(page, { type: 'mentions', limit: 20 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('action_failed'),
+        });
+    });
+
+    it('allows an empty notification list after a successful store read', async () => {
+        const command = getRegistry().get('rednote/notifications');
+        const page = createPageMock({ items: [] });
+        await expect(command.func(page, { type: 'mentions', limit: 20 })).resolves.toEqual([]);
+    });
+});

package/clis/rednote/search.js

@@ -0,0 +1,97 @@
+/**
+ * Rednote search — international mirror of xiaohongshu/search.
+ *
+ * Reuses the DOM-extraction IIFE from `../xiaohongshu/search.js`; only the
+ * web host and the login-gate detection differ. See issue #1136 for the
+ * 1:1 comparison between the two frontends.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError } from '@jackwener/opencli/errors';
+import { buildSearchExtractJs, noteIdToDate } from '../xiaohongshu/search.js';
+
+function parseLimit(raw) {
+    const parsed = Number(raw);
+    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;
+}
+
+/**
+ * Wait for search results or login wall using MutationObserver (max 5s).
+ *
+ * Differs from xiaohongshu by detecting a full-screen login modal instead
+ * of (and as a fallback, alongside) the inline `登录后查看搜索结果` text.
+ * The modal detector filters hidden / zero-area elements to avoid false
+ * positives on background dialogs.
+ */
+const WAIT_FOR_CONTENT_JS = `
+  new Promise((resolve) => {
+    const hasLoginModal = () => {
+      const candidates = document.querySelectorAll(
+        '[class*="login-modal"], [class*="LoginModal"], [class*="login-container"], [class*="LoginContainer"], dialog[role="dialog"]'
+      );
+      for (const el of candidates) {
+        if (!(el instanceof HTMLElement)) continue;
+        const rect = el.getBoundingClientRect();
+        if (rect.width <= 0 || rect.height <= 0) continue;
+        const style = getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden') continue;
+        return true;
+      }
+      return false;
+    };
+    const detect = () => {
+      if (document.querySelector('section.note-item')) return 'content';
+      if (/登录后查看搜索结果|请登录/.test(document.body?.innerText || '')) return 'login_wall';
+      if (hasLoginModal()) return 'login_wall';
+      return null;
+    };
+    const found = detect();
+    if (found) return resolve(found);
+    const observer = new MutationObserver(() => {
+      const result = detect();
+      if (result) { observer.disconnect(); resolve(result); }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    setTimeout(() => { observer.disconnect(); resolve('timeout'); }, 5000);
+  })
+`;
+
+cli({
+    site: 'rednote',
+    name: 'search',
+    access: 'read',
+    description: 'Search rednote notes',
+    domain: 'www.rednote.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', 'author_url'],
+    func: async (page, kwargs) => {
+        const limit = parseLimit(kwargs.limit ?? 20);
+        const keyword = encodeURIComponent(kwargs.query);
+        await page.goto(`https://www.rednote.com/search_result?keyword=${keyword}&source=web_search_result_notes`);
+        const waitResult = await page.evaluate(WAIT_FOR_CONTENT_JS);
+        if (waitResult === 'login_wall') {
+            throw new AuthRequiredError('www.rednote.com', 'Rednote search results are blocked behind a login wall');
+        }
+        await page.autoScroll({ times: 2 });
+        const payload = await page.evaluate(buildSearchExtractJs('www.rednote.com'));
+        const data = Array.isArray(payload) ? payload : [];
+        return data
+            .filter((item) => item.title)
+            .slice(0, limit)
+            .map((item, i) => ({
+            rank: i + 1,
+            ...item,
+            published_at: noteIdToDate(item.url),
+        }));
+    },
+});

package/clis/rednote/user.js

@@ -0,0 +1,55 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { USER_SNAPSHOT_JS } from '../xiaohongshu/user.js';
+import { extractXhsUserNotes, normalizeXhsUserId } from '../xiaohongshu/user-helpers.js';
+
+const WEB_HOST = 'www.rednote.com';
+
+function parseLimit(raw) {
+    const parsed = Number(raw ?? 15);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be a positive integer, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < 1) {
+        throw new ArgumentError(`--limit must be a positive integer, got ${parsed}`);
+    }
+    return parsed;
+}
+
+export const command = cli({
+    site: 'rednote',
+    name: 'user',
+    access: 'read',
+    description: 'Get public notes from a rednote user profile',
+    domain: WEB_HOST,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'id', type: 'str', required: true, positional: true, help: 'User id or profile URL' },
+        { name: 'limit', type: 'int', default: 15, help: 'Number of notes to return' },
+    ],
+    columns: ['id', 'title', 'type', 'likes', 'url'],
+    func: async (page, kwargs) => {
+        const userId = normalizeXhsUserId(String(kwargs.id));
+        const limit = parseLimit(kwargs.limit);
+        await page.goto(`https://${WEB_HOST}/user/profile/${userId}`);
+        let snapshot = await page.evaluate(USER_SNAPSHOT_JS);
+        let results = extractXhsUserNotes(snapshot ?? {}, userId, WEB_HOST);
+        let previousCount = results.length;
+        for (let i = 0; results.length < limit && i < 4; i += 1) {
+            await page.autoScroll({ times: 1, delayMs: 1500 });
+            await page.wait({ time: 1 });
+            snapshot = await page.evaluate(USER_SNAPSHOT_JS);
+            const nextResults = extractXhsUserNotes(snapshot ?? {}, userId, WEB_HOST);
+            if (nextResults.length <= previousCount)
+                break;
+            results = nextResults;
+            previousCount = nextResults.length;
+        }
+        if (results.length === 0) {
+            throw new EmptyResultError('rednote/user', 'No public notes found for this rednote user.');
+        }
+        return results.slice(0, limit);
+    },
+});

package/clis/xiaohongshu/comments.js

@@ -8,34 +8,19 @@
 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(`
+/**
+ * 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) {
+    return `
       (async () => {
         const wait = (ms) => new Promise(r => setTimeout(r, ms))
         const withReplies = ${withReplies}
@@ -115,7 +100,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 +135,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/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;
             }
         }

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');
         }