@chainlesschain/personal-data-hub 0.3.1 → 0.3.7

package/__tests__/adapters/social-kuaishou-adb-collector.test.js

@@ -0,0 +1,276 @@
+"use strict";
+
+import { describe, it, expect, vi } from "vitest";
+const os = require("node:os");
+
+const {
+  collect,
+  collectAndSync,
+} = require("../../lib/adapters/social-kuaishou-adb/collector");
+const {
+  KuaishouApiClient,
+} = require("../../lib/adapters/social-kuaishou-adb/api-client");
+
+function makeFakeFetch(responses) {
+  const calls = [];
+  const fakeFetch = async (urlStr, opts) => {
+    calls.push({ url: urlStr, opts });
+    for (const [pattern, payload] of responses) {
+      if (urlStr.includes(pattern)) {
+        const resolved =
+          typeof payload === "function" ? await payload(urlStr, opts) : payload;
+        return {
+          ok: resolved.status == null || resolved.status === 200,
+          status: resolved.status || 200,
+          text: async () => resolved.body,
+        };
+      }
+    }
+    throw new Error("fake fetch: no response for " + urlStr);
+  };
+  return { fakeFetch, calls };
+}
+
+function gqlBody(opName, dataFn) {
+  return async (urlStr, opts) => {
+    const reqBody = JSON.parse(opts.body);
+    if (reqBody.operationName !== opName) {
+      return { body: JSON.stringify({ data: {} }) };
+    }
+    return { body: JSON.stringify({ data: dataFn() }) };
+  };
+}
+
+const HAPPY_RESPONSES = [
+  // Single graphql endpoint — switch on operationName via body inspection
+  [
+    "graphql",
+    async (urlStr, opts) => {
+      const reqBody = JSON.parse(opts.body);
+      let data = {};
+      if (reqBody.operationName === "visionFeedRecommend") {
+        data = {
+          visionFeedRecommend: {
+            feeds: [
+              {
+                photo: { id: "W1", caption: "watched", timestamp: 1700000000 },
+                author: { id: "AUTH", name: "Author" },
+              },
+            ],
+          },
+        };
+      } else if (reqBody.operationName === "visionProfilePhotoList") {
+        data = {
+          visionProfilePhotoList: {
+            feeds: [
+              {
+                photo: { id: "OWN1", caption: "my", timestamp: 1700001000 },
+              },
+            ],
+          },
+        };
+      } else if (reqBody.operationName === "visionSearchPhoto") {
+        data = {
+          visionSearchPhoto: {
+            recentSearchList: [{ keyword: "kw", time: 1700002000 }],
+          },
+        };
+      }
+      return { body: JSON.stringify({ data }) };
+    },
+  ],
+];
+
+const apiPhPayload = encodeURIComponent(
+  JSON.stringify({
+    user_id: "12345",
+    user_name: "Alice",
+  }),
+);
+
+const COOKIE_PAYLOAD = {
+  cookie: `userId=12345; kuaishou.web.cp.api_ph=${apiPhPayload}`,
+  uid: "12345",
+  diagnostic: { cookieCount: 5, hadEncrypted: false, cookieNames: [] },
+};
+
+function makeBridge(invokeResult) {
+  return {
+    invoke: vi.fn(async () => invokeResult),
+  };
+}
+
+describe("collect — happy path with signProvider", () => {
+  it("warmUp → 3 signed endpoints → shutdown", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const lifecycle = [];
+    const sign = {
+      warmUp: vi.fn(async (c) => lifecycle.push({ warmUp: c })),
+      signUrl: vi.fn(async (url) => {
+        const u = new URL(String(url));
+        u.searchParams.set("__NS_sig3", "BRIDGE_SIG");
+        return u;
+      }),
+      signedHeaders: vi.fn(async () => ({
+        kpf: "PC_WEB",
+        kpn: "KUAISHOU_VISION",
+      })),
+      shutdown: vi.fn(async () => lifecycle.push("shutdown")),
+    };
+    const client = new KuaishouApiClient({
+      fetch: fakeFetch,
+      signProvider: sign,
+    });
+    const r = await collect(makeBridge(COOKIE_PAYLOAD), {
+      apiClient: client,
+      signProvider: sign,
+      stagingDir: os.tmpdir(),
+    });
+    expect(sign.warmUp).toHaveBeenCalledWith(COOKIE_PAYLOAD.cookie);
+    expect(sign.shutdown).toHaveBeenCalledOnce();
+    expect(r.uid).toBe("12345");
+    expect(r.nickname).toBe("Alice");
+    expect(r.profileFetchFailed).toBe(false);
+    expect(r.eventCounts.profile).toBe(1);
+    expect(r.eventCounts.watch).toBe(1);
+    expect(r.eventCounts.collect).toBe(1);
+    expect(r.eventCounts.search).toBe(1);
+    expect(r.signProviderHits).toBe(3);
+    expect(r.signProviderFallbacks).toBe(0);
+  });
+});
+
+describe("collect — fallback path (no signProvider)", () => {
+  it("3 signed endpoints short-circuit; profile from cookie still emitted", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const client = new KuaishouApiClient({ fetch: fakeFetch });
+    const r = await collect(makeBridge(COOKIE_PAYLOAD), {
+      apiClient: client,
+      stagingDir: os.tmpdir(),
+    });
+    expect(r.uid).toBe("12345");
+    expect(r.profileFetchFailed).toBe(false);
+    expect(r.eventCounts.profile).toBe(1); // pure cookie parse
+    expect(r.eventCounts.watch).toBe(0); // short-circuit
+    expect(r.eventCounts.collect).toBe(0);
+    expect(r.eventCounts.search).toBe(0);
+    expect(r.signProviderUsed).toBe("none");
+    expect(r.signProviderHits).toBe(0);
+    expect(r.signProviderFallbacks).toBe(3);
+  });
+});
+
+describe("collect — profile fetch fails (no api_ph)", () => {
+  it("emits empty snapshot with cookie-derived uid + profileFetchFailed=true", async () => {
+    const cookiePayload = {
+      cookie: "userId=12345", // no api_ph → fetchProfile fails
+      uid: "12345",
+      diagnostic: {},
+    };
+    const { fakeFetch } = makeFakeFetch([]);
+    const client = new KuaishouApiClient({ fetch: fakeFetch });
+    const r = await collect(makeBridge(cookiePayload), {
+      apiClient: client,
+      stagingDir: os.tmpdir(),
+    });
+    expect(r.profileFetchFailed).toBe(true);
+    expect(r.uid).toBe("12345"); // cookie pre-extract
+    expect(r.eventCounts.total).toBe(0);
+    expect(r.lastErrorCode).toBe(-8);
+  });
+});
+
+describe("collect — bridge warmUp failure", () => {
+  it("tolerates warmUp throw; signed endpoints fall through to short-circuit", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const sign = {
+      warmUp: vi.fn(async () => {
+        throw new Error("kuaishou.com 403");
+      }),
+      signUrl: vi.fn(async () => null),
+      signedHeaders: vi.fn(async () => ({})),
+      shutdown: vi.fn(async () => {}),
+    };
+    const client = new KuaishouApiClient({
+      fetch: fakeFetch,
+      signProvider: sign,
+    });
+    const r = await collect(makeBridge(COOKIE_PAYLOAD), {
+      apiClient: client,
+      signProvider: sign,
+      stagingDir: os.tmpdir(),
+    });
+    expect(r.profileFetchFailed).toBe(false); // profile pure cookie parse
+    expect(r.eventCounts.watch).toBe(0);
+    expect(client._fallbackHits).toBe(3);
+    expect(sign.shutdown).toHaveBeenCalledOnce();
+  });
+});
+
+describe("collect — malformed bridge payload", () => {
+  it("throws when bridge returns no cookie", async () => {
+    const bridge = { invoke: vi.fn(async () => ({ uid: "1" })) };
+    await expect(
+      collect(bridge, { stagingDir: os.tmpdir() }),
+    ).rejects.toThrow(/malformed payload/);
+  });
+
+  it("throws when bridge missing invoke", async () => {
+    await expect(collect({}, {})).rejects.toThrow(
+      /bridge must expose invoke/,
+    );
+  });
+});
+
+describe("collect — signProviderUsed diagnostic", () => {
+  it("reports class name when bridge present", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    class KuaishouSignBridge {
+      constructor() {
+        this.warmUp = vi.fn(async () => {});
+        this.signUrl = vi.fn(async (url) => {
+          const u = new URL(String(url));
+          u.searchParams.set("__NS_sig3", "X");
+          return u;
+        });
+        this.signedHeaders = vi.fn(async () => ({
+          kpf: "PC_WEB",
+          kpn: "KUAISHOU_VISION",
+        }));
+        this.shutdown = vi.fn(async () => {});
+      }
+    }
+    const sign = new KuaishouSignBridge();
+    const client = new KuaishouApiClient({
+      fetch: fakeFetch,
+      signProvider: sign,
+    });
+    const r = await collect(makeBridge(COOKIE_PAYLOAD), {
+      apiClient: client,
+      signProvider: sign,
+      stagingDir: os.tmpdir(),
+    });
+    expect(r.signProviderUsed).toBe("KuaishouSignBridge");
+  });
+});
+
+describe("collectAndSync", () => {
+  it("orchestrates collect + registry.syncAdapter + cleanup", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const client = new KuaishouApiClient({ fetch: fakeFetch });
+    const registry = {
+      syncAdapter: vi.fn(async (name) => ({ adapter: name, status: "ok" })),
+    };
+    const r = await collectAndSync(makeBridge(COOKIE_PAYLOAD), registry, {
+      apiClient: client,
+      stagingDir: os.tmpdir(),
+    });
+    expect(registry.syncAdapter).toHaveBeenCalledWith(
+      "social-kuaishou",
+      expect.objectContaining({ inputPath: expect.stringContaining(".json") }),
+    );
+    expect(r.adapter).toBe("social-kuaishou");
+    expect(r.kuaishou.uid).toBe("12345");
+    expect(r.kuaishou.eventCounts.profile).toBe(1);
+  });
+});

