@chainlesschain/personal-data-hub 0.3.1 → 0.3.6

package/lib/adapters/social-xiaohongshu-adb/api-client.js

@@ -0,0 +1,278 @@
+"use strict";
+
+/**
+ * Phase 3c (Xhs C 路径 — 2026-05-25): Node-side XhsApiClient.
+ *
+ * Byte-parity port of XhsApiClient.kt 4 endpoints. **Best-effort X-S
+ * signing** (~60% GET / <30% POST hit rate) — collector tolerates
+ * partial failures.
+ *
+ * Endpoints:
+ *   - `/api/sns/web/v1/user/me`             — no X-S, cookies-only
+ *   - `/api/sns/web/v2/user_posted`         — needs X-S
+ *   - `/api/sns/web/v1/note/like/page`      — needs X-S
+ *   - `/api/sns/web/v1/user/follow/list`    — needs X-S
+ *
+ * **Anti-bot signal**: User-Agent must look like desktop Chrome (xhs
+ * web is desktop-tuned, NOT mobile like Bilibili/Weibo). Referer +
+ * Origin = `https://www.xiaohongshu.com/`.
+ */
+
+const { computeXsXt } = require("./sign");
+
+const DEFAULT_BASE_URL = "https://edith.xiaohongshu.com/";
+
+const BROWSER_UA =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
+  "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+
+const BROWSER_HEADERS = Object.freeze({
+  "User-Agent": BROWSER_UA,
+  Referer: "https://www.xiaohongshu.com/",
+  Origin: "https://www.xiaohongshu.com",
+  Accept: "application/json, text/plain, */*",
+  "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+});
+
+/**
+ * Parse xhs's interact_info count strings: "1.2万" / "10w+" / "234" / "亿".
+ * Mirrors XhsApiClient.kt:parseCount.
+ */
+function parseCount(raw) {
+  if (typeof raw !== "string" || raw.length === 0) return 0;
+  const trimmed = raw.trim();
+  if (trimmed.endsWith("万")) {
+    const n = parseFloat(trimmed.slice(0, -1));
+    return Number.isFinite(n) ? Math.floor(n * 10000) : 0;
+  }
+  if (trimmed.endsWith("w+") || trimmed.endsWith("W+")) {
+    const n = parseFloat(trimmed.slice(0, -2));
+    return Number.isFinite(n) ? Math.floor(n * 10000) : 0;
+  }
+  if (trimmed.endsWith("w") || trimmed.endsWith("W")) {
+    const n = parseFloat(trimmed.slice(0, -1));
+    return Number.isFinite(n) ? Math.floor(n * 10000) : 0;
+  }
+  if (trimmed.endsWith("亿")) {
+    const n = parseFloat(trimmed.slice(0, -1));
+    return Number.isFinite(n) ? Math.floor(n * 100_000_000) : 0;
+  }
+  const n = parseInt(trimmed, 10);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/**
+ * Normalize a Xhs timestamp to milliseconds (seconds → ms when < 1e12).
+ */
+function normalizeMs(v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) return 0;
+  return v > 1e12 ? v : v * 1000;
+}
+
+class XhsApiClient {
+  constructor(opts = {}) {
+    this.baseUrl = opts.baseUrl || DEFAULT_BASE_URL;
+    if (!this.baseUrl.endsWith("/")) this.baseUrl += "/";
+    this._fetch = opts.fetch || globalThis.fetch;
+    if (typeof this._fetch !== "function") {
+      throw new Error(
+        "XhsApiClient: fetch not available — pass opts.fetch or run on Node 18+",
+      );
+    }
+    this._now = opts.now || Date.now;
+    this.lastErrorCode = 0;
+    this.lastErrorMessage = null;
+  }
+
+  async _doGetJson(url, cookie, a1, requireSign) {
+    const headers = { ...BROWSER_HEADERS, Cookie: cookie };
+    if (requireSign && a1) {
+      const pathWithQuery = url.pathname + url.search;
+      const { xs, xt } = computeXsXt(pathWithQuery, null, a1, {
+        now: this._now,
+      });
+      headers["X-S"] = xs;
+      headers["X-T"] = xt;
+    }
+    try {
+      const resp = await this._fetch(url.toString(), {
+        method: "GET",
+        headers,
+      });
+      const body = await resp.text();
+      if (!resp.ok) {
+        this._setLastError(resp.status, `HTTP ${resp.status}`);
+        return null;
+      }
+      const trimmed = body.trimStart();
+      if (!trimmed.startsWith("{")) {
+        this._setLastError(-4, "non-json (login redirect / anti-bot HTML)");
+        return null;
+      }
+      let obj;
+      try {
+        obj = JSON.parse(body);
+      } catch (e) {
+        this._setLastError(-3, "parse: " + (e.message || String(e)));
+        return null;
+      }
+      // xhs returns either {code: N, msg:..., data:...} or {success:bool, code:N, data:...}
+      const success = obj.success === undefined ? true : obj.success;
+      if (success === false) {
+        this._setLastError(-5, "/success=false (no code)");
+        return null;
+      }
+      const code = typeof obj.code === "number" ? obj.code : 0;
+      if (code !== 0) {
+        this._setLastError(code, (obj.msg || "").toString());
+        return null;
+      }
+      this._clearLastError();
+      return obj;
+    } catch (e) {
+      this._setLastError(-2, "IO: " + (e.message || String(e)));
+      return null;
+    }
+  }
+
+  _setLastError(code, message) {
+    this.lastErrorCode = code;
+    this.lastErrorMessage = message;
+  }
+  _clearLastError() {
+    this.lastErrorCode = 0;
+    this.lastErrorMessage = null;
+  }
+
+  /**
+   * Fetch /api/sns/web/v1/user/me — cookies-only, no X-S required.
+   * Returns `{userId, nickname}` or null on failure.
+   */
+  async fetchMe(cookie) {
+    const url = new URL("api/sns/web/v1/user/me", this.baseUrl);
+    const obj = await this._doGetJson(url, cookie, null, false);
+    if (!obj) return null;
+    const data = obj.data || {};
+    const userId = (data.user_id && String(data.user_id)) || null;
+    if (!userId) {
+      this._setLastError(
+        -7,
+        "/user/me ok but user_id blank (cookie likely missing web_session)",
+      );
+      return null;
+    }
+    return {
+      userId,
+      nickname: data.nickname || null,
+    };
+  }
+
+  /**
+   * Fetch user's posted notes. Requires X-S signing.
+   */
+  async fetchNotes(cookie, a1, userId, opts = {}) {
+    const limit = Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : 30;
+    const url = new URL("api/sns/web/v2/user_posted", this.baseUrl);
+    url.searchParams.set("user_id", userId);
+    url.searchParams.set("num", "30");
+    url.searchParams.set("cursor", "");
+    url.searchParams.set("image_formats", "jpg,webp,avif");
+    const obj = await this._doGetJson(url, cookie, a1, true);
+    if (!obj) return [];
+    const data = obj.data || {};
+    const notes = Array.isArray(data.notes) ? data.notes : [];
+    const out = [];
+    for (let i = 0; i < Math.min(limit, notes.length); i++) {
+      const n = notes[i];
+      if (!n) continue;
+      const noteId =
+        (n.note_id && String(n.note_id)) || (n.id && String(n.id));
+      if (!noteId) continue;
+      const interact = n.interact_info || {};
+      out.push({
+        noteId,
+        title:
+          n.display_title ||
+          n.title ||
+          "(no title)",
+        desc: n.desc || null,
+        type: n.type || "normal",
+        createdAt: normalizeMs(typeof n.time === "number" ? n.time : 0),
+        likedCount: parseCount(interact.liked_count),
+        collectedCount: parseCount(interact.collected_count),
+        commentCount: parseCount(interact.comment_count),
+      });
+    }
+    return out;
+  }
+
+  /**
+   * Fetch user's liked notes. Requires X-S.
+   */
+  async fetchLiked(cookie, a1, opts = {}) {
+    const limit = Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : 30;
+    const url = new URL("api/sns/web/v1/note/like/page", this.baseUrl);
+    url.searchParams.set("num", "20");
+    url.searchParams.set("cursor", "");
+    const obj = await this._doGetJson(url, cookie, a1, true);
+    if (!obj) return [];
+    const data = obj.data || {};
+    const notes = Array.isArray(data.notes) ? data.notes : [];
+    const out = [];
+    for (let i = 0; i < Math.min(limit, notes.length); i++) {
+      const n = notes[i];
+      if (!n) continue;
+      const noteId = n.note_id && String(n.note_id);
+      if (!noteId) continue;
+      const user = n.user || {};
+      out.push({
+        noteId,
+        title: n.display_title || n.title || "(no title)",
+        // xhs doesn't return explicit liked_at — collector fills with snapshotted_at
+        likedAt: 0,
+        authorNickname: user.nickname || null,
+      });
+    }
+    return out;
+  }
+
+  /**
+   * Fetch follow list. Requires X-S.
+   */
+  async fetchFollows(cookie, a1, userId, opts = {}) {
+    const limit = Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : 100;
+    const url = new URL("api/sns/web/v1/user/follow/list", this.baseUrl);
+    url.searchParams.set("user_id", userId);
+    url.searchParams.set("num", "20");
+    url.searchParams.set("cursor", "");
+    const obj = await this._doGetJson(url, cookie, a1, true);
+    if (!obj) return [];
+    const data = obj.data || {};
+    const users = Array.isArray(data.users) ? data.users : [];
+    const out = [];
+    for (let i = 0; i < Math.min(limit, users.length); i++) {
+      const u = users[i];
+      if (!u) continue;
+      const userIdStr = u.user_id && String(u.user_id);
+      if (!userIdStr) continue;
+      out.push({
+        userId: userIdStr,
+        nickname: u.nickname || "(unnamed)",
+        image: u.image || null,
+        // xhs doesn't return explicit follow time
+        followedAt: 0,
+      });
+    }
+    return out;
+  }
+}
+
+module.exports = {
+  XhsApiClient,
+  _internals: {
+    parseCount,
+    normalizeMs,
+    BROWSER_UA,
+    BROWSER_HEADERS,
+  },
+};

package/lib/adapters/social-xiaohongshu-adb/collector.js

@@ -0,0 +1,158 @@
+"use strict";
+
+/**
+ * Phase 3c (Xhs C 路径 — 2026-05-25): end-to-end orchestrator.
+ *
+ *   bridge.invoke("xhs.cookies")            ← Phase 3c cookies extension
+ *           │
+ *           ▼  {cookie, a1, diagnostic}
+ *   XhsApiClient.fetchMe                     ← /user/me 拿 user_id (无 X-S)
+ *           │
+ *           ▼  {userId, nickname}
+ *   fetchNotes + fetchLiked + fetchFollows   (parallel, X-S 需 a1)
+ *           │
+ *           ▼  3 arrays (partial-failure OK; ~60% GET hit rate)
+ *   buildSnapshot + writeSnapshotJson        ← schemaVersion=1
+ *           │
+ *           ▼
+ *   registry.syncAdapter("social-xiaohongshu", { inputPath })
+ *
+ * Mirror of social-weibo-adb/collector.js. Key diff: 3 endpoints need
+ * X-S signing (best-effort md5 approximation hits ~60% GET, <30% POST;
+ * collector tolerates partial failures via lastErrorCode propagation).
+ */
+
+const { XhsApiClient } = require("./api-client");
+const {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+} = require("./snapshot-builder");
+
+async function collect(bridge, opts = {}) {
+  if (!bridge || typeof bridge.invoke !== "function") {
+    throw new TypeError(
+      "XhsAdbCollector.collect: bridge must expose invoke(method, params)",
+    );
+  }
+  const now = opts.now || Date.now;
+  const client = opts.apiClient || new XhsApiClient({ now });
+  const limits = opts.limits || {};
+
+  const cookieResult = await bridge.invoke("xhs.cookies");
+  if (
+    !cookieResult ||
+    typeof cookieResult.cookie !== "string" ||
+    typeof cookieResult.a1 !== "string"
+  ) {
+    throw new Error(
+      "XhsAdbCollector.collect: bridge.invoke('xhs.cookies') returned malformed payload — got cookie=" +
+        typeof cookieResult?.cookie +
+        " a1=" +
+        typeof cookieResult?.a1,
+    );
+  }
+  const { cookie, a1, diagnostic: cookieDiagnostic } = cookieResult;
+
+  // fetchMe — no X-S required
+  const me = await client.fetchMe(cookie);
+  if (!me) {
+    // Cookie expired or web_session missing — write empty snapshot
+    // (build requires userId, use sentinel "0" + emit 0 events).
+    const snapshot = buildSnapshot({
+      userId: "unknown-user",
+      nickname: opts.displayName,
+      snapshottedAt: now(),
+    });
+    const snapshotPath = writeSnapshotJson(snapshot, { dir: opts.stagingDir });
+    return {
+      snapshotPath,
+      userId: null,
+      nickname: null,
+      eventCounts: { note: 0, liked: 0, follow: 0, total: 0 },
+      lastErrorCode: client.lastErrorCode,
+      lastErrorMessage: client.lastErrorMessage,
+      cookieDiagnostic: cookieDiagnostic || null,
+      meFetchFailed: true,
+    };
+  }
+
+  // Parallel 3 endpoints — partial failure tolerated (~60% X-S hit rate)
+  const [notes, liked, follows] = await Promise.all([
+    client.fetchNotes(cookie, a1, me.userId, {
+      limit: Number.isInteger(limits.note) ? limits.note : undefined,
+    }),
+    client.fetchLiked(cookie, a1, {
+      limit: Number.isInteger(limits.liked) ? limits.liked : undefined,
+    }),
+    client.fetchFollows(cookie, a1, me.userId, {
+      limit: Number.isInteger(limits.follow) ? limits.follow : undefined,
+    }),
+  ]);
+
+  const snapshot = buildSnapshot({
+    userId: me.userId,
+    nickname: opts.displayName || me.nickname,
+    notes,
+    liked,
+    follows,
+    snapshottedAt: now(),
+  });
+  const snapshotPath = writeSnapshotJson(snapshot, { dir: opts.stagingDir });
+
+  return {
+    snapshotPath,
+    userId: me.userId,
+    nickname: me.nickname,
+    eventCounts: {
+      note: notes.length,
+      liked: liked.length,
+      follow: follows.length,
+      total: snapshot.events.length,
+    },
+    lastErrorCode: client.lastErrorCode,
+    lastErrorMessage: client.lastErrorMessage,
+    cookieDiagnostic: cookieDiagnostic || null,
+    meFetchFailed: false,
+  };
+}
+
+async function collectAndSync(bridge, registry, opts = {}) {
+  if (!registry || typeof registry.syncAdapter !== "function") {
+    throw new TypeError(
+      "XhsAdbCollector.collectAndSync: registry must expose syncAdapter(name, options)",
+    );
+  }
+  const collectResult = await collect(bridge, opts);
+  let syncReport = null;
+  let cleanupFailed = false;
+  try {
+    syncReport = await registry.syncAdapter("social-xiaohongshu", {
+      inputPath: collectResult.snapshotPath,
+    });
+  } finally {
+    try {
+      cleanupSnapshotJson(collectResult.snapshotPath);
+    } catch (_e) {
+      cleanupFailed = true;
+    }
+  }
+  return {
+    ...syncReport,
+    xhs: {
+      userId: collectResult.userId,
+      nickname: collectResult.nickname,
+      eventCounts: collectResult.eventCounts,
+      lastErrorCode: collectResult.lastErrorCode,
+      lastErrorMessage: collectResult.lastErrorMessage,
+      cookieDiagnostic: collectResult.cookieDiagnostic,
+      meFetchFailed: collectResult.meFetchFailed,
+      cleanupFailed,
+    },
+  };
+}
+
+module.exports = {
+  collect,
+  collectAndSync,
+};

package/lib/adapters/social-xiaohongshu-adb/cookies-extension.js

@@ -0,0 +1,211 @@
+"use strict";
+
+/**
+ * Phase 3c (Xhs C 路径 — 2026-05-25): xhs.cookies ADB extension factory.
+ *
+ * Mirror of `social-weibo-adb/cookies-extension.js` (P3a) but for
+ * com.xingin.xhs (Xiaohongshu) — same chromium-cookies-reader reuse,
+ * different package + cookie name requirements.
+ *
+ * Required cookies (without these, X-S signing or auth fails):
+ *  - `a1`           — anti-bot fingerprint, REQUIRED for X-S sig input
+ *  - `web_session`  — login session token
+ *
+ * Either of the two missing → WEIBO_COOKIES_INCOMPLETE-style error code
+ * (XHS_COOKIES_INCOMPLETE) so UI surfaces a "relog on phone" banner.
+ *
+ * Returns:
+ *   {
+ *     cookie: string,             // full Cookie header value
+ *     a1: string,                 // pre-extracted a1 (saves caller parsing)
+ *     extractedAt: number,
+ *     diagnostic: {
+ *       cookieCount: number,
+ *       hadEncrypted: boolean,
+ *       cookieNames: string[],
+ *     }
+ *   }
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const {
+  readChromiumCookies,
+} = require("../social-bilibili-adb/chromium-cookies-reader");
+
+const XHS_COOKIES_REMOTE_PATH =
+  "/data/data/com.xingin.xhs/app_webview/Default/Cookies";
+
+const XHS_COOKIE_HOST_DOMAIN = "xiaohongshu.com";
+
+const XHS_REQUIRED_COOKIES = Object.freeze(["a1", "web_session"]);
+
+async function pullCookiesViaSu(adb, serial, opts) {
+  const adbOpts = { serial, timeoutMs: opts?.timeoutMs || 60_000 };
+  const lsOut = await adb(
+    [
+      "shell",
+      "su",
+      "-c",
+      `ls ${XHS_COOKIES_REMOTE_PATH} 2>/dev/null || echo NOT_FOUND`,
+    ],
+    adbOpts,
+  );
+  const lsLine = lsOut.replace(/\r+$/gm, "").trim();
+  if (lsLine === "NOT_FOUND" || lsLine === "") {
+    throw new Error(
+      "XHS_NOT_INSTALLED: " +
+        XHS_COOKIES_REMOTE_PATH +
+        " not found. Install Xiaohongshu App + log in once on the phone, then retry.",
+    );
+  }
+  const idOut = await adb(["shell", "su", "-c", "id -u"], adbOpts);
+  const idLine = idOut.replace(/\r+$/gm, "").trim();
+  if (idLine !== "0" && !idLine.includes("uid=0")) {
+    throw new Error(
+      "XHS_NO_ROOT: this phone isn't rooted (su returned `" +
+        idLine.substring(0, 60) +
+        "`). Xiaohongshu release APK isn't debuggable, so root is required.",
+    );
+  }
+  const b64 = await adb(
+    [
+      "shell",
+      "su",
+      "-c",
+      `base64 ${XHS_COOKIES_REMOTE_PATH} | tr -d '\\n\\r'`,
+    ],
+    { ...adbOpts, timeoutMs: opts?.timeoutMs || 60_000 },
+  );
+  const b64Clean = b64.replace(/[\r\n\t ]+/g, "");
+  if (b64Clean.length === 0) {
+    throw new Error(
+      "XHS_COOKIES_EMPTY: base64 stream returned 0 bytes (su exec may have silently failed on MIUI / OEM ROM)",
+    );
+  }
+  let buf;
+  try {
+    buf = Buffer.from(b64Clean, "base64");
+  } catch (e) {
+    throw new Error(
+      "XHS_BASE64_PARSE: stream wasn't valid base64 (" +
+        (e.message || String(e)) +
+        ")",
+    );
+  }
+  if (buf.length < 1024) {
+    throw new Error(
+      "XHS_COOKIES_TRUNCATED: decoded file is only " +
+        buf.length +
+        " bytes — expected ≥4KB sqlite",
+    );
+  }
+  const magic = buf.subarray(0, 16).toString("latin1");
+  if (!magic.startsWith("SQLite format 3")) {
+    throw new Error(
+      "XHS_NOT_SQLITE: decoded file lacks `SQLite format 3` magic header",
+    );
+  }
+  const tmpDir = os.tmpdir();
+  const tmpFile = path.join(tmpDir, `cc-xhs-cookies-${crypto.randomUUID()}.db`);
+  fs.writeFileSync(tmpFile, buf);
+  return tmpFile;
+}
+
+/**
+ * Build a Cookie header + extract a1 from a chromium-cookies array.
+ *
+ * Xhs requires BOTH a1 and web_session — without either, X-S signing
+ * fails (a1) or auth fails (web_session).
+ */
+function assembleXhsCookieHeader(cookies) {
+  if (!Array.isArray(cookies)) {
+    throw new TypeError("assembleXhsCookieHeader: cookies must be an array");
+  }
+  const byName = new Map();
+  for (const c of cookies) {
+    if (
+      !byName.has(c.name) ||
+      c.hostKey.length > (byName.get(c.name).hostKey || "").length
+    ) {
+      byName.set(c.name, c);
+    }
+  }
+  const missing = XHS_REQUIRED_COOKIES.filter((n) => !byName.has(n));
+  const present = new Set(byName.keys());
+  if (missing.length > 0) {
+    return { header: null, a1: null, present, missing };
+  }
+  const header = Array.from(byName.values())
+    .map((c) => `${c.name}=${c.value}`)
+    .join("; ");
+  const a1 = byName.get("a1")?.value || null;
+  return { header, a1, present, missing: [] };
+}
+
+function createXhsCookiesExtension(factoryOpts = {}) {
+  const timeoutMs = factoryOpts.timeoutMs || 60_000;
+  const onCleanupFailed = factoryOpts.onCleanupFailed || (() => {});
+
+  return async function xhsCookiesHandler(_params, ctx) {
+    if (
+      !ctx ||
+      typeof ctx.adb !== "function" ||
+      typeof ctx.pickDevice !== "function"
+    ) {
+      throw new TypeError(
+        "xhs.cookies extension: ctx must provide {adb, pickDevice}",
+      );
+    }
+    const serial = await ctx.pickDevice();
+    let tmpFile = null;
+    try {
+      tmpFile = await pullCookiesViaSu(ctx.adb, serial, { timeoutMs });
+      const cookies = readChromiumCookies(tmpFile, XHS_COOKIE_HOST_DOMAIN);
+      const cookieCount = cookies.length;
+      const hadEncrypted = (cookies._skippedEncryptedCount || 0) > 0;
+      const { header, a1, missing, present } = assembleXhsCookieHeader(cookies);
+      if (header === null) {
+        throw new Error(
+          "XHS_COOKIES_INCOMPLETE: missing required cookies " +
+            JSON.stringify(missing) +
+            ". User probably logged out (relog on phone) or Xhs version uses non-default WebView storage path (hadEncrypted=" +
+            hadEncrypted +
+            ").",
+        );
+      }
+      return {
+        cookie: header,
+        a1,
+        extractedAt: Date.now(),
+        diagnostic: {
+          cookieCount,
+          hadEncrypted,
+          cookieNames: Array.from(present),
+        },
+      };
+    } finally {
+      if (tmpFile) {
+        try {
+          fs.unlinkSync(tmpFile);
+        } catch (_e) {
+          onCleanupFailed(tmpFile);
+        }
+      }
+    }
+  };
+}
+
+module.exports = {
+  createXhsCookiesExtension,
+  XHS_COOKIES_REMOTE_PATH,
+  XHS_COOKIE_HOST_DOMAIN,
+  XHS_REQUIRED_COOKIES,
+  assembleXhsCookieHeader,
+  _internals: {
+    pullCookiesViaSu,
+  },
+};

package/lib/adapters/social-xiaohongshu-adb/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+/**
+ * social-xiaohongshu-adb — Phase 3c (Xhs C 路径) entry.
+ *
+ * Phase 3c — desktop ADB Chromium cookies + edith.xiaohongshu.com HTTP
+ * with best-effort X-S signing (md5 approximation, ~60% GET hit rate).
+ *
+ * Pipeline:
+ *   bridge.invoke("xhs.cookies") → {cookie, a1}
+ *     → XhsApiClient.fetchMe (no X-S, cookies-only)
+ *     → fetchNotes + fetchLiked + fetchFollows (X-S signed, parallel)
+ *     → buildSnapshot + writeSnapshotJson
+ *     → registry.syncAdapter("social-xiaohongshu", { inputPath })
+ */
+
+const {
+  createXhsCookiesExtension,
+  XHS_COOKIES_REMOTE_PATH,
+  XHS_COOKIE_HOST_DOMAIN,
+  XHS_REQUIRED_COOKIES,
+  assembleXhsCookieHeader,
+} = require("./cookies-extension");
+const { computeXsXt, extractA1, XS_PREFIX } = require("./sign");
+const { XhsApiClient } = require("./api-client");
+const {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("./snapshot-builder");
+const { collect, collectAndSync } = require("./collector");
+
+module.exports = {
+  createXhsCookiesExtension,
+  XHS_COOKIES_REMOTE_PATH,
+  XHS_COOKIE_HOST_DOMAIN,
+  XHS_REQUIRED_COOKIES,
+  assembleXhsCookieHeader,
+  computeXsXt,
+  extractA1,
+  XS_PREFIX,
+  XhsApiClient,
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+  collect,
+  collectAndSync,
+};