@chainlesschain/personal-data-hub 0.2.0 → 0.2.2

package/__tests__/adapters/ai-chat-cookie-capture-spec.test.js

@@ -0,0 +1,211 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  COOKIE_SPEC_VERSION,
+  KNOWN_VENDORS,
+  COOKIE_CAPTURE_SPECS,
+  getSpec,
+  listVendors,
+  classifyProbedCookies,
+  validateCookieCaptureSpec,
+  _internal,
+} = require("../../lib/adapters/ai-chat-history/cookie-capture-spec");
+
+describe("cookie-capture-spec — Phase 10.3.1 matrix", () => {
+  it("exposes a positive integer COOKIE_SPEC_VERSION", () => {
+    expect(Number.isInteger(COOKIE_SPEC_VERSION)).toBe(true);
+    expect(COOKIE_SPEC_VERSION).toBeGreaterThanOrEqual(1);
+  });
+
+  it("KNOWN_VENDORS contains exactly the 9 wired vendors", () => {
+    expect(KNOWN_VENDORS).toEqual([
+      "deepseek",
+      "kimi",
+      "tongyi",
+      "zhipu",
+      "hunyuan",
+      "qianfan",
+      "coze",
+      "dreamina",
+      "doubao",
+    ]);
+    // Defensive — frozen so contributors don't accidentally mutate at runtime.
+    expect(Object.isFrozen(KNOWN_VENDORS)).toBe(true);
+  });
+
+  it("ships 9 specs, one per KNOWN_VENDORS entry, no duplicates", () => {
+    expect(COOKIE_CAPTURE_SPECS.length).toBe(KNOWN_VENDORS.length);
+    const seen = new Set();
+    for (const s of COOKIE_CAPTURE_SPECS) {
+      expect(KNOWN_VENDORS).toContain(s.vendor);
+      expect(seen.has(s.vendor)).toBe(false);
+      seen.add(s.vendor);
+    }
+  });
+
+  it("validates the shipped spec set without errors", () => {
+    const r = validateCookieCaptureSpec(undefined, { throwOnError: false });
+    expect(r.errors).toEqual([]);
+    expect(r.ok).toBe(true);
+  });
+
+  it("each loginUrl host matches at least one cookieDomains entry", () => {
+    for (const s of COOKIE_CAPTURE_SPECS) {
+      const host = new URL(s.loginUrl).host;
+      const matched = s.cookieDomains.some((d) =>
+        d.startsWith(".") ? host.endsWith(d.slice(1)) : host === d,
+      );
+      expect({ vendor: s.vendor, host, matched }).toEqual({ vendor: s.vendor, host, matched: true });
+    }
+  });
+
+  it("each spec has non-empty requiredCookies + postLoginPathHints + positive maxAge", () => {
+    for (const s of COOKIE_CAPTURE_SPECS) {
+      expect(Array.isArray(s.requiredCookies)).toBe(true);
+      expect(s.requiredCookies.length).toBeGreaterThan(0);
+      expect(Array.isArray(s.postLoginPathHints)).toBe(true);
+      expect(s.postLoginPathHints.length).toBeGreaterThan(0);
+      expect(Number.isInteger(s.cookieMaxAgeHintDays)).toBe(true);
+      expect(s.cookieMaxAgeHintDays).toBeGreaterThan(0);
+      expect(typeof s.notes).toBe("string");
+      expect(s.notes.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("getSpec returns the right spec for a known vendor and null for unknown", () => {
+    const ds = getSpec("deepseek");
+    expect(ds).toBeTruthy();
+    expect(ds.vendor).toBe("deepseek");
+    expect(getSpec("notarealvendor")).toBeNull();
+    expect(getSpec("")).toBeNull();
+    expect(getSpec(undefined)).toBeNull();
+    expect(getSpec(null)).toBeNull();
+  });
+
+  it("listVendors returns a copy (mutation does not affect KNOWN_VENDORS)", () => {
+    const arr = listVendors();
+    expect(arr).toEqual([...KNOWN_VENDORS]);
+    arr.push("hacked");
+    expect(KNOWN_VENDORS.includes("hacked")).toBe(false);
+  });
+});
+
+describe("classifyProbedCookies — required vs optional vs missing", () => {
+  it("returns ok=true when all required cookies present (object input)", () => {
+    const r = classifyProbedCookies("deepseek", {
+      userToken: "abc",
+      "intercom-session-deepseek": "xyz",
+    });
+    expect(r.ok).toBe(true);
+    expect(r.foundRequired).toEqual(["userToken"]);
+    expect(r.missingRequired).toEqual([]);
+    expect(r.foundOptional).toEqual(["intercom-session-deepseek"]);
+  });
+
+  it("returns ok=false when a required cookie is missing", () => {
+    const r = classifyProbedCookies("kimi", { refresh_token: "rt", session_id: "sid" });
+    expect(r.ok).toBe(false);
+    expect(r.missingRequired).toEqual(["access_token"]);
+    expect(r.foundOptional.sort()).toEqual(["refresh_token", "session_id"]);
+  });
+
+  it("accepts Electron Cookie[] shape (array of { name, value })", () => {
+    const r = classifyProbedCookies("zhipu", [
+      { name: "chatglm_token", value: "tok" },
+      { name: "cgsessionid", value: "sid" },
+      { name: "unrelated", value: "x" },
+    ]);
+    expect(r.ok).toBe(true);
+    expect(r.foundRequired).toEqual(["chatglm_token"]);
+    expect(r.foundOptional).toContain("cgsessionid");
+  });
+
+  it("accepts raw 'k=v; k=v' string (web-shell paste fallback)", () => {
+    const raw = "sessionid=abc; sid_guard=xyz; passport_csrf_token=csrf;  ;junk";
+    const r = classifyProbedCookies("doubao", raw);
+    expect(r.ok).toBe(true);
+    expect(r.foundRequired).toEqual(["sessionid"]);
+    expect(r.foundOptional.sort()).toEqual(["passport_csrf_token", "sid_guard"]);
+  });
+
+  it("string parser tolerates values containing '=' (e.g. base64)", () => {
+    // sessionid is base64 with '=' padding; only the FIRST '=' is the delimiter.
+    const raw = "sessionid=YWJjZGVmZ2g=; sid_guard=v1=";
+    const r = classifyProbedCookies("coze", raw);
+    expect(r.ok).toBe(true);
+    expect(r.foundRequired).toEqual(["sessionid"]);
+    // raw cookie value must be preserved verbatim including the trailing '='
+    const jar = _internal._normalizeCookieJar(raw);
+    expect(jar.sessionid).toBe("YWJjZGVmZ2g=");
+  });
+
+  it("empty string / null / undefined / wrong type all produce ok=false", () => {
+    for (const input of ["", null, undefined, 42, true]) {
+      const r = classifyProbedCookies("doubao", input);
+      expect(r.ok).toBe(false);
+      expect(r.missingRequired).toEqual(["sessionid"]);
+    }
+  });
+
+  it("returns UNKNOWN_VENDOR reason for an unregistered vendor name", () => {
+    const r = classifyProbedCookies("notarealvendor", { anything: "x" });
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("UNKNOWN_VENDOR");
+  });
+
+  it("treats empty-string cookie value as missing (not present)", () => {
+    const r = classifyProbedCookies("deepseek", { userToken: "" });
+    expect(r.ok).toBe(false);
+    expect(r.foundRequired).toEqual([]);
+    expect(r.missingRequired).toEqual(["userToken"]);
+  });
+});
+
+describe("validateCookieCaptureSpec — defensive guard catches malformed specs", () => {
+  it("flags unknown vendor", () => {
+    const { ok, errors } = validateCookieCaptureSpec(
+      [{ ...COOKIE_CAPTURE_SPECS[0], vendor: "ghostvendor" }],
+      { throwOnError: false },
+    );
+    expect(ok).toBe(false);
+    expect(errors.join(" ")).toMatch(/unknown vendor/);
+  });
+
+  it("flags loginUrl host not matching any cookieDomain", () => {
+    const broken = {
+      ...COOKIE_CAPTURE_SPECS[0],
+      loginUrl: "https://malicious.example.com/",
+    };
+    const { ok, errors } = validateCookieCaptureSpec([broken], { throwOnError: false });
+    expect(ok).toBe(false);
+    expect(errors.join(" ")).toMatch(/does not match any cookieDomain/);
+  });
+
+  it("flags empty requiredCookies / postLoginPathHints / invalid maxAge", () => {
+    const broken = {
+      ...COOKIE_CAPTURE_SPECS[0],
+      requiredCookies: [],
+      postLoginPathHints: [],
+      cookieMaxAgeHintDays: 0,
+    };
+    const { ok, errors } = validateCookieCaptureSpec([broken], { throwOnError: false });
+    expect(ok).toBe(false);
+    const joined = errors.join(" ");
+    expect(joined).toMatch(/requiredCookies/);
+    expect(joined).toMatch(/postLoginPathHints/);
+    expect(joined).toMatch(/cookieMaxAgeHintDays/);
+  });
+
+  it("flags duplicate vendor entries", () => {
+    const dup = [COOKIE_CAPTURE_SPECS[0], { ...COOKIE_CAPTURE_SPECS[0] }];
+    const { ok, errors } = validateCookieCaptureSpec(dup, { throwOnError: false });
+    expect(ok).toBe(false);
+    expect(errors.join(" ")).toMatch(/duplicate vendor/);
+  });
+
+  it("throws by default when malformed (no opts)", () => {
+    expect(() => validateCookieCaptureSpec([{ vendor: "ghost" }])).toThrow(/Invalid cookie capture spec/);
+  });
+});

package/__tests__/adapters/ai-chat-health-checker.test.js

@@ -0,0 +1,262 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+const {
+  createAIChatHealthChecker,
+  DEFAULT_INTERVAL_MS,
+  DEFAULT_FIRST_RUN_DELAY_MS,
+} = require("../../lib/adapters/ai-chat-history/health-checker");
+
+// ─── fakes ────────────────────────────────────────────────────────────────
+
+function makeFakeAccountsStore({ initial = {} } = {}) {
+  const store = new Map(Object.entries(initial));
+  return {
+    get: vi.fn(async (v) => store.get(v) || null),
+    put: vi.fn(async (v, e) => store.set(v, e)),
+    delete: vi.fn(async (v) => store.delete(v)),
+    list: vi.fn(async () => Array.from(store.values())),
+    _store: store,
+  };
+}
+
+function makeFakeAdapter({ behaviors = {} } = {}) {
+  // behaviors = { vendor: ({ok, reason?, throw?: msg}) }
+  return {
+    registerVendor: vi.fn(async (vendor, _cookies) => {
+      const b = behaviors[vendor];
+      if (!b) return { ok: true, userId: "u_" + vendor };
+      if (b.throw) throw new Error(b.throw);
+      return b;
+    }),
+  };
+}
+
+function makeFakeTimers() {
+  // Deterministic timer dispatcher we can step through. We track scheduled
+  // callbacks + their delays in a queue and let tests `flush` them in order.
+  const scheduled = [];
+  let _now = 0;
+  let _id = 0;
+  const setTimeout = (fn, ms) => {
+    const id = ++_id;
+    scheduled.push({ id, type: "timeout", fireAt: _now + ms, fn });
+    return id;
+  };
+  const setInterval = (fn, ms) => {
+    const id = ++_id;
+    scheduled.push({ id, type: "interval", fireAt: _now + ms, ms, fn });
+    return id;
+  };
+  const clearTimeout = (id) => {
+    const i = scheduled.findIndex((s) => s.id === id);
+    if (i >= 0) scheduled.splice(i, 1);
+  };
+  const clearInterval = clearTimeout;
+  async function advance(ms) {
+    _now += ms;
+    while (true) {
+      const due = scheduled
+        .filter((s) => s.fireAt <= _now)
+        .sort((a, b) => a.fireAt - b.fireAt);
+      if (due.length === 0) break;
+      const next = due[0];
+      const idx = scheduled.indexOf(next);
+      scheduled.splice(idx, 1);
+      if (next.type === "interval") {
+        scheduled.push({ ...next, fireAt: next.fireAt + next.ms });
+      }
+      await next.fn();
+      // Flush any fire-and-forget microtasks the callback kicked off
+      // (runOnce returns a promise; the callback doesn't await it).
+      await new Promise((r) => setImmediate(r));
+    }
+  }
+  return {
+    setTimeout, setInterval, clearTimeout, clearInterval,
+    clock: () => _now,
+    advance,
+    _scheduled: scheduled,
+  };
+}
+
+// ─── construction guards ─────────────────────────────────────────────────
+
+describe("createAIChatHealthChecker — guards", () => {
+  it("throws when accountsStore.list missing", () => {
+    expect(() => createAIChatHealthChecker({ accountsStore: {}, vendorAdapter: { registerVendor: () => {} } })).toThrow(/accountsStore.list/);
+  });
+  it("throws when accountsStore.put missing", () => {
+    expect(() => createAIChatHealthChecker({ accountsStore: { list: () => [] }, vendorAdapter: { registerVendor: () => {} } })).toThrow(/accountsStore.put/);
+  });
+  it("throws when vendorAdapter.registerVendor missing", () => {
+    expect(() => createAIChatHealthChecker({ accountsStore: makeFakeAccountsStore() })).toThrow(/vendorAdapter.registerVendor/);
+  });
+});
+
+// ─── runOnce behavior ────────────────────────────────────────────────────
+
+describe("runOnce — health classification", () => {
+  let timers;
+  beforeEach(() => {
+    timers = makeFakeTimers();
+  });
+
+  it("marks vendors ok when adapter returns ok=true", async () => {
+    const store = makeFakeAccountsStore({
+      initial: {
+        deepseek: { vendor: "deepseek", cookies: { userToken: "x" }, cookieSpecVersion: 1 },
+        kimi: { vendor: "kimi", cookies: { access_token: "y" }, cookieSpecVersion: 1 },
+      },
+    });
+    const adapter = makeFakeAdapter();
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter, _deps: timers,
+    });
+    const r = await hc.runOnce();
+    expect(r).toMatchObject({ checked: 2, ok: 2, failed: 0, mismatch: 0 });
+    expect(store._store.get("deepseek").lastHealth.ok).toBe(true);
+    expect(store._store.get("kimi").lastHealth.ok).toBe(true);
+  });
+
+  it("marks vendors failed when adapter returns ok=false (with reason)", async () => {
+    const store = makeFakeAccountsStore({
+      initial: { deepseek: { vendor: "deepseek", cookies: {}, cookieSpecVersion: 1 } },
+    });
+    const adapter = makeFakeAdapter({
+      behaviors: { deepseek: { ok: false, reason: "COOKIE_EXPIRED" } },
+    });
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter, _deps: timers,
+    });
+    const r = await hc.runOnce();
+    expect(r).toMatchObject({ checked: 1, failed: 1, ok: 0 });
+    expect(store._store.get("deepseek").lastHealth).toMatchObject({
+      ok: false, reason: "COOKIE_EXPIRED",
+    });
+  });
+
+  it("marks SPEC_VERSION_MISMATCH when entry.cookieSpecVersion < specVersion", async () => {
+    const store = makeFakeAccountsStore({
+      initial: { deepseek: { vendor: "deepseek", cookies: { x: "y" }, cookieSpecVersion: 0 } },
+    });
+    const adapter = makeFakeAdapter();
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter, specVersion: 2, _deps: timers,
+    });
+    const r = await hc.runOnce();
+    expect(r).toMatchObject({ checked: 1, mismatch: 1, ok: 0, failed: 0 });
+    expect(store._store.get("deepseek").lastHealth).toMatchObject({
+      ok: false, reason: "SPEC_VERSION_MISMATCH",
+    });
+    // Adapter was NOT called because the version gate fired first
+    expect(adapter.registerVendor).not.toHaveBeenCalled();
+  });
+
+  it("captures ADAPTER_THREW when registerVendor rejects", async () => {
+    const store = makeFakeAccountsStore({
+      initial: { deepseek: { vendor: "deepseek", cookies: { x: "y" }, cookieSpecVersion: 1 } },
+    });
+    const adapter = makeFakeAdapter({ behaviors: { deepseek: { throw: "net down" } } });
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter, _deps: timers,
+    });
+    const r = await hc.runOnce();
+    expect(r).toMatchObject({ checked: 1, failed: 1 });
+    expect(store._store.get("deepseek").lastHealth).toMatchObject({
+      ok: false, reason: "ADAPTER_THREW",
+    });
+  });
+
+  it("skips a run if previous one is still in flight", async () => {
+    const store = makeFakeAccountsStore({
+      initial: { deepseek: { vendor: "deepseek", cookies: {}, cookieSpecVersion: 1 } },
+    });
+    let release;
+    const adapter = {
+      registerVendor: vi.fn(() => new Promise((resolve) => {
+        release = () => resolve({ ok: true, userId: "u" });
+      })),
+    };
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter, _deps: timers,
+    });
+    const p1 = hc.runOnce();
+    const r2 = await hc.runOnce();
+    expect(r2.skipped).toBe(true);
+    release();
+    await p1;
+  });
+
+  it("returns 0 counts on empty accounts list", async () => {
+    const hc = createAIChatHealthChecker({
+      accountsStore: makeFakeAccountsStore(),
+      vendorAdapter: makeFakeAdapter(),
+      _deps: timers,
+    });
+    const r = await hc.runOnce();
+    expect(r).toMatchObject({ checked: 0, ok: 0, failed: 0, mismatch: 0 });
+  });
+});
+
+// ─── start / stop / interval scheduling ──────────────────────────────────
+
+describe("start / stop / interval", () => {
+  let timers, store, adapter;
+  beforeEach(() => {
+    timers = makeFakeTimers();
+    store = makeFakeAccountsStore({
+      initial: { deepseek: { vendor: "deepseek", cookies: { userToken: "x" }, cookieSpecVersion: 1 } },
+    });
+    adapter = makeFakeAdapter();
+  });
+
+  it("first run happens after firstRunDelayMs (30s default), then interval (6h)", async () => {
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter,
+      intervalMs: 6 * 3600_000, firstRunDelayMs: 30_000,
+      _deps: timers,
+    });
+    hc.start();
+    expect(hc.status().started).toBe(true);
+    // 10s in — nothing has fired yet
+    await timers.advance(10_000);
+    expect(adapter.registerVendor).not.toHaveBeenCalled();
+    // 30s mark — first run fires
+    await timers.advance(20_000);
+    expect(adapter.registerVendor).toHaveBeenCalledTimes(1);
+    // Another 6h — interval run #1
+    await timers.advance(6 * 3600_000);
+    expect(adapter.registerVendor).toHaveBeenCalledTimes(2);
+  });
+
+  it("start is idempotent — second call returns false", () => {
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter, _deps: timers,
+    });
+    expect(hc.start()).toBe(true);
+    expect(hc.start()).toBe(false);
+  });
+
+  it("stop clears pending first-run + interval", async () => {
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter, firstRunDelayMs: 30_000, _deps: timers,
+    });
+    hc.start();
+    hc.stop();
+    expect(hc.status().started).toBe(false);
+    // 60s in — nothing fires since we stopped
+    await timers.advance(60_000);
+    expect(adapter.registerVendor).not.toHaveBeenCalled();
+  });
+
+  it("uses default 6h interval + 30s delay when not specified", () => {
+    const hc = createAIChatHealthChecker({
+      accountsStore: store, vendorAdapter: adapter, _deps: timers,
+    });
+    const s = hc.status();
+    expect(s.intervalMs).toBe(DEFAULT_INTERVAL_MS);
+    expect(s.firstRunDelayMs).toBe(DEFAULT_FIRST_RUN_DELAY_MS);
+  });
+});

