@chainlesschain/personal-data-hub 0.4.28 → 0.4.30

package/__tests__/adapters/wechat-md5-key-provider.test.js

@@ -1,101 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const {
-  WeChatKeyProvider,
-  WeChatMD5KeyProvider,
-} = require("../../lib/adapters/wechat");
-
-describe("WeChatKeyProvider — base contract", () => {
-  it("getKey throws on bare base instance (subclass must override)", async () => {
-    const base = new WeChatKeyProvider();
-    await expect(base.getKey()).rejects.toThrow(/must be overridden/);
-  });
-
-  it("name defaults to key-provider-base", () => {
-    const base = new WeChatKeyProvider();
-    expect(base.name).toBe("key-provider-base");
-  });
-});
-
-describe("WeChatMD5KeyProvider — construction validation", () => {
-  it("throws if opts missing", () => {
-    expect(() => new WeChatMD5KeyProvider()).toThrow(/wechatDataPath/);
-  });
-
-  it("throws if wechatDataPath missing", () => {
-    expect(() => new WeChatMD5KeyProvider({ uin: "1" })).toThrow(/wechatDataPath/);
-  });
-
-  it("name returns md5", () => {
-    const p = new WeChatMD5KeyProvider({ wechatDataPath: "/tmp/wx" });
-    expect(p.name).toBe("md5");
-  });
-});
-
-describe("WeChatMD5KeyProvider — extractor DI happy path", () => {
-  it("getKey returns hex when extractor yields key", async () => {
-    const extractor = (opts) => {
-      expect(opts.wechatDataPath).toBe("/tmp/wx");
-      return {
-        uin: "100200300",
-        imei: "350123456789012",
-        key: "abcdef1",
-        source: "test",
-        warnings: [],
-      };
-    };
-    const p = new WeChatMD5KeyProvider({
-      wechatDataPath: "/tmp/wx",
-      extractor,
-    });
-    const key = await p.getKey();
-    expect(key).toBe("abcdef1");
-    expect(p.getLastResult().uin).toBe("100200300");
-    expect(p.getLastResult().imei).toBe("350123456789012");
-  });
-
-  it("getKey passes uin/imei overrides through to extractor", async () => {
-    let passedOpts = null;
-    const extractor = (opts) => {
-      passedOpts = opts;
-      return { key: "0000000", uin: opts.uin, imei: opts.imei, warnings: [] };
-    };
-    const p = new WeChatMD5KeyProvider({
-      wechatDataPath: "/tmp/wx",
-      uin: "999",
-      imei: "deadbeef",
-      extractor,
-    });
-    await p.getKey();
-    expect(passedOpts.uin).toBe("999");
-    expect(passedOpts.imei).toBe("deadbeef");
-  });
-});
-
-describe("WeChatMD5KeyProvider — extractor failure surfaces as throw", () => {
-  it("throws with warnings when extractor returns no key", async () => {
-    const extractor = () => ({
-      uin: null,
-      imei: null,
-      key: null,
-      source: "missing",
-      warnings: ["UIN not found in shared_prefs", "IMEI not found in CompatibleInfo.cfg"],
-    });
-    const p = new WeChatMD5KeyProvider({
-      wechatDataPath: "/tmp/empty",
-      extractor,
-    });
-    await expect(p.getKey()).rejects.toThrow(/UIN not found/);
-  });
-
-  it("throws with generic reason when warnings empty", async () => {
-    const extractor = () => ({ key: null, warnings: [] });
-    const p = new WeChatMD5KeyProvider({
-      wechatDataPath: "/tmp/empty",
-      extractor,
-    });
-    await expect(p.getKey()).rejects.toThrow(/extraction returned empty/);
-  });
-});

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

