@chainlesschain/personal-data-hub 0.2.0 → 0.2.2

package/__tests__/adapters/ai-chat-vendors.test.js

@@ -16,6 +16,7 @@ const hunyuanModule = require("../../lib/adapters/ai-chat-history/vendors/hunyua
 const qianfanModule = require("../../lib/adapters/ai-chat-history/vendors/qianfan");
 const cozeModule = require("../../lib/adapters/ai-chat-history/vendors/coze");
 const dreaminaModule = require("../../lib/adapters/ai-chat-history/vendors/dreamina");
+const doubaoModule = require("../../lib/adapters/ai-chat-history/vendors/doubao");
 
 // ─── helpers ─────────────────────────────────────────────────────────────
 
@@ -296,11 +297,11 @@ describe("AIChatHistoryAdapter.sync — wired DeepSeek path E2E", () => {
     const out = [];
     for await (const ev of a.sync({ vendors: ["deepseek"] })) out.push(ev);
     expect(out.length).toBe(3); // 1 conv + 2 msgs
-    expect(out[0].kind).toBe("conversation");
-    expect(out[0].conversation.title).toBe("wired test");
-    expect(out[1].kind).toBe("message");
-    expect(out[1].message.role).toBe("user");
-    expect(out[2].message.role).toBe("assistant");
+    expect(out[0].payload.kind).toBe("conversation");
+    expect(out[0].payload.conversation.title).toBe("wired test");
+    expect(out[1].payload.kind).toBe("message");
+    expect(out[1].payload.message.role).toBe("user");
+    expect(out[2].payload.message.role).toBe("assistant");
 
     // normalize → events / topics
     const batches = out.map((r) => a.normalize(r));
@@ -319,8 +320,8 @@ describe("AIChatHistoryAdapter.sync — wired DeepSeek path E2E", () => {
     const out = [];
     for await (const ev of a.sync({ vendors: ["deepseek"] })) out.push(ev);
     expect(out.length).toBe(1);
-    expect(out[0].kind).toBe("vendor-cookie-expired");
-    expect(out[0].vendor).toBe("deepseek");
+    expect(out[0].payload.kind).toBe("vendor-cookie-expired");
+    expect(out[0].payload.vendor).toBe("deepseek");
   });
 
   it("healthCheck reports per-vendor wired result", async () => {
@@ -712,9 +713,148 @@ describe("Dreamina vendor — Phase 10.2 wiring", () => {
   });
 });
 
+// ─── Doubao 豆包 ────────────────────────────────────────────────────────
+
+function doubaoFixtureClient() {
+  const fixture = makeRoutedFetch([
+    [
+      "/samantha/user/info",
+      makeResponse({ body: { code: 0, data: { user_id: "db-u1" } } }),
+    ],
+    [
+      "/samantha/conversation/list",
+      makeResponse({
+        body: {
+          data: {
+            conversation_list: [
+              {
+                conversation_id: "conv-1",
+                name: "聊聊 Rust",
+                bot_id: "bot-default",
+                bot_name: "豆包",
+                create_time: 1700000000,
+                last_message_time: 1700001000,
+                message_count: 4,
+              },
+            ],
+            has_more: false,
+            cursor: "",
+          },
+        },
+      }),
+    ],
+    [
+      /samantha\/conversation\/conv-1\/message\/list/,
+      makeResponse({
+        body: {
+          data: {
+            message_list: [
+              {
+                id: "m-2",
+                sender_type: 2,
+                content: "Rust 的核心是所有权…",
+                create_time: 1700000060,
+                bot_id: "bot-default",
+              },
+              {
+                id: "m-1",
+                sender_type: 1,
+                content: "讲讲 Rust 的特点",
+                create_time: 1700000050,
+              },
+            ],
+            has_more: false,
+            cursor: "",
+          },
+        },
+      }),
+    ],
+  ]);
+  const clk = makeClock();
+  const httpClient = new HttpClient({
+    vendor: "doubao",
+    rateLimits: { perMinute: 0, minIntervalMs: 0 },
+    fetch: fixture.fetch,
+    sleep: clk.sleep,
+    now: clk.now,
+  });
+  return { httpClient, fixture };
+}
+
+describe("Doubao vendor — Phase 10.2(+) v0.1 scaffold", () => {
+  it("validateCookie returns userId from /samantha/user/info", async () => {
+    const { httpClient } = doubaoFixtureClient();
+    const session = new CookieAuthSession({ vendor: "doubao", cookies: [] });
+    const r = await doubaoModule.SPEC.validateCookie({
+      httpClient,
+      session,
+      vendor: "doubao",
+    });
+    expect(r.ok).toBe(true);
+    expect(r.userId).toBe("db-u1");
+  });
+
+  it("listConversations yields RawConversation with bot_name as modelName", async () => {
+    const { httpClient } = doubaoFixtureClient();
+    const session = new CookieAuthSession({ vendor: "doubao", cookies: [] });
+    const out = [];
+    for await (const c of doubaoModule.SPEC.listConversations({
+      httpClient,
+      session,
+      vendor: "doubao",
+    })) {
+      out.push(c);
+    }
+    expect(out.length).toBe(1);
+    expect(out[0].originalId).toBe("conv-1");
+    expect(out[0].title).toBe("聊聊 Rust");
+    expect(out[0].modelName).toBe("豆包");
+    expect(out[0].extra.botId).toBe("bot-default");
+  });
+
+  it("listMessages sorts messages chronologically + maps numeric sender_type", async () => {
+    const { httpClient } = doubaoFixtureClient();
+    const session = new CookieAuthSession({ vendor: "doubao", cookies: [] });
+    const out = [];
+    for await (const m of doubaoModule.SPEC.listMessages(
+      { httpClient, session, vendor: "doubao" },
+      "conv-1",
+    )) {
+      out.push(m);
+    }
+    expect(out.length).toBe(2);
+    // Re-sorted to chronological even though API returned reverse.
+    expect(out[0].originalId).toBe("m-1");
+    expect(out[0].role).toBe("user");
+    expect(out[0].content.text).toBe("讲讲 Rust 的特点");
+    expect(out[1].originalId).toBe("m-2");
+    expect(out[1].role).toBe("assistant");
+  });
+
+  it("_normalizeRole handles numeric + string + uppercase sender_type", () => {
+    const { _normalizeRole } = doubaoModule._internal;
+    expect(_normalizeRole(1)).toBe("user");
+    expect(_normalizeRole("2")).toBe("assistant");
+    expect(_normalizeRole("SYSTEM")).toBe("system");
+    expect(_normalizeRole("assistant")).toBe("assistant");
+  });
+
+  it("_extractConvList absorbs alternate response field names", () => {
+    const { _extractConvList, _extractMsgList } = doubaoModule._internal;
+    expect(_extractConvList({ data: { conversations: [{ id: 1 }] } })).toEqual([
+      { id: 1 },
+    ]);
+    expect(_extractConvList({ data: { list: [{ id: 2 }] } })).toEqual([{ id: 2 }]);
+    expect(_extractMsgList({ data: { messages: [{ id: "x" }] } })).toEqual([
+      { id: "x" },
+    ]);
+    expect(_extractMsgList({})).toEqual([]);
+  });
+});
+
 // ─── Spec contract still valid after wiring ──────────────────────────────
 
-describe("vendor spec post-wire smoke (8/8 vendors live)", () => {
+describe("vendor spec post-wire smoke (9 vendors total — 8 live + doubao scaffold)", () => {
   it.each([
     "deepseek",
     "kimi",
@@ -724,6 +864,7 @@ describe("vendor spec post-wire smoke (8/8 vendors live)", () => {
     "qianfan",
     "coze",
     "dreamina",
+    "doubao",
   ])("%s spec still has correct shape", (v) => {
     expect(DEFAULT_VENDOR_SPECS[v].name).toBe(v);
     expect(typeof DEFAULT_VENDOR_SPECS[v].listConversations).toBe("function");

package/__tests__/adapters/social-toutiao-kuaishou-scaffold.test.js

@@ -0,0 +1,269 @@
+/**
+ * Phase 13.8+13.9 — Toutiao 今日头条 + Kuaishou 快手 v0.1 scaffold tests.
+ *
+ * Tests are intentionally focused on scaffold-quality guarantees:
+ *   - Adapter contract conformance (assertAdapter ok)
+ *   - Account validation (rejects missing uid)
+ *   - sync() yields raw rows per `kind` from mocked SQLite driver
+ *   - normalize() produces valid UnifiedSchema events with correct subtype
+ *
+ * Field-level assertions intentionally avoided — schema is待 fixture pin
+ * in Phase 13.10 (real-device E2E).
+ */
+
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const { ToutiaoAdapter, KuaishouAdapter } = require("../../lib");
+const { assertAdapter } = require("../../lib/adapter-spec");
+const { validateBatch } = require("../../lib/batch");
+
+function makeMockDriver(scriptedRows) {
+  return function () {
+    return {
+      prepare(sql) {
+        return {
+          all() {
+            for (const [matchSubstr, rows] of scriptedRows) {
+              if (sql.includes(matchSubstr)) return rows;
+            }
+            throw new Error("no such table");
+          },
+        };
+      },
+      close() {},
+    };
+  };
+}
+
+function withFakeDb(fn) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pdh-scaffold-"));
+  const dbPath = path.join(dir, "fake.db");
+  fs.writeFileSync(dbPath, "fake");
+  return fn(dbPath);
+}
+
+// ─── ToutiaoAdapter ─────────────────────────────────────────────────────
+
+describe("ToutiaoAdapter — Phase 13.8(+) v0.1 scaffold", () => {
+  it("contract conformance + sensitivity high (news reading reveals political/medical interest)", () => {
+    const a = new ToutiaoAdapter({ account: { uid: "u-1" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.name).toBe("social-toutiao");
+    expect(a.extractMode).toBe("device-pull");
+    expect(a.dataDisclosure.sensitivity).toBe("high");
+  });
+
+  it("rejects missing account.uid", () => {
+    expect(() => new ToutiaoAdapter({})).toThrow();
+    expect(() => new ToutiaoAdapter({ account: {} })).toThrow(/uid/);
+  });
+
+  it("sync yields read + collection + search raws via mocked driver", async () => {
+    await withFakeDb(async (dbPath) => {
+      const driver = makeMockDriver([
+        [
+          "FROM read_history",
+          [
+            { id: 1, item_id: "i-1", title: "新闻 A", read_time: 1700000000, category: "tech" },
+            { id: 2, item_id: "i-2", title: "新闻 B", read_time: 1700000010, category: "finance" },
+          ],
+        ],
+        [
+          "FROM collection_article",
+          [{ id: 1, item_id: "i-3", article_title: "深度长文", save_time: 1700001000 }],
+        ],
+        [
+          "FROM search_history",
+          [{ id: 1, keyword: "Rust 语言", search_time: 1700002000 }],
+        ],
+      ]);
+      const a = new ToutiaoAdapter({
+        account: { uid: "u-1" },
+        dbPath,
+        dbDriverFactory: () => driver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(4);
+      expect(raws.filter((r) => r.payload.kind === "read")).toHaveLength(2);
+      expect(raws.filter((r) => r.payload.kind === "collection")).toHaveLength(1);
+      expect(raws.filter((r) => r.payload.kind === "search")).toHaveLength(1);
+    });
+  });
+
+  it("normalize maps read → browse / collection → like / search → post (all subtypes valid)", async () => {
+    const a = new ToutiaoAdapter({ account: { uid: "u-1" } });
+    const samples = [
+      {
+        kind: "read",
+        row: { id: 1, item_id: "i-1", title: "T1", read_time: 1700000000, category: "tech" },
+        expectedSubtype: "browse",
+      },
+      {
+        kind: "collection",
+        row: { id: 1, item_id: "i-2", article_title: "T2", save_time: 1700001000 },
+        expectedSubtype: "like",
+      },
+      {
+        kind: "search",
+        row: { id: 1, keyword: "Rust", search_time: 1700002000 },
+        expectedSubtype: "post",
+      },
+    ];
+    for (const s of samples) {
+      const batch = a.normalize({
+        adapter: "social-toutiao",
+        originalId: `${s.kind}-${s.row.id}`,
+        capturedAt: Date.now(),
+        payload: { row: s.row, kind: s.kind },
+      });
+      const v = validateBatch(batch);
+      expect(v.valid).toBe(true);
+      expect(batch.events[0].subtype).toBe(s.expectedSubtype);
+      expect(batch.events[0].source.adapter).toBe("social-toutiao");
+    }
+  });
+
+  it("normalize throws on missing payload.row (validator-friendly)", () => {
+    const a = new ToutiaoAdapter({ account: { uid: "u-1" } });
+    expect(() => a.normalize({ payload: {} })).toThrow(/row missing/);
+  });
+
+  it("search keyword preserved verbatim in content.title + extra.keyword", () => {
+    const a = new ToutiaoAdapter({ account: { uid: "u-1" } });
+    const batch = a.normalize({
+      adapter: "social-toutiao",
+      originalId: "search-1",
+      capturedAt: 1700002000_000,
+      payload: { row: { id: 1, keyword: "新冠 后遗症", search_time: 1700002000 }, kind: "search" },
+    });
+    expect(batch.events[0].content.title).toBe("新冠 后遗症");
+    expect(batch.events[0].extra.kind).toBe("search");
+    expect(batch.events[0].extra.keyword).toBe("新冠 后遗症");
+  });
+
+  it("sync gracefully exits when dbPath missing", async () => {
+    const a = new ToutiaoAdapter({ account: { uid: "u-1" }, dbPath: "/no/such/path.db" });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    expect(raws).toEqual([]);
+  });
+});
+
+// ─── KuaishouAdapter ────────────────────────────────────────────────────
+
+describe("KuaishouAdapter — Phase 13.9(+) v0.1 scaffold", () => {
+  it("contract conformance + sensitivity medium (entertainment preference)", () => {
+    const a = new KuaishouAdapter({ account: { uid: "u-2" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.name).toBe("social-kuaishou");
+    expect(a.extractMode).toBe("device-pull");
+    expect(a.dataDisclosure.sensitivity).toBe("medium");
+  });
+
+  it("rejects missing account.uid", () => {
+    expect(() => new KuaishouAdapter({})).toThrow();
+    expect(() => new KuaishouAdapter({ account: {} })).toThrow(/uid/);
+  });
+
+  it("sync yields watch + collect + search raws via mocked driver", async () => {
+    await withFakeDb(async (dbPath) => {
+      const driver = makeMockDriver([
+        [
+          "FROM photo_history",
+          [
+            {
+              id: 1,
+              photo_id: "p-1",
+              caption: "搞笑视频",
+              view_time: 1700000000,
+              duration: 30,
+              author_name: "UpA",
+            },
+          ],
+        ],
+        [
+          "FROM user_collect",
+          [{ id: 1, photo_id: "p-2", caption: "美食 vlog", collect_time: 1700001000 }],
+        ],
+        [
+          "FROM search_record",
+          [{ id: 1, keyword: "广场舞", search_time: 1700002000 }],
+        ],
+      ]);
+      const a = new KuaishouAdapter({
+        account: { uid: "u-2" },
+        dbPath,
+        dbDriverFactory: () => driver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3);
+      expect(raws.filter((r) => r.payload.kind === "watch")).toHaveLength(1);
+      expect(raws.filter((r) => r.payload.kind === "collect")).toHaveLength(1);
+      expect(raws.filter((r) => r.payload.kind === "search")).toHaveLength(1);
+    });
+  });
+
+  it("normalize maps watch → browse / collect → like / search → post (all subtypes valid)", () => {
+    const a = new KuaishouAdapter({ account: { uid: "u-2" } });
+    const samples = [
+      {
+        kind: "watch",
+        row: { id: 1, photo_id: "p-1", caption: "C1", view_time: 1700000000, duration: 30 },
+        expectedSubtype: "browse",
+      },
+      {
+        kind: "collect",
+        row: { id: 1, photo_id: "p-2", caption: "C2", collect_time: 1700001000 },
+        expectedSubtype: "like",
+      },
+      {
+        kind: "search",
+        row: { id: 1, keyword: "广场舞", search_time: 1700002000 },
+        expectedSubtype: "post",
+      },
+    ];
+    for (const s of samples) {
+      const batch = a.normalize({
+        adapter: "social-kuaishou",
+        originalId: `${s.kind}-${s.row.id}`,
+        capturedAt: Date.now(),
+        payload: { row: s.row, kind: s.kind },
+      });
+      const v = validateBatch(batch);
+      expect(v.valid).toBe(true);
+      expect(batch.events[0].subtype).toBe(s.expectedSubtype);
+      expect(batch.events[0].source.adapter).toBe("social-kuaishou");
+    }
+  });
+
+  it("watch event extra carries photoId + duration + authorName", () => {
+    const a = new KuaishouAdapter({ account: { uid: "u-2" } });
+    const batch = a.normalize({
+      adapter: "social-kuaishou",
+      originalId: "watch-1",
+      capturedAt: 1700000000_000,
+      payload: {
+        row: {
+          id: 1,
+          photo_id: "p-1",
+          caption: "美食",
+          view_time: 1700000000,
+          duration: 60,
+          author_name: "FoodVlogger",
+        },
+        kind: "watch",
+      },
+    });
+    expect(batch.events[0].extra.photoId).toBe("p-1");
+    expect(batch.events[0].extra.duration).toBe(60);
+    expect(batch.events[0].extra.authorName).toBe("FoodVlogger");
+  });
+});

package/__tests__/adapters/system-data-android-ingest.test.js

@@ -0,0 +1,144 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtempSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const {
+  SystemDataAndroidAdapter,
+  ingestSystemDataAndroidSnapshot,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/system-data-android");
+
+/**
+ * Tests for the Path C ingest helper — staging-file write + syncAdapter call
+ * + cleanup. Uses a fake hub.registry that proxies to a real
+ * SystemDataAndroidAdapter so we exercise both halves of the pipeline (the
+ * adapter's _syncViaSnapshot does fs.readFileSync of the staging path we
+ * wrote, then the helper unlinks it after).
+ */
+
+let tmpHubDir;
+let hub;
+
+beforeEach(() => {
+  tmpHubDir = mkdtempSync(join(tmpdir(), "pdh-ingest-"));
+  const adapter = new SystemDataAndroidAdapter();
+  hub = {
+    hubDir: tmpHubDir,
+    registry: {
+      syncAdapter: vi.fn(async (name, opts) => {
+        // Mimic what the real hub does: run the adapter's sync against the
+        // staging path the helper wrote.
+        const out = { adapter: name, ingested: 0, partitions: {} };
+        for await (const raw of adapter.sync(opts)) {
+          out.ingested += 1;
+          if (raw.kind === "contact")
+            out.partitions.contacts = { ingested: (out.partitions.contacts?.ingested || 0) + 1 };
+          if (raw.kind === "app")
+            out.partitions.apps = { ingested: (out.partitions.apps?.ingested || 0) + 1 };
+        }
+        return out;
+      }),
+    },
+  };
+});
+
+afterEach(() => {
+  rmSync(tmpHubDir, { recursive: true, force: true });
+});
+
+describe("ingestSystemDataAndroidSnapshot", () => {
+  it("writes staging file, runs syncAdapter, cleans up", async () => {
+    const snapshot = {
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      snapshottedAt: 1_700_000_000_000,
+      contacts: [
+        { lookupKey: "ck-1", displayName: "妈妈", phones: ["13800000001"] },
+      ],
+      apps: [{ packageName: "com.tencent.mm", label: "微信" }],
+    };
+
+    const report = await ingestSystemDataAndroidSnapshot(hub, snapshot);
+
+    expect(report.adapter).toBe("system-data-android");
+    expect(report.ingested).toBe(2); // 1 contact + 1 app
+
+    // syncAdapter was called with an inputPath under <hubDir>/staging/
+    expect(hub.registry.syncAdapter).toHaveBeenCalledTimes(1);
+    const [name, opts] = hub.registry.syncAdapter.mock.calls[0];
+    expect(name).toBe("system-data-android");
+    expect(opts.inputPath).toContain(join(tmpHubDir, "staging"));
+    expect(opts.inputPath).toMatch(/system-data-android-\d+.+\.json$/);
+
+    // Staging file was cleaned up afterwards
+    expect(existsSync(opts.inputPath)).toBe(false);
+  });
+
+  it("rejects snapshot with mismatched schemaVersion", async () => {
+    await expect(
+      ingestSystemDataAndroidSnapshot(hub, {
+        schemaVersion: 99,
+        snapshottedAt: 0,
+        contacts: [],
+        apps: [],
+      }),
+    ).rejects.toThrow(/schemaVersion 99/);
+  });
+
+  it("rejects missing hub.hubDir", async () => {
+    await expect(
+      ingestSystemDataAndroidSnapshot(
+        { registry: hub.registry },
+        { schemaVersion: SNAPSHOT_SCHEMA_VERSION, snapshottedAt: 0, contacts: [], apps: [] },
+      ),
+    ).rejects.toThrow(/hubDir/);
+  });
+
+  it("rejects missing snapshot payload", async () => {
+    await expect(
+      ingestSystemDataAndroidSnapshot(hub, null),
+    ).rejects.toThrow(/snapshot payload required/);
+  });
+
+  it("cleans up staging file even when syncAdapter throws", async () => {
+    hub.registry.syncAdapter = vi.fn(async () => {
+      throw new Error("simulated sync failure");
+    });
+    let leaked = null;
+    try {
+      await ingestSystemDataAndroidSnapshot(hub, {
+        schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+        snapshottedAt: 0,
+        contacts: [{ lookupKey: "x", displayName: "X" }],
+        apps: [],
+      });
+    } catch (_e) {
+      // expected
+    }
+    leaked = hub.registry.syncAdapter.mock.calls[0]?.[1]?.inputPath;
+    expect(leaked).toBeTruthy();
+    expect(existsSync(leaked)).toBe(false);
+  });
+
+  it("staging file contains the snapshot JSON we passed in", async () => {
+    // Capture path before syncAdapter unlinks it
+    let captured = null;
+    hub.registry.syncAdapter = vi.fn(async (_name, opts) => {
+      captured = readFileSync(opts.inputPath, "utf-8");
+      return { adapter: "system-data-android", ingested: 0 };
+    });
+    const snapshot = {
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      snapshottedAt: 1_700_000_000_000,
+      contacts: [{ lookupKey: "ck-test", displayName: "Test" }],
+      apps: [],
+    };
+    await ingestSystemDataAndroidSnapshot(hub, snapshot);
+    expect(captured).toBeTruthy();
+    const parsed = JSON.parse(captured);
+    expect(parsed.schemaVersion).toBe(SNAPSHOT_SCHEMA_VERSION);
+    expect(parsed.contacts[0].lookupKey).toBe("ck-test");
+  });
+});