@chainlesschain/personal-data-hub 0.2.0 → 0.2.2

package/__tests__/adapters/wechat-frida-key-provider.test.js

@@ -0,0 +1,188 @@
+"use strict";
+
+import { describe, it, expect, vi } from "vitest";
+
+const { FridaKeyProvider } = require("../../lib/adapters/wechat/key-providers/frida-key-provider");
+
+/** Helper that builds a mock frida binding with a scripted message timeline. */
+function makeMockFrida({ onAttachThrow, onCreateScriptThrow, onLoadThrow, messages = [], deviceId = "device" }) {
+  const ops = {
+    unloadCalled: 0,
+    detachCalled: 0,
+    loadCalled: 0,
+    messageHandler: null,
+  };
+  const script = {
+    message: {
+      connect: (handler) => { ops.messageHandler = handler; },
+    },
+    load: vi.fn(async () => {
+      ops.loadCalled++;
+      if (onLoadThrow) throw onLoadThrow;
+      // Replay the scripted messages on next tick so .connect handler is
+      // wired before the first send fires.
+      setTimeout(() => {
+        for (const m of messages) {
+          if (ops.messageHandler) ops.messageHandler({ type: "send", payload: m });
+        }
+      }, 0);
+    }),
+    unload: vi.fn(async () => { ops.unloadCalled++; }),
+  };
+  const session = {
+    createScript: vi.fn(async () => {
+      if (onCreateScriptThrow) throw onCreateScriptThrow;
+      return script;
+    }),
+    detach: vi.fn(async () => { ops.detachCalled++; }),
+  };
+  const device = {
+    attach: vi.fn(async (pkg) => {
+      if (onAttachThrow) throw onAttachThrow;
+      device._attachedTo = pkg;
+      return session;
+    }),
+  };
+  const frida = {
+    getDevice: vi.fn(async (id) => {
+      device._id = id;
+      return device;
+    }),
+    getUsbDevice: vi.fn(async () => device),
+  };
+  return { frida, device, session, script, ops };
+}
+
+describe("FridaKeyProvider — construction", () => {
+  it("defaults packageName to com.tencent.mm", () => {
+    const p = new FridaKeyProvider({});
+    expect(p._packageName).toBe("com.tencent.mm");
+  });
+
+  it("name is frida", () => {
+    const p = new FridaKeyProvider({});
+    expect(p.name).toBe("frida");
+  });
+
+  it("getKey throws FRIDA_BINDING_MISSING when frida not available", async () => {
+    const p = new FridaKeyProvider({});
+    try {
+      await p.getKey();
+      throw new Error("should have thrown");
+    } catch (err) {
+      expect(err.code).toBe("FRIDA_BINDING_MISSING");
+    }
+  });
+});
+
+describe("FridaKeyProvider — happy path", () => {
+  it("captures key hex and detaches", async () => {
+    const keyHex = "00112233445566778899aabbccddeeff" +
+                   "ffeeddccbbaa99887766554433221100";
+    const { frida, ops } = makeMockFrida({
+      messages: [
+        { kind: "hooked", symbol: "sqlite3_key", module: "libwcdb.so" },
+        { kind: "key", hex: keyHex.toUpperCase(), source: "sqlite3_key" },
+      ],
+    });
+    const p = new FridaKeyProvider({ frida, deviceId: "Z1", agentLoader: () => "/* mock agent */" });
+    const k = await p.getKey();
+    expect(k).toBe(keyHex); // lowercased
+    expect(ops.unloadCalled).toBe(1);
+    expect(ops.detachCalled).toBe(1);
+    const tel = p.getLastTelemetry();
+    expect(tel.keySource).toBe("sqlite3_key");
+    expect(tel.hooked).toHaveLength(1);
+    expect(tel.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it("uses USB device when no deviceId provided", async () => {
+    const { frida } = makeMockFrida({
+      messages: [{ kind: "key", hex: "aa" + "00".repeat(31), source: "sqlite3_key" }],
+    });
+    const p = new FridaKeyProvider({ frida, agentLoader: () => "/* mock */" });
+    await p.getKey();
+    expect(frida.getUsbDevice).toHaveBeenCalled();
+    expect(frida.getDevice).not.toHaveBeenCalled();
+  });
+});
+
+describe("FridaKeyProvider — error paths", () => {
+  it("WECHAT_NOT_RUNNING when attach reports process not found", async () => {
+    const { frida } = makeMockFrida({
+      onAttachThrow: new Error("unable to find process with name 'com.tencent.mm'"),
+    });
+    const p = new FridaKeyProvider({ frida, deviceId: "Z1", agentLoader: () => "" });
+    await expect(p.getKey()).rejects.toMatchObject({ code: "WECHAT_NOT_RUNNING" });
+  });
+
+  it("FRIDA_ATTACH_FAILED on generic attach error", async () => {
+    const { frida } = makeMockFrida({
+      onAttachThrow: new Error("permission denied"),
+    });
+    const p = new FridaKeyProvider({ frida, deviceId: "Z1", agentLoader: () => "" });
+    await expect(p.getKey()).rejects.toMatchObject({ code: "FRIDA_ATTACH_FAILED" });
+  });
+
+  it("FRIDA_ATTACH_FAILED + session cleanup when createScript throws", async () => {
+    const { frida, ops } = makeMockFrida({
+      onCreateScriptThrow: new Error("syntax error in agent"),
+    });
+    const p = new FridaKeyProvider({ frida, deviceId: "Z1", agentLoader: () => "BAD" });
+    await expect(p.getKey()).rejects.toMatchObject({ code: "FRIDA_ATTACH_FAILED" });
+    // Even though createScript threw, the session was already attached;
+    // implementation cleans it up in the catch path.
+    expect(ops.detachCalled).toBe(1);
+  });
+
+  it("WCDB_KEY_TIMEOUT when no key event in time", async () => {
+    const { frida, ops } = makeMockFrida({
+      messages: [{ kind: "hooked", symbol: "sqlite3_key", module: "libwcdb.so" }],
+    });
+    const p = new FridaKeyProvider({
+      frida,
+      deviceId: "Z1",
+      timeoutMs: 50,
+      agentLoader: () => "",
+    });
+    await expect(p.getKey()).rejects.toMatchObject({ code: "WCDB_KEY_TIMEOUT" });
+    expect(ops.unloadCalled).toBe(1);
+    expect(ops.detachCalled).toBe(1);
+  });
+
+  it("non-fatal hook errors are recorded but don't reject", async () => {
+    const keyHex = "ee" + "00".repeat(31);
+    const { frida } = makeMockFrida({
+      messages: [
+        { kind: "error", message: "Interceptor.attach failed for WCDBKeyDerive: not found" },
+        { kind: "hooked", symbol: "sqlite3_key", module: "libwcdb.so" },
+        { kind: "key", hex: keyHex, source: "sqlite3_key" },
+      ],
+    });
+    const p = new FridaKeyProvider({ frida, deviceId: "Z1", agentLoader: () => "" });
+    const k = await p.getKey();
+    expect(k).toBe(keyHex);
+    expect(p.getLastTelemetry().errors).toContain("Interceptor.attach failed for WCDBKeyDerive: not found");
+  });
+});
+
+describe("FridaKeyProvider — logger DI", () => {
+  it("logger receives frida-message events", async () => {
+    const events = [];
+    const { frida } = makeMockFrida({
+      messages: [
+        { kind: "hooked", symbol: "sqlite3_key", module: "libwcdb.so" },
+        { kind: "key", hex: "ff" + "00".repeat(31), source: "sqlite3_key" },
+      ],
+    });
+    const p = new FridaKeyProvider({
+      frida,
+      deviceId: "Z1",
+      agentLoader: () => "",
+      logger: (e) => events.push(e),
+    });
+    await p.getKey();
+    expect(events.some((e) => e.kind === "frida-message" && e.evt.kind === "hooked")).toBe(true);
+    expect(events.some((e) => e.kind === "frida-message" && e.evt.kind === "key")).toBe(true);
+  });
+});

package/__tests__/adapters/wechat-md5-key-provider.test.js

@@ -0,0 +1,101 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  WeChatKeyProvider,
+  WeChatMD5KeyProvider,
+} = require("../../lib/adapters/wechat");
+
+describe("WeChatKeyProvider — base contract", () => {
+  it("getKey throws on bare base instance (subclass must override)", async () => {
+    const base = new WeChatKeyProvider();
+    await expect(base.getKey()).rejects.toThrow(/must be overridden/);
+  });
+
+  it("name defaults to key-provider-base", () => {
+    const base = new WeChatKeyProvider();
+    expect(base.name).toBe("key-provider-base");
+  });
+});
+
+describe("WeChatMD5KeyProvider — construction validation", () => {
+  it("throws if opts missing", () => {
+    expect(() => new WeChatMD5KeyProvider()).toThrow(/wechatDataPath/);
+  });
+
+  it("throws if wechatDataPath missing", () => {
+    expect(() => new WeChatMD5KeyProvider({ uin: "1" })).toThrow(/wechatDataPath/);
+  });
+
+  it("name returns md5", () => {
+    const p = new WeChatMD5KeyProvider({ wechatDataPath: "/tmp/wx" });
+    expect(p.name).toBe("md5");
+  });
+});
+
+describe("WeChatMD5KeyProvider — extractor DI happy path", () => {
+  it("getKey returns hex when extractor yields key", async () => {
+    const extractor = (opts) => {
+      expect(opts.wechatDataPath).toBe("/tmp/wx");
+      return {
+        uin: "100200300",
+        imei: "350123456789012",
+        key: "abcdef1",
+        source: "test",
+        warnings: [],
+      };
+    };
+    const p = new WeChatMD5KeyProvider({
+      wechatDataPath: "/tmp/wx",
+      extractor,
+    });
+    const key = await p.getKey();
+    expect(key).toBe("abcdef1");
+    expect(p.getLastResult().uin).toBe("100200300");
+    expect(p.getLastResult().imei).toBe("350123456789012");
+  });
+
+  it("getKey passes uin/imei overrides through to extractor", async () => {
+    let passedOpts = null;
+    const extractor = (opts) => {
+      passedOpts = opts;
+      return { key: "0000000", uin: opts.uin, imei: opts.imei, warnings: [] };
+    };
+    const p = new WeChatMD5KeyProvider({
+      wechatDataPath: "/tmp/wx",
+      uin: "999",
+      imei: "deadbeef",
+      extractor,
+    });
+    await p.getKey();
+    expect(passedOpts.uin).toBe("999");
+    expect(passedOpts.imei).toBe("deadbeef");
+  });
+});
+
+describe("WeChatMD5KeyProvider — extractor failure surfaces as throw", () => {
+  it("throws with warnings when extractor returns no key", async () => {
+    const extractor = () => ({
+      uin: null,
+      imei: null,
+      key: null,
+      source: "missing",
+      warnings: ["UIN not found in shared_prefs", "IMEI not found in CompatibleInfo.cfg"],
+    });
+    const p = new WeChatMD5KeyProvider({
+      wechatDataPath: "/tmp/empty",
+      extractor,
+    });
+    await expect(p.getKey()).rejects.toThrow(/UIN not found/);
+  });
+
+  it("throws with generic reason when warnings empty", async () => {
+    const extractor = () => ({ key: null, warnings: [] });
+    const p = new WeChatMD5KeyProvider({
+      wechatDataPath: "/tmp/empty",
+      extractor,
+    });
+    await expect(p.getKey()).rejects.toThrow(/extraction returned empty/);
+  });
+});

package/__tests__/analysis-skills.test.js

@@ -250,6 +250,64 @@ describe("RelationsSkill", () => {
     expect(r.ranked[0].personId).toBe("p-mom");
     expect(r.ranked[0].totalInteractions).toBe(2);
   });
+
+  it("empty vault → ranked mode returns empty list, no crash", async () => {
+    const skill = new RelationsSkill({ vault: rig.vault });
+    const r = await skill.run({});
+    expect(r.mode).toBe("ranked");
+    expect(r.ranked).toEqual([]);
+    expect(r.citations).toEqual([]);
+    expect(r.llm_commentary).toBeNull();
+  });
+
+  it("non-local LLM gate: isLocal=false without acceptNonLocal → commentary stays null", async () => {
+    makePerson(rig.vault, "p-mom", ["妈"]);
+    makePayment(rig.vault, { id: "e1", occurredAt: ts(2026, 5, 1), counterpartyId: "p-mom", counterpartyName: "妈", amount: 100 });
+    const nonLocalLlm = {
+      isLocal: false,
+      chat: async () => ({ text: "this should never reach the caller" }),
+    };
+    const skill = new RelationsSkill({ vault: rig.vault, llm: nonLocalLlm });
+    const r = await skill.run({ personId: "p-mom" });
+    expect(r.mode).toBe("single");
+    expect(r.profile.totalInteractions).toBe(1);
+    // gate enforced by base.callLlmCommentary
+    expect(r.llm_commentary).toBeNull();
+  });
+
+  it("LLM exception swallowed → commentary null but profile data intact", async () => {
+    makePerson(rig.vault, "p-mom", ["妈"]);
+    makePayment(rig.vault, { id: "e1", occurredAt: ts(2026, 5, 1), counterpartyId: "p-mom", counterpartyName: "妈", amount: 100 });
+    const throwingLlm = {
+      isLocal: true,
+      chat: async () => { throw new Error("model timeout"); },
+    };
+    const skill = new RelationsSkill({ vault: rig.vault, llm: throwingLlm });
+    const r = await skill.run({ personId: "p-mom" });
+    expect(r.profile.totalInteractions).toBe(1); // data path unaffected
+    expect(r.llm_commentary).toBeNull();
+  });
+
+  it("merge-group expansion: vault.getMergeGroupMembers fans the personId out", async () => {
+    // Two PersonIds representing the same real-world person across sources;
+    // EntityResolver (Phase 8) would normally merge them into a group.
+    makePerson(rig.vault, "p-mom-email", ["妈"], { email: ["mom@163.com"] });
+    makePerson(rig.vault, "p-mom-alipay", ["陈XX"], { alipay: ["mom@163.com"] });
+    makePayment(rig.vault, { id: "e1", occurredAt: ts(2026, 4, 1), counterpartyId: "p-mom-email", counterpartyName: "妈", amount: 200, adapter: "email-imap" });
+    makePayment(rig.vault, { id: "e2", occurredAt: ts(2026, 5, 1), counterpartyId: "p-mom-alipay", counterpartyName: "陈XX", amount: 300, adapter: "alipay-bill" });
+
+    // Stub the resolver hook
+    rig.vault.getMergeGroupMembers = (pid) =>
+      (pid === "p-mom-email" || pid === "p-mom-alipay")
+        ? ["p-mom-email", "p-mom-alipay"]
+        : [pid];
+
+    const skill = new RelationsSkill({ vault: rig.vault });
+    const r = await skill.run({ personId: "p-mom-email" });
+    expect(r.profile.totalInteractions).toBe(2); // both events counted
+    expect(r.profile.totalSpend).toBe(500);
+    expect(Object.keys(r.profile.byAdapter).sort()).toEqual(["alipay-bill", "email-imap"]);
+  });
 });
 
 // ─── FootprintSkill ──────────────────────────────────────────────────────
