@jackwener/opencli 1.5.5 → 1.5.7

package/src/clis/xiaohongshu/note.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IPage } from '../../types.js';
+import { getRegistry } from '../../registry.js';
+import { parseNoteId, buildNoteUrl } from './note-helpers.js';
+import './note.js';
+
+function createPageMock(evaluateResult: any): IPage {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(evaluateResult),
+    snapshot: vi.fn().mockResolvedValue(undefined),
+    click: vi.fn().mockResolvedValue(undefined),
+    typeText: vi.fn().mockResolvedValue(undefined),
+    pressKey: vi.fn().mockResolvedValue(undefined),
+    scrollTo: vi.fn().mockResolvedValue(undefined),
+    getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+    wait: vi.fn().mockResolvedValue(undefined),
+    tabs: vi.fn().mockResolvedValue([]),
+    closeTab: vi.fn().mockResolvedValue(undefined),
+    newTab: vi.fn().mockResolvedValue(undefined),
+    selectTab: vi.fn().mockResolvedValue(undefined),
+    networkRequests: vi.fn().mockResolvedValue([]),
+    consoleMessages: vi.fn().mockResolvedValue([]),
+    scroll: vi.fn().mockResolvedValue(undefined),
+    autoScroll: vi.fn().mockResolvedValue(undefined),
+    installInterceptor: vi.fn().mockResolvedValue(undefined),
+    getInterceptedRequests: vi.fn().mockResolvedValue([]),
+    getCookies: vi.fn().mockResolvedValue([]),
+    screenshot: vi.fn().mockResolvedValue(''),
+    waitForCapture: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe('parseNoteId', () => {
+  it('extracts ID from /explore/ URL', () => {
+    expect(parseNoteId('https://www.xiaohongshu.com/explore/69c131c9000000002800be4c')).toBe('69c131c9000000002800be4c');
+  });
+
+  it('extracts ID from /search_result/ URL with query params', () => {
+    expect(parseNoteId('https://www.xiaohongshu.com/search_result/69c131c9000000002800be4c?xsec_token=abc')).toBe('69c131c9000000002800be4c');
+  });
+
+  it('extracts ID from /note/ URL', () => {
+    expect(parseNoteId('https://www.xiaohongshu.com/note/69c131c9000000002800be4c')).toBe('69c131c9000000002800be4c');
+  });
+
+  it('returns raw string when no URL pattern matches', () => {
+    expect(parseNoteId('69c131c9000000002800be4c')).toBe('69c131c9000000002800be4c');
+  });
+
+  it('trims whitespace', () => {
+    expect(parseNoteId('  69c131c9000000002800be4c  ')).toBe('69c131c9000000002800be4c');
+  });
+});
+
+describe('buildNoteUrl', () => {
+  it('returns full URL as-is when given https URL', () => {
+    const url = 'https://www.xiaohongshu.com/search_result/abc123?xsec_token=tok';
+    expect(buildNoteUrl(url)).toBe(url);
+  });
+
+  it('constructs /explore/ URL for bare note ID', () => {
+    expect(buildNoteUrl('abc123')).toBe('https://www.xiaohongshu.com/explore/abc123');
+  });
+});
+
+describe('xiaohongshu note', () => {
+  const command = getRegistry().get('xiaohongshu/note');
+
+  it('is registered', () => {
+    expect(command).toBeDefined();
+    expect(command!.func).toBeTypeOf('function');
+  });
+
+  it('returns note content as field/value rows', async () => {
+    const page = createPageMock({
+      loginWall: false,
+      notFound: false,
+      title: '尚界Z7实车体验',
+      desc: '今天去看了实车，外观很帅',
+      author: '小红薯用户',
+      likes: '257',
+      collects: '98',
+      comments: '45',
+      tags: ['#尚界Z7', '#鸿蒙智行'],
+    });
+
+    const result = (await command!.func!(page, { 'note-id': '69c131c9000000002800be4c' })) as any[];
+
+    expect((page.goto as any).mock.calls[0][0]).toContain('/explore/69c131c9000000002800be4c');
+    expect(result).toEqual([
+      { field: 'title', value: '尚界Z7实车体验' },
+      { field: 'author', value: '小红薯用户' },
+      { field: 'content', value: '今天去看了实车，外观很帅' },
+      { field: 'likes', value: '257' },
+      { field: 'collects', value: '98' },
+      { field: 'comments', value: '45' },
+      { field: 'tags', value: '#尚界Z7, #鸿蒙智行' },
+    ]);
+  });
+
+  it('parses note ID from full /explore/ URL', async () => {
+    const page = createPageMock({
+      loginWall: false, notFound: false,
+      title: 'Test', desc: '', author: '', likes: '0', collects: '0', comments: '0', tags: [],
+    });
+
+    await command!.func!(page, {
+      'note-id': 'https://www.xiaohongshu.com/explore/69c131c9000000002800be4c?xsec_token=abc',
+    });
+
+    expect((page.goto as any).mock.calls[0][0]).toContain('/explore/69c131c9000000002800be4c');
+  });
+
+  it('preserves full search_result URL with xsec_token for navigation', async () => {
+    const page = createPageMock({
+      loginWall: false, notFound: false,
+      title: 'Test', desc: '', author: '', likes: '0', collects: '0', comments: '0', tags: [],
+    });
+
+    const fullUrl = 'https://www.xiaohongshu.com/search_result/69c131c9000000002800be4c?xsec_token=abc';
+    await command!.func!(page, { 'note-id': fullUrl });
+
+    // Should navigate to the full URL as-is, not strip the token
+    expect((page.goto as any).mock.calls[0][0]).toBe(fullUrl);
+  });
+
+  it('throws AuthRequiredError on login wall', async () => {
+    const page = createPageMock({ loginWall: true, notFound: false });
+
+    await expect(command!.func!(page, { 'note-id': 'abc123' })).rejects.toThrow('Note content requires login');
+  });
+
+  it('throws EmptyResultError when note is not found', async () => {
+    const page = createPageMock({ loginWall: false, notFound: true });
+
+    await expect(command!.func!(page, { 'note-id': 'abc123' })).rejects.toThrow('returned no data');
+  });
+
+  it('normalizes placeholder text to 0 for zero-count metrics', async () => {
+    const page = createPageMock({
+      loginWall: false, notFound: false,
+      title: 'New note', desc: 'Just posted', author: 'Author',
+      likes: '赞', collects: '收藏', comments: '评论', tags: [],
+    });
+
+    const result = (await command!.func!(page, { 'note-id': 'abc123' })) as any[];
+    expect(result.find((r: any) => r.field === 'likes')!.value).toBe('0');
+    expect(result.find((r: any) => r.field === 'collects')!.value).toBe('0');
+    expect(result.find((r: any) => r.field === 'comments')!.value).toBe('0');
+  });
+
+  it('omits tags row when no tags present', async () => {
+    const page = createPageMock({
+      loginWall: false, notFound: false,
+      title: 'No tags', desc: 'Content', author: 'Author',
+      likes: '1', collects: '2', comments: '3', tags: [],
+    });
+
+    const result = (await command!.func!(page, { 'note-id': 'abc123' })) as any[];
+    expect(result.find((r: any) => r.field === 'tags')).toBeUndefined();
+    expect(result).toHaveLength(6);
+  });
+});

package/src/clis/xiaohongshu/note.ts

@@ -0,0 +1,86 @@
+/**
+ * Xiaohongshu note — read full note content from a public note page.
+ *
+ * Extracts title, author, description text, and engagement metrics
+ * (likes, collects, comment count) via DOM extraction.
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError, EmptyResultError } from '../../errors.js';
+import { parseNoteId, buildNoteUrl } from './note-helpers.js';
+
+cli({
+  site: 'xiaohongshu',
+  name: 'note',
+  description: '获取小红书笔记正文和互动数据',
+  domain: 'www.xiaohongshu.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'note-id', required: true, positional: true, help: 'Note ID or full URL (preserves xsec_token for access)' },
+  ],
+  columns: ['field', 'value'],
+  func: async (page, kwargs) => {
+    const raw = String(kwargs['note-id']);
+    const noteId = parseNoteId(raw);
+    const url = buildNoteUrl(raw);
+
+    await page.goto(url);
+    await page.wait(3);
+
+    const data = await page.evaluate(`
+      (() => {
+        const loginWall = /登录后查看|请登录/.test(document.body.innerText || '')
+        const notFound = /页面不见了|笔记不存在|无法浏览/.test(document.body.innerText || '')
+
+        const clean = (el) => (el?.textContent || '').replace(/\\s+/g, ' ').trim()
+
+        const title = clean(document.querySelector('#detail-title, .title'))
+        const desc = clean(document.querySelector('#detail-desc, .desc, .note-text'))
+        const author = clean(document.querySelector('.username, .author-wrapper .name'))
+        const likes = clean(document.querySelector('.like-wrapper .count'))
+        const collects = clean(document.querySelector('.collect-wrapper .count'))
+        const comments = clean(document.querySelector('.chat-wrapper .count'))
+
+        // Try to extract tags/topics
+        const tags = []
+        document.querySelectorAll('#detail-desc a.tag, #detail-desc a[href*="search_result"]').forEach(el => {
+          const t = (el.textContent || '').trim()
+          if (t) tags.push(t)
+        })
+
+        return { loginWall, notFound, title, desc, author, likes, collects, comments, tags }
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') {
+      throw new EmptyResultError('xiaohongshu/note', 'Unexpected evaluate response');
+    }
+
+    if ((data as any).loginWall) {
+      throw new AuthRequiredError('www.xiaohongshu.com', 'Note content requires login');
+    }
+
+    if ((data as any).notFound) {
+      throw new EmptyResultError('xiaohongshu/note', `Note ${noteId} not found or unavailable — it may have been deleted or restricted`);
+    }
+
+    const d = data as any;
+    // XHS renders placeholder text like "赞"/"收藏"/"评论" when count is 0;
+    // normalize to '0' unless the value looks numeric.
+    const numOrZero = (v: string) => /^\d+/.test(v) ? v : '0';
+    const rows = [
+      { field: 'title', value: d.title || '' },
+      { field: 'author', value: d.author || '' },
+      { field: 'content', value: d.desc || '' },
+      { field: 'likes', value: numOrZero(d.likes || '') },
+      { field: 'collects', value: numOrZero(d.collects || '') },
+      { field: 'comments', value: numOrZero(d.comments || '') },
+    ];
+
+    if (d.tags?.length) {
+      rows.push({ field: 'tags', value: d.tags.join(', ') });
+    }
+
+    return rows;
+  },
+});

package/src/clis/xiaohongshu/publish.test.ts

@@ -8,7 +8,7 @@ import { getRegistry } from '../../registry.js';
 import type { IPage } from '../../types.js';
 import './publish.js';
 
-function createPageMock(evaluateResults: any[]): IPage {
+function createPageMock(evaluateResults: any[], overrides: Partial<IPage> = {}): IPage {
   const evaluate = vi.fn();
   for (const result of evaluateResults) {
     evaluate.mockResolvedValueOnce(result);
@@ -37,10 +37,88 @@ function createPageMock(evaluateResults: any[]): IPage {
     getCookies: vi.fn().mockResolvedValue([]),
     screenshot: vi.fn().mockResolvedValue(''),
     waitForCapture: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
   };
 }
 
 describe('xiaohongshu publish', () => {
+  it('prefers CDP setFileInput upload when the page supports it', async () => {
+    const cmd = getRegistry().get('xiaohongshu/publish');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-xhs-publish-'));
+    const imagePath = path.join(tempDir, 'demo.jpg');
+    fs.writeFileSync(imagePath, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+
+    const setFileInput = vi.fn().mockResolvedValue(undefined);
+    const page = createPageMock([
+      'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+      { ok: true, target: '上传图文', text: '上传图文' },
+      { state: 'editor_ready', hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+      'input[type="file"][accept*="image"],input[type="file"][accept*=".jpg"],input[type="file"][accept*=".jpeg"],input[type="file"][accept*=".png"],input[type="file"][accept*=".gif"],input[type="file"][accept*=".webp"]',
+      false,
+      true,
+      { ok: true, sel: 'input[maxlength="20"]' },
+      { ok: true, sel: '[contenteditable="true"][class*="content"]' },
+      true,
+      'https://creator.xiaohongshu.com/publish/success',
+      '发布成功',
+    ], {
+      setFileInput,
+    });
+
+    const result = await cmd!.func!(page, {
+      title: 'CDP上传优先',
+      content: '优先走 setFileInput 主路径',
+      images: imagePath,
+      topics: '',
+      draft: false,
+    });
+
+    expect(setFileInput).toHaveBeenCalledWith(
+      [imagePath],
+      expect.stringContaining('input[type="file"][accept*="image"]'),
+    );
+    const evaluateCalls = (page.evaluate as any).mock.calls.map((args: any[]) => String(args[0]));
+    expect(evaluateCalls.some((code: string) => code.includes('atob(img.base64)'))).toBe(false);
+    expect(result).toEqual([
+      {
+        status: '✅ 发布成功',
+        detail: '"CDP上传优先" · 1张图片 · 发布成功',
+      },
+    ]);
+  });
+
+  it('fails fast when only a generic file input exists on the page', async () => {
+    const cmd = getRegistry().get('xiaohongshu/publish');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-xhs-publish-'));
+    const imagePath = path.join(tempDir, 'demo.jpg');
+    fs.writeFileSync(imagePath, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+
+    const setFileInput = vi.fn().mockResolvedValue(undefined);
+    const page = createPageMock([
+      'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+      { ok: true, target: '上传图文', text: '上传图文' },
+      { state: 'editor_ready', hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+      null,
+    ], {
+      setFileInput,
+    });
+
+    await expect(cmd!.func!(page, {
+      title: '不要走泛化上传',
+      content: 'generic file input 应该直接报错',
+      images: imagePath,
+      topics: '',
+      draft: false,
+    })).rejects.toThrow('Image injection failed: No file input found on page');
+
+    expect(setFileInput).not.toHaveBeenCalled();
+    expect(page.screenshot).toHaveBeenCalledWith({ path: '/tmp/xhs_publish_upload_debug.png' });
+  });
+
   it('selects the image-text tab and publishes successfully', async () => {
     const cmd = getRegistry().get('xiaohongshu/publish');
     expect(cmd?.func).toBeTypeOf('function');

package/src/clis/xiaohongshu/publish.ts

@@ -3,7 +3,7 @@
  *
  * Flow:
  *   1. Navigate to creator publish page
- *   2. Upload images via DataTransfer injection into the file input
+ *   2. Upload images via CDP DOM.setFileInputFiles (with base64 fallback)
  *   3. Fill title and body text
  *   4. Add topic hashtags
  *   5. Publish (or save as draft)
@@ -43,44 +43,98 @@ const TITLE_SELECTORS = [
   'input[maxlength]',
 ];
 
-type ImagePayload = { name: string; mimeType: string; base64: string };
+const SUPPORTED_EXTENSIONS: Record<string, string> = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+};
 
 /**
- * Read a local image and return the name, MIME type, and base64 content.
- * Throws if the file does not exist or the extension is unsupported.
+ * Validate image paths: check existence and extension.
+ * Returns resolved absolute paths.
  */
-function readImageFile(filePath: string): ImagePayload {
-  const absPath = path.resolve(filePath);
-  if (!fs.existsSync(absPath)) throw new Error(`Image file not found: ${absPath}`);
-  const ext = path.extname(absPath).toLowerCase();
-  const mimeMap: Record<string, string> = {
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.png': 'image/png',
-    '.gif': 'image/gif',
-    '.webp': 'image/webp',
-  };
-  const mimeType = mimeMap[ext];
-  if (!mimeType) throw new Error(`Unsupported image format "${ext}". Supported: jpg, png, gif, webp`);
-  const base64 = fs.readFileSync(absPath).toString('base64');
-  return { name: path.basename(absPath), mimeType, base64 };
+function validateImagePaths(filePaths: string[]): string[] {
+  return filePaths.map((filePath) => {
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath)) throw new Error(`Image file not found: ${absPath}`);
+    const ext = path.extname(absPath).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS[ext]) {
+      throw new Error(`Unsupported image format "${ext}". Supported: jpg, png, gif, webp`);
+    }
+    return absPath;
+  });
 }
 
