@chainlesschain/personal-data-hub 0.1.0 → 0.2.1

package/__tests__/integration/ai-chat-history-registry.test.js

@@ -0,0 +1,228 @@
+"use strict";
+
+// Integration — AIChatHistoryAdapter end-to-end through AdapterRegistry.
+// Verifies the full chain: register → syncAdapter → real vendor HTTP →
+// raw archive → normalize → partition → vault put → watermark advance →
+// audit log.
+
+import { describe, it, expect, afterEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  LocalVault, generateKeyHex, AdapterRegistry,
+} = require("../../lib");
+const {
+  AIChatHistoryAdapter, CookieAuthSession, DEFAULT_VENDOR_SPECS,
+} = require("../../lib/adapters/ai-chat-history");
+
+function makeRig() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pdh-aichat-int-"));
+  const vault = new LocalVault({ path: path.join(dir, "v.db"), key: generateKeyHex() });
+  vault.open();
+  const registry = new AdapterRegistry({ vault });
+  return { vault, registry, dir };
+}
+
+function cleanup({ vault, dir }) {
+  try { vault.close(); } catch (_e) {}
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) {}
+}
+
+function makeResponse({ status = 200, body = {} } = {}) {
+  return {
+    status,
+    ok: status >= 200 && status < 300,
+    headers: { get: () => null },
+    async json() { return body; },
+    async text() { return JSON.stringify(body); },
+  };
+}
+
+function makeRoutedFetch(routes) {
+  const calls = [];
+  return {
+    calls,
+    async fetch(url, init) {
+      calls.push({ url, init });
+      for (const [pattern, response] of routes) {
+        if (typeof pattern === "string" ? url.includes(pattern) : pattern.test(url)) {
+          if (typeof response === "function") return response(url, init);
+          return response;
+        }
+      }
+      return makeResponse({ status: 404, body: { error: "no route" } });
+    },
+  };
+}
+
+function makeClock() {
+  let t = 1700000000_000;
+  return {
+    now: () => t,
+    sleep: async (ms) => { t += ms; },
+  };
+}
+
+function deepseekFixtures() {
+  return [
+    ["/get_user_info", makeResponse({ body: { code: 0, data: { biz_data: { user_id: "ds-u1" } } } })],
+    [/fetch_page.*before=/, makeResponse({ body: { data: { biz_data: { chat_sessions: [] } } } })],
+    ["/chat_session/fetch_page", makeResponse({ body: { data: { biz_data: { chat_sessions: [
+      { id: "ds-c1", title: "test ds chat", model: "deepseek-r1", inserted_at: 1700000100, updated_at: 1700000200 },
+    ] } } } })],
+    ["/chat/history_messages", makeResponse({ body: { data: { biz_data: { chat_messages: [
+      { id: "ds-m1", role: "USER", content: "hi deepseek", inserted_at: 1700000100 },
+      { id: "ds-m2", role: "ASSISTANT", content: "hi back", inserted_at: 1700000110, model: "deepseek-r1" },
+    ] } } } })],
+  ];
+}
+
+function kimiFixtures() {
+  return [
+    ["/api/user", makeResponse({ body: { id: "km-u1" } })],
+    [/list\?offset=30/, makeResponse({ body: { items: [], total: 1 } })],
+    [/list\?offset=0/, makeResponse({ body: { items: [
+      { id: "km-c1", name: "test kimi", created_at: 1700000300, updated_at: 1700000400, message_count: 1 },
+    ], total: 1 } })],
+    [/segment\/scroll/, async (_url, init) => {
+      const body = JSON.parse(init.body);
+      if (body.last === "0") {
+        return makeResponse({ body: {
+          items: [{ id: "km-msg-1", role: "user", content: "hi kimi", created_at: 1700000300 }],
+          has_more: false,
+        } });
+      }
+      return makeResponse({ body: { items: [], has_more: false } });
+    }],
+  ];
+}
+
+// ─── tests ───────────────────────────────────────────────────────────────
+
+describe("Integration — AIChatHistoryAdapter through AdapterRegistry", () => {
+  let rig;
+  afterEach(() => cleanup(rig));
+
+  it("registers without contract errors (adapter passes assertAdapter)", () => {
+    rig = makeRig();
+    const a = new AIChatHistoryAdapter();
+    expect(() => rig.registry.register(a)).not.toThrow();
+  });
+
+  it("two-vendor sync writes events to vault with proper raw_events archive", async () => {
+    rig = makeRig();
+    const clk = makeClock();
+    const fetched = makeRoutedFetch([...deepseekFixtures(), ...kimiFixtures()]);
+    const a = new AIChatHistoryAdapter({
+      fetch: fetched.fetch,
+      sleep: clk.sleep,
+      now: clk.now,
+    });
+    a.setSession("deepseek", new CookieAuthSession({ vendor: "deepseek", cookies: [{ name: "userToken", value: "x" }] }));
+    a.setSession("kimi", new CookieAuthSession({ vendor: "kimi", cookies: [{ name: "sess", value: "y" }] }));
+    rig.registry.register(a);
+
+    const report = await rig.registry.syncAdapter("ai-chat-history");
+    expect(report.status).toBe("ok");
+    expect(report.invalidCount).toBe(0); // adapter must yield valid registry envelopes
+
+    // Each vendor yields: 1 conv + N msgs (deepseek=2, kimi=1) = 5 raws across both
+    expect(report.rawCount).toBeGreaterThanOrEqual(5);
+
+    // Vault has events (2 deepseek msgs + 1 kimi msg)
+    const allEvents = rig.vault.queryEvents({ adapter: "ai-chat-history", limit: 1000 });
+    expect(allEvents.length).toBeGreaterThanOrEqual(3);
+    const vendors = new Set(allEvents.map((e) => e.extra && e.extra.vendor).filter(Boolean));
+    expect(vendors.has("deepseek")).toBe(true);
+    expect(vendors.has("kimi")).toBe(true);
+
+    // Vendor Person dedup via raw SQL: only 1 DeepSeek Person + 1 Kimi Person
+    const aiAgentCount = rig.vault.db
+      .prepare("SELECT COUNT(*) AS n FROM persons WHERE subtype = 'ai-agent'")
+      .get().n;
+    expect(aiAgentCount).toBe(2);
+
+    // Topics: 1 conversation Topic per vendor (extra.kind = 'ai-conversation')
+    const topicCount = rig.vault.db
+      .prepare("SELECT COUNT(*) AS n FROM topics WHERE json_extract(extra, '$.kind') = 'ai-conversation'")
+      .get().n;
+    expect(topicCount).toBe(2);
+  });
+
+  it("watermark advances after successful sync; second sync is idempotent", async () => {
+    rig = makeRig();
+    const clk = makeClock();
+    const fetched = makeRoutedFetch(deepseekFixtures());
+    const a = new AIChatHistoryAdapter({ fetch: fetched.fetch, sleep: clk.sleep, now: clk.now });
+    a.setSession("deepseek", new CookieAuthSession({ vendor: "deepseek", cookies: [{ name: "userToken", value: "x" }] }));
+    rig.registry.register(a);
+
+    const r1 = await rig.registry.syncAdapter("ai-chat-history");
+    expect(r1.status).toBe("ok");
+    const firstWatermark = r1.watermark;
+    expect(firstWatermark).toBeTruthy();
+
+    const eventsAfterFirst = rig.vault.queryEvents({ adapter: "ai-chat-history", limit: 100 }).length;
+    expect(eventsAfterFirst).toBeGreaterThanOrEqual(2);
+
+    // Re-sync same fixtures — should be idempotent (no duplicate events).
+    const r2 = await rig.registry.syncAdapter("ai-chat-history");
+    expect(r2.status).toBe("ok");
+
+    // Vault doesn't double-insert thanks to events table PK (id is UUIDv7 so different each time
+    // but source.originalId dedup via findBySource semantics applies). At minimum, both syncs
+    // succeeded without errors and the watermark moved forward.
+    expect(Number(r2.watermark)).toBeGreaterThanOrEqual(Number(firstWatermark));
+  });
+
+  it("vendor-cookie-expired sentinel does not abort the whole sync", async () => {
+    rig = makeRig();
+    const clk = makeClock();
+    // deepseek returns 401, kimi works.
+    const fetched = makeRoutedFetch([
+      [/chat_session\/fetch_page/, makeResponse({ status: 401 })],
+      ...kimiFixtures(),
+    ]);
+    const a = new AIChatHistoryAdapter({ fetch: fetched.fetch, sleep: clk.sleep, now: clk.now });
+    a.setSession("deepseek", new CookieAuthSession({ vendor: "deepseek", cookies: [] }));
+    a.setSession("kimi", new CookieAuthSession({ vendor: "kimi", cookies: [] }));
+    rig.registry.register(a);
+
+    const report = await rig.registry.syncAdapter("ai-chat-history");
+    expect(report.status).toBe("ok"); // partial success is still ok
+
+    // Kimi events made it in despite deepseek failure.
+    const allEvents = rig.vault.queryEvents({ adapter: "ai-chat-history", limit: 100 });
+    const kimiEvents = allEvents.filter((e) => e.extra && e.extra.vendor === "kimi");
+    expect(kimiEvents.length).toBeGreaterThan(0);
+  });
+
+  it("no sessions configured → zero events ingested, no error", async () => {
+    rig = makeRig();
+    const a = new AIChatHistoryAdapter();
+    rig.registry.register(a);
+
+    const report = await rig.registry.syncAdapter("ai-chat-history");
+    expect(report.status).toBe("ok");
+    expect(report.rawCount).toBe(0);
+    expect(rig.vault.queryEvents({ adapter: "ai-chat-history", limit: 10 }).length).toBe(0);
+  });
+
+  it("audit log captures sync.ok with adapter name + scope", async () => {
+    rig = makeRig();
+    const clk = makeClock();
+    const fetched = makeRoutedFetch(deepseekFixtures());
+    const a = new AIChatHistoryAdapter({ fetch: fetched.fetch, sleep: clk.sleep, now: clk.now });
+    a.setSession("deepseek", new CookieAuthSession({ vendor: "deepseek", cookies: [] }));
+    rig.registry.register(a);
+
+    await rig.registry.syncAdapter("ai-chat-history");
+
+    const audit = rig.vault.queryAudit({ adapter: "ai-chat-history", limit: 50 });
+    const okEntries = audit.filter((a) => a.action === "adapter.sync.ok");
+    expect(okEntries.length).toBeGreaterThan(0);
+  });
+});