@@ -301,6 +359,55 @@ describe("FootprintSkill", () => {
     expect(r.summary.totalTrips).toBe(0);
     expect(r.topPlaces).toEqual([]);
   });
+
+  it("local LLM commentary fires when trips present", async () => {
+    rig.vault.putEvent({
+      id: "trip-1", type: "event", subtype: "trip",
+      occurredAt: ts(2026, 4, 1),
+      actor: "person-self",
+      content: { title: "Hangzhou trip" },
+      ingestedAt: Date.now(),
+      source: defaultSource("travel"),
+      extra: { to: "Hangzhou" },
+    });
+    const llm = { isLocal: true, chat: async () => ({ text: "你这个月去过 1 个地方。" }) };
+    const skill = new FootprintSkill({ vault: rig.vault, llm });
+    const r = await skill.run({});
+    expect(r.llm_commentary).toBe("你这个月去过 1 个地方。");
+  });
+
+  it("non-local LLM gate → llm_commentary null", async () => {
+    rig.vault.putEvent({
+      id: "trip-1", type: "event", subtype: "trip",
+      occurredAt: ts(2026, 4, 1),
+      actor: "person-self",
+      content: { title: "Beijing" },
+      ingestedAt: Date.now(),
+      source: defaultSource("travel"),
+      extra: { to: "Beijing" },
+    });
+    const llm = { isLocal: false, chat: async () => ({ text: "should not appear" }) };
+    const skill = new FootprintSkill({ vault: rig.vault, llm });
+    const r = await skill.run({});
+    expect(r.llm_commentary).toBeNull();
+  });
+
+  it("LLM exception swallowed → commentary null but data intact", async () => {
+    rig.vault.putEvent({
+      id: "trip-1", type: "event", subtype: "trip",
+      occurredAt: ts(2026, 4, 1),
+      actor: "person-self",
+      content: { title: "Tokyo" },
+      ingestedAt: Date.now(),
+      source: defaultSource("travel"),
+      extra: { to: "Tokyo" },
+    });
+    const llm = { isLocal: true, chat: async () => { throw new Error("net down"); } };
+    const skill = new FootprintSkill({ vault: rig.vault, llm });
+    const r = await skill.run({});
+    expect(r.summary.totalTrips).toBe(1);
+    expect(r.llm_commentary).toBeNull();
+  });
 });
 
 // ─── InterestsSkill ──────────────────────────────────────────────────────
