@chainlesschain/personal-data-hub 0.2.1 → 0.2.2

package/__tests__/adapters/wechat-frida-agent.test.js

@@ -171,6 +171,134 @@ describe("frida-agent — fallback symbol resolution", () => {
   });
 });
 
+describe("frida-agent — sjqz-audit fixes (sig + format + module case)", () => {
+  // Helper extending fakePtr with readCString for ascii-hex tests.
+  function fakeAsciiHexPtr(asciiHex) {
+    return {
+      _v: asciiHex,
+      toInt32() { return 0; },
+      readByteArray(_len) { return new Uint8Array(0).buffer; },
+    };
+  }
+  function memoryReadCString(ptr, _maxLen) {
+    return ptr && typeof ptr._v === "string" ? ptr._v : null;
+  }
+
+  it("attaches when only uppercase libWCDB.so resolves (sjqz canonical name)", () => {
+    const send = vi.fn();
+    const Interceptor = { attach: vi.fn() };
+    const Module = {
+      findExportByName(mod, sym) {
+        return mod === "libWCDB.so" && sym === "sqlite3_key"
+          ? { symbol: sym }
+          : null;
+      },
+    };
+    const Process = {
+      findModuleByName(mod) {
+        return mod === "libWCDB.so" ? { name: mod } : null;
+      },
+    };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    const hooked = send.mock.calls.find((c) => c[0].kind === "hooked");
+    expect(hooked).toBeDefined();
+    expect(hooked[0].module).toBe("libWCDB.so");
+  });
+
+  it("v2 hook reads key from args[2] and length from args[3] (not args[1]/[2])", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const Module = {
+      findExportByName(mod, sym) {
+        return sym === "sqlite3_key_v2" ? { symbol: sym } : null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    // sqlite3_key_v2(sqlite3 *db, const char *zDbName, const void *pKey, int nKey)
+    // args[0]=db, args[1]=name, args[2]=keyBytes, args[3]=len
+    const dbNamePtr = fakePtr("ffeeffeeffeeffeeffeeffeeffeeffee");  // would be wrong if read as key
+    const keyHex = "12345678" + "00".repeat(28);                     // 32 bytes
+    const args = [
+      fakePtr(0),                   // db
+      dbNamePtr,                    // name (NOT the key)
+      fakePtr(keyHex),              // pKey — correct args[2]
+      fakePtr(32),                  // nKey — correct args[3]
+    ];
+    attached.sqlite3_key_v2.onEnter(args);
+
+    const keyEvt = send.mock.calls.find((c) => c[0].kind === "key");
+    expect(keyEvt).toBeDefined();
+    expect(keyEvt[0].hex).toBe(keyHex);           // proves args[2] was read, not args[1]
+    expect(keyEvt[0].sig).toBe("v2");
+    expect(keyEvt[0].format).toBe("raw-bytes");
+    expect(keyEvt[0].length).toBe(32);
+  });
+
+  it("reads ascii-hex key via readCString when length === 64", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const Module = {
+      findExportByName(mod, sym) {
+        return sym === "sqlite3_key" ? { symbol: sym } : null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+    const Memory = { readCString: memoryReadCString };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send, Memory });
+
+    // 64-char ASCII hex string + len=64 → readCString path (sjqz scenario)
+    const asciiHex = "ABCDEF0123456789".repeat(4).toLowerCase();
+    const args = [fakePtr(0), fakeAsciiHexPtr(asciiHex), fakePtr(64)];
+    attached.sqlite3_key.onEnter(args);
+
+    const keyEvt = send.mock.calls.find((c) => c[0].kind === "key");
+    expect(keyEvt).toBeDefined();
+    expect(keyEvt[0].hex).toBe(asciiHex);
+    expect(keyEvt[0].format).toBe("ascii-hex");
+    expect(keyEvt[0].length).toBe(64);
+  });
+
+  it("emits unsupported-signature error for mangled C++ symbol (no host attempt)", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const mangledSymbol =
+      "_ZN4WCDB8Database13setCipherKeyERKNSt6__ndk112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE";
+    const Module = {
+      findExportByName(mod, sym) {
+        return sym === mangledSymbol ? { symbol: sym } : null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    attached[mangledSymbol].onEnter([fakePtr(0), fakePtr("aabb"), fakePtr(32)]);
+
+    const errEvt = send.mock.calls.find(
+      (c) => c[0].kind === "error" && /unsupported symbol signature/.test(c[0].message),
+    );
+    expect(errEvt).toBeDefined();
+    // And NO key event emitted (host must fall back to MD5 path).
+    const keyEvt = send.mock.calls.find((c) => c[0].kind === "key");
+    expect(keyEvt).toBeUndefined();
+  });
+});
+
 describe("frida-agent — module not yet loaded path", () => {
   it("emits module-waiting and schedules retry", () => {
     const send = vi.fn();
@@ -183,7 +311,10 @@ describe("frida-agent — module not yet loaded path", () => {
 
     const waiting = send.mock.calls.find((c) => c[0].kind === "module-waiting");
     expect(waiting).toBeDefined();
-    expect(waiting[0].module).toBe("libwcdb.so");
+    // Post-sjqz audit: agent now tries both libWCDB.so (uppercase, sjqz-verified)
+    // and libwcdb.so. The module-waiting event surfaces the join so the
+    // host telemetry shows both attempted names.
+    expect(waiting[0].module).toBe("libWCDB.so|libwcdb.so");
     expect(setTimeoutMock).toHaveBeenCalled();
     // First retry delay 500ms
     expect(setTimeoutMock.mock.calls[0][1]).toBe(500);

package/__tests__/integration/social-bilibili-pipeline.test.js

@@ -0,0 +1,261 @@
+"use strict";
+
+/**
+ * Integration test — A8 v0.1 Bilibili snapshot → vault pipeline.
+ *
+ * Exercises the full chain WITHOUT any real WebView / OkHttp / Android JNI:
+ *
+ *   Synthetic snapshot JSON (4 kinds)
+ *      ↓
+ *   AdapterRegistry (real) + LocalVault (real, SQLCipher)
+ *      ↓
+ *   adapter.sync({ inputPath }) → _syncViaSnapshot yields raw events
+ *      ↓
+ *   registry.putRawEvent → vault.raw_events
+ *      ↓
+ *   adapter.normalize(raw) → batch
+ *      ↓
+ *   vault.putBatch → events / persons / places / items / topics tables
+ *
+ * Two scenarios:
+ *   A. happy path — 4-kind snapshot ingests; vault yields exact counts;
+ *      KG triples derive; originalId stable across re-sync (idempotency)
+ *   B. partial snapshot — only history + follow; vault gets correct subset
+ *
+ * Win note: bs3mc has a known NODE_MODULE_VERSION mismatch on this dev box
+ * (Node 22.22.2 ABI v127 vs prebuild ABI v140); test passes on CI Linux
+ * which uses the matched prebuild. See memory pdh-plan-a-android-standalone-
+ * design §"bs3mc NODE_MODULE_VERSION mismatch".
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  LocalVault,
+  generateKeyHex,
+  AdapterRegistry,
+} = require("../../lib");
+const {
+  BilibiliAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-bilibili");
+
+function makeRig() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-int-"));
+  const vault = new LocalVault({ path: path.join(dir, "v.db"), key: generateKeyHex() });
+  vault.open();
+  const registry = new AdapterRegistry({ vault });
+  return { vault, registry, dir };
+}
+
+function cleanup(rig) {
+  if (!rig) return;
+  try { rig.vault.close(); } catch (_e) { /* noop */ }
+  try { fs.rmSync(rig.dir, { recursive: true, force: true }); } catch (_e) { /* noop */ }
+}
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "social-bilibili.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+function sampleSnapshot(opts = {}) {
+  const include = {
+    history: true,
+    favourite: true,
+    dynamic: true,
+    follow: true,
+    ...opts.include,
+  };
+  const events = [];
+  if (include.history) {
+    events.push({
+      kind: "history",
+      id: "BV1abc",
+      capturedAt: 1715000000000,
+      title: "Rust 异步学习",
+      bvid: "BV1abc",
+      avid: 42,
+      duration: 600,
+      uploader: "技术UP主",
+      uploaderMid: 100,
+      part: "01 介绍",
+    });
+  }
+  if (include.favourite) {
+    events.push({
+      kind: "favourite",
+      id: "fav-BV2def",
+      capturedAt: 1714000000000,
+      title: "前端架构",
+      bvid: "BV2def",
+      folderName: "学习",
+      uploader: "码农UP",
+    });
+  }
+  if (include.dynamic) {
+    events.push({
+      kind: "dynamic",
+      id: "dyn-99",
+      capturedAt: 1713000000000,
+      summary: "今天发了一个新视频",
+      dynamicType: "av",
+      rid: "99",
+      authorMid: 200,
+      authorName: "我关注的UP",
+    });
+  }
+  if (include.follow) {
+    events.push({
+      kind: "follow",
+      id: "follow-300",
+      capturedAt: 1712000000000,
+      mid: 300,
+      uname: "美食UP",
+      face: "https://i0.hdslb.com/300.jpg",
+      sign: "好吃的视频",
+    });
+  }
+  return {
+    schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+    snapshottedAt: 1716000000000,
+    account: { uid: "12345", displayName: "alice" },
+    events,
+  };
+}
+
+describe("Integration — A8 Bilibili snapshot → vault end-to-end", () => {
+  let rig;
+  afterEach(() => { cleanup(rig); rig = null; });
+
+  it("4 kinds ingest into vault with exact entity counts", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, sampleSnapshot());
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+
+    // 3 events (history + favourite + dynamic) + 1 person (follow) +
+    // 2 items (history-video + favourite-video)
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(3);
+    expect(report.entityCounts.persons).toBe(1);
+    expect(report.entityCounts.items).toBe(2);
+
+    // Vault round-trip
+    const events = rig.vault.queryEvents({ limit: 100 });
+    expect(events).toHaveLength(3);
+    const subtypes = events.map((e) => e.subtype).sort();
+    expect(subtypes).toEqual(["browse", "browse", "like"]); // history+dynamic+favourite
+
+    const persons = rig.vault.queryPersons({ limit: 100 });
+    expect(persons).toHaveLength(1);
+    expect(persons[0].names[0]).toBe("美食UP");
+
+    const items = rig.vault.queryItems({ limit: 100 });
+    expect(items).toHaveLength(2);
+    expect(items.map((i) => i.name).sort()).toEqual(["Rust 异步学习", "前端架构"]);
+  });
+
+  it("re-sync is idempotent — same snapshot twice does NOT double entities", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+    const snapshotPath = writeSnapshot(rig.dir, sampleSnapshot());
+
+    // First sync
+    const report1 = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report1.status).toBe("ok");
+
+    // Second sync — same snapshot
+    const report2 = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report2.status).toBe("ok");
+
+    // Stable originalId means re-sync de-dups at raw_events layer.
+    // The person/item entities should remain at 1 / 2 respectively
+    // because their IDs derive from bvid / mid (stable). Events can
+    // legitimately double-write because each "browse" is a separate
+    // occurrence — registry doesn't dedup events.
+    const persons = rig.vault.queryPersons({ limit: 100 });
+    expect(persons).toHaveLength(1);
+
+    const items = rig.vault.queryItems({ limit: 100 });
+    // Items with same bvid produce same ID, so item table stays at 2
+    // (UPSERT semantics via primary-key id).
+    expect(items).toHaveLength(2);
+  });
+
+  it("partial snapshot (history + follow only) yields exact subset", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(
+      rig.dir,
+      sampleSnapshot({ include: { favourite: false, dynamic: false } })
+    );
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(1); // history only
+    expect(report.entityCounts.persons).toBe(1); // follow
+    expect(report.entityCounts.items).toBe(1); // history video
+  });
+
+  it("empty events array → ok status with 0 entity counts", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, {
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(0);
+    expect(report.entityCounts.persons).toBe(0);
+    expect(report.entityCounts.items).toBe(0);
+  });
+
+  it("schemaVersion mismatch surfaces in SyncReport.error (not silent)", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, {
+      schemaVersion: 99, // wrong
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("error");
+    expect(String(report.error)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("registry queryable by adapter.name after register()", () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+    expect(rig.registry.has("social-bilibili")).toBe(true);
+    expect(rig.registry.list().some((m) => m.name === "social-bilibili")).toBe(true);
+  });
+});

