feat(xiaohongshu): paginate creator-notes past the 10-row /analyze/list cap

The /api/galaxy/creator/datacenter/note/analyze/list endpoint serves 10
note rows per page, and the previous fetchCreatorNotesByApi only ever
requested page 1 because the in-page direct fetch() bypassed xhs's
signing interceptor and returned HTTP 406 for subsequent pages. As a
result `opencli xiaohongshu creator-notes --limit 25` silently capped
at 10 even for accounts with hundreds of notes.

Install the same window.__xhsCapture fetch + XHR hook used by
creator-note-detail (jackwener#1732), SPA-navigate to /statistics/data-analysis
so the dashboard fires its own signed page_num=1 request under the
hook, then click .d-pagination-page buttons for pages 2..N to make the
dashboard's React router fire successive signed requests. Dedupe by
note.id and return up to --limit.

Pagination buttons render the page number duplicated in textContent
("22" for page 2 because of an inner accessibility span + visible
span), so the click selector tolerates both the raw digit and the
doubled form. CAPTURE_POLL_ATTEMPTS / CAPTURE_POLL_INTERVAL_S match
the constant naming used by sibling delete-note.js.

Fresh notes whose title field is still empty in the API response get
enriched from the note-manager card DOM (which derives a title from the
content's first line), so the pre-existing title coverage is preserved
for the rows the API surfaces empty.

Live-verified on benjamin-eecs's 圣诞薯 account (11 published notes,
data-analysis permission active): creator-notes --limit 15 now returns
all 11 rows, with 10 titles enriched via note-manager and 1 left empty
because that note is older than note-manager's first 10 visible cards.
For real-world use (e.g. @ppop123's reported 148-note account), all
titles populate directly from the API.

Closes jackwener#1729.

Author: Benjamin-eecs

clis/xiaohongshu/creator-notes.js

@@ -13,6 +13,9 @@ const DATE_LINE_RE = /^发布于 (\d{4}年\d{2}月\d{2}日 \d{2}:\d{2})$/;
 const METRIC_LINE_RE = /^\d+$/;
 const VISIBILITY_LINE_RE = /可见$/;
 const NOTE_ANALYZE_API_PATH = '/api/galaxy/creator/datacenter/note/analyze/list';
+const NOTE_ANALYZE_PAGE_SIZE = 10;
+const CAPTURE_POLL_ATTEMPTS = 20;
+const CAPTURE_POLL_INTERVAL_S = 0.5;
 const NOTE_DETAIL_PAGE_URL = 'https://creator.xiaohongshu.com/statistics/note-detail';
 const NOTE_ID_HTML_RE = /"noteId":"([0-9a-f]{24})"/g;
 function buildNoteDetailUrl(noteId) {
@@ -105,6 +108,171 @@ function mapAnalyzeItems(items) {
         url: buildNoteDetailUrl(item.id),
     }));
 }
