@chainlesschain/personal-data-hub 0.4.29 → 0.4.31

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

@@ -1,276 +0,0 @@
-"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

@@ -1,152 +0,0 @@
-"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);
-  });
-
-  it("falls back to base64-encoded api_ph (v0.3 newer Kuaishou builds)", () => {
-    const b64 = Buffer.from(
-      JSON.stringify({ user_id: "424242" }),
-      "utf-8",
-    ).toString("base64");
-    const map = make([
-      ["kuaishou.web.cp.api_ph", encodeURIComponent(b64)],
-    ]);
-    expect(_internals.pickUidFromCookieMap(map)).toBe("424242");
-  });
-});
-
-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

@@ -1,178 +0,0 @@
-"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();
-  });
-});