@gotgenes/pi-permission-system 16.2.1 → 17.1.0

package/test/canonicalize-path.test.ts

@@ -21,12 +21,14 @@ describe("canonicalizePath", () => {
   });
 
   test("returns empty string for empty input", () => {
-    expect(canonicalizePath("")).toBe("");
+    expect(canonicalizePath("", "linux")).toBe("");
   });
 
   test("returns realpathSync result when path exists", () => {
     realpathSync.mockReturnValueOnce("/real/projects/app");
-    expect(canonicalizePath("/projects/link")).toBe("/real/projects/app");
+    expect(canonicalizePath("/projects/link", "linux")).toBe(
+      "/real/projects/app",
+    );
   });
 
   test("re-appends a non-existent leaf to the canonical parent", () => {
@@ -35,7 +37,7 @@ describe("canonicalizePath", () => {
         throw enoent("/projects/app/new-file.ts");
       })
       .mockReturnValueOnce("/canonical/app");
-    expect(canonicalizePath("/projects/app/new-file.ts")).toBe(
+    expect(canonicalizePath("/projects/app/new-file.ts", "linux")).toBe(
       "/canonical/app/new-file.ts",
     );
   });
@@ -52,7 +54,7 @@ describe("canonicalizePath", () => {
         throw enoent("/projects/app");
       })
       .mockReturnValueOnce("/canonical/projects");
-    expect(canonicalizePath("/projects/app/src/new-file.ts")).toBe(
+    expect(canonicalizePath("/projects/app/src/new-file.ts", "linux")).toBe(
       "/canonical/projects/app/src/new-file.ts",
     );
   });
@@ -61,7 +63,7 @@ describe("canonicalizePath", () => {
     realpathSync.mockImplementation(() => {
       throw enoent("");
     });
-    expect(canonicalizePath("/nonexistent/path/file.ts")).toBe(
+    expect(canonicalizePath("/nonexistent/path/file.ts", "linux")).toBe(
       "/nonexistent/path/file.ts",
     );
   });
@@ -70,14 +72,18 @@ describe("canonicalizePath", () => {
     realpathSync.mockImplementation(() => {
       throw Object.assign(new Error("ELOOP"), { code: "ELOOP" });
     });
-    expect(canonicalizePath("/some/looping/path")).toBe("/some/looping/path");
+    expect(canonicalizePath("/some/looping/path", "linux")).toBe(
+      "/some/looping/path",
+    );
   });
 
   test("returns input unchanged on EACCES (permission denied)", () => {
     realpathSync.mockImplementation(() => {
       throw Object.assign(new Error("EACCES"), { code: "EACCES" });
     });
-    expect(canonicalizePath("/restricted/path")).toBe("/restricted/path");
+    expect(canonicalizePath("/restricted/path", "linux")).toBe(
+      "/restricted/path",
+    );
   });
 
   test("handles ENOTDIR by walking up (like ENOENT)", () => {
@@ -86,8 +92,28 @@ describe("canonicalizePath", () => {
         throw Object.assign(new Error("ENOTDIR"), { code: "ENOTDIR" });
       })
       .mockReturnValueOnce("/real/parent");
-    expect(canonicalizePath("/real/parent/not-a-dir")).toBe(
+    expect(canonicalizePath("/real/parent/not-a-dir", "linux")).toBe(
       "/real/parent/not-a-dir",
     );
   });
+
+  // ── injected platform flavor (win32-separator splitting) ──────────────
+
+  test("win32: splits and rejoins on the backslash separator", () => {
+    realpathSync
+      .mockImplementationOnce(() => {
+        throw enoent("C:\\projects\\link\\file.ts");
+      })
+      .mockReturnValueOnce("C:\\real\\app");
+    expect(canonicalizePath("C:\\projects\\link\\file.ts", "win32")).toBe(
+      "C:\\real\\app\\file.ts",
+    );
+  });
+
+  test("win32: resolves an existing path via realpathSync", () => {
+    realpathSync.mockReturnValueOnce("C:\\real\\app");
+    expect(canonicalizePath("C:\\projects\\link", "win32")).toBe(
+      "C:\\real\\app",
+    );
+  });
 });

package/test/forwarding-manager.test.ts