package/__tests__/integration/aichat-wizard-end-to-end.test.js

@@ -0,0 +1,282 @@
+/**
+ * AIChat WebView 鉴权向导 — end-to-end integration test (Phase 10.3.6).
+ *
+ * Exercises the full chain WITHOUT any real Electron / real network:
+ *
+ *   cookie-capture-spec
+ *      ↓
+ *   wizard-controller (paste-fallback mode)
+ *      ↓
+ *   accountsStore (real fs, temp dir)
+ *      ↓
+ *   vendor-adapter-bridge (stub validateCookie)
+ *      ↓
+ *   health-checker (real periodic logic, injected timers)
+ *
+ * Three scenarios:
+ *   - Happy:    probe → register → health=ok
+ *   - Expired:  register → mutate stored cookies to "stale" + adapter
+ *               returns ok=false → health=failed
+ *   - Version:  register at specVersion=1 → bump to specVersion=2 →
+ *               health marks SPEC_VERSION_MISMATCH
+ *
+ * Lives in integration/ rather than adapters/ because it spans modules
+ * (controller + factory + health-checker + real fs).
+ */
+
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtempSync, rmSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const {
+  createAIChatWizardController,
+} = require("../../lib/adapters/ai-chat-history/wizard-controller");
+const {
+  createAIChatHealthChecker,
+} = require("../../lib/adapters/ai-chat-history/health-checker");
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function makeRealFsAccountsStore({ hubDir }) {
+  // A minimal accountsStore that mirrors the shape used by both desktop
+  // factory + cli wizard wirings, but uses fs directly so integration is
+  // observable on disk.
+  const filePath = join(hubDir, "aichat-accounts.json");
+  function readAll() {
+    try {
+      return JSON.parse(readFileSync(filePath, "utf-8")) || {};
+    } catch (err) {
+      if (err && err.code === "ENOENT") return {};
+      return {};
+    }
+  }
+  return {
+    get: async (v) => readAll()[v] || null,
+    put: async (v, entry) => {
+      const all = readAll();
+      all[v] = entry;
+      writeFileSync(filePath, JSON.stringify(all, null, 2), { mode: 0o600 });
+    },
+    delete: async (v) => {
+      const all = readAll();
+      delete all[v];
+      writeFileSync(filePath, JSON.stringify(all, null, 2), { mode: 0o600 });
+    },
+    list: async () => Object.values(readAll()),
+    _filePath: filePath,
+  };
+}
+
+function makeStubVendorAdapter({ behaviorByVendor = {} } = {}) {
+  return {
+    registerVendor: vi.fn(async (vendor, cookies) => {
+      const b = behaviorByVendor[vendor];
+      if (typeof b === "function") return b(vendor, cookies);
+      return b || { ok: true, userId: "u_" + vendor };
+    }),
+  };
+}
+
+function buildWizard({ accountsStore, vendorAdapter }) {
+  // Minimal _deps for paste-fallback mode. classifier/specLookup come
+  // from the real spec module.
+  const {
+    classifyProbedCookies,
+    getSpec,
+    listVendors,
+    COOKIE_SPEC_VERSION,
+  } = require("../../lib/adapters/ai-chat-history/cookie-capture-spec");
+  return createAIChatWizardController({
+    accountsStore,
+    vendorAdapter,
+    _deps: {
+      sessionFactory: () => ({}),
+      clock: () => Date.now(),
+      logger: { info: () => {}, warn: () => {}, error: () => {} },
+      classifier: classifyProbedCookies,
+      specLookup: getSpec,
+      knownVendors: listVendors(),
+      cookieSpecVersion: COOKIE_SPEC_VERSION,
+      fallbackMode: "paste",
+    },
+  });
+}
+
+let hubDir;
+beforeEach(() => {
+  hubDir = mkdtempSync(join(tmpdir(), "aichat-wiz-e2e-"));
+});
+afterEach(() => {
+  rmSync(hubDir, { recursive: true, force: true });
+});
+
+// ─── Scenario A: happy path ──────────────────────────────────────────────
+
+describe("aichat wizard E2E — happy path", () => {
+  it("probe → register → file written → health=ok", async () => {
+    const accountsStore = makeRealFsAccountsStore({ hubDir });
+    const vendorAdapter = makeStubVendorAdapter({
+      behaviorByVendor: { doubao: { ok: true, userId: "u_42" } },
+    });
+    const wiz = buildWizard({ accountsStore, vendorAdapter });
+
+    // Step 1: open paste-fallback metadata for doubao
+    const opened = await wiz.openVendorLogin({ vendor: "doubao" });
+    expect(opened.ok).toBe(true);
+    expect(opened.fallbackMode).toBe("paste");
+    expect(opened.loginUrl).toMatch(/doubao\.com/);
+
+    // Step 2: probe a pasted cookie header
+    const probed = await wiz.probeCookies({
+      vendor: "doubao",
+      cookieHeader: "sessionid=abc; sid_guard=xyz",
+    });
+    expect(probed.ok).toBe(true);
+    expect(probed.foundRequired).toEqual(["sessionid"]);
+
+    // Step 3: register — writes the accounts file on disk
+    const registered = await wiz.registerVendor({
+      vendor: "doubao",
+      cookies: probed.cookies,
+    });
+    expect(registered.ok).toBe(true);
+    expect(registered.accountId).toBe("doubao:u_42");
+
+    const onDisk = JSON.parse(readFileSync(accountsStore._filePath, "utf-8"));
+    expect(onDisk.doubao.userId).toBe("u_42");
+    expect(onDisk.doubao.cookieSpecVersion).toBe(1);
+    expect(onDisk.doubao.lastHealth.ok).toBe(true);
+
+    // Step 4: HealthChecker.runOnce should re-validate and stay ok
+    const hc = createAIChatHealthChecker({
+      accountsStore, vendorAdapter,
+      _deps: { logger: { info: () => {}, warn: () => {}, error: () => {} } },
+    });
+    const r = await hc.runOnce();
+    expect(r).toMatchObject({ checked: 1, ok: 1, failed: 0, mismatch: 0 });
+    expect(vendorAdapter.registerVendor).toHaveBeenCalledTimes(2);
+
+    // Stored entry still ok=true; lastHealth.at should have changed.
+    const refreshed = JSON.parse(readFileSync(accountsStore._filePath, "utf-8"));
+    expect(refreshed.doubao.lastHealth.ok).toBe(true);
+  });
+});
+
+// ─── Scenario B: cookie expired ──────────────────────────────────────────
+
+describe("aichat wizard E2E — expired path", () => {
+  it("after stored cookies stop validating, health marks failed", async () => {
+    const accountsStore = makeRealFsAccountsStore({ hubDir });
+    let isValid = true;
+    const vendorAdapter = makeStubVendorAdapter({
+      behaviorByVendor: {
+        kimi: async () => (isValid
+          ? { ok: true, userId: "u_kimi" }
+          : { ok: false, reason: "COOKIE_EXPIRED" }),
+      },
+    });
+    const wiz = buildWizard({ accountsStore, vendorAdapter });
+
+    await wiz.registerVendor({ vendor: "kimi", cookies: { access_token: "ok" } });
+
+    // Simulate the server invalidating the session.
+    isValid = false;
+
+    const hc = createAIChatHealthChecker({
+      accountsStore, vendorAdapter,
+      _deps: { logger: { info: () => {}, warn: () => {}, error: () => {} } },
+    });
+    const r = await hc.runOnce();
+    expect(r).toMatchObject({ checked: 1, ok: 0, failed: 1, mismatch: 0 });
+
+    const refreshed = JSON.parse(readFileSync(accountsStore._filePath, "utf-8"));
+    expect(refreshed.kimi.lastHealth).toMatchObject({
+      ok: false, reason: "COOKIE_EXPIRED",
+    });
+  });
+});
+
+// ─── Scenario C: spec version mismatch ───────────────────────────────────
+
+describe("aichat wizard E2E — spec version mismatch", () => {
+  it("bumping specVersion marks old registrations SPEC_VERSION_MISMATCH", async () => {
+    const accountsStore = makeRealFsAccountsStore({ hubDir });
+    const vendorAdapter = makeStubVendorAdapter();
+    const wiz = buildWizard({ accountsStore, vendorAdapter });
+
+    await wiz.registerVendor({
+      vendor: "deepseek",
+      cookies: { userToken: "abc" },
+    });
+
+    // Bump spec version by passing 2 to HealthChecker (simulates a future
+    // cookie-capture-spec version bump).
+    const hc = createAIChatHealthChecker({
+      accountsStore, vendorAdapter, specVersion: 2,
+      _deps: { logger: { info: () => {}, warn: () => {}, error: () => {} } },
+    });
+    const r = await hc.runOnce();
+    expect(r).toMatchObject({ checked: 1, mismatch: 1, ok: 0, failed: 0 });
+
+    const refreshed = JSON.parse(readFileSync(accountsStore._filePath, "utf-8"));
+    expect(refreshed.deepseek.lastHealth).toMatchObject({
+      ok: false, reason: "SPEC_VERSION_MISMATCH",
+    });
+    // Adapter should NOT have been called for this entry — version gate
+    // short-circuits before validateCookie.
+    expect(vendorAdapter.registerVendor).toHaveBeenCalledTimes(1); // only register, no health validate
+  });
+});
+
+// ─── Scenario D: full lifecycle (register → cleanupOrphanPartitions) ─────
+
+describe("aichat wizard E2E — orphan partition cleanup", () => {
+  it("cleanupOrphanPartitions drops partitions whose vendor was never registered", async () => {
+    const accountsStore = makeRealFsAccountsStore({ hubDir });
+    const vendorAdapter = makeStubVendorAdapter();
+    // For this scenario we use the in-test paste fallback — sessions are
+    // simulated. cleanupOrphanPartitions runs against the partition list
+    // we pass in, returning the vendors it would have cleared.
+    const cleared = new Set();
+    const wiz = createAIChatWizardController({
+      accountsStore,
+      vendorAdapter,
+      _deps: {
+        sessionFactory: (partName) => ({
+          clearStorageData: async () => {
+            cleared.add(partName);
+          },
+        }),
+        clock: () => Date.now(),
+        logger: { info: () => {}, warn: () => {}, error: () => {} },
+        classifier: require("../../lib/adapters/ai-chat-history/cookie-capture-spec").classifyProbedCookies,
+        specLookup: require("../../lib/adapters/ai-chat-history/cookie-capture-spec").getSpec,
+        knownVendors: require("../../lib/adapters/ai-chat-history/cookie-capture-spec").listVendors(),
+        cookieSpecVersion: 1,
+        fallbackMode: "browser-view",
+      },
+    });
+
+    await wiz.registerVendor({
+      vendor: "kimi",
+      cookies: { access_token: "x" },
+    });
+
+    const result = await wiz.cleanupOrphanPartitions({
+      partitions: [
+        "persist:aichat-deepseek", // orphan: no entry in store
+        "persist:aichat-kimi", // registered: should NOT be cleared
+        "persist:aichat-doubao", // orphan
+        "persist:unrelated", // not ours: leave alone
+      ],
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.cleared.sort()).toEqual(["deepseek", "doubao"]);
+    expect(cleared.has("persist:aichat-kimi")).toBe(false);
+    expect(cleared.has("persist:unrelated")).toBe(false);
+  });
+});