@chainlesschain/personal-data-hub 0.3.6 → 0.3.8

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

@@ -0,0 +1,196 @@
+"use strict";
+
+/**
+ * Phase 6d (Kuaishou C 路径 — 2026-05-25): end-to-end orchestrator.
+ *
+ *   bridge.invoke("kuaishou.cookies")        ← Phase 6d cookies extension
+ *           │
+ *           ▼  {cookie, uid, diagnostic}
+ *   KuaishouApiClient.fetchProfile           ← cookie parse (no HTTP)
+ *           │
+ *           ▼  ProfileInfo
+ *   signProvider.warmUp(cookie)              ← Phase 6d bridge ready
+ *           │
+ *           ▼
+ *   fetchWatchHistory + fetchProfilePhotos + fetchSearchHistory
+ *           │   (parallel, GraphQL POST + __NS_sig3 + kpf/kpn)
+ *           ▼  3 arrays (partial-failure OK)
+ *   buildSnapshot + writeSnapshotJson        ← schemaVersion=1
+ *           │
+ *           ▼
+ *   registry.syncAdapter("social-kuaishou", { inputPath })
+ *
+ * Mirror of social-toutiao-adb but with GraphQL POST signing + dual
+ * URL/header bridge contract.
+ */
+
+const { KuaishouApiClient } = require("./api-client");
+const {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+} = require("./snapshot-builder");
+
+async function collect(bridge, opts = {}) {
+  if (!bridge || typeof bridge.invoke !== "function") {
+    throw new TypeError(
+      "KuaishouAdbCollector.collect: bridge must expose invoke(method, params)",
+    );
+  }
+  const now = opts.now || Date.now;
+  const signProvider = opts.signProvider || undefined;
+  const client =
+    opts.apiClient || new KuaishouApiClient({ now, signProvider });
+  const limits = opts.limits || {};
+
+  const cookieResult = await bridge.invoke("kuaishou.cookies");
+  if (
+    !cookieResult ||
+    typeof cookieResult.cookie !== "string"
+  ) {
+    throw new Error(
+      "KuaishouAdbCollector.collect: bridge.invoke('kuaishou.cookies') returned malformed payload — got cookie=" +
+        typeof cookieResult?.cookie,
+    );
+  }
+  const { cookie, uid: cookieUid, diagnostic: cookieDiagnostic } = cookieResult;
+
+  if (signProvider && typeof signProvider.warmUp === "function") {
+    try {
+      await signProvider.warmUp(cookie);
+    } catch (e) {
+      client._setLastError(
+        -98,
+        `signProvider warm-up failed: ${e && e.message ? e.message : String(e)}`,
+      );
+    }
+  }
+
+  try {
+    // fetchProfile — pure cookie parse, no HTTP, no _sig.
+    const profile = await client.fetchProfile(cookie);
+    if (!profile) {
+      // Cookie lacks api_ph or parse failed. Emit empty snapshot using
+      // cookie-derived uid (or sentinel).
+      const uid = cookieUid || "unknown-user";
+      const snapshot = buildSnapshot({
+        uid,
+        displayName: opts.displayName,
+        snapshottedAt: now(),
+      });
+      const snapshotPath = writeSnapshotJson(snapshot, { dir: opts.stagingDir });
+      return {
+        snapshotPath,
+        uid: cookieUid,
+        nickname: null,
+        eventCounts: { profile: 0, watch: 0, collect: 0, search: 0, total: 0 },
+        lastErrorCode: client.lastErrorCode,
+        lastErrorMessage: client.lastErrorMessage,
+        cookieDiagnostic: cookieDiagnostic || null,
+        profileFetchFailed: true,
+        signProviderUsed: signProvider
+          ? signProvider.constructor.name
+          : "none",
+        signProviderHits: client._bridgeHits,
+        signProviderFallbacks: client._fallbackHits,
+      };
+    }
+
+    // Parallel 3 signed endpoints — partial failure tolerated.
+    const [watch, collectPosts, search] = await Promise.all([
+      client.fetchWatchHistory(cookie, {
+        limit: Number.isInteger(limits.watch) ? limits.watch : undefined,
+      }),
+      client.fetchProfilePhotos(cookie, profile.uid, {
+        limit: Number.isInteger(limits.collect)
+          ? limits.collect
+          : undefined,
+      }),
+      client.fetchSearchHistory(cookie, {
+        limit: Number.isInteger(limits.search) ? limits.search : undefined,
+      }),
+    ]);
+
+    const snapshot = buildSnapshot({
+      uid: profile.uid,
+      displayName: opts.displayName || profile.nickname,
+      profile,
+      watch,
+      collect: collectPosts,
+      search,
+      snapshottedAt: now(),
+    });
+    const snapshotPath = writeSnapshotJson(snapshot, { dir: opts.stagingDir });
+
+    return {
+      snapshotPath,
+      uid: profile.uid,
+      nickname: profile.nickname,
+      eventCounts: {
+        profile: 1,
+        watch: watch.length,
+        collect: collectPosts.length,
+        search: search.length,
+        total: snapshot.events.length,
+      },
+      lastErrorCode: client.lastErrorCode,
+      lastErrorMessage: client.lastErrorMessage,
+      cookieDiagnostic: cookieDiagnostic || null,
+      profileFetchFailed: false,
+      signProviderUsed: signProvider ? signProvider.constructor.name : "none",
+      signProviderHits: client._bridgeHits,
+      signProviderFallbacks: client._fallbackHits,
+    };
+  } finally {
+    if (signProvider && typeof signProvider.shutdown === "function") {
+      try {
+        await signProvider.shutdown();
+      } catch (_e) {
+        // Best-effort
+      }
+    }
+  }
+}
+
+async function collectAndSync(bridge, registry, opts = {}) {
+  if (!registry || typeof registry.syncAdapter !== "function") {
+    throw new TypeError(
+      "KuaishouAdbCollector.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-kuaishou", {
+      inputPath: collectResult.snapshotPath,
+    });
+  } finally {
+    try {
+      cleanupSnapshotJson(collectResult.snapshotPath);
+    } catch (_e) {
+      cleanupFailed = true;
+    }
+  }
+  return {
+    ...syncReport,
+    kuaishou: {
+      uid: collectResult.uid,
+      nickname: collectResult.nickname,
+      eventCounts: collectResult.eventCounts,
+      lastErrorCode: collectResult.lastErrorCode,
+      lastErrorMessage: collectResult.lastErrorMessage,
+      cookieDiagnostic: collectResult.cookieDiagnostic,
+      profileFetchFailed: collectResult.profileFetchFailed,
+      signProviderUsed: collectResult.signProviderUsed,
+      signProviderHits: collectResult.signProviderHits,
+      signProviderFallbacks: collectResult.signProviderFallbacks,
+      cleanupFailed,
+    },
+  };
+}
+
+module.exports = {
+  collect,
+  collectAndSync,
+};

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

