@gotgenes/pi-permission-system 5.10.0 → 5.11.0

package/tests/handlers/input.test.ts

@@ -3,10 +3,10 @@ import { describe, expect, it, vi } from "vitest";
 
 import {
   extractSkillNameFromInput,
-  handleInput,
-} from "../../src/handlers/input";
-import type { HandlerDeps } from "../../src/handlers/types";
+  PermissionGateHandler,
+} from "../../src/handlers/permission-gate-handler";
 import type { PermissionSession } from "../../src/permission-session";
+import type { ToolRegistry } from "../../src/tool-registry";
 import type { PermissionState } from "../../src/types";
 
 // ── helpers ────────────────────────────────────────────────────────────────
@@ -45,26 +45,40 @@ 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(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
+function makeEvents() {
   return {
-    session: makeSession(),
-    events: { emit: vi.fn(), on: vi.fn().mockReturnValue(() => undefined) },
-    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,
+    emit: vi.fn(),
+    on: vi.fn().mockReturnValue(() => undefined),
+  };
+}
+
+function makeToolRegistry(): ToolRegistry {
+  return {
+    getAll: vi.fn().mockReturnValue([]),
+    setActive: vi.fn(),
   };
 }
 
+function makeHandler(overrides?: {
+  session?: Partial<Record<keyof PermissionSession, unknown>>;
+}): {
+  handler: PermissionGateHandler;
+  session: PermissionSession;
+} {
+  const session = makeSession(overrides?.session);
+  const events = makeEvents();
+  const toolRegistry = makeToolRegistry();
+  const handler = new PermissionGateHandler(session, events, toolRegistry);
+  return { handler, session };
+}
+
 // ── extractSkillNameFromInput ──────────────────────────────────────────────
 
 describe("extractSkillNameFromInput", () => {
@@ -104,15 +118,14 @@ describe("extractSkillNameFromInput", () => {
 describe("handleInput", () => {
   it("activates session with ctx", async () => {
     const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleInput(deps, makeInputEvent("hello"), ctx);
-    expect(deps.session.activate).toHaveBeenCalledWith(ctx);
+    const { handler, session } = makeHandler();
+    await handler.handleInput(makeInputEvent("hello"), ctx);
+    expect(session.activate).toHaveBeenCalledWith(ctx);
   });
 
   it("returns continue for non-skill input", async () => {
-    const deps = makeDeps();
-    const result = await handleInput(
-      deps,
+    const { handler } = makeHandler();
+    const result = await handler.handleInput(
       makeInputEvent("just a message"),
       makeCtx(),
     );
@@ -120,15 +133,14 @@ describe("handleInput", () => {
   });
 
   it("does not check permissions for non-skill input", async () => {
-    const deps = makeDeps();
-    await handleInput(deps, makeInputEvent("just a message"), makeCtx());
-    expect(deps.session.checkPermission).not.toHaveBeenCalled();
+    const { handler, session } = makeHandler();
+    await handler.handleInput(makeInputEvent("just a message"), makeCtx());
+    expect(session.checkPermission).not.toHaveBeenCalled();
   });
 
   it("returns continue when skill is allowed", async () => {
-    const deps = makeDeps();
-    const result = await handleInput(
-      deps,
+    const { handler } = makeHandler();
+    const result = await handler.handleInput(
       makeInputEvent("/skill:librarian"),
       makeCtx(),
     );
@@ -136,12 +148,12 @@ describe("handleInput", () => {
   });
 
   it("returns handled when skill is denied", async () => {
-    const session = makeSession({
-      checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+    const { handler } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      },
     });
-    const deps = makeDeps({ session });
-    const result = await handleInput(
-      deps,
+    const result = await handler.handleInput(
       makeInputEvent("/skill:librarian"),
       makeCtx(),
     );
@@ -150,11 +162,12 @@ describe("handleInput", () => {
 
   it("shows a warning notification when skill is denied and UI is available", async () => {
     const ctx = makeCtx({ hasUI: true });
-    const session = makeSession({
-      checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+    const { handler } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      },
     });
-    const deps = makeDeps({ session });
-    await handleInput(deps, makeInputEvent("/skill:librarian"), ctx);
+    await handler.handleInput(makeInputEvent("/skill:librarian"), ctx);
     expect(ctx.ui.notify).toHaveBeenCalledWith(
       expect.stringContaining("librarian"),
       "warning",
@@ -163,24 +176,23 @@ describe("handleInput", () => {
 
   it("does not show a warning notification when skill is denied and UI is absent", async () => {
     const ctx = makeCtx({ hasUI: false });
-    const session = makeSession({
-      checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+    const { handler } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      },
     });
-    const deps = makeDeps({ session });
-    await handleInput(deps, makeInputEvent("/skill:librarian"), ctx);
+    await handler.handleInput(makeInputEvent("/skill:librarian"), ctx);
     expect(ctx.ui.notify).not.toHaveBeenCalled();
   });
 
   it("returns handled when skill requires approval but no UI is available", async () => {
-    const session = makeSession({
-      checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
-    });
-    const deps = makeDeps({
-      session,
-      canRequestPermissionConfirmation: vi.fn().mockReturnValue(false),
+    const { handler } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+        canPrompt: vi.fn().mockReturnValue(false),
+      },
     });
-    const result = await handleInput(
-      deps,
+    const result = await handler.handleInput(
       makeInputEvent("/skill:librarian"),
       makeCtx(),
     );
@@ -188,38 +200,30 @@ describe("handleInput", () => {
   });
 
   it("prompts and returns continue when skill ask is approved", async () => {
-    const session = makeSession({
-      checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+    const { handler, session } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+        prompt: vi
+          .fn()
+          .mockResolvedValue({ approved: true, state: "approved" }),
+      },
     });
-    const deps = makeDeps({
-      session,
-      canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: true, state: "approved" }),
-    });
-    const result = await handleInput(
-      deps,
+    const result = await handler.handleInput(
       makeInputEvent("/skill:librarian"),
       makeCtx(),
     );
     expect(result).toEqual({ action: "continue" });
-    expect(deps.promptPermission).toHaveBeenCalledOnce();
+    expect(session.prompt).toHaveBeenCalledOnce();
   });
 
   it("returns handled when skill ask is denied by user", async () => {
-    const session = makeSession({
-      checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
-    });
-    const deps = makeDeps({
-      session,
-      canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: false, state: "denied" }),
+    const { handler } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+        prompt: vi.fn().mockResolvedValue({ approved: false, state: "denied" }),
+      },
     });
-    const result = await handleInput(
-      deps,
+    const result = await handler.handleInput(
       makeInputEvent("/skill:librarian"),
       makeCtx(),
     );
@@ -227,19 +231,17 @@ describe("handleInput", () => {
   });
 
   it("passes agentName in the prompt permission request", async () => {
-    const session = makeSession({
-      checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
-      resolveAgentName: vi.fn().mockReturnValue("code-agent"),
-    });
-    const deps = makeDeps({
-      session,
-      canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: true, state: "approved" }),
+    const { handler, session } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+        resolveAgentName: vi.fn().mockReturnValue("code-agent"),
+        prompt: vi
+          .fn()
+          .mockResolvedValue({ approved: true, state: "approved" }),
+      },
     });
-    await handleInput(deps, makeInputEvent("/skill:librarian"), makeCtx());
-    expect(deps.promptPermission).toHaveBeenCalledWith(
+    await handler.handleInput(makeInputEvent("/skill:librarian"), makeCtx());
+    expect(session.prompt).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
         agentName: "code-agent",

package/tests/handlers/lifecycle.test.ts

@@ -1,11 +1,6 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  handleResourcesDiscover,
-  handleSessionShutdown,
-  handleSessionStart,
-} from "../../src/handlers/lifecycle";
-import type { HandlerDeps } from "../../src/handlers/types";
+import { describe, expect, it, vi } from "vitest";
+import { SessionLifecycleHandler } from "../../src/handlers/lifecycle";
 import type { PermissionSession } from "../../src/permission-session";
 
 // ── status stub ────────────────────────────────────────────────────────────
@@ -53,20 +48,17 @@ function makeSession(
   } as unknown as PermissionSession;
 }
 
-function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
-  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(),
-    ...overrides,
-  };
+function makeHandler(
+  overrides?: Partial<Record<keyof PermissionSession, unknown>>,
+): {
+  handler: SessionLifecycleHandler;
+  session: PermissionSession;
+  cleanupRpc: ReturnType<typeof vi.fn>;
+} {
+  const session = makeSession(overrides);
+  const cleanupRpc = vi.fn();
+  const handler = new SessionLifecycleHandler(session, cleanupRpc);
+  return { handler, session, cleanupRpc };
 }
 
 // ── handleSessionStart ─────────────────────────────────────────────────────
@@ -74,52 +66,51 @@ function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
 describe("handleSessionStart", () => {
   it("refreshes config with ctx", async () => {
     const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleSessionStart(deps, { reason: "startup" }, ctx);
-    expect(deps.session.refreshConfig).toHaveBeenCalledWith(ctx);
+    const { handler, session } = makeHandler();
+    await handler.handleSessionStart({ reason: "startup" }, ctx);
+    expect(session.refreshConfig).toHaveBeenCalledWith(ctx);
   });
 
   it("calls resetForNewSession with ctx", async () => {
     const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleSessionStart(deps, { reason: "startup" }, ctx);
-    expect(deps.session.resetForNewSession).toHaveBeenCalledWith(ctx);
+    const { handler, session } = makeHandler();
+    await handler.handleSessionStart({ reason: "startup" }, ctx);
+    expect(session.resetForNewSession).toHaveBeenCalledWith(ctx);
   });
 
   it("logs resolved config paths", async () => {
-    const deps = makeDeps();
-    await handleSessionStart(deps, { reason: "startup" }, makeCtx());
-    expect(deps.session.logResolvedConfigPaths).toHaveBeenCalledOnce();
+    const { handler, session } = makeHandler();
+    await handler.handleSessionStart({ reason: "startup" }, makeCtx());
+    expect(session.logResolvedConfigPaths).toHaveBeenCalledOnce();
   });
 
   it("resolves agent name from ctx", async () => {
     const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleSessionStart(deps, { reason: "startup" }, ctx);
-    expect(deps.session.resolveAgentName).toHaveBeenCalledWith(ctx);
+    const { handler, session } = makeHandler();
+    await handler.handleSessionStart({ reason: "startup" }, ctx);
+    expect(session.resolveAgentName).toHaveBeenCalledWith(ctx);
   });
 
   it("notifies each policy issue", async () => {
-    const session = makeSession({
+    const { handler, session } = makeHandler({
       getConfigIssues: vi.fn().mockReturnValue(["issue A", "issue B"]),
     });
-    const deps = makeDeps({ session });
-    await handleSessionStart(deps, { reason: "startup" }, makeCtx());
+    await handler.handleSessionStart({ reason: "startup" }, makeCtx());
     expect(session.logger.warn).toHaveBeenCalledWith("issue A");
     expect(session.logger.warn).toHaveBeenCalledWith("issue B");
   });
 
   it("does not warn when there are no policy issues", async () => {
-    const deps = makeDeps();
-    await handleSessionStart(deps, { reason: "startup" }, makeCtx());
-    expect(deps.session.logger.warn).not.toHaveBeenCalled();
+    const { handler, session } = makeHandler();
+    await handler.handleSessionStart({ reason: "startup" }, makeCtx());
+    expect(session.logger.warn).not.toHaveBeenCalled();
   });
 
   it("writes lifecycle.reload debug log when reason is reload", async () => {
     const ctx = makeCtx({ cwd: "/proj" });
-    const deps = makeDeps();
-    await handleSessionStart(deps, { reason: "reload" }, ctx);
-    expect(deps.session.logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
+    const { handler, session } = makeHandler();
+    await handler.handleSessionStart({ reason: "reload" }, ctx);
+    expect(session.logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
       triggeredBy: "session_start",
       reason: "reload",
       cwd: "/proj",
@@ -127,19 +118,18 @@ describe("handleSessionStart", () => {
   });
 
   it("does not write lifecycle.reload debug log for non-reload reasons", async () => {
-    const deps = makeDeps();
-    await handleSessionStart(deps, { reason: "startup" }, makeCtx());
-    expect(deps.session.logger.debug).not.toHaveBeenCalled();
+    const { handler, session } = makeHandler();
+    await handler.handleSessionStart({ reason: "startup" }, makeCtx());
+    expect(session.logger.debug).not.toHaveBeenCalled();
   });
 
   it("calls refreshConfig before resetForNewSession", async () => {
     const callOrder: string[] = [];
-    const session = makeSession({
+    const { handler } = makeHandler({
       refreshConfig: vi.fn(() => callOrder.push("refreshConfig")),
       resetForNewSession: vi.fn(() => callOrder.push("resetForNewSession")),
     });
-    const deps = makeDeps({ session });
-    await handleSessionStart(deps, { reason: "startup" }, makeCtx());
+    await handler.handleSessionStart({ reason: "startup" }, makeCtx());
     expect(callOrder).toEqual(["refreshConfig", "resetForNewSession"]);
   });
 });
@@ -148,24 +138,23 @@ describe("handleSessionStart", () => {
 
 describe("handleResourcesDiscover", () => {
   it("does nothing when reason is not reload", async () => {
-    const deps = makeDeps();
-    await handleResourcesDiscover(deps, { reason: "startup" });
-    expect(deps.session.reload).not.toHaveBeenCalled();
+    const { handler, session } = makeHandler();
+    await handler.handleResourcesDiscover({ reason: "startup" });
+    expect(session.reload).not.toHaveBeenCalled();
   });
 
   it("calls reload on the session on reload", async () => {
-    const deps = makeDeps();
-    await handleResourcesDiscover(deps, { reason: "reload" });
-    expect(deps.session.reload).toHaveBeenCalledOnce();
+    const { handler, session } = makeHandler();
+    await handler.handleResourcesDiscover({ reason: "reload" });
+    expect(session.reload).toHaveBeenCalledOnce();
   });
 
   it("writes lifecycle.reload debug log on reload", async () => {
     const ctx = makeCtx({ cwd: "/proj" });
-    const session = makeSession({
+    const { handler, session } = makeHandler({
       getRuntimeContext: vi.fn().mockReturnValue(ctx),
     });
-    const deps = makeDeps({ session });
-    await handleResourcesDiscover(deps, { reason: "reload" });
+    await handler.handleResourcesDiscover({ reason: "reload" });
     expect(session.logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
       triggeredBy: "resources_discover",
       reason: "reload",
@@ -174,9 +163,9 @@ describe("handleResourcesDiscover", () => {
   });
 
   it("logs cwd as null when runtimeContext is null on reload", async () => {
-    const deps = makeDeps();
-    await handleResourcesDiscover(deps, { reason: "reload" });
-    expect(deps.session.logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
+    const { handler, session } = makeHandler();
+    await handler.handleResourcesDiscover({ reason: "reload" });
+    expect(session.logger.debug).toHaveBeenCalledWith("lifecycle.reload", {
       triggeredBy: "resources_discover",
       reason: "reload",
       cwd: null,
@@ -189,11 +178,10 @@ describe("handleResourcesDiscover", () => {
 describe("handleSessionShutdown", () => {
   it("clears UI status when runtime context is present", async () => {
     const ctx = makeCtx();
-    const session = makeSession({
+    const { handler } = makeHandler({
       getRuntimeContext: vi.fn().mockReturnValue(ctx),
     });
-    const deps = makeDeps({ session });
-    await handleSessionShutdown(deps);
+    await handler.handleSessionShutdown();
     expect(ctx.ui.setStatus).toHaveBeenCalledWith(
       "permission-system",
       undefined,
@@ -201,19 +189,19 @@ describe("handleSessionShutdown", () => {
   });
 
   it("does not throw when runtime context is null", async () => {
-    const deps = makeDeps();
-    await expect(handleSessionShutdown(deps)).resolves.not.toThrow();
+    const { handler } = makeHandler();
+    await expect(handler.handleSessionShutdown()).resolves.not.toThrow();
   });
 
   it("calls shutdown on the session", async () => {
-    const deps = makeDeps();
-    await handleSessionShutdown(deps);
-    expect(deps.session.shutdown).toHaveBeenCalledOnce();
+    const { handler, session } = makeHandler();
+    await handler.handleSessionShutdown();
+    expect(session.shutdown).toHaveBeenCalledOnce();
   });
 
-  it("calls stopPermissionRpcHandlers", async () => {
-    const deps = makeDeps();
-    await handleSessionShutdown(deps);
-    expect(deps.stopPermissionRpcHandlers).toHaveBeenCalledOnce();
+  it("calls cleanupRpc", async () => {
+    const { handler, cleanupRpc } = makeHandler();
+    await handler.handleSessionShutdown();
+    expect(cleanupRpc).toHaveBeenCalledOnce();
   });
 });