@gotgenes/pi-permission-system 4.2.0 → 4.4.0

package/tests/permission-prompter.test.ts

@@ -0,0 +1,398 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// ── Module mocks ────────────────────────────────────────────────────────────
+
+const { mockConfirmPermission } = vi.hoisted(() => ({
+  mockConfirmPermission: vi.fn(),
+}));
+
+vi.mock("../src/forwarded-permissions/polling", () => ({
+  confirmPermission: mockConfirmPermission,
+  processForwardedPermissionRequests: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ── Imports (after mocks) ───────────────────────────────────────────────────
+
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { DEFAULT_EXTENSION_CONFIG } from "../src/extension-config";
+import type { PromptPermissionDetails } from "../src/handlers/types";
+import type { PermissionPromptDecision } from "../src/permission-dialog";
+import {
+  PermissionPrompter,
+  type PermissionPrompterDeps,
+} from "../src/permission-prompter";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeCtx(hasUI: boolean): ExtensionContext {
+  return {
+    hasUI,
+    ui: { select: vi.fn(), input: vi.fn() },
+    sessionManager: { getSessionDir: vi.fn().mockReturnValue(null) },
+  } as unknown as ExtensionContext;
+}
+
+function makeDetails(
+  overrides?: Partial<PromptPermissionDetails>,
+): PromptPermissionDetails {
+  return {
+    requestId: "req-123",
+    source: "tool_call",
+    agentName: "test-agent",
+    message: "Allow read?",
+    toolName: "read",
+    ...overrides,
+  };
+}
+
+function makeDeps(
+  overrides?: Partial<PermissionPrompterDeps>,
+): PermissionPrompterDeps {
+  return {
+    getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: false }),
+    writeReviewLog: vi.fn(),
+    subagentSessionsDir: "/sessions/subagents",
+    forwardingDir: "/sessions/permission-forwarding",
+    requestPermissionDecisionFromUi: vi
+      .fn()
+      .mockResolvedValue({ approved: true, state: "approved" }),
+    ...overrides,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("PermissionPrompter", () => {
+  beforeEach(() => {
+    mockConfirmPermission.mockReset();
+  });
+
+  // ── Yolo-mode auto-approve ───────────────────────────────────────────────
+
+  describe("yolo-mode auto-approve", () => {
+    it("returns approved without calling confirmPermission when yoloMode is true", async () => {
+      const deps = makeDeps({
+        getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+      });
+      const prompter = new PermissionPrompter(deps);
+
+      const decision = await prompter.prompt(makeCtx(false), makeDetails());
+
+      expect(decision).toEqual({ approved: true, state: "approved" });
+      expect(mockConfirmPermission).not.toHaveBeenCalled();
+    });
+
+    it("logs permission_request.auto_approved in yolo mode", async () => {
+      const writeReviewLog = vi.fn();
+      const deps = makeDeps({
+        getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+        writeReviewLog,
+      });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(false), makeDetails());
+
+      expect(writeReviewLog).toHaveBeenCalledWith(
+        "permission_request.auto_approved",
+        expect.objectContaining({ requestId: "req-123" }),
+      );
+    });
+
+    it("does not log permission_request.waiting in yolo mode", async () => {
+      const writeReviewLog = vi.fn();
+      const deps = makeDeps({
+        getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+        writeReviewLog,
+      });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(false), makeDetails());
+
+      expect(writeReviewLog).not.toHaveBeenCalledWith(
+        "permission_request.waiting",
+        expect.anything(),
+      );
+    });
+
+    it("does not call confirmPermission with yoloMode even when ctx has UI", async () => {
+      const deps = makeDeps({
+        getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+      });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(true), makeDetails());
+
+      expect(mockConfirmPermission).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── Non-yolo path ────────────────────────────────────────────────────────
+
+  describe("non-yolo path (UI present)", () => {
+    it("logs permission_request.waiting before calling confirmPermission", async () => {
+      const writeReviewLog = vi.fn();
+      const approved: PermissionPromptDecision = {
+        approved: true,
+        state: "approved",
+      };
+      mockConfirmPermission.mockResolvedValue(approved);
+      const deps = makeDeps({ writeReviewLog });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(true), makeDetails());
+
+      const calls = writeReviewLog.mock.calls.map((c) => c[0] as string);
+      expect(
+        calls.indexOf("permission_request.waiting"),
+      ).toBeGreaterThanOrEqual(0);
+      expect(calls.indexOf("permission_request.waiting")).toBeLessThan(
+        calls.indexOf("permission_request.approved"),
+      );
+    });
+
+    it("logs permission_request.approved when confirmPermission returns approved", async () => {
+      const writeReviewLog = vi.fn();
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps({ writeReviewLog });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(true), makeDetails());
+
+      expect(writeReviewLog).toHaveBeenCalledWith(
+        "permission_request.approved",
+        expect.objectContaining({
+          requestId: "req-123",
+          resolution: "approved",
+        }),
+      );
+    });
+
+    it("logs permission_request.denied when confirmPermission returns denied", async () => {
+      const writeReviewLog = vi.fn();
+      mockConfirmPermission.mockResolvedValue({
+        approved: false,
+        state: "denied",
+      });
+      const deps = makeDeps({ writeReviewLog });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(true), makeDetails());
+
+      expect(writeReviewLog).toHaveBeenCalledWith(
+        "permission_request.denied",
+        expect.objectContaining({
+          requestId: "req-123",
+          resolution: "denied",
+        }),
+      );
+    });
+
+    it("logs permission_request.denied with denialReason when present", async () => {
+      const writeReviewLog = vi.fn();
+      mockConfirmPermission.mockResolvedValue({
+        approved: false,
+        state: "denied_with_reason",
+        denialReason: "too sensitive",
+      });
+      const deps = makeDeps({ writeReviewLog });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(true), makeDetails());
+
+      expect(writeReviewLog).toHaveBeenCalledWith(
+        "permission_request.denied",
+        expect.objectContaining({
+          denialReason: "too sensitive",
+        }),
+      );
+    });
+
+    it("returns the decision from confirmPermission", async () => {
+      const decision: PermissionPromptDecision = {
+        approved: false,
+        state: "denied_with_reason",
+        denialReason: "sensitive",
+      };
+      mockConfirmPermission.mockResolvedValue(decision);
+      const deps = makeDeps();
+      const prompter = new PermissionPrompter(deps);
+
+      const result = await prompter.prompt(makeCtx(true), makeDetails());
+
+      expect(result).toEqual(decision);
+    });
+
+    it("passes sessionLabel option to confirmPermission when present", async () => {
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps();
+      const prompter = new PermissionPrompter(deps);
+      const details = makeDetails({ sessionLabel: "Yes, for 'read' tool" });
+
+      await prompter.prompt(makeCtx(true), details);
+
+      expect(mockConfirmPermission).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.any(String),
+        expect.anything(),
+        { sessionLabel: "Yes, for 'read' tool" },
+      );
+    });
+
+    it("passes undefined options to confirmPermission when sessionLabel is absent", async () => {
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps();
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(true), makeDetails());
+
+      expect(mockConfirmPermission).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.any(String),
+        expect.anything(),
+        undefined,
+      );
+    });
+
+    it("passes the message from details to confirmPermission", async () => {
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps();
+      const prompter = new PermissionPrompter(deps);
+      const details = makeDetails({ message: "Allow bash: git status?" });
+
+      await prompter.prompt(makeCtx(true), details);
+
+      expect(mockConfirmPermission).toHaveBeenCalledWith(
+        expect.anything(),
+        "Allow bash: git status?",
+        expect.anything(),
+        undefined,
+      );
+    });
+  });
+
+  // ── Review log field coverage ────────────────────────────────────────────
+
+  describe("review log fields", () => {
+    it("includes all standard fields in the waiting log entry", async () => {
+      const writeReviewLog = vi.fn();
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps({ writeReviewLog });
+      const prompter = new PermissionPrompter(deps);
+      const details = makeDetails({
+        toolCallId: "tc-1",
+        skillName: "librarian",
+        path: "/src/foo.ts",
+        command: "git status",
+        target: "server:tool",
+        toolInputPreview: "{ path: '...' }",
+      });
+
+      await prompter.prompt(makeCtx(true), details);
+
+      expect(writeReviewLog).toHaveBeenCalledWith(
+        "permission_request.waiting",
+        expect.objectContaining({
+          requestId: "req-123",
+          source: "tool_call",
+          agentName: "test-agent",
+          message: "Allow read?",
+          toolCallId: "tc-1",
+          toolName: "read",
+          skillName: "librarian",
+          path: "/src/foo.ts",
+          command: "git status",
+          target: "server:tool",
+          toolInputPreview: "{ path: '...' }",
+        }),
+      );
+    });
+
+    it("uses null for optional fields not present in details", async () => {
+      const writeReviewLog = vi.fn();
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps({ writeReviewLog });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(true), makeDetails());
+
+      expect(writeReviewLog).toHaveBeenCalledWith(
+        "permission_request.waiting",
+        expect.objectContaining({
+          toolCallId: null,
+          skillName: null,
+          path: null,
+          command: null,
+          target: null,
+          toolInputPreview: null,
+        }),
+      );
+    });
+  });
+
+  // ── Subagent forwarding path ─────────────────────────────────────────────
+
+  describe("subagent forwarding path", () => {
+    it("calls confirmPermission even when ctx has no UI", async () => {
+      const forwarded: PermissionPromptDecision = {
+        approved: true,
+        state: "approved",
+      };
+      mockConfirmPermission.mockResolvedValue(forwarded);
+      const deps = makeDeps();
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(false), makeDetails());
+
+      expect(mockConfirmPermission).toHaveBeenCalled();
+    });
+
+    it("returns the decision from confirmPermission in the subagent path", async () => {
+      const forwarded: PermissionPromptDecision = {
+        approved: false,
+        state: "denied",
+      };
+      mockConfirmPermission.mockResolvedValue(forwarded);
+      const deps = makeDeps();
+      const prompter = new PermissionPrompter(deps);
+
+      const result = await prompter.prompt(makeCtx(false), makeDetails());
+
+      expect(result).toEqual(forwarded);
+    });
+
+    it("logs the outcome when confirmPermission resolves via forwarding", async () => {
+      const writeReviewLog = vi.fn();
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps({ writeReviewLog });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(false), makeDetails());
+
+      expect(writeReviewLog).toHaveBeenCalledWith(
+        "permission_request.approved",
+        expect.objectContaining({ requestId: "req-123" }),
+      );
+    });
+  });
+});