package/__tests__/adapters/ai-chat-history.test.js

@@ -21,7 +21,7 @@ const {
 // ─── vendor-spec assertion ──────────────────────────────────────────────
 
 describe("assertVendorSpec — SUPPORTED_VENDORS", () => {
-  it("8 vendors are declared", () => {
+  it("9 vendors are declared (Phase 10.2 +doubao scaffold)", () => {
     expect(SUPPORTED_VENDORS).toEqual([
       "deepseek",
       "kimi",
@@ -31,6 +31,7 @@ describe("assertVendorSpec — SUPPORTED_VENDORS", () => {
       "qianfan",
       "coze",
       "dreamina",
+      "doubao",
     ]);
   });
 
@@ -184,9 +185,9 @@ describe("AIChatHistoryAdapter.sync — skeleton path", () => {
     const out = [];
     for await (const ev of a.sync({ vendors: ["deepseek"] })) out.push(ev);
     expect(out.length).toBe(1);
-    expect(out[0].kind).toBe("vendor-not-wired");
-    expect(out[0].vendor).toBe("deepseek");
-    expect(out[0].error).toBe("VENDOR_NOT_WIRED");
+    expect(out[0].payload.kind).toBe("vendor-not-wired");
+    expect(out[0].payload.vendor).toBe("deepseek");
+    expect(out[0].payload.error).toBe("VENDOR_NOT_WIRED");
   });
 
   it("can be driven end-to-end with a mock vendor spec", async () => {
@@ -237,9 +238,9 @@ describe("AIChatHistoryAdapter.sync — skeleton path", () => {
     const out = [];
     for await (const ev of a.sync({ vendors: ["deepseek"] })) out.push(ev);
     expect(out.length).toBe(3); // 1 conv + 2 msgs
-    expect(out[0].kind).toBe("conversation");
-    expect(out[1].kind).toBe("message");
-    expect(out[2].kind).toBe("message");
+    expect(out[0].payload.kind).toBe("conversation");
+    expect(out[1].payload.kind).toBe("message");
+    expect(out[2].payload.kind).toBe("message");
 
     // Drive normalize() over each
     const batches = out.map((r) => a.normalize(r));