@chainlesschain/personal-data-hub 0.4.29 → 0.4.31

package/__tests__/adapters/netease-music-live.test.js

@@ -1,244 +0,0 @@
-/**
- * 网易云音乐 LIVE cookie web-API (weapi) fetcher tests.
- * weapi crypto determinism (fixed secKey) + account/play/playlist parsing +
- * adapter cookie-mode sync + error mapping. All network via injected fetch.
- */
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { NeteaseMusicAdapter } = require("../../lib/adapters/netease-music");
-const {
-  NeteaseMusicApiClient,
-  weapiEncrypt,
-  aesEncrypt,
-  rsaEncrypt,
-  modpow,
-} = require("../../lib/adapters/netease-music/api-client");
-const { partitionBatch } = require("../../lib/batch");
-
-const FIXED_SECKEY = "0123456789abcdef"; // 16 chars → deterministic weapi
-const COOKIE = "MUSIC_U=abcdef0123456789; __csrf=zzz";
-
-/** Map endpoint path substrings → JSON bodies; record posted form bodies. */
-function makeFetch(routes, calls) {
-  return async (url, init) => {
-    calls.push({ url, body: init && init.body, headers: (init && init.headers) || {} });
-    const route = routes.find((r) => url.includes(r.match));
-    if (!route) return { ok: false, status: 404, text: async () => "not mapped" };
-    return {
-      ok: route.status ? route.status >= 200 && route.status < 300 : true,
-      status: route.status || 200,
-      text: async () =>
-        typeof route.body === "string" ? route.body : JSON.stringify(route.body),
-    };
-  };
-}
-
-async function collect(iter) {
-  const out = [];
-  for await (const r of iter) out.push(r);
-  return out;
-}
-
-describe("weapi crypto primitives", () => {
-  it("modpow matches BigInt ** % for small values", () => {
-    expect(modpow(4n, 13n, 497n)).toBe(445n); // textbook RSA example
-    expect(modpow(7n, 0n, 13n)).toBe(1n);
-  });
-
-  it("aesEncrypt is deterministic (fixed key + IV) and base64", () => {
-    const a = aesEncrypt("hello", "0CoJUm6Qyw8W8jud");
-    const b = aesEncrypt("hello", "0CoJUm6Qyw8W8jud");
-    expect(a).toBe(b);
-    expect(a).toMatch(/^[A-Za-z0-9+/=]+$/);
-  });
-
-  it("rsaEncrypt yields zero-padded 256-hex", () => {
-    const enc = rsaEncrypt("test", "010001", "e0b5");
-    expect(enc).toHaveLength(256);
-    expect(enc).toMatch(/^[0-9a-f]{256}$/);
-  });
-
-  it("weapiEncrypt produces stable { params, encSecKey } for a fixed secKey", () => {
-    const a = weapiEncrypt({ uid: 1 }, FIXED_SECKEY);
-    const b = weapiEncrypt({ uid: 1 }, FIXED_SECKEY);
-    expect(a).toEqual(b);
-    expect(a.encSecKey).toHaveLength(256);
-    expect(a.params).toMatch(/^[A-Za-z0-9+/=]+$/);
-  });
-});
-
-describe("NeteaseMusicApiClient.fetchSnapshot — live (mocked fetch)", () => {
-  it("resolves account, play record, playlists into snapshot-shaped events", async () => {
-    const calls = [];
-    const fetch = makeFetch(
-      [
-        {
-          match: "/weapi/w/nuser/account/get",
-          body: { code: 200, profile: { userId: 42, nickname: "听歌的人" }, account: { id: 42 } },
-        },
-        {
-          match: "/weapi/v1/play/record",
-          body: {
-            code: 200,
-            weekData: [
-              { playCount: 50, song: { id: 186016, name: "晴天", ar: [{ name: "周杰伦" }], al: { name: "叶惠美" } } },
-            ],
-          },
-        },
-        {
-          match: "/weapi/user/playlist",
-          body: {
-            code: 200,
-            playlist: [{ id: 999, name: "我喜欢的音乐", trackCount: 200, creator: { nickname: "听歌的人" } }],
-          },
-        },
-      ],
-      calls,
-    );
-    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
-    const result = await client.fetchSnapshot(COOKIE);
-    expect(result.account).toEqual({ uid: "42", nickname: "听歌的人" });
-    expect(result.events).toHaveLength(2);
-    const play = result.events.find((e) => e.kind === "play");
-    expect(play).toMatchObject({ songId: "186016", song: "晴天", artist: "周杰伦", album: "叶惠美", playCount: 50 });
-    const pl = result.events.find((e) => e.kind === "playlist");
-    expect(pl).toMatchObject({ playlistId: "999", name: "我喜欢的音乐", trackCount: 200, creator: "听歌的人" });
-    // every POST is form-encoded weapi (params + encSecKey) with the cookie.
-    for (const c of calls) {
-      expect(c.body).toMatch(/^params=.+&encSecKey=.+$/);
-      expect(c.headers.Cookie).toBe(COOKIE);
-      expect(c.headers["Content-Type"]).toContain("x-www-form-urlencoded");
-    }
-  });
-
-  it("multi-artist joined with ' / '; falls back to allData when weekData empty", async () => {
-    const calls = [];
-    const fetch = makeFetch(
-      [
-        { match: "account/get", body: { code: 200, profile: { userId: 7 } } },
-        {
-          match: "play/record",
-          body: {
-            code: 200,
-            weekData: [],
-            allData: [{ playCount: 3, song: { id: 1, name: "S", ar: [{ name: "A" }, { name: "B" }], al: { name: "Al" } } }],
-          },
-        },
-        { match: "user/playlist", body: { code: 200, playlist: [] } },
-      ],
-      calls,
-    );
-    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
-    const result = await client.fetchSnapshot(COOKIE);
-    const play = result.events.find((e) => e.kind === "play");
-    expect(play.artist).toBe("A / B");
-  });
-
-  it("include flags skip endpoints", async () => {
-    const calls = [];
-    const fetch = makeFetch(
-      [
-        { match: "account/get", body: { code: 200, profile: { userId: 7 } } },
-        { match: "user/playlist", body: { code: 200, playlist: [] } },
-      ],
-      calls,
-    );
-    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
-    const result = await client.fetchSnapshot(COOKIE, { include: { play: false } });
-    expect(calls.some((c) => c.url.includes("play/record"))).toBe(false);
-    expect(result.events.every((e) => e.kind !== "play")).toBe(true);
-  });
-
-  it("maps API code != 200 to null + lastError (e.g. -460 risk-control)", async () => {
-    const calls = [];
-    const fetch = makeFetch(
-      [{ match: "account/get", body: { code: -460, message: "Cheating" } }],
-      calls,
-    );
-    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
-    expect(await client.fetchSnapshot(COOKIE)).toBeNull();
-    expect(client.lastError.code).toBe(-460);
-    expect(client.lastError.message).toContain("Cheating");
-  });
-
-  it("account with no userId → null + lastError -7", async () => {
-    const calls = [];
-    const fetch = makeFetch([{ match: "account/get", body: { code: 200, profile: null, account: null } }], calls);
-    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
-    expect(await client.fetchSnapshot(COOKIE)).toBeNull();
-    expect(client.lastError.code).toBe(-7);
-  });
-
-  it("empty cookie → null + lastError -1 (no network)", async () => {
-    const calls = [];
-    const client = new NeteaseMusicApiClient({ fetch: makeFetch([], calls), secKey: FIXED_SECKEY });
-    expect(await client.fetchSnapshot("")).toBeNull();
-    expect(client.lastError.code).toBe(-1);
-    expect(calls).toHaveLength(0);
-  });
-
-  it("HTTP non-2xx → null + lastError with status", async () => {
-    const calls = [];
-    const fetch = makeFetch([{ match: "account/get", status: 502, body: "bad gw" }], calls);
-    const client = new NeteaseMusicApiClient({ fetch, secKey: FIXED_SECKEY });
-    expect(await client.fetchSnapshot(COOKIE)).toBeNull();
-    expect(client.lastError.code).toBe(502);
-  });
-});
-
-describe("NeteaseMusicAdapter — cookie (live) sync mode", () => {
-  it("authenticate accepts a cookie with MUSIC_U; rejects without it", async () => {
-    const a = new NeteaseMusicAdapter();
-    expect((await a.authenticate({ cookie: COOKIE })).mode).toBe("cookie");
-    const bad = await a.authenticate({ cookie: "foo=bar" });
-    expect(bad.ok).toBe(false);
-    expect(bad.reason).toBe("INVALID_COOKIE");
-  });
-
-  it("capabilities/version reflect v0.2 live mode", () => {
-    const a = new NeteaseMusicAdapter();
-    expect(a.version).toBe("0.2.0");
-    expect(a.capabilities).toContain("sync:cookie");
-  });
-
-  it("sync via cookie yields play+playlist raws → valid normalized batch", async () => {
-    const calls = [];
-    const fetch = makeFetch(
-      [
-        { match: "account/get", body: { code: 200, profile: { userId: 42, nickname: "me" } } },
-        {
-          match: "play/record",
-          body: { code: 200, weekData: [{ playCount: 9, song: { id: 5, name: "夜曲", ar: [{ name: "周杰伦" }], al: { name: "11月的萧邦" } } }] },
-        },
-        { match: "user/playlist", body: { code: 200, playlist: [{ id: 8, name: "练歌", trackCount: 12, creator: { nickname: "me" } }] } },
-      ],
-      calls,
-    );
-    const a = new NeteaseMusicAdapter();
-    const raws = await collect(a.sync({ cookie: COOKIE, fetch, secKey: FIXED_SECKEY }));
-    expect(raws.map((r) => r.kind).sort()).toEqual(["play", "playlist"]);
-    const playRaw = raws.find((r) => r.kind === "play");
-    expect(playRaw.originalId).toBe("netease-music:play:play-5");
-
-    // normalize → vault-valid batch for both kinds.
-    for (const raw of raws) {
-      const batch = a.normalize(raw);
-      const { invalidReasons } = partitionBatch(batch);
-      expect(invalidReasons).toHaveLength(0);
-    }
-    const playBatch = a.normalize(playRaw);
-    expect(playBatch.items[0].extra.songId).toBe("5");
-    expect(playBatch.events[0].content.title).toContain("夜曲");
-  });
-
-  it("sync via cookie throws (mapped lastError) on risk-control", async () => {
-    const calls = [];
-    const fetch = makeFetch([{ match: "account/get", body: { code: -460, message: "Cheating" } }], calls);
-    const a = new NeteaseMusicAdapter();
-    await expect(collect(a.sync({ cookie: COOKIE, fetch, secKey: FIXED_SECKEY }))).rejects.toThrow(
-      /Cheating|code -460/,
-    );
-  });
-});

