@chainlesschain/personal-data-hub 0.1.0 → 0.2.1

package/__tests__/sidecar-contacts-cross-validate.test.js

@@ -0,0 +1,163 @@
+"use strict";
+
+/**
+ * Cross-validate that Persons produced by the Python sidecar's
+ * `system.parse_contacts` method pass the hub-side UnifiedSchema validator.
+ *
+ * Without this test, sidecar and hub can drift silently: sidecar emits
+ * fields the schema rejects, or skips required ones. Run against a real
+ * sidecar subprocess + synthesized contacts2.db.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { spawnSync } from "node:child_process";
+
+const { SidecarSupervisor } = require("../lib/sidecar");
+const { validatePerson } = require("../lib/schemas");
+const Database = require("better-sqlite3-multiple-ciphers");
+
+const SIDECAR_ROOT = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "personal-data-hub-bridge",
+);
+
+let pythonAvailable = true;
+try {
+  const probe = spawnSync(
+    process.env.FORENSICS_BRIDGE_PYTHON || "python",
+    ["--version"],
+    { stdio: "ignore" },
+  );
+  if (probe.status !== 0) pythonAvailable = false;
+} catch (_err) {
+  pythonAvailable = false;
+}
+
+const describePy = pythonAvailable ? describe : describe.skip;
+
+function seedFixtureContactsDb(dbPath) {
+  const db = new Database(dbPath);
+  try {
+    db.exec(`
+      CREATE TABLE raw_contacts (
+        _id INTEGER PRIMARY KEY,
+        display_name TEXT,
+        starred INTEGER DEFAULT 0,
+        deleted INTEGER DEFAULT 0
+      );
+      CREATE TABLE mimetypes (
+        _id INTEGER PRIMARY KEY,
+        mimetype TEXT NOT NULL UNIQUE
+      );
+      CREATE TABLE data (
+        _id INTEGER PRIMARY KEY,
+        raw_contact_id INTEGER NOT NULL,
+        mimetype_id INTEGER NOT NULL,
+        data1 TEXT
+      );
+    `);
+    const mimetypes = {
+      "vnd.android.cursor.item/phone_v2": 5,
+      "vnd.android.cursor.item/email_v2": 1,
+      "vnd.android.cursor.item/organization": 4,
+      "vnd.android.cursor.item/note": 10,
+    };
+    const insertMime = db.prepare(
+      "INSERT INTO mimetypes (_id, mimetype) VALUES (?, ?)",
+    );
+    for (const [mt, mid] of Object.entries(mimetypes)) insertMime.run(mid, mt);
+
+    const insertContact = db.prepare(
+      "INSERT INTO raw_contacts (_id, display_name, starred, deleted) VALUES (?, ?, ?, 0)",
+    );
+    insertContact.run(1, "妈妈", 1);
+    insertContact.run(2, "张三", 0);
+
+    const insertData = db.prepare(
+      "INSERT INTO data (raw_contact_id, mimetype_id, data1) VALUES (?, ?, ?)",
+    );
+    insertData.run(1, mimetypes["vnd.android.cursor.item/phone_v2"], "13800001111");
+    insertData.run(1, mimetypes["vnd.android.cursor.item/phone_v2"], "13900002222");
+    insertData.run(1, mimetypes["vnd.android.cursor.item/email_v2"], "mom@example.com");
+    insertData.run(2, mimetypes["vnd.android.cursor.item/phone_v2"], "13711112222");
+  } finally {
+    db.close();
+  }
+}
+
+describePy("sidecar.system.parse_contacts × hub.validatePerson", () => {
+  let supervisor;
+  let tmpDir;
+  let dbPath;
+
+  beforeAll(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "phdb-sidecar-contacts-"));
+    dbPath = path.join(tmpDir, "contacts2.db");
+    seedFixtureContactsDb(dbPath);
+
+    supervisor = new SidecarSupervisor({
+      command: process.env.FORENSICS_BRIDGE_PYTHON || "python",
+      args: ["-u", "-m", "forensics_bridge.ipc_server"],
+      cwd: SIDECAR_ROOT,
+      healthCheckIntervalMs: 0,
+      env: { PYTHONPATH: SIDECAR_ROOT },
+    });
+    await supervisor.start({ readyTimeoutMs: 8_000 });
+  }, 15_000);
+
+  afterAll(async () => {
+    if (supervisor) await supervisor.stop({ graceMs: 1500 });
+    if (tmpDir) {
+      try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      } catch (_err) {
+        /* best effort */
+      }
+    }
+  });
+
+  it("emits Persons that pass hub UnifiedSchema validation", async () => {
+    const persons = [];
+    const result = await supervisor.invoke(
+      "system.parse_contacts",
+      { data_path: dbPath, device_serial: "24115RA8EC-test" },
+      {
+        timeoutMs: 10_000,
+        onChunk: (batch) => {
+          for (const p of batch.persons || []) persons.push(p);
+        },
+      },
+    );
+
+    expect(result.status).toBe("ok");
+    expect(result.totalPersons).toBe(2);
+    expect(persons).toHaveLength(2);
+
+    for (const person of persons) {
+      const validation = validatePerson(person);
+      if (!validation.valid) {
+        // Dump the offender so CI failures are debuggable without re-running.
+        console.error(
+          "validatePerson failed for",
+          JSON.stringify(person, null, 2),
+          "errors:",
+          validation.errors,
+        );
+      }
+      expect(validation.valid).toBe(true);
+      expect(validation.errors).toEqual([]);
+    }
+
+    // Spot-check shape — mom has phones+email+starred+notes? (notes none in this fixture)
+    const mom = persons.find((p) => p.names[0] === "妈妈");
+    expect(mom.identifiers.phone).toEqual(["13800001111", "13900002222"]);
+    expect(mom.identifiers.email).toEqual(["mom@example.com"]);
+    expect(mom.extra.starred).toBe(true);
+    expect(mom.extra.deviceSerial).toBe("24115RA8EC-test");
+  });
+});