+/** CSS selector for image-accepting file inputs. */
+const IMAGE_INPUT_SELECTOR = 'input[type="file"][accept*="image"],'
+  + 'input[type="file"][accept*=".jpg"],'
+  + 'input[type="file"][accept*=".jpeg"],'
+  + 'input[type="file"][accept*=".png"],'
+  + 'input[type="file"][accept*=".gif"],'
+  + 'input[type="file"][accept*=".webp"]';
+
 /**
- * Inject images into the page's file input using DataTransfer.
- * Converts base64 payloads to File objects in the browser context, then dispatches
- * a synthetic 'change' event on the input element.
+ * Upload images via CDP DOM.setFileInputFiles — Chrome reads files directly
+ * from the local filesystem, avoiding base64 payload size limits.
  *
- * Returns { ok, count, error }.
+ * Falls back to the legacy base64 DataTransfer approach if the extension
+ * does not support set-file-input (e.g. older extension version).
  */
-async function injectImages(page: IPage, images: ImagePayload[]): Promise<{ ok: boolean; count: number; error?: string }> {
+async function uploadImages(
+  page: IPage,
+  absPaths: string[],
+): Promise<{ ok: boolean; count: number; error?: string }> {
+  // ── Primary: CDP DOM.setFileInputFiles ──────────────────────────────
+  if (page.setFileInput) {
+    try {
+      // Find image-accepting file input on the page
+      const selector: string | null = await page.evaluate(`
+        (() => {
+          const sels = ${JSON.stringify(IMAGE_INPUT_SELECTOR)};
+          const el = document.querySelector(sels);
+          return el ? sels : null;
+        })()
+      `);
+      if (!selector) {
+        return { ok: false, count: 0, error: 'No file input found on page' };
+      }
+      await page.setFileInput(absPaths, selector);
+      return { ok: true, count: absPaths.length };
+    } catch (err) {
+      // If set-file-input action is not supported by extension, fall through to legacy
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes('Unknown action') || msg.includes('not supported')) {
+        // Extension too old — fall through to legacy base64 method
+      } else {
+        return { ok: false, count: 0, error: msg };
+      }
+    }
+  }
+
+  // ── Fallback: legacy base64 DataTransfer injection ─────────────────
+  const images = absPaths.map((absPath) => {
+    const base64 = fs.readFileSync(absPath).toString('base64');
+    const ext = path.extname(absPath).toLowerCase();
+    return { name: path.basename(absPath), mimeType: SUPPORTED_EXTENSIONS[ext], base64 };
+  });
+
+  // Warn if total payload is large — this may fail with older extensions
+  const totalBytes = images.reduce((sum, img) => sum + img.base64.length, 0);
+  if (totalBytes > 500_000) {
+    console.warn(
+      `[warn] Total image payload is ${(totalBytes / 1024 / 1024).toFixed(1)}MB (base64). ` +
+      'This may fail with the browser bridge. Update the extension to v1.6+ for CDP-based upload, ' +
+      'or compress images before publishing.'
+    );
+  }
+
   const payload = JSON.stringify(images);
   return page.evaluate(`
     (async () => {
       const images = ${payload};
 
-      // Only use image-capable file inputs. Do not fall back to a generic uploader,
-      // otherwise we can accidentally feed images into the video upload flow.
       const inputs = Array.from(document.querySelectorAll('input[type="file"]'));
       const input = inputs.find(el => {
         const accept = el.getAttribute('accept') || '';
@@ -346,8 +400,8 @@ cli({
     if (imagePaths.length > MAX_IMAGES)
       throw new Error(`Too many images: ${imagePaths.length} (max ${MAX_IMAGES})`);
 
-    // Read images in Node.js context before navigating (fast-fail on bad paths)
-    const imageData: ImagePayload[] = imagePaths.map(readImageFile);
+    // Validate image paths before navigating (fast-fail on bad paths / unsupported formats)
+    const absImagePaths = validateImagePaths(imagePaths);
 
     // ── Step 1: Navigate to publish page ──────────────────────────────────────
     await page.goto(PUBLISH_URL);
@@ -377,7 +431,7 @@ cli({
     }
 
     // ── Step 3: Upload images ──────────────────────────────────────────────────
-    const upload = await injectImages(page, imageData);
+    const upload = await uploadImages(page, absImagePaths);
     if (!upload.ok) {
       await page.screenshot({ path: '/tmp/xhs_publish_upload_debug.png' });
       throw new Error(
@@ -532,7 +586,7 @@ cli({
         status: isSuccess ? `✅ ${verb}` : '⚠️ 操作完成，请在浏览器中确认',
         detail: [
           `"${title}"`,
-          `${imageData.length}张图片`,
+          `${absImagePaths.length}张图片`,
           topics.length ? `话题: ${topics.join(' ')}` : '',
           successMsg || finalUrl || '',
         ]

package/src/clis/xiaohongshu/search.test.ts

@@ -41,15 +41,16 @@ describe('xiaohongshu search', () => {
     expect(cmd?.func).toBeTypeOf('function');
 
     const page = createPageMock([
-      {
-        loginWall: true,
-        results: [],
-      },
+      // First evaluate: early login-wall check (returns true)
+      true,
     ]);
 
     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
+    expect(page.autoScroll).not.toHaveBeenCalled();
   });
 
   it('returns ranked results with search_result url and author_url preserved', async () => {
@@ -62,6 +63,9 @@ describe('xiaohongshu search', () => {
       'https://www.xiaohongshu.com/user/profile/635a9c720000000018028b40?xsec_token=user-token&xsec_source=pc_search';
 
     const page = createPageMock([
+      // First evaluate: early login-wall check (returns false → no wall)
+      false,
+      // Second evaluate: main DOM extraction
       {
         loginWall: false,
         results: [
@@ -99,6 +103,9 @@ describe('xiaohongshu search', () => {
     expect(cmd?.func).toBeTypeOf('function');
 
     const page = createPageMock([
+      // First evaluate: early login-wall check (returns false → no wall)
+      false,
+      // Second evaluate: main DOM extraction
       {
         loginWall: false,
         results: [

package/src/clis/xiaohongshu/search.ts

@@ -44,6 +44,19 @@ cli({
     );
     await page.wait(3);
 
+    // Early login-wall detection: XHS may show a login gate instead of
+    // results. Check *before* autoScroll to avoid crashing on a page
+    // that has no meaningful content to scroll through.
+    const loginCheck = await page.evaluate(`
+      (() => /登录后查看搜索结果/.test(document.body?.innerText || ''))()
+    `);
+    if (loginCheck) {
+      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 });
 

package/src/clis/xiaohongshu/user-helpers.test.ts

@@ -75,6 +75,7 @@ describe('extractXhsUserNotes', () => {
         title: 'First note',
         type: 'video',
         likes: '4.6万',
+        cover: '',
         url: 'https://www.xiaohongshu.com/user/profile/user-1/note-1?xsec_token=abc&xsec_source=pc_user',
       },
       {
@@ -82,11 +83,33 @@ describe('extractXhsUserNotes', () => {
         title: 'Second note',
         type: 'normal',
         likes: '42',
+        cover: '',
         url: 'https://www.xiaohongshu.com/user/profile/fallback-user/note-2',
       },
     ]);
   });
 
+  it('extracts cover urls with fallback priority urlDefault -> urlPre -> url', () => {
+    const rows = extractXhsUserNotes(
+      {
+        noteGroups: [
+          [
+            { noteCard: { noteId: 'cover-1', cover: { urlDefault: 'https://img.example/default.jpg', urlPre: 'https://img.example/pre.jpg', url: 'https://img.example/raw.jpg' } } },
+            { noteCard: { noteId: 'cover-2', cover: { urlPre: 'https://img.example/pre-only.jpg', url: 'https://img.example/raw-only.jpg' } } },
+            { noteCard: { noteId: 'cover-3', cover: { url: 'https://img.example/raw-fallback.jpg' } } },
+          ],
+        ],
+      },
+      'fallback-user'
+    );
+
+    expect(rows.map(row => row.cover)).toEqual([
+      'https://img.example/default.jpg',
+      'https://img.example/pre-only.jpg',
+      'https://img.example/raw-fallback.jpg',
+    ]);
+  });
+
   it('deduplicates repeated notes by note id', () => {
     const rows = extractXhsUserNotes(
       {

package/src/clis/xiaohongshu/user-helpers.ts

@@ -8,6 +8,7 @@ export interface XhsUserNoteRow {
   title: string;
   type: string;
   likes: string;
+  cover: string;
   url: string;
 }
 
@@ -72,11 +73,14 @@ export function extractXhsUserNotes(snapshot: XhsUserPageSnapshot, fallbackUserI
     const xsecToken = toCleanString(entry?.xsecToken ?? entry?.xsec_token ?? noteCard.xsecToken ?? noteCard.xsec_token);
     const likes = toCleanString(noteCard.interactInfo?.likedCount ?? noteCard.interact_info?.liked_count ?? 0) || '0';
 
+    const cover = toCleanString(noteCard.cover?.urlDefault ?? noteCard.cover?.urlPre ?? noteCard.cover?.url ?? '');
+
     rows.push({
       id: noteId,
       title: toCleanString(noteCard.displayTitle ?? noteCard.display_title ?? noteCard.title),
       type: toCleanString(noteCard.type),
       likes,
+      cover,
       url: buildXhsNoteUrl(userId || fallbackUserId, noteId, xsecToken),
     });
   }