@chainlesschain/personal-data-hub 0.1.0 → 0.2.1

package/__tests__/mobile-extractor.test.js

@@ -0,0 +1,288 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { AndroidExtractor, iOSBackupReader } = require("../lib/mobile-extractor");
+
+// ─── AndroidExtractor — mocked execFn ────────────────────────────────────
+
+function mockExec(scriptMap) {
+  // scriptMap: { "args joined by space": { stdout: "...", stderr: "..." }
+  // | () => Promise<{stdout, stderr}> }
+  return async (cmd, args) => {
+    const key = args.join(" ");
+    if (key in scriptMap) {
+      const v = scriptMap[key];
+      return typeof v === "function" ? await v() : v;
+    }
+    // Allow prefix matches for convenience
+    for (const k of Object.keys(scriptMap)) {
+      if (key.startsWith(k)) {
+        const v = scriptMap[k];
+        return typeof v === "function" ? await v() : v;
+      }
+    }
+    throw new Error(`mockExec: no script for: ${cmd} ${key}`);
+  };
+}
+
+describe("AndroidExtractor", () => {
+  it("listDevices parses adb output", async () => {
+    const ext = new AndroidExtractor({
+      execFn: mockExec({
+        "devices -l": {
+          stdout:
+            "List of devices attached\n" +
+            "ABCDEF123  device  product:redmi  model:Redmi_24115RA8EC  device:redmi\n" +
+            "OFFLINE99  offline\n",
+          stderr: "",
+        },
+      }),
+    });
+    const devices = await ext.listDevices();
+    expect(devices).toHaveLength(2);
+    expect(devices[0].serial).toBe("ABCDEF123");
+    expect(devices[0].state).toBe("device");
+    expect(devices[0].model).toBe("Redmi_24115RA8EC");
+    expect(devices[1].state).toBe("offline");
+  });
+
+  it("isDeviceReady checks state", async () => {
+    const ext = new AndroidExtractor({
+      execFn: mockExec({
+        "devices -l": {
+          stdout: "List of devices attached\nABCDEF123  device  product:p\n",
+          stderr: "",
+        },
+      }),
+    });
+    expect(await ext.isDeviceReady("ABCDEF123")).toBe(true);
+    expect(await ext.isDeviceReady("BAD-SERIAL")).toBe(false);
+  });
+
+  it("probeRoot detects Magisk + selinux", async () => {
+    const ext = new AndroidExtractor({
+      execFn: mockExec({
+        "-s ABC shell which su": { stdout: "/system/bin/magisk\n" },
+        "-s ABC shell which magisk": { stdout: "/system/bin/magisk\n" },
+        "-s ABC shell getenforce": { stdout: "Enforcing\n" },
+      }),
+    });
+    const probe = await ext.probeRoot("ABC");
+    expect(probe.rooted).toBe(true);
+    expect(probe.su).toBe("magisk-su");
+    expect(probe.magiskInstalled).toBe(true);
+    expect(probe.selinux).toBe("enforcing");
+  });
+
+  it("probeRoot non-rooted device", async () => {
+    const ext = new AndroidExtractor({
+      execFn: mockExec({
+        "-s ABC shell which su": { stdout: "" },
+        "-s ABC shell which magisk": { stdout: "" },
+        "-s ABC shell getenforce": { stdout: "Enforcing\n" },
+      }),
+    });
+    const probe = await ext.probeRoot("ABC");
+    expect(probe.rooted).toBe(false);
+    expect(probe.su).toBeNull();
+  });
+
+  it("listPackages filters user-installed by default", async () => {
+    const ext = new AndroidExtractor({
+      execFn: mockExec({
+        "-s ABC shell pm list packages -3": {
+          stdout: "package:com.tencent.mm\npackage:com.taobao.taobao\n",
+        },
+      }),
+    });
+    const pkgs = await ext.listPackages("ABC");
+    expect(pkgs).toEqual(["com.tencent.mm", "com.taobao.taobao"]);
+  });
+
+  it("pull creates dest dir + invokes adb pull", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ax-"));
+    let pulled = false;
+    const ext = new AndroidExtractor({
+      execFn: async (cmd, args) => {
+        if (args[2] === "pull") {
+          pulled = true;
+          // Simulate adb pull writing to dest
+          fs.writeFileSync(args[4], "fake-pulled-content");
+          return { stdout: "1 file pulled", stderr: "" };
+        }
+        throw new Error("unexpected adb call");
+      },
+    });
+    const dest = path.join(dir, "sub/file.bin");
+    await ext.pull("ABC", "/sdcard/x.bin", dest);
+    expect(pulled).toBe(true);
+    expect(fs.existsSync(dest)).toBe(true);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("pullFromAppPrivate uses su cat + temp + cleanup", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ax-"));
+    const calls = [];
+    const ext = new AndroidExtractor({
+      execFn: async (cmd, args) => {
+        calls.push(args.join(" "));
+        if (args[2] === "shell" && args[3].startsWith("su -c 'cat")) {
+          return { stdout: "", stderr: "" };
+        }
+        if (args[2] === "pull") {
+          fs.writeFileSync(args[4], "decrypted-db-bytes");
+          return { stdout: "", stderr: "" };
+        }
+        if (args[2] === "shell" && args[3].startsWith("rm -f")) {
+          return { stdout: "", stderr: "" };
+        }
+        throw new Error("unexpected adb call: " + args.join(" "));
+      },
+    });
+    const dest = path.join(dir, "EnMicroMsg.db");
+    await ext.pullFromAppPrivate("ABC", "com.tencent.mm", "/data/data/com.tencent.mm/MicroMsg/x/EnMicroMsg.db", dest);
+    expect(fs.existsSync(dest)).toBe(true);
+    // Verify su cat happened + cleanup rm happened
+    expect(calls.some((c) => c.includes("su -c 'cat"))).toBe(true);
+    expect(calls.some((c) => c.includes("rm -f"))).toBe(true);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("lsAppPrivate parses ls -1 output", async () => {
+    const ext = new AndroidExtractor({
+      execFn: mockExec({
+        "-s ABC shell su -c 'ls -1 \"/data/data/com.tencent.mm\"'": {
+          stdout: "MicroMsg\nshared_prefs\nfiles\ncache\n",
+        },
+      }),
+    });
+    const ls = await ext.lsAppPrivate("ABC", "/data/data/com.tencent.mm");
+    expect(ls).toContain("MicroMsg");
+    expect(ls).toContain("shared_prefs");
+  });
+});
+
+// ─── iOSBackupReader — fixture-driven ────────────────────────────────────
+
+describe("iOSBackupReader", () => {
+  let dir;
+
+  function makeBackup({ encrypted = false } = {}) {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "ios-bk-"));
+    fs.writeFileSync(
+      path.join(dir, "Manifest.plist"),
+      `<?xml version="1.0"?><plist version="1.0"><dict>
+<key>IsEncrypted</key>${encrypted ? "<true/>" : "<false/>"}
+</dict></plist>`,
+    );
+    fs.writeFileSync(
+      path.join(dir, "Info.plist"),
+      `<?xml version="1.0"?><plist version="1.0"><dict>
+<key>Device Name</key><string>Test iPhone</string>
+<key>Product Type</key><string>iPhone15,2</string>
+<key>Product Version</key><string>18.0</string>
+</dict></plist>`,
+    );
+    // Empty SQLite Manifest.db — mock driver below skips it
+    fs.writeFileSync(path.join(dir, "Manifest.db"), Buffer.from("SQLite format 3\0"));
+    return dir;
+  }
+
+  afterEach(() => {
+    if (dir) {
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) {}
+    }
+    dir = null;
+  });
+
+  it("constructor rejects missing dir", () => {
+    expect(() => new iOSBackupReader({ backupDir: "/nonexistent/path/xx" })).toThrow();
+    expect(() => new iOSBackupReader({})).toThrow(/backupDir/);
+  });
+
+  it("encrypted backup throws (Phase 7.5b TODO)", async () => {
+    const backupDir = makeBackup({ encrypted: true });
+    const reader = new iOSBackupReader({
+      backupDir,
+      dbDriverFn: () => {
+        throw new Error("driver should not be called when encrypted");
+      },
+    });
+    await expect(reader.open()).rejects.toThrow(/encrypted/);
+  });
+
+  it("open() reads Info.plist + opens Manifest.db", async () => {
+    const backupDir = makeBackup({ encrypted: false });
+    // Mock SQLite driver
+    const mockDb = {
+      prepare: () => ({ all: () => [], get: () => undefined }),
+      close: () => {},
+    };
+    const mockDriver = () => mockDb;
+    const reader = new iOSBackupReader({ backupDir, dbDriverFn: mockDriver });
+    const r = await reader.open();
+    expect(r.encrypted).toBe(false);
+    expect(r.info["Device Name"]).toBe("Test iPhone");
+    expect(r.info["Product Version"]).toBe("18.0");
+    reader.close();
+  });
+
+  it("listFiles passes WHERE clauses based on opts", async () => {
+    const backupDir = makeBackup({ encrypted: false });
+    let lastSql, lastParams;
+    const mockDriver = () => ({
+      prepare: (sql) => ({
+        all: (...params) => {
+          lastSql = sql;
+          lastParams = params;
+          return [{ fileID: "abc", domain: "HomeDomain", relativePath: "Library/Notes/notes.sqlite", flags: 1 }];
+        },
+      }),
+      close: () => {},
+    });
+    const reader = new iOSBackupReader({ backupDir, dbDriverFn: mockDriver });
+    await reader.open();
+    const files = reader.listFiles({ domain: "HomeDomain", limit: 10 });
+    expect(files).toHaveLength(1);
+    expect(lastSql).toContain("WHERE domain = ?");
+    expect(lastParams).toContain("HomeDomain");
+    reader.close();
+  });
+
+  it("resolveFileOnDisk shards by first 2 chars", async () => {
+    const backupDir = makeBackup({ encrypted: false });
+    const mockDriver = () => ({
+      prepare: () => ({ all: () => [], get: () => undefined }),
+      close: () => {},
+    });
+    const reader = new iOSBackupReader({ backupDir, dbDriverFn: mockDriver });
+    await reader.open();
+    const p = reader.resolveFileOnDisk("abcd1234567890");
+    expect(p).toBe(path.join(backupDir, "ab", "abcd1234567890"));
+    reader.close();
+  });
+
+  it("copyOut copies the sharded file to localPath", async () => {
+    const backupDir = makeBackup({ encrypted: false });
+    // Create a fake sharded file
+    const fileID = "abc1234";
+    const shardedDir = path.join(backupDir, "ab");
+    fs.mkdirSync(shardedDir, { recursive: true });
+    fs.writeFileSync(path.join(shardedDir, fileID), "test-content");
+
+    const mockDriver = () => ({
+      prepare: () => ({ all: () => [], get: () => undefined }),
+      close: () => {},
+    });
+    const reader = new iOSBackupReader({ backupDir, dbDriverFn: mockDriver });
+    await reader.open();
+    const local = path.join(backupDir, "out", "extracted.bin");
+    reader.copyOut(fileID, local);
+    expect(fs.readFileSync(local, "utf-8")).toBe("test-content");
+    reader.close();
+  });
+});