package/__tests__/sidecar-supervisor.test.js

@@ -0,0 +1,120 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import path from "node:path";
+
+const {
+  SidecarSupervisor,
+  SidecarTimeoutError,
+  SidecarMethodError,
+  SidecarNotRunningError,
+} = require("../lib/sidecar");
+
+const SIDECAR_ROOT = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "personal-data-hub-bridge",
+);
+
+/**
+ * Spawn the forensics-bridge sidecar from this repo's sibling package.
+ * Tests are skipped if Python is unavailable on PATH (CI matrix coverage
+ * is the source of truth; local dev without Python should not be blocked).
+ */
+function makeSupervisor() {
+  return new SidecarSupervisor({
+    command: process.env.FORENSICS_BRIDGE_PYTHON || "python",
+    args: ["-u", "-m", "forensics_bridge.ipc_server"],
+    cwd: SIDECAR_ROOT,
+    healthCheckIntervalMs: 0, // disable for tests — manual control only
+    env: { PYTHONPATH: SIDECAR_ROOT },
+  });
+}
+
+let pythonAvailable = true;
+try {
+  // Cheap synchronous probe — spawn fails if python is not on PATH.
+  const { spawnSync } = require("node:child_process");
+  const probe = spawnSync(
+    process.env.FORENSICS_BRIDGE_PYTHON || "python",
+    ["--version"],
+    { stdio: "ignore" },
+  );
+  if (probe.status !== 0) pythonAvailable = false;
+} catch (_err) {
+  pythonAvailable = false;
+}
+
+const itPy = pythonAvailable ? it : it.skip;
+
+describe("SidecarSupervisor (forensics-bridge integration)", () => {
+  let supervisor;
+
+  beforeEach(() => {
+    supervisor = makeSupervisor();
+  });
+
+  afterEach(async () => {
+    if (supervisor) await supervisor.stop({ graceMs: 1500 });
+  });
+
+  itPy("starts the sidecar and round-trips sidecar.ping", async () => {
+    await supervisor.start({ readyTimeoutMs: 8_000 });
+    expect(supervisor.isRunning()).toBe(true);
+
+    const ping = await supervisor.invoke("sidecar.ping", {}, { timeoutMs: 3_000 });
+    expect(ping.version).toMatch(/^\d+\.\d+\.\d+/);
+    expect(ping.pythonVersion).toMatch(/^3\./);
+  });
+
+  itPy("sidecar.capabilities exposes registered methods", async () => {
+    await supervisor.start({ readyTimeoutMs: 8_000 });
+
+    const caps = await supervisor.invoke("sidecar.capabilities");
+    expect(caps.methods).toContain("sidecar.ping");
+    expect(caps.methods).toContain("sidecar.capabilities");
+    // Namespace registry grows as parsers/extractors land; Phase 4.5.2 brings
+    // the system parser online.
+    expect(caps.parsers).toContain("system");
+    expect(caps.extractors).toContain("android");
+  });
+
+  itPy("METHOD_NOT_FOUND surfaces as a typed SidecarMethodError", async () => {
+    await supervisor.start({ readyTimeoutMs: 8_000 });
+
+    await expect(
+      supervisor.invoke("definitely.not.a.real.method"),
+    ).rejects.toMatchObject({
+      name: "SidecarMethodError",
+      code: "METHOD_NOT_FOUND",
+      retryable: false,
+    });
+  });
+
+  itPy("invoke rejects with SidecarNotRunningError when sidecar is stopped", async () => {
+    await supervisor.start({ readyTimeoutMs: 8_000 });
+    await supervisor.stop({ graceMs: 1500 });
+    expect(supervisor.isRunning()).toBe(false);
+
+    await expect(supervisor.invoke("sidecar.ping")).rejects.toMatchObject({
+      name: "SidecarNotRunningError",
+      code: "SIDECAR_NOT_RUNNING",
+    });
+  });
+
+  itPy("two sequential invokes share one sidecar process", async () => {
+    await supervisor.start({ readyTimeoutMs: 8_000 });
+    const first = await supervisor.invoke("sidecar.ping");
+    const second = await supervisor.invoke("sidecar.capabilities");
+    expect(first.version).toBeDefined();
+    expect(second.methods).toContain("sidecar.ping");
+  });
+
+  itPy("error class hierarchy is exported", () => {
+    expect(typeof SidecarSupervisor).toBe("function");
+    expect(typeof SidecarTimeoutError).toBe("function");
+    expect(typeof SidecarMethodError).toBe("function");
+    expect(typeof SidecarNotRunningError).toBe("function");
+  });
+});

