@chainlesschain/personal-data-hub 0.4.18 → 0.4.24

package/__tests__/adapters/bank-family.test.js

@@ -0,0 +1,125 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const base = require("../../lib/adapters/_bank-base");
+const cmbc = require("../../lib/adapters/bank-cmbc");
+const boc = require("../../lib/adapters/bank-boc");
+const bankcomm = require("../../lib/adapters/bank-bankcomm");
+const icbc = require("../../lib/adapters/bank-icbc");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-bank-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+const COOKIES = "MBANK_SSO=abc; sid=xyz";
+
+describe("_bank-base helpers", () => {
+  it("normDirection: keyword + amount-sign fallback", () => {
+    expect(base.normDirection({ direction: "收入" })).toBe("credit");
+    expect(base.normDirection({ flag: "支出" })).toBe("debit");
+    expect(base.normDirection({ amount: -50 })).toBe("debit");
+    expect(base.normDirection({ amount: 50 })).toBe("credit");
+  });
+  it("mapTransaction / mapCard aliases; no id → null", () => {
+    const tx = base.mapTransaction({ serialNo: "T1", tranTime: 1716383000, tranAmount: "-1,234.56", oppName: "星巴克", abstract: "消费", bal: 9999 });
+    expect(tx).toMatchObject({ txId: "T1", direction: "debit", counterparty: "星巴克", summary: "消费" });
+    expect(tx.amount).toBeCloseTo(1234.56, 2);
+    expect(tx.balance).toBe(9999);
+    expect(base.mapTransaction({ amount: 1 })).toBe(null);
+    const card = base.mapCard({ billId: "B1", billMonth: "2025-03", statementAmount: 3210, minPayment: 321, status: "已出账" });
+    expect(card).toMatchObject({ billId: "B1", billMonth: "2025-03", statementAmount: 3210, status: "已出账" });
+    expect(base.mapCard({ status: "x" })).toBe(null);
+  });
+  it("billMonthToMs", () => {
+    expect(base.billMonthToMs("2025-03")).toBe(Date.parse("2025-03-01T00:00:00Z"));
+  });
+});
+
+describe("bank wrappers identity", () => {
+  it("each wrapper has its own name + adapter class", () => {
+    expect(cmbc.NAME).toBe("bank-cmbc");
+    expect(boc.NAME).toBe("bank-boc");
+    expect(bankcomm.NAME).toBe("bank-bankcomm");
+    expect(icbc.NAME).toBe("bank-icbc");
+    expect(new cmbc.CmbcBankAdapter().name).toBe("bank-cmbc");
+    expect(new boc.BocBankAdapter().name).toBe("bank-boc");
+    expect(new bankcomm.BankcommBankAdapter().name).toBe("bank-bankcomm");
+    expect(new icbc.IcbcBankAdapter().name).toBe("bank-icbc");
+  });
+  it("all gated high sensitivity + legalGate", () => {
+    for (const A of [new cmbc.CmbcBankAdapter(), new boc.BocBankAdapter(), new bankcomm.BankcommBankAdapter(), new icbc.IcbcBankAdapter()]) {
+      expect(A.dataDisclosure.sensitivity).toBe("high");
+      expect(A.dataDisclosure.legalGate).toBe(true);
+    }
+  });
+});
+
+describe("CmbcBankAdapter (via _bank-base)", () => {
+  const SNAP = JSON.stringify({
+    schemaVersion: 1,
+    snapshottedAt: 1716383000000,
+    account: { userId: "u1" },
+    events: [
+      { kind: "transaction", id: "tx-T1", txId: "T1", time: 1716383000, amount: -88.5, direction: "支出", counterparty: "全家", summary: "消费", balance: 1200 },
+      { kind: "card", id: "card-C1", billId: "C1", billMonth: "2025-03", statementAmount: 3210, minPayment: 321, status: "已出账" },
+    ],
+  });
+
+  it("transaction → PAYMENT event; card → OTHER event", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new cmbc.CmbcBankAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(2);
+      const tx = a.normalize(items[0]);
+      expect(tx.events[0].subtype).toBe("payment");
+      expect(tx.events[0].content.title).toContain("支出");
+      expect(tx.events[0].extra.amount).toBe(88.5);
+      expect(tx.events[0].extra.direction).toBe("debit");
+      expect(items[0].originalId).toBe("cmbc:transaction:T1");
+      const card = a.normalize(items[1]);
+      expect(card.events[0].subtype).toBe("other");
+      expect(card.events[0].extra.billMonth).toBe("2025-03");
+      expect(items[1].originalId).toBe("cmbc:card:C1");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("cookie-api: best-effort fetch + unverified + sign seam", async () => {
+    let signed = 0;
+    const a = new cmbc.CmbcBankAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      signProvider: async () => { signed += 1; return "sig"; },
+      fetchFn: async ({ url, query }) => {
+        if (query.page > 1) return { list: [] };
+        if (url.includes("transactions")) return { list: [{ txId: "T9", time: 1716383000, amount: 500, direction: "收入", summary: "工资" }] };
+        return { list: [{ billId: "C9", billMonth: "2025-02", statementAmount: 1000 }] };
+      },
+    });
+    expect(await a.authenticate()).toMatchObject({ ok: true, mode: "cookie", unverified: true });
+    const items = await collect(a.sync({}));
+    expect(items).toHaveLength(2);
+    expect(items.map((i) => i.originalId).sort()).toEqual(["cmbc:card:C9", "cmbc:transaction:T9"]);
+    expect(signed).toBeGreaterThan(0);
+  });
+
+  it("default fetch throws; no input throws", async () => {
+    const a = new cmbc.CmbcBankAdapter({ account: { cookies: COOKIES } });
+    await expect(collect(a.sync({}))).rejects.toThrow(/no fetchFn configured/);
+    const b = new cmbc.CmbcBankAdapter();
+    await expect(collect(b.sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});

package/__tests__/adapters/biz-tianyancha.test.js

@@ -0,0 +1,159 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const {
+  TianyanchaAdapter,
+  extractData,
+  NAME,
+  VERSION,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/biz-tianyancha");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-tyc-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+
+const COOKIES = "auth_token=abc; TYCID=xyz";
+
+const SNAP = JSON.stringify({
+  schemaVersion: 1,
+  snapshottedAt: 1716383000000,
+  account: { userId: "u1" },
+  events: [
+    { kind: "monitor", id: "mon-G1", companyId: "G1", companyName: "字节跳动有限公司", legalPerson: "张利东", regStatus: "存续", capturedAt: 1716300000000 },
+    { kind: "search", id: "s-1", query: "小米科技", companyName: "小米科技有限责任公司", capturedAt: 1716320000000 },
+  ],
+});
+
+describe("constants + extractData", () => {
+  it("name/version/schema", () => {
+    expect(NAME).toBe("biz-tianyancha");
+    expect(VERSION).toBe("0.1.0");
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+  });
+  it("extractData tolerant", () => {
+    expect(extractData({ data: [{ id: 1 }] })).toHaveLength(1);
+    expect(extractData({ data: { resultList: [{ id: 1 }] } })).toHaveLength(1);
+    expect(extractData({ list: [{ id: 1 }] })).toHaveLength(1);
+    expect(extractData({})).toEqual([]);
+  });
+});
+
+describe("TianyanchaAdapter snapshot mode", () => {
+  it("authenticate validates inputPath", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new TianyanchaAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      expect((await a.authenticate({ inputPath: path.join(os.tmpdir(), "no-tyc.json") })).reason).toBe("INPUT_PATH_UNREADABLE");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("sync 2 kinds + normalize monitor→like / search→interaction", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new TianyanchaAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items.map((x) => x.kind)).toEqual(["monitor", "search"]);
+
+      const mon = a.normalize(items[0]);
+      expect(mon.events[0].subtype).toBe("like");
+      expect(mon.events[0].content.title).toBe("关注公司: 字节跳动有限公司");
+      expect(mon.events[0].extra.legalPerson).toBe("张利东");
+      expect(mon.events[0].extra.regStatus).toBe("存续");
+
+      const search = a.normalize(items[1]);
+      expect(search.events[0].subtype).toBe("interaction");
+      expect(search.events[0].content.title).toBe("搜索企业: 小米科技");
+      expect(search.events[0].extra.companyName).toBe("小米科技有限责任公司");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("include + limit + schema mismatch + unknown kind", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new TianyanchaAdapter();
+      expect((await collect(a.sync({ inputPath: p, include: { monitor: false } }))).map((x) => x.kind)).toEqual(["search"]);
+      expect(await collect(a.sync({ inputPath: p, limit: 1 }))).toHaveLength(1);
+      expect(() => a.normalize({ kind: "bogus", payload: {} })).toThrow(/unknown kind/);
+    } finally {
+      fs.unlinkSync(p);
+    }
+    const bad = writeTmp(JSON.stringify({ schemaVersion: 9, events: [] }));
+    try {
+      const a = new TianyanchaAdapter();
+      await expect(collect(a.sync({ inputPath: bad }))).rejects.toThrow(/schemaVersion mismatch/);
+    } finally {
+      fs.unlinkSync(bad);
+    }
+  });
+});
+
+describe("TianyanchaAdapter cookie-api mode", () => {
+  it("authenticate cookie (userId optional)", async () => {
+    const a = new TianyanchaAdapter({ account: { cookies: COOKIES } });
+    expect(await a.authenticate()).toEqual({ ok: true, account: null, mode: "cookie" });
+  });
+
+  it("sync fetches monitor + search, normalizes", async () => {
+    const byUrl = (u) => (u.includes("monitor") ? "monitor" : "search");
+    const data = {
+      monitor: [{ graphId: "G9", companyName: "腾讯科技", legalPersonName: "马化腾", createTime: 1716300000 }],
+      search: [{ id: "h1", keyword: "阿里巴巴", searchTime: 1716320000 }],
+    };
+    const calls = [];
+    const a = new TianyanchaAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      fetchFn: async ({ url, cookies, query, sign }) => {
+        const k = byUrl(url);
+        calls.push({ k, cookies, pageNum: query.pageNum, sign });
+        return { data: { list: query.pageNum === 1 ? data[k] : [] } };
+      },
+    });
+    const items = await collect(a.sync({}));
+    expect(items.map((x) => x.kind).sort()).toEqual(["monitor", "search"]);
+    expect(calls.every((c) => c.cookies === COOKIES && c.sign === null)).toBe(true);
+    const mon = a.normalize(items.find((x) => x.kind === "monitor"));
+    expect(mon.events[0].content.title).toBe("关注公司: 腾讯科技");
+    expect(mon.events[0].extra.legalPerson).toBe("马化腾");
+    const search = a.normalize(items.find((x) => x.kind === "search"));
+    expect(search.events[0].content.title).toBe("搜索企业: 阿里巴巴");
+  });
+
+  it("invokes signProvider + limit + empty + default fetch + no input", async () => {
+    const signCalls = [];
+    const a = new TianyanchaAdapter({
+      account: { cookies: COOKIES },
+      fetchFn: async ({ query }) => ({ data: { list: query.pageNum === 1 ? [{ graphId: "G1", companyName: "a" }, { graphId: "G2", companyName: "b" }] : [] } }),
+      signProvider: async (ctx) => { signCalls.push(ctx); return "sig"; },
+    });
+    expect(await collect(a.sync({ limit: 1, include: { search: false } }))).toHaveLength(1);
+    expect(signCalls.length).toBeGreaterThan(0);
+    expect(signCalls[0].cookies).toBe(COOKIES);
+
+    const a2 = new TianyanchaAdapter({ account: { cookies: COOKIES }, fetchFn: async () => "<html>login</html>" });
+    expect(await collect(a2.sync({}))).toEqual([]);
+
+    const a3 = new TianyanchaAdapter({ account: { cookies: COOKIES } });
+    await expect(collect(a3.sync({}))).rejects.toThrow(/no fetchFn configured/);
+
+    const a4 = new TianyanchaAdapter();
+    await expect(collect(a4.sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});

package/__tests__/adapters/car-mercedesme.test.js

@@ -0,0 +1,74 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const mb = require("../../lib/adapters/car-mercedesme");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-mb-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+const COOKIES = "mb_token=abc";
+
+describe("car-mercedesme", () => {
+  it("name + tripToRecord (km direct + meters fallback; no id → null)", () => {
+    expect(mb.NAME).toBe("car-mercedesme");
+    const r = mb.tripToRecord({ tripId: "T1", startTime: 1716383000, endTime: 1716385000, startAddress: "家", endAddress: "公司", distanceKm: 12.4, plate: "京A12345" });
+    expect(r).toMatchObject({ vendorId: "mercedesme", recordId: "T1", vehicleType: "car", carrier: "Mercedes me", vehicleNumber: "京A12345" });
+    expect(r.from.name).toBe("家");
+    expect(r.to.name).toBe("公司");
+    expect(r.extras.distanceKm).toBeCloseTo(12.4, 2);
+    // meters fallback
+    expect(mb.tripToRecord({ tripId: "T2", distanceMeters: 5230 }).extras.distanceKm).toBeCloseTo(5.23, 2);
+    expect(mb.tripToRecord({ startAddress: "x" })).toBe(null);
+  });
+  it("extractTrips tolerant", () => {
+    expect(mb.extractTrips({ trips: [{ tripId: 1 }] })).toHaveLength(1);
+    expect(mb.extractTrips({ data: { list: [{ tripId: 1 }] } })).toHaveLength(1);
+    expect(mb.extractTrips({})).toEqual([]);
+  });
+
+  it("snapshot trip → car travel event", async () => {
+    const SNAP = JSON.stringify({ trips: [{ tripId: "T1", startTime: 1716383000, endTime: 1716385000, startAddress: "家", endAddress: "公司", distanceKm: 12.4 }] });
+    const p = writeTmp(SNAP);
+    try {
+      const a = new mb.MercedesMeAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(1);
+      expect(items[0].originalId).toBe("T1");
+      const b = a.normalize(items[0]);
+      expect(b.events[0].source.adapter).toBe("car-mercedesme");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("cookie-api: unverified + sign seam", async () => {
+    let signed = 0;
+    const a = new mb.MercedesMeAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      signProvider: async () => { signed += 1; return "sig"; },
+      fetchFn: async ({ query }) => (query.page > 1 ? { trips: [] } : { trips: [{ tripId: "T9", startTime: 1716383000, distanceMeters: 8000 }] }),
+    });
+    expect(await a.authenticate()).toMatchObject({ ok: true, mode: "cookie", unverified: true });
+    const items = await collect(a.sync({}));
+    expect(items).toHaveLength(1);
+    expect(items[0].originalId).toBe("T9");
+    expect(signed).toBeGreaterThan(0);
+  });
+
+  it("medium sensitivity; default fetch throws", async () => {
+    expect(new mb.MercedesMeAdapter().dataDisclosure.sensitivity).toBe("medium");
+    await expect(collect(new mb.MercedesMeAdapter({ account: { cookies: COOKIES } }).sync({}))).rejects.toThrow(/no fetchFn/);
+  });
+});

package/__tests__/adapters/doc-camscanner.test.js

@@ -0,0 +1,147 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const cs = require("../../lib/adapters/doc-camscanner");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-cs-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+
+const COOKIES = "INTSIG_TOKEN=abc; PHPSESSID=xyz";
+
+describe("doc-camscanner mappers", () => {
+  it("name/version", () => {
+    expect(cs.NAME).toBe("doc-camscanner");
+    expect(cs.VERSION).toBe("0.1.0");
+  });
+  it("mapDoc maps CamScanner fields; doc_type + extension → docType", () => {
+    const rec = cs.mapDoc({
+      sync_doc_id: "DOC123",
+      title: "营业执照",
+      doc_type: 2,
+      page_num: 3,
+      create_time: 1716383000,
+      modify_time: 1716390000,
+      pdf_url: "https://cs/DOC123.pdf",
+      tags: ["证件"],
+    });
+    expect(rec).toMatchObject({ docId: "DOC123", title: "营业执照", docType: "certificate" });
+    expect(rec.createdMs).toBe(1716383000000);
+    expect(rec.updatedMs).toBe(1716390000000);
+    expect(rec.url).toBe("https://cs/DOC123.pdf");
+    expect(rec.extra.pageNum).toBe(3);
+    expect(rec.extra.tags).toEqual(["证件"]);
+    // extension fallback when no doc_type
+    expect(cs.mapDoc({ doc_id: 1, title: "报表.xlsx" }).docType).toBe("excel");
+    expect(cs.mapDoc({ doc_id: 2, title: "合同.pdf" }).docType).toBe("pdf");
+    // default → scan
+    expect(cs.mapDoc({ doc_id: 3, title: "随手拍" }).docType).toBe("scan");
+    // no id → null
+    expect(cs.mapDoc({ title: "noid" })).toBe(null);
+  });
+  it("extractDocs tolerant across shapes", () => {
+    expect(cs.extractDocs({ docs: [{ doc_id: 1 }] })).toHaveLength(1);
+    expect(cs.extractDocs({ list: [{ doc_id: 1 }] })).toHaveLength(1);
+    expect(cs.extractDocs({ data: { docs: [{ doc_id: 1 }] } })).toHaveLength(1);
+    expect(cs.extractDocs({})).toEqual([]);
+  });
+});
+
+describe("CamScannerDocAdapter (via _document-base)", () => {
+  const SNAP = JSON.stringify({
+    schemaVersion: 1,
+    snapshottedAt: 1716383000000,
+    account: { userId: "u1" },
+    events: [
+      {
+        kind: "document",
+        id: "doc-S1",
+        docId: "S1",
+        title: "身份证扫描",
+        docType: "certificate",
+        updatedTime: 1716383000,
+        url: "https://cs/S1.pdf",
+      },
+    ],
+  });
+
+  it("snapshot sync + normalize → event(post)+item(document)", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new cs.CamScannerDocAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(1);
+      const batch = a.normalize(items[0]);
+      expect(batch.events[0].subtype).toBe("post");
+      expect(batch.items[0].subtype).toBe("document");
+      expect(batch.items[0].name).toBe("身份证扫描");
+      expect(batch.items[0].extra.platform).toBe("camscanner");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("cookie-api: fetch + paginate + normalize", async () => {
+    const pages = [
+      { docs: [{ sync_doc_id: 7, title: "发票.pdf", doc_type: "pdf", modify_time: 1716383000 }] },
+      { docs: [] },
+    ];
+    const calls = [];
+    const a = new cs.CamScannerDocAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      fetchFn: async ({ url, cookies, query, sign }) => {
+        calls.push({ url, cookies, offset: query.offset, sign });
+        return query.offset === 0 ? pages[0] : pages[1];
+      },
+    });
+    expect(await a.authenticate()).toEqual({ ok: true, account: "u1", mode: "cookie" });
+    const items = await collect(a.sync({}));
+    expect(items).toHaveLength(1);
+    expect(items[0].originalId).toBe("camscanner:document:7");
+    expect(calls[0].cookies).toBe(COOKIES);
+    expect(calls[0].sign).toBe(null);
+    const batch = a.normalize(items[0]);
+    expect(batch.items[0].name).toBe("发票.pdf");
+    expect(batch.items[0].extra.docType).toBe("pdf");
+  });
+
+  it("cookie-api: signProvider seam invoked when present", async () => {
+    let seen = null;
+    const a = new cs.CamScannerDocAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      signProvider: async ({ url, query }) => {
+        seen = { url, offset: query.offset };
+        return "sig-abc";
+      },
+      fetchFn: async ({ sign, query }) => {
+        return query.offset === 0
+          ? { docs: [{ sync_doc_id: "X", title: "t", _sign: sign }] }
+          : { docs: [] };
+      },
+    });
+    const items = await collect(a.sync({}));
+    expect(items).toHaveLength(1);
+    expect(seen.offset).toBe(0);
+    expect(seen.url).toContain("intsig");
+  });
+
+  it("default fetch throws; no input throws", async () => {
+    const a = new cs.CamScannerDocAdapter({ account: { cookies: COOKIES } });
+    await expect(collect(a.sync({}))).rejects.toThrow(/no fetchFn configured/);
+    const b = new cs.CamScannerDocAdapter();
+    await expect(collect(b.sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});

package/__tests__/adapters/finance-dcep.test.js

@@ -0,0 +1,74 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const dc = require("../../lib/adapters/finance-dcep");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-dcep-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+const COOKIES = "DCEP_SSO=abc";
+
+describe("finance-dcep", () => {
+  it("name/version + mappers", () => {
+    expect(dc.NAME).toBe("finance-dcep");
+    expect(dc.normDirection({ direction: "收款" })).toBe("receive");
+    expect(dc.normDirection({ amount: -5 })).toBe("pay");
+    const t = dc.mapTx({ txId: "X1", time: 1716383000, amount: -12.5, merchant: "便利店", subWallet: "中行子钱包" });
+    expect(t).toMatchObject({ txId: "X1", direction: "pay", counterparty: "便利店", walletType: "中行子钱包" });
+    expect(t.amount).toBe(12.5);
+    expect(dc.mapTx({ amount: 1 })).toBe(null);
+  });
+
+  it("snapshot → PAYMENT event; cookie-api unverified + sign", async () => {
+    const SNAP = JSON.stringify({
+      schemaVersion: 1,
+      snapshottedAt: 1716383000000,
+      account: { userId: "u1" },
+      events: [{ kind: "transaction", id: "tx-X1", txId: "X1", time: 1716383000, amount: 12.5, direction: "pay", counterparty: "便利店" }],
+    });
+    const p = writeTmp(SNAP);
+    try {
+      const a = new dc.DcepAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(1);
+      const b = a.normalize(items[0]);
+      expect(b.events[0].subtype).toBe("payment");
+      expect(b.events[0].content.title).toContain("付款");
+      expect(b.events[0].extra.amount).toBe(12.5);
+      expect(items[0].originalId).toBe("dcep:transaction:X1");
+    } finally {
+      fs.unlinkSync(p);
+    }
+
+    let signed = 0;
+    const a = new dc.DcepAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      signProvider: async () => { signed += 1; return "sig"; },
+      fetchFn: async ({ query }) => (query.page > 1 ? { list: [] } : { list: [{ txId: "X9", time: 1716383000, amount: 9.9, direction: "receive" }] }),
+    });
+    expect(await a.authenticate()).toMatchObject({ ok: true, mode: "cookie", unverified: true });
+    const items = await collect(a.sync({}));
+    expect(items).toHaveLength(1);
+    expect(items[0].originalId).toBe("dcep:transaction:X9");
+    expect(signed).toBeGreaterThan(0);
+  });
+
+  it("high sensitivity + legalGate; default fetch / no input throw", async () => {
+    expect(new dc.DcepAdapter().dataDisclosure.sensitivity).toBe("high");
+    expect(new dc.DcepAdapter().dataDisclosure.legalGate).toBe(true);
+    await expect(collect(new dc.DcepAdapter({ account: { cookies: COOKIES } }).sync({}))).rejects.toThrow(/no fetchFn/);
+    await expect(collect(new dc.DcepAdapter().sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});

package/__tests__/adapters/fitness-joyrun.test.js

@@ -0,0 +1,82 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const jr = require("../../lib/adapters/fitness-joyrun");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-jr-${crypto.randomUUID()}.json`);
+  fs.writeFileSync(p, content, "utf-8");
+  return p;
+}
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+const COOKIES = "joyrun_sid=abc";
+
+describe("fitness-joyrun", () => {
+  it("name + mapRun (meter wins; km*1000 fallback; no id → null)", () => {
+    expect(jr.NAME).toBe("fitness-joyrun");
+    const r = jr.mapRun({ fid: "R1", starttime: 1716383000, meter: 5230, second: 1800, pace: 344, dohas: 320, stepcount: 6400 });
+    expect(r).toMatchObject({ runId: "R1", distanceMeters: 5230, durationSec: 1800, paceSecPerKm: 344, calories: 320, steps: 6400 });
+    expect(r.timeMs).toBe(1716383000000);
+    // distance given as km (5.23) with no meter field → *1000
+    expect(jr.mapRun({ id: "R2", distance: 5.23 }).distanceMeters).toBeCloseTo(5230, 0);
+    expect(jr.mapRun({ meter: 100 })).toBe(null);
+  });
+  it("extractList tolerant", () => {
+    expect(jr.extractList({ data: { runs: [{ fid: 1 }] } })).toHaveLength(1);
+    expect(jr.extractList({ list: [{ fid: 1 }] })).toHaveLength(1);
+    expect(jr.extractList({})).toEqual([]);
+  });
+
+  it("snapshot → OTHER event with km title + run extras", async () => {
+    const SNAP = JSON.stringify({
+      schemaVersion: 1,
+      snapshottedAt: 1716383000000,
+      account: { userId: "u1" },
+      events: [{ kind: "run", id: "r-R1", runId: "R1", time: 1716383000, distanceMeters: 5230, durationSec: 1800, paceSecPerKm: 344, calories: 320 }],
+    });
+    const p = writeTmp(SNAP);
+    try {
+      const a = new jr.JoyrunAdapter();
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(1);
+      const b = a.normalize(items[0]);
+      expect(b.events[0].subtype).toBe("other");
+      expect(b.events[0].content.title).toBe("跑步 5.23 km");
+      expect(b.events[0].extra.distanceMeters).toBe(5230);
+      expect(b.events[0].extra.calories).toBe(320);
+      expect(items[0].originalId).toBe("joyrun:run:R1");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("cookie-api: unverified flag + sign seam + paginate", async () => {
+    let signed = 0;
+    const a = new jr.JoyrunAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      signProvider: async () => { signed += 1; return "sig"; },
+      fetchFn: async ({ query }) => (query.page > 1 ? { list: [] } : { data: { runs: [{ fid: "R9", starttime: 1716383000, meter: 10000, second: 3600 }] } }),
+    });
+    expect(await a.authenticate()).toMatchObject({ ok: true, mode: "cookie", unverified: true });
+    const items = await collect(a.sync({}));
+    expect(items).toHaveLength(1);
+    expect(items[0].originalId).toBe("joyrun:run:R9");
+    expect(signed).toBeGreaterThan(0);
+  });
+
+  it("medium sensitivity (GPS route); default fetch / no input throw", async () => {
+    expect(new jr.JoyrunAdapter().dataDisclosure.sensitivity).toBe("medium");
+    expect(new jr.JoyrunAdapter().dataDisclosure.legalGate).toBe(false);
+    await expect(collect(new jr.JoyrunAdapter({ account: { cookies: COOKIES } }).sync({}))).rejects.toThrow(/no fetchFn/);
+    await expect(collect(new jr.JoyrunAdapter().sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});