@gotgenes/pi-permission-system 10.3.1 → 10.5.0

package/test/permission-resolver.test.ts

@@ -0,0 +1,194 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ScopedPermissionManager } from "#src/permission-manager";
+import { PermissionResolver } from "#src/permission-resolver";
+import type { Ruleset } from "#src/rule";
+import { SessionApproval } from "#src/session-approval";
+import { SessionRules } from "#src/session-rules";
+import type { PermissionCheckResult, PermissionState } from "#src/types";
+
+function makePermissionManager() {
+  return {
+    configureForCwd: vi.fn<(cwd: string | undefined | null) => void>(),
+    checkPermission: vi
+      .fn<
+        (
+          toolName: string,
+          input: unknown,
+          agentName?: string,
+          sessionRules?: Ruleset,
+        ) => PermissionCheckResult
+      >()
+      .mockReturnValue({
+        state: "allow",
+        toolName: "read",
+        source: "tool",
+        origin: "builtin",
+      }),
+    getToolPermission: vi
+      .fn<(toolName: string, agentName?: string) => PermissionState>()
+      .mockReturnValue("allow"),
+    getConfigIssues: vi.fn((): string[] => []),
+    getPolicyCacheStamp: vi.fn((): string => "stamp-1"),
+  };
+}
+
+function makeResolver(
+  pm?: ScopedPermissionManager,
+  sessionRules?: Pick<SessionRules, "getRuleset">,
+) {
+  const permissionManager = pm ?? makePermissionManager();
+  const rules = sessionRules ?? new SessionRules();
+  return {
+    resolver: new PermissionResolver(permissionManager, rules),
+    permissionManager,
+  };
+}
+
+beforeEach(() => {
+  // no module-level vi.fn() stubs to reset
+});
+
+describe("PermissionResolver", () => {
+  describe("resolve", () => {
+    it("forwards surface, input, and agentName, applying the empty session ruleset", () => {
+      const { resolver, permissionManager } = makeResolver();
+
+      resolver.resolve("bash", { command: "ls" }, "agent-x");
+
+      expect(permissionManager.checkPermission).toHaveBeenCalledWith(
+        "bash",
+        { command: "ls" },
+        "agent-x",
+        [],
+      );
+    });
+
+    it("defaults agentName to undefined when omitted", () => {
+      const { resolver, permissionManager } = makeResolver();
+
+      resolver.resolve("read", { path: ".env" });
+
+      expect(permissionManager.checkPermission).toHaveBeenCalledWith(
+        "read",
+        { path: ".env" },
+        undefined,
+        [],
+      );
+    });
+
+    it("applies a recorded session approval on the next resolve", () => {
+      const pm = makePermissionManager();
+      const sessionRules = new SessionRules();
+      const { resolver } = makeResolver(pm, sessionRules);
+
+      // Record an approval directly into the shared SessionRules instance.
+      sessionRules.record(SessionApproval.single("bash", "git *"));
+      resolver.resolve("bash", { command: "git status" });
+
+      const passedRules = vi.mocked(pm.checkPermission).mock.calls[0][3];
+      expect(passedRules).toHaveLength(1);
+      expect(passedRules?.[0]).toMatchObject({
+        surface: "bash",
+        pattern: "git *",
+        action: "allow",
+      });
+    });
+
+    it("returns the PermissionManager's check result", () => {
+      const pm = makePermissionManager();
+      vi.mocked(pm.checkPermission).mockReturnValue({
+        state: "deny",
+        toolName: "bash",
+        source: "bash",
+        origin: "global",
+        matchedPattern: "rm *",
+      });
+      const { resolver } = makeResolver(pm);
+
+      const result = resolver.resolve("bash", { command: "rm -rf /" });
+
+      expect(result).toEqual({
+        state: "deny",
+        toolName: "bash",
+        source: "bash",
+        origin: "global",
+        matchedPattern: "rm *",
+      });
+    });
+  });
+
+  describe("checkPermission", () => {
+    it("delegates to permissionManager.checkPermission with the given args", () => {
+      const { resolver, permissionManager } = makeResolver();
+
+      resolver.checkPermission("bash", { command: "ls" }, "agent-1");
+
+      expect(permissionManager.checkPermission).toHaveBeenCalledWith(
+        "bash",
+        { command: "ls" },
+        "agent-1",
+        undefined,
+      );
+    });
+
+    it("passes optional sessionRules through when supplied", () => {
+      const { resolver, permissionManager } = makeResolver();
+      const extraRules: Ruleset = [
+        { surface: "bash", pattern: "*", action: "allow", origin: "session" },
+      ];
+
+      resolver.checkPermission(
+        "bash",
+        { command: "ls" },
+        undefined,
+        extraRules,
+      );
+
+      expect(permissionManager.checkPermission).toHaveBeenCalledWith(
+        "bash",
+        { command: "ls" },
+        undefined,
+        extraRules,
+      );
+    });
+  });
+
+  describe("getToolPermission", () => {
+    it("delegates to permissionManager.getToolPermission", () => {
+      const pm = makePermissionManager();
+      vi.mocked(pm.getToolPermission).mockReturnValue("deny");
+      const { resolver } = makeResolver(pm);
+
+      const result = resolver.getToolPermission("write", "my-agent");
+
+      expect(pm.getToolPermission).toHaveBeenCalledWith("write", "my-agent");
+      expect(result).toBe("deny");
+    });
+  });
+
+  describe("getConfigIssues", () => {
+    it("delegates to permissionManager.getConfigIssues", () => {
+      const pm = makePermissionManager();
+      vi.mocked(pm.getConfigIssues).mockReturnValue(["issue-1"]);
+      const { resolver } = makeResolver(pm);
+
+      const result = resolver.getConfigIssues("agent-1");
+
+      expect(pm.getConfigIssues).toHaveBeenCalledWith("agent-1");
+      expect(result).toEqual(["issue-1"]);
+    });
+  });
+
+  describe("getPolicyCacheStamp", () => {
+    it("delegates to permissionManager.getPolicyCacheStamp", () => {
+      const pm = makePermissionManager();
+      vi.mocked(pm.getPolicyCacheStamp).mockReturnValue("stamp-abc");
+      const { resolver } = makeResolver(pm);
+
+      const result = resolver.getPolicyCacheStamp("agent-1");
+
+      expect(pm.getPolicyCacheStamp).toHaveBeenCalledWith("agent-1");
+      expect(result).toBe("stamp-abc");
+    });
+  });
+});