package/__tests__/adapters/netease-music.test.js

@@ -1,74 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { NeteaseMusicAdapter } = require("../../lib/adapters/netease-music");
-const { partitionBatch } = require("../../lib/batch");
-
-const SNAPSHOT = {
-  schemaVersion: 1,
-  snapshottedAt: 1700000000000,
-  account: { uid: "42", nickname: "me" },
-  events: [
-    { kind: "play", id: "p1", capturedAt: 1700000001000, song: "晴天", artist: "周杰伦", album: "叶惠美", songId: "186016", playCount: 50 },
-    { kind: "favorite", id: "f1", capturedAt: 1700000002000, song: "稻香", artist: "周杰伦", songId: "186001" },
-    { kind: "playlist", id: "pl1", capturedAt: 1700000003000, name: "我喜欢的音乐", playlistId: "999", trackCount: 200, creator: "me" },
-    { kind: "bogus", id: "x" },
-  ],
-};
-
-function adapter(snap = SNAPSHOT, { exists = true } = {}) {
-  const a = new NeteaseMusicAdapter();
-  a._deps.fs = {
-    existsSync: () => exists,
-    readFileSync: () => JSON.stringify(snap),
-    accessSync: () => {},
-    constants: { R_OK: 4 },
-  };
-  return a;
-}
-
-async function collect(iter) {
-  const out = [];
-  for await (const r of iter) out.push(r);
-  return out;
-}
-
-describe("NeteaseMusicAdapter", () => {
-  it("readinessOnly → NO_INPUT (snapshot)", async () => {
-    const r = await new NeteaseMusicAdapter().authenticate({ readinessOnly: true });
-    expect(r.reason).toBe("NO_INPUT");
-  });
-
-  it("ingests play/favorite/playlist, skips unknown kinds", async () => {
-    const raws = await collect(adapter().sync({ inputPath: "/x" }));
-    expect(raws.map((r) => r.kind)).toEqual(["play", "favorite", "playlist"]);
-  });
-
-  it("normalizes to valid batch (events + items + topic)", async () => {
-    const a = adapter();
-    const raws = await collect(a.sync({ inputPath: "/x" }));
-    const merged = { events: [], persons: [], places: [], items: [], topics: [] };
-    for (const r of raws) {
-      const n = a.normalize(r);
-      for (const k of Object.keys(merged)) merged[k].push(...n[k]);
-    }
-    const { valid, invalidReasons } = partitionBatch(merged);
-    expect(invalidReasons).toHaveLength(0);
-    expect(valid.events).toHaveLength(2); // play + favorite
-    expect(valid.items).toHaveLength(2); // two songs
-    expect(valid.topics).toHaveLength(1); // playlist
-    const play = valid.events.find((e) => e.subtype === "media");
-    expect(play.content.title).toContain("晴天");
-    expect(valid.topics[0].name).toBe("我喜欢的音乐");
-  });
-
-  it("schemaVersion mismatch throws", async () => {
-    const a = adapter({ schemaVersion: 99, events: [] });
-    await expect(collect(a.sync({ inputPath: "/x" }))).rejects.toThrow(/schemaVersion/);
-  });
-
-  it("missing file yields nothing", async () => {
-    expect(await collect(adapter(SNAPSHOT, { exists: false }).sync({ inputPath: "/x" }))).toHaveLength(0);
-  });
-});

