@gotgenes/pi-permission-system 16.0.2 → 16.2.0

package/test/permission-resolver.test.ts

@@ -1,4 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ResolvedAccessIntent } from "#src/access-intent/access-intent";
+import { AccessPath } from "#src/access-intent/access-path";
 import type { ScopedPermissionManager } from "#src/permission-manager";
 import { PermissionResolver } from "#src/permission-resolver";
 import type { Ruleset } from "#src/rule";
@@ -9,12 +11,10 @@ import type { PermissionCheckResult, PermissionState } from "#src/types";
 function makePermissionManager() {
   return {
     configureForCwd: vi.fn<(cwd: string | undefined | null) => void>(),
-    checkPermission: vi
+    check: vi
       .fn<
         (
-          toolName: string,
-          input: unknown,
-          agentName?: string,
+          intent: ResolvedAccessIntent,
           sessionRules?: Ruleset,
         ) => PermissionCheckResult
       >()
@@ -24,20 +24,6 @@ function makePermissionManager() {
         source: "tool",
         origin: "builtin",
       }),
-    checkPathPolicy: vi
-      .fn<
-        (
-          values: readonly string[],
-          agentName?: string,
-          sessionRules?: Ruleset,
-        ) => PermissionCheckResult
-      >()
-      .mockReturnValue({
-        state: "allow",
-        toolName: "path",
-        source: "special",
-        origin: "builtin",
-      }),
     getToolPermission: vi
       .fn<(toolName: string, agentName?: string) => PermissionState>()
       .mockReturnValue("allow"),
@@ -62,29 +48,24 @@ beforeEach(() => {
 });
 
 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", () => {
+  describe("resolve — tool intent", () => {
+    it("forwards a tool intent with the empty session ruleset", () => {
       const { resolver, permissionManager } = makeResolver();
 
-      resolver.resolve("read", { path: ".env" });
+      resolver.resolve({
+        kind: "tool",
+        surface: "bash",
+        input: { command: "ls" },
+        agentName: "agent-x",
+      });
 
-      expect(permissionManager.checkPermission).toHaveBeenCalledWith(
-        "read",
-        { path: ".env" },
-        undefined,
+      expect(permissionManager.check).toHaveBeenCalledWith(
+        {
+          kind: "tool",
+          surface: "bash",
+          input: { command: "ls" },
+          agentName: "agent-x",
+        },
         [],
       );
     });
@@ -94,13 +75,16 @@ describe("PermissionResolver", () => {
       const sessionRules = new SessionRules();
       const { resolver } = makeResolver(pm, sessionRules);
 
-      // Record an approval directly into the shared SessionRules instance.
       sessionRules.recordSessionApproval(
         SessionApproval.single("bash", "git *"),
       );
-      resolver.resolve("bash", { command: "git status" });
+      resolver.resolve({
+        kind: "tool",
+        surface: "bash",
+        input: { command: "git status" },
+      });
 
-      const passedRules = vi.mocked(pm.checkPermission).mock.calls[0][3];
+      const passedRules = vi.mocked(pm.check).mock.calls[0][1];
       expect(passedRules).toHaveLength(1);
       expect(passedRules?.[0]).toMatchObject({
         surface: "bash",
@@ -109,9 +93,9 @@ describe("PermissionResolver", () => {
       });
     });
 
-    it("returns the PermissionManager's check result", () => {
+    it("returns the manager's check result", () => {
       const pm = makePermissionManager();
-      vi.mocked(pm.checkPermission).mockReturnValue({
+      vi.mocked(pm.check).mockReturnValue({
         state: "deny",
         toolName: "bash",
         source: "bash",
@@ -120,7 +104,11 @@ describe("PermissionResolver", () => {
       });
       const { resolver } = makeResolver(pm);
 
-      const result = resolver.resolve("bash", { command: "rm -rf /" });
+      const result = resolver.resolve({
+        kind: "tool",
+        surface: "bash",
+        input: { command: "rm -rf /" },
+      });
 
       expect(result).toEqual({
         state: "deny",
@@ -132,30 +120,25 @@ describe("PermissionResolver", () => {
     });
   });
 
-  describe("resolvePathPolicy", () => {
-    it("forwards values and agentName with the current session ruleset", () => {
+  describe("resolve — path-values intent", () => {
+    it("forwards a path-values intent with the current session ruleset", () => {
       const { resolver, permissionManager } = makeResolver();
 
-      resolver.resolvePathPolicy(["/proj/src/a.ts", "src/a.ts"], "agent-x");
-
-      expect(permissionManager.checkPathPolicy).toHaveBeenCalledWith(
-        ["/proj/src/a.ts", "src/a.ts"],
-        "agent-x",
-        [],
-        "path",
-      );
-    });
-
-    it("forwards an explicit surface to checkPathPolicy", () => {
-      const { resolver, permissionManager } = makeResolver();
-
-      resolver.resolvePathPolicy(["/tmp/x"], "agent-x", "external_directory");
+      resolver.resolve({
+        kind: "path-values",
+        surface: "path",
+        values: ["/proj/src/a.ts", "src/a.ts"],
+        agentName: "agent-x",
+      });
 
-      expect(permissionManager.checkPathPolicy).toHaveBeenCalledWith(
-        ["/tmp/x"],
-        "agent-x",
+      expect(permissionManager.check).toHaveBeenCalledWith(
+        {
+          kind: "path-values",
+          surface: "path",
+          values: ["/proj/src/a.ts", "src/a.ts"],
+          agentName: "agent-x",
+        },
         [],
-        "external_directory",
       );
     });
 
@@ -167,9 +150,13 @@ describe("PermissionResolver", () => {
       sessionRules.recordSessionApproval(
         SessionApproval.single("path", "src/*"),
       );
-      resolver.resolvePathPolicy(["src/a.ts"]);
+      resolver.resolve({
+        kind: "path-values",
+        surface: "path",
+        values: ["src/a.ts"],
+      });
 
-      const passedRules = vi.mocked(pm.checkPathPolicy).mock.calls[0][2];
+      const passedRules = vi.mocked(pm.check).mock.calls[0][1];
       expect(passedRules).toHaveLength(1);
       expect(passedRules?.[0]).toMatchObject({
         surface: "path",
@@ -177,45 +164,78 @@ describe("PermissionResolver", () => {
         action: "allow",
       });
     });
+  });
 
-    it("returns the PermissionManager's check result", () => {
+  describe("resolve — access-path intent", () => {
+    it("unwraps the AccessPath via matchValues() into a path-values intent", () => {
+      const { resolver, permissionManager } = makeResolver();
+      const accessPath = AccessPath.forExternalDirectory(
+        "/tmp/x",
+        "/workspace",
+      );
+
+      resolver.resolve({
+        kind: "access-path",
+        surface: "external_directory",
+        path: accessPath,
+        agentName: "agent-x",
+      });
+
+      expect(permissionManager.check).toHaveBeenCalledWith(
+        {
+          kind: "path-values",
+          surface: "external_directory",
+          values: accessPath.matchValues(),
+          agentName: "agent-x",
+        },
+        [],
+      );
+    });
+
+    it("returns the manager's check result for an access-path intent", () => {
       const pm = makePermissionManager();
-      vi.mocked(pm.checkPathPolicy).mockReturnValue({
+      vi.mocked(pm.check).mockReturnValue({
         state: "deny",
-        toolName: "path",
+        toolName: "external_directory",
         source: "special",
         origin: "global",
-        matchedPattern: "src/*",
+        matchedPattern: "/tmp/*",
       });
       const { resolver } = makeResolver(pm);
+      const accessPath = AccessPath.forExternalDirectory(
+        "/tmp/x",
+        "/workspace",
+      );
 
-      const result = resolver.resolvePathPolicy(["src/a.ts"]);
-
-      expect(result).toEqual({
-        state: "deny",
-        toolName: "path",
-        source: "special",
-        origin: "global",
-        matchedPattern: "src/*",
+      const result = resolver.resolve({
+        kind: "access-path",
+        surface: "external_directory",
+        path: accessPath,
       });
+
+      expect(result.state).toBe("deny");
+      expect(result.matchedPattern).toBe("/tmp/*");
     });
   });
 
-  describe("checkPermission", () => {
-    it("delegates to permissionManager.checkPermission with the given args", () => {
+  describe("checkPermission (raw, off-interface)", () => {
+    it("delegates to manager.check as a tool intent without session rules", () => {
       const { resolver, permissionManager } = makeResolver();
 
       resolver.checkPermission("bash", { command: "ls" }, "agent-1");
 
-      expect(permissionManager.checkPermission).toHaveBeenCalledWith(
-        "bash",
-        { command: "ls" },
-        "agent-1",
+      expect(permissionManager.check).toHaveBeenCalledWith(
+        {
+          kind: "tool",
+          surface: "bash",
+          input: { command: "ls" },
+          agentName: "agent-1",
+        },
         undefined,
       );
     });
 
-    it("passes optional sessionRules through when supplied", () => {
+    it("passes optional sessionRules as the second arg to check", () => {
       const { resolver, permissionManager } = makeResolver();
       const extraRules: Ruleset = [
         { surface: "bash", pattern: "*", action: "allow", origin: "session" },
@@ -228,10 +248,13 @@ describe("PermissionResolver", () => {
         extraRules,
       );
 
-      expect(permissionManager.checkPermission).toHaveBeenCalledWith(
-        "bash",
-        { command: "ls" },
-        undefined,
+      expect(permissionManager.check).toHaveBeenCalledWith(
+        {
+          kind: "tool",
+          surface: "bash",
+          input: { command: "ls" },
+          agentName: undefined,
+        },
         extraRules,
       );
     });

package/test/permissions-service.test.ts

@@ -96,7 +96,7 @@ describe("checkPermission", () => {
     expect(mockBuildInputForSurface).toHaveBeenCalledWith("read", undefined);
   });
 
-  it("calls permissionManager.checkPermission with surface, built input, agentName, and current ruleset", () => {
+  it("calls permissionManager.check with a tool intent, built input, agentName, and current ruleset", () => {
     const ruleset: Ruleset = [
       { surface: "bash", pattern: "*", action: "allow", origin: "global" },
     ];
@@ -106,19 +106,22 @@ describe("checkPermission", () => {
       sessionRules: makeSessionRules(ruleset),
     });
     service.checkPermission("bash", "echo hi", "my-agent");
-    expect(permissionManager.checkPermission).toHaveBeenCalledWith(
-      "bash",
-      builtInput,
-      "my-agent",
+    expect(permissionManager.check).toHaveBeenCalledWith(
+      {
+        kind: "tool",
+        surface: "bash",
+        input: builtInput,
+        agentName: "my-agent",
+      },
       ruleset,
     );
     void sessionRules; // used indirectly
   });
 
-  it("returns the result from permissionManager.checkPermission", () => {
+  it("returns the result from permissionManager.check", () => {
     const expected = makeCheckResult({ state: "deny", toolName: "bash" });
     const { service, permissionManager } = makeService();
-    vi.mocked(permissionManager.checkPermission).mockReturnValue(expected);
+    vi.mocked(permissionManager.check).mockReturnValue(expected);
     const result = service.checkPermission("bash", "rm -rf /");
     expect(result).toBe(expected);
   });

package/test/skill-prompt-sanitizer.test.ts

@@ -1,14 +1,27 @@
 import { resolve } from "node:path";
 import { afterEach, describe, expect, test, vi } from "vitest";
-import type { PermissionManager } from "#src/permission-manager";
+import type { ScopedPermissionManager } from "#src/permission-manager";
 import {
   findSkillPathMatch,
   parseAllSkillPromptSections,
   resolveSkillPromptEntries,
+  type SkillPermissionChecker,
 } from "#src/skill-prompt-sanitizer";
 import type { PermissionCheckResult } from "#src/types";
 import { createManager } from "#test/helpers/manager-harness";
 
+/**
+ * Adapt a real `PermissionManager` to the raw `SkillPermissionChecker`
+ * contract, mirroring how `PermissionResolver.checkPermission` delegates to
+ * `manager.check` with a tool intent (#478).
+ */
+function asChecker(manager: ScopedPermissionManager): SkillPermissionChecker {
+  return {
+    checkPermission: (surface, input, agentName) =>
+      manager.check({ kind: "tool", surface, input, agentName }),
+  };
+}
+
 afterEach(() => {
   vi.restoreAllMocks();
 });
@@ -20,16 +33,16 @@ const CWD = "/projects/my-app";
 function makeManager(
   defaultState: "allow" | "deny" | "ask" = "allow",
   overrides: Record<string, "allow" | "deny" | "ask"> = {},
-): PermissionManager {
+): SkillPermissionChecker {
   return {
     checkPermission: vi.fn(
-      (_surface: string, input: { name?: string }): PermissionCheckResult => {
-        const name = input.name ?? "";
+      (_surface: string, input: unknown): PermissionCheckResult => {
+        const name = (input as { name?: string }).name ?? "";
         const state = overrides[name] ?? defaultState;
         return { toolName: "skill", state, source: "tool", origin: "builtin" };
       },
     ),
-  } as unknown as PermissionManager;
+  };
 }
 
 function skillBlock(
@@ -312,7 +325,12 @@ test("REGRESSION: resolveSkillPromptEntries sanitizes every available_skills blo
       "System prompt end",
     ].join("\n");
 
-    const result = resolveSkillPromptEntries(prompt, manager, null, "/cwd");
+    const result = resolveSkillPromptEntries(
+      prompt,
+      asChecker(manager),
+      null,
+      "/cwd",
+    );
 
     expect(result.prompt).not.toContain("denied-skill");
     expect(result.prompt).toContain("visible-skill");
@@ -354,7 +372,12 @@ test("REGRESSION: resolveSkillPromptEntries keeps only visible skills available
       "System prompt end",
     ].join("\n");
 
-    const result = resolveSkillPromptEntries(prompt, manager, null, "/cwd");
+    const result = resolveSkillPromptEntries(
+      prompt,
+      asChecker(manager),
+      null,
+      "/cwd",
+    );
     const visiblePath = resolve("/cwd", "./skills/visible/file.ts");
     const blockedPath = resolve("/cwd", "./skills/blocked/file.ts");
     const matchedVisibleSkill = findSkillPathMatch(