@chainlesschain/personal-data-hub 0.4.28 → 0.4.30

package/__tests__/social-weibo-sqlite-device.test.js

@@ -1,174 +0,0 @@
-"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 { WeiboAdapter } = require("../lib/adapters/social-weibo");
-
-// §A8 sqlite mode — device-verified schema regression tests.
-//
-// The legacy sqlite path queried `post`/`status`/`search_history`, but a real
-// Weibo install (Redmi M2104K10AC, 微博 16.5.3, verified 2026-06-16) has NO
-// such tables — its data lives in `home_table` (timeline), `like_table`
-// (likes), `follower_table` (following). So the legacy path silently
-// collected ZERO on a real device. These tests pin the device-verified
-// table/column mapping + the legacy fallback.
-//
-// A fake driver returns synthetic rows keyed off the table name in the SQL,
-// and throws "no such table" for absent tables (mirroring better-sqlite3) so
-// `trySelect` falls through exactly as on a real DB.
-
-function makeFakeDriver(tables) {
-  return function dbDriverFactory() {
-    return class FakeDb {
-      constructor() {}
-      prepare(sql) {
-        return {
-          all: () => {
-            for (const [name, rows] of Object.entries(tables)) {
-              if (new RegExp(`FROM ${name}\\b`).test(sql)) return rows;
-            }
-            throw new Error("no such table");
-          },
-        };
-      }
-      close() {}
-    };
-  };
-}
-
-const SELF_UID = "2075014533";
-
-// Device-verified column shapes.
-const HOME_ROW = {
-  mblogid: "MID_001",
-  uid: SELF_UID,
-  own_uid: SELF_UID,
-  nick: "me",
-  content: "今天去爬山了 ⛰️",
-  time: "1718500000",
-  src: "微博 weibo.com",
-  rtnum: 3,
-  commentnum: 7,
-  attitudenum: 42,
-};
-const LIKE_ROW = {
-  mblogid: "MID_LIKED",
-  uid: "999",
-  nick: "好友A",
-  content: "一条被点赞的微博",
-  time: "1718400000",
-  attitudenum: 100,
-};
-const FOLLOW_ROW = {
-  user_id: "555",
-  id: "555",
-  screen_name: "关注的人",
-  remark: "",
-  gender: "f",
-  following: 1,
-};
-
-function newAdapter(tables) {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "weibo-sqlite-"));
-  const dbPath = path.join(tmp, "sina_weibo");
-  fs.writeFileSync(dbPath, "x"); // existsSync gate
-  const a = new WeiboAdapter({
-    account: { uid: SELF_UID },
-    dbPath,
-    dbDriverFactory: makeFakeDriver(tables),
-  });
-  return { a, dbPath, tmp };
-}
-
-async function collect(a, dbPath) {
-  const out = [];
-  for await (const raw of a.sync({ dbPath })) out.push(raw);
-  return out;
-}
-
-describe("WeiboAdapter sqlite mode — device-verified schema", () => {
-  let dirs = [];
-  afterEach(() => {
-    for (const d of dirs) {
-      try { fs.rmSync(d, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
-    }
-    dirs = [];
-  });
-
-  it("modern device (home/like/follower only) collects posts+favs+follows", async () => {
-    const { a, dbPath, tmp } = newAdapter({
-      home_table: [HOME_ROW],
-      like_table: [LIKE_ROW],
-      follower_table: [FOLLOW_ROW],
-    });
-    dirs.push(tmp);
-    const raws = await collect(a, dbPath);
-    const kinds = raws.map((r) => r.payload.kind).sort();
-    expect(kinds).toEqual(["favourite", "follow", "post"]);
-  });
-
-  it("home_table post normalizes content/time/counts correctly", async () => {
-    const { a, dbPath, tmp } = newAdapter({ home_table: [HOME_ROW] });
-    dirs.push(tmp);
-    const raws = await collect(a, dbPath);
-    expect(raws).toHaveLength(1);
-    const norm = a.normalize(raws[0]);
-    const ev = norm.events[0];
-    expect(ev.subtype).toBe("post");
-    expect(ev.content.text).toBe("今天去爬山了 ⛰️");
-    expect(ev.extra.weiboMid).toBe("MID_001");
-    expect(ev.extra.likesCount).toBe(42);
-    expect(ev.extra.repostsCount).toBe(3);
-    expect(ev.extra.commentsCount).toBe(7);
-    // time '1718500000' (epoch seconds) → ms
-    expect(ev.occurredAt).toBe(1718500000 * 1000);
-  });
-
-  it("like_table normalizes to a LIKE event with author nick", async () => {
-    const { a, dbPath, tmp } = newAdapter({ like_table: [LIKE_ROW] });
-    dirs.push(tmp);
-    const raws = await collect(a, dbPath);
-    const norm = a.normalize(raws[0]);
-    const ev = norm.events[0];
-    expect(ev.subtype).toBe("like");
-    expect(ev.content.text).toBe("一条被点赞的微博");
-    expect(ev.extra.weiboMid).toBe("MID_LIKED");
-    expect(ev.extra.authorScreenName).toBe("好友A");
-  });
-
-  it("follower_table normalizes to a CONTACT person with weibo-uid", async () => {
-    const { a, dbPath, tmp } = newAdapter({ follower_table: [FOLLOW_ROW] });
-    dirs.push(tmp);
-    const raws = await collect(a, dbPath);
-    const norm = a.normalize(raws[0]);
-    expect(norm.events).toHaveLength(0);
-    expect(norm.persons).toHaveLength(1);
-    const person = norm.persons[0];
-    expect(person.names).toEqual(["关注的人"]);
-    expect(person.identifiers["weibo-uid"]).toEqual(["555"]);
-  });
-
-  it("legacy device (post table, no home_table) still works via fallback", async () => {
-    const { a, dbPath, tmp } = newAdapter({
-      post: [{ id: "L1", text: "legacy post", created_at: "1700000000", attitudes_count: 5 }],
-    });
-    dirs.push(tmp);
-    const raws = await collect(a, dbPath);
-    expect(raws).toHaveLength(1);
-    const ev = a.normalize(raws[0]).events[0];
-    expect(ev.subtype).toBe("post");
-    expect(ev.content.text).toBe("legacy post");
-    expect(ev.extra.likesCount).toBe(5);
-  });
-
-  it("empty DB (none of the tables exist) collects nothing, no throw", async () => {
-    const { a, dbPath, tmp } = newAdapter({});
-    dirs.push(tmp);
-    const raws = await collect(a, dbPath);
-    expect(raws).toEqual([]);
-  });
-});

package/__tests__/social-xiaohongshu-snapshot.test.js

@@ -1,232 +0,0 @@
-"use strict";
-
-import { describe, it, expect, beforeEach } from "vitest";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const os = require("node:os");
-
-const {
-  XiaohongshuAdapter,
-  SNAPSHOT_SCHEMA_VERSION,
-  VALID_SNAPSHOT_KINDS,
-} = require("../lib/adapters/social-xiaohongshu");
-const { validateBatch } = require("../lib/batch");
-
-// §A8 v0.2 — snapshot-mode tests, mirror of social-weibo-snapshot.test.js.
-//
-// Snapshot mode is in-APK Android cc reading JSON written by XhsLocalCollector
-// (WebView + OkHttp + X-S signed requests). Sqlite/device-pull tests stay in
-// longtail-adapters.test.js (legacy Phase 13.4 path).
-
-function writeSnapshot(dir, snapshot) {
-  const p = path.join(dir, "social-xiaohongshu.json");
-  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
-  return p;
-}
-
-describe("XiaohongshuAdapter snapshot mode", () => {
-  let tmpDir;
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "xhs-snap-"));
-  });
-
-  it("exports SNAPSHOT_SCHEMA_VERSION = 1 + 3 VALID_SNAPSHOT_KINDS", () => {
-    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
-    expect(VALID_SNAPSHOT_KINDS).toEqual(["note", "liked", "follow"]);
-  });
-
-  it("authenticate(inputPath) ok when readable", async () => {
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1,
-      snapshottedAt: Date.now(),
-      events: [],
-    });
-    const a = new XiaohongshuAdapter();
-    const res = await a.authenticate({ inputPath: p });
-    expect(res.ok).toBe(true);
-    expect(res.mode).toBe("snapshot-file");
-  });
-
-  it("authenticate(inputPath) fails when path unreadable", async () => {
-    const a = new XiaohongshuAdapter();
-    const res = await a.authenticate({ inputPath: path.join(tmpDir, "missing.json") });
-    expect(res.ok).toBe(false);
-    expect(res.reason).toBe("INPUT_PATH_UNREADABLE");
-  });
-
-  it("authenticate() with neither inputPath nor dbPath returns NO_INPUT", async () => {
-    const a = new XiaohongshuAdapter();
-    const res = await a.authenticate({});
-    expect(res.ok).toBe(false);
-    expect(res.reason).toBe("NO_INPUT");
-  });
-
-  it("rejects schemaVersion mismatch", async () => {
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 99,
-      snapshottedAt: Date.now(),
-      events: [],
-    });
-    const a = new XiaohongshuAdapter();
-    let threw = null;
-    try {
-      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
-    } catch (err) {
-      threw = err;
-    }
-    expect(threw).toBeTruthy();
-    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
-  });
-
-  it("empty events array yields nothing (no crash)", async () => {
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1,
-      snapshottedAt: Date.now(),
-      events: [],
-    });
-    const a = new XiaohongshuAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p })) raws.push(r);
-    expect(raws.length).toBe(0);
-  });
-
-  it("note + liked + follow round-trip normalize cleanly", async () => {
-    const now = Date.now();
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1,
-      snapshottedAt: now,
-      account: { uid: "5e8c8f7e000000000abcdef0", numericUid: "12345", displayName: "alice" },
-      events: [
-        {
-          kind: "note",
-          id: "note-N1",
-          capturedAt: now - 1000,
-          title: "今日穿搭",
-          noteId: "N1",
-          desc: "夏日清凉",
-          type: "normal",
-          likedCount: 100,
-          collectedCount: 30,
-          commentCount: 15,
-        },
-        {
-          kind: "liked",
-          id: "liked-N2",
-          capturedAt: now - 2000,
-          title: "好喜欢的菜谱",
-          noteId: "N2",
-          authorNickname: "美食家",
-        },
-        {
-          kind: "follow",
-          id: "follow-USR99",
-          capturedAt: now - 3000,
-          userId: "USR99",
-          nickname: "carol",
-          image: "https://example.com/c.jpg",
-        },
-      ],
-    });
-    const a = new XiaohongshuAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p })) raws.push(r);
-    expect(raws.length).toBe(3);
-
-    const kinds = raws.map((r) => r.kind);
-    expect(kinds).toEqual(["note", "liked", "follow"]);
-
-    expect(raws[0].originalId).toMatch(/^xiaohongshu:note:/);
-    expect(raws[1].originalId).toMatch(/^xiaohongshu:liked:/);
-    expect(raws[2].originalId).toMatch(/^xiaohongshu:follow:/);
-
-    for (const raw of raws) {
-      const batch = a.normalize(raw);
-      expect(validateBatch(batch).valid).toBe(true);
-    }
-
-    const noteBatch = a.normalize(raws[0]);
-    expect(noteBatch.events[0].subtype).toBe("post");
-    expect(noteBatch.events[0].extra.noteId).toBe("N1");
-    expect(noteBatch.events[0].extra.likedCount).toBe(100);
-    expect(noteBatch.events[0].extra.collectedCount).toBe(30);
-    expect(noteBatch.events[0].extra.commentCount).toBe(15);
-    expect(noteBatch.events[0].extra.type).toBe("normal");
-    expect(noteBatch.events[0].source.capturedBy).toBe("api");
-
-    const likedBatch = a.normalize(raws[1]);
-    expect(likedBatch.events[0].subtype).toBe("like");
-    expect(likedBatch.events[0].extra.authorNickname).toBe("美食家");
-
-    const followBatch = a.normalize(raws[2]);
-    expect(followBatch.events.length).toBe(0);
-    expect(followBatch.persons.length).toBe(1);
-    expect(followBatch.persons[0].names).toEqual(["carol"]);
-    expect(followBatch.persons[0].identifiers["xiaohongshu-uid"]).toEqual(["USR99"]);
-  });
-
-  it("respects per-kind include opt-out", async () => {
-    const now = Date.now();
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1,
-      snapshottedAt: now,
-      events: [
-        { kind: "note", id: "n1", capturedAt: now, title: "t", noteId: "N1" },
-        { kind: "liked", id: "l1", capturedAt: now, title: "l", noteId: "N2" },
-        { kind: "follow", id: "fl1", capturedAt: now, userId: "U1", nickname: "x" },
-      ],
-    });
-    const a = new XiaohongshuAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p, include: { liked: false } })) {
-      raws.push(r);
-    }
-    const kinds = raws.map((r) => r.kind);
-    expect(kinds).toEqual(["note", "follow"]);
-  });
-
-  it("respects opts.limit", async () => {
-    const now = Date.now();
-    const events = Array.from({ length: 5 }, (_, i) => ({
-      kind: "note", id: `n${i}`, capturedAt: now - i * 100, title: `t${i}`, noteId: `N${i}`,
-    }));
-    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: now, events });
-    const a = new XiaohongshuAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p, limit: 2 })) raws.push(r);
-    expect(raws.length).toBe(2);
-  });
-
-  it("filters out unknown kinds (forward compat)", async () => {
-    const now = Date.now();
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1,
-      snapshottedAt: now,
-      events: [
-        { kind: "note", id: "n1", capturedAt: now, title: "ok", noteId: "N1" },
-        { kind: "future-kind", id: "x", capturedAt: now },
-        { kind: "history", id: "h", capturedAt: now }, // sqlite-only
-      ],
-    });
-    const a = new XiaohongshuAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p })) raws.push(r);
-    expect(raws.length).toBe(1);
-    expect(raws[0].kind).toBe("note");
-  });
-
-  it("snapshottedAt fallback when event capturedAt missing", async () => {
-    const ts = 1700000000000;
-    const p = writeSnapshot(tmpDir, {
-      schemaVersion: 1,
-      snapshottedAt: ts,
-      events: [
-        { kind: "note", id: "n1", title: "no time", noteId: "N1" },
-      ],
-    });
-    const a = new XiaohongshuAdapter();
-    const raws = [];
-    for await (const r of a.sync({ inputPath: p })) raws.push(r);
-    expect(raws[0].capturedAt).toBe(ts);
-  });
-});