package/__tests__/registry.test.js

@@ -178,7 +178,9 @@ describe("AdapterRegistry.syncAdapter", () => {
   it("refuses concurrent sync of two adapters in one registry", async () => {
     freshVault();
     const reg = new AdapterRegistry({ vault });
-    reg.register(new MockAdapter({ name: "a", count: 5000 })); // long enough to be in-flight
+    // Use 500 events (not 5000) — still big enough to be mid-flight when
+    // the second syncAdapter() lands, but fits comfortably in 10s.
+    reg.register(new MockAdapter({ name: "a", count: 500 }));
     reg.register(new MockAdapter({ name: "b", count: 5 }));
 
     const p1 = reg.syncAdapter("a");
@@ -194,7 +196,7 @@ describe("AdapterRegistry.syncAdapter", () => {
     // assert no double-sync corruption. The active-sync invariant is
     // additionally enforced by the activeSync flag.
     expect(racedReject == null || /already syncing/.test(racedReject.message)).toBe(true);
-  });
+  }, 30_000);
 });
 
 // ─── KG + RAG sinks ──────────────────────────────────────────────────────

package/__tests__/shopping-adapters.test.js

@@ -0,0 +1,296 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  normalizeOrderRecord,
+  CookieAuth,
+  TaobaoAdapter,
+  JdAdapter,
+  MeituanAdapter,
+} = require("../lib");
+const { orderToRecord: taobaoOrderToRecord, parseTaobaoTime } = require("../lib/adapters/shopping-taobao");
+const { orderToRecord: jdOrderToRecord } = require("../lib/adapters/shopping-jd");
+const { orderToRecord: meituanOrderToRecord } = require("../lib/adapters/shopping-meituan");
+const { assertAdapter } = require("../lib/adapter-spec");
+const { validateBatch } = require("../lib/batch");
+
+// ─── normalizeOrderRecord ───────────────────────────────────────────────
+
+describe("normalizeOrderRecord", () => {
+  it("produces Event + merchant Person + Item entities", () => {
+    const rec = {
+      vendorId: "taobao",
+      orderId: "ORD-1",
+      placedAt: 1700000000000,
+      paidAt: 1700000010000,
+      status: "delivered",
+      merchantName: "Apple官方旗舰店",
+      totalAmount: { value: 9999, currency: "CNY" },
+      items: [
+        { name: "iPhone 17 Pro 256GB", quantity: 1, unitPrice: 9999 },
+      ],
+      recipient: "张三",
+      shippingAddress: "上海市某区某路",
+      trackingNumber: "SF1234567",
+    };
+    const b = normalizeOrderRecord(rec, { adapterName: "shopping-taobao", adapterVersion: "0.5.0" });
+    expect(b.events).toHaveLength(1);
+    expect(b.events[0].subtype).toBe("order");
+    expect(b.events[0].content.amount.value).toBe(9999);
+    expect(b.events[0].content.amount.direction).toBe("out");
+    expect(b.events[0].extra.merchantOrderNumber).toBe("ORD-1"); // cross-source link
+    expect(b.events[0].extra.orderStatus).toBe("delivered");
+    expect(b.events[0].extra.trackingNumber).toBe("SF1234567");
+    expect(b.persons).toHaveLength(1);
+    expect(b.persons[0].subtype).toBe("merchant");
+    expect(b.items).toHaveLength(1);
+    expect(b.items[0].name).toBe("iPhone 17 Pro 256GB");
+    const v = validateBatch(b);
+    expect(v.valid).toBe(true);
+  });
+
+  it("refund status maps to refund subtype + amount in", () => {
+    const rec = {
+      vendorId: "taobao", orderId: "X", placedAt: Date.now(),
+      status: "refunded", merchantName: "Test",
+      totalAmount: { value: 100, currency: "CNY" },
+    };
+    const b = normalizeOrderRecord(rec, { adapterName: "shopping-taobao" });
+    expect(b.events[0].subtype).toBe("refund");
+    expect(b.events[0].content.amount.direction).toBe("in");
+  });
+
+  it("cancelled status maps to cancelled subtype", () => {
+    const rec = {
+      vendorId: "jd", orderId: "X", placedAt: Date.now(),
+      status: "已取消", merchantName: "Test",
+    };
+    const b = normalizeOrderRecord(rec, { adapterName: "shopping-jd" });
+    expect(b.events[0].subtype).toBe("cancelled");
+  });
+
+  it("requires orderId + merchantName", () => {
+    expect(() => normalizeOrderRecord({})).toThrow();
+    expect(() => normalizeOrderRecord({ orderId: "x" })).toThrow();
+  });
+});
+
+// ─── CookieAuth ──────────────────────────────────────────────────────────
+
+describe("CookieAuth", () => {
+  it("constructor requires platform", () => {
+    expect(() => new CookieAuth({})).toThrow(/platform/);
+  });
+
+  it("toHeader returns null for empty", () => {
+    const ca = new CookieAuth({ platform: "taobao" });
+    expect(ca.toHeader()).toBeNull();
+  });
+
+  it("toHeader returns the cookie string when set", () => {
+    const ca = new CookieAuth({ platform: "taobao", cookies: "k1=v1; k2=v2" });
+    expect(ca.toHeader()).toBe("k1=v1; k2=v2");
+  });
+
+  it("getCookieValue reads single cookie", () => {
+    const ca = new CookieAuth({ platform: "taobao", cookies: "k1=v1; k2=v%20space" });
+    expect(ca.getCookieValue("k1")).toBe("v1");
+    expect(ca.getCookieValue("k2")).toBe("v space"); // decoded
+    expect(ca.getCookieValue("missing")).toBeNull();
+  });
+
+  it("validate returns false for empty", async () => {
+    const ca = new CookieAuth({ platform: "taobao" });
+    expect(await ca.validate()).toBe(false);
+  });
+
+  it("validate uses injected validator", async () => {
+    const ca = new CookieAuth({
+      platform: "taobao",
+      cookies: "k=v",
+      validator: async (c) => c.includes("good"),
+    });
+    expect(await ca.validate()).toBe(false);
+    ca.setCookies("good=ok");
+    expect(await ca.validate()).toBe(true);
+  });
+});
+
+// ─── TaobaoAdapter ──────────────────────────────────────────────────────
+
+describe("TaobaoAdapter", () => {
+  it("contract conformance", () => {
+    const a = new TaobaoAdapter({ account: { userId: "u-1", cookies: "k=v" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.extractMode).toBe("web-api");
+  });
+
+  it("orderToRecord maps Taobao fields", () => {
+    const o = {
+      bizOrderId: "TB-1",
+      sellerNick: "Apple官方旗舰店",
+      createTime: 1700000000,
+      payTime: 1700000010,
+      statusText: "已发货",
+      actualFee: "9999.00",
+      subOrders: [
+        { itemTitle: "iPhone 17", buyCount: 1, itemPrice: "9999" },
+      ],
+      receiverName: "张三",
+      fullAddress: "上海...",
+    };
+    const rec = taobaoOrderToRecord(o);
+    expect(rec.orderId).toBe("TB-1");
+    expect(rec.merchantName).toBe("Apple官方旗舰店");
+    expect(rec.status).toBe("shipped");
+    expect(rec.totalAmount.value).toBe(9999);
+    expect(rec.items).toHaveLength(1);
+    expect(rec.placedAt).toBeGreaterThan(0);
+  });
+
+  it("parseTaobaoTime upgrades seconds → ms", () => {
+    expect(parseTaobaoTime(1700000000)).toBe(1700000000000);
+    expect(parseTaobaoTime(1700000000000)).toBe(1700000000000);
+    expect(parseTaobaoTime("2026-04-15T10:00:00Z")).toBeGreaterThan(0);
+  });
+
+  it("sync yields raw events from fetchFn fixture", async () => {
+    const fetchFn = async () => ({
+      orders: [
+        {
+          bizOrderId: "TB-2", sellerNick: "Test",
+          createTime: 1700000000, payTime: 1700000010,
+          statusText: "已签收", actualFee: "100",
+          subOrders: [{ itemTitle: "Item A", buyCount: 1, itemPrice: "100" }],
+        },
+      ],
+    });
+    const a = new TaobaoAdapter({
+      account: { userId: "u-1", cookies: "valid=cookie" },
+      fetchFn,
+    });
+    const raws = [];
+    for await (const r of a.sync({ pageSize: 20, sinceWatermark: 0 })) raws.push(r);
+    expect(raws).toHaveLength(1);
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+  });
+
+  it("sync no-ops on invalid cookies", async () => {
+    const a = new TaobaoAdapter({ account: { userId: "u-1" } }); // no cookies
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    expect(raws).toHaveLength(0);
+  });
+});
+
+// ─── JdAdapter ───────────────────────────────────────────────────────────
+
+describe("JdAdapter", () => {
+  it("contract conformance", () => {
+    const a = new JdAdapter({ account: { pin: "p1", cookies: "k=v" } });
+    expect(assertAdapter(a).ok).toBe(true);
+  });
+
+  it("orderToRecord maps JD fields", () => {
+    const o = {
+      orderId: "JD-1",
+      orderTotalPrice: "1999.00",
+      orderStartTime: "2026-04-15 10:00:00",
+      orderStatusText: "已收货",
+      venderName: "京东自营",
+      productList: [
+        { productName: "Kindle", productPrice: "999", productQuantity: 2 },
+      ],
+      consigneeName: "张三",
+    };
+    const rec = jdOrderToRecord(o);
+    expect(rec.orderId).toBe("JD-1");
+    expect(rec.merchantName).toBe("京东自营");
+    expect(rec.status).toBe("delivered");
+    expect(rec.totalAmount.value).toBe(1999);
+    expect(rec.items[0].name).toBe("Kindle");
+    expect(rec.items[0].quantity).toBe(2);
+  });
+
+  it("sync + normalize end-to-end", async () => {
+    const fetchFn = async () => ({
+      orders: [
+        {
+          orderId: "JD-2", orderTotalPrice: "299",
+          orderStartTime: "2026-04-15 10:00:00",
+          orderStatusText: "已发货",
+          venderName: "京东",
+          productList: [{ productName: "鼠标", productPrice: "299", productQuantity: 1 }],
+        },
+      ],
+    });
+    const a = new JdAdapter({
+      account: { pin: "p1", cookies: "v=ok" },
+      fetchFn,
+    });
+    const raws = [];
+    for await (const r of a.sync({ sinceWatermark: 0 })) raws.push(r);
+    expect(raws).toHaveLength(1);
+    expect(validateBatch(a.normalize(raws[0])).valid).toBe(true);
+  });
+});
+
+// ─── MeituanAdapter ──────────────────────────────────────────────────────
+
+describe("MeituanAdapter", () => {
+  it("contract conformance", () => {
+    const a = new MeituanAdapter({ account: { userId: "u-1", cookies: "k=v" } });
+    expect(assertAdapter(a).ok).toBe(true);
+  });
+
+  it("orderToRecord maps Meituan 外卖 fields", () => {
+    const o = {
+      orderId: "MT-1",
+      poiName: "麦当劳(中山公园店)",
+      orderTime: 1700000000,
+      payTime: 1700000010,
+      statusDesc: "已送达",
+      totalPrice: "45.50",
+      dishes: [
+        { name: "巨无霸套餐", quantity: 1, price: "45.5" },
+      ],
+      recipientAddress: "上海...",
+    };
+    const rec = meituanOrderToRecord(o, "waimai");
+    expect(rec.orderId).toBe("MT-1");
+    expect(rec.merchantName).toBe("麦当劳(中山公园店)");
+    expect(rec.status).toBe("delivered");
+    expect(rec.totalAmount.value).toBe(45.5);
+    expect(rec.extras.platform).toBe("waimai");
+  });
+
+  it("sync iterates multiple platforms", async () => {
+    const seen = [];
+    const fetchFn = async (opts) => {
+      seen.push(opts.query.platform);
+      return {
+        orders: [
+          {
+            orderId: `MT-${opts.query.platform}`,
+            poiName: "Test",
+            orderTime: 1700000000,
+            statusDesc: "已完成",
+            totalPrice: "10",
+            dishes: [{ name: "x", quantity: 1, price: "10" }],
+          },
+        ],
+      };
+    };
+    const a = new MeituanAdapter({
+      account: { userId: "u-1", cookies: "v=ok" },
+      fetchFn,
+    });
+    const raws = [];
+    for await (const r of a.sync({ sinceWatermark: 0, platforms: ["waimai", "groupbuy"] })) raws.push(r);
+    expect(seen).toContain("waimai");
+    expect(seen).toContain("groupbuy");
+    expect(raws.length).toBeGreaterThan(0);
+  });
+});