@jackwener/opencli 1.7.22 → 1.8.1

package/clis/xiaohongshu/delete-note.js

@@ -0,0 +1,260 @@
+/**
+ * Xiaohongshu delete-note: remove a published note via creator center UI.
+ *
+ * Flow:
+ *   1. Navigate to creator note-manager
+ *   2. Switch to "已发布" tab (delete is only available on published notes;
+ *      "审核中" and "未通过" rows do not expose a web delete entry, only mobile)
+ *   3. Locate the row whose `data-impression` JSON contains the target noteId
+ *   4. Click the inline `<span class="control data-del">` action
+ *   5. Click "确定" in the `.d-modal-footer` confirmation modal
+ *   6. Poll for the row disappearing from the list
+ *
+ * Requires: logged into creator.xiaohongshu.com in Chrome.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CliError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+const NOTE_MANAGER_URL = 'https://creator.xiaohongshu.com/new/note-manager';
+const ROW_SETTLE_MS = 3000;
+const MODAL_SETTLE_MS = 2000;
+const VERIFY_TIMEOUT_MS = 10_000;
+const VERIFY_POLL_MS = 1000;
+const NOTE_ID_RE = /^[0-9a-f]{24}$/i;
+function unwrapEvaluateResult(payload) {
+    if (payload && typeof payload === 'object' && 'session' in payload && 'data' in payload) {
+        return payload.data;
+    }
+    return payload;
+}
+function requireEvaluateString(payload, context) {
+    if (typeof payload !== 'string') {
+        throw new CommandExecutionError(`xiaohongshu/delete-note: malformed ${context} payload`);
+    }
+    return payload;
+}
+function requireEvaluateBoolean(payload, context) {
+    if (typeof payload !== 'boolean') {
+        throw new CommandExecutionError(`xiaohongshu/delete-note: malformed ${context} payload`);
+    }
+    return payload;
+}
+function requireEvaluateObject(payload, context) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new CommandExecutionError(`xiaohongshu/delete-note: malformed ${context} payload`);
+    }
+    return payload;
+}
+function requireActionResult(payload, context) {
+    const result = requireEvaluateObject(payload, context);
+    if (typeof result.ok !== 'boolean') {
+        throw new CommandExecutionError(`xiaohongshu/delete-note: malformed ${context} payload`);
+    }
+    return result;
+}
+function isXiaohongshuHost(hostname) {
+    const host = String(hostname || '').toLowerCase();
+    return host === 'xiaohongshu.com' || host.endsWith('.xiaohongshu.com');
+}
+function isSupportedQueryNoteUrl(url) {
+    return url.hostname.toLowerCase() === 'creator.xiaohongshu.com'
+        && url.pathname.replace(/\/+$/, '') === '/statistics/note-detail';
+}
+function normalizeNoteId(input) {
+    const raw = String(input ?? '').trim();
+    if (!raw) {
+        throw new ArgumentError('xiaohongshu/delete-note: note-id cannot be empty');
+    }
+    if (NOTE_ID_RE.test(raw))
+        return raw.toLowerCase();
+    if (!/^https:\/\//i.test(raw)) {
+        throw new ArgumentError('xiaohongshu/delete-note: note-id must be a 24-character Xiaohongshu note ID or an exact Xiaohongshu note URL');
+    }
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new ArgumentError('xiaohongshu/delete-note: invalid note URL');
+    }
+    if (url.protocol !== 'https:' || url.username || url.password || url.port || !isXiaohongshuHost(url.hostname)) {
+        throw new ArgumentError('xiaohongshu/delete-note: note URL must be an exact https://*.xiaohongshu.com URL');
+    }
+    const queryId = url.searchParams.get('noteId') || url.searchParams.get('note_id');
+    if (queryId && NOTE_ID_RE.test(queryId) && isSupportedQueryNoteUrl(url))
+        return queryId.toLowerCase();
+    const pathMatch = url.pathname.match(/^\/(?:explore|note|search_result|discovery\/item)\/([0-9a-f]{24})\/?$/i)
+        || url.pathname.match(/^\/user\/profile\/[^/?#]+\/([0-9a-f]{24})\/?$/i);
+    if (pathMatch)
+        return pathMatch[1].toLowerCase();
+    throw new ArgumentError('xiaohongshu/delete-note: note URL must contain a 24-character note ID');
+}
+function buildLocateAndMaybeDeleteScript(noteId, shouldClick) {
+    return `
+      (cfg => {
+        const { targetId, shouldClick } = cfg;
+        const isVisible = (el) => !!el && el.offsetParent !== null;
+        const matchesNoteId = (impressionRaw) => {
+          if (!impressionRaw) return false;
+          try {
+            const parsed = JSON.parse(impressionRaw);
+            const id = parsed && parsed.noteTarget && parsed.noteTarget.value && parsed.noteTarget.value.noteId;
+            return typeof id === 'string' && id === targetId;
+          } catch {
+            return false;
+          }
+        };
+        const notes = Array.from(document.querySelectorAll('.note')).filter(isVisible);
+        for (const note of notes) {
+          if (matchesNoteId(note.getAttribute('data-impression'))) {
+            const del = note.querySelector('span.control.data-del');
+            if (!del || !isVisible(del)) {
+              return { ok: false, kind: 'no_delete_action', visibleRows: notes.length };
+            }
+            if (!shouldClick) {
+              return { ok: true, clicked: false };
+            }
+            del.click();
+            return { ok: true, clicked: true };
+          }
+        }
+        return { ok: false, kind: 'not_found', visibleRows: notes.length };
+      })(${JSON.stringify({ targetId: noteId, shouldClick })})
+    `;
+}
+function buildVerifyGoneScript(noteId) {
+    return `
+        (targetId => {
+          const matchesNoteId = (impressionRaw) => {
+            if (!impressionRaw) return false;
+            try {
+              const parsed = JSON.parse(impressionRaw);
+              const id = parsed && parsed.noteTarget && parsed.noteTarget.value && parsed.noteTarget.value.noteId;
+              return typeof id === 'string' && id === targetId;
+            } catch {
+              return false;
+            }
+          };
+          const notes = Array.from(document.querySelectorAll('.note'));
+          return notes.some((n) => matchesNoteId(n.getAttribute('data-impression')));
+        })(${JSON.stringify(noteId)})
+      `;
+}
+cli({
+    site: 'xiaohongshu',
+    name: 'delete-note',
+    access: 'write',
+    description: '删除小红书已发布笔记 (creator center UI automation)',
+    domain: 'creator.xiaohongshu.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    browser: true,
+    args: [
+        {
+            name: 'note-id',
+            required: true,
+            positional: true,
+            help: 'Note ID (e.g. 6a08ba0b000000000702a893 from xiaohongshu creator-notes / URL)',
+        },
+        {
+            name: 'execute',
+            type: 'boolean',
+            default: false,
+            help: 'Actually click delete + confirm. Default is dry-run target verification only.',
+        },
+    ],
+    columns: ['status', 'note_id', 'message'],
+    func: async (page, kwargs) => {
+        try {
+            const noteId = normalizeNoteId(kwargs['note-id']);
+            const execute = kwargs.execute === true;
+            await page.goto(NOTE_MANAGER_URL);
+            await page.wait({ time: ROW_SETTLE_MS / 1000 });
+            // Detect login redirect (creator.xiaohongshu.com bounces to /login on auth failure)
+            const currentUrl = requireEvaluateString(unwrapEvaluateResult(await page.evaluate('() => location.href')), 'current-url');
+            if (typeof currentUrl === 'string' && /\/login(?:[/?#]|$)/i.test(new URL(currentUrl).pathname + new URL(currentUrl).search)) {
+                throw new AuthRequiredError('creator.xiaohongshu.com');
+            }
+            // Step 1: ensure 已发布 tab is active (delete only exposed there).
+            const tabClicked = requireEvaluateBoolean(unwrapEvaluateResult(await page.evaluate(`
+      () => {
+        const isVisible = (el) => !!el && el.offsetParent !== null;
+        for (const el of document.querySelectorAll('a, button, [role="tab"], div')) {
+          const text = (el.innerText || el.textContent || '').trim();
+          if (text === '已发布' && isVisible(el)) {
+            el.click();
+            return true;
+          }
+        }
+        return false;
+      }
+    `)), 'published-tab');
+            if (!tabClicked) {
+                throw new CommandExecutionError('xiaohongshu/delete-note: 已发布 tab not found on note-manager; xhs creator UI may have changed.');
+            }
+            await page.wait({ time: ROW_SETTLE_MS / 1000 });
+            // Step 2: locate the .note row whose data-impression JSON carries the
+            // exact `noteId` field. Dry-run stops here; execute clicks delete.
+            // Substring matching on the raw attribute would risk matching unrelated
+            // fields whose values happen to share the noteId prefix, so parse the JSON
+            // and compare `noteTarget.value.noteId` explicitly.
+            const initResult = requireActionResult(unwrapEvaluateResult(await page.evaluate(buildLocateAndMaybeDeleteScript(noteId, execute))), 'locate-note');
+            if (!initResult?.ok) {
+                if (initResult?.kind === 'not_found') {
+                    throw new EmptyResultError('xiaohongshu/delete-note', `Note ${noteId} not visible in the 已发布 tab. Verify the note belongs to the logged-in account and has cleared review (审核中 / 未通过 rows have no web delete entry).`);
+                }
+                if (initResult?.kind === 'no_delete_action') {
+                    throw new CommandExecutionError(`xiaohongshu/delete-note: note ${noteId} row found but no delete action visible; xhs creator UI may have changed.`);
+                }
+                throw new CommandExecutionError('xiaohongshu/delete-note: failed to locate note row');
+            }
+            if (!execute) {
+                return [{ status: 'dry-run', note_id: noteId, message: 'Target note row and delete action verified. Re-run with --execute to delete.' }];
+            }
+            await page.wait({ time: MODAL_SETTLE_MS / 1000 });
+            // Step 3: click "确定" in the `.d-modal-footer` confirmation modal.
+            const confirmResult = requireActionResult(unwrapEvaluateResult(await page.evaluate(`
+      () => {
+        const isVisible = (el) => !!el && el.offsetParent !== null;
+        const footer = Array.from(document.querySelectorAll('.d-modal-footer')).find(isVisible);
+        if (!footer) return { ok: false, kind: 'no_modal' };
+        const buttons = Array.from(footer.querySelectorAll('button, [role="button"]')).filter(isVisible);
+        const confirmBtn = buttons.find((b) => (b.innerText || b.textContent || '').trim() === '确定');
+        if (!confirmBtn) return { ok: false, kind: 'no_confirm', labels: buttons.map(b => (b.innerText || '').trim()) };
+        confirmBtn.click();
+        return { ok: true };
+      }
+    `)), 'confirm-modal');
+            if (!confirmResult?.ok) {
+                throw new CommandExecutionError(`xiaohongshu/delete-note: confirmation modal step failed (${confirmResult?.kind ?? 'unknown'})`);
+            }
+            // Step 4: poll for row removal (proves the delete actually committed,
+            // not just the modal was clicked). Iteration-bounded rather than
+            // wall-clock so tests with a mocked `page.wait` exhaust the loop
+            // quickly instead of stalling on real time.
+            const VERIFY_ITERATIONS = Math.ceil(VERIFY_TIMEOUT_MS / VERIFY_POLL_MS);
+            let stillPresent = true;
+            for (let i = 0; i < VERIFY_ITERATIONS; i++) {
+                await page.wait({ time: VERIFY_POLL_MS / 1000 });
+                const probe = requireEvaluateBoolean(unwrapEvaluateResult(await page.evaluate(buildVerifyGoneScript(noteId))), 'verify-gone');
+                if (probe === false) {
+                    stillPresent = false;
+                    break;
+                }
+            }
+            if (stillPresent) {
+                throw new CommandExecutionError(`xiaohongshu/delete-note: note ${noteId} still visible after confirm click; deletion may not have committed.`);
+            }
+            return [{ status: 'deleted', note_id: noteId, message: 'Delete confirmed and note row disappeared.' }];
+        }
+        catch (err) {
+            if (err instanceof CliError)
+                throw err;
+            throw new CommandExecutionError(`xiaohongshu/delete-note failed: ${err?.message ?? String(err)}`);
+        }
+    },
+});
+export const __test__ = {
+    normalizeNoteId,
+    buildLocateAndMaybeDeleteScript,
+    buildVerifyGoneScript,
+};

package/clis/xiaohongshu/delete-note.test.js

@@ -0,0 +1,172 @@
+import { describe, expect, it, vi } from 'vitest';
+import { JSDOM } from 'jsdom';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+import { __test__ } from './delete-note.js';
+
+function makePage(evaluateResults = []) {
+  const evaluate = vi.fn();
+  for (const r of evaluateResults) evaluate.mockResolvedValueOnce(r);
+  evaluate.mockResolvedValue(undefined);
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate,
+  };
+}
+
+describe('xiaohongshu delete-note command', () => {
+  const getCommand = () => getRegistry().get('xiaohongshu/delete-note');
+  const validId = '6a08ba0b000000000702a893';
+
+  it('returns deleted status when delete + confirm + verify all succeed', async () => {
+    const page = makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',  // currentUrl
+      true,                                                 // 已发布 tab click
+      { ok: true, clicked: true },                          // initResult: row found + delete clicked
+      { ok: true },                                         // confirmResult
+      false,                                                // verify probe: row gone
+    ]);
+    const result = await getCommand().func(page, { 'note-id': validId, execute: true });
+    expect(result).toEqual([
+      { status: 'deleted', note_id: validId, message: 'Delete confirmed and note row disappeared.' },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith('https://creator.xiaohongshu.com/new/note-manager');
+  });
+
+  it('dry-runs by default after verifying the exact target and delete affordance', async () => {
+    const page = makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',
+      true,
+      { ok: true, clicked: false },
+    ]);
+    const result = await getCommand().func(page, { 'note-id': validId });
+    expect(result).toEqual([
+      { status: 'dry-run', note_id: validId, message: 'Target note row and delete action verified. Re-run with --execute to delete.' },
+    ]);
+    expect(page.evaluate).toHaveBeenCalledTimes(3);
+  });
+
+  it('unwraps browser bridge envelopes at every evaluate boundary', async () => {
+    const page = makePage([
+      { session: 's', data: 'https://creator.xiaohongshu.com/new/note-manager' },
+      { session: 's', data: true },
+      { session: 's', data: { ok: true, clicked: true } },
+      { session: 's', data: { ok: true } },
+      { session: 's', data: false },
+    ]);
+    const result = await getCommand().func(page, { 'note-id': validId, execute: true });
+    expect(result[0]).toMatchObject({ status: 'deleted', note_id: validId });
+  });
+
+  it('normalizes exact Xiaohongshu note IDs from supported URL forms', () => {
+    expect(__test__.normalizeNoteId(validId.toUpperCase())).toBe(validId);
+    expect(__test__.normalizeNoteId(`https://www.xiaohongshu.com/explore/${validId}?xsec_token=t`)).toBe(validId);
+    expect(__test__.normalizeNoteId(`https://creator.xiaohongshu.com/statistics/note-detail?noteId=${validId}`)).toBe(validId);
+  });
+
+  it('throws ArgumentError for missing or ambiguous note identity before navigation', async () => {
+    const page = makePage();
+    await expect(getCommand().func(page, { 'note-id': '' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { 'note-id': '   ' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { 'note-id': 'x' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { 'note-id': 'https://evil.com/explore/6a08ba0b000000000702a893' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { 'note-id': 'https://xhslink.com/abc' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(getCommand().func(page, { 'note-id': `https://www.xiaohongshu.com/anything?noteId=${validId}` })).rejects.toBeInstanceOf(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('throws CommandExecutionError for malformed evaluate payloads instead of trusting truthy objects', async () => {
+    await expect(getCommand().func(makePage([
+      { session: 's', data: { href: 'https://creator.xiaohongshu.com/new/note-manager' } },
+    ]), { 'note-id': validId })).rejects.toThrowError(/malformed current-url payload/);
+
+    await expect(getCommand().func(makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',
+      { session: 's', data: { ok: true } },
+    ]), { 'note-id': validId })).rejects.toThrowError(/malformed published-tab payload/);
+
+    await expect(getCommand().func(makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',
+      true,
+      { session: 's', data: { ok: 'yes', clicked: false } },
+    ]), { 'note-id': validId })).rejects.toThrowError(/malformed locate-note payload/);
+  });
+
+  it('throws AuthRequiredError when redirected to login', async () => {
+    const page = makePage([
+      'https://creator.xiaohongshu.com/login?redirectReason=401',
+    ]);
+    await expect(getCommand().func(page, { 'note-id': validId })).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('throws CommandExecutionError when 已发布 tab cannot be clicked (UI drift)', async () => {
+    const page = makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',
+      false, // tab click returns false
+    ]);
+    await expect(getCommand().func(page, { 'note-id': validId })).rejects.toThrowError(/已发布 tab not found/);
+  });
+
+  it('throws EmptyResultError when the note row is not in the 已发布 tab', async () => {
+    const page = makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',
+      true,
+      { ok: false, kind: 'not_found', visibleRows: 0 },
+    ]);
+    await expect(getCommand().func(page, { 'note-id': validId })).rejects.toBeInstanceOf(EmptyResultError);
+  });
+
+  it('throws CommandExecutionError when the row has no visible delete action', async () => {
+    const page = makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',
+      true,
+      { ok: false, kind: 'no_delete_action', visibleRows: 1 },
+    ]);
+    await expect(getCommand().func(page, { 'note-id': validId })).rejects.toThrowError(/no delete action/i);
+  });
+
+  it('throws CommandExecutionError when the confirmation modal does not appear', async () => {
+    const page = makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',
+      true,
+      { ok: true },
+      { ok: false, kind: 'no_modal' },
+    ]);
+    await expect(getCommand().func(page, { 'note-id': validId, execute: true })).rejects.toThrowError(/no_modal/);
+  });
+
+  it('throws CommandExecutionError when row stays visible after confirm (delete did not commit)', async () => {
+    // verify probes return true (note still present) for the entire poll window.
+    const probes = Array(15).fill(true);
+    const page = makePage([
+      'https://creator.xiaohongshu.com/new/note-manager',
+      true,
+      { ok: true },
+      { ok: true },
+      ...probes,
+    ]);
+    await expect(getCommand().func(page, { 'note-id': validId, execute: true })).rejects.toThrowError(/still visible after confirm/i);
+  });
+
+  it('executes the generated row locator without substring-matching other impression fields', () => {
+    const otherId = '6a08ba0b000000000702a894';
+    const dom = new JSDOM(`
+      <div class="note" data-impression='{"noteTarget":{"value":{"noteId":"${otherId}"}},"title":"${validId}"}'>
+        <span class="control data-del">删除</span>
+      </div>
+      <div class="note" data-impression='{"noteTarget":{"value":{"noteId":"${validId}"}}}'>
+        <span class="control data-del">删除</span>
+      </div>
+    `, { runScripts: 'outside-only' });
+    Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetParent', {
+      configurable: true,
+      get() {
+        return this.ownerDocument.body;
+      },
+    });
+    const result = dom.window.eval(__test__.buildLocateAndMaybeDeleteScript(validId, false));
+    expect(result).toEqual({ ok: true, clicked: false });
+  });
+});

package/clis/xiaohongshu/download.js

@@ -52,49 +52,108 @@ export function buildDownloadExtractJs(noteId) {
         const authorEl = document.querySelector('.username, .author-name, .name');
         result.author = authorEl?.textContent?.trim() || 'unknown';
 
-        // Get images - try multiple selectors
-        const imageSelectors = [
-          '.swiper-slide img',
-          '.carousel-image img',
-          '.note-slider img',
-          '.note-image img',
-          '.image-wrapper img',
-          '#noteContainer .media-container img[src*="xhscdn"]',
-          'img[src*="ci.xiaohongshu.com"]'
-        ];
+        // Get images: prefer canonical carousel order from __INITIAL_STATE__
+        // so the saved order matches what the user sees on the platform (#1514).
+        // DOM extraction is used only as a fallback because multiple selectors,
+        // hidden / duplicated / preloaded slides, and lazy rendering can reorder
+        // the discovered nodes away from the platform's display order.
 
-        const imageUrls = new Set();
-        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') || src.includes('rednote'))) {
-              src = src.split('?')[0];
-              src = src.replace(/\\/imageView\\d+\\/\\d+\\/w\\/\\d+/, '');
-              imageUrls.add(src);
+        const normalizeImageUrl = (raw) => {
+          if (!raw || typeof raw !== 'string') return '';
+          let src = raw.split('?')[0];
+          src = src.replace(/\\/imageView\\d+\\/\\d+\\/w\\/\\d+/, '');
+          return src;
+        };
+        const orderedImageUrls = [];
+        const seenImageUrls = new Set();
+        const pushImage = (url) => {
+          if (!url || seenImageUrls.has(url)) return;
+          seenImageUrls.add(url);
+          orderedImageUrls.push(url);
+        };
+
+        const getStructuredNotes = () => {
+          const state = window.__INITIAL_STATE__;
+          const noteData = state?.note?.noteDetailMap || state?.note?.note || {};
+          if (!noteData || typeof noteData !== 'object') return [];
+          const currentIds = [...new Set([result.noteId, '${noteId}'].filter(Boolean))];
+          const notes = [];
+          for (const id of currentIds) {
+            const entry = noteData[id];
+            const note = entry?.note || entry;
+            if (note && typeof note === 'object') notes.push(note);
+          }
+          // Compatibility fallback for legacy single-note stores. Do not use this
+          // when keyed detail maps contain multiple notes, or carousel order can
+          // be polluted by preloaded/previous note entries.
+          const keys = Object.keys(noteData);
+          if (notes.length === 0 && keys.length === 1) {
+            const entry = noteData[keys[0]];
+            const note = entry?.note || entry;
+            if (note && typeof note === 'object') notes.push(note);
+          }
+          return notes;
+        };
+
+        // Method 1: walk __INITIAL_STATE__.note.noteDetailMap[id].note.imageList
+        // in array order. Each entry exposes urlDefault as the canonical CDN URL.
+        let imageInitialStateUsed = false;
+        try {
+          for (const note of getStructuredNotes()) {
+            const list = Array.isArray(note?.imageList) ? note.imageList : [];
+            for (const item of list) {
+              const candidate = item?.urlDefault || item?.urlPre || item?.url
+                || item?.infoList?.find(i => i?.imageScene === 'WB_DFT')?.url
+                || item?.infoList?.[0]?.url
+                || '';
+              const src = normalizeImageUrl(candidate);
+              if (src && (src.includes('xhscdn') || src.includes('xiaohongshu') || src.includes('rednote'))) {
+                pushImage(src);
+                imageInitialStateUsed = true;
+              }
             }
-          });
+          }
+        } catch(e) {}
+
+        // Method 2: fallback to DOM scraping when the structured state is missing
+        // (e.g. preview pages without full SSR hydration). Order may differ from
+        // the carousel; surface it anyway rather than returning zero images.
+        if (!imageInitialStateUsed) {
+          const imageSelectors = [
+            '.swiper-slide img',
+            '.carousel-image img',
+            '.note-slider img',
+            '.note-image img',
+            '.image-wrapper img',
+            '#noteContainer .media-container img[src*="xhscdn"]',
+            'img[src*="ci.xiaohongshu.com"]'
+          ];
+          for (const selector of imageSelectors) {
+            document.querySelectorAll(selector).forEach(img => {
+              const raw = img.src || img.getAttribute('data-src') || '';
+              const src = normalizeImageUrl(raw);
+              if (src && (src.includes('xhscdn') || src.includes('xiaohongshu') || src.includes('rednote'))) {
+                pushImage(src);
+              }
+            });
+          }
         }
 
         // Get video — prefer real URL from page state over blob: URLs
 
         // Method 1: Extract from __INITIAL_STATE__ (SSR hydration data)
         try {
-          const state = window.__INITIAL_STATE__;
-          if (state) {
-            const noteData = state.note?.noteDetailMap || state.note?.note || {};
-            for (const key of Object.keys(noteData)) {
-              const note = noteData[key]?.note || noteData[key];
-              const video = note?.video;
-              if (video) {
-                const vUrl = video.url || video.originVideoKey || video.consumer?.originVideoKey;
-                if (vUrl) {
-                  const fullUrl = vUrl.startsWith('http') ? vUrl : 'https://sns-video-bd.xhscdn.com/' + vUrl;
-                  pushMedia('video', fullUrl);
-                }
-                const streams = video.media?.stream?.h264 || [];
-                for (const stream of streams) {
-                  if (stream.masterUrl) pushMedia('video', stream.masterUrl);
-                }
+          for (const note of getStructuredNotes()) {
+            const video = note?.video;
+            if (video) {
+              const vUrl = video.url || video.originVideoKey || video.consumer?.originVideoKey;
+              if (vUrl) {
+                const fullUrl = vUrl.startsWith('http') ? vUrl : 'https://sns-video-bd.xhscdn.com/' + vUrl;
+                pushMedia('video', fullUrl);
+              }
+              const streams = video.media?.stream?.h264 || [];
+              for (const stream of streams) {
+                if (stream.masterUrl) pushMedia('video', stream.masterUrl);
               }
             }
           }
@@ -135,10 +194,9 @@ export function buildDownloadExtractJs(noteId) {
           }
         }
 
-        // Add images to media
-        imageUrls.forEach(url => {
-          pushMedia('image', url);
-        });
+        // Preserve the pre-existing media type order (videos first, then images)
+        // while keeping image carousel order stable within the image batch.
+        orderedImageUrls.forEach(url => pushMedia('image', url));
 
         return result;
       })()