package/__tests__/social-adapters.test.js

@@ -37,9 +37,47 @@ describe("BilibiliAdapter", () => {
     expect(a.extractMode).toBe("device-pull");
   });
 
-  it("rejects missing account.uid", () => {
-    expect(() => new BilibiliAdapter({})).toThrow();
-    expect(() => new BilibiliAdapter({ account: {} })).toThrow(/uid/);
+  it("accepts stateless construction (snapshot mode added in A8)", () => {
+    // Before A8: constructor required opts.account.uid. After A8 the adapter
+    // is stateless when running snapshot mode (in-APK Android cc reads a JSON
+    // produced by the phone). Sqlite mode still needs account.uid but the
+    // check moved into _syncViaSqlite where it actually matters.
+    expect(() => new BilibiliAdapter({})).not.toThrow();
+    expect(() => new BilibiliAdapter({ account: {} })).not.toThrow();
+    expect(() => new BilibiliAdapter()).not.toThrow();
+  });
+
+  it("sqlite mode rejects missing account.uid at sync time", async () => {
+    const a = new BilibiliAdapter({ dbPath: "/tmp/bili.db" });
+    // Path-existence check happens before account.uid validation, so we
+    // exercise the guard via dbPath=null + account=null which falls to
+    // "sync needs inputPath OR dbPath" first. Use a real-looking dbPath
+    // with no account to surface the account.uid throw deterministically.
+    const fs = require("node:fs");
+    const path = require("node:path");
+    const os = require("node:os");
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-no-acct-"));
+    const dbPath = path.join(dir, "bili.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const b = new BilibiliAdapter({
+        dbPath,
+        dbDriverFactory: () => () => ({
+          prepare: () => ({ all: () => [] }),
+          close() {},
+        }),
+      });
+      let threw = null;
+      try {
+        for await (const _r of b.sync()) { /* drain */ }
+      } catch (err) {
+        threw = err;
+      }
+      expect(threw).toBeTruthy();
+      expect(String(threw.message)).toMatch(/account\.uid/);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   it("sync yields history + favourite records via mocked driver", async () => {
@@ -83,26 +121,34 @@ describe("BilibiliAdapter", () => {
     }
   });
 
-  it("idle when DB path missing", async () => {
+  it("throws when neither inputPath nor dbPath provided (A8: surface config errors)", async () => {
+    // Before A8: sync silently yielded 0 if dbPath missing — masked typos and
+    // misconfigured callers. After A8 we throw so callers see the problem.
     const a = new BilibiliAdapter({ account: { uid: "1234" } });
-    const raws = [];
-    for await (const r of a.sync()) raws.push(r);
-    expect(raws).toHaveLength(0);
+    let threw = null;
+    try {
+      for await (const _r of a.sync()) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/inputPath|dbPath/);
   });
 
-  it("normalize captures bvid/avid/uploader into extra", async () => {
+  it("normalize captures bvid/avid/uploader into extra (flat payload, A8 shape)", async () => {
     const a = new BilibiliAdapter({ account: { uid: "1234" } });
     const raw = {
       adapter: "social-bilibili",
-      originalId: "history-1",
+      kind: "history",
+      originalId: "bilibili:history:BV1abc",
       capturedAt: 1700000000000,
       payload: {
         kind: "history",
-        row: {
-          id: 1, bvid: "BV1abc", avid: "1234",
-          title: "Test", view_at: 1700000000,
-          uploader: "UpA", duration: 300,
-        },
+        title: "Test",
+        bvid: "BV1abc",
+        avid: "1234",
+        uploader: "UpA",
+        duration: 300,
       },
     };
     const batch = a.normalize(raw);
@@ -110,6 +156,9 @@ describe("BilibiliAdapter", () => {
     expect(batch.events[0].extra.avid).toBe("1234");
     expect(batch.events[0].extra.uploader).toBe("UpA");
     expect(batch.events[0].extra.duration).toBe(300);
+    // A8: history also yields an item entity (video) for KG linkage
+    expect(batch.items).toHaveLength(1);
+    expect(batch.items[0].extra.bvid).toBe("BV1abc");
   });
 });