package/__tests__/sqlite-leaf-salvage.test.js

@@ -1,97 +0,0 @@
-"use strict";
-
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const os = require("node:os");
-
-// The salvager lives in scripts/ (a standalone forensic tool) but exports its
-// pure parsers for testing.
-const {
-  parseLeafPage,
-  readVarint,
-  serialTypeSize,
-} = require("../../../scripts/android/pdh-sqlite-leaf-salvage.js");
-
-// Build a real (UTF-8) SQLite DB via the SQLCipher-capable driver, then salvage
-// records straight from its raw page bytes — proving the leaf-page parser reads
-// rowids + columns + UTF-8 text correctly (the Method-B reconstruction step for
-// scattered/malformed memory dumps). See docs/internal/pdh-db-decryption-runbook.md.
-describe("pdh-sqlite-leaf-salvage — leaf-page record salvager", () => {
-  let dir, dbPath, buf;
-  beforeAll(() => {
-    const Database = require("better-sqlite3-multiple-ciphers");
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), "salvage-"));
-    dbPath = path.join(dir, "u.db");
-    const db = new Database(dbPath);
-    db.exec(
-      "CREATE TABLE msg(msg_uuid TEXT, conversation_id TEXT, sender INTEGER, content TEXT, created_time INTEGER)",
-    );
-    const ins = db.prepare("INSERT INTO msg VALUES(?,?,?,?,?)");
-    ins.run("uuid-1", "conv-1", 111, "你好呀 hello", 1700000000000);
-    ins.run("uuid-2", "conv-1", 222, "在吗？晚上一起吃饭", 1700000001000);
-    ins.run("uuid-3", "conv-2", 333, "ok 👍", 1700000002000);
-    db.close();
-    buf = fs.readFileSync(dbPath);
-  });
-  afterAll(() => {
-    try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) { /* ignore */ }
-  });
-
-  it("varint + serialTypeSize basics", () => {
-    expect(readVarint(Buffer.from([0x01]), 0)[0]).toBe(1n);
-    expect(readVarint(Buffer.from([0x81, 0x00]), 0)[0]).toBe(128n);
-    expect(serialTypeSize(1n)).toBe(1); // 1-byte int
-    expect(serialTypeSize(6n)).toBe(8); // 8-byte int
-    expect(serialTypeSize(13n)).toBe(0); // text len 0
-    expect(serialTypeSize(0x29n)).toBe(14); // text serial 41 → 14 bytes
-  });
-
-  it("salvages all 3 msg rows with correct columns + UTF-8 text", () => {
-    const PAGE = 4096;
-    const records = [];
-    for (let base = 0; base + PAGE <= buf.length; base += PAGE) {
-      const recs = parseLeafPage(buf, base, PAGE, 3);
-      if (recs) records.push(...recs);
-    }
-    // find the msg rows (5 cols, content is the 4th)
-    const msgRows = records.filter((r) => r.cols.length === 5);
-    expect(msgRows.length).toBe(3);
-    const byUuid = Object.fromEntries(msgRows.map((r) => [r.cols[0], r]));
-    expect(byUuid["uuid-1"].cols[2]).toBe(111); // sender int
-    expect(byUuid["uuid-1"].cols[3]).toBe("你好呀 hello"); // UTF-8 intact
-    expect(byUuid["uuid-2"].cols[3]).toBe("在吗？晚上一起吃饭");
-    expect(byUuid["uuid-2"].cols[4]).toBe(1700000001000); // created_time
-    expect(byUuid["uuid-3"].cols[3]).toBe("ok 👍"); // emoji (4-byte UTF-8)
-  });
-
-  it("finds a leaf page at a NON-4096-aligned offset (unaligned scan)", () => {
-    const PAGE = 4096;
-    // locate a real data leaf page on the aligned grid
-    let leaf = null;
-    for (let base = 0; base + PAGE <= buf.length; base += PAGE) {
-      const recs = parseLeafPage(buf, base, PAGE, 3);
-      if (recs && recs.some((r) => r.cols.length === 5)) { leaf = buf.slice(base, base + PAGE); break; }
-    }
-    expect(leaf).not.toBeNull();
-    // embed it at a 512-aligned-but-not-4096-aligned offset inside a zero buffer
-    const big = Buffer.alloc(PAGE * 4, 0);
-    const off = 512 * 3; // 1536: hit by stride-512, missed by stride-4096
-    leaf.copy(big, off);
-    // aligned 4096-grid misses it
-    expect(parseLeafPage(big, 0, PAGE, 3)).toBeNull();
-    expect(parseLeafPage(big, PAGE, PAGE, 3)).toBeNull();
-    // unaligned stride finds it at its true offset
-    const recs = parseLeafPage(big, off, PAGE, 3);
-    expect(recs).not.toBeNull();
-    expect(recs.some((r) => r.cols[0] === "uuid-1")).toBe(true);
-  });
-
-  it("returns null for non-leaf / garbage pages", () => {
-    const garbage = Buffer.alloc(4096, 0xff);
-    expect(parseLeafPage(garbage, 0, 4096, 3)).toBeNull();
-    const zeros = Buffer.alloc(4096, 0);
-    expect(parseLeafPage(zeros, 0, 4096, 3)).toBeNull();
-  });
-});