@chainlesschain/personal-data-hub 0.3.6 → 0.3.7

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

@@ -0,0 +1,285 @@
+"use strict";
+
+import { describe, it, expect, vi } from "vitest";
+const os = require("node:os");
+
+const {
+  collect,
+  collectAndSync,
+} = require("../../lib/adapters/social-toutiao-adb/collector");
+const {
+  ToutiaoApiClient,
+} = require("../../lib/adapters/social-toutiao-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 };
+}
+
+const HAPPY_RESPONSES = [
+  [
+    "passport/account/info/v2",
+    {
+      body: JSON.stringify({
+        status_code: 0,
+        data: {
+          user_id: "12345",
+          screen_name: "Alice",
+          avatar_url: "https://a/x.jpg",
+        },
+      }),
+    },
+  ],
+  [
+    "api/news/feed/v90",
+    {
+      body: JSON.stringify({
+        data: [{ group_id: "G1", title: "T1", behot_time: 1700000000 }],
+      }),
+    },
+  ],
+  [
+    "article/v2/tab_comments",
+    {
+      body: JSON.stringify({
+        data: [{ group_id: "C1", title: "Saved", behot_time: 1700001000 }],
+      }),
+    },
+  ],
+  [
+    "api/search/content",
+    {
+      body: JSON.stringify({
+        data: { user_search_history: [{ keyword: "kw", time: 1700002000 }] },
+      }),
+    },
+  ],
+];
+
+function makeBridge(invokeResult) {
+  return {
+    invoke: vi.fn(async (method, params) => invokeResult),
+  };
+}
+
+const COOKIE_PAYLOAD = {
+  cookie: "sessionid=abc; passport_uid=12345",
+  uid: "12345",
+  diagnostic: { cookieCount: 2, hadEncrypted: false, cookieNames: ["sessionid", "passport_uid"] },
+};
+
+describe("collect — happy path with signProvider", () => {
+  it("warmUp → signed endpoints → shutdown", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const calls = [];
+    const sign = {
+      warmUp: vi.fn(async (c) => calls.push({ warmUp: c })),
+      signUrl: vi.fn(async (url) => {
+        const u = new URL(String(url));
+        u.searchParams.set("_signature", "BRIDGE_SIG");
+        return u;
+      }),
+      shutdown: vi.fn(async () => calls.push("shutdown")),
+    };
+    const client = new ToutiaoApiClient({
+      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.feed).toBe(1);
+    expect(r.eventCounts.collection).toBe(1);
+    expect(r.eventCounts.search).toBe(1);
+    expect(r.eventCounts.profile).toBe(1);
+    expect(r.signProviderHits).toBe(3); // 3 signed endpoints
+    expect(r.signProviderFallbacks).toBe(0);
+  });
+});
+
+describe("collect — fallback path (no signProvider)", () => {
+  it("3 signed endpoints short-circuit; profile still emitted", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const client = new ToutiaoApiClient({ 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);
+    expect(r.eventCounts.feed).toBe(0); // short-circuit
+    expect(r.eventCounts.collection).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", () => {
+  it("emits empty snapshot with cookie-derived uid + profileFetchFailed=true", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      [
+        "passport/account/info/v2",
+        {
+          body: JSON.stringify({
+            status_code: 1,
+            status_msg: "token expired",
+          }),
+        },
+      ],
+    ]);
+    const client = new ToutiaoApiClient({ fetch: fakeFetch });
+    const r = await collect(makeBridge(COOKIE_PAYLOAD), {
+      apiClient: client,
+      stagingDir: os.tmpdir(),
+    });
+    expect(r.profileFetchFailed).toBe(true);
+    expect(r.uid).toBe("12345"); // from cookie pre-extract
+    expect(r.eventCounts.total).toBe(0);
+    expect(r.lastErrorCode).toBe(1);
+  });
+
+  it("falls back to 'unknown-user' uid when cookie pre-extract also empty", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      [
+        "passport/account/info/v2",
+        { body: JSON.stringify({ status_code: 1, status_msg: "expired" }) },
+      ],
+    ]);
+    const client = new ToutiaoApiClient({ fetch: fakeFetch });
+    const r = await collect(
+      makeBridge({
+        cookie: "sessionid=abc",
+        uid: null,
+        diagnostic: {},
+      }),
+      { apiClient: client, stagingDir: os.tmpdir() },
+    );
+    expect(r.uid).toBe(null);
+    expect(r.profileFetchFailed).toBe(true);
+  });
+});
+
+describe("collect — bridge warmUp failure", () => {
+  it("tolerates warmUp throw (falls through to fallback path)", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const sign = {
+      warmUp: vi.fn(async () => {
+        throw new Error("toutiao.com 403 — anti-bot blocked");
+      }),
+      signUrl: vi.fn(async () => null),
+      shutdown: vi.fn(async () => {}),
+    };
+    const client = new ToutiaoApiClient({
+      fetch: fakeFetch,
+      signProvider: sign,
+    });
+    const r = await collect(makeBridge(COOKIE_PAYLOAD), {
+      apiClient: client,
+      signProvider: sign,
+      stagingDir: os.tmpdir(),
+    });
+    expect(r.profileFetchFailed).toBe(false); // profile uses no _sig
+    expect(r.eventCounts.feed).toBe(0); // signed endpoints fall through
+    expect(client._fallbackHits).toBe(3);
+    expect(sign.shutdown).toHaveBeenCalledOnce();
+  });
+});
+
+describe("collect — malformed bridge payload", () => {
+  it("throws when bridge.invoke 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 ToutiaoSignBridge {
+      constructor() {
+        this.warmUp = vi.fn(async () => {});
+        this.signUrl = vi.fn(async (url) => {
+          const u = new URL(String(url));
+          u.searchParams.set("_signature", "X");
+          return u;
+        });
+        this.shutdown = vi.fn(async () => {});
+      }
+    }
+    const sign = new ToutiaoSignBridge();
+    const client = new ToutiaoApiClient({
+      fetch: fakeFetch,
+      signProvider: sign,
+    });
+    const r = await collect(makeBridge(COOKIE_PAYLOAD), {
+      apiClient: client,
+      signProvider: sign,
+      stagingDir: os.tmpdir(),
+    });
+    expect(r.signProviderUsed).toBe("ToutiaoSignBridge");
+  });
+
+  it("reports 'none' when no bridge", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const client = new ToutiaoApiClient({ fetch: fakeFetch });
+    const r = await collect(makeBridge(COOKIE_PAYLOAD), {
+      apiClient: client,
+      stagingDir: os.tmpdir(),
+    });
+    expect(r.signProviderUsed).toBe("none");
+  });
+});
+
+describe("collectAndSync", () => {
+  it("orchestrates collect + registry.syncAdapter + cleanup", async () => {
+    const { fakeFetch } = makeFakeFetch(HAPPY_RESPONSES);
+    const client = new ToutiaoApiClient({ 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-toutiao",
+      expect.objectContaining({ inputPath: expect.stringContaining(".json") }),
+    );
+    expect(r.adapter).toBe("social-toutiao");
+    expect(r.toutiao.uid).toBe("12345");
+    expect(r.toutiao.eventCounts.profile).toBe(1);
+  });
+});

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

@@ -0,0 +1,163 @@
+"use strict";
+
+import { describe, it, expect, vi } from "vitest";
+
+const {
+  createToutiaoCookiesExtension,
+  TOUTIAO_COOKIES_REMOTE_PATH,
+  TOUTIAO_COOKIE_HOST_DOMAIN,
+  TOUTIAO_SESSION_COOKIES,
+  TOUTIAO_UID_COOKIES,
+  assembleToutiaoCookieHeader,
+  _internals,
+} = require("../../lib/adapters/social-toutiao-adb/cookies-extension");
+
+describe("constants", () => {
+  it("path points to com.ss.android.article.news WebView cookies", () => {
+    expect(TOUTIAO_COOKIES_REMOTE_PATH).toBe(
+      "/data/data/com.ss.android.article.news/app_webview/Default/Cookies",
+    );
+  });
+
+  it("host domain is toutiao.com", () => {
+    expect(TOUTIAO_COOKIE_HOST_DOMAIN).toBe("toutiao.com");
+  });
+
+  it("session cookies enumerated (lenient — sessionid OR sessionid_ss)", () => {
+    expect([...TOUTIAO_SESSION_COOKIES]).toEqual(["sessionid", "sessionid_ss"]);
+  });
+
+  it("uid cookie candidates in priority order", () => {
+    expect([...TOUTIAO_UID_COOKIES]).toEqual([
+      "passport_uid",
+      "multi_sids",
+      "__ac_uid",
+      "tt_uid",
+    ]);
+  });
+});
+
+describe("pickUidFromCookieMap", () => {
+  const make = (entries) => new Map(entries.map(([k, v]) => [k, { value: v }]));
+
+  it("prefers passport_uid", () => {
+    const map = make([
+      ["passport_uid", "12345"],
+      ["__ac_uid", "99999"],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("12345");
+  });
+
+  it("falls back to multi_sids first segment", () => {
+    const map = make([["multi_sids", "67890:abcd;11111:efgh"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("67890");
+  });
+
+  it("falls back to __ac_uid when passport + multi missing", () => {
+    const map = make([["__ac_uid", "555"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("555");
+  });
+
+  it("falls back to tt_uid (legacy) when above missing", () => {
+    const map = make([["tt_uid", "777"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("777");
+  });
+
+  it("returns null for '0' values (guest sentinel)", () => {
+    const map = make([
+      ["passport_uid", "0"],
+      ["__ac_uid", "0"],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe(null);
+  });
+
+  it("returns null for non-numeric values", () => {
+    const map = make([["passport_uid", "notnumeric"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe(null);
+  });
+
+  it("returns null when none of the uid candidates present", () => {
+    const map = make([["sessionid", "abc"]]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe(null);
+  });
+});
+
+describe("assembleToutiaoCookieHeader", () => {
+  const mkCookie = (name, value, hostKey = ".toutiao.com") => ({
+    name,
+    value,
+    hostKey,
+  });
+
+  it("builds header from a session + uid cookie", () => {
+    const cookies = [
+      mkCookie("sessionid", "sessabc"),
+      mkCookie("passport_uid", "12345"),
+    ];
+    const r = assembleToutiaoCookieHeader(cookies);
+    expect(r.header).toContain("sessionid=sessabc");
+    expect(r.header).toContain("passport_uid=12345");
+    expect(r.uid).toBe("12345");
+    expect(r.missing).toEqual([]);
+  });
+
+  it("succeeds with only sessionid_ss (no sessionid)", () => {
+    const cookies = [
+      mkCookie("sessionid_ss", "altsess"),
+      mkCookie("passport_uid", "999"),
+    ];
+    const r = assembleToutiaoCookieHeader(cookies);
+    expect(r.header).toContain("sessionid_ss=altsess");
+    expect(r.uid).toBe("999");
+    expect(r.missing).toEqual([]);
+  });
+
+  it("returns null header when no session cookie present", () => {
+    const cookies = [mkCookie("passport_uid", "12345")];
+    const r = assembleToutiaoCookieHeader(cookies);
+    expect(r.header).toBe(null);
+    expect(r.uid).toBe(null);
+    expect(r.missing).toEqual(["sessionid", "sessionid_ss"]);
+  });
+
+  it("succeeds without any uid cookie (uid=null, fetchProfile fills later)", () => {
+    const cookies = [
+      mkCookie("sessionid", "sess"),
+      mkCookie("ttwid", "anonid"),
+    ];
+    const r = assembleToutiaoCookieHeader(cookies);
+    expect(r.header).toContain("sessionid=sess");
+    expect(r.uid).toBe(null);
+    expect(r.missing).toEqual([]);
+  });
+
+  it("dedupes by longest hostKey when same name appears twice", () => {
+    const cookies = [
+      mkCookie("sessionid", "subdomain-val", "www.toutiao.com"),
+      mkCookie("sessionid", "wildcard-val", ".toutiao.com"),
+      mkCookie("passport_uid", "1"),
+    ];
+    const r = assembleToutiaoCookieHeader(cookies);
+    // www.toutiao.com (16 chars) > .toutiao.com (12 chars) — longest wins
+    expect(r.header).toContain("sessionid=subdomain-val");
+  });
+
+  it("throws TypeError on non-array input", () => {
+    expect(() => assembleToutiaoCookieHeader(null)).toThrow(TypeError);
+    expect(() => assembleToutiaoCookieHeader("string")).toThrow(TypeError);
+  });
+});
+
+describe("createToutiaoCookiesExtension", () => {
+  it("rejects when ctx missing required functions", async () => {
+    const ext = createToutiaoCookiesExtension();
+    await expect(ext({}, {})).rejects.toThrow(/ctx must provide/);
+  });
+
+  it("rejects when ctx.adb is not a function", async () => {
+    const ext = createToutiaoCookiesExtension();
+    await expect(
+      ext({}, { adb: null, pickDevice: () => "serial" }),
+    ).rejects.toThrow(/ctx must provide/);
+  });
+});

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

@@ -0,0 +1,196 @@
+"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-toutiao-adb/snapshot-builder");
+
+describe("SNAPSHOT_SCHEMA_VERSION", () => {
+  it("is 1 (matches existing social-toutiao 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 when input.profile given", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      profile: {
+        nickname: "Alice",
+        avatarUrl: "https://a/x.jpg",
+        mobile: "138****",
+        followingCount: 10,
+        followerCount: 99,
+        mediaId: "5678",
+      },
+      snapshottedAt: 1716383021000,
+    });
+    expect(snap.schemaVersion).toBe(1);
+    expect(snap.account).toEqual({ uid: "12345", displayName: "" });
+    const profileEvents = snap.events.filter((e) => e.kind === "profile");
+    expect(profileEvents).toHaveLength(1);
+    expect(profileEvents[0]).toMatchObject({
+      kind: "profile",
+      id: "profile-12345",
+      uid: "12345",
+      nickname: "Alice",
+      followingCount: 10,
+      followerCount: 99,
+      mediaId: "5678",
+    });
+  });
+
+  it("skips profile event when input.profile missing", () => {
+    const snap = buildSnapshot({ uid: "12345" });
+    expect(snap.events.filter((e) => e.kind === "profile")).toHaveLength(0);
+  });
+
+  it("emits read events from feed input", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      feed: [
+        {
+          itemId: "G1",
+          title: "Read 1",
+          category: "tech",
+          author: "AuthorA",
+          publishedAt: 1716000000000,
+          readDuration: 60,
+          source: "source-a",
+        },
+      ],
+    });
+    const reads = snap.events.filter((e) => e.kind === "read");
+    expect(reads).toHaveLength(1);
+    expect(reads[0]).toMatchObject({
+      kind: "read",
+      id: "read-G1",
+      capturedAt: 1716000000000,
+      itemId: "G1",
+      title: "Read 1",
+      category: "tech",
+      author: "AuthorA",
+      readDuration: 60,
+      source: "source-a",
+    });
+  });
+
+  it("emits collection events", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      collection: [
+        {
+          itemId: "C1",
+          title: "Saved",
+          category: "news",
+          author: "AuthorB",
+          savedAt: 1716100000000,
+        },
+      ],
+    });
+    const cols = snap.events.filter((e) => e.kind === "collection");
+    expect(cols).toHaveLength(1);
+    expect(cols[0]).toMatchObject({
+      kind: "collection",
+      id: "collect-C1",
+      capturedAt: 1716100000000,
+      itemId: "C1",
+      title: "Saved",
+      category: "news",
+      author: "AuthorB",
+    });
+  });
+
+  it("emits search events with keyword as id base", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      search: [{ keyword: "AI", searchedAt: 1716200000000 }],
+    });
+    const searches = snap.events.filter((e) => e.kind === "search");
+    expect(searches).toHaveLength(1);
+    expect(searches[0]).toMatchObject({
+      kind: "search",
+      id: "search-AI:1716200000000",
+      capturedAt: 1716200000000,
+      keyword: "AI",
+      searchAt: 1716200000000,
+    });
+  });
+
+  it("ignores search entries with empty keyword", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      search: [{ keyword: "", searchedAt: 1 }, { keyword: "ok", searchedAt: 2 }],
+    });
+    const searches = snap.events.filter((e) => e.kind === "search");
+    expect(searches).toHaveLength(1);
+    expect(searches[0].keyword).toBe("ok");
+  });
+
+  it("falls back to snapshottedAt when event lacks timestamp", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      feed: [{ itemId: "G", title: "T" }],
+      snapshottedAt: 1716000000000,
+    });
+    expect(snap.events[0].capturedAt).toBe(1716000000000);
+  });
+
+  it("emits multiple kinds at once with stable id formats", () => {
+    const snap = buildSnapshot({
+      uid: "12345",
+      profile: { nickname: "Alice" },
+      feed: [{ itemId: "G1", title: "T1" }],
+      collection: [{ itemId: "C1", title: "T2" }],
+      search: [{ keyword: "kw1", searchedAt: 1 }],
+    });
+    expect(snap.events).toHaveLength(4);
+    const ids = snap.events.map((e) => e.id);
+    expect(ids).toContain("profile-12345");
+    expect(ids).toContain("read-G1");
+    expect(ids).toContain("collect-C1");
+    expect(ids).toContain("search-kw1:1");
+  });
+});
+
+describe("writeSnapshotJson + cleanupSnapshotJson", () => {
+  it("writes valid JSON to staging dir", () => {
+    const snap = buildSnapshot({ uid: "1", profile: { nickname: "A" } });
+    const fullPath = writeSnapshotJson(snap);
+    try {
+      expect(fs.existsSync(fullPath)).toBe(true);
+      const round = JSON.parse(fs.readFileSync(fullPath, "utf-8"));
+      expect(round.account.uid).toBe("1");
+    } finally {
+      cleanupSnapshotJson(fullPath);
+    }
+  });
+
+  it("rejects fileName with path separator", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    expect(() =>
+      writeSnapshotJson(snap, { fileName: "../escape.json" }),
+    ).toThrow(/basename, not a path/);
+    expect(() =>
+      writeSnapshotJson(snap, { fileName: "sub/dir.json" }),
+    ).toThrow(/basename, not a path/);
+  });
+
+  it("cleanupSnapshotJson tolerates missing file", () => {
+    expect(() => cleanupSnapshotJson(null)).not.toThrow();
+    expect(() =>
+      cleanupSnapshotJson(path.join(os.tmpdir(), "nonexistent-x-y-z.json")),
+    ).not.toThrow();
+  });
+});