@chainlesschain/personal-data-hub 0.4.23 → 0.4.24

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

@@ -0,0 +1,108 @@
+"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 fanqie = require("../../lib/adapters/reading-fanqie");
+const qimao = require("../../lib/adapters/reading-qimao");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-read-${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 = "novel_sid=abc; uid=1";
+
+describe("reading wrappers identity + mappers", () => {
+  it("names", () => {
+    expect(fanqie.NAME).toBe("reading-fanqie");
+    expect(qimao.NAME).toBe("reading-qimao");
+    expect(new fanqie.FanqieReadingAdapter().name).toBe("reading-fanqie");
+    expect(new qimao.QimaoReadingAdapter().name).toBe("reading-qimao");
+  });
+  it("low sensitivity, no legalGate", () => {
+    for (const A of [new fanqie.FanqieReadingAdapter(), new qimao.QimaoReadingAdapter()]) {
+      expect(A.dataDisclosure.sensitivity).toBe("low");
+      expect(A.dataDisclosure.legalGate).toBe(false);
+    }
+  });
+  it("fanqie mapItem (book_id / book_name / read_progress)", () => {
+    const r = fanqie.mapItem({ book_id: "B1", book_name: "诡秘之主", author: "爱潜水的乌贼", category: "玄幻", read_progress: "0.42", last_chapter_title: "第100章", read_time: 1716383000 });
+    expect(r).toMatchObject({ bookId: "B1", title: "诡秘之主", author: "爱潜水的乌贼", category: "玄幻", chapter: "第100章" });
+    expect(r.progress).toBeCloseTo(0.42, 2);
+    expect(r.occurredAt).toBe(1716383000000);
+    expect(r.url).toContain("fanqienovel.com/page/B1");
+    expect(fanqie.mapItem({ book_name: "x" })).toBe(null);
+  });
+  it("qimao mapItem (book_id / title / read_proportion)", () => {
+    const r = qimao.mapItem({ book_id: "Q1", title: "大奉打更人", author: "卖报小郎君", read_proportion: 0.8 });
+    expect(r).toMatchObject({ bookId: "Q1", title: "大奉打更人", author: "卖报小郎君" });
+    expect(r.progress).toBeCloseTo(0.8, 2);
+    expect(qimao.mapItem({ title: "x" })).toBe(null);
+  });
+});
+
+describe("FanqieReadingAdapter (snapshot + cookie-api via _reading-base)", () => {
+  const SNAP = JSON.stringify({
+    schemaVersion: 1,
+    snapshottedAt: 1716383000000,
+    account: { userId: "u1" },
+    events: [
+      { kind: "read", id: "read-B1", bookId: "B1", title: "诡秘之主", author: "乌贼", category: "玄幻", progress: 0.42 },
+      { kind: "favourite", id: "fav-B2", bookId: "B2", title: "全职高手", author: "蝴蝶蓝" },
+    ],
+  });
+
+  it("read → MEDIA event + DOCUMENT item; favourite → LIKE event", async () => {
+    const p = writeTmp(SNAP);
+    try {
+      const a = new fanqie.FanqieReadingAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(2);
+      const read = a.normalize(items[0]);
+      expect(read.events[0].subtype).toBe("media");
+      expect(read.events[0].content.title).toContain("读了: 诡秘之主");
+      expect(read.items[0].subtype).toBe("document");
+      expect(read.items[0].extra.platform).toBe("fanqie");
+      expect(read.events[0].extra.progress).toBeCloseTo(0.42, 2);
+      expect(items[0].originalId).toBe("fanqie:read:read-B1");
+      const fav = a.normalize(items[1]);
+      expect(fav.events[0].subtype).toBe("like");
+      expect(fav.events[0].content.title).toContain("收藏: 全职高手");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("cookie-api: read + favourite fetch + sign seam", async () => {
+    let signed = 0;
+    const a = new fanqie.FanqieReadingAdapter({
+      account: { cookies: COOKIES, userId: "u1" },
+      signProvider: async () => { signed += 1; return "sig"; },
+      fetchFn: async ({ url, query }) => {
+        if (query.page > 1) return { list: [] };
+        if (url.includes("/history")) return { data: { list: [{ book_id: "B9", book_name: "斗破", read_time: 1716383000 }] } };
+        return { data: { books: [{ book_id: "B8", book_name: "遮天" }] } };
+      },
+    });
+    expect(await a.authenticate()).toEqual({ ok: true, account: "u1", mode: "cookie" });
+    const items = await collect(a.sync({}));
+    expect(items).toHaveLength(2);
+    expect(items.map((i) => i.originalId).sort()).toEqual(["fanqie:favourite:B8", "fanqie:read:B9"]);
+    expect(signed).toBeGreaterThan(0);
+  });
+
+  it("default fetch / no input throw", async () => {
+    await expect(collect(new fanqie.FanqieReadingAdapter({ account: { cookies: COOKIES } }).sync({}))).rejects.toThrow(/no fetchFn/);
+    await expect(collect(new fanqie.FanqieReadingAdapter().sync({}))).rejects.toThrow(/needs opts.inputPath/);
+  });
+});

package/__tests__/adapters/travel-didi-consumer.test.js

@@ -0,0 +1,66 @@
+"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/travel-didi-consumer");
+
+function writeTmp(content) {
+  const p = path.join(os.tmpdir(), `cc-didic-${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 = "didi_token=abc";
+
+describe("travel-didi-consumer", () => {
+  it("name distinct from enterprise", () => {
+    expect(dc.NAME).toBe("travel-didi-consumer");
+    expect(new dc.DidiConsumerAdapter().name).toBe("travel-didi-consumer");
+  });
+
+  it("snapshot ride → car travel event (via travel-base normalize)", async () => {
+    const SNAP = JSON.stringify([
+      { orderId: "O1", fromAddress: "家", toAddress: "公司", departTime: 1716383000, arriveTime: 1716385000, fare: 2350, productName: "快车" },
+    ]);
+    const p = writeTmp(SNAP);
+    try {
+      const a = new dc.DidiConsumerAdapter();
+      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
+      const items = await collect(a.sync({ inputPath: p }));
+      expect(items).toHaveLength(1);
+      expect(items[0].originalId).toBe("O1");
+      const b = a.normalize(items[0]);
+      expect(b.events.length).toBeGreaterThan(0);
+      expect(b.source ? true : b.events[0].source.adapter).toBe("travel-didi-consumer");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("cookie-api: unverified + sign seam + paginate", async () => {
+    let signed = 0;
+    const a = new dc.DidiConsumerAdapter({
+      account: { cookies: COOKIES, phone: "1" },
+      signProvider: async () => { signed += 1; return "sig"; },
+      fetchFn: async ({ query }) => (query.pageIndex > 1 ? { data: { list: [] } } : { data: { list: [{ orderId: "O9", fromAddress: "A", toAddress: "B", departTime: Date.now() }] } }),
+    });
+    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("O9");
+    expect(signed).toBeGreaterThan(0);
+  });
+
+  it("medium sensitivity; default fetch throws", async () => {
+    expect(new dc.DidiConsumerAdapter().dataDisclosure.sensitivity).toBe("medium");
+    await expect(collect(new dc.DidiConsumerAdapter({ account: { cookies: COOKIES } }).sync({}))).rejects.toThrow(/no fetchFn/);
+  });
+});

package/__tests__/audio-ximalaya-snapshot.test.js

@@ -0,0 +1,279 @@
+"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 {
+  XimalayaAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+  VALID_KINDS,
+  extractList,
+  trackItemToRecord,
+  albumItemToRecord,
+} = require("../lib/adapters/audio-ximalaya");
+const { assertAdapter } = require("../lib/adapter-spec");
+const { validateBatch } = require("../lib/batch");
+
+// 喜马拉雅 (Ximalaya) — 听书/播客; mirrors music-kugou's play/favorite/subscribe
+// shape. signing injected (signProvider). pure-Node.
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "audio-ximalaya.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+describe("XimalayaAdapter snapshot mode", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "xmly-snap-"));
+  });
+
+  it("exports schema constants", () => {
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+    expect(VALID_KINDS).toEqual(["play", "favorite", "subscribe"]);
+  });
+
+  it("authenticate(inputPath) ok when readable", async () => {
+    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: Date.now(), events: [] });
+    const a = new XimalayaAdapter();
+    const res = await a.authenticate({ inputPath: p });
+    expect(res.ok).toBe(true);
+    expect(res.mode).toBe("snapshot-file");
+  });
+
+  it("authenticate() no input → NO_INPUT", async () => {
+    const a = new XimalayaAdapter();
+    const res = await a.authenticate({});
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("NO_INPUT");
+  });
+
+  it("sync() without input throws with signProvider hint", async () => {
+    const a = new XimalayaAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({})) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(String(threw.message)).toMatch(/signProvider/);
+  });
+
+  it("rejects schemaVersion mismatch", async () => {
+    const p = writeSnapshot(tmpDir, { schemaVersion: 9, snapshottedAt: Date.now(), events: [] });
+    const a = new XimalayaAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("play (收听节目) → MEDIA event + MEDIA item", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1, snapshottedAt: now,
+      account: { userId: "u1", name: "alice" },
+      events: [
+        { kind: "play", id: "t1", trackId: "98765", title: "第1集 三体广播剧",
+          anchor: "729声工场", album: "三体", durationSec: 1800, capturedAt: now - 1000 },
+      ],
+    });
+    const a = new XimalayaAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].originalId).toBe("ximalaya:play:t1");
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+    expect(batch.events[0].subtype).toBe("media");
+    expect(batch.events[0].content.title).toContain("收听: 第1集 三体广播剧 - 729声工场");
+    expect(batch.items[0].subtype).toBe("media");
+    expect(batch.items[0].name).toBe("第1集 三体广播剧 - 729声工场");
+    expect(batch.events[0].extra.album).toBe("三体");
+  });
+
+  it("favorite → LIKE event", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1, snapshottedAt: now,
+      events: [{ kind: "favorite", id: "f1", trackId: "555", title: "收藏的播客", anchor: "主播X" }],
+    });
+    const a = new XimalayaAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+    expect(batch.events[0].subtype).toBe("like");
+    expect(batch.events[0].content.title).toContain("收藏: 收藏的播客");
+  });
+
+  it("subscribe → TOPIC (album)", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1, snapshottedAt: now,
+      events: [{ kind: "subscribe", id: "s1", albumId: "30001", album: "得到·精英日课",
+        trackCount: 365, anchor: "罗振宇" }],
+    });
+    const a = new XimalayaAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+    expect(batch.events.length).toBe(0);
+    expect(batch.topics.length).toBe(1);
+    expect(batch.topics[0].id).toBe("topic-ximalaya-album-30001");
+    expect(batch.topics[0].name).toBe("得到·精英日课");
+    expect(batch.topics[0].extra.trackCount).toBe(365);
+  });
+
+  it("respects include opt-out + limit", async () => {
+    const now = Date.now();
+    const events = [
+      { kind: "play", id: "p1", trackId: "1", title: "a", capturedAt: now },
+      { kind: "favorite", id: "f1", trackId: "2", title: "b" },
+      { kind: "subscribe", id: "s1", albumId: "3", album: "c" },
+    ];
+    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: now, events });
+    const a = new XimalayaAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, include: { favorite: false, subscribe: false } })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].kind).toBe("play");
+  });
+
+  it("filters unknown kinds", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1, snapshottedAt: now,
+      events: [
+        { kind: "play", id: "p1", trackId: "1", title: "a", capturedAt: now },
+        { kind: "comment", id: "c1" },
+      ],
+    });
+    const a = new XimalayaAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+  });
+
+  it("advertises capabilities + passes assertAdapter", () => {
+    const a = new XimalayaAdapter();
+    expect(a.capabilities).toContain("sync:snapshot");
+    expect(a.capabilities).toContain("sync:cookie-api");
+    expect(assertAdapter(a).ok).toBe(true);
+  });
+});
+
+describe("XimalayaAdapter cookie-api mode", () => {
+  it("authenticate(cookie) ok with cookies (userId optional)", async () => {
+    const a = new XimalayaAdapter({ account: { cookies: "1&_token=ok" } });
+    const res = await a.authenticate();
+    expect(res.ok).toBe(true);
+    expect(res.mode).toBe("cookie");
+  });
+
+  it("fetches plays/favorites/subscribes and normalizes", async () => {
+    const byUrl = (url) => {
+      if (url.includes("/history")) {
+        return { data: { list: [{ trackId: 98765, title: "第1集", nickname: "声工场", albumTitle: "三体", duration: 1800, startedAt: 1700000000000 }] } };
+      }
+      if (url.includes("/favorite")) {
+        return { data: { tracks: [{ track_id: 555, track_title: "播客A", anchor_name: "主播X" }] } };
+      }
+      if (url.includes("/subscribe")) {
+        return { data: { albums: [{ albumId: 30001, albumTitle: "精英日课", includeTrackCount: 365, nickname: "罗振宇" }] } };
+      }
+      return {};
+    };
+    const fetchFn = async (opts) => byUrl(opts.url);
+    const a = new XimalayaAdapter({ account: { userId: "u1", cookies: "1&_token=ok" }, fetchFn });
+    const raws = [];
+    for await (const r of a.sync({})) raws.push(r);
+    expect(raws.map((r) => r.kind).sort()).toEqual(["favorite", "play", "subscribe"]);
+
+    const play = raws.find((r) => r.kind === "play");
+    const pb = a.normalize(play);
+    expect(validateBatch(pb).valid).toBe(true);
+    expect(pb.events[0].content.title).toContain("收听: 第1集 - 声工场");
+    expect(pb.items[0].name).toBe("第1集 - 声工场");
+
+    const sub = raws.find((r) => r.kind === "subscribe");
+    const sb = a.normalize(sub);
+    expect(sb.topics[0].name).toBe("精英日课");
+    expect(sb.topics[0].extra.trackCount).toBe(365);
+  });
+
+  it("invokes signProvider, passes sign to fetchFn", async () => {
+    let seen = null;
+    const signProvider = async () => "SIG";
+    const fetchFn = async (opts) => {
+      seen = opts.sign;
+      return {};
+    };
+    const a = new XimalayaAdapter({ account: { cookies: "x=1" }, fetchFn, signProvider });
+    for await (const _r of a.sync({ include: { favorite: false, subscribe: false } })) { /* drain */ }
+    expect(seen).toBe("SIG");
+  });
+
+  it("paginates plays until short page", async () => {
+    const all = Array.from({ length: 45 }, (_, i) => ({ trackId: i + 1, title: `t${i}`, startedAt: 1700000000000 }));
+    const seenPages = [];
+    const fetchFn = async (opts) => {
+      if (!opts.url.includes("/history")) return {};
+      const page = opts.query.page;
+      seenPages.push(page);
+      return { list: all.slice((page - 1) * 30, page * 30) };
+    };
+    const a = new XimalayaAdapter({ account: { cookies: "x=1" }, fetchFn });
+    const raws = [];
+    for await (const r of a.sync({ include: { favorite: false, subscribe: false } })) raws.push(r);
+    expect(raws.length).toBe(45);
+    expect(seenPages).toEqual([1, 2]);
+  });
+
+  it("extractList + item mappers tolerate shapes", () => {
+    expect(extractList({ list: [1] })).toEqual([1]);
+    expect(extractList({ data: { tracks: [2] } })).toEqual([2]);
+    expect(extractList({ data: { albums: [3] } })).toEqual([3]);
+    expect(extractList(null)).toEqual([]);
+    expect(trackItemToRecord({ trackId: 7, title: "x" }).trackId).toBe("7");
+    expect(trackItemToRecord({})).toBe(null);
+    expect(albumItemToRecord({ albumId: 9, albumTitle: "A" }).album).toBe("A");
+    expect(albumItemToRecord({})).toBe(null);
+  });
+
+  it("uses opts.*Url overrides", async () => {
+    const seen = [];
+    const fetchFn = async (opts) => {
+      seen.push(opts.url);
+      return {};
+    };
+    const a = new XimalayaAdapter({
+      account: { cookies: "x=1" },
+      fetchFn,
+      playsUrl: "https://x/p",
+      favoritesUrl: "https://x/f",
+      subscribesUrl: "https://x/s",
+    });
+    for await (const _r of a.sync({})) { /* drain */ }
+    expect(seen).toEqual(["https://x/p", "https://x/f", "https://x/s"]);
+  });
+
+  it("default fetchFn throws legible error", async () => {
+    const a = new XimalayaAdapter({ account: { cookies: "x=1" } });
+    let threw = null;
+    try {
+      for await (const _r of a.sync({})) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(String(threw.message)).toMatch(/no fetchFn configured/);
+  });
+});

package/__tests__/fitness-keep-snapshot.test.js

@@ -0,0 +1,224 @@
+"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 {
+  KeepAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+  VALID_SNAPSHOT_KINDS,
+  mapWorkout,
+  extractList,
+  typeLabel,
+} = require("../lib/adapters/fitness-keep");
+const { assertAdapter } = require("../lib/adapter-spec");
+const { validateBatch } = require("../lib/batch");
+
+// Keep (健身) — mirrors fitness-joyrun but multi-type (workoutType). best-effort
+// scaffold; signing injected. pure-Node.
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "fitness-keep.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+describe("KeepAdapter snapshot mode", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "keep-snap-"));
+  });
+
+  it("exports schema constants", () => {
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+    expect(VALID_SNAPSHOT_KINDS).toEqual(["workout"]);
+  });
+
+  it("authenticate(inputPath) ok; authenticate() no input → NO_INPUT", async () => {
+    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: Date.now(), events: [] });
+    const a = new KeepAdapter();
+    expect((await a.authenticate({ inputPath: p })).ok).toBe(true);
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("NO_INPUT");
+  });
+
+  it("rejects schemaVersion mismatch", async () => {
+    const p = writeSnapshot(tmpDir, { schemaVersion: 9, snapshottedAt: Date.now(), events: [] });
+    const a = new KeepAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("running workout → OTHER event '运动: 跑步 X km' + GPS-bearing extra", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1, snapshottedAt: now,
+      account: { userId: "u1" },
+      events: [
+        { kind: "workout", id: "w1", workoutId: "9001", type: "running", name: "晨跑",
+          time: 1700000000, distanceMeters: 5230, durationSec: 1800, calories: 320, steps: 6400 },
+      ],
+    });
+    const a = new KeepAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].originalId).toBe("keep:workout:9001");
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+    expect(batch.events[0].subtype).toBe("other");
+    expect(batch.events[0].content.title).toBe("运动: 跑步 5.23 km");
+    expect(batch.events[0].extra.workoutType).toBe("running");
+    expect(batch.events[0].extra.calories).toBe(320);
+  });
+
+  it("non-distance workout (yoga) → '运动: 瑜伽 N 分钟'", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1, snapshottedAt: now,
+      events: [
+        { kind: "workout", id: "w2", workoutId: "9002", type: "yoga", name: "晚间瑜伽",
+          time: now, durationSec: 1500, calories: 120 },
+      ],
+    });
+    const a = new KeepAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+    expect(batch.events[0].content.title).toBe("运动: 瑜伽 25 分钟");
+  });
+
+  it("unknown type falls back to raw token; no metrics → bare '运动: <type>'", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1, snapshottedAt: now,
+      events: [{ kind: "workout", id: "w3", workoutId: "9003", type: "parkour", time: now }],
+    });
+    const a = new KeepAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    const batch = a.normalize(raws[0]);
+    expect(batch.events[0].content.title).toBe("运动: parkour");
+  });
+
+  it("respects include opt-out + limit", async () => {
+    const now = Date.now();
+    const events = Array.from({ length: 4 }, (_, i) => ({
+      kind: "workout", id: `w${i}`, workoutId: String(100 + i), type: "running",
+      time: now - i * 1000, distanceMeters: 3000,
+    }));
+    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: now, events });
+    const a = new KeepAdapter();
+    let raws = [];
+    for await (const r of a.sync({ inputPath: p, limit: 2 })) raws.push(r);
+    expect(raws.length).toBe(2);
+    raws = [];
+    for await (const r of a.sync({ inputPath: p, include: { workout: false } })) raws.push(r);
+    expect(raws.length).toBe(0);
+  });
+
+  it("advertises capabilities + passes assertAdapter", () => {
+    const a = new KeepAdapter();
+    expect(a.capabilities).toContain("sync:snapshot");
+    expect(a.capabilities).toContain("sync:cookie-api");
+    expect(assertAdapter(a).ok).toBe(true);
+  });
+});
+
+describe("KeepAdapter cookie-api mode", () => {
+  it("authenticate(cookie) returns unverified:true (best-effort scaffold)", async () => {
+    const a = new KeepAdapter({ account: { cookies: "token=ok" } });
+    const res = await a.authenticate();
+    expect(res.ok).toBe(true);
+    expect(res.mode).toBe("cookie");
+    expect(res.unverified).toBe(true);
+  });
+
+  it("fetches workouts via fetchFn and normalizes (km vs meters heuristic)", async () => {
+    const fetchFn = async () => ({
+      data: {
+        records: [
+          { workoutId: 555, type: "cycling", name: "骑行", doneDate: 1700000000, distance: 12.5, duration: 2400, kcal: 410 },
+        ],
+      },
+    });
+    const a = new KeepAdapter({ account: { userId: "u1", cookies: "token=ok" }, fetchFn });
+    const raws = [];
+    for await (const r of a.sync({})) raws.push(r);
+    expect(raws.length).toBe(1);
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+    // distance 12.5 (looks like km, no meter field) → 12500 m → 12.50 km
+    expect(batch.events[0].content.title).toBe("运动: 骑行 12.50 km");
+    expect(batch.events[0].extra.calories).toBe(410);
+  });
+
+  it("invokes signProvider, passes sign to fetchFn", async () => {
+    let seen = null;
+    const signProvider = async () => "SIG";
+    const fetchFn = async (opts) => {
+      seen = opts.sign;
+      return { list: [] };
+    };
+    const a = new KeepAdapter({ account: { cookies: "x=1" }, fetchFn, signProvider });
+    for await (const _r of a.sync({})) { /* drain */ }
+    expect(seen).toBe("SIG");
+  });
+
+  it("paginates until short page", async () => {
+    const all = Array.from({ length: 45 }, (_, i) => ({ workoutId: i + 1, type: "running", time: 1700000000, distanceMeters: 3000 }));
+    const seenPages = [];
+    const fetchFn = async (opts) => {
+      const page = opts.query.page;
+      seenPages.push(page);
+      return { list: all.slice((page - 1) * 30, page * 30) };
+    };
+    const a = new KeepAdapter({ account: { cookies: "x=1" }, fetchFn });
+    const raws = [];
+    for await (const r of a.sync({})) raws.push(r);
+    expect(raws.length).toBe(45);
+    expect(seenPages).toEqual([1, 2]);
+  });
+
+  it("mapWorkout / extractList / typeLabel helpers", () => {
+    expect(mapWorkout({ workoutId: 7, type: "running", distanceMeters: 5000 }).distanceMeters).toBe(5000);
+    expect(mapWorkout({})).toBe(null);
+    expect(extractList({ data: { logs: [1] } })).toEqual([1]);
+    expect(extractList(null)).toEqual([]);
+    expect(typeLabel("yoga")).toBe("瑜伽");
+    expect(typeLabel("xyz")).toBe("xyz");
+    expect(typeLabel(null)).toBe("运动");
+  });
+
+  it("uses opts.listUrl override", async () => {
+    let seenUrl = null;
+    const fetchFn = async (opts) => {
+      seenUrl = opts.url;
+      return { list: [] };
+    };
+    const a = new KeepAdapter({ account: { cookies: "x=1" }, fetchFn, listUrl: "https://x/w" });
+    for await (const _r of a.sync({})) { /* drain */ }
+    expect(seenUrl).toBe("https://x/w");
+  });
+
+  it("default fetchFn throws legible error", async () => {
+    const a = new KeepAdapter({ account: { cookies: "x=1" } });
+    let threw = null;
+    try {
+      for await (const _r of a.sync({})) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(String(threw.message)).toMatch(/no fetchFn configured/);
+  });
+});