@gotgenes/pi-permission-system 5.10.0 → 5.11.0

package/tests/handlers/before-agent-start.test.ts

@@ -2,11 +2,11 @@ import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { describe, expect, it, vi } from "vitest";
 
 import {
-  handleBeforeAgentStart,
+  AgentPrepHandler,
   shouldExposeTool,
 } from "../../src/handlers/before-agent-start";
-import type { HandlerDeps } from "../../src/handlers/types";
 import type { PermissionSession } from "../../src/permission-session";
+import type { ToolRegistry } from "../../src/tool-registry";
 import type { PermissionState } from "../../src/types";
 
 // ── SDK stubs ──────────────────────────────────────────────────────────────
@@ -65,22 +65,28 @@ function makeSession(
   } as unknown as PermissionSession;
 }
 
-function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
+function makeToolRegistry(overrides: Partial<ToolRegistry> = {}): ToolRegistry {
   return {
-    session: makeSession(),
-    events: { emit: vi.fn(), on: vi.fn().mockReturnValue(() => undefined) },
-    canRequestPermissionConfirmation: vi.fn().mockReturnValue(false),
-    promptPermission: vi
-      .fn()
-      .mockResolvedValue({ approved: true, state: "approved" }),
-    createPermissionRequestId: vi.fn().mockReturnValue("test-id"),
-    stopPermissionRpcHandlers: vi.fn(),
-    getAllTools: vi.fn().mockReturnValue([]),
-    setActiveTools: vi.fn(),
+    getAll: vi.fn().mockReturnValue([]),
+    setActive: vi.fn(),
     ...overrides,
   };
 }
 
+function makeHandler(overrides?: {
+  session?: Partial<Record<keyof PermissionSession, unknown>>;
+  toolRegistry?: Partial<ToolRegistry>;
+}): {
+  handler: AgentPrepHandler;
+  session: PermissionSession;
+  toolRegistry: ToolRegistry;
+} {
+  const session = makeSession(overrides?.session);
+  const toolRegistry = makeToolRegistry(overrides?.toolRegistry);
+  const handler = new AgentPrepHandler(session, toolRegistry);
+  return { handler, session, toolRegistry };
+}
+
 // ── shouldExposeTool (pure helper) ─────────────────────────────────────────
 
 describe("shouldExposeTool", () => {
@@ -112,136 +118,110 @@ describe("shouldExposeTool", () => {
   });
 });
 
-// ── handleBeforeAgentStart ─────────────────────────────────────────────────
+// ── AgentPrepHandler.handle ────────────────────────────────────────────────
 
