@blackbelt-technology/pi-agent-dashboard 0.5.1 → 0.5.2

package/packages/server/src/__tests__/openspec-group-store.test.ts

@@ -0,0 +1,496 @@
+/**
+ * Tests for the OpenSpec change-grouping store.
+ *
+ * Covers tasks 2.15–2.17 + spec scenarios from
+ * `openspec/changes/add-openspec-change-grouping/specs/openspec-change-grouping/spec.md`.
+ *
+ * See change: add-openspec-change-grouping.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import {
+  createOpenSpecGroupStore,
+  ConcurrentEditError,
+  UnsupportedSchemaVersionError,
+  GroupNotFoundError,
+  UnknownGroupIdError,
+  type OpenSpecGroupStore,
+} from "../openspec-group-store.js";
+import { OPENSPEC_GROUPS_SCHEMA_VERSION } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+describe("openspec-group-store", () => {
+  let tmpDir: string;
+  let cwd: string;
+  let groupsFile: string;
+  let store: OpenSpecGroupStore;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "ogs-"));
+    cwd = tmpDir;
+    groupsFile = path.join(cwd, "openspec", "groups", "groups.json");
+    store = createOpenSpecGroupStore();
+  });
+
+  afterEach(async () => {
+    store.dispose();
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  // ── Read path ────────────────────────────────────────────────
+
+  describe("read()", () => {
+    it("returns the default-empty payload when the file is absent and does NOT create the directory", async () => {
+      const data = await store.read(cwd);
+      expect(data).toEqual({ schemaVersion: 1, groups: [], assignments: {} });
+
+      const dirExists = await fs.stat(path.join(cwd, "openspec", "groups")).then(
+        () => true,
+        () => false,
+      );
+      expect(dirExists).toBe(false);
+    });
+
+    it("returns parsed contents verbatim when file present", async () => {
+      await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+      await fs.writeFile(
+        groupsFile,
+        JSON.stringify({
+          schemaVersion: 1,
+          groups: [{ id: "ui", name: "UI", color: "#3b82f6", order: 0 }],
+          assignments: { "add-foo": "ui" },
+        }),
+      );
+      const data = await store.read(cwd);
+      expect(data.groups).toEqual([{ id: "ui", name: "UI", color: "#3b82f6", order: 0 }]);
+      expect(data.assignments).toEqual({ "add-foo": "ui" });
+    });
+
+    it("returns cached data on unchanged (mtime, size) without calling readFile", async () => {
+      await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+      await fs.writeFile(
+        groupsFile,
+        JSON.stringify({ schemaVersion: 1, groups: [], assignments: {} }),
+      );
+      // Prime the cache.
+      await store.read(cwd);
+      const readSpy = vi.spyOn(fs, "readFile");
+      // Second read should be a cache hit — no readFile.
+      await store.read(cwd);
+      await store.read(cwd);
+      expect(readSpy).not.toHaveBeenCalled();
+      readSpy.mockRestore();
+    });
+
+    it("re-reads when mtime changes", async () => {
+      await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+      await fs.writeFile(
+        groupsFile,
+        JSON.stringify({ schemaVersion: 1, groups: [], assignments: {} }),
+      );
+      const first = await store.read(cwd);
+      expect(first.groups).toHaveLength(0);
+      // Bump mtime and content.
+      await new Promise((r) => setTimeout(r, 10));
+      const future = new Date(Date.now() + 60_000);
+      await fs.writeFile(
+        groupsFile,
+        JSON.stringify({
+          schemaVersion: 1,
+          groups: [{ id: "ui", name: "UI", order: 0 }],
+          assignments: {},
+        }),
+      );
+      await fs.utimes(groupsFile, future, future);
+      const second = await store.read(cwd);
+      expect(second.groups).toHaveLength(1);
+      expect(second.groups[0]?.id).toBe("ui");
+    });
+
+    it("detects within-same-second writes via size delta", async () => {
+      await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+      const base = { schemaVersion: 1, groups: [], assignments: {} };
+      await fs.writeFile(groupsFile, JSON.stringify(base));
+      const stat1 = await fs.stat(groupsFile);
+      await store.read(cwd);
+      // Write with same mtime but larger size.
+      const bigger = {
+        schemaVersion: 1,
+        groups: [{ id: "ui", name: "UI", order: 0 }],
+        assignments: {},
+      };
+      await fs.writeFile(groupsFile, JSON.stringify(bigger));
+      await fs.utimes(groupsFile, stat1.atime, stat1.mtime); // force same mtime
+      const data = await store.read(cwd);
+      expect(data.groups).toHaveLength(1);
+    });
+
+    it("clears the cache and returns default when the file is deleted", async () => {
+      await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+      await fs.writeFile(
+        groupsFile,
+        JSON.stringify({
+          schemaVersion: 1,
+          groups: [{ id: "ui", name: "UI", order: 0 }],
+          assignments: {},
+        }),
+      );
+      const first = await store.read(cwd);
+      expect(first.groups).toHaveLength(1);
+      await fs.rm(groupsFile);
+      const second = await store.read(cwd);
+      expect(second).toEqual({ schemaVersion: 1, groups: [], assignments: {} });
+    });
+
+    it("shares one readFile call across concurrent reads in the same tick", async () => {
+      await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+      await fs.writeFile(
+        groupsFile,
+        JSON.stringify({ schemaVersion: 1, groups: [], assignments: {} }),
+      );
+      const readSpy = vi.spyOn(fs, "readFile");
+      const reads = await Promise.all([store.read(cwd), store.read(cwd), store.read(cwd), store.read(cwd), store.read(cwd)]);
+      expect(reads.every((r) => r.schemaVersion === 1)).toBe(true);
+      // First batch: 1 readFile call shared across 5 reads.
+      expect(readSpy).toHaveBeenCalledTimes(1);
+      readSpy.mockRestore();
+    });
+
+    it("rejects unknown schemaVersion with UnsupportedSchemaVersionError", async () => {
+      await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+      await fs.writeFile(groupsFile, JSON.stringify({ schemaVersion: 2, groups: [], assignments: {} }));
+      await expect(store.read(cwd)).rejects.toBeInstanceOf(UnsupportedSchemaVersionError);
+    });
+
+    it("rejects missing schemaVersion field with UnsupportedSchemaVersionError", async () => {
+      await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+      await fs.writeFile(groupsFile, JSON.stringify({ groups: [], assignments: {} }));
+      await expect(store.read(cwd)).rejects.toBeInstanceOf(UnsupportedSchemaVersionError);
+    });
+  });
+
+  // ── createGroup ──────────────────────────────────────────────
+
+  describe("createGroup()", () => {
+    it("creates the file + directory on first write", async () => {
+      const g = await store.createGroup(cwd, { name: "UI", color: "#3b82f6" });
+      expect(g.id).toBe("ui");
+      expect(g.name).toBe("UI");
+      expect(g.order).toBe(0);
+      const raw = await fs.readFile(groupsFile, "utf-8");
+      const parsed = JSON.parse(raw);
+      expect(parsed.schemaVersion).toBe(OPENSPEC_GROUPS_SCHEMA_VERSION);
+      expect(parsed.groups).toHaveLength(1);
+      expect(parsed.assignments).toEqual({});
+    });
+
+    it("appends collision suffix when slug already exists", async () => {
+      await store.createGroup(cwd, { name: "UI" });
+      const second = await store.createGroup(cwd, { name: "UI" });
+      expect(second.id).toBe("ui-2");
+      const third = await store.createGroup(cwd, { name: "UI" });
+      expect(third.id).toBe("ui-3");
+    });
+
+    it("auto-assigns order = groups.length", async () => {
+      const a = await store.createGroup(cwd, { name: "UI" });
+      const b = await store.createGroup(cwd, { name: "Server" });
+      expect(a.order).toBe(0);
+      expect(b.order).toBe(1);
+    });
+
+    it("serializes concurrent creates for the same cwd via FIFO mutex", async () => {
+      const [a, b, c] = await Promise.all([
+        store.createGroup(cwd, { name: "A" }),
+        store.createGroup(cwd, { name: "B" }),
+        store.createGroup(cwd, { name: "C" }),
+      ]);
+      const data = await store.read(cwd);
+      expect(data.groups).toHaveLength(3);
+      const ids = new Set(data.groups.map((g) => g.id));
+      expect(ids.has(a.id)).toBe(true);
+      expect(ids.has(b.id)).toBe(true);
+      expect(ids.has(c.id)).toBe(true);
+      // Orders are contiguous 0..2.
+      const orders = data.groups.map((g) => g.order).sort();
+      expect(orders).toEqual([0, 1, 2]);
+    });
+  });
+
+  // ── updateGroup ──────────────────────────────────────────────
+
+  describe("updateGroup()", () => {
+    it("renames without changing id", async () => {
+      const g = await store.createGroup(cwd, { name: "UI" });
+      const updated = await store.updateGroup(cwd, g.id, { name: "Frontend" });
+      expect(updated.id).toBe("ui");
+      expect(updated.name).toBe("Frontend");
+    });
+
+    it("throws GroupNotFoundError on unknown id", async () => {
+      await expect(store.updateGroup(cwd, "does-not-exist", { name: "X" })).rejects.toBeInstanceOf(
+        GroupNotFoundError,
+      );
+    });
+
+    it("normalizes order to contiguous 0..N-1 after a reorder", async () => {
+      const a = await store.createGroup(cwd, { name: "A" }); // order 0
+      const b = await store.createGroup(cwd, { name: "B" }); // order 1
+      const c = await store.createGroup(cwd, { name: "C" }); // order 2
+      // Move A to the end.
+      await store.updateGroup(cwd, a.id, { order: 5 });
+      const data = await store.read(cwd);
+      const byId = new Map(data.groups.map((g) => [g.id, g.order]));
+      const orders = [...byId.values()].sort();
+      expect(orders).toEqual([0, 1, 2]);
+      // A should be last (highest order).
+      expect(byId.get(a.id)).toBe(2);
+      expect(byId.get(b.id)).toBe(0);
+      expect(byId.get(c.id)).toBe(1);
+    });
+  });
+
+  // ── deleteGroup ──────────────────────────────────────────────
+
+  describe("deleteGroup()", () => {
+    it("removes the group", async () => {
+      const g = await store.createGroup(cwd, { name: "UI" });
+      await store.deleteGroup(cwd, g.id);
+      const data = await store.read(cwd);
+      expect(data.groups).toHaveLength(0);
+    });
+
+    it("cascades through assignments referencing the deleted group", async () => {
+      const g = await store.createGroup(cwd, { name: "UI" });
+      const other = await store.createGroup(cwd, { name: "Server" });
+      await store.setAssignment(cwd, "add-foo", g.id);
+      await store.setAssignment(cwd, "fix-bar", other.id);
+      await store.deleteGroup(cwd, g.id);
+      const data = await store.read(cwd);
+      expect(data.assignments).toEqual({ "fix-bar": other.id });
+    });
+
+    it("throws GroupNotFoundError on unknown id", async () => {
+      await expect(store.deleteGroup(cwd, "does-not-exist")).rejects.toBeInstanceOf(GroupNotFoundError);
+    });
+
+    it("re-packs orders contiguously after delete", async () => {
+      const a = await store.createGroup(cwd, { name: "A" });
+      const b = await store.createGroup(cwd, { name: "B" });
+      const c = await store.createGroup(cwd, { name: "C" });
+      await store.deleteGroup(cwd, b.id);
+      const data = await store.read(cwd);
+      const byId = new Map(data.groups.map((g) => [g.id, g.order]));
+      // Surviving orders should be contiguous 0..1.
+      const orders = [...byId.values()].sort();
+      expect(orders).toEqual([0, 1]);
+      expect(byId.get(a.id)).toBe(0);
+      expect(byId.get(c.id)).toBe(1);
+    });
+  });
+
+  // ── setAssignment ────────────────────────────────────────────
+
+  describe("setAssignment()", () => {
+    it("adds a single map entry", async () => {
+      const g = await store.createGroup(cwd, { name: "UI" });
+      await store.setAssignment(cwd, "add-foo", g.id);
+      const data = await store.read(cwd);
+      expect(data.assignments).toEqual({ "add-foo": g.id });
+    });
+
+    it("replaces previous group on reassignment", async () => {
+      const g1 = await store.createGroup(cwd, { name: "UI" });
+      const g2 = await store.createGroup(cwd, { name: "Server" });
+      await store.setAssignment(cwd, "add-foo", g1.id);
+      await store.setAssignment(cwd, "add-foo", g2.id);
+      const data = await store.read(cwd);
+      expect(data.assignments).toEqual({ "add-foo": g2.id });
+    });
+
+    it("removes the entry on null", async () => {
+      const g = await store.createGroup(cwd, { name: "UI" });
+      await store.setAssignment(cwd, "add-foo", g.id);
+      await store.setAssignment(cwd, "add-foo", null);
+      const data = await store.read(cwd);
+      expect(data.assignments).toEqual({});
+    });
+
+    it("throws UnknownGroupIdError on unknown groupId", async () => {
+      await expect(store.setAssignment(cwd, "add-foo", "does-not-exist")).rejects.toBeInstanceOf(
+        UnknownGroupIdError,
+      );
+    });
+
+    it("tolerates unknown changeName", async () => {
+      const g = await store.createGroup(cwd, { name: "UI" });
+      await store.setAssignment(cwd, "never-existed", g.id);
+      const data = await store.read(cwd);
+      expect(data.assignments).toEqual({ "never-existed": g.id });
+    });
+  });
+
+  // ── Concurrency: FIFO mutex + cwd isolation ──────────────────
+
+  describe("concurrency", () => {
+    it("two concurrent writes to the same cwd produce both results (no lost write)", async () => {
+      // Both should serialize and both succeed.
+      const [a, b] = await Promise.all([
+        store.createGroup(cwd, { name: "A" }),
+        store.createGroup(cwd, { name: "B" }),
+      ]);
+      const data = await store.read(cwd);
+      const ids = new Set(data.groups.map((g) => g.id));
+      expect(ids.has(a.id)).toBe(true);
+      expect(ids.has(b.id)).toBe(true);
+    });
+
+    it("concurrent writes to different cwds proceed in parallel", async () => {
+      const tmpDir2 = await fs.mkdtemp(path.join(os.tmpdir(), "ogs2-"));
+      try {
+        const [a, b] = await Promise.all([
+          store.createGroup(cwd, { name: "A" }),
+          store.createGroup(tmpDir2, { name: "B" }),
+        ]);
+        expect(a.id).toBe("a");
+        expect(b.id).toBe("b");
+      } finally {
+        await fs.rm(tmpDir2, { recursive: true, force: true });
+      }
+    });
+  });
+
+  // ── 1-shot retry on hand-edit race ───────────────────────────
+
+  describe("hand-edit race detection", () => {
+    it("retries once and succeeds when the file is hand-edited between read and rename", async () => {
+      let triggered = false;
+      const racingStore = createOpenSpecGroupStore({
+        __testHookBeforeRename: async () => {
+          if (triggered) return;
+          triggered = true;
+          // Simulate a hand-edit: write a different version of the file.
+          await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+          const future = new Date(Date.now() + 60_000);
+          await fs.writeFile(
+            groupsFile,
+            JSON.stringify({
+              schemaVersion: 1,
+              groups: [{ id: "external", name: "External", order: 0 }],
+              assignments: {},
+            }),
+          );
+          await fs.utimes(groupsFile, future, future);
+        },
+      });
+      try {
+        const created = await racingStore.createGroup(cwd, { name: "UI" });
+        expect(created.name).toBe("UI");
+        // Final file should contain BOTH the external group and the dashboard one.
+        const data = await racingStore.read(cwd);
+        const ids = new Set(data.groups.map((g) => g.id));
+        expect(ids.has("external")).toBe(true);
+        expect(ids.has(created.id)).toBe(true);
+      } finally {
+        racingStore.dispose();
+      }
+    });
+
+    it("throws ConcurrentEditError after a sustained race (two strikes)", async () => {
+      let strikes = 0;
+      const racingStore = createOpenSpecGroupStore({
+        __testHookBeforeRename: async () => {
+          strikes++;
+          // Always race — simulate sustained external editor.
+          await fs.mkdir(path.dirname(groupsFile), { recursive: true });
+          const future = new Date(Date.now() + 60_000 * strikes);
+          await fs.writeFile(
+            groupsFile,
+            JSON.stringify({
+              schemaVersion: 1,
+              groups: [{ id: "external", name: `External-${strikes}`, order: 0 }],
+              assignments: {},
+            }),
+          );
+          await fs.utimes(groupsFile, future, future);
+        },
+      });
+      try {
+        await expect(racingStore.createGroup(cwd, { name: "UI" })).rejects.toBeInstanceOf(
+          ConcurrentEditError,
+        );
+        // Hook fires twice: once for the original write, once for the retry.
+        expect(strikes).toBe(2);
+      } finally {
+        racingStore.dispose();
+      }
+    });
+  });
+
+  // ── Subscribe / debounced broadcast ──────────────────────────
+
+  describe("subscribe() — debounced broadcast", () => {
+    it("emits a single broadcast for one write within the debounce window", async () => {
+      vi.useFakeTimers();
+      const fast = createOpenSpecGroupStore({ debounceMs: 100 });
+      const events: Array<{ cwd: string; payload: unknown }> = [];
+      fast.subscribe((cwd, payload) => events.push({ cwd, payload }));
+      try {
+        await fast.createGroup(cwd, { name: "UI" });
+        // Before the debounce window elapses, no broadcast yet.
+        expect(events).toHaveLength(0);
+        await vi.advanceTimersByTimeAsync(100);
+        expect(events).toHaveLength(1);
+        expect(events[0]?.cwd).toBe(cwd);
+      } finally {
+        vi.useRealTimers();
+        fast.dispose();
+      }
+    });
+
+    it("coalesces 5 writes within 100 ms into 1 broadcast", async () => {
+      vi.useFakeTimers();
+      const fast = createOpenSpecGroupStore({ debounceMs: 100 });
+      const events: Array<{ cwd: string; payload: { groups: Array<{ id: string }> } }> = [];
+      fast.subscribe((c, p) => events.push({ cwd: c, payload: p as any }));
+      try {
+        await fast.createGroup(cwd, { name: "A" });
+        await fast.createGroup(cwd, { name: "B" });
+        await fast.createGroup(cwd, { name: "C" });
+        await fast.createGroup(cwd, { name: "D" });
+        await fast.createGroup(cwd, { name: "E" });
+        // Still inside debounce window.
+        await vi.advanceTimersByTimeAsync(50);
+        expect(events).toHaveLength(0);
+        await vi.advanceTimersByTimeAsync(100);
+        expect(events).toHaveLength(1);
+        expect(events[0]?.payload.groups).toHaveLength(5);
+      } finally {
+        vi.useRealTimers();
+        fast.dispose();
+      }
+    });
+
+    it("does NOT coalesce broadcasts across different cwds", async () => {
+      const tmpDir2 = await fs.mkdtemp(path.join(os.tmpdir(), "ogs2-"));
+      vi.useFakeTimers();
+      const fast = createOpenSpecGroupStore({ debounceMs: 100 });
+      const events: Array<{ cwd: string }> = [];
+      fast.subscribe((c) => events.push({ cwd: c }));
+      try {
+        await fast.createGroup(cwd, { name: "A" });
+        await fast.createGroup(tmpDir2, { name: "B" });
+        await vi.advanceTimersByTimeAsync(100);
+        expect(events).toHaveLength(2);
+        const cwds = new Set(events.map((e) => e.cwd));
+        expect(cwds.has(cwd)).toBe(true);
+        expect(cwds.has(tmpDir2)).toBe(true);
+      } finally {
+        vi.useRealTimers();
+        fast.dispose();
+        await fs.rm(tmpDir2, { recursive: true, force: true });
+      }
+    });
+  });
+});

package/packages/server/src/__tests__/pi-ai-shape.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Precondition test: pi-ai symbol shape.
+ *
+ * Runtime-resolves pi-ai via the ToolRegistry and asserts every symbol
+ * the model-proxy change depends on exists in the resolved module.
+ *
+ * - `it.skip` when pi-ai cannot be resolved (clean CI without ~/.pi-dashboard/).
+ * - Full run when pi-ai is installed locally.
+ * - Set `MODEL_PROXY_REQUIRE_PI_AI=1` to force hard-fail (for release-cut runs).
+ *
+ * Run locally:
+ *   MODEL_PROXY_REQUIRE_PI_AI=1 npm test -- pi-ai-shape
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { getDefaultRegistry } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
+
+const REQUIRE = process.env.MODEL_PROXY_REQUIRE_PI_AI === "1";
+
+let piAi: Record<string, unknown> | null = null;
+let piAiOAuth: Record<string, unknown> | null = null;
+let resolveError: Error | null = null;
+
+beforeAll(async () => {
+  try {
+    const result = await getDefaultRegistry().resolveModule<Record<string, unknown>>("pi-ai");
+    piAi = result.module;
+
+    // Resolve oauth subpath — pi-ai exports it from dist/oauth.js
+    const resolution = result.resolution;
+    if (resolution.path) {
+      const oauthPath = resolution.path.replace(/\/dist\/index\.js$/, "/dist/oauth.js");
+      try {
+        const { pathToFileURL } = await import("node:url");
+        piAiOAuth = (await import(pathToFileURL(oauthPath).href)) as Record<string, unknown>;
+      } catch {
+        // OAuth subpath may not exist in all versions
+      }
+    }
+  } catch (err) {
+    resolveError = err as Error;
+    if (REQUIRE) {
+      throw new Error(
+        `MODEL_PROXY_REQUIRE_PI_AI=1 but pi-ai could not be resolved: ${(err as Error).message}`,
+      );
+    }
+  }
+});
+
+const skipOrRun = () => {
+  if (!piAi) return it.skip;
+  return it;
+};
+
+describe("pi-ai shape precondition", () => {
+  it("resolves pi-ai or skips gracefully", () => {
+    if (REQUIRE) {
+      expect(piAi).not.toBeNull();
+    } else if (!piAi) {
+      console.log(`pi-ai not resolved (${resolveError?.message}); skipping shape checks`);
+    }
+  });
+
+  // --- Main exports from pi-ai (dist/index.js) ---
+
+  describe("main exports", () => {
+    it("exports streamSimple", () => {
+      if (!piAi) return;
+      expect(typeof piAi.streamSimple).toBe("function");
+    });
+
+    it("exports getModels", () => {
+      if (!piAi) return;
+      expect(typeof piAi.getModels).toBe("function");
+    });
+
+    it("exports registerBuiltInApiProviders", () => {
+      if (!piAi) return;
+      expect(typeof piAi.registerBuiltInApiProviders).toBe("function");
+    });
+
+    it("exports getApiProvider", () => {
+      if (!piAi) return;
+      expect(typeof piAi.getApiProvider).toBe("function");
+    });
+
+    it("exports getProviders", () => {
+      if (!piAi) return;
+      expect(typeof piAi.getProviders).toBe("function");
+    });
+
+    it("exports registerApiProvider", () => {
+      if (!piAi) return;
+      expect(typeof piAi.registerApiProvider).toBe("function");
+    });
+
+    it("exports getModel", () => {
+      if (!piAi) return;
+      expect(typeof piAi.getModel).toBe("function");
+    });
+
+    it("exports registerFauxProvider (for testing)", () => {
+      if (!piAi) return;
+      expect(typeof piAi.registerFauxProvider).toBe("function");
+    });
+
+    it("exports fauxText / fauxThinking / fauxToolCall helpers", () => {
+      if (!piAi) return;
+      expect(typeof piAi.fauxText).toBe("function");
+      expect(typeof piAi.fauxThinking).toBe("function");
+      expect(typeof piAi.fauxToolCall).toBe("function");
+    });
+  });
+
+  // --- OAuth exports from pi-ai/oauth (dist/oauth.js) ---
+
+  describe("oauth exports", () => {
+    it("exports refreshAnthropicToken (Anthropic OAuth)", () => {
+      if (!piAiOAuth) return;
+      expect(typeof piAiOAuth.refreshAnthropicToken).toBe("function");
+    });
+
+    it("exports refreshOpenAICodexToken (Codex OAuth)", () => {
+      if (!piAiOAuth) return;
+      expect(typeof piAiOAuth.refreshOpenAICodexToken).toBe("function");
+    });
+
+    it("exports refreshGitHubCopilotToken (GitHub Copilot OAuth)", () => {
+      if (!piAiOAuth) return;
+      expect(typeof piAiOAuth.refreshGitHubCopilotToken).toBe("function");
+    });
+
+    it("exports getOAuthProvider (generic provider lookup)", () => {
+      if (!piAiOAuth) return;
+      expect(typeof piAiOAuth.getOAuthProvider).toBe("function");
+    });
+
+    it("exports refreshOAuthToken (generic refresh)", () => {
+      if (!piAiOAuth) return;
+      expect(typeof piAiOAuth.refreshOAuthToken).toBe("function");
+    });
+
+    it("exports getOAuthApiKey (get API key from credentials)", () => {
+      if (!piAiOAuth) return;
+      expect(typeof piAiOAuth.getOAuthApiKey).toBe("function");
+    });
+  });
+});