@@ -0,0 +1,261 @@
+"use strict";
+
+/**
+ * Phase 6d (Kuaishou C 路径 — 2026-05-25): kuaishou.cookies ADB extension factory.
+ *
+ * Mirror of `social-toutiao-adb/cookies-extension.js` (P6c). Reads the
+ * Chromium cookies SQLite from Kuaishou Android app (com.smile.gifmaker)
+ * via `su -c base64`. Returns Cookie header + best-effort pre-extracted
+ * uid (from userId direct cookie OR kuaishou.web.cp.api_ph nested JSON).
+ *
+ * **Required cookies**: at least one of `userId` / `kuaishou.web.cp.api_ph`
+ * (login state). The api_ph payload also carries nickname / avatar /
+ * kuaishou_id, so api-client can extract profile from cookie alone — no
+ * HTTP for profile call.
+ *
+ * Returns:
+ *   {
+ *     cookie: string,
+ *     uid: string|null,
+ *     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 KUAISHOU_COOKIES_REMOTE_PATH =
+  "/data/data/com.smile.gifmaker/app_webview/Default/Cookies";
+
+const KUAISHOU_COOKIE_HOST_DOMAIN = "kuaishou.com";
+
+/**
+ * At least one of these must be present for the cookie to be considered
+ * "logged in". userId is the simplest signal; api_ph carries richer
+ * profile data but isn't always written.
+ */
+const KUAISHOU_LOGIN_COOKIES = Object.freeze([
+  "userId",
+  "kuaishou.web.cp.api_ph",
+]);
+
+async function pullCookiesViaSu(adb, serial, opts) {
+  const adbOpts = { serial, timeoutMs: opts?.timeoutMs || 60_000 };
+  const lsOut = await adb(
+    [
+      "shell",
+      "su",
+      "-c",
+      `ls ${KUAISHOU_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(
+      "KUAISHOU_NOT_INSTALLED: " +
+        KUAISHOU_COOKIES_REMOTE_PATH +
+        " not found. Install Kuaishou App (快手 com.smile.gifmaker) + log in once, then open any video to populate the WebView cookies, then retry. Note: 极速版 (com.kuaishou.nebula) uses a different package — only the standard app is supported.",
+    );
+  }
+  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(
+      "KUAISHOU_NO_ROOT: this phone isn't rooted (su returned `" +
+        idLine.substring(0, 60) +
+        "`). Kuaishou release APK isn't debuggable, so root is required to read the Chromium cookies DB.",
+    );
+  }
+  const b64 = await adb(
+    [
+      "shell",
+      "su",
+      "-c",
+      `base64 ${KUAISHOU_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(
+      "KUAISHOU_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(
+      "KUAISHOU_BASE64_PARSE: stream wasn't valid base64 (" +
+        (e.message || String(e)) +
+        ")",
+    );
+  }
+  if (buf.length < 1024) {
+    throw new Error(
+      "KUAISHOU_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(
+      "KUAISHOU_NOT_SQLITE: decoded file lacks `SQLite format 3` magic header",
+    );
+  }
+  const tmpDir = os.tmpdir();
+  const tmpFile = path.join(
+    tmpDir,
+    `cc-kuaishou-cookies-${crypto.randomUUID()}.db`,
+  );
+  fs.writeFileSync(tmpFile, buf);
+  return tmpFile;
+}
+
+/**
+ * Extract uid from a chromium-cookies array. Priority:
+ *   1. Direct `userId` cookie (numeric, !=0)
+ *   2. Nested user_id inside `kuaishou.web.cp.api_ph` URL-encoded JSON
+ */
+function pickUidFromCookieMap(byName) {
+  const direct = byName.get("userId")?.value;
+  if (direct && /^\d+$/.test(direct) && direct !== "0") {
+    return direct;
+  }
+  const cpRaw = byName.get("kuaishou.web.cp.api_ph")?.value;
+  if (cpRaw) {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(cpRaw);
+    } catch {
+      decoded = cpRaw;
+    }
+    // Try nested user_id / uid / userId regex (don't require strict JSON
+    // — api_ph format isn't documented and varies)
+    for (const pat of [
+      /"?user_id"?\s*:\s*"?(\d+)"?/,
+      /"?uid"?\s*:\s*"?(\d+)"?/,
+      /"?userId"?\s*:\s*"?(\d+)"?/,
+    ]) {
+      const m = pat.exec(decoded);
+      if (m && m[1] && m[1] !== "0") {
+        return m[1];
+      }
+    }
+  }
+  return null;
+}
+
+function assembleKuaishouCookieHeader(cookies) {
+  if (!Array.isArray(cookies)) {
+    throw new TypeError(
+      "assembleKuaishouCookieHeader: 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 hasLogin = KUAISHOU_LOGIN_COOKIES.some((n) => byName.has(n));
+  const uid = pickUidFromCookieMap(byName);
+  const present = new Set(byName.keys());
+  if (!hasLogin) {
+    return {
+      header: null,
+      uid: null,
+      present,
+      missing: [...KUAISHOU_LOGIN_COOKIES],
+    };
+  }
+  const header = Array.from(byName.values())
+    .map((c) => `${c.name}=${c.value}`)
+    .join("; ");
+  return { header, uid, present, missing: [] };
+}
+
+function createKuaishouCookiesExtension(factoryOpts = {}) {
+  const timeoutMs = factoryOpts.timeoutMs || 60_000;
+  const onCleanupFailed = factoryOpts.onCleanupFailed || (() => {});
+
+  return async function kuaishouCookiesHandler(_params, ctx) {
+    if (
+      !ctx ||
+      typeof ctx.adb !== "function" ||
+      typeof ctx.pickDevice !== "function"
+    ) {
+      throw new TypeError(
+        "kuaishou.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,
+        KUAISHOU_COOKIE_HOST_DOMAIN,
+      );
+      const cookieCount = cookies.length;
+      const hadEncrypted = (cookies._skippedEncryptedCount || 0) > 0;
+      const { header, uid, missing, present } =
+        assembleKuaishouCookieHeader(cookies);
+      if (header === null) {
+        throw new Error(
+          "KUAISHOU_COOKIES_INCOMPLETE: missing required login cookies " +
+            JSON.stringify(missing) +
+            ". Likely the user logged out, or has never logged in via the Kuaishou app + browsed (open any video to populate WebView). hadEncrypted=" +
+            hadEncrypted +
+            ".",
+        );
+      }
+      return {
+        cookie: header,
+        uid,
+        extractedAt: Date.now(),
+        diagnostic: {
+          cookieCount,
+          hadEncrypted,
+          cookieNames: Array.from(present),
+        },
+      };
+    } finally {
+      if (tmpFile) {
+        try {
+          fs.unlinkSync(tmpFile);
+        } catch (_e) {
+          onCleanupFailed(tmpFile);
+        }
+      }
+    }
+  };
+}
+
+module.exports = {
+  createKuaishouCookiesExtension,
+  KUAISHOU_COOKIES_REMOTE_PATH,
+  KUAISHOU_COOKIE_HOST_DOMAIN,
+  KUAISHOU_LOGIN_COOKIES,
+  assembleKuaishouCookieHeader,
+  _internals: {
+    pullCookiesViaSu,
+    pickUidFromCookieMap,
+  },
+};

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

@@ -0,0 +1,53 @@
+"use strict";
+
+/**
+ * social-kuaishou-adb — Phase 6d (Kuaishou C 路径) entry.
+ *
+ * Desktop ADB pulls Chromium cookies from Kuaishou Android app
+ * (com.smile.gifmaker) via `su -c base64`, then runs Kuaishou web
+ * GraphQL via KuaishouApiClient. Profile comes from cookie's api_ph
+ * payload (no HTTP); 3 signed GraphQL endpoints (visionFeedRecommend /
+ * visionProfilePhotoList / visionSearchPhoto) need __NS_sig3 query
+ * param + kpf/kpn headers. Desktop wiring injects KuaishouSignBridge;
+ * CLI / test contexts use NullSignProvider → signed endpoints short-
+ * circuit with lastErrorCode=-99.
+ *
+ * Pipeline:
+ *   bridge.invoke("kuaishou.cookies") → {cookie, uid}
+ *     → KuaishouApiClient.fetchProfile (cookie parse, no HTTP)
+ *     → fetchWatchHistory + fetchProfilePhotos + fetchSearchHistory
+ *       (signed GraphQL POST, parallel)
+ *     → buildSnapshot + writeSnapshotJson
+ *     → registry.syncAdapter("social-kuaishou", { inputPath })
+ */
+
+const {
+  createKuaishouCookiesExtension,
+  KUAISHOU_COOKIES_REMOTE_PATH,
+  KUAISHOU_COOKIE_HOST_DOMAIN,
+  KUAISHOU_LOGIN_COOKIES,
+  assembleKuaishouCookieHeader,
+} = require("./cookies-extension");
+const { KuaishouApiClient } = require("./api-client");
+const {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("./snapshot-builder");
+const { collect, collectAndSync } = require("./collector");
+
+module.exports = {
+  createKuaishouCookiesExtension,
+  KUAISHOU_COOKIES_REMOTE_PATH,
+  KUAISHOU_COOKIE_HOST_DOMAIN,
+  KUAISHOU_LOGIN_COOKIES,
+  assembleKuaishouCookieHeader,
+  KuaishouApiClient,
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+  collect,
+  collectAndSync,
+};

package/lib/adapters/social-kuaishou-adb/snapshot-builder.js

@@ -0,0 +1,145 @@
+"use strict";
+
+/**
+ * Phase 6d (Kuaishou C 路径 — 2026-05-25): API responses → snapshot JSON.
+ *
+ * Matches the existing `social-kuaishou` adapter's snapshot mode schema
+ * (schemaVersion=1). Kinds: profile / watch / collect / search.
+ *
+ * Kuaishou uid is numeric string. account.uid set verbatim.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const SNAPSHOT_SCHEMA_VERSION = 1;
+
+function buildSnapshot(input) {
+  if (!input || typeof input !== "object") {
+    throw new TypeError("buildSnapshot: input must be an object");
+  }
+  const uid = input.uid;
+  if (typeof uid !== "string" || uid.length === 0) {
+    throw new TypeError("buildSnapshot: input.uid must be a non-empty string");
+  }
+  const snapshottedAt =
+    Number.isFinite(input.snapshottedAt) && input.snapshottedAt > 0
+      ? input.snapshottedAt
+      : Date.now();
+  const account = {
+    uid,
+    displayName: typeof input.displayName === "string" ? input.displayName : "",
+  };
+  const events = [];
+
+  // profile (1 event — adapter normalize() upserts the person record)
+  if (input.profile && typeof input.profile === "object") {
+    const p = input.profile;
+    events.push({
+      kind: "profile",
+      id: `profile-${uid}`,
+      capturedAt: snapshottedAt,
+      uid,
+      nickname: p.nickname || account.displayName,
+      kuaishouId: p.kuaishouId || null,
+      avatarUrl: p.avatarUrl || null,
+      sex: p.sex || null,
+      city: p.city || null,
+      constellation: p.constellation || null,
+      description: p.description || null,
+    });
+  }
+
+  // watch history (recommended-feed dwell items)
+  const watch = Array.isArray(input.watch) ? input.watch : [];
+  watch.forEach((w, idx) => {
+    if (!w || typeof w !== "object" || !w.photoId) return;
+    events.push({
+      kind: "watch",
+      id: `photo-${w.photoId}`,
+      capturedAt:
+        typeof w.viewedAt === "number" && w.viewedAt > 0
+          ? w.viewedAt
+          : snapshottedAt,
+      photoId: w.photoId,
+      caption: w.caption || null,
+      duration: typeof w.duration === "number" ? w.duration : 0,
+      authorId: w.authorId || null,
+      authorName: w.authorName || null,
+    });
+  });
+
+  // collect — own posted photos (KIND_COLLECT semantically: "videos I'm
+  // associated with on Kuaishou"). adapter v0.2.1 mapping intentional.
+  const collect = Array.isArray(input.collect) ? input.collect : [];
+  collect.forEach((c, idx) => {
+    if (!c || typeof c !== "object" || !c.photoId) return;
+    events.push({
+      kind: "collect",
+      id: `collect-${c.photoId}`,
+      capturedAt:
+        typeof c.postedAt === "number" && c.postedAt > 0
+          ? c.postedAt
+          : snapshottedAt,
+      photoId: c.photoId,
+      caption: c.caption || null,
+      authorId: uid, // self-posted
+      authorName: account.displayName || null,
+    });
+  });
+
+  // search history
+  const search = Array.isArray(input.search) ? input.search : [];
+  search.forEach((s, idx) => {
+    if (!s || typeof s !== "object" || !s.keyword) return;
+    events.push({
+      kind: "search",
+      id: `search-${s.keyword}:${s.searchedAt || idx}`,
+      capturedAt:
+        typeof s.searchedAt === "number" && s.searchedAt > 0
+          ? s.searchedAt
+          : snapshottedAt,
+      keyword: s.keyword,
+      searchAt: s.searchedAt || snapshottedAt,
+    });
+  });
+
+  return {
+    schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+    snapshottedAt,
+    account,
+    events,
+  };
+}
+
+function writeSnapshotJson(snapshot, opts = {}) {
+  const dir = opts.dir || os.tmpdir();
+  const fileName =
+    opts.fileName || `cc-kuaishou-snapshot-${crypto.randomUUID()}.json`;
+  if (fileName.includes("/") || fileName.includes("\\")) {
+    throw new Error(
+      "writeSnapshotJson: opts.fileName must be a basename, not a path",
+    );
+  }
+  const full = path.join(dir, fileName);
+  fs.writeFileSync(full, JSON.stringify(snapshot), "utf-8");
+  return full;
+}
+
+function cleanupSnapshotJson(filePath) {
+  if (!filePath) return;
+  try {
+    fs.unlinkSync(filePath);
+  } catch (_e) {
+    // ignore
+  }
+}
+
+module.exports = {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+};