@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.0

package/packages/server/src/__tests__/session-action-handler-headless-reload.test.ts

@@ -0,0 +1,467 @@
+/**
+ * Tests for server-side /reload handling on headless pi sessions.
+ *
+ * See change: headless-reload-via-respawn.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock spawnPiSession BEFORE importing the handler.
+vi.mock("../process-manager.js", () => ({
+  spawnPiSession: vi.fn(),
+}));
+vi.mock("@blackbelt-technology/pi-dashboard-shared/config.js", () => ({
+  loadConfig: () => ({ spawnStrategy: "headless" as const }),
+}));
+
+import {
+  handleHeadlessReload,
+  handleSendPrompt,
+} from "../browser-handlers/session-action-handler.js";
+import { spawnPiSession } from "../process-manager.js";
+
+type SentMessage = { type: string; [k: string]: unknown };
+type InsertedEvent = {
+  sessionId: string;
+  event: { eventType: string; data: Record<string, unknown>; timestamp: number };
+};
+
+function makeCtx(
+  options: {
+    pidBySession?: Record<string, number | undefined>;
+    sessions?: Record<string, any>;
+  } = {},
+) {
+  const broadcasts: SentMessage[] = [];
+  const insertedEvents: InsertedEvent[] = [];
+  const killCalls: string[] = [];
+  const registerCalls: Array<{ pid: number; cwd: string; proc: unknown }> = [];
+  const sessionUpdates: Array<{ id: string; updates: any }> = [];
+
+  const pidBySession: Record<string, number | undefined> = {
+    ...(options.pidBySession ?? {}),
+  };
+  const sessions: Record<string, any> = { ...(options.sessions ?? {}) };
+
+  const ctx = {
+    ws: { readyState: 1 } as any,
+    sessionManager: {
+      get: (sid: string) => sessions[sid],
+      update: (sid: string, updates: any) => {
+        sessionUpdates.push({ id: sid, updates });
+        if (sessions[sid]) Object.assign(sessions[sid], updates);
+      },
+      unregister: vi.fn(),
+    },
+    piGateway: {
+      sendToSession: vi.fn().mockReturnValue(true),
+    },
+    headlessPidRegistry: {
+      getPid: (sid: string) => pidBySession[sid],
+      killBySessionId: (sid: string) => {
+        killCalls.push(sid);
+        // Simulate immediate removal from registry on kill
+        pidBySession[sid] = undefined;
+        return true;
+      },
+      register: (pid: number, cwd: string, proc: unknown) => {
+        registerCalls.push({ pid, cwd, proc });
+        // Simulate the registry linking the session after re-register
+        const existingSessionId = Object.keys(sessions).find(
+          (id) => sessions[id]?.cwd === cwd,
+        );
+        if (existingSessionId) pidBySession[existingSessionId] = pid;
+      },
+    },
+    pendingResumeRegistry: { record: vi.fn(), consume: vi.fn() },
+    pendingDashboardSpawns: new Map<string, number>(),
+    eventStore: {
+      insertEvent: (sid: string, event: any) => {
+        insertedEvents.push({ sessionId: sid, event });
+        return insertedEvents.length; // fake seq
+      },
+    },
+    broadcast: (m: SentMessage) => {
+      broadcasts.push(m);
+    },
+    sendTo: (_ws: unknown, m: SentMessage) => {
+      broadcasts.push(m);
+    },
+  } as any;
+
+  return {
+    ctx,
+    broadcasts,
+    insertedEvents,
+    killCalls,
+    registerCalls,
+    sessionUpdates,
+    pidBySession,
+    sessions,
+  };
+}
+
+function findFeedback(events: InsertedEvent[]) {
+  return events
+    .filter((e) => e.event.eventType === "command_feedback")
+    .map((e) => e.event.data);
+}
+
+describe("handleHeadlessReload — happy path", () => {
+  beforeEach(() => vi.clearAllMocks());
+  afterEach(() => vi.restoreAllMocks());
+
+  it("kills old pi, spawns new pi, registers new PID, emits started+completed", async () => {
+    (spawnPiSession as any).mockResolvedValueOnce({
+      success: true,
+      pid: 9999,
+      process: { _fake: true },
+      message: "ok",
+    });
+
+    const { ctx, killCalls, registerCalls, insertedEvents } = makeCtx({
+      pidBySession: { S1: 1234 },
+      sessions: {
+        S1: {
+          id: "S1",
+          cwd: "/home/u/proj",
+          sessionFile: "/home/u/proj/.pi/sessions/abc.jsonl",
+          status: "active",
+        },
+      },
+    });
+
+    await handleHeadlessReload(
+      { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+      ctx,
+    );
+
+    // Kill came before spawn
+    expect(killCalls).toEqual(["S1"]);
+    expect(spawnPiSession).toHaveBeenCalledTimes(1);
+    expect(spawnPiSession).toHaveBeenCalledWith(
+      "/home/u/proj",
+      expect.objectContaining({
+        sessionFile: "/home/u/proj/.pi/sessions/abc.jsonl",
+        mode: "continue",
+        strategy: "headless",
+      }),
+    );
+
+    // New PID registered
+    expect(registerCalls).toHaveLength(1);
+    expect(registerCalls[0].pid).toBe(9999);
+
+    // Feedback sequence: started → completed
+    const feedback = findFeedback(insertedEvents);
+    expect(feedback.map((f) => f.status)).toEqual(["started", "completed"]);
+  });
+});
+
+describe("handleHeadlessReload — streaming session", () => {
+  beforeEach(() => vi.clearAllMocks());
+  afterEach(() => vi.restoreAllMocks());
+
+  it("rejects reload when session is streaming; no kill, no spawn", async () => {
+    const { ctx, killCalls, insertedEvents } = makeCtx({
+      pidBySession: { S1: 1234 },
+      sessions: {
+        S1: {
+          id: "S1",
+          cwd: "/p",
+          sessionFile: "/p/s.jsonl",
+          status: "streaming",
+        },
+      },
+    });
+
+    await handleHeadlessReload(
+      { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+      ctx,
+    );
+
+    expect(killCalls).toEqual([]);
+    expect(spawnPiSession).not.toHaveBeenCalled();
+
+    const feedback = findFeedback(insertedEvents);
+    expect(feedback).toHaveLength(1);
+    expect(feedback[0].status).toBe("error");
+    expect(String(feedback[0].message)).toMatch(/response/i);
+  });
+});
+
+describe("handleHeadlessReload — spawn failure", () => {
+  beforeEach(() => vi.clearAllMocks());
+  afterEach(() => vi.restoreAllMocks());
+
+  it("broadcasts session_updated{status:ended} and error feedback when spawnPiSession returns failure", async () => {
+    (spawnPiSession as any).mockResolvedValueOnce({
+      success: false,
+      message: "tmux unavailable, headless failed",
+    });
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const { ctx, broadcasts, sessionUpdates, insertedEvents } = makeCtx({
+      pidBySession: { S1: 1234 },
+      sessions: {
+        S1: {
+          id: "S1",
+          cwd: "/p",
+          sessionFile: "/p/s.jsonl",
+          status: "active",
+        },
+      },
+    });
+
+    await handleHeadlessReload(
+      { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+      ctx,
+    );
+
+    expect(errSpy).toHaveBeenCalledWith(
+      expect.stringContaining("headless reload spawn failed"),
+    );
+
+    // Session marked ended
+    expect(
+      sessionUpdates.some(
+        (u) => u.id === "S1" && u.updates.status === "ended",
+      ),
+    ).toBe(true);
+    // session_updated broadcast
+    expect(
+      broadcasts.some(
+        (m) =>
+          m.type === "session_updated" &&
+          (m as any).sessionId === "S1" &&
+          ((m as any).updates as any).status === "ended",
+      ),
+    ).toBe(true);
+
+    // Final feedback is error
+    const feedback = findFeedback(insertedEvents);
+    expect(feedback[feedback.length - 1].status).toBe("error");
+    expect(String(feedback[feedback.length - 1].message)).toContain(
+      "tmux unavailable",
+    );
+
+    errSpy.mockRestore();
+  });
+
+  it("handles spawnPiSession throwing", async () => {
+    (spawnPiSession as any).mockRejectedValueOnce(new Error("ENOENT: pi not found"));
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const { ctx, sessionUpdates, insertedEvents } = makeCtx({
+      pidBySession: { S1: 1234 },
+      sessions: {
+        S1: { id: "S1", cwd: "/p", sessionFile: "/p/s.jsonl", status: "active" },
+      },
+    });
+
+    await handleHeadlessReload(
+      { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+      ctx,
+    );
+
+    expect(
+      sessionUpdates.some((u) => u.updates.status === "ended"),
+    ).toBe(true);
+    const feedback = findFeedback(insertedEvents);
+    expect(feedback[feedback.length - 1].status).toBe("error");
+    expect(String(feedback[feedback.length - 1].message)).toMatch(/ENOENT/);
+
+    errSpy.mockRestore();
+  });
+});
+
+describe("handleHeadlessReload — missing session file", () => {
+  beforeEach(() => vi.clearAllMocks());
+  afterEach(() => vi.restoreAllMocks());
+
+  it("errors when the session has no sessionFile", async () => {
+    const { ctx, insertedEvents, killCalls } = makeCtx({
+      pidBySession: { S1: 1234 },
+      sessions: {
+        S1: { id: "S1", cwd: "/p", status: "active" },
+      },
+    });
+
+    await handleHeadlessReload(
+      { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+      ctx,
+    );
+
+    expect(killCalls).toEqual([]);
+    expect(spawnPiSession).not.toHaveBeenCalled();
+
+    const feedback = findFeedback(insertedEvents);
+    expect(feedback).toHaveLength(1);
+    expect(feedback[0].status).toBe("error");
+  });
+});
+
+describe("handleHeadlessReload — concurrent calls", () => {
+  beforeEach(() => vi.clearAllMocks());
+  afterEach(() => vi.restoreAllMocks());
+
+  it("two back-to-back /reload calls still register exactly one live PID (the second)", async () => {
+    let nextPid = 7001;
+    (spawnPiSession as any).mockImplementation(async () => ({
+      success: true,
+      pid: nextPid++,
+      process: { _fake: true },
+    }));
+
+    const { ctx, killCalls, registerCalls, pidBySession } = makeCtx({
+      pidBySession: { S1: 1234 },
+      sessions: {
+        S1: {
+          id: "S1",
+          cwd: "/p",
+          sessionFile: "/p/s.jsonl",
+          status: "active",
+        },
+      },
+    });
+
+    // Fire two concurrent reloads.
+    const [r1, r2] = await Promise.all([
+      handleHeadlessReload(
+        { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+        ctx,
+      ),
+      handleHeadlessReload(
+        { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+        ctx,
+      ),
+    ]);
+    expect(r1).toBeUndefined();
+    expect(r2).toBeUndefined();
+
+    // First call kills the original; second call observes no PID and kills noop.
+    expect(killCalls.length).toBeGreaterThanOrEqual(1);
+    expect(killCalls.length).toBeLessThanOrEqual(2);
+
+    // Both calls spawned, but registry ended with one live PID (the later one).
+    expect(spawnPiSession).toHaveBeenCalledTimes(2);
+    expect(registerCalls).toHaveLength(2);
+    expect(pidBySession.S1).toBe(registerCalls[registerCalls.length - 1].pid);
+  });
+});
+
+describe("handleSendPrompt — interception wiring", () => {
+  beforeEach(() => vi.clearAllMocks());
+  afterEach(() => vi.restoreAllMocks());
+
+  it("/reload on a headless session triggers respawn, NOT bridge forward", async () => {
+    (spawnPiSession as any).mockResolvedValueOnce({
+      success: true,
+      pid: 4242,
+      process: { _fake: true },
+    });
+
+    const { ctx } = makeCtx({
+      pidBySession: { S1: 1234 },
+      sessions: {
+        S1: {
+          id: "S1",
+          cwd: "/p",
+          sessionFile: "/p/s.jsonl",
+          status: "active",
+        },
+      },
+    });
+
+    await handleSendPrompt(
+      { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+      ctx,
+    );
+
+    expect(spawnPiSession).toHaveBeenCalledTimes(1);
+    expect(ctx.piGateway.sendToSession).not.toHaveBeenCalled();
+  });
+
+  it("/reload on a non-headless (tmux) session forwards to the bridge unchanged", async () => {
+    const { ctx } = makeCtx({
+      pidBySession: { S1: undefined }, // no PID → non-headless
+      sessions: {
+        S1: {
+          id: "S1",
+          cwd: "/p",
+          sessionFile: "/p/s.jsonl",
+          status: "active",
+        },
+      },
+    });
+
+    await handleSendPrompt(
+      { type: "send_prompt", sessionId: "S1", text: "/reload" } as any,
+      ctx,
+    );
+
+    expect(spawnPiSession).not.toHaveBeenCalled();
+    expect(ctx.piGateway.sendToSession).toHaveBeenCalledWith(
+      "S1",
+      expect.objectContaining({
+        type: "send_prompt",
+        text: "/reload",
+      }),
+    );
+  });
+
+  it("non-/reload prompt on a headless session still forwards to the bridge", async () => {
+    const { ctx } = makeCtx({
+      pidBySession: { S1: 1234 }, // headless
+      sessions: {
+        S1: {
+          id: "S1",
+          cwd: "/p",
+          sessionFile: "/p/s.jsonl",
+          status: "active",
+        },
+      },
+    });
+
+    await handleSendPrompt(
+      {
+        type: "send_prompt",
+        sessionId: "S1",
+        text: "please do the thing",
+      } as any,
+      ctx,
+    );
+
+    expect(spawnPiSession).not.toHaveBeenCalled();
+    expect(ctx.piGateway.sendToSession).toHaveBeenCalledWith(
+      "S1",
+      expect.objectContaining({ text: "please do the thing" }),
+    );
+  });
+
+  it("/reload with images on a headless session is NOT intercepted (falls through to bridge)", async () => {
+    const { ctx } = makeCtx({
+      pidBySession: { S1: 1234 },
+      sessions: {
+        S1: {
+          id: "S1",
+          cwd: "/p",
+          sessionFile: "/p/s.jsonl",
+          status: "active",
+        },
+      },
+    });
+
+    await handleSendPrompt(
+      {
+        type: "send_prompt",
+        sessionId: "S1",
+        text: "/reload",
+        images: [{ type: "image", data: "x" }],
+      } as any,
+      ctx,
+    );
+
+    expect(spawnPiSession).not.toHaveBeenCalled();
+    expect(ctx.piGateway.sendToSession).toHaveBeenCalled();
+  });
+});

package/packages/server/src/__tests__/session-action-handler-reload-predicate.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "vitest";
+import { shouldInterceptReload } from "../browser-handlers/session-action-helpers.js";
+
+function makeRegistry(pidBySessionId: Record<string, number | undefined>) {
+  return {
+    getPid(sid: string) {
+      return pidBySessionId[sid];
+    },
+  };
+}
+
+function msg(overrides: Partial<{ text: string; images: unknown[]; sessionId: string }> = {}) {
+  return {
+    type: "send_prompt" as const,
+    sessionId: overrides.sessionId ?? "S1",
+    text: overrides.text ?? "/reload",
+    images: overrides.images as any,
+  };
+}
+
+describe("shouldInterceptReload", () => {
+  it("returns true for exact '/reload' on a tracked headless session", () => {
+    const reg = makeRegistry({ S1: 1234 });
+    expect(shouldInterceptReload(msg() as any, reg)).toBe(true);
+  });
+
+  it("returns false for trailing whitespace ' /reload '", () => {
+    const reg = makeRegistry({ S1: 1234 });
+    expect(shouldInterceptReload(msg({ text: " /reload" }) as any, reg)).toBe(false);
+    expect(shouldInterceptReload(msg({ text: "/reload " }) as any, reg)).toBe(false);
+  });
+
+  it("returns false for '/reload something'", () => {
+    const reg = makeRegistry({ S1: 1234 });
+    expect(shouldInterceptReload(msg({ text: "/reload arg" }) as any, reg)).toBe(false);
+  });
+
+  it("returns false when images are attached", () => {
+    const reg = makeRegistry({ S1: 1234 });
+    expect(
+      shouldInterceptReload(msg({ images: [{ type: "image", data: "xxx" }] }) as any, reg),
+    ).toBe(false);
+  });
+
+  it("returns true when images is an empty array", () => {
+    const reg = makeRegistry({ S1: 1234 });
+    expect(shouldInterceptReload(msg({ images: [] }) as any, reg)).toBe(true);
+  });
+
+  it("returns false when the session has no tracked PID (non-headless)", () => {
+    const reg = makeRegistry({ S1: undefined });
+    expect(shouldInterceptReload(msg() as any, reg)).toBe(false);
+  });
+
+  it("returns false for the wrong session id", () => {
+    const reg = makeRegistry({ S1: 1234 });
+    expect(shouldInterceptReload(msg({ sessionId: "OTHER" }) as any, reg)).toBe(false);
+  });
+
+  it("returns false for unrelated slash commands", () => {
+    const reg = makeRegistry({ S1: 1234 });
+    expect(shouldInterceptReload(msg({ text: "/new" }) as any, reg)).toBe(false);
+    expect(shouldInterceptReload(msg({ text: "/quit" }) as any, reg)).toBe(false);
+    expect(shouldInterceptReload(msg({ text: "hello" }) as any, reg)).toBe(false);
+  });
+
+  it("still returns true even if the tracked PID is stale — liveness is checked later, not here", () => {
+    // shouldInterceptReload is a cheap gate. Liveness is the handler's job;
+    // killBySessionId is a no-op when the process is already dead.
+    const reg = makeRegistry({ S1: 99999999 });
+    expect(shouldInterceptReload(msg() as any, reg)).toBe(true);
+  });
+});

package/packages/server/src/__tests__/session-action-handler-spawn-error.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock spawnPiSession BEFORE importing the handler.
+vi.mock("../process-manager.js", () => ({
+  spawnPiSession: vi.fn(),
+}));
+vi.mock("../../../shared/src/config.js", () => ({
+  loadConfig: () => ({ spawnStrategy: "headless" as const }),
+}));
+vi.mock("@blackbelt-technology/pi-dashboard-shared/config.js", () => ({
+  loadConfig: () => ({ spawnStrategy: "headless" as const }),
+}));
+
+import { handleSpawnSession } from "../browser-handlers/session-action-handler.js";
+import { spawnPiSession } from "../process-manager.js";
+
+type SentMessage = { type: string; [k: string]: unknown };
+
+function makeCtx() {
+  const sent: SentMessage[] = [];
+  const ws = { readyState: 1 } as unknown as WebSocket;
+  const ctx = {
+    ws,
+    headlessPidRegistry: { register: vi.fn() },
+    pendingDashboardSpawns: new Map<string, number>(),
+    sendTo: (_ws: unknown, msg: SentMessage) => { sent.push(msg); },
+  } as any;
+  return { ctx, sent };
+}
+
+describe("handleSpawnSession — error propagation", () => {
+  beforeEach(() => { vi.clearAllMocks(); });
+  afterEach(() => { vi.restoreAllMocks(); });
+
+  it("emits spawn_error when spawnPiSession throws", async () => {
+    (spawnPiSession as any).mockRejectedValueOnce(new Error("ENOENT: pi not found"));
+    const { ctx, sent } = makeCtx();
+    await handleSpawnSession({ type: "spawn_session", cwd: "C:\\proj" } as any, ctx);
+    const errMsg = sent.find(m => m.type === "spawn_error");
+    const resMsg = sent.find(m => m.type === "spawn_result");
+    expect(resMsg).toBeDefined();
+    expect(resMsg!.success).toBe(false);
+    expect(errMsg).toBeDefined();
+    expect(errMsg!.cwd).toBe("C:\\proj");
+    expect(errMsg!.strategy).toBe("headless");
+    expect(errMsg!.message).toMatch(/ENOENT/);
+  });
+
+  it("emits spawn_error when spawnPiSession returns { success: false }", async () => {
+    (spawnPiSession as any).mockResolvedValueOnce({ success: false, message: "tmux unavailable" });
+    const { ctx, sent } = makeCtx();
+    await handleSpawnSession({ type: "spawn_session", cwd: "/app" } as any, ctx);
+    const errMsg = sent.find(m => m.type === "spawn_error");
+    expect(errMsg).toBeDefined();
+    expect(errMsg!.message).toBe("tmux unavailable");
+  });
+
+  it("does NOT emit spawn_error on successful spawn", async () => {
+    (spawnPiSession as any).mockResolvedValueOnce({ success: true, message: "ok", pid: 1234 });
+    const { ctx, sent } = makeCtx();
+    await handleSpawnSession({ type: "spawn_session", cwd: "/app" } as any, ctx);
+    expect(sent.some(m => m.type === "spawn_error")).toBe(false);
+    expect(sent.some(m => m.type === "spawn_result" && m.success === true)).toBe(true);
+  });
+
+  it("includes stderr tail when thrown error carries one", async () => {
+    const err = Object.assign(new Error("boom"), { stderr: "line1\nline2\nline3" });
+    (spawnPiSession as any).mockRejectedValueOnce(err);
+    const { ctx, sent } = makeCtx();
+    await handleSpawnSession({ type: "spawn_session", cwd: "/x" } as any, ctx);
+    const errMsg = sent.find(m => m.type === "spawn_error");
+    expect(errMsg!.stderr).toContain("line3");
+  });
+});

package/packages/server/src/__tests__/terminal-manager.test.ts

@@ -25,6 +25,12 @@ vi.mock("node-pty", () => ({
   })),
 }));
 
+// Mock platform/process.ts killProcess so the Windows path is observable in tests.
+const mockKillProcess = vi.fn((..._args: unknown[]) => Promise.resolve({ ok: true, forced: false }));
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/process.js", () => ({
+  killProcess: (...args: unknown[]) => mockKillProcess(...args),
+}));
+
 describe("TerminalManager", () => {
   let manager: TerminalManager;
   let exitCallbacks: Array<(termId: string) => void>;
@@ -112,10 +118,44 @@ describe("TerminalManager", () => {
   });
 
   describe("kill", () => {
-    it("sends SIGHUP to PTY (bash on Linux ignores SIGTERM)", () => {
+    beforeEach(() => {
+      mockKillProcess.mockClear();
+    });
+
+    it("POSIX: sends SIGHUP to PTY (bash on Linux ignores SIGTERM)", () => {
+      if (process.platform === "win32") return; // skipped on Windows; covered below
       const session = manager.spawn("/tmp");
       manager.kill(session.id);
       expect(mockPtyKill).toHaveBeenCalledWith("SIGHUP");
+      expect(mockKillProcess).not.toHaveBeenCalled();
+    });
+
+    it("Windows: routes kill through platform killProcess (tree kill via taskkill /F /T)", () => {
+      if (process.platform !== "win32") return; // skipped off-Windows
+      const session = manager.spawn("C:\\tmp");
+      manager.kill(session.id);
+      // pty.kill MUST NOT be called on Windows — killProcess(pid) does the tree-kill.
+      expect(mockPtyKill).not.toHaveBeenCalled();
+      expect(mockKillProcess).toHaveBeenCalledWith(12345, expect.objectContaining({ timeoutMs: 2000 }));
+    });
+
+    it("fallback cleanup fires if onExit does not within 3 s (simulates Windows ConPTY)", async () => {
+      vi.useFakeTimers();
+      try {
+        const session = manager.spawn("/tmp");
+        let exitCalled = false;
+        manager = createTerminalManager({
+          onExit: () => { exitCalled = true; },
+        });
+        const session2 = manager.spawn("/tmp");
+        manager.kill(session2.id);
+        // Simulate node-pty NOT firing onExit (the actual Windows failure mode).
+        await vi.advanceTimersByTimeAsync(3001);
+        expect(exitCalled).toBe(true);
+        expect(manager.get(session2.id)).toBeUndefined(); // removed from map
+      } finally {
+        vi.useRealTimers();
+      }
     });
 
     it("throws for unknown ID", () => {