+// Capture the dashboard's signed /api/galaxy/* responses on window.__xhsCapture
+// since a direct fetch() from page.evaluate bypasses the x-s signing and gets 406.
+async function installXhsFetchCaptureHook(page) {
+    await page.evaluate(`(() => {
+    window.__xhsCapture = {};
+    if (window.__xhsCaptureInstalled) return;
+    window.__xhsCaptureInstalled = true;
+    const origFetch = window.fetch;
+    window.fetch = async function(...args) {
+      const resp = await origFetch.apply(this, args);
+      try {
+        const url = typeof args[0] === 'string' ? args[0] : (args[0] && args[0].url) || '';
+        if (url.includes('/api/galaxy/')) {
+          resp.clone().text().then((body) => {
+            try { window.__xhsCapture[url] = { status: resp.status, ok: resp.ok, body }; } catch (_) {}
+          }).catch(() => {});
+        }
+      } catch (_) {}
+      return resp;
+    };
+    const OrigXHR = window.XMLHttpRequest;
+    function HookedXHR() {
+      const xhr = new OrigXHR();
+      const origOpen = xhr.open;
+      let capturedUrl = '';
+      xhr.open = function(method, url, ...rest) {
+        capturedUrl = url;
+        return origOpen.call(this, method, url, ...rest);
+      };
+      xhr.addEventListener('load', () => {
+        try {
+          if (capturedUrl.includes('/api/galaxy/')) {
+            window.__xhsCapture[capturedUrl] = { status: xhr.status, ok: xhr.status >= 200 && xhr.status < 300, body: xhr.responseText };
+          }
+        } catch (_) {}
+      });
+      return xhr;
+    }
+    HookedXHR.prototype = OrigXHR.prototype;
+    for (const key of ['UNSENT', 'OPENED', 'HEADERS_RECEIVED', 'LOADING', 'DONE']) {
+      if (key in OrigXHR) HookedXHR[key] = OrigXHR[key];
+    }
+    window.XMLHttpRequest = HookedXHR;
+  })()`);
+}
+function harvestAnalyzeListCaptures(captureMap) {
+    const items = [];
+    const seen = new Set();
+    let total = 0;
+    for (const [url, capture] of Object.entries(captureMap)) {
+        if (!url.includes('/note/analyze/list')) continue;
+        if (!capture?.ok) continue;
+        try {
+            const json = JSON.parse(capture.body);
+            const data = json?.data ?? {};
+            if (typeof data.total === 'number' && data.total > total) total = data.total;
+            for (const note of data.note_infos ?? []) {
+                if (!note?.id || seen.has(note.id)) continue;
+                seen.add(note.id);
+                items.push(note);
+            }
+        }
+        catch { }
+    }
+    return { items, total };
+}
+async function pollCaptureMap(page) {
+    let captureMap = {};
+    for (let i = 0; i < CAPTURE_POLL_ATTEMPTS; i++) {
+        await page.wait(CAPTURE_POLL_INTERVAL_S);
+        const raw = await page.evaluate('JSON.stringify(window.__xhsCapture || {})');
+        captureMap = typeof raw === 'string' ? JSON.parse(raw) : {};
+        if (Object.keys(captureMap).some((url) => url.includes('/note/analyze/list'))) break;
+    }
+    return captureMap;
+}
+// Fresh-published notes return title: "" from /note/analyze/list (the field
+// only populates once xhs's backend has indexed the content). Scrape the
+// /new/note-manager card DOM as a secondary source so freshly-published
+// notes still get a title even before backend indexing catches up.
+async function fetchNoteManagerTitleMap(page, neededCount) {
+    const map = new Map();
+    try {
+        await page.goto('https://creator.xiaohongshu.com/new/note-manager');
+        await page.wait(2);
+        // The note-manager renders 10 cards per scroll batch and lazy-loads more
+        // on PageDown. Scroll enough batches to cover all caller-requested ids.
+        const scrollBatches = Math.max(1, Math.ceil(neededCount / NOTE_ANALYZE_PAGE_SIZE) + 1);
+        for (let i = 0; i < scrollBatches; i++) {
+            const cards = await page.evaluate(`() => {
+        const noteIdRe = /"noteId":"([0-9a-f]{24})"/;
+        return Array.from(document.querySelectorAll('div.note[data-impression], div.note')).map((card) => {
+          const impression = card.getAttribute('data-impression') || '';
+          const id = impression.match(noteIdRe)?.[1] || '';
+          const title = (card.querySelector('.title, .raw')?.innerText || '').trim();
+          return { id, title };
+        }).filter((entry) => entry.id && entry.title);
+      }`);
+            for (const card of Array.isArray(cards) ? cards : []) {
+                if (!map.has(card.id)) map.set(card.id, card.title);
+            }
+            if (map.size >= neededCount) break;
+            await page.pressKey('PageDown');
+            await page.wait(1);
+        }
+        return map;
+    }
+    catch {
+        return map;
+    }
+}
+async function fetchCreatorNotesByCapture(page, limit) {
+    // Land on dashboard root before installing the hook so the data-analysis
+    // SPA navigation fires page_num=1's signed request UNDER the hook.
+    await page.goto('https://creator.xiaohongshu.com/statistics');
+    await installXhsFetchCaptureHook(page);
+    await page.evaluate(`(() => {
+    history.pushState({}, '', '/statistics/data-analysis?source=official');
+    window.dispatchEvent(new PopStateEvent('popstate'));
+  })()`);
+    let captureMap = await pollCaptureMap(page);
+    let { items, total } = harvestAnalyzeListCaptures(captureMap);
+    if (items.length === 0) return [];
+    const totalPages = total > 0 ? Math.ceil(total / NOTE_ANALYZE_PAGE_SIZE) : 1;
+    const neededPages = Math.min(totalPages, Math.ceil(limit / NOTE_ANALYZE_PAGE_SIZE));
+    for (let pageNum = 2; pageNum <= neededPages && items.length < limit; pageNum++) {
+        const clicked = await page.evaluate(`(() => {
+      const target = String(${pageNum});
+      // .d-pagination-page renders the page number doubled (a visible span +
+      // an accessibility span), so textContent for page 2 reads "22". Match
+      // both the raw digit and the doubled form to tolerate either render.
+      const btns = Array.from(document.querySelectorAll('.d-pagination-page'));
+      const match = btns.find((btn) => {
+        const text = (btn.textContent || '').trim();
+        return text === target || text === target + target;
+      });
+      if (match) { match.click(); return true; }
+      return false;
+    })()`);
+        if (!clicked) break;
+        const before = items.length;
+        for (let attempt = 0; attempt < CAPTURE_POLL_ATTEMPTS; attempt++) {
+            await page.wait(CAPTURE_POLL_INTERVAL_S);
+            const raw = await page.evaluate('JSON.stringify(window.__xhsCapture || {})');
+            captureMap = typeof raw === 'string' ? JSON.parse(raw) : {};
+            const harvested = harvestAnalyzeListCaptures(captureMap);
+            if (harvested.items.length > before) {
+                items = harvested.items;
+                total = Math.max(total, harvested.total);
+                break;
+            }
+        }
+    }
+    const notes = mapAnalyzeItems(items).slice(0, limit);
+    const missingTitles = notes.filter((note) => !note.title).length;
+    if (missingTitles > 0) {
+        const titleMap = await fetchNoteManagerTitleMap(page, notes.length);
+        for (const note of notes) {
+            if (!note.title && note.id && titleMap.has(note.id)) {
+                note.title = titleMap.get(note.id);
+            }
+        }
+    }
+    return notes;
+}
 async function fetchCreatorNotesByApi(page, limit) {
     const pageSize = Math.min(Math.max(limit, 10), 20);
     const maxPages = Math.max(1, Math.ceil(limit / pageSize));
@@ -148,7 +316,10 @@ async function fetchCreatorNotesByApi(page, limit) {
     return notes.slice(0, limit);
 }
 export async function fetchCreatorNotes(page, limit) {
-    let notes = await fetchCreatorNotesByApi(page, limit);
+    let notes = await fetchCreatorNotesByCapture(page, limit).catch(() => []);
+    if (notes.length === 0) {
+        notes = await fetchCreatorNotesByApi(page, limit);
+    }
     if (notes.length === 0) {
         await page.goto('https://creator.xiaohongshu.com/new/note-manager');
         const maxPageDowns = Math.max(0, Math.ceil(limit / 10) + 1);