@gotgenes/pi-permission-system 5.9.0 → 5.11.0

package/tests/handlers/input.test.ts

@@ -3,11 +3,11 @@ import { describe, expect, it, vi } from "vitest";
 
 import {
   extractSkillNameFromInput,
-  handleInput,
-} from "../../src/handlers/input";
-import type { HandlerDeps } from "../../src/handlers/types";
-import type { SessionState } from "../../src/runtime";
-import type { SkillPromptEntry } from "../../src/skill-prompt-sanitizer";
+  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 ────────────────────────────────────────────────────────────────
 
@@ -34,49 +34,51 @@ function makeInputEvent(text: string) {
   return { text };
 }
 
-function makeSession(overrides: Partial<SessionState> = {}): SessionState {
+function makeSession(
+  overrides: Partial<Record<keyof PermissionSession, unknown>> = {},
+): PermissionSession {
   return {
-    runtimeContext: null,
-    permissionManager: {
-      checkPermission: vi.fn().mockReturnValue({ state: "allow" }),
-    } as unknown as SessionState["permissionManager"],
-    activeSkillEntries: [] as SkillPromptEntry[],
-    lastKnownActiveAgentName: null,
-    lastActiveToolsCacheKey: null,
-    lastPromptStateCacheKey: null,
-    sessionRules: {
-      approve: vi.fn(),
-      getRuleset: vi.fn().mockReturnValue([]),
-      clear: vi.fn(),
-    } as unknown as SessionState["sessionRules"],
+    logger: { debug: vi.fn(), review: vi.fn(), warn: vi.fn() },
+    activate: vi.fn(),
+    resolveAgentName: vi.fn().mockReturnValue(null),
+    checkPermission: vi.fn().mockReturnValue({ state: "allow" }),
+    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 makeEvents() {
+  return {
+    emit: vi.fn(),
+    on: vi.fn().mockReturnValue(() => undefined),
   };
 }
 
-function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
+function makeToolRegistry(): ToolRegistry {
   return {
-    session: makeSession(),
-    logger: { debug: vi.fn(), review: vi.fn(), warn: vi.fn() },
-    piInfrastructureDirs: ["/test/agent", "/test/agent/git"],
-    getPiInfrastructureReadPaths: vi.fn().mockReturnValue([]),
-    createPermissionManagerForCwd: vi.fn(),
-    refreshExtensionConfig: vi.fn(),
-    logResolvedConfigPaths: vi.fn(),
-    resolveAgentName: vi.fn().mockReturnValue(null),
-    canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
-    promptPermission: vi
-      .fn()
-      .mockResolvedValue({ approved: true, state: "approved" }),
-    createPermissionRequestId: vi.fn().mockReturnValue("req-id"),
-    events: { emit: vi.fn(), on: vi.fn().mockReturnValue(() => undefined) },
-    forwarding: { start: vi.fn(), stop: vi.fn() },
-    stopPermissionRpcHandlers: vi.fn(),
-    getAllTools: vi.fn().mockReturnValue([]),
-    setActiveTools: vi.fn(),
-    ...overrides,
+    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", () => {
@@ -114,24 +116,16 @@ describe("extractSkillNameFromInput", () => {
 // ── handleInput ───────────────────────────────────────────────────────────
 
 describe("handleInput", () => {
-  it("sets runtime context", async () => {
-    const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleInput(deps, makeInputEvent("hello"), ctx);
-    expect(deps.session.runtimeContext).toBe(ctx);
-  });
-
-  it("starts forwarded permission polling", async () => {
+  it("activates session with ctx", async () => {
     const ctx = makeCtx();
-    const deps = makeDeps();
-    await handleInput(deps, makeInputEvent("hello"), ctx);
-    expect(deps.forwarding.start).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(),
     );
@@ -139,18 +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.permissionManager.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();
-    // default makeRuntime() has checkPermission → { state: "allow" }
-    const result = await handleInput(
-      deps,
+    const { handler } = makeHandler();
+    const result = await handler.handleInput(
       makeInputEvent("/skill:librarian"),
       makeCtx(),
     );
@@ -158,16 +148,12 @@ describe("handleInput", () => {
   });
 
   it("returns handled when skill is denied", async () => {
-    const pm = {
-      checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
-    };
-    const deps = makeDeps({
-      session: makeSession({
-        permissionManager: pm as unknown as SessionState["permissionManager"],
-      }),
+    const { handler } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      },
     });
-    const result = await handleInput(
-      deps,
+    const result = await handler.handleInput(
       makeInputEvent("/skill:librarian"),
       makeCtx(),
     );
@@ -176,15 +162,12 @@ describe("handleInput", () => {
 
   it("shows a warning notification when skill is denied and UI is available", async () => {
     const ctx = makeCtx({ hasUI: true });
-    const pm = {
-      checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
-    };
-    const deps = makeDeps({
-      session: makeSession({
-        permissionManager: pm as unknown as SessionState["permissionManager"],
-      }),
+    const { handler } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      },
     });
-    await handleInput(deps, makeInputEvent("/skill:librarian"), ctx);
+    await handler.handleInput(makeInputEvent("/skill:librarian"), ctx);
     expect(ctx.ui.notify).toHaveBeenCalledWith(
       expect.stringContaining("librarian"),
       "warning",
@@ -193,26 +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 pm = { checkPermission: vi.fn().mockReturnValue({ state: "deny" }) };
-    const deps = makeDeps({
-      session: makeSession({
-        permissionManager: pm as unknown as SessionState["permissionManager"],
-      }),
+    const { handler } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      },
     });
-    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 pm = { checkPermission: vi.fn().mockReturnValue({ state: "ask" }) };
-    const deps = makeDeps({
-      session: makeSession({
-        permissionManager: pm as unknown as SessionState["permissionManager"],
-      }),
-      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(),
     );
@@ -220,38 +200,30 @@ describe("handleInput", () => {
   });
 
   it("prompts and returns continue when skill ask is approved", async () => {
-    const pm = { checkPermission: vi.fn().mockReturnValue({ state: "ask" }) };
-    const deps = makeDeps({
-      session: makeSession({
-        permissionManager: pm as unknown as SessionState["permissionManager"],
-      }),
-      canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
-      promptPermission: vi
-        .fn()
-        .mockResolvedValue({ approved: true, state: "approved" }),
+    const { handler, session } = makeHandler({
+      session: {
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+        prompt: 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 pm = { checkPermission: vi.fn().mockReturnValue({ state: "ask" }) };
-    const deps = makeDeps({
-      session: makeSession({
-        permissionManager: pm as unknown as SessionState["permissionManager"],
-      }),
-      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(),
     );
@@ -259,19 +231,17 @@ describe("handleInput", () => {
   });
 
   it("passes agentName in the prompt permission request", async () => {
-    const pm = { checkPermission: vi.fn().mockReturnValue({ state: "ask" }) };
-    const deps = makeDeps({
-      session: makeSession({
-        permissionManager: pm as unknown as SessionState["permissionManager"],
-      }),
-      resolveAgentName: vi.fn().mockReturnValue("code-agent"),
-      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",