package/test/permission-session.test.ts

@@ -22,10 +22,8 @@ import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
 import type { ExtensionPaths } from "#src/extension-paths";
 import type { ForwardingController } from "#src/forwarding-manager";
 import type { ScopedPermissionManager } from "#src/permission-manager";
-import {
-  PermissionSession,
-  type PermissionSessionRuntimeDeps,
-} from "#src/permission-session";
+import { PermissionSession } from "#src/permission-session";
+import type { PromptingGatewayLifecycle } from "#src/prompting-gateway";
 import type { Ruleset } from "#src/rule";
 import { SessionApproval } from "#src/session-approval";
 import type { SessionLogger } from "#src/session-logger";
@@ -83,12 +81,10 @@ function makeConfigStore(
   };
 }
 
-function makeRuntimeDeps(): PermissionSessionRuntimeDeps {
+function makeGateway(): PromptingGatewayLifecycle {
   return {
-    canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
-    promptPermission: vi
-      .fn()
-      .mockResolvedValue({ approved: true, state: "approved" }),
+    activate: vi.fn<PromptingGatewayLifecycle["activate"]>(),
+    deactivate: vi.fn<PromptingGatewayLifecycle["deactivate"]>(),
   };
 }
 
@@ -132,7 +128,7 @@ function createSession(overrides?: {
   permissionManager?: ScopedPermissionManager;
   sessionRules?: SessionRules;
   configStore?: SessionConfigStore;
-  runtimeDeps?: PermissionSessionRuntimeDeps;
+  gateway?: PromptingGatewayLifecycle;
 }): {
   session: PermissionSession;
   paths: ExtensionPaths;
@@ -140,7 +136,7 @@ function createSession(overrides?: {
   forwarding: ForwardingController;
   sessionRules: SessionRules;
   configStore: SessionConfigStore;
-  runtimeDeps: PermissionSessionRuntimeDeps;
+  gateway: PromptingGatewayLifecycle;
 } {
   const paths = makePaths(overrides?.paths);
   const logger = overrides?.logger ?? makeLogger();
@@ -149,7 +145,7 @@ function createSession(overrides?: {
     overrides?.permissionManager ?? makePermissionManager();
   const sessionRules = overrides?.sessionRules ?? new SessionRules();
   const configStore = overrides?.configStore ?? makeConfigStore();
-  const runtimeDeps = overrides?.runtimeDeps ?? makeRuntimeDeps();
+  const gateway = overrides?.gateway ?? makeGateway();
   const session = new PermissionSession(
     paths,
     logger,
@@ -157,7 +153,7 @@ function createSession(overrides?: {
     permissionManager,
     sessionRules,
     configStore,
-    runtimeDeps,
+    gateway,
   );
   return {
     session,
@@ -166,7 +162,7 @@ function createSession(overrides?: {
     forwarding,
     sessionRules,
     configStore,
-    runtimeDeps,
+    gateway,
   };
 }
 
@@ -244,74 +240,6 @@ describe("PermissionSession", () => {
     });
   });
 
-  describe("resolve", () => {
-    it("forwards surface, input, and agentName, applying the empty session ruleset", () => {
-      const pm = makePermissionManager();
-      const { session } = createSession({ permissionManager: pm });
-
-      session.resolve("bash", { command: "ls" }, "agent-x");
-
-      expect(pm.checkPermission).toHaveBeenCalledWith(
-        "bash",
-        { command: "ls" },
-        "agent-x",
-        [],
-      );
-    });
-
-    it("defaults agentName to undefined when omitted", () => {
-      const pm = makePermissionManager();
-      const { session } = createSession({ permissionManager: pm });
-
-      session.resolve("read", { path: ".env" });
-
-      expect(pm.checkPermission).toHaveBeenCalledWith(
-        "read",
-        { path: ".env" },
-        undefined,
-        [],
-      );
-    });
-
-    it("applies a recorded session approval on the next resolve", () => {
-      const pm = makePermissionManager();
-      const { session } = createSession({ permissionManager: pm });
-
-      session.recordSessionApproval(SessionApproval.single("bash", "git *"));
-      session.resolve("bash", { command: "git status" });
-
-      const sessionRules = vi.mocked(pm.checkPermission).mock.calls[0][3];
-      expect(sessionRules).toHaveLength(1);
-      expect(sessionRules?.[0]).toMatchObject({
-        surface: "bash",
-        pattern: "git *",
-        action: "allow",
-      });
-    });
-
-    it("returns the PermissionManager's check result", () => {
-      const pm = makePermissionManager();
-      vi.mocked(pm.checkPermission).mockReturnValue({
-        state: "deny",
-        toolName: "bash",
-        source: "bash",
-        origin: "global",
-        matchedPattern: "rm *",
-      });
-      const { session } = createSession({ permissionManager: pm });
-
-      const result = session.resolve("bash", { command: "rm -rf /" });
-
-      expect(result).toEqual({
-        state: "deny",
-        toolName: "bash",
-        source: "bash",
-        origin: "global",
-        matchedPattern: "rm *",
-      });
-    });
-  });
-
   describe("activate and deactivate", () => {
     it("stores the context on activate", () => {
       const { session, forwarding } = createSession();
@@ -329,6 +257,23 @@ describe("PermissionSession", () => {
 
       expect(forwarding.stop).toHaveBeenCalled();
     });
+
+    it("forwards activate to the gateway", () => {
+      const { session, gateway } = createSession();
+      const ctx = makeCtx();
+
+      session.activate(ctx);
+
+      expect(gateway.activate).toHaveBeenCalledWith(ctx);
+    });
+
+    it("forwards deactivate to the gateway", () => {
+      const { session, gateway } = createSession();
+      session.activate(makeCtx());
+      session.deactivate();
+
+      expect(gateway.deactivate).toHaveBeenCalled();
+    });
   });
 
   describe("resetForNewSession", () => {
@@ -627,102 +572,4 @@ describe("PermissionSession", () => {
       expect(session.getRuntimeContext()).toBeNull();
     });
   });
-
-  describe("canConfirm", () => {
-    it("returns true when context is active and canPrompt returns true", () => {
-      const { session } = createSession();
-      session.activate(makeCtx());
-      expect(session.canConfirm()).toBe(true);
-    });
-
-    it("returns false when no context is active", () => {
-      const { session } = createSession();
-      expect(session.canConfirm()).toBe(false);
-    });
-
-    it("returns false when canPrompt returns false", () => {
-      const runtimeDeps = makeRuntimeDeps();
-      (
-        runtimeDeps.canRequestPermissionConfirmation as ReturnType<typeof vi.fn>
-      ).mockReturnValue(false);
-      const { session } = createSession({ runtimeDeps });
-      session.activate(makeCtx());
-      expect(session.canConfirm()).toBe(false);
-    });
-  });
-
-  describe("promptPermission", () => {
-    it("delegates to prompt with stored context", async () => {
-      const { session, runtimeDeps } = createSession();
-      const ctx = makeCtx();
-      session.activate(ctx);
-      const details = {
-        requestId: "req-1",
-        source: "tool_call" as const,
-        agentName: null,
-        message: "Allow?",
-      };
-
-      const result = await session.promptPermission(details);
-
-      expect(runtimeDeps.promptPermission).toHaveBeenCalledWith(ctx, details);
-      expect(result).toEqual({ approved: true, state: "approved" });
-    });
-
-    it("throws when no context is active", async () => {
-      const { session } = createSession();
-      const details = {
-        requestId: "req-1",
-        source: "tool_call" as const,
-        agentName: null,
-        message: "Allow?",
-      };
-
-      await expect(session.promptPermission(details)).rejects.toThrow(
-        "promptPermission called before the session was activated",
-      );
-    });
-  });
-
-  describe("canPrompt", () => {
-    it("delegates to runtimeDeps.canRequestPermissionConfirmation", () => {
-      const { session, runtimeDeps } = createSession();
-      const ctx = makeCtx();
-
-      const result = session.canPrompt(ctx);
-
-      expect(runtimeDeps.canRequestPermissionConfirmation).toHaveBeenCalledWith(
-        ctx,
-      );
-      expect(result).toBe(true);
-    });
-
-    it("returns false when runtimeDeps says no", () => {
-      const runtimeDeps = makeRuntimeDeps();
-      (
-        runtimeDeps.canRequestPermissionConfirmation as ReturnType<typeof vi.fn>
-      ).mockReturnValue(false);
-      const { session } = createSession({ runtimeDeps });
-
-      expect(session.canPrompt(makeCtx())).toBe(false);
-    });
-  });
-
-  describe("prompt", () => {
-    it("delegates to runtimeDeps.promptPermission", async () => {
-      const { session, runtimeDeps } = createSession();
-      const ctx = makeCtx();
-      const details = {
-        requestId: "req-1",
-        source: "tool_call" as const,
-        agentName: null,
-        message: "Allow?",
-      };
-
-      const result = await session.prompt(ctx, details);
-
-      expect(runtimeDeps.promptPermission).toHaveBeenCalledWith(ctx, details);
-      expect(result).toEqual({ approved: true, state: "approved" });
-    });
-  });
 });

package/test/prompting-gateway.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Unit tests for PromptingGateway.
+ *
+ * The gateway owns the stored ExtensionContext and is the sole implementation
+ * of the GatePrompter role. These tests exercise canConfirm() across all
+ * policy permutations and verify the prompt/reject contract for promptPermission().
+ */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import type { ConfigReader } from "#src/config-store";
+import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
+import type { PermissionPromptDecision } from "#src/permission-dialog";
+import type {
+  PermissionPrompterApi,
+  PromptPermissionDetails,
+} from "#src/permission-prompter";
+import {
+  PromptingGateway,
+  type PromptingGatewayDeps,
+} from "#src/prompting-gateway";
+
+// ── Test helpers ──────────────────────────────────────────────────────────
+
+function makeCtx(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
+  return {
+    cwd: "/test/project",
+    hasUI: true,
+    ui: {
+      setStatus: vi.fn(),
+      notify: vi.fn(),
+      select: vi.fn(),
+      input: vi.fn(),
+    },
+    sessionManager: {
+      getEntries: vi.fn().mockReturnValue([]),
+      getSessionDir: vi.fn().mockReturnValue("/sessions/test"),
+      getSessionId: vi.fn().mockReturnValue(null),
+      addEntry: vi.fn(),
+    },
+    ...overrides,
+  } as unknown as ExtensionContext;
+}
+
+function makeConfigReader(
+  overrides: Partial<typeof DEFAULT_EXTENSION_CONFIG> = {},
+): ConfigReader {
+  return {
+    current: vi
+      .fn<() => typeof DEFAULT_EXTENSION_CONFIG>()
+      .mockReturnValue({ ...DEFAULT_EXTENSION_CONFIG, ...overrides }),
+  };
+}
+
+function makePrompterApi(): PermissionPrompterApi & {
+  prompt: ReturnType<typeof vi.fn>;
+} {
+  return {
+    prompt: vi
+      .fn<PermissionPrompterApi["prompt"]>()
+      .mockResolvedValue({ approved: true, state: "approved" }),
+  };
+}
+
+function makeDetails(): PromptPermissionDetails {
+  return {
+    requestId: "req-1",
+    source: "tool_call",
+    agentName: null,
+    message: "Allow this?",
+  };
+}
+
+function makeDeps(
+  overrides: Partial<PromptingGatewayDeps> = {},
+): PromptingGatewayDeps {
+  return {
+    config: overrides.config ?? makeConfigReader(),
+    subagentSessionsDir:
+      overrides.subagentSessionsDir ?? "/test/agent/subagent-sessions",
+    registry: overrides.registry,
+    prompter: overrides.prompter ?? makePrompterApi(),
+  };
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────
+
+describe("PromptingGateway", () => {
+  describe("canConfirm", () => {
+    it("returns false before activate", () => {
+      const gateway = new PromptingGateway(makeDeps());
+      expect(gateway.canConfirm()).toBe(false);
+    });
+
+    it("returns true after activate when context has UI", () => {
+      const gateway = new PromptingGateway(makeDeps());
+      gateway.activate(makeCtx({ hasUI: true }));
+      expect(gateway.canConfirm()).toBe(true);
+    });
+
+    it("returns false when context has no UI, is not a subagent, and yolo mode is off", () => {
+      const gateway = new PromptingGateway(
+        makeDeps({ config: makeConfigReader({ yoloMode: false }) }),
+      );
+      gateway.activate(makeCtx({ hasUI: false }));
+      expect(gateway.canConfirm()).toBe(false);
+    });
+
+    it("returns true when yolo mode is enabled (no UI, not subagent)", () => {
+      const gateway = new PromptingGateway(
+        makeDeps({ config: makeConfigReader({ yoloMode: true }) }),
+      );
+      gateway.activate(makeCtx({ hasUI: false }));
+      expect(gateway.canConfirm()).toBe(true);
+    });
+
+    it("returns true when running as a subagent (env hint)", () => {
+      vi.stubEnv("PI_IS_SUBAGENT", "1");
+      const gateway = new PromptingGateway(
+        makeDeps({ config: makeConfigReader({ yoloMode: false }) }),
+      );
+      gateway.activate(makeCtx({ hasUI: false }));
+      expect(gateway.canConfirm()).toBe(true);
+      vi.unstubAllEnvs();
+    });
+
+    it("returns false after deactivate", () => {
+      const gateway = new PromptingGateway(makeDeps());
+      gateway.activate(makeCtx({ hasUI: true }));
+      gateway.deactivate();
+      expect(gateway.canConfirm()).toBe(false);
+    });
+
+    it("returns true after re-activate following deactivate", () => {
+      const gateway = new PromptingGateway(makeDeps());
+      gateway.activate(makeCtx({ hasUI: true }));
+      gateway.deactivate();
+      gateway.activate(makeCtx({ hasUI: true }));
+      expect(gateway.canConfirm()).toBe(true);
+    });
+  });
+
+  describe("prompt", () => {
+    it("rejects before activate", async () => {
+      const gateway = new PromptingGateway(makeDeps());
+      await expect(gateway.prompt(makeDetails())).rejects.toThrow(
+        "prompt called before the session was activated",
+      );
+    });
+
+    it("delegates to deps.prompter.prompt with the stored context", async () => {
+      const prompter = makePrompterApi();
+      const gateway = new PromptingGateway(makeDeps({ prompter }));
+      const ctx = makeCtx();
+      gateway.activate(ctx);
+      const details = makeDetails();
+
+      const result = await gateway.prompt(details);
+
+      expect(prompter.prompt).toHaveBeenCalledWith(ctx, details);
+      expect(result).toEqual({ approved: true, state: "approved" });
+    });
+
+    it("uses the most recently activated context", async () => {
+      const prompter = makePrompterApi();
+      const gateway = new PromptingGateway(makeDeps({ prompter }));
+      const firstCtx = makeCtx({ cwd: "/first" });
+      const secondCtx = makeCtx({ cwd: "/second" });
+
+      gateway.activate(firstCtx);
+      gateway.activate(secondCtx);
+
+      await gateway.prompt(makeDetails());
+
+      expect(prompter.prompt).toHaveBeenCalledWith(
+        secondCtx,
+        expect.anything(),
+      );
+    });
+
+    it("rejects after deactivate", async () => {
+      const gateway = new PromptingGateway(makeDeps());
+      gateway.activate(makeCtx());
+      gateway.deactivate();
+      await expect(gateway.prompt(makeDetails())).rejects.toThrow(
+        "prompt called before the session was activated",
+      );
+    });
+
+    it("returns the prompter decision", async () => {
+      const decision: PermissionPromptDecision = {
+        approved: false,
+        state: "denied",
+        denialReason: "user declined",
+      };
+      const prompter = makePrompterApi();
+      prompter.prompt.mockResolvedValue(decision);
+      const gateway = new PromptingGateway(makeDeps({ prompter }));
+      gateway.activate(makeCtx());
+
+      const result = await gateway.prompt(makeDetails());
+
+      expect(result).toEqual(decision);
+    });
+  });
+
+  describe("lifecycle", () => {
+    afterEach(() => {
+      vi.unstubAllEnvs();
+    });
+
+    it("activate then deactivate clears the stored context", () => {
+      const gateway = new PromptingGateway(makeDeps());
+      gateway.activate(makeCtx());
+      gateway.deactivate();
+      expect(gateway.canConfirm()).toBe(false);
+    });
+
+    it("multiple activate calls update the stored context", () => {
+      const prompter = makePrompterApi();
+      const gateway = new PromptingGateway(makeDeps({ prompter }));
+      const ctx2 = makeCtx({ cwd: "/new" });
+      gateway.activate(makeCtx({ cwd: "/old" }));
+      gateway.activate(ctx2);
+
+      // canConfirm still works (context set)
+      expect(gateway.canConfirm()).toBe(true);
+    });
+  });
+});