@@ -30,7 +30,11 @@ function makeForwarder() {
 }
 
 function makeManager() {
-  return new ForwardingManager("/agent/subagent-sessions", makeForwarder());
+  return new ForwardingManager(
+    "/agent/subagent-sessions",
+    makeForwarder(),
+    "linux",
+  );
 }
 
 // ── Tests ─────────────────────────────────────────────────────────────────
@@ -180,6 +184,7 @@ describe("ForwardingManager", () => {
       const manager = new ForwardingManager(
         "/custom/subagent-dir",
         makeForwarder(),
+        "linux",
       );
       const ctx = makeCtx();
       manager.start(ctx);
@@ -187,6 +192,7 @@ describe("ForwardingManager", () => {
       expect(mockIsSubagentExecutionContext).toHaveBeenCalledWith(
         ctx,
         "/custom/subagent-dir",
+        "linux",
         undefined,
       );
     });

package/test/handlers/external-directory-symlink-acceptance.test.ts

@@ -22,6 +22,7 @@ import {
 } from "#src/handlers/gates/descriptor";
 import { describeExternalDirectoryGate } from "#src/handlers/gates/external-directory";
 import type { ToolCallContext } from "#src/handlers/gates/types";
+import { PathNormalizer } from "#src/path-normalizer";
 import { PermissionResolver } from "#src/permission-resolver";
 import { SessionRules } from "#src/session-rules";
 import type { ScopeConfig } from "#src/types";
@@ -83,7 +84,13 @@ describe("external_directory symlink acceptance (#418)", () => {
       },
     });
     try {
-      const result = describeExternalDirectoryGate(readTcc(), [], resolver);
+      const result = describeExternalDirectoryGate(
+        readTcc(),
+        [],
+        resolver,
+        new PathNormalizer(process.platform, cwd),
+        "linux",
+      );
       expect(isGateDescriptor(result)).toBe(true);
       expect((result as GateDescriptor).preCheck?.state).toBe("allow");
     } finally {
@@ -101,7 +108,13 @@ describe("external_directory symlink acceptance (#418)", () => {
       },
     });
     try {
-      const result = describeExternalDirectoryGate(readTcc(), [], resolver);
+      const result = describeExternalDirectoryGate(
+        readTcc(),
+        [],
+        resolver,
+        new PathNormalizer(process.platform, cwd),
+        "linux",
+      );
       expect(isGateDescriptor(result)).toBe(true);
       expect((result as GateDescriptor).preCheck?.state).toBe("allow");
     } finally {
@@ -114,7 +127,13 @@ describe("external_directory symlink acceptance (#418)", () => {
       permission: { external_directory: { "*": "ask" } },
     });
     try {
-      const result = describeExternalDirectoryGate(readTcc(), [], resolver);
+      const result = describeExternalDirectoryGate(
+        readTcc(),
+        [],
+        resolver,
+        new PathNormalizer(process.platform, cwd),
+        "linux",
+      );
       expect(isGateDescriptor(result)).toBe(true);
       expect((result as GateDescriptor).preCheck?.state).toBe("ask");
     } finally {
@@ -137,7 +156,10 @@ describe("external_directory symlink acceptance (#418)", () => {
         toolCallId: "tc-2",
         cwd,
       };
-      const program = await BashProgram.parse(command, cwd);
+      const program = await BashProgram.parse(
+        command,
+        new PathNormalizer(process.platform, cwd),
+      );
       const result = describeBashExternalDirectoryGate(tcc, program, resolver);
       // All external paths are covered by the allow → bypass, no prompt.
       expect(isGateBypass(result)).toBe(true);

package/test/handlers/gates/bash-command-metamorphic.test.ts

@@ -12,6 +12,7 @@
 import { describe, expect, it } from "vitest";
 import { BashProgram } from "#src/access-intent/bash/program";
 import { resolveBashCommandCheck } from "#src/handlers/gates/bash-command";
+import { PathNormalizer } from "#src/path-normalizer";
 import type { ScopedPermissionResolver } from "#src/permission-resolver";
 import type { PermissionState } from "#src/types";
 
@@ -48,7 +49,10 @@ async function decide(
   command: string,
   resolver: ScopedPermissionResolver,
 ): Promise<PermissionState> {
-  const program = await BashProgram.parse(command, "/cwd");
+  const program = await BashProgram.parse(
+    command,
+    new PathNormalizer(process.platform, "/cwd"),
+  );
   return resolveBashCommandCheck(
     command,
     program.commands(),

package/test/handlers/gates/bash-external-directory.test.ts

@@ -9,6 +9,7 @@ import type {
 } from "#src/handlers/gates/descriptor";
 import { isGateBypass, isGateDescriptor } from "#src/handlers/gates/descriptor";
 import type { ToolCallContext } from "#src/handlers/gates/types";
+import { PathNormalizer } from "#src/path-normalizer";
 import type { ScopedPermissionResolver } from "#src/permission-resolver";
 import type { PermissionCheckResult } from "#src/types";
 import { getNonEmptyString, toRecord } from "#src/value-guards";
@@ -44,7 +45,6 @@ function makeCheckResult(
 /** Extract the policy match values a resolve(intent) call carries. */
 function intentValues(intent: AccessIntent): readonly string[] {
   if (intent.kind === "access-path") return intent.path.matchValues();
-  if (intent.kind === "path-values") return intent.values;
   return [];
 }
 
@@ -60,7 +60,10 @@ async function describeGate(
   const command = getNonEmptyString(toRecord(tcc.input).command);
   const bashProgram =
     tcc.toolName === "bash" && command
-      ? await BashProgram.parse(command, tcc.cwd)
+      ? await BashProgram.parse(
+          command,
+          new PathNormalizer(process.platform, tcc.cwd),
+        )
       : null;
   return describeBashExternalDirectoryGate(tcc, bashProgram, resolver);
 }

package/test/handlers/gates/bash-path.test.ts

@@ -9,6 +9,7 @@ vi.mock("node:os", () => {
   };
 });
 
+import { AccessPath } from "#src/access-intent/access-path";
 import { BashProgram } from "#src/access-intent/bash/program";
 import { describeBashPathGate } from "#src/handlers/gates/bash-path";
 import type {
@@ -18,6 +19,7 @@ import type {
 } from "#src/handlers/gates/descriptor";
 import { isGateBypass, isGateDescriptor } from "#src/handlers/gates/descriptor";
 import type { ToolCallContext } from "#src/handlers/gates/types";
+import { PathNormalizer } from "#src/path-normalizer";
 import type { ScopedPermissionResolver } from "#src/permission-resolver";
 import { getNonEmptyString, toRecord } from "#src/value-guards";
 
@@ -44,7 +46,10 @@ async function describeGate(
   const command = getNonEmptyString(toRecord(tcc.input).command);
   const bashProgram =
     tcc.toolName === "bash" && command
-      ? await BashProgram.parse(command, tcc.cwd)
+      ? await BashProgram.parse(
+          command,
+          new PathNormalizer(process.platform, tcc.cwd),
+        )
       : null;
   return describeBashPathGate(tcc, bashProgram, resolver);
 }
@@ -229,13 +234,13 @@ describe("describeBashPathGate", () => {
     )) as GateDescriptor;
 
     expect(resolver.resolve).toHaveBeenCalledWith({
-      kind: "path-values",
+      kind: "access-path",
       surface: "path",
-      values: [
-        "/test/project/nested/src/file.txt",
-        "nested/src/file.txt",
-        "src/file.txt",
-      ],
+      path: AccessPath.forPath("src/file.txt", {
+        cwd: "/test/project",
+        resolveBase: "/test/project/nested",
+        platform: "linux",
+      }),
       agentName: undefined,
     });
     // The raw token drives the prompt, denial context, and session approval.
@@ -256,9 +261,9 @@ describe("describeBashPathGate", () => {
     );
 
     expect(resolver.resolve).toHaveBeenCalledWith({
-      kind: "path-values",
+      kind: "access-path",
       surface: "path",
-      values: ["src/foo.ts"],
+      path: AccessPath.forLiteral("src/foo.ts"),
       agentName: undefined,
     });
   });

package/test/handlers/gates/external-directory-policy.test.ts

@@ -25,7 +25,10 @@ function makeCheckResult(
 
 describe("resolveExternalDirectoryPolicy", () => {
   it("resolves the path's match aliases on the external_directory surface (#418)", () => {
-    const path = AccessPath.forExternalDirectory("/outside/a.ts", cwd);
+    const path = AccessPath.forPath("/outside/a.ts", {
+      cwd,
+      platform: "linux",
+    });
     const resolver = makeResolver(makeCheckResult("ask"));
 
     const result = resolveExternalDirectoryPolicy(path, resolver, undefined);
@@ -40,7 +43,10 @@ describe("resolveExternalDirectoryPolicy", () => {
   });
 
   it("threads the agent name through to the resolver", () => {
-    const path = AccessPath.forExternalDirectory("/outside/a.ts", cwd);
+    const path = AccessPath.forPath("/outside/a.ts", {
+      cwd,
+      platform: "linux",
+    });
     const resolver = makeResolver(makeCheckResult("allow"));
 
     resolveExternalDirectoryPolicy(path, resolver, "reviewer");
@@ -57,8 +63,8 @@ describe("resolveExternalDirectoryPolicy", () => {
 describe("selectUncoveredExternalPaths", () => {
   it("returns no uncovered paths when every path resolves to allow", () => {
     const paths = [
-      AccessPath.forExternalDirectory("/outside/a.ts", cwd),
-      AccessPath.forExternalDirectory("/outside/b.ts", cwd),
+      AccessPath.forPath("/outside/a.ts", { cwd, platform: "linux" }),
+      AccessPath.forPath("/outside/b.ts", { cwd, platform: "linux" }),
     ];
     const resolver = makeResolver(makeCheckResult("allow"));
 
@@ -73,16 +79,18 @@ describe("selectUncoveredExternalPaths", () => {
   });
 
   it("collects only paths whose resolved state is not allow", () => {
-    const allowed = AccessPath.forExternalDirectory("/outside/ok.ts", cwd);
-    const asked = AccessPath.forExternalDirectory("/outside/ask.ts", cwd);
+    const allowed = AccessPath.forPath("/outside/ok.ts", {
+      cwd,
+      platform: "linux",
+    });
+    const asked = AccessPath.forPath("/outside/ask.ts", {
+      cwd,
+      platform: "linux",
+    });
     const resolver = makeResolver();
     resolver.resolve.mockImplementation((intent) => {
       const values =
-        intent.kind === "access-path"
-          ? intent.path.matchValues()
-          : intent.kind === "path-values"
-            ? intent.values
-            : [];
+        intent.kind === "access-path" ? intent.path.matchValues() : [];
       return values.includes("/outside/ok.ts")
         ? makeCheckResult("allow")
         : makeCheckResult("ask");
@@ -98,16 +106,18 @@ describe("selectUncoveredExternalPaths", () => {
   });
 
   it("returns the most restrictive uncovered check as worstCheck (deny > ask)", () => {
-    const asked = AccessPath.forExternalDirectory("/outside/ask.ts", cwd);
-    const denied = AccessPath.forExternalDirectory("/outside/deny.ts", cwd);
+    const asked = AccessPath.forPath("/outside/ask.ts", {
+      cwd,
+      platform: "linux",
+    });
+    const denied = AccessPath.forPath("/outside/deny.ts", {
+      cwd,
+      platform: "linux",
+    });
     const resolver = makeResolver();
     resolver.resolve.mockImplementation((intent) => {
       const values =
-        intent.kind === "access-path"
-          ? intent.path.matchValues()
-          : intent.kind === "path-values"
-            ? intent.values
-            : [];
+        intent.kind === "access-path" ? intent.path.matchValues() : [];
       return values.includes("/outside/deny.ts")
         ? makeCheckResult("deny")
         : makeCheckResult("ask");

package/test/handlers/gates/external-directory.test.ts

@@ -7,6 +7,7 @@ import type {
 import { isGateBypass, isGateDescriptor } from "#src/handlers/gates/descriptor";
 import { describeExternalDirectoryGate } from "#src/handlers/gates/external-directory";
 import type { ToolCallContext } from "#src/handlers/gates/types";
+import { PathNormalizer } from "#src/path-normalizer";
 import type { ScopedPermissionResolver } from "#src/permission-resolver";
 import type { ToolAccessExtractorLookup } from "#src/tool-access-extractor-registry";
 import { makeResolver } from "#test/helpers/gate-fixtures";
@@ -37,7 +38,14 @@ function gateUnderTest(
     makeCheckResult({ state: "ask", toolName: "external_directory" }),
   ),
 ) {
-  return describeExternalDirectoryGate(tcc, infraDirs, resolver, extractors);
+  return describeExternalDirectoryGate(
+    tcc,
+    infraDirs,
+    resolver,
+    new PathNormalizer(process.platform, tcc.cwd),
+    "linux",
+    extractors,
+  );
 }
 
 // ── tests ────────────────────��────────────────────────────────────��────────