package/__tests__/adapters/pc-local-discovery.test.js

@@ -1,141 +0,0 @@
-"use strict";
-
-/**
- * Unit tests for _pc-local-discovery against a synthetic filesystem — no real
- * App needs to be installed. Uses posix path so assertions are host-agnostic.
- */
-
-import { describe, it, expect } from "vitest";
-const path = require("node:path");
-const { discover, SUPPORTED_APPS } = require("../../lib/adapters/_pc-local-discovery");
-
-// Build a fake fs from a map of { dirPath: [entryName...] } + a set of file paths.
-function makeFakeFs({ tree = {}, files = {}, sizes = {} } = {}) {
-  const norm = (p) => p.replace(/\\/g, "/");
-  const fileSet = new Set(Object.keys(files).map(norm));
-  const dirSet = new Set(Object.keys(tree).map(norm));
-  return {
-    existsSync: (p) => fileSet.has(norm(p)) || dirSet.has(norm(p)),
-    readdirSync: (p) => {
-      const entries = tree[norm(p)] || [];
-      return entries.map((e) => ({
-        name: e.name,
-        isDirectory: () => e.type === "dir",
-        isFile: () => e.type === "file",
-      }));
-    },
-    statSync: (p) => ({ size: sizes[norm(p)] || 1 }),
-    constants: { R_OK: 4 },
-  };
-}
-
-const D = (name) => ({ name, type: "dir" });
-const F = (name) => ({ name, type: "file" });
-
-describe("_pc-local-discovery", () => {
-  it("supports the expected app keys", () => {
-    expect(SUPPORTED_APPS).toEqual(["wechat-pc", "qq-pc", "dingtalk-pc", "feishu-pc"]);
-  });
-
-  it("returns installed:false for an unknown app key (never throws)", () => {
-    const r = discover("totally-unknown", { fs: makeFakeFs(), home: "/h", env: {}, path: path.posix });
-    expect(r.installed).toBe(false);
-    expect(r.note).toMatch(/不支持/);
-  });
-
-  it("returns installed:false when nothing is on disk", () => {
-    const r = discover("wechat-pc", { fs: makeFakeFs(), home: "/h", env: {}, path: path.posix });
-    expect(r.installed).toBe(false);
-    expect(r.primaryDb).toBe(null);
-  });
-
-  it("discovers a WeChat 4.x account and picks message_0.db as primary", () => {
-    const base = "/h/Documents/xwechat_files";
-    const acc = `${base}/wxid_demo_42`;
-    const fs = makeFakeFs({
-      tree: {
-        [base]: [D("wxid_demo_42"), D("all_users")],
-        [`${acc}/db_storage/message`]: [F("message_0.db"), F("biz_message_0.db"), F("message_fts.db")],
-      },
-      files: {
-        [`${acc}/db_storage`]: 1,
-        [`${acc}/db_storage/message/message_0.db`]: 1,
-        [`${acc}/db_storage/contact/contact.db`]: 1,
-        [`${acc}/db_storage/sns/sns.db`]: 1,
-      },
-      sizes: {
-        [`${acc}/db_storage/message/message_0.db`]: 99,
-        [`${acc}/db_storage/message/biz_message_0.db`]: 50,
-      },
-    });
-    const r = discover("wechat-pc", { fs, home: "/h", env: {}, path: path.posix });
-    expect(r.installed).toBe(true);
-    expect(r.layout).toBe("4.x");
-    expect(r.encrypted).toBe(true);
-    expect(r.accounts).toHaveLength(1);
-    expect(r.accounts[0].id).toBe("wxid_demo");
-    expect(r.primaryDb).toContain("message_0.db");
-    // message_fts.db must NOT be picked up as a message db
-    const purposes = r.accounts[0].dbs.map((d) => d.purpose).sort();
-    expect(purposes).toContain("message");
-    expect(purposes).toContain("contact");
-    expect(r.accounts[0].dbs.some((d) => /message_fts/.test(d.path))).toBe(false);
-  });
-
-  it("discovers a WeChat 3.x account (MSG*.db + MicroMsg.db)", () => {
-    const base = "/h/Documents/WeChat Files";
-    const acc = `${base}/wxid_old`;
-    const fs = makeFakeFs({
-      tree: {
-        [base]: [D("wxid_old"), D("All Users")],
-        [`${acc}/Msg/Multi`]: [F("MSG0.db"), F("MSG1.db")],
-      },
-      files: {
-        [`${acc}/Msg/Multi/MSG0.db`]: 1,
-        [`${acc}/Msg/Multi/MSG1.db`]: 1,
-        [`${acc}/Msg/MicroMsg.db`]: 1,
-      },
-    });
-    const r = discover("wechat-pc", { fs, home: "/h", env: {}, path: path.posix });
-    expect(r.installed).toBe(true);
-    expect(r.layout).toBe("3.x");
-    expect(r.accounts[0].dbs.filter((d) => d.purpose === "message")).toHaveLength(2);
-  });
-
-  it("discovers a QQ NT account by numeric uin dir", () => {
-    const base = "/h/Documents/Tencent Files";
-    const acc = `${base}/896075341`;
-    const fs = makeFakeFs({
-      tree: { [base]: [D("896075341"), D("nt_qq")] },
-      files: {
-        [`${acc}/nt_qq/nt_db/nt_msg.db`]: 1,
-        [`${acc}/nt_qq/nt_db/group_info.db`]: 1,
-      },
-    });
-    const r = discover("qq-pc", { fs, home: "/h", env: {}, path: path.posix });
-    expect(r.installed).toBe(true);
-    expect(r.accounts[0].id).toBe("896075341");
-    expect(r.primaryDb).toContain("nt_msg.db");
-    expect(r.encrypted).toBe(true);
-  });
-
-  it("dingtalk best-effort scan finds plaintext db (encrypted:false)", () => {
-    const root = "/appdata/DingTalk";
-    const fs = makeFakeFs({
-      tree: {
-        [root]: [D("user1")],
-        [`${root}/user1`]: [F("im_message.db"), F("cache.db")],
-      },
-      files: {
-        [`${root}/user1/im_message.db`]: 1,
-        [`${root}/user1/cache.db`]: 1,
-      },
-      sizes: { [`${root}/user1/im_message.db`]: 100 },
-    });
-    const r = discover("dingtalk-pc", { fs, home: "/h", env: { APPDATA: "/appdata" }, path: path.posix });
-    expect(r.installed).toBe(true);
-    expect(r.encrypted).toBe(false);
-    expect(r.bestEffort).toBe(true);
-    expect(r.primaryDb).toContain("im_message.db");
-  });
-});