package/tests/permission-system.test.ts

@@ -2620,6 +2620,187 @@ test("session rules override config deny for external_directory", () => {
   }
 });
 
+// ── Session rule evaluation for all surfaces ─────────────────────────────
+
+test("checkPermission returns source 'session' for bash when session rules match", () => {
+  const { manager, cleanup } = createManager({ permission: {} });
+
+  try {
+    const sessionRules = [
+      {
+        surface: "bash",
+        pattern: "git *",
+        action: "allow" as const,
+        layer: "session" as const,
+      },
+    ];
+
+    const result = manager.checkPermission(
+      "bash",
+      { command: "git status --short" },
+      undefined,
+      sessionRules,
+    );
+    assert.equal(result.state, "allow");
+    assert.equal(result.source, "session");
+    assert.equal(result.matchedPattern, "git *");
+  } finally {
+    cleanup();
+  }
+});
+
+test("checkPermission returns source 'session' for bash when session rule is exact match", () => {
+  const { manager, cleanup } = createManager({ permission: {} });
+
+  try {
+    const sessionRules = [
+      {
+        surface: "bash",
+        pattern: "ls",
+        action: "allow" as const,
+        layer: "session" as const,
+      },
+    ];
+
+    const result = manager.checkPermission(
+      "bash",
+      { command: "ls" },
+      undefined,
+      sessionRules,
+    );
+    assert.equal(result.state, "allow");
+    assert.equal(result.source, "session");
+  } finally {
+    cleanup();
+  }
+});
+
+test("checkPermission falls back to config for bash when session rules do not match the command", () => {
+  const { manager, cleanup } = createManager({ permission: { bash: "deny" } });
+
+  try {
+    const sessionRules = [
+      {
+        surface: "bash",
+        pattern: "git *",
+        action: "allow" as const,
+        layer: "session" as const,
+      },
+    ];
+
+    const result = manager.checkPermission(
+      "bash",
+      { command: "npm run build" },
+      undefined,
+      sessionRules,
+    );
+    assert.equal(result.state, "deny");
+    assert.equal(result.source, "bash");
+  } finally {
+    cleanup();
+  }
+});
+
+test("checkPermission returns source 'session' for mcp when session rules match the target", () => {
+  const { manager, cleanup } = createManager({ permission: {} });
+
+  try {
+    const sessionRules = [
+      {
+        surface: "mcp",
+        pattern: "exa:*",
+        action: "allow" as const,
+        layer: "session" as const,
+      },
+    ];
+
+    const result = manager.checkPermission(
+      "mcp",
+      { tool: "exa:search" },
+      undefined,
+      sessionRules,
+    );
+    assert.equal(result.state, "allow");
+    assert.equal(result.source, "session");
+  } finally {
+    cleanup();
+  }
+});
+
+test("checkPermission returns source 'session' for skill when session rules match", () => {
+  const { manager, cleanup } = createManager({ permission: {} });
+
+  try {
+    const sessionRules = [
+      {
+        surface: "skill",
+        pattern: "librarian",
+        action: "allow" as const,
+        layer: "session" as const,
+      },
+    ];
+
+    const result = manager.checkPermission(
+      "skill",
+      { name: "librarian" },
+      undefined,
+      sessionRules,
+    );
+    assert.equal(result.state, "allow");
+    assert.equal(result.source, "session");
+    assert.equal(result.matchedPattern, "librarian");
+  } finally {
+    cleanup();
+  }
+});
+
+test("checkPermission returns source 'session' for tool surface when session rules match", () => {
+  const { manager, cleanup } = createManager({ permission: {} });
+
+  try {
+    const sessionRules = [
+      {
+        surface: "read",
+        pattern: "*",
+        action: "allow" as const,
+        layer: "session" as const,
+      },
+    ];
+
+    const result = manager.checkPermission("read", {}, undefined, sessionRules);
+    assert.equal(result.state, "allow");
+    assert.equal(result.source, "session");
+  } finally {
+    cleanup();
+  }
+});
+
+test("bash session rules do not bleed into mcp checks", () => {
+  const { manager, cleanup } = createManager({ permission: {} });
+
+  try {
+    const sessionRules = [
+      {
+        surface: "bash",
+        pattern: "git *",
+        action: "allow" as const,
+        layer: "session" as const,
+      },
+    ];
+
+    const result = manager.checkPermission(
+      "mcp",
+      { tool: "exa:search" },
+      undefined,
+      sessionRules,
+    );
+    // bash session rule must not affect mcp surface
+    assert.notEqual(result.source, "session");
+  } finally {
+    cleanup();
+  }
+});
+
 // Suppress unused import warning — PermissionState used in type annotations
 const _unused: PermissionState = "ask";
 void _unused;

package/tests/runtime.test.ts

@@ -59,9 +59,6 @@ vi.mock("../src/config-reporter", () => ({
 
 vi.mock("../src/forwarded-permissions/polling", () => ({
   processForwardedPermissionRequests: vi.fn().mockResolvedValue(undefined),
-  confirmPermission: vi
-    .fn()
-    .mockResolvedValue({ approved: true, state: "approved" }),
 }));
 
 vi.mock("../src/subagent-context", () => ({