-describe("handleBeforeAgentStart", () => {
+describe("AgentPrepHandler.handle", () => {
   it("activates the session with ctx", async () => {
     const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleBeforeAgentStart(deps, makeEvent(), ctx);
-    expect(deps.session.activate).toHaveBeenCalledWith(ctx);
+    const { handler, session } = makeHandler();
+    await handler.handle(makeEvent(), ctx);
+    expect(session.activate).toHaveBeenCalledWith(ctx);
   });
 
   it("refreshes config with ctx", async () => {
     const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleBeforeAgentStart(deps, makeEvent(), ctx);
-    expect(deps.session.refreshConfig).toHaveBeenCalledWith(ctx);
+    const { handler, session } = makeHandler();
+    await handler.handle(makeEvent(), ctx);
+    expect(session.refreshConfig).toHaveBeenCalledWith(ctx);
   });
 
   it("resolves agent name using systemPrompt", async () => {
     const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleBeforeAgentStart(
-      deps,
-      makeEvent("<active_agent name='x'>"),
-      ctx,
-    );
-    expect(deps.session.resolveAgentName).toHaveBeenCalledWith(
+    const { handler, session } = makeHandler();
+    await handler.handle(makeEvent("<active_agent name='x'>"), ctx);
+    expect(session.resolveAgentName).toHaveBeenCalledWith(
       ctx,
       "<active_agent name='x'>",
     );
   });
 
   it("filters out denied tools from allowed list", async () => {
-    const session = makeSession({
-      getToolPermission: vi.fn().mockReturnValue("deny"),
+    const { handler, toolRegistry } = makeHandler({
+      session: { getToolPermission: vi.fn().mockReturnValue("deny") },
+      toolRegistry: {
+        getAll: vi.fn().mockReturnValue([{ name: "write" }, { name: "read" }]),
+      },
     });
-    const deps = makeDeps({
-      session,
-      getAllTools: vi
-        .fn()
-        .mockReturnValue([{ name: "write" }, { name: "read" }]),
-    });
-    await handleBeforeAgentStart(deps, makeEvent(), makeCtx());
-    expect(deps.setActiveTools).toHaveBeenCalledWith([]);
+    await handler.handle(makeEvent(), makeCtx());
+    expect(toolRegistry.setActive).toHaveBeenCalledWith([]);
   });
 
   it("includes allowed and ask tools in the active list", async () => {
-    const deps = makeDeps({
-      getAllTools: vi
-        .fn()
-        .mockReturnValue([{ name: "read" }, { name: "write" }]),
+    const { handler, toolRegistry } = makeHandler({
+      toolRegistry: {
+        getAll: vi.fn().mockReturnValue([{ name: "read" }, { name: "write" }]),
+      },
     });
-    await handleBeforeAgentStart(deps, makeEvent(), makeCtx());
-    expect(deps.setActiveTools).toHaveBeenCalledWith(["read", "write"]);
+    await handler.handle(makeEvent(), makeCtx());
+    expect(toolRegistry.setActive).toHaveBeenCalledWith(["read", "write"]);
   });
 
   it("commits active-tools cache key after applying", async () => {
-    const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([{ name: "read" }]),
+    const { handler, session } = makeHandler({
+      toolRegistry: {
+        getAll: vi.fn().mockReturnValue([{ name: "read" }]),
+      },
     });
-    await handleBeforeAgentStart(deps, makeEvent(), makeCtx());
-    expect(deps.session.commitActiveToolsCacheKey).toHaveBeenCalled();
+    await handler.handle(makeEvent(), makeCtx());
+    expect(session.commitActiveToolsCacheKey).toHaveBeenCalled();
   });
 
-  it("skips setActiveTools when cache key is unchanged", async () => {
-    const session = makeSession({
-      shouldUpdateActiveTools: vi.fn().mockReturnValue(false),
-    });
-    const deps = makeDeps({
-      session,
-      getAllTools: vi.fn().mockReturnValue([{ name: "read" }]),
+  it("skips setActive when cache key is unchanged", async () => {
+    const { handler, session, toolRegistry } = makeHandler({
+      session: { shouldUpdateActiveTools: vi.fn().mockReturnValue(false) },
+      toolRegistry: {
+        getAll: vi.fn().mockReturnValue([{ name: "read" }]),
+      },
     });
-    await handleBeforeAgentStart(deps, makeEvent(), makeCtx());
-    expect(deps.setActiveTools).not.toHaveBeenCalled();
+    await handler.handle(makeEvent(), makeCtx());
+    expect(toolRegistry.setActive).not.toHaveBeenCalled();
     expect(session.commitActiveToolsCacheKey).not.toHaveBeenCalled();
   });
 
   it("returns empty object when prompt cache is unchanged", async () => {
-    const session = makeSession({
-      shouldUpdatePromptState: vi.fn().mockReturnValue(false),
-    });
-    const deps = makeDeps({
-      session,
-      getAllTools: vi.fn().mockReturnValue([]),
+    const { handler, session } = makeHandler({
+      session: { shouldUpdatePromptState: vi.fn().mockReturnValue(false) },
     });
-    const result = await handleBeforeAgentStart(deps, makeEvent(), makeCtx());
+    const result = await handler.handle(makeEvent(), makeCtx());
     expect(result).toEqual({});
     expect(session.commitPromptStateCacheKey).not.toHaveBeenCalled();
   });
 
   it("commits prompt-state cache key and processes prompt when cache is new", async () => {
-    const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([]),
-    });
-    await handleBeforeAgentStart(deps, makeEvent(), makeCtx());
-    expect(deps.session.commitPromptStateCacheKey).toHaveBeenCalled();
+    const { handler, session } = makeHandler();
+    await handler.handle(makeEvent(), makeCtx());
+    expect(session.commitPromptStateCacheKey).toHaveBeenCalled();
   });
 
   it("stores resolved skill entries on the session", async () => {
-    const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([]),
-    });
-    await handleBeforeAgentStart(deps, makeEvent(), makeCtx());
-    expect(deps.session.setActiveSkillEntries).toHaveBeenCalledWith(
+    const { handler, session } = makeHandler();
+    await handler.handle(makeEvent(), makeCtx());
+    expect(session.setActiveSkillEntries).toHaveBeenCalledWith(
       expect.any(Array),
     );
   });
 
   it("returns modified systemPrompt when prompt changes", async () => {
     const systemPrompt = `You are an assistant.\n\nAvailable tools:\n- read\n- write\n`;
-    const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([]),
-    });
-    const result = await handleBeforeAgentStart(
-      deps,
-      makeEvent(systemPrompt),
-      makeCtx(),
-    );
+    const { handler } = makeHandler();
+    const result = await handler.handle(makeEvent(systemPrompt), makeCtx());
     expect(result).toHaveProperty("systemPrompt");
   });
 
   it("returns empty object when systemPrompt is unchanged", async () => {
     const prompt = "No tools section here.";
-    const deps = makeDeps({
-      getAllTools: vi.fn().mockReturnValue([]),
-    });
-    const result = await handleBeforeAgentStart(
-      deps,
-      makeEvent(prompt),
-      makeCtx(),
-    );
+    const { handler } = makeHandler();
+    const result = await handler.handle(makeEvent(prompt), makeCtx());
     expect(result).toEqual({});
   });
 });

package/tests/handlers/input-events.test.ts

@@ -4,11 +4,11 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { describe, expect, it, vi } from "vitest";
 
-import { handleInput } from "../../src/handlers/input";
-import type { HandlerDeps } from "../../src/handlers/types";
+import { PermissionGateHandler } from "../../src/handlers/permission-gate-handler";
 import type { PermissionDecisionEvent } from "../../src/permission-events";
 import { PERMISSIONS_DECISION_CHANNEL } from "../../src/permission-events";
 import type { PermissionSession } from "../../src/permission-session";
+import type { ToolRegistry } from "../../src/tool-registry";
 import type { PermissionState } from "../../src/types";
 
 // ── helpers ────────────────────────────────────────────────────────────────
@@ -41,6 +41,7 @@ function makeCtx(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
 
 function makeSession(
   state: "allow" | "deny" | "ask" = "allow",
+  overrides: Partial<Record<keyof PermissionSession, unknown>> = {},
 ): PermissionSession {
   return {
     logger: { debug: vi.fn(), review: vi.fn(), warn: vi.fn() },
@@ -56,31 +57,42 @@ function makeSession(
     getToolPermission: vi.fn().mockReturnValue("allow" as PermissionState),
     getSessionRuleset: vi.fn().mockReturnValue([]),
     approveSessionRule: vi.fn(),
+    canPrompt: vi.fn().mockReturnValue(true),
+    prompt: vi.fn().mockResolvedValue({ approved: true, state: "approved" }),
+    createPermissionRequestId: vi.fn().mockReturnValue("req-id"),
+    ...overrides,
   } as unknown as PermissionSession;
 }
 
-function makeDeps(
-  state: "allow" | "deny" | "ask" = "allow",
-  overrides: Partial<HandlerDeps> = {},
-): HandlerDeps {
+function makeToolRegistry(): ToolRegistry {
   return {
-    session: makeSession(state),
-    events: makeEvents(),
-    canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
-    promptPermission: vi
-      .fn()
-      .mockResolvedValue({ approved: true, state: "approved" }),
-    createPermissionRequestId: vi.fn().mockReturnValue("req-id"),
-    stopPermissionRpcHandlers: vi.fn(),
-    getAllTools: vi.fn().mockReturnValue([]),
-    setActiveTools: vi.fn(),
-    ...overrides,
+    getAll: vi.fn().mockReturnValue([]),
+    setActive: vi.fn(),
   };
 }
 
-function getDecisionEvents(deps: HandlerDeps): PermissionDecisionEvent[] {
-  const emitMock = (deps.events as ReturnType<typeof makeEvents>).emit;
-  return emitMock.mock.calls
+function makeHandler(
+  state: "allow" | "deny" | "ask" = "allow",
+  sessionOverrides: Partial<Record<keyof PermissionSession, unknown>> = {},
+): {
+  handler: PermissionGateHandler;
+  events: ReturnType<typeof makeEvents>;
+} {
+  const session = makeSession(state, sessionOverrides);
+  const events = makeEvents();
+  const handler = new PermissionGateHandler(
+    session,
+    events,
+    makeToolRegistry(),
+  );
+  return { handler, events };
+}
+
+/** Extract all permissions:decision payloads from the events.emit mock. */
+function getDecisionEvents(
+  events: ReturnType<typeof makeEvents>,
+): PermissionDecisionEvent[] {
+  return events.emit.mock.calls
     .filter(([channel]) => channel === PERMISSIONS_DECISION_CHANNEL)
     .map(([, payload]) => payload as PermissionDecisionEvent);
 }
@@ -89,18 +101,18 @@ function getDecisionEvents(deps: HandlerDeps): PermissionDecisionEvent[] {
 
 describe("handleInput decision events — skill gate", () => {
   it("does not emit when input is not a skill invocation", async () => {
-    const deps = makeDeps();
-    await handleInput(deps, { text: "hello world" }, makeCtx());
-    expect(getDecisionEvents(deps)).toHaveLength(0);
+    const { handler, events } = makeHandler();
+    await handler.handleInput({ text: "hello world" }, makeCtx());
+    expect(getDecisionEvents(events)).toHaveLength(0);
   });
 
   it("emits allow with policy_allow for an allowed skill", async () => {
-    const deps = makeDeps("allow");
-    await handleInput(deps, { text: "/skill:librarian" }, makeCtx());
+    const { handler, events } = makeHandler("allow");
+    await handler.handleInput({ text: "/skill:librarian" }, makeCtx());
 
-    const events = getDecisionEvents(deps);
-    expect(events).toHaveLength(1);
-    expect(events[0]).toMatchObject({
+    const decisions = getDecisionEvents(events);
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0]).toMatchObject({
       surface: "skill",
       value: "librarian",
       result: "allow",
@@ -109,12 +121,12 @@ describe("handleInput decision events — skill gate", () => {
   });
 
   it("emits deny with policy_deny for a denied skill", async () => {
-    const deps = makeDeps("deny");
-    await handleInput(deps, { text: "/skill:restricted" }, makeCtx());
+    const { handler, events } = makeHandler("deny");
+    await handler.handleInput({ text: "/skill:restricted" }, makeCtx());
 
-    const events = getDecisionEvents(deps);
-    expect(events).toHaveLength(1);
-    expect(events[0]).toMatchObject({
+    const decisions = getDecisionEvents(events);
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0]).toMatchObject({
       surface: "skill",
       value: "restricted",
       result: "deny",
@@ -123,16 +135,14 @@ describe("handleInput decision events — skill gate", () => {
   });
 
   it("emits allow with user_approved when state=ask and user approves", async () => {
-    const deps = makeDeps("ask", {
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: true, state: "approved" }),
+    const { handler, events } = makeHandler("ask", {
+      prompt: vi.fn().mockResolvedValue({ approved: true, state: "approved" }),
     });
-    await handleInput(deps, { text: "/skill:explorer" }, makeCtx());
+    await handler.handleInput({ text: "/skill:explorer" }, makeCtx());
 
-    const events = getDecisionEvents(deps);
-    expect(events).toHaveLength(1);
-    expect(events[0]).toMatchObject({
+    const decisions = getDecisionEvents(events);
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0]).toMatchObject({
       surface: "skill",
       value: "explorer",
       result: "allow",
@@ -141,16 +151,14 @@ describe("handleInput decision events — skill gate", () => {
   });
 
   it("emits deny with user_denied when state=ask and user denies", async () => {
-    const deps = makeDeps("ask", {
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: false, state: "denied" }),
+    const { handler, events } = makeHandler("ask", {
+      prompt: vi.fn().mockResolvedValue({ approved: false, state: "denied" }),
     });
-    await handleInput(deps, { text: "/skill:explorer" }, makeCtx());
+    await handler.handleInput({ text: "/skill:explorer" }, makeCtx());
 
-    const events = getDecisionEvents(deps);
-    expect(events).toHaveLength(1);
-    expect(events[0]).toMatchObject({
+    const decisions = getDecisionEvents(events);
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0]).toMatchObject({
       surface: "skill",
       value: "explorer",
       result: "deny",
@@ -159,18 +167,17 @@ describe("handleInput decision events — skill gate", () => {
   });
 
   it("emits deny with confirmation_unavailable when state=ask but no UI", async () => {
-    const deps = makeDeps("ask", {
-      canRequestPermissionConfirmation: vi.fn().mockReturnValue(false),
+    const { handler, events } = makeHandler("ask", {
+      canPrompt: vi.fn().mockReturnValue(false),
     });
-    await handleInput(
-      deps,
+    await handler.handleInput(
       { text: "/skill:explorer" },
       makeCtx({ hasUI: false }),
     );
 
-    const events = getDecisionEvents(deps);
-    expect(events).toHaveLength(1);
-    expect(events[0]).toMatchObject({
+    const decisions = getDecisionEvents(events);
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0]).toMatchObject({
       surface: "skill",
       value: "explorer",
       result: "deny",
@@ -178,19 +185,19 @@ describe("handleInput decision events — skill gate", () => {
     });
   });
 
-  it("emits allow with auto_approved when promptPermission returns autoApproved:true", async () => {
-    const deps = makeDeps("ask", {
-      promptPermission: vi.fn().mockResolvedValue({
+  it("emits allow with auto_approved when prompt returns autoApproved:true", async () => {
+    const { handler, events } = makeHandler("ask", {
+      prompt: vi.fn().mockResolvedValue({
         approved: true,
         state: "approved",
         autoApproved: true,
       }),
     });
-    await handleInput(deps, { text: "/skill:explorer" }, makeCtx());
+    await handler.handleInput({ text: "/skill:explorer" }, makeCtx());
 
-    const events = getDecisionEvents(deps);
-    expect(events).toHaveLength(1);
-    expect(events[0]).toMatchObject({
+    const decisions = getDecisionEvents(events);
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0]).toMatchObject({
       surface: "skill",
       value: "explorer",
       result: "allow",