@chainlesschain/personal-data-hub 0.4.29 → 0.4.30

package/__tests__/adapters/health-meiyou.test.js

@@ -1,125 +0,0 @@
-"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 my = require("../../lib/adapters/health-meiyou");
-
-function writeTmp(content) {
-  const p = path.join(os.tmpdir(), `cc-my-${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 = "myclient_id=abc; sid=xyz";
-
-describe("health-meiyou mappers", () => {
-  it("name/version", () => {
-    expect(my.NAME).toBe("health-meiyou");
-    expect(my.VERSION).toBe("0.1.0");
-  });
-  it("mapPeriod / mapRecord field aliases; no id → null", () => {
-    const p = my.mapPeriod({ record_id: "P1", start_date: 1716383000, end_date: 1716800000, cycle_length: 28, period_length: 5 });
-    expect(p).toMatchObject({ recordId: "P1", cycleLength: 28, periodLength: 5 });
-    expect(p.startMs).toBe(1716383000000);
-    expect(my.mapPeriod({})).toBe(null);
-    const r = my.mapRecord({ id: "R1", record_type: "mood", date: 1716383000, value: "开心", remark: "今天不错" });
-    expect(r).toMatchObject({ recordId: "R1", recordType: "mood", value: "开心", note: "今天不错" });
-    expect(my.mapRecord({ note: "noid" })).toBe(null);
-  });
-  it("extractList tolerant", () => {
-    expect(my.extractList({ list: [{ id: 1 }] })).toHaveLength(1);
-    expect(my.extractList({ data: { calendar: [{ id: 1 }] } })).toHaveLength(1);
-    expect(my.extractList({})).toEqual([]);
-  });
-});
-
-describe("MeiyouAdapter (snapshot + cookie-api)", () => {
-  const SNAP = JSON.stringify({
-    schemaVersion: 1,
-    snapshottedAt: 1716383000000,
-    account: { userId: "u1" },
-    events: [
-      { kind: "period", id: "p-P1", recordId: "P1", startDate: 1716383000, endDate: 1716800000, cycleLength: 28, periodLength: 5 },
-      { kind: "record", id: "r-R1", recordId: "R1", recordType: "mood", date: 1716383000, value: "开心" },
-    ],
-  });
-
-  it("snapshot sync + normalize → period + record events", async () => {
-    const p = writeTmp(SNAP);
-    try {
-      const a = new my.MeiyouAdapter();
-      expect((await a.authenticate({ inputPath: p })).mode).toBe("snapshot-file");
-      const items = await collect(a.sync({ inputPath: p }));
-      expect(items).toHaveLength(2);
-      const period = a.normalize(items[0]);
-      expect(period.events[0].subtype).toBe("other");
-      expect(period.events[0].content.title).toBe("经期记录");
-      expect(period.events[0].extra.cycleLength).toBe(28);
-      expect(items[0].originalId).toBe("meiyou:period:P1");
-      const record = a.normalize(items[1]);
-      expect(record.events[0].extra.recordType).toBe("mood");
-      expect(record.events[0].extra.value).toBe("开心");
-      expect(items[1].originalId).toBe("meiyou:record:R1");
-    } finally {
-      fs.unlinkSync(p);
-    }
-  });
-
-  it("dataDisclosure: high sensitivity + legalGate (reproductive health)", () => {
-    const a = new my.MeiyouAdapter();
-    expect(a.dataDisclosure.sensitivity).toBe("high");
-    expect(a.dataDisclosure.legalGate).toBe(true);
-  });
-
-  it("include filter can exclude a kind", async () => {
-    const p = writeTmp(SNAP);
-    try {
-      const a = new my.MeiyouAdapter();
-      const items = await collect(a.sync({ inputPath: p, include: { record: false } }));
-      expect(items).toHaveLength(1);
-      expect(items[0].kind).toBe("period");
-    } finally {
-      fs.unlinkSync(p);
-    }
-  });
-
-  it("cookie-api: best-effort fetch both kinds + unverified flag + sign seam", async () => {
-    const calls = [];
-    let signed = 0;
-    const a = new my.MeiyouAdapter({
-      account: { cookies: COOKIES, userId: "u1" },
-      signProvider: async () => {
-        signed += 1;
-        return "sig";
-      },
-      fetchFn: async ({ url, query }) => {
-        calls.push({ url, page: query.page });
-        if (query.page > 1) return { list: [] };
-        if (url.includes("/period")) return { list: [{ recordId: "P9", startDate: 1716383000, cycleLength: 30 }] };
-        return { list: [{ recordId: "R9", recordType: "weight", date: 1716383000, value: 55 }] };
-      },
-    });
-    const auth = await a.authenticate();
-    expect(auth).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(["meiyou:period:P9", "meiyou:record:R9"]);
-    expect(signed).toBeGreaterThan(0);
-  });
-
-  it("default fetch throws; no input throws", async () => {
-    const a = new my.MeiyouAdapter({ account: { cookies: COOKIES } });
-    await expect(collect(a.sync({}))).rejects.toThrow(/no fetchFn configured/);
-    const b = new my.MeiyouAdapter();
-    await expect(collect(b.sync({}))).rejects.toThrow(/needs opts.inputPath/);
-  });
-});

package/__tests__/adapters/local-files.test.js

@@ -1,264 +0,0 @@
-"use strict";
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, utimesSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-const {
-  LocalFilesAdapter,
-  LOCAL_FILES_NAME,
-  LOCAL_FILES_VERSION,
-} = require("../../lib/adapters/local-files");
-const { assertAdapter } = require("../../lib/adapter-spec");
-const { EVENT_SUBTYPES } = require("../../lib/constants");
-const { validateEvent } = require("../../lib/schemas");
-
-let tmpDir;
-
-function makeFile(rel, content, mtimeMs) {
-  const p = join(tmpDir, rel);
-  mkdirSync(join(tmpDir, rel, ".."), { recursive: true });
-  writeFileSync(p, content, "utf-8");
-  if (mtimeMs) utimesSync(p, mtimeMs / 1000, mtimeMs / 1000);
-  return p;
-}
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "local-files-test-"));
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-describe("LocalFilesAdapter — contract + identity", () => {
-  it("conforms to PersonalDataAdapter contract", () => {
-    expect(assertAdapter(new LocalFilesAdapter())).toEqual({ ok: true });
-  });
-
-  it("identifies as local-files with sync:local-file-walk capability", () => {
-    const a = new LocalFilesAdapter();
-    expect(a.name).toBe(LOCAL_FILES_NAME);
-    expect(a.name).toBe("local-files");
-    expect(a.version).toBe(LOCAL_FILES_VERSION);
-    expect(a.capabilities).toContain("sync:local-file-walk");
-  });
-});
-
-describe("LocalFilesAdapter.sync", () => {
-  it("yields one row per file across multiple roots", async () => {
-    const r1 = join(tmpDir, "root1");
-    const r2 = join(tmpDir, "root2");
-    mkdirSync(r1);
-    mkdirSync(r2);
-    makeFile("root1/a.txt", "a", 1_700_000_001_000);
-    makeFile("root1/b.md", "b", 1_700_000_002_000);
-    makeFile("root2/c.pdf", "c", 1_700_000_003_000);
-    const a = new LocalFilesAdapter({ roots: [r1, r2] });
-    const raws = [];
-    for await (const r of a.sync()) raws.push(r);
-    expect(raws).toHaveLength(3);
-    expect(raws.every((r) => r.kind === "local-file")).toBe(true);
-    const names = raws.map((r) => r.payload.name).sort();
-    expect(names).toEqual(["a.txt", "b.md", "c.pdf"]);
-  });
-
-  it("walks subdirectories within maxDepth", async () => {
-    const r = join(tmpDir, "r");
-    mkdirSync(r);
-    makeFile("r/sub/nested/deep.txt", "x", 1_700_000_001_000);
-    const a = new LocalFilesAdapter({ roots: [r] });
-    const raws = [];
-    for await (const x of a.sync()) raws.push(x);
-    expect(raws).toHaveLength(1);
-    expect(raws[0].payload.name).toBe("deep.txt");
-  });
-
-  it("excludes xwechat_files / WXWork / node_modules / .git by default", async () => {
-    const r = join(tmpDir, "r");
-    mkdirSync(r);
-    makeFile("r/normal.txt", "ok", 1_700_000_001_000);
-    makeFile("r/xwechat_files/x.txt", "skip", 1_700_000_001_000);
-    makeFile("r/WXWork/y.txt", "skip", 1_700_000_001_000);
-    makeFile("r/node_modules/lib/index.js", "skip", 1_700_000_001_000);
-    makeFile("r/.git/config", "skip", 1_700_000_001_000);
-    const a = new LocalFilesAdapter({ roots: [r] });
-    const raws = [];
-    for await (const x of a.sync()) raws.push(x);
-    expect(raws.map((r) => r.payload.name)).toEqual(["normal.txt"]);
-  });
-
-  it("custom excludes override defaults", async () => {
-    const r = join(tmpDir, "r");
-    mkdirSync(r);
-    makeFile("r/.git/config", "kept-now", 1_700_000_001_000);
-    makeFile("r/build/out.txt", "skipped-now", 1_700_000_001_000);
-    const a = new LocalFilesAdapter({ roots: [r], excludes: ["build"] });
-    const raws = [];
-    for await (const x of a.sync()) raws.push(x);
-    // .git is hidden (leading '.') so still skipped even without default rule
-    expect(raws.map((r) => r.payload.name)).toEqual([]);
-  });
-
-  it("skips hidden files / dirs (leading '.')", async () => {
-    const r = join(tmpDir, "r");
-    mkdirSync(r);
-    makeFile("r/.hidden", "skip", 1_700_000_001_000);
-    makeFile("r/.cache/sub.txt", "skip", 1_700_000_001_000);
-    makeFile("r/visible.txt", "ok", 1_700_000_001_000);
-    const a = new LocalFilesAdapter({ roots: [r] });
-    const raws = [];
-    for await (const x of a.sync()) raws.push(x);
-    expect(raws.map((r) => r.payload.name)).toEqual(["visible.txt"]);
-  });
-
-  it("respects since filter (file mtime granularity)", async () => {
-    const r = join(tmpDir, "r");
-    mkdirSync(r);
-    makeFile("r/old.txt", "x", 1_700_000_001_000);
-    makeFile("r/new.txt", "x", 1_700_000_005_000);
-    const a = new LocalFilesAdapter({ roots: [r] });
-    const raws = [];
-    for await (const x of a.sync({ since: 1_700_000_003_000 })) raws.push(x);
-    expect(raws.map((r) => r.payload.name)).toEqual(["new.txt"]);
-  });
-
-  it("respects limit", async () => {
-    const r = join(tmpDir, "r");
-    mkdirSync(r);
-    for (let i = 0; i < 5; i++) makeFile(`r/f${i}.txt`, "x", 1_700_000_001_000);
-    const a = new LocalFilesAdapter({ roots: [r] });
-    const raws = [];
-    for await (const x of a.sync({ limit: 2 })) raws.push(x);
-    expect(raws).toHaveLength(2);
-  });
-
-  it("missing roots silently produce nothing", async () => {
-    const a = new LocalFilesAdapter({ roots: [join(tmpDir, "nonexistent")] });
-    const raws = [];
-    for await (const x of a.sync()) raws.push(x);
-    expect(raws).toHaveLength(0);
-  });
-
-  it("originalId encodes path + mtime so re-saved files dedupe per mtime", async () => {
-    const r = join(tmpDir, "r");
-    mkdirSync(r);
-    const p = makeFile("r/a.txt", "x", 1_700_000_001_000);
-    const a = new LocalFilesAdapter({ roots: [r] });
-    const first = [];
-    for await (const x of a.sync()) first.push(x);
-    expect(first[0].originalId).toBe(`local-file:${p}:1700000001000`);
-    // change mtime -> new originalId so adapter does not collapse history
-    utimesSync(p, 1_700_000_009 / 1000, 1_700_000_009);
-    const second = [];
-    for await (const x of a.sync()) second.push(x);
-    expect(second[0].originalId).not.toBe(first[0].originalId);
-  });
-});
-
-describe("LocalFilesAdapter.authenticate + healthCheck", () => {
-  it("authenticate returns ok=true with resolved roots when defaults exist", async () => {
-    const r = join(tmpDir, "r");
-    mkdirSync(r);
-    const a = new LocalFilesAdapter({ roots: [r] });
-    const result = await a.authenticate();
-    expect(result.ok).toBe(true);
-    expect(result.mode).toBe("file-import");
-    expect(result.roots).toEqual([r]);
-  });
-
-  it("authenticate returns NO_DATA_ROOTS when roots is empty", async () => {
-    const a = new LocalFilesAdapter({ roots: [] });
-    // Constructor coerces empty array to override=null, so defaults kick in.
-    // Force empty roots via context arg path is not exposed; verify the
-    // adapter at least returns ok when defaults present. This test verifies
-    // the no-roots branch by stubbing defaultRoots to return [].
-    a._deps.defaultRoots = () => [];
-    const result = await a.authenticate();
-    expect(result.ok).toBe(false);
-    expect(result.reason).toBe("NO_DATA_ROOTS");
-  });
-
-  it("healthCheck always returns ok=true (file-import adapter has no live dep)", async () => {
-    const a = new LocalFilesAdapter();
-    const r = await a.healthCheck();
-    expect(r.ok).toBe(true);
-    expect(typeof r.lastChecked).toBe("number");
-  });
-});
-
-describe("LocalFilesAdapter.normalize", () => {
-  it("maps local-file → Event(OTHER) with [file] title prefix", () => {
-    const a = new LocalFilesAdapter();
-    const { events } = a.normalize({
-      kind: "local-file",
-      originalId: "local-file:/home/u/Documents/report.pdf:1700000005000",
-      capturedAt: 1_700_000_010_000,
-      payload: {
-        path: "/home/u/Documents/report.pdf",
-        name: "report.pdf",
-        ext: "pdf",
-        size: 4096,
-        mtimeMs: 1_700_000_005_000,
-        root: "/home/u/Documents",
-      },
-    });
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.subtype).toBe(EVENT_SUBTYPES.OTHER);
-    expect(e.actor).toBe("self");
-    expect(e.content.title).toBe("[file] report.pdf");
-    expect(e.content.text).toBe("/home/u/Documents/report.pdf");
-    expect(e.occurredAt).toBe(1_700_000_005_000);
-    expect(e.extra.kind).toBe("local-file");
-    expect(e.extra.ext).toBe("pdf");
-    expect(e.extra.size).toBe(4096);
-    expect(validateEvent(e).valid).toBe(true);
-  });
-
-  it("truncates long filenames in title (keeps full path in text)", () => {
-    const a = new LocalFilesAdapter();
-    const longName = "x".repeat(300) + ".txt";
-    const { events } = a.normalize({
-      kind: "local-file",
-      originalId: "local-file:/r/big.txt:1700000000000",
-      capturedAt: 1_700_000_000_000,
-      payload: {
-        path: "/r/" + longName,
-        name: longName,
-        ext: "txt",
-        size: 0,
-        mtimeMs: 1_700_000_000_000,
-        root: "/r",
-      },
-    });
-    expect(events[0].content.title.length).toBeLessThanOrEqual(101);
-    expect(events[0].content.title.endsWith("…")).toBe(true);
-    expect(events[0].content.text).toContain(longName);
-  });
-
-  it("uses '(无名)' for empty filename", () => {
-    const a = new LocalFilesAdapter();
-    const { events } = a.normalize({
-      kind: "local-file",
-      originalId: "local-file::1700000000000",
-      capturedAt: 1_700_000_000_000,
-      payload: {
-        path: "",
-        name: "",
-        ext: "",
-        size: 0,
-        mtimeMs: 1_700_000_000_000,
-        root: "",
-      },
-    });
-    expect(events[0].content.title).toBe("[file] (无名)");
-  });
-
-  it("throws on unknown raw.kind", () => {
-    expect(() => new LocalFilesAdapter().normalize({ kind: "bogus" })).toThrow(
-      /unknown raw\.kind=bogus/,
-    );
-  });
-});

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

@@ -1,154 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { DingTalkPcAdapter } = require("../../lib/adapters/dingtalk-pc");
-const { FeishuPcAdapter } = require("../../lib/adapters/feishu-pc");
-const { readLocalImDb } = require("../../lib/adapters/_local-im-db-reader");
-const { partitionBatch } = require("../../lib/batch");
-
-// fake driver answering sqlite_master + table_info + SELECT * by table
-function makeFakeDb(spec) {
-  class FakeStmt {
-    constructor(sql) {
-      this.sql = sql;
-    }
-    all() {
-      const s = this.sql;
-      if (/type='table'/.test(s)) return (spec.tables || []).map((n) => ({ name: n }));
-      const ti = s.match(/table_info\("(\w+)"\)/);
-      if (ti) return spec.cols[ti[1]] || [];
-      const fr = s.match(/FROM "(\w+)"/);
-      if (fr) return spec.rows[fr[1]] || [];
-      return [];
-    }
-    get() {
-      return { n: 1 };
-    }
-  }
-  return class FakeDb {
-    // eslint-disable-next-line no-unused-vars
-    constructor(_p, _o) {}
-    prepare(sql) {
-      return new FakeStmt(sql);
-    }
-    pragma() {}
-    exec() {}
-    close() {}
-  };
-}
-
-const SPEC = {
-  // msg_table matches + has time/content → ingested
-  // msg_meta  matches pattern but no time/content → skipped (loud diagnostic)
-  // contact_meta doesn't match pattern → not scanned
-  // sqlite_sequence → filtered (sqlite_*)
-  tables: ["msg_table", "msg_meta", "contact_meta", "sqlite_sequence"],
-  cols: {
-    msg_table: [
-      { name: "msgId" },
-      { name: "createTime" },
-      { name: "senderId" },
-      { name: "conversationId" },
-      { name: "content" },
-    ],
-    msg_meta: [{ name: "uid" }, { name: "name" }],
-    contact_meta: [{ name: "uid" }, { name: "name" }],
-  },
-  rows: {
-    msg_table: [
-      { msgId: "m1", createTime: 1700000000, senderId: "u1", conversationId: "c1", content: "开会通知" },
-      { msgId: "m2", createTime: 1700000010, senderId: "u2", conversationId: "c1", content: "收到" },
-    ],
-  },
-};
-
-// opaque schema — time resolves, but body is a BLOB → text null, raw kept
-const OPAQUE_SPEC = {
-  tables: ["chat_msg"],
-  cols: { chat_msg: [{ name: "id" }, { name: "timestamp" }, { name: "body" }] },
-  rows: { chat_msg: [{ id: 7, timestamp: 1700000000, body: Buffer.from([1, 2]) }] },
-};
-
-function adapter(Cls, spec, { exists = true } = {}) {
-  const a = new Cls({ dbPath: "/fake.db" });
-  a._deps.fs = { existsSync: () => exists, 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("readLocalImDb (generic honest reader)", () => {
-  it("discovers message tables, skips metadata + sqlite_*", () => {
-    const { messages, diagnostic } = readLocalImDb("/x", { _databaseClass: makeFakeDb(SPEC) });
-    expect(diagnostic.messageTables).toEqual(["msg_table"]);
-    expect(diagnostic.skippedTables).toEqual(["msg_meta"]);
-    expect(messages).toHaveLength(2);
-    expect(messages[0].text).toBe("开会通知");
-    expect(messages[0].createdTimeMs).toBe(1700000000000);
-  });
-
-  it("opaque body → text null but rawRow preserved + loud diagnostic", () => {
-    const { messages, diagnostic } = readLocalImDb("/x", { _databaseClass: makeFakeDb(OPAQUE_SPEC) });
-    expect(messages).toHaveLength(1);
-    expect(messages[0].text).toBeNull();
-    expect(messages[0].rawRow).toBeTruthy();
-    expect(diagnostic.textCount).toBe(0);
-    expect(diagnostic.messageTables).toEqual(["chat_msg"]);
-  });
-});
-
-describe.each([
-  ["DingTalkPcAdapter", DingTalkPcAdapter, "dingtalk"],
-  ["FeishuPcAdapter", FeishuPcAdapter, "feishu"],
-])("%s (honest best-effort)", (_label, Cls, platform) => {
-  it("no-arg construct + APP_NOT_INSTALLED when nothing discoverable + legalGate", async () => {
-    const a = new Cls();
-    a._deps.discoveryDeps = {
-      fs: { existsSync: () => false, readdirSync: () => [], statSync: () => ({ size: 0 }), constants: { R_OK: 4 } },
-      home: "/no-home",
-      env: {},
-    };
-    expect(a.extractMode).toBe("device-pull");
-    expect(a.dataDisclosure.legalGate).toBe(true);
-    const r = await a.authenticate({ readinessOnly: true });
-    expect(r.reason).toBe("APP_NOT_INSTALLED");
-  });
-
-  it("reads messages → valid events, platform tag, raw preserved", async () => {
-    const a = adapter(Cls, SPEC);
-    const raws = await collect(a.sync({ dbPath: "/fake.db" }));
-    expect(raws).toHaveLength(2);
-    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);
-    expect(valid.events[0].extra.platform).toBe(platform);
-    expect(valid.events[0].extra.textResolved).toBe(true);
-    expect(valid.events[0].extra.rawRow).toBeTruthy();
-  });
-
-  it("emits local-im-read progress diagnostic", async () => {
-    const a = adapter(Cls, SPEC);
-    const ev = [];
-    await collect(a.sync({ dbPath: "/fake.db", onProgress: (e) => ev.push(e) }));
-    const d = ev.find((e) => e.phase === "local-im-read");
-    expect(d.messageTables).toContain("msg_table");
-    expect(d.messageCount).toBe(2);
-  });
-
-  it("missing db yields nothing; unknown kind throws", async () => {
-    const a = adapter(Cls, SPEC, { exists: false });
-    expect(await collect(a.sync({ dbPath: "/no.db" }))).toHaveLength(0);
-    expect(() => new Cls().normalize({ kind: "x", payload: { kind: "x" } })).toThrow(/unknown kind/);
-  });
-});