package/__tests__/adapters/social-kuaishou-adb-cookies-extension.test.js

@@ -0,0 +1,141 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  createKuaishouCookiesExtension,
+  KUAISHOU_COOKIES_REMOTE_PATH,
+  KUAISHOU_COOKIE_HOST_DOMAIN,
+  KUAISHOU_LOGIN_COOKIES,
+  assembleKuaishouCookieHeader,
+  _internals,
+} = require("../../lib/adapters/social-kuaishou-adb/cookies-extension");
+
+describe("constants", () => {
+  it("path points to com.smile.gifmaker WebView cookies", () => {
+    expect(KUAISHOU_COOKIES_REMOTE_PATH).toBe(
+      "/data/data/com.smile.gifmaker/app_webview/Default/Cookies",
+    );
+  });
+
+  it("host domain is kuaishou.com", () => {
+    expect(KUAISHOU_COOKIE_HOST_DOMAIN).toBe("kuaishou.com");
+  });
+
+  it("login cookies enumerated (userId OR kuaishou.web.cp.api_ph)", () => {
+    expect([...KUAISHOU_LOGIN_COOKIES]).toEqual([
+      "userId",
+      "kuaishou.web.cp.api_ph",
+    ]);
+  });
+});
+
+describe("pickUidFromCookieMap", () => {
+  const make = (entries) =>
+    new Map(entries.map(([k, v]) => [k, { value: v }]));
+
+  it("prefers direct userId cookie", () => {
+    const map = make([
+      ["userId", "12345"],
+      ["kuaishou.web.cp.api_ph", encodeURIComponent('{"user_id":99999}')],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("12345");
+  });
+
+  it("falls back to api_ph nested user_id", () => {
+    const map = make([
+      ["kuaishou.web.cp.api_ph", encodeURIComponent('{"user_id":"55555"}')],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("55555");
+  });
+
+  it("falls back to api_ph nested uid alternate", () => {
+    const map = make([
+      ["kuaishou.web.cp.api_ph", encodeURIComponent('{"uid":"77777"}')],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("77777");
+  });
+
+  it("handles api_ph not URL-encoded (raw)", () => {
+    const map = make([["kuaishou.web.cp.api_ph", '{"user_id":"33333"}']]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("33333");
+  });
+
+  it("returns null for userId=0 (guest sentinel)", () => {
+    const map = make([["userId", "0"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe(null);
+  });
+
+  it("returns null when only anti-bot cookies present", () => {
+    const map = make([["did", "anonid"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe(null);
+  });
+});
+
+describe("assembleKuaishouCookieHeader", () => {
+  const mkCookie = (name, value, hostKey = ".kuaishou.com") => ({
+    name,
+    value,
+    hostKey,
+  });
+
+  it("builds header from direct userId cookie", () => {
+    const cookies = [
+      mkCookie("userId", "12345"),
+      mkCookie("did", "anon"),
+    ];
+    const r = assembleKuaishouCookieHeader(cookies);
+    expect(r.header).toContain("userId=12345");
+    expect(r.uid).toBe("12345");
+    expect(r.missing).toEqual([]);
+  });
+
+  it("builds header from api_ph alone (no direct userId)", () => {
+    const cookies = [
+      mkCookie(
+        "kuaishou.web.cp.api_ph",
+        encodeURIComponent('{"user_id":"55555","user_name":"Alice"}'),
+      ),
+    ];
+    const r = assembleKuaishouCookieHeader(cookies);
+    expect(r.header).toContain("kuaishou.web.cp.api_ph=");
+    expect(r.uid).toBe("55555");
+    expect(r.missing).toEqual([]);
+  });
+
+  it("returns null header when no login cookie present", () => {
+    const cookies = [mkCookie("did", "anon"), mkCookie("ttwid", "x")];
+    const r = assembleKuaishouCookieHeader(cookies);
+    expect(r.header).toBe(null);
+    expect(r.uid).toBe(null);
+    expect(r.missing).toEqual(["userId", "kuaishou.web.cp.api_ph"]);
+  });
+
+  it("dedupes by longest hostKey when same name appears twice", () => {
+    const cookies = [
+      mkCookie("userId", "subdomain-val", "www.kuaishou.com"),
+      mkCookie("userId", "wildcard-val", ".kuaishou.com"),
+    ];
+    const r = assembleKuaishouCookieHeader(cookies);
+    expect(r.header).toContain("userId=subdomain-val");
+  });
+
+  it("throws TypeError on non-array input", () => {
+    expect(() => assembleKuaishouCookieHeader(null)).toThrow(TypeError);
+    expect(() => assembleKuaishouCookieHeader("x")).toThrow(TypeError);
+  });
+});
+
+describe("createKuaishouCookiesExtension", () => {
+  it("rejects when ctx missing required functions", async () => {
+    const ext = createKuaishouCookiesExtension();
+    await expect(ext({}, {})).rejects.toThrow(/ctx must provide/);
+  });
+
+  it("rejects when adb is not a function", async () => {
+    const ext = createKuaishouCookiesExtension();
+    await expect(
+      ext({}, { adb: null, pickDevice: () => "serial" }),
+    ).rejects.toThrow(/ctx must provide/);
+  });
+});

package/__tests__/adapters/social-kuaishou-adb-snapshot-builder.test.js

@@ -0,0 +1,178 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-kuaishou-adb/snapshot-builder");
+
+describe("SNAPSHOT_SCHEMA_VERSION", () => {
+  it("is 1 (matches existing social-kuaishou adapter)", () => {
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+  });
+});
+
+describe("buildSnapshot", () => {
+  it("throws on missing uid", () => {
+    expect(() => buildSnapshot({})).toThrow(/uid must be a non-empty string/);
+  });
+
+  it("emits profile event from input.profile", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      profile: {
+        nickname: "Alice",
+        kuaishouId: "alice_ks",
+        avatarUrl: "https://a/x.jpg",
+        sex: "F",
+        city: "Beijing",
+      },
+      snapshottedAt: 1716383021000,
+    });
+    expect(snap.schemaVersion).toBe(1);
+    expect(snap.account).toEqual({ uid: "12345", displayName: "" });
+    const prof = snap.events.find((e) => e.kind === "profile");
+    expect(prof).toMatchObject({
+      kind: "profile",
+      id: "profile-12345",
+      uid: "12345",
+      nickname: "Alice",
+      kuaishouId: "alice_ks",
+      city: "Beijing",
+    });
+  });
+
+  it("emits watch events with photo metadata", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      watch: [
+        {
+          photoId: "P1",
+          caption: "Funny vid",
+          duration: 30,
+          authorId: "A1",
+          authorName: "Auth1",
+          viewedAt: 1716000000000,
+        },
+      ],
+    });
+    const w = snap.events.filter((e) => e.kind === "watch");
+    expect(w).toHaveLength(1);
+    expect(w[0]).toMatchObject({
+      kind: "watch",
+      id: "photo-P1",
+      capturedAt: 1716000000000,
+      photoId: "P1",
+      caption: "Funny vid",
+      duration: 30,
+      authorId: "A1",
+      authorName: "Auth1",
+    });
+  });
+
+  it("emits collect events with self as author", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      displayName: "Alice",
+      collect: [{ photoId: "C1", caption: "My vid", postedAt: 1716100000000 }],
+    });
+    const c = snap.events.filter((e) => e.kind === "collect");
+    expect(c).toHaveLength(1);
+    expect(c[0]).toMatchObject({
+      kind: "collect",
+      id: "collect-C1",
+      capturedAt: 1716100000000,
+      photoId: "C1",
+      caption: "My vid",
+      authorId: "12345", // self
+      authorName: "Alice",
+    });
+  });
+
+  it("emits search events with keyword:ts id", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      search: [{ keyword: "AI", searchedAt: 1716200000000 }],
+    });
+    const s = snap.events.find((e) => e.kind === "search");
+    expect(s).toMatchObject({
+      kind: "search",
+      id: "search-AI:1716200000000",
+      capturedAt: 1716200000000,
+      keyword: "AI",
+      searchAt: 1716200000000,
+    });
+  });
+
+  it("ignores entries missing photoId / keyword", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      watch: [{ caption: "no photoId" }, { photoId: "OK" }],
+      collect: [{ caption: "no photoId" }],
+      search: [{ keyword: "" }, { keyword: "good" }],
+    });
+    expect(snap.events.filter((e) => e.kind === "watch")).toHaveLength(1);
+    expect(snap.events.filter((e) => e.kind === "collect")).toHaveLength(0);
+    expect(snap.events.filter((e) => e.kind === "search")).toHaveLength(1);
+  });
+
+  it("falls back to snapshottedAt when event lacks timestamp", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      watch: [{ photoId: "P" }],
+      snapshottedAt: 1716000000000,
+    });
+    expect(snap.events[0].capturedAt).toBe(1716000000000);
+  });
+
+  it("emits all 4 kinds at once", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      profile: { nickname: "Alice" },
+      watch: [{ photoId: "W1" }],
+      collect: [{ photoId: "C1" }],
+      search: [{ keyword: "kw1", searchedAt: 1 }],
+    });
+    expect(snap.events).toHaveLength(4);
+    expect(snap.events.map((e) => e.kind).sort()).toEqual([
+      "collect",
+      "profile",
+      "search",
+      "watch",
+    ]);
+  });
+});
+
+describe("writeSnapshotJson + cleanupSnapshotJson", () => {
+  it("writes valid JSON", () => {
+    const snap = buildSnapshot({ uid: "1", profile: { nickname: "A" } });
+    const full = writeSnapshotJson(snap);
+    try {
+      expect(fs.existsSync(full)).toBe(true);
+      const round = JSON.parse(fs.readFileSync(full, "utf-8"));
+      expect(round.account.uid).toBe("1");
+    } finally {
+      cleanupSnapshotJson(full);
+    }
+  });
+
+  it("rejects fileName with path separator", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    expect(() =>
+      writeSnapshotJson(snap, { fileName: "../escape.json" }),
+    ).toThrow(/basename, not a path/);
+  });
+
+  it("cleanup tolerates missing file", () => {
+    expect(() => cleanupSnapshotJson(null)).not.toThrow();
+    expect(() =>
+      cleanupSnapshotJson(path.join(os.tmpdir(), "nonexistent-ks.json")),
+    ).not.toThrow();
+  });
+});