@@ -349,6 +456,46 @@ describe("InterestsSkill", () => {
     expect(r.llmInterests).toHaveLength(1);
     expect(r.llmInterests[0].category).toBe("摄影");
   });
+
+  it("empty vault → topTopics + topItems empty, no crash", async () => {
+    const skill = new InterestsSkill({ vault: rig.vault });
+    const r = await skill.run({});
+    expect(r.topTopics).toEqual([]);
+    expect(r.topItems).toEqual([]);
+    expect(r.llmInterests).toBeNull();
+  });
+
+  it("non-local LLM gate → llmInterests null even with topics present", async () => {
+    rig.vault.putTopic({
+      id: "topic-b", type: "topic", name: "Cooking",
+      derivedFromEvents: ["e-1"],
+      ingestedAt: Date.now(), source: defaultSource("test"),
+    });
+    const llm = {
+      isLocal: false,
+      chat: async () => ({ text: '[{"category":"烹饪","evidenceCount":1,"examples":["Cooking"]}]' }),
+    };
+    const skill = new InterestsSkill({ vault: rig.vault, llm });
+    const r = await skill.run({});
+    expect(r.topTopics[0].name).toBe("Cooking");
+    expect(r.llmInterests).toBeNull();
+  });
+
+  it("LLM clustering exception swallowed → llmInterests null but data intact", async () => {
+    rig.vault.putTopic({
+      id: "topic-c", type: "topic", name: "Travel",
+      derivedFromEvents: ["e-1", "e-2"],
+      ingestedAt: Date.now(), source: defaultSource("test"),
+    });
+    const llm = {
+      isLocal: true,
+      chat: async () => { throw new Error("vllm 500"); },
+    };
+    const skill = new InterestsSkill({ vault: rig.vault, llm });
+    const r = await skill.run({});
+    expect(r.topTopics[0].name).toBe("Travel");
+    expect(r.llmInterests).toBeNull();
+  });
 });
 
 // ─── TimelineSkill ──────────────────────────────────────────────────────