@chainlesschain/personal-data-hub 0.1.0 → 0.2.0

package/__tests__/longtail-adapters.test.js

@@ -0,0 +1,217 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  DouyinAdapter,
+  XiaohongshuAdapter,
+  QQAdapter,
+  TelegramAdapter,
+} = 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");
+          },
+        };
+      },
+      pragma() {},
+      close() {},
+    };
+  };
+}
+
+function tmpDb() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "longtail-"));
+  const dbPath = path.join(dir, "fake.db");
+  fs.writeFileSync(dbPath, "fake");
+  return { dir, dbPath };
+}
+
+function cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) {}
+}
+
+// ─── DouyinAdapter ──────────────────────────────────────────────────────
+
+describe("DouyinAdapter", () => {
+  it("contract conformance", () => {
+    const a = new DouyinAdapter({ account: { uid: "u-1" } });
+    expect(assertAdapter(a).ok).toBe(true);
+  });
+
+  it("rejects missing account.uid", () => {
+    expect(() => new DouyinAdapter({ account: {} })).toThrow(/uid/);
+  });
+
+  it("sync yields history + favourite + search", async () => {
+    const { dir, dbPath } = tmpDb();
+    try {
+      const mockDriver = makeMockDriver([
+        ["FROM video_history", [{ id: 1, aweme_id: "v1", title: "Cat", view_time: 1700000000, author: "@cat", duration: 30 }]],
+        ["FROM history", []],
+        ["FROM user_favorite", [{ id: 1, aweme_id: "v2", title: "Saved", create_time: 1700001000 }]],
+        ["FROM favourite", []],
+        ["FROM search_history", [{ id: 1, keyword: "music", time: 1700002000 }]],
+      ]);
+      const a = new DouyinAdapter({ account: { uid: "u-1" }, dbPath, dbDriverFactory: () => mockDriver });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3);
+      for (const r of raws) {
+        expect(validateBatch(a.normalize(r)).valid).toBe(true);
+      }
+    } finally { cleanup(dir); }
+  });
+});
+
+// ─── XiaohongshuAdapter ─────────────────────────────────────────────────
+
+describe("XiaohongshuAdapter", () => {
+  it("contract conformance", () => {
+    const a = new XiaohongshuAdapter({ account: { uid: "u-1" } });
+    expect(assertAdapter(a).ok).toBe(true);
+  });
+
+  it("rejects missing account.uid", () => {
+    expect(() => new XiaohongshuAdapter({ account: {} })).toThrow(/uid/);
+  });
+
+  it("sync yields history + likes + favourites", async () => {
+    const { dir, dbPath } = tmpDb();
+    try {
+      const mockDriver = makeMockDriver([
+        ["FROM browse_history", [{ id: 1, note_id: "n1", title: "Recipe", view_time: 1700000000, author: "chef" }]],
+        ["FROM note", []],
+        ["FROM liked_note", [{ id: 1, note_id: "n2", title: "Liked", like_time: 1700001000 }]],
+        ["FROM favourite", [{ id: 1, note_id: "n3", title: "Saved", save_time: 1700002000 }]],
+      ]);
+      const a = new XiaohongshuAdapter({ account: { uid: "u-1" }, dbPath, dbDriverFactory: () => mockDriver });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3);
+      for (const r of raws) {
+        const batch = a.normalize(r);
+        expect(validateBatch(batch).valid).toBe(true);
+      }
+    } finally { cleanup(dir); }
+  });
+});
+
+// ─── QQAdapter ──────────────────────────────────────────────────────────
+
+describe("QQAdapter", () => {
+  it("contract conformance", () => {
+    const a = new QQAdapter({ account: { qq: "12345" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.dataDisclosure.legalGate).toBe(true);
+  });
+
+  it("rejects missing account.qq", () => {
+    expect(() => new QQAdapter({ account: {} })).toThrow(/qq/);
+  });
+
+  it("authenticate fails without DB", async () => {
+    const a = new QQAdapter({ account: { qq: "12345" }, keyProvider: { getKey: async () => "k" } });
+    const r = await a.authenticate();
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("DB_NOT_PULLED");
+  });
+
+  it("authenticate fails without keyProvider", async () => {
+    const { dir, dbPath } = tmpDb();
+    try {
+      const a = new QQAdapter({ account: { qq: "12345" }, dbPath });
+      const r = await a.authenticate();
+      expect(r.reason).toBe("NO_KEY_PROVIDER");
+    } finally { cleanup(dir); }
+  });
+
+  it("sync yields contact + group + message types", async () => {
+    const { dir, dbPath } = tmpDb();
+    try {
+      const mockDriver = makeMockDriver([
+        ["FROM mr_friend", [{ uin: "999", nickname: "好友A", remark: "" }]],
+        ["FROM mr_troop", [{ troop_uin: "888", troop_name: "测试群" }]],
+        ["FROM sqlite_master", [{ name: "msgcsr_friend_999" }]],
+        ["FROM msgcsr_friend_999", [{ msgid: "m1", msg: "你好", time: 1700000000, frienduin: "999", msgtype: 1 }]],
+      ]);
+      const a = new QQAdapter({
+        account: { qq: "12345" },
+        dbPath,
+        keyProvider: { getKey: async () => "fakekey" },
+        dbDriverFactory: () => mockDriver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3); // contact + group + message
+      const contact = raws.find((r) => r.payload.kind === "contact");
+      const group = raws.find((r) => r.payload.kind === "group");
+      const message = raws.find((r) => r.payload.kind === "message");
+      expect(contact).toBeDefined();
+      expect(group).toBeDefined();
+      expect(message).toBeDefined();
+      for (const r of raws) {
+        expect(validateBatch(a.normalize(r)).valid).toBe(true);
+      }
+    } finally { cleanup(dir); }
+  });
+});
+
+// ─── TelegramAdapter ────────────────────────────────────────────────────
+
+describe("TelegramAdapter", () => {
+  it("contract conformance", () => {
+    const a = new TelegramAdapter({ account: { userId: "u-1" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.dataDisclosure.legalGate).toBe(true);
+  });
+
+  it("rejects missing account.userId", () => {
+    expect(() => new TelegramAdapter({ account: {} })).toThrow(/userId/);
+  });
+
+  it("sync yields user + chat + messages (no key needed)", async () => {
+    const { dir, dbPath } = tmpDb();
+    try {
+      const mockDriver = makeMockDriver([
+        ["FROM users", [{ uid: "111", name: "Alice", username: "alice", phone: "13800001111" }]],
+        ["FROM chats", [{ uid: "222", name: "Group A" }]],
+        ["FROM messages_v2", [{ mid: "m1", uid: "111", message: "Hi", date: 1700000000, out: 0 }]],
+        ["FROM messages", []],
+      ]);
+      const a = new TelegramAdapter({ account: { userId: "u-1" }, dbPath, dbDriverFactory: () => mockDriver });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3);
+      for (const r of raws) {
+        expect(validateBatch(a.normalize(r)).valid).toBe(true);
+      }
+    } finally { cleanup(dir); }
+  });
+
+  it("normalize contact includes phone identifier", async () => {
+    const a = new TelegramAdapter({ account: { userId: "u-1" } });
+    const batch = a.normalize({
+      adapter: "messaging-telegram",
+      originalId: "user-111",
+      capturedAt: Date.now(),
+      payload: { kind: "contact", row: { uid: "111", name: "Bob", phone: "13800001111" } },
+    });
+    expect(batch.persons[0].identifiers.telegramId).toBe("111");
+    expect(batch.persons[0].identifiers.phone).toEqual(["13800001111"]);
+  });
+});

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();
+  });
+});