@@ -1,365 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { WeChatPcAdapter } = require("../../lib/adapters/wechat-pc");
-const { partitionBatch } = require("../../lib/batch");
-
-/**
- * WeChat **PC desktop** local-direct-read (本地直读样板, ported from Douyin).
- *
- * No native SQLite: a fake Database driver is injected via
- * `_deps.dbDriverFactory` (pc-db-reader accepts it as `_databaseClass`).
- * Covers the message/contact normalize + the MSG / Contact table read +
- * group-message sender-prefix parsing + key-vs-plaintext routing.
- */
-
-// Fake better-sqlite3-style driver answering pc-db-reader's PRAGMA + SELECTs.
-function makeFakeDb(spec) {
-  class FakeStmt {
-    constructor(sql) {
-      this.sql = sql;
-    }
-    all() {
-      const s = this.sql;
-      if (/PRAGMA table_info\(MSG\)/.test(s)) return spec.msgCols || [];
-      if (/FROM MSG/.test(s)) return spec.msgRows || [];
-      if (/PRAGMA table_info\(Contact\)/.test(s)) return spec.contactCols || [];
-      if (/FROM Contact/.test(s)) return spec.contactRows || [];
-      return [];
-    }
-    get() {
-      return { n: 1 }; // sqlite_master probe
-    }
-  }
-  return class FakeDb {
-    // eslint-disable-next-line no-unused-vars
-    constructor(_path, _opts) {}
-    prepare(sql) {
-      return new FakeStmt(sql);
-    }
-    pragma() {}
-    exec() {}
-    close() {}
-  };
-}
-
-const MSG_SPEC = {
-  msgCols: [
-    { name: "MsgSvrID" },
-    { name: "StrTalker" },
-    { name: "IsSender" },
-    { name: "CreateTime" },
-    { name: "Type" },
-    { name: "StrContent" },
-  ],
-  msgRows: [
-    { msgSvrId: "700001", talker: "wxid_bob", isSend: 0, createTime: 1700000000, type: 1, content: "你好啊" },
-    { msgSvrId: "700002", talker: "wxid_bob", isSend: 1, createTime: 1700000010, type: 1, content: "在的" },
-    { msgSvrId: "700003", talker: "room1@chatroom", isSend: 0, createTime: 1700000020, type: 1, content: "wxid_carol:\n大家好" },
-  ],
-};
-
-const CONTACT_SPEC = {
-  contactCols: [
-    { name: "UserName" },
-    { name: "Alias" },
-    { name: "NickName" },
-    { name: "Remark" },
-    { name: "Type" },
-  ],
-  contactRows: [
-    { wxid: "wxid_bob", alias: "bob123", nickname: "Bob", remark: "老鲍", type: 3 },
-    { wxid: "gh_official01", alias: null, nickname: "某公众号", remark: null, type: 3 },
-    { wxid: "room1@chatroom", alias: null, nickname: "群", remark: null, type: 2 }, // filtered
-  ],
-};
-
-function freshAdapter(spec, { fsOverride } = {}) {
-  const a = new WeChatPcAdapter({ dbPath: "/fake/MSG0.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("WeChatPcAdapter — readiness + construction", () => {
-  // Synthetic "nothing installed" filesystem so auto-discovery is
-  // deterministic regardless of what's on the host running the tests.
-  const EMPTY_FS = {
-    existsSync: () => false,
-    readdirSync: () => [],
-    statSync: () => ({ size: 0 }),
-    constants: { R_OK: 4 },
-  };
-
-  it("constructs no-arg and reports APP_NOT_INSTALLED when nothing is discoverable", async () => {
-    const a = new WeChatPcAdapter();
-    a._deps.discoveryDeps = { fs: EMPTY_FS, home: "/no-home", env: {} };
-    expect(a.name).toBe("wechat-pc");
-    expect(a.extractMode).toBe("device-pull");
-    expect(a.dataDisclosure.legalGate).toBe(true);
-    const r = await a.authenticate({ readinessOnly: true });
-    expect(r.ok).toBe(false);
-    expect(r.reason).toBe("APP_NOT_INSTALLED");
-  });
-
-  it("auto-discovers an installed WeChat 4.x DB → DB_FOUND_NEEDS_KEY", async () => {
-    // Minimal synthetic 4.x layout: ~/Documents/xwechat_files/<wxid>_N/db_storage/message/message_0.db
-    const dirs = {
-      "/h/Documents/xwechat_files": [{ name: "wxid_abc_1", isDirectory: () => true, isFile: () => false }],
-      "/h/Documents/xwechat_files/wxid_abc_1/db_storage/message": [
-        { name: "message_0.db", isDirectory: () => false, isFile: () => true },
-      ],
-    };
-    const exist = new Set([
-      "/h/Documents/xwechat_files",
-      "/h/Documents/xwechat_files/wxid_abc_1/db_storage",
-      "/h/Documents/xwechat_files/wxid_abc_1/db_storage/contact/contact.db",
-    ]);
-    const fakeFs = {
-      existsSync: (p) => exist.has(p.replace(/\\/g, "/")),
-      readdirSync: (p) => dirs[p.replace(/\\/g, "/")] || [],
-      statSync: () => ({ size: 1234 }),
-      constants: { R_OK: 4 },
-    };
-    const a = new WeChatPcAdapter();
-    a._deps.discoveryDeps = { fs: fakeFs, home: "/h", env: {}, path: require("node:path").posix };
-    const r = await a.authenticate({ readinessOnly: true });
-    expect(r.ok).toBe(false);
-    expect(r.reason).toBe("DB_FOUND_NEEDS_KEY");
-    expect(r.discovered.installed).toBe(true);
-    expect(r.discovered.primaryDb).toContain("message_0.db");
-  });
-
-  it("readinessOnly with a configured dbPath reports configured (no DB open)", async () => {
-    const a = new WeChatPcAdapter({ dbPath: "/some/MSG0.db" });
-    const r = await a.authenticate({ readinessOnly: true });
-    expect(r.ok).toBe(true);
-    expect(r.mode).toBe("configured");
-  });
-});
-
-describe("WeChatPcAdapter — MSG*.db messages", () => {
-  it("reads MSG rows → message raws with stable ids", async () => {
-    const a = freshAdapter(MSG_SPEC);
-    const raws = await collect(a.sync({ dbPath: "/fake/MSG0.db" }));
-    expect(raws.map((r) => r.kind)).toEqual(["message", "message", "message"]);
-    expect(raws.map((r) => r.originalId)).toEqual([
-      "wechat-pc:message:700001",
-      "wechat-pc:message:700002",
-      "wechat-pc:message:700003",
-    ]);
-  });
-
-  it("messages normalize to valid events (+ contact persons + group topic), 0 invalid", async () => {
-    const a = freshAdapter(MSG_SPEC);
-    const raws = await collect(a.sync({ dbPath: "/fake/MSG0.db" }));
-    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(3);
-    // bob (1-on-1) + carol (group sender)
-    const personIds = valid.persons.map((p) => p.id).sort();
-    expect(personIds).toContain("person-wechat-wxid_bob");
-    expect(personIds).toContain("person-wechat-wxid_carol");
-    // the chatroom becomes a topic
-    expect(valid.topics.map((t) => t.id)).toContain("topic-wechat-group-room1@chatroom");
-  });
-
-  it("strips the group-message sender prefix from the text", async () => {
-    const a = freshAdapter(MSG_SPEC);
-    const raws = await collect(a.sync({ dbPath: "/fake/MSG0.db" }));
-    const groupRaw = raws.find((r) => r.payload.talker === "room1@chatroom");
-    expect(groupRaw.payload.senderWxid).toBe("wxid_carol");
-    expect(groupRaw.payload.text).toBe("大家好");
-    const ev = a.normalize(groupRaw).events[0];
-    expect(ev.content.text).toBe("大家好");
-    expect(ev.extra.isGroup).toBe(true);
-    expect(ev.actor).toBe("person-wechat-wxid_carol");
-  });
-
-  it("CreateTime (seconds) normalizes to ms", async () => {
-    const a = freshAdapter(MSG_SPEC);
-    const raws = await collect(a.sync({ dbPath: "/fake/MSG0.db" }));
-    expect(raws[0].payload.createdTimeMs).toBe(1700000000000);
-  });
-});
-
-describe("WeChatPcAdapter — MicroMsg.db contacts", () => {
-  it("reads Contact rows → contact persons; skips @chatroom; gh_ → merchant", async () => {
-    const a = freshAdapter(CONTACT_SPEC);
-    const raws = await collect(a.sync({ dbPath: "/fake/MicroMsg.db" }));
-    expect(raws.map((r) => r.kind)).toEqual(["contact", "contact"]); // chatroom filtered
-    const persons = raws.map((r) => a.normalize(r).persons[0]);
-    const bob = persons.find((p) => p.id === "person-wechat-wxid_bob");
-    expect(bob.subtype).toBe("contact");
-    expect(bob.names[0]).toBe("老鲍"); // remark wins
-    expect(bob.identifiers.wechatId).toBe("wxid_bob");
-    const gh = persons.find((p) => p.id === "person-wechat-gh_official01");
-    expect(gh.subtype).toBe("merchant");
-  });
-});
-
-describe("WeChatPcAdapter — options + edge cases", () => {
-  it("respects include={message:false} and limit", async () => {
-    const a = freshAdapter(MSG_SPEC);
-    const none = await collect(a.sync({ dbPath: "/fake/MSG0.db", include: { message: false } }));
-    expect(none).toHaveLength(0);
-    const capped = await collect(a.sync({ dbPath: "/fake/MSG0.db", limit: 2 }));
-    expect(capped).toHaveLength(2);
-  });
-
-  it("emits a pc-db-read progress event with the diagnostic", async () => {
-    const a = freshAdapter(MSG_SPEC);
-    const events = [];
-    await collect(a.sync({ dbPath: "/fake/MSG0.db", onProgress: (e) => events.push(e) }));
-    const parsed = events.find((e) => e.phase === "pc-db-read");
-    expect(parsed).toBeTruthy();
-    expect(parsed.hadMsgTable).toBe(true);
-    expect(parsed.messageCount).toBe(3);
-    expect(parsed.mode).toBe("plaintext"); // no key supplied
-  });
-
-  it("missing db file yields nothing (no throw)", async () => {
-    const a = freshAdapter(MSG_SPEC, { fsOverride: { existsSync: () => false } });
-    const raws = await collect(a.sync({ dbPath: "/nope/MSG0.db" }));
-    expect(raws).toHaveLength(0);
-  });
-
-  it("unknown normalize kind throws", () => {
-    const a = new WeChatPcAdapter();
-    expect(() => a.normalize({ kind: "weird", payload: { kind: "weird" } })).toThrow(
-      /unknown kind/,
-    );
-  });
-});
-
-describe("WeChatPcAdapter — WeChat 4.x sidecar path", () => {
-  function fakeCollector(result) {
-    return async (_opts) => result;
-  }
-
-  it("opts.mode='v4' routes through the injected collector and yields messages", async () => {
-    const a = new WeChatPcAdapter({
-      v4Collector: fakeCollector({
-        account: "wxid_me",
-        messageCount: 2,
-        dbs: [{ db: "message_0.db", messageCount: 2, hmacFailures: 0 }],
-        messages: [
-          {
-            conversation: "wxid_friend",
-            sender: "wxid_friend",
-            type: 1,
-            createTime: 1700000002,
-            text: "hello from 4.0",
-            originalId: "wechat-pc:wxid_friend:1001",
-          },
-          {
-            conversation: "39354004187@chatroom",
-            sender: "wxid_other",
-            type: 1,
-            createTime: 1700000003,
-            text: "group line",
-            originalId: "wechat-pc:39354004187@chatroom:1002",
-          },
-        ],
-      }),
-    });
-    const raws = await collect(a.sync({ mode: "v4" }));
-    expect(raws).toHaveLength(2);
-    expect(raws[0].originalId).toBe("wechat-pc:wxid_friend:1001");
-    expect(raws[0].payload.text).toBe("hello from 4.0");
-    expect(raws[0].payload.isGroup).toBe(false);
-    // group message: peer is the chatroom, sender preserved
-    expect(raws[1].payload.isGroup).toBe(true);
-    expect(raws[1].payload.senderWxid).toBe("wxid_other");
-
-    // normalize reuses the 3.x path → produces a valid message event
-    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("hello from 4.0");
-    expect(texts).toContain("group line");
-  });
-
-  it("v4 self-sent message marks isSend=1 when sender == account", async () => {
-    const a = new WeChatPcAdapter({
-      v4Collector: fakeCollector({
-        account: "wxid_me",
-        messages: [
-          { conversation: "wxid_friend", sender: "wxid_me", type: 1, createTime: 1700000004, text: "mine", originalId: "id-3" },
-        ],
-      }),
-    });
-    const raws = await collect(a.sync({ mode: "v4" }));
-    expect(raws[0].payload.isSend).toBe(1);
-  });
-
-  it("v4 forwards limit to the sidecar collector (sidecar owns the cap)", async () => {
-    const msgs = Array.from({ length: 5 }, (_v, i) => ({
-      conversation: "wxid_f", sender: "wxid_f", type: 1, createTime: 1700000000 + i, text: "m" + i, originalId: "id-" + i,
-    }));
-    let seenLimit = null;
-    // Collector that honors the limit, like the real Python sidecar does.
-    const collector = async (opts) => {
-      seenLimit = opts.limit;
-      return { account: "wxid_me", messages: msgs.slice(0, opts.limit || msgs.length), contacts: [] };
-    };
-    const a = new WeChatPcAdapter({ v4Collector: collector });
-    const raws = await collect(a.sync({ mode: "v4", limit: 3 }));
-    expect(seenLimit).toBe(3);
-    expect(raws.filter((r) => r.kind === "message")).toHaveLength(3);
-  });
-
-  it("v4 yields contacts from contact.db as Person entities", async () => {
-    const a = new WeChatPcAdapter({
-      v4Collector: fakeCollector({
-        account: "wxid_me",
-        messages: [
-          { conversation: "wxid_friend", sender: "wxid_friend", type: 1, createTime: 1700000002, text: "hi", originalId: "m-1" },
-        ],
-        contacts: [
-          { wxid: "wxid_friend", nickname: "昵称", remark: "备注名", alias: "alias1", type: 3 },
-          { wxid: "12345@chatroom", nickname: "群", remark: null, alias: null, type: 2 }, // skipped (chatroom)
-        ],
-      }),
-    });
-    const raws = await collect(a.sync({ mode: "v4" }));
-    const contactRaws = raws.filter((r) => r.kind === "contact");
-    expect(contactRaws).toHaveLength(1); // chatroom filtered out
-    expect(contactRaws[0].payload.wxid).toBe("wxid_friend");
-    expect(contactRaws[0].payload.remark).toBe("备注名");
-
-    // normalize → Person entity
-    const n = a.normalize(contactRaws[0]);
-    expect(n.persons.length).toBeGreaterThanOrEqual(1);
-    expect(n.persons[0].identifiers.wechatId).toBe("wxid_friend");
-  });
-
-  it("v4 can opt out of contacts via include.contact=false", async () => {
-    const a = new WeChatPcAdapter({
-      v4Collector: fakeCollector({
-        account: "wxid_me",
-        messages: [],
-        contacts: [{ wxid: "wxid_x", nickname: "n", remark: null, alias: null, type: 3 }],
-      }),
-    });
-    const raws = await collect(a.sync({ mode: "v4", include: { contact: false } }));
-    expect(raws.filter((r) => r.kind === "contact")).toHaveLength(0);
-  });
-});

package/__tests__/adapters/wechat-pc-group-topic.test.js

@@ -1,63 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { WeChatPcAdapter } = require("../../lib/adapters/wechat-pc");
-
-// Build the raw envelope shape that WeChatPcAdapter.normalize() consumes for a
-// group message (the sync() generator yields { kind:"message", payload, ... }).
-function groupMessageRaw(payload) {
-  return {
-    adapter: "wechat-pc",
-    kind: "message",
-    originalId: "orig-1",
-    capturedAt: 1780000000000,
-    payload: { kind: "message", ...payload },
-  };
-}
-
-describe("wechat-pc — group topic naming", () => {
-  it("uses the resolved group display name for the topic when groupName is present", () => {
-    const adapter = new WeChatPcAdapter();
-    const out = adapter.normalize(groupMessageRaw({
-      talker: "45498354778@chatroom",
-      isGroup: true,
-      senderWxid: "wxid_friend",
-      groupName: "家庭群",
-      text: "晚饭吃什么",
-      createdTimeMs: 1780000000000,
-    }));
-    expect(out.topics).toHaveLength(1);
-    // Stable id keyed on the chatroom wxid (identity unchanged)...
-    expect(out.topics[0].id).toBe("topic-wechat-group-45498354778@chatroom");
-    // ...but the human-readable display name is used, NOT the numeric id.
-    expect(out.topics[0].name).toBe("家庭群");
-  });
-
-  it("falls back to the raw numeric id when no group name was resolved", () => {
-    const adapter = new WeChatPcAdapter();
-    const out = adapter.normalize(groupMessageRaw({
-      talker: "45498354778@chatroom",
-      isGroup: true,
-      senderWxid: "wxid_friend",
-      groupName: null,
-      text: "hi",
-      createdTimeMs: 1780000000000,
-    }));
-    expect(out.topics).toHaveLength(1);
-    expect(out.topics[0].name).toBe("45498354778");
-  });
-
-  it("blank/whitespace group name falls back to the raw id (no empty topic name)", () => {
-    const adapter = new WeChatPcAdapter();
-    const out = adapter.normalize(groupMessageRaw({
-      talker: "12345@chatroom",
-      isGroup: true,
-      senderWxid: "wxid_x",
-      groupName: "   ",
-      text: "hi",
-      createdTimeMs: 1780000000000,
-    }));
-    expect(out.topics[0].name).toBe("12345");
-  });
-});

package/__tests__/adapters/wechat-pc-v4-sidecar.test.js

@@ -1,72 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { collectWeChatV4, _internals } = require("../../lib/adapters/wechat-pc/v4-sidecar");
-
-// Fake SidecarSupervisor: scripted per python exe (command[0]).
-function makeFactory(behaviorByPython, calls) {
-  return (command, _cwd) => {
-    const py = command[0];
-    calls.push(py);
-    const behavior = behaviorByPython[py] || { throwOn: "start", error: new Error("ENOENT spawn " + py) };
-    return {
-      async start() {
-        if (behavior.throwOn === "start") throw behavior.error;
-      },
-      async invoke(_method, _params, _opts) {
-        if (behavior.throwOn === "invoke") throw behavior.error;
-        return behavior.result;
-      },
-      async stop() {},
-    };
-  };
-}
-
-describe("collectWeChatV4 — python fallback + error routing", () => {
-  it("falls through to the next python when the first lacks cryptography", async () => {
-    const calls = [];
-    const result = await collectWeChatV4({
-      pythonExe: "python", // tried first
-      _supervisorFactory: makeFactory(
-        {
-          python: { throwOn: "invoke", error: new Error("ModuleNotFoundError: No module named 'cryptography'") },
-          python3: { throwOn: null, result: { account: "wxid_x", messages: [{ text: "ok" }] } },
-        },
-        calls,
-      ),
-    });
-    expect(result.account).toBe("wxid_x");
-    expect(calls[0]).toBe("python");
-    expect(calls).toContain("python3");
-  });
-
-  it("surfaces a WeChat data error immediately (no fallback)", async () => {
-    const calls = [];
-    await expect(
-      collectWeChatV4({
-        pythonExe: "python",
-        _supervisorFactory: makeFactory(
-          { python: { throwOn: "invoke", error: new Error("KEY_NOT_FOUND: key not found in Weixin.exe memory") } },
-          calls,
-        ),
-      }),
-    ).rejects.toThrow(/KEY_NOT_FOUND/);
-    expect(calls).toEqual(["python"]); // did NOT try other pythons
-  });
-
-  it("throws SIDECAR_UNAVAILABLE when no python works", async () => {
-    const calls = [];
-    await expect(
-      collectWeChatV4({
-        _supervisorFactory: makeFactory({}, calls), // all spawn-fail
-      }),
-    ).rejects.toThrow(/SIDECAR_UNAVAILABLE|could not run/);
-  });
-
-  it("pythonCandidates dedupes + honors explicit/env order", () => {
-    const list = _internals.pythonCandidates("my-python");
-    expect(list[0]).toBe("my-python");
-    expect(new Set(list).size).toBe(list.length);
-  });
-});