package/__tests__/social-adapters.test.js

@@ -0,0 +1,206 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const { BilibiliAdapter, WeiboAdapter } = 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() {},
+    };
+  };
+}
+
+// ─── BilibiliAdapter ────────────────────────────────────────────────────
+
+describe("BilibiliAdapter", () => {
+  it("contract conformance", () => {
+    const a = new BilibiliAdapter({ account: { uid: "1234" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.extractMode).toBe("device-pull");
+  });
+
+  it("rejects missing account.uid", () => {
+    expect(() => new BilibiliAdapter({})).toThrow();
+    expect(() => new BilibiliAdapter({ account: {} })).toThrow(/uid/);
+  });
+
+  it("sync yields history + favourite records via mocked driver", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-"));
+    const dbPath = path.join(dir, "bili.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const mockDriver = makeMockDriver([
+        ["FROM history", [
+          { id: 1, bvid: "BV1abc", title: "趣味视频", view_at: 1700000000, uploader: "UpA" },
+          { id: 2, bvid: "BV1xyz", title: "教程", view_at: 1700000010, uploader: "UpB", duration: 300 },
+        ]],
+        ["FROM bili_favourite", [
+          { id: 1, bvid: "BV1fav", title: "收藏A", save_time: 1700001000, folder_name: "学习" },
+        ]],
+      ]);
+      const a = new BilibiliAdapter({
+        account: { uid: "1234" },
+        dbPath,
+        dbDriverFactory: () => mockDriver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3); // 2 history + 1 favourite
+      const histories = raws.filter((r) => r.payload.kind === "history");
+      const favs = raws.filter((r) => r.payload.kind === "favourite");
+      expect(histories).toHaveLength(2);
+      expect(favs).toHaveLength(1);
+
+      // Normalize each
+      for (const raw of raws) {
+        const batch = a.normalize(raw);
+        const v = validateBatch(batch);
+        expect(v.valid).toBe(true);
+        const subtype = batch.events[0].subtype;
+        if (raw.payload.kind === "history") expect(subtype).toBe("browse");
+        if (raw.payload.kind === "favourite") expect(subtype).toBe("like");
+      }
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("idle when DB path missing", async () => {
+    const a = new BilibiliAdapter({ account: { uid: "1234" } });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    expect(raws).toHaveLength(0);
+  });
+
+  it("normalize captures bvid/avid/uploader into extra", async () => {
+    const a = new BilibiliAdapter({ account: { uid: "1234" } });
+    const raw = {
+      adapter: "social-bilibili",
+      originalId: "history-1",
+      capturedAt: 1700000000000,
+      payload: {
+        kind: "history",
+        row: {
+          id: 1, bvid: "BV1abc", avid: "1234",
+          title: "Test", view_at: 1700000000,
+          uploader: "UpA", duration: 300,
+        },
+      },
+    };
+    const batch = a.normalize(raw);
+    expect(batch.events[0].extra.bvid).toBe("BV1abc");
+    expect(batch.events[0].extra.avid).toBe("1234");
+    expect(batch.events[0].extra.uploader).toBe("UpA");
+    expect(batch.events[0].extra.duration).toBe(300);
+  });
+});
+
+// ─── WeiboAdapter ───────────────────────────────────────────────────────
+
+describe("WeiboAdapter", () => {
+  it("contract conformance", () => {
+    const a = new WeiboAdapter({ account: { uid: "1234" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.extractMode).toBe("device-pull");
+  });
+
+  it("rejects missing account.uid", () => {
+    expect(() => new WeiboAdapter({})).toThrow();
+    expect(() => new WeiboAdapter({ account: {} })).toThrow(/uid/);
+  });
+
+  it("sync yields posts + search records via mocked driver", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "weibo-"));
+    const dbPath = path.join(dir, "weibo.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const mockDriver = makeMockDriver([
+        ["FROM post", [
+          { id: 1, mid: "M1", text: "今天天气真好", created_at: 1700000000, reposts_count: 5, comments_count: 3 },
+        ]],
+        ["FROM status", []],
+        ["FROM search_history", [
+          { id: 1, keyword: "iPhone", time: 1700001000 },
+          { id: 2, keyword: "音乐", time: 1700001100 },
+        ]],
+      ]);
+      const a = new WeiboAdapter({
+        account: { uid: "1234" },
+        dbPath,
+        dbDriverFactory: () => mockDriver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3); // 1 post + 2 searches
+
+      for (const raw of raws) {
+        const batch = a.normalize(raw);
+        const v = validateBatch(batch);
+        expect(v.valid).toBe(true);
+        const subtype = batch.events[0].subtype;
+        if (raw.payload.kind === "post") expect(subtype).toBe("post");
+        if (raw.payload.kind === "search") expect(subtype).toBe("interaction");
+      }
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("normalize captures post metrics", async () => {
+    const a = new WeiboAdapter({ account: { uid: "1234" } });
+    const raw = {
+      adapter: "social-weibo",
+      originalId: "post-M1",
+      capturedAt: 1700000000000,
+      payload: {
+        kind: "post",
+        row: {
+          id: 1, mid: "M1", text: "测试",
+          created_at: 1700000000,
+          reposts_count: 5, comments_count: 3, attitudes_count: 10,
+          location: "上海",
+        },
+      },
+    };
+    const batch = a.normalize(raw);
+    expect(batch.events[0].extra.weiboMid).toBe("M1");
+    expect(batch.events[0].extra.repostsCount).toBe(5);
+    expect(batch.events[0].extra.commentsCount).toBe(3);
+    expect(batch.events[0].extra.likesCount).toBe(10);
+    expect(batch.events[0].extra.location).toBe("上海");
+  });
+
+  it("normalize falls back when text is empty", async () => {
+    const a = new WeiboAdapter({ account: { uid: "1234" } });
+    const raw = {
+      adapter: "social-weibo",
+      originalId: "post-x",
+      capturedAt: Date.now(),
+      payload: {
+        kind: "post",
+        row: { id: 1, mid: "X", text: "", created_at: Math.floor(Date.now() / 1000) },
+      },
+    };
+    const batch = a.normalize(raw);
+    expect(batch.events[0].content.title).toBe("(空)");
+    expect(validateBatch(batch).valid).toBe(true);
+  });
+});