@gotgenes/pi-permission-system 17.1.0 → 18.0.0

package/test/input-normalizer.test.ts

@@ -1,4 +1,3 @@
-import { join } from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 const mockHomedir = vi.hoisted(() => vi.fn(() => "/mock/home"));
@@ -8,243 +7,128 @@ vi.mock("node:os", () => ({
   default: { homedir: mockHomedir },
 }));
 
-import { normalizeInput } from "#src/input-normalizer";
+// Mock node:fs so realpathSync (used by the canonical alias) is controllable.
+// Default implementation is identity — lexical tests are unaffected.
+const realpathSync = vi.hoisted(() =>
+  vi.fn<(path: string) => string>((p) => p),
+);
+vi.mock("node:fs", () => ({
+  realpathSync,
+  default: { realpathSync },
+}));
+
+import {
+  buildAccessIntentForSurface,
+  normalizeInput,
+} from "#src/input-normalizer";
 import { createMcpPermissionTargets } from "#src/mcp-targets";
+import { PathNormalizer } from "#src/path-normalizer";
 
 afterEach(() => {
   mockHomedir.mockClear();
+  realpathSync.mockReset();
+  realpathSync.mockImplementation((p: string) => p);
 });
 
 describe("normalizeInput — non-MCP surfaces", () => {
-  describe("special / path", () => {
-    it("uses path from input as the lookup value", () => {
-      const result = normalizeInput("path", { path: ".env" }, [], "linux");
+  // Path-bearing and special surfaces no longer derive path lookup values
+  // through normalizeInput — that is now done by the access-path gate (#502)
+  // and the service/RPC builder (#503). normalizeInput's tool branch collapses
+  // every path-bearing or special surface to the catch-all ["*"] exactly as it
+  // does for any unrecognised extension tool.
+  describe("path-bearing and special surfaces collapse to '*'", () => {
+    it("path surface ignores input.path and returns ['*']", () => {
+      // After #504 removal: path no longer has a special branch.
+      const result = normalizeInput("path", { path: ".env" }, []);
       expect(result.surface).toBe("path");
-      expect(result.values).toEqual([".env"]);
-      expect(result.resultExtras).toEqual({});
-    });
-
-    it("falls back to '*' when path is missing", () => {
-      const result = normalizeInput("path", {}, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("falls back to '*' when path is not a string", () => {
-      const result = normalizeInput("path", { path: 42 }, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("falls back to '*' when path is an empty string", () => {
-      const result = normalizeInput("path", { path: "" }, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("falls back to '*' when path is whitespace-only", () => {
-      const result = normalizeInput("path", { path: "   " }, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("handles null input", () => {
-      const result = normalizeInput("path", null, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("expands ~/... path value to absolute home path", () => {
-      const result = normalizeInput(
-        "path",
-        { path: "~/.ssh/config" },
-        [],
-        "linux",
-      );
-      expect(result.values).toEqual([join("/mock/home", ".ssh/config")]);
-    });
-
-    it("expands $HOME/... path value to absolute home path", () => {
-      const result = normalizeInput(
-        "path",
-        { path: "$HOME/.ssh/config" },
-        [],
-        "linux",
-      );
-      expect(result.values).toEqual([join("/mock/home", ".ssh/config")]);
-    });
-
-    it("does not expand non-home values", () => {
-      const result = normalizeInput("path", { path: ".env" }, [], "linux");
-      expect(result.values).toEqual([".env"]);
-    });
-
-    it("does not expand the '*' fallback", () => {
-      const result = normalizeInput("path", {}, [], "linux");
       expect(result.values).toEqual(["*"]);
+      expect(result.resultExtras).toEqual({});
     });
 
-    it("adds cwd-normalized and relative aliases when cwd is provided", () => {
-      const result = normalizeInput(
-        "path",
-        { path: "src/App.jsx" },
-        [],
-        "linux",
-        "/workspace/project",
-      );
-      expect(result.values).toEqual([
-        "/workspace/project/src/App.jsx",
-        "src/App.jsx",
-      ]);
-    });
-
-    it("ignores a user-supplied string pathPolicyValues field", () => {
-      const result = normalizeInput(
-        "path",
-        { path: "src/App.jsx", pathPolicyValues: ["/etc/shadow"] },
-        [],
-        "linux",
-        "/workspace/project",
-      );
-      expect(result.values).toEqual([
-        "/workspace/project/src/App.jsx",
-        "src/App.jsx",
-      ]);
-    });
-  });
-
-  describe("special / external_directory", () => {
-    it("uses path from input as the lookup value", () => {
+    it("external_directory surface ignores input.path and returns ['*']", () => {
       const result = normalizeInput(
         "external_directory",
         { path: "/other/project" },
         [],
-        "linux",
       );
       expect(result.surface).toBe("external_directory");
-      expect(result.values).toEqual(["/other/project"]);
-      expect(result.resultExtras).toEqual({});
-    });
-
-    it("falls back to '*' when path is missing", () => {
-      const result = normalizeInput("external_directory", {}, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("falls back to '*' when path is not a string", () => {
-      const result = normalizeInput(
-        "external_directory",
-        { path: 42 },
-        [],
-        "linux",
-      );
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("falls back to '*' when path is an empty string", () => {
-      const result = normalizeInput(
-        "external_directory",
-        { path: "" },
-        [],
-        "linux",
-      );
       expect(result.values).toEqual(["*"]);
+      expect(result.resultExtras).toEqual({});
     });
 
-    it("handles null input", () => {
-      const result = normalizeInput("external_directory", null, [], "linux");
+    it("read surface ignores input.path and returns ['*']", () => {
+      const result = normalizeInput("read", { path: ".env" }, []);
+      expect(result.surface).toBe("read");
       expect(result.values).toEqual(["*"]);
+      expect(result.resultExtras).toEqual({});
     });
 
-    it("expands ~/... path value to absolute home path", () => {
-      const result = normalizeInput(
-        "external_directory",
-        { path: "~/dev/project" },
-        [],
-        "linux",
-      );
-      expect(result.values).toEqual([join("/mock/home", "dev/project")]);
-    });
-
-    it("expands $HOME/... path value to absolute home path", () => {
-      const result = normalizeInput(
-        "external_directory",
-        { path: "$HOME/dev/project" },
-        [],
-        "linux",
-      );
-      expect(result.values).toEqual([join("/mock/home", "dev/project")]);
-    });
-
-    it("adds cwd-normalized and relative aliases when cwd is provided", () => {
-      const result = normalizeInput(
+    it("missing path also returns ['*'] (unchanged fallback)", () => {
+      for (const surface of [
+        "path",
         "external_directory",
-        { path: "src/App.jsx" },
-        [],
-        "linux",
-        "/workspace/project",
-      );
-      expect(result.values).toEqual([
-        "/workspace/project/src/App.jsx",
-        "src/App.jsx",
-      ]);
+        "read",
+        "write",
+        "edit",
+        "grep",
+        "find",
+        "ls",
+      ]) {
+        const result = normalizeInput(surface, {}, []);
+        expect(result.values).toEqual(["*"]);
+      }
     });
   });
 
   describe("skill", () => {
     it("uses skill name from input.name", () => {
-      const result = normalizeInput(
-        "skill",
-        { name: "librarian" },
-        [],
-        "linux",
-      );
+      const result = normalizeInput("skill", { name: "librarian" }, []);
       expect(result.surface).toBe("skill");
       expect(result.values).toEqual(["librarian"]);
       expect(result.resultExtras).toEqual({});
     });
 
     it("falls back to '*' when name is missing", () => {
-      const result = normalizeInput("skill", {}, [], "linux");
+      const result = normalizeInput("skill", {}, []);
       expect(result.values).toEqual(["*"]);
     });
 
     it("falls back to '*' when name is not a string", () => {
-      const result = normalizeInput("skill", { name: 99 }, [], "linux");
+      const result = normalizeInput("skill", { name: 99 }, []);
       expect(result.values).toEqual(["*"]);
     });
   });
 
   describe("bash", () => {
     it("uses command from input.command", () => {
-      const result = normalizeInput(
-        "bash",
-        { command: "git status" },
-        [],
-        "linux",
-      );
+      const result = normalizeInput("bash", { command: "git status" }, []);
       expect(result.surface).toBe("bash");
       expect(result.values).toEqual(["git status"]);
       expect(result.resultExtras).toEqual({ command: "git status" });
     });
 
     it("uses empty string when command is missing", () => {
-      const result = normalizeInput("bash", {}, [], "linux");
+      const result = normalizeInput("bash", {}, []);
       expect(result.values).toEqual([""]);
       expect(result.resultExtras).toEqual({ command: "" });
     });
 
     it("uses empty string when command is not a string", () => {
-      const result = normalizeInput("bash", { command: 42 }, [], "linux");
+      const result = normalizeInput("bash", { command: 42 }, []);
       expect(result.values).toEqual([""]);
       expect(result.resultExtras).toEqual({ command: "" });
     });
 
     it("strips leading comment lines from values but keeps original in resultExtras", () => {
       const cmd = "# Check debug logs\nfind /home -path '*debug*' -type f";
-      const result = normalizeInput("bash", { command: cmd }, [], "linux");
+      const result = normalizeInput("bash", { command: cmd }, []);
       expect(result.values).toEqual(["find /home -path '*debug*' -type f"]);
       expect(result.resultExtras).toEqual({ command: cmd });
     });
 
     it("strips multiple comment lines", () => {
       const cmd = "# Step 1\n# Step 2\ngit status --short";
-      const result = normalizeInput("bash", { command: cmd }, [], "linux");
+      const result = normalizeInput("bash", { command: cmd }, []);
       expect(result.values).toEqual(["git status --short"]);
     });
 
@@ -253,98 +137,20 @@ describe("normalizeInput — non-MCP surfaces", () => {
         "bash",
         { command: "grep -rn foo src/" },
         [],
-        "linux",
       );
       expect(result.values).toEqual(["grep -rn foo src/"]);
     });
 
     it("falls back to original when all lines are comments", () => {
       const cmd = "# just a comment";
-      const result = normalizeInput("bash", { command: cmd }, [], "linux");
+      const result = normalizeInput("bash", { command: cmd }, []);
       expect(result.values).toEqual(["# just a comment"]);
     });
   });
 
-  describe("path-bearing tools (read, write, edit, grep, find, ls)", () => {
-    it("uses input.path as the lookup value when path is present", () => {
-      for (const tool of ["read", "write", "edit", "grep", "find", "ls"]) {
-        const result = normalizeInput(
-          tool,
-          { path: "/project/src/main.ts" },
-          [],
-          "linux",
-        );
-        expect(result.surface).toBe(tool);
-        expect(result.values).toEqual(["/project/src/main.ts"]);
-        expect(result.resultExtras).toEqual({});
-      }
-    });
-
-    it("falls back to '*' when input.path is missing", () => {
-      for (const tool of ["read", "write", "edit", "grep", "find", "ls"]) {
-        const result = normalizeInput(tool, {}, [], "linux");
-        expect(result.values).toEqual(["*"]);
-      }
-    });
-
-    it("falls back to '*' when input.path is empty string", () => {
-      const result = normalizeInput("read", { path: "" }, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("falls back to '*' when input.path is not a string", () => {
-      const result = normalizeInput("write", { path: 42 }, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("falls back to '*' when input is null", () => {
-      const result = normalizeInput("edit", null, [], "linux");
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("expands ~/... path value to absolute home path", () => {
-      const result = normalizeInput(
-        "read",
-        { path: "~/.ssh/config" },
-        [],
-        "linux",
-      );
-      expect(result.values).toEqual([join("/mock/home", ".ssh/config")]);
-    });
-
-    it("expands $HOME/... path value to absolute home path", () => {
-      const result = normalizeInput(
-        "write",
-        { path: "$HOME/.ssh/config" },
-        [],
-        "linux",
-      );
-      expect(result.values).toEqual([join("/mock/home", ".ssh/config")]);
-    });
-
-    it("adds cwd-normalized and relative aliases when cwd is provided", () => {
-      const result = normalizeInput(
-        "read",
-        { path: "src/App.jsx" },
-        [],
-        "linux",
-        "/workspace/project",
-      );
-      expect(result.values).toEqual([
-        "/workspace/project/src/App.jsx",
-        "src/App.jsx",
-      ]);
-    });
-  });
-
   describe("extension tools (non-path-bearing)", () => {
     it("uses '*' as the lookup value for extension tools", () => {
-      const result = normalizeInput(
-        "my_extension_tool",
-        { some: "input" },
-        [],
-        "linux",
-      );
+      const result = normalizeInput("my_extension_tool", { some: "input" }, []);
       expect(result.surface).toBe("my_extension_tool");
       expect(result.values).toEqual(["*"]);
       expect(result.resultExtras).toEqual({});
@@ -355,7 +161,6 @@ describe("normalizeInput — non-MCP surfaces", () => {
         "my_extension_tool",
         { path: "/some/path" },
         [],
-        "linux",
       );
       expect(result.values).toEqual(["*"]);
     });
@@ -364,17 +169,17 @@ describe("normalizeInput — non-MCP surfaces", () => {
 
 describe("normalizeInput — MCP surface", () => {
   it("surface is 'mcp'", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, [], "linux");
+    const result = normalizeInput("mcp", { tool: "exa:search" }, []);
     expect(result.surface).toBe("mcp");
   });
 
   it("values end with the catch-all 'mcp' target", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, [], "linux");
+    const result = normalizeInput("mcp", { tool: "exa:search" }, []);
     expect(result.values.at(-1)).toBe("mcp");
   });
 
   it("values include specific targets before the catch-all for a qualified tool call", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, [], "linux");
+    const result = normalizeInput("mcp", { tool: "exa:search" }, []);
     expect(result.values).toContain("exa_search");
     expect(result.values).toContain("exa:search");
     expect(result.values).toContain("exa");
@@ -387,46 +192,134 @@ describe("normalizeInput — MCP surface", () => {
     const rawTargets = createMcpPermissionTargets({ tool: "exa:search" }, [
       "exa",
     ]);
-    const result = normalizeInput(
-      "mcp",
-      { tool: "exa:search" },
-      ["exa"],
-      "linux",
-    );
+    const result = normalizeInput("mcp", { tool: "exa:search" }, ["exa"]);
     expect(result.values).toEqual([...rawTargets, "mcp"]);
   });
 
   it("resultExtras.target is the first specific target (most-specific)", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, [], "linux");
+    const result = normalizeInput("mcp", { tool: "exa:search" }, []);
     expect(result.resultExtras.target).toBe(result.values[0]);
   });
 
   it("resultExtras.target is 'mcp' when no specific targets are derived", () => {
     // Empty input → only mcp_status then mcp appended
-    const result = normalizeInput("mcp", {}, [], "linux");
+    const result = normalizeInput("mcp", {}, []);
     expect(result.resultExtras.target).toBe("mcp_status");
   });
 
   it("values contain no duplicates", () => {
-    const result = normalizeInput(
-      "mcp",
-      { tool: "exa:search" },
-      ["exa"],
-      "linux",
-    );
+    const result = normalizeInput("mcp", { tool: "exa:search" }, ["exa"]);
     const unique = [...new Set(result.values)];
     expect(result.values).toEqual(unique);
   });
 
   it("produces mcp_status + mcp for status input", () => {
-    const result = normalizeInput("mcp", {}, [], "linux");
+    const result = normalizeInput("mcp", {}, []);
     expect(result.values).toEqual(["mcp_status", "mcp"]);
   });
 
   it("produces connect targets + mcp for connect input", () => {
-    const result = normalizeInput("mcp", { connect: "exa" }, [], "linux");
+    const result = normalizeInput("mcp", { connect: "exa" }, []);
     expect(result.values).toContain("mcp_connect_exa");
     expect(result.values).toContain("mcp_connect");
     expect(result.values.at(-1)).toBe("mcp");
   });
 });
+
+describe("buildAccessIntentForSurface", () => {
+  const normalizer = new PathNormalizer("linux", "/test/project");
+
+  it("emits an access-path intent carrying the canonical alias for the path surface", () => {
+    realpathSync.mockImplementation((p: string) =>
+      p === "/test/project/link" ? "/test/project/real" : p,
+    );
+    const intent = buildAccessIntentForSurface(
+      "path",
+      "link",
+      normalizer,
+      undefined,
+    );
+    expect(intent.kind).toBe("access-path");
+    if (intent.kind === "access-path") {
+      expect(intent.surface).toBe("path");
+      expect(intent.path.matchValues()).toContain("/test/project/real");
+      expect(intent.path.value()).toBe("/test/project/link");
+    }
+  });
+
+  it("emits an access-path intent for the external_directory surface", () => {
+    const intent = buildAccessIntentForSurface(
+      "external_directory",
+      "/outside/dir",
+      normalizer,
+      undefined,
+    );
+    expect(intent.kind).toBe("access-path");
+    if (intent.kind === "access-path") {
+      expect(intent.surface).toBe("external_directory");
+      expect(intent.path.value()).toBe("/outside/dir");
+    }
+  });
+
+  it("emits an access-path intent for a path-bearing tool surface (read)", () => {
+    const intent = buildAccessIntentForSurface(
+      "read",
+      "/test/project/.env",
+      normalizer,
+      undefined,
+    );
+    expect(intent.kind).toBe("access-path");
+    if (intent.kind === "access-path") {
+      expect(intent.surface).toBe("read");
+      expect(intent.path.value()).toBe("/test/project/.env");
+    }
+  });
+
+  it("emits a tool intent for a non-path surface (bash)", () => {
+    const intent = buildAccessIntentForSurface(
+      "bash",
+      "echo hi",
+      normalizer,
+      "my-agent",
+    );
+    expect(intent).toEqual({
+      kind: "tool",
+      surface: "bash",
+      input: { command: "echo hi" },
+      agentName: "my-agent",
+    });
+  });
+
+  it("passes agentName through on the access-path branch", () => {
+    const intent = buildAccessIntentForSurface(
+      "path",
+      "/some/file",
+      normalizer,
+      "Explore",
+    );
+    expect(intent.agentName).toBe("Explore");
+  });
+
+  it("falls back to a tool intent for a value-less path surface", () => {
+    const intent = buildAccessIntentForSurface(
+      "path",
+      undefined,
+      normalizer,
+      undefined,
+    );
+    expect(intent.kind).toBe("tool");
+    if (intent.kind === "tool") {
+      expect(intent.surface).toBe("path");
+    }
+  });
+
+  it("falls back to a tool intent for a whitespace-only path value", () => {
+    const intent = buildAccessIntentForSurface(
+      "external_directory",
+      "   ",
+      normalizer,
+      undefined,
+    );
+    expect(intent.kind).toBe("tool");
+  });
+});

package/test/path-normalizer.test.ts

@@ -77,6 +77,13 @@ describe("PathNormalizer", () => {
       );
       expect(normalizer.isOutsideWorkingDirectory("/etc/hosts")).toBe(true);
     });
+
+    test("comparableValue returns the lexical absolute form (no FS)", () => {
+      expect(normalizer.comparableValue("src/foo.ts")).toBe(
+        "/projects/my-app/src/foo.ts",
+      );
+      expect(normalizer.comparableValue("/etc/hosts")).toBe("/etc/hosts");
+    });
   });
 
   describe("win32 flavor", () => {
@@ -119,5 +126,41 @@ describe("PathNormalizer", () => {
       ).toBe(false);
       expect(normalizer.isOutsideWorkingDirectory("C:\\Other\\dir")).toBe(true);
     });
+
+    test("comparableValue case-folds the lexical absolute form", () => {
+      expect(normalizer.comparableValue("src\\foo.ts")).toBe(
+        "c:\\projects\\app\\src\\foo.ts",
+      );
+    });
+  });
+
+  describe("isInfrastructureRead", () => {
+    const normalizer = new PathNormalizer("linux", "/projects/my-app");
+
+    test("allows a read-only tool targeting a configured infra dir", () => {
+      const ap = normalizer.forPath("/infra/git/pkg/SKILL.md");
+      expect(normalizer.isInfrastructureRead("read", ap, ["/infra"])).toBe(
+        true,
+      );
+    });
+
+    test("does not allow a write tool targeting an infra dir", () => {
+      const ap = normalizer.forPath("/infra/git/pkg/file.ts");
+      expect(normalizer.isInfrastructureRead("write", ap, ["/infra"])).toBe(
+        false,
+      );
+    });
+
+    test("does not allow a read-only tool outside any infra dir", () => {
+      const ap = normalizer.forPath("/elsewhere/file.ts");
+      expect(normalizer.isInfrastructureRead("read", ap, ["/infra"])).toBe(
+        false,
+      );
+    });
+
+    test("allows a read targeting the project-local .pi/npm dir (from baked cwd)", () => {
+      const ap = normalizer.forPath("/projects/my-app/.pi/npm/dep/index.js");
+      expect(normalizer.isInfrastructureRead("read", ap, [])).toBe(true);
+    });
   });
 });

package/test/path-utils.test.ts

@@ -421,7 +421,7 @@ describe("isPathOutsideWorkingDirectory", () => {
     // /tmp -> /private/tmp on macOS; cwd reported as /private/tmp.
     const symlinkCwd = "/private/tmp";
     realpathSync.mockImplementation((p: string) => {
-      if (p.startsWith("/tmp/")) return "/private/tmp" + p.slice(4);
+      if (p.startsWith("/tmp/")) return `/private/tmp${p.slice(4)}`;
       if (p === "/tmp") return "/private/tmp";
       return p;
     });