package/__tests__/adapters/qq-pc-direct-read.test.js

@@ -1,227 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { QQPcAdapter } = require("../../lib/adapters/qq-pc");
-const { partitionBatch } = require("../../lib/batch");
-
-/**
- * QQ NT (PC desktop) local-direct-read — 本地直读样板 (ported from wechat-pc).
- *
- * No native SQLite: fake driver via `_deps.dbDriverFactory`. The point of
- * these tests is the PLUMBING + honest defensiveness (resolve columns,
- * preserve raw row, loud diagnostic, best-effort text) — not protobuf
- * decoding, which is real-device tuning.
- */
-
-function makeFakeDb(spec) {
-  class FakeStmt {
-    constructor(sql) {
-      this.sql = sql;
-    }
-    all() {
-      const s = this.sql;
-      const m = s.match(/PRAGMA table_info\((\w+)\)/);
-      if (m) return spec.cols[m[1]] || [];
-      const f = s.match(/FROM (\w+)/);
-      if (f) return spec.rows[f[1]] || [];
-      return [];
-    }
-    get() {
-      return { n: 1 };
-    }
-  }
-  return class FakeDb {
-    // eslint-disable-next-line no-unused-vars
-    constructor(_path, _opts) {}
-    prepare(sql) {
-      return new FakeStmt(sql);
-    }
-    pragma() {}
-    exec() {}
-    close() {}
-  };
-}
-
-// readable-name schema (decrypted/re-exported db) — text resolves cleanly
-const READABLE_SPEC = {
-  cols: {
-    c2c_msg_table: [
-      { name: "msgId" },
-      { name: "msgTime" },
-      { name: "msgType" },
-      { name: "senderUin" },
-      { name: "peerUin" },
-      { name: "content" },
-    ],
-    group_msg_table: [
-      { name: "msgId" },
-      { name: "msgTime" },
-      { name: "senderUin" },
-      { name: "peerUin" },
-      { name: "content" },
-    ],
-  },
-  rows: {
-    c2c_msg_table: [
-      { msgId: "c1", msgTime: 1700000000, msgType: 1, senderUin: "111", peerUin: "222", content: "hi there" },
-    ],
-    group_msg_table: [
-      { msgId: "g1", msgTime: 1700000100, senderUin: "333", peerUin: "9001", content: "群里大家好" },
-    ],
-  },
-};
-
-// obfuscated numeric schema + BLOB content — text is null but raw preserved
-const NUMERIC_SPEC = {
-  cols: {
-    c2c_msg_table: [
-      { name: "40001" }, // msgId
-      { name: "40050" }, // time
-      { name: "40011" }, // type
-      { name: "40033" }, // sender
-      { name: "40021" }, // peer
-      { name: "40800" }, // content (blob)
-    ],
-  },
-  rows: {
-    c2c_msg_table: [
-      { "40001": 9001, "40050": 1700000000, "40011": 1, "40033": 111, "40021": 222, "40800": Buffer.from([1, 2, 3]) },
-    ],
-  },
-};
-
-function freshAdapter(spec, { fsOverride } = {}) {
-  const a = new QQPcAdapter({ dbPath: "/fake/nt_msg.db" });
-  a._deps.fs = fsOverride || { existsSync: () => true, accessSync: () => {}, constants: { R_OK: 4 } };
-  a._deps.dbDriverFactory = () => makeFakeDb(spec);
-  return a;
-}
-
-async function collect(iter) {
-  const out = [];
-  for await (const r of iter) out.push(r);
-  return out;
-}
-
-describe("QQPcAdapter — readiness + construction", () => {
-  it("no-arg construct + APP_NOT_INSTALLED when nothing discoverable", async () => {
-    const a = new QQPcAdapter();
-    a._deps.discoveryDeps = {
-      fs: { existsSync: () => false, readdirSync: () => [], statSync: () => ({ size: 0 }), constants: { R_OK: 4 } },
-      home: "/no-home",
-      env: {},
-    };
-    expect(a.name).toBe("qq-pc");
-    expect(a.dataDisclosure.legalGate).toBe(true);
-    const r = await a.authenticate({ readinessOnly: true });
-    expect(r.reason).toBe("APP_NOT_INSTALLED");
-  });
-});
-
-describe("QQPcAdapter — nt_msg.db (readable schema)", () => {
-  it("reads c2c + group messages → valid events, 0 invalid", async () => {
-    const a = freshAdapter(READABLE_SPEC);
-    const raws = await collect(a.sync({ dbPath: "/fake/nt_msg.db" }));
-    expect(raws).toHaveLength(2);
-    expect(raws.every((r) => r.kind === "message")).toBe(true);
-    const merged = { events: [], persons: [], places: [], items: [], topics: [] };
-    for (const r of raws) {
-      const n = a.normalize(r);
-      for (const k of Object.keys(merged)) merged[k].push(...n[k]);
-    }
-    const { valid, invalidReasons } = partitionBatch(merged);
-    expect(invalidReasons).toHaveLength(0);
-    expect(valid.events).toHaveLength(2);
-  });
-
-  it("resolves text + flags group + preserves timestamp", async () => {
-    const a = freshAdapter(READABLE_SPEC);
-    const raws = await collect(a.sync({ dbPath: "/fake/nt_msg.db" }));
-    const group = raws.find((r) => r.payload.isGroup);
-    expect(group.payload.text).toBe("群里大家好");
-    expect(group.payload.createdTimeMs).toBe(1700000100000);
-    const ev = a.normalize(group).events[0];
-    expect(ev.extra.isGroup).toBe(true);
-    expect(ev.extra.textResolved).toBe(true);
-  });
-});
-
-describe("QQPcAdapter — nt_msg.db (numeric/obfuscated + BLOB body)", () => {
-  it("still ingests, text null, raw row preserved, loud diagnostic", async () => {
-    const a = freshAdapter(NUMERIC_SPEC);
-    const events = [];
-    const raws = await collect(
-      a.sync({ dbPath: "/fake/nt_msg.db", onProgress: (e) => events.push(e) }),
-    );
-    expect(raws).toHaveLength(1);
-    const ev = a.normalize(raws[0]).events[0];
-    // No silent drop: it's a valid event even with unresolved protobuf text.
-    const { valid, invalidReasons } = partitionBatch({
-      events: [ev], persons: [], places: [], items: [], topics: [],
-    });
-    expect(invalidReasons).toHaveLength(0);
-    expect(valid.events).toHaveLength(1);
-    expect(ev.extra.textResolved).toBe(false);
-    expect(ev.extra.rawRow).toBeTruthy(); // nothing lost
-    // diagnostic tells the user what resolved
-    const diag = events.find((e) => e.phase === "qq-nt-read");
-    expect(diag.hadC2cTable).toBe(true);
-    expect(diag.messageCount).toBe(1);
-    expect(diag.resolvedColumns.c2c_msg_table.time).toBe("40050");
-  });
-});
-
-describe("QQPcAdapter — edge cases", () => {
-  it("respects limit", async () => {
-    const a = freshAdapter(READABLE_SPEC);
-    const capped = await collect(a.sync({ dbPath: "/fake/nt_msg.db", limit: 1 }));
-    expect(capped).toHaveLength(1);
-  });
-
-  it("missing db yields nothing", async () => {
-    const a = freshAdapter(READABLE_SPEC, { fsOverride: { existsSync: () => false } });
-    expect(await collect(a.sync({ dbPath: "/nope.db" }))).toHaveLength(0);
-  });
-
-  it("unknown normalize kind throws", () => {
-    const a = new QQPcAdapter();
-    expect(() => a.normalize({ kind: "x", payload: { kind: "x" } })).toThrow(/unknown kind/);
-  });
-});
-
-describe("QQPcAdapter — QQ NT sidecar path (passphrase)", () => {
-  const fakeCollector = (result) => async (_opts) => result;
-
-  it("opts.passphrase routes through the sidecar collector and yields messages", async () => {
-    const a = new QQPcAdapter({
-      qqCollector: fakeCollector({
-        account: "896075341",
-        messageCount: 2,
-        c2c: 1,
-        group: 1,
-        messages: [
-          { kind: "group", peer: 88966001, peerUid: "u_x", senderUin: 38181604, senderName: "疯子", type: 0, createTime: 1780941580, text: "保持高贵的沉默。", originalId: "qq-pc:group:88966001:1" },
-          { kind: "c2c", peer: 2747277822, peerUid: "u_y", senderUin: 12345, senderName: "张三", type: 0, createTime: 1780900000, text: "在吗", originalId: "qq-pc:c2c:2747277822:2" },
-        ],
-      }),
-    });
-    const raws = await collect(a.sync({ passphrase: "5{sww#,6aq=)8=A@" }));
-    expect(raws).toHaveLength(2);
-    expect(raws[0].payload.text).toBe("保持高贵的沉默。");
-    expect(raws[0].payload.isGroup).toBe(true);
-    expect(raws[0].payload.senderName).toBe("疯子");
-    expect(raws[1].payload.isGroup).toBe(false);
-
-    const merged = { events: [], persons: [], places: [], items: [], topics: [] };
-    for (const r of raws) {
-      const n = a.normalize(r);
-      for (const k of Object.keys(merged)) if (Array.isArray(n[k])) merged[k].push(...n[k]);
-    }
-    const { valid } = partitionBatch(merged);
-    expect(valid.events.length).toBe(2);
-    const texts = valid.events.map((e) => e.content && e.content.text);
-    expect(texts).toContain("保持高贵的沉默。");
-    expect(valid.events.find((e) => e.content.text === "保持高贵的沉默。").extra.senderName).toBe("疯子");
-  });
-});