@gotgenes/pi-permission-system 18.0.0 → 18.0.2

package/test/path-normalization.test.ts

@@ -0,0 +1,233 @@
+import { join } from "node:path";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+// Mock node:os so tilde-expansion is deterministic across platforms.
+vi.mock("node:os", () => {
+  const homedir = vi.fn(() => "/mock/home");
+  return {
+    homedir,
+    default: { homedir },
+  };
+});
+
+// Mock node:fs so realpathSync (used by canonicalizePath) is controllable.
+// Default implementation is identity — existing lexical tests are unaffected.
+const realpathSync = vi.hoisted(() =>
+  vi.fn<(path: string) => string>((p) => p),
+);
+vi.mock("node:fs", () => ({
+  realpathSync,
+  default: { realpathSync },
+}));
+
+import {
+  canonicalNormalizePathForComparison,
+  getPathPolicyValues,
+  normalizePathForComparison,
+  normalizePathPolicyLiteral,
+} from "#src/access-intent/path-normalization";
+
+describe("normalizePathForComparison", () => {
+  const cwd = "/projects/my-app";
+
+  test("resolves absolute path unchanged", () => {
+    expect(normalizePathForComparison("/usr/local/bin", cwd, "linux")).toBe(
+      "/usr/local/bin",
+    );
+  });
+
+  test("resolves relative path against cwd", () => {
+    expect(normalizePathForComparison("src/foo.ts", cwd, "linux")).toBe(
+      "/projects/my-app/src/foo.ts",
+    );
+  });
+
+  test("expands bare ~ to homedir", () => {
+    expect(normalizePathForComparison("~", cwd, "linux")).toBe("/mock/home");
+  });
+
+  test("expands ~/... to homedir-relative path", () => {
+    expect(normalizePathForComparison("~/docs/readme.md", cwd, "linux")).toBe(
+      join("/mock/home", "docs/readme.md"),
+    );
+  });
+
+  test("expands bare $HOME to homedir", () => {
+    expect(normalizePathForComparison("$HOME", cwd, "linux")).toBe(
+      "/mock/home",
+    );
+  });
+
+  test("expands $HOME/... to homedir-relative path", () => {
+    expect(normalizePathForComparison("$HOME/.ssh/config", cwd, "linux")).toBe(
+      join("/mock/home", ".ssh/config"),
+    );
+  });
+
+  test("strips leading @ before resolving", () => {
+    expect(normalizePathForComparison("@/usr/local/bin", cwd, "linux")).toBe(
+      "/usr/local/bin",
+    );
+  });
+
+  test("strips surrounding quotes", () => {
+    expect(normalizePathForComparison("'/usr/local/bin'", cwd, "linux")).toBe(
+      "/usr/local/bin",
+    );
+    expect(normalizePathForComparison('"/usr/local/bin"', cwd, "linux")).toBe(
+      "/usr/local/bin",
+    );
+  });
+
+  test("returns empty string for blank/whitespace-only path", () => {
+    expect(normalizePathForComparison("", cwd, "linux")).toBe("");
+    expect(normalizePathForComparison("   ", cwd, "linux")).toBe("");
+  });
+
+  // ── injected platform flavor (Windows is case-folded, win32-resolved) ────
+
+  test("win32: lowercases the resolved absolute path", () => {
+    expect(
+      normalizePathForComparison(
+        "C:\\Users\\Foo\\Bar.txt",
+        "C:\\Projects",
+        "win32",
+      ),
+    ).toBe("c:\\users\\foo\\bar.txt");
+  });
+
+  test("win32: resolves a relative path against cwd with win32 rules", () => {
+    expect(
+      normalizePathForComparison("src\\foo.ts", "C:\\Projects\\App", "win32"),
+    ).toBe("c:\\projects\\app\\src\\foo.ts");
+  });
+
+  test("posix platform leaves case untouched", () => {
+    expect(
+      normalizePathForComparison("/Projects/App/Src.ts", cwd, "linux"),
+    ).toBe("/Projects/App/Src.ts");
+  });
+});
+
+describe("canonicalNormalizePathForComparison", () => {
+  const cwd = "/projects/my-app";
+
+  beforeEach(() => {
+    realpathSync.mockReset();
+    realpathSync.mockImplementation((p: string) => p);
+  });
+
+  test("returns canonical form of an existing path", () => {
+    realpathSync.mockImplementation((p: string) => {
+      if (p === "/projects/link") return "/real/projects/app";
+      return p;
+    });
+    expect(
+      canonicalNormalizePathForComparison("/projects/link", cwd, "linux"),
+    ).toBe("/real/projects/app");
+  });
+
+  test("returns empty string for empty input", () => {
+    expect(canonicalNormalizePathForComparison("", cwd, "linux")).toBe("");
+  });
+
+  test("returns lexical form when no symlinks (identity realpathSync)", () => {
+    expect(
+      canonicalNormalizePathForComparison(
+        "/projects/my-app/src/index.ts",
+        cwd,
+        "linux",
+      ),
+    ).toBe("/projects/my-app/src/index.ts");
+  });
+
+  test("win32: lowercases the canonical form", () => {
+    expect(
+      canonicalNormalizePathForComparison(
+        "C:\\Projects\\App\\Src",
+        "C:\\Projects\\App",
+        "win32",
+      ),
+    ).toBe("c:\\projects\\app\\src");
+  });
+});
+
+describe("normalizePathPolicyLiteral", () => {
+  test("returns a relative token unchanged", () => {
+    expect(normalizePathPolicyLiteral("src/foo.ts")).toBe("src/foo.ts");
+  });
+
+  test("trims and strips simple wrapping quotes", () => {
+    expect(normalizePathPolicyLiteral("  'src/foo.ts'  ")).toBe("src/foo.ts");
+    expect(normalizePathPolicyLiteral('"a/b"')).toBe("a/b");
+  });
+
+  test("strips a leading @ prefix", () => {
+    expect(normalizePathPolicyLiteral("@src/foo.ts")).toBe("src/foo.ts");
+  });
+
+  test("expands ~ to the home directory", () => {
+    expect(normalizePathPolicyLiteral("~/docs/readme.md")).toBe(
+      join("/mock/home", "docs/readme.md"),
+    );
+  });
+
+  test("does not resolve a relative value against any cwd", () => {
+    expect(normalizePathPolicyLiteral("foo.ts")).toBe("foo.ts");
+  });
+
+  test("returns empty string for blank input", () => {
+    expect(normalizePathPolicyLiteral("   ")).toBe("");
+  });
+
+  test("preserves the surface catch-all", () => {
+    expect(normalizePathPolicyLiteral("*")).toBe("*");
+  });
+});
+
+describe("getPathPolicyValues", () => {
+  const cwd = "/projects/my-app";
+
+  test("returns only the literal when no base is available", () => {
+    expect(getPathPolicyValues("src/foo.ts", {}, "linux")).toEqual([
+      "src/foo.ts",
+    ]);
+    expect(getPathPolicyValues("src/foo.ts", {}, "linux")).toEqual([
+      "src/foo.ts",
+    ]);
+  });
+
+  test("adds absolute and project-relative aliases for a relative token", () => {
+    expect(getPathPolicyValues("src/foo.ts", { cwd }, "linux")).toEqual([
+      "/projects/my-app/src/foo.ts",
+      "src/foo.ts",
+    ]);
+  });
+
+  test("omits the relative alias for a token outside cwd", () => {
+    expect(getPathPolicyValues("/etc/hosts", { cwd }, "linux")).toEqual([
+      "/etc/hosts",
+    ]);
+  });
+
+  test("resolves against resolveBase while aliasing relative to cwd", () => {
+    expect(
+      getPathPolicyValues(
+        "foo.txt",
+        {
+          cwd,
+          resolveBase: "/projects/my-app/nested",
+        },
+        "linux",
+      ),
+    ).toEqual(["/projects/my-app/nested/foo.txt", "nested/foo.txt", "foo.txt"]);
+  });
+
+  test("preserves the surface catch-all", () => {
+    expect(getPathPolicyValues("*", { cwd }, "linux")).toEqual(["*"]);
+  });
+
+  test("returns empty for blank input", () => {
+    expect(getPathPolicyValues("   ", { cwd }, "linux")).toEqual([]);
+  });
+});

package/test/path-normalizer.test.ts

@@ -78,6 +78,36 @@ describe("PathNormalizer", () => {
       expect(normalizer.isOutsideWorkingDirectory("/etc/hosts")).toBe(true);
     });
 
+    test("isOutsideWorkingDirectory expands a home-relative token", () => {
+      expect(normalizer.isOutsideWorkingDirectory("~/secrets")).toBe(true);
+    });
+
+    test("isOutsideWorkingDirectory resolves a relative token inside cwd", () => {
+      expect(normalizer.isOutsideWorkingDirectory("src/index.ts")).toBe(false);
+    });
+
+    test("isOutsideWorkingDirectory follows an in-cwd symlink to an external target", () => {
+      // ./link -> /etc: realpathSync resolves the full token in one call.
+      realpathSync.mockImplementation((p: string) => {
+        if (p === "/projects/my-app/link/hosts") return "/etc/hosts";
+        return p;
+      });
+      expect(normalizer.isOutsideWorkingDirectory("./link/hosts")).toBe(true);
+    });
+
+    test("isOutsideWorkingDirectory keeps a path inside a symlinked cwd", () => {
+      // /tmp -> /private/tmp on macOS; cwd reported as the resolved /private/tmp.
+      realpathSync.mockImplementation((p: string) => {
+        if (p.startsWith("/tmp/")) return `/private/tmp${p.slice(4)}`;
+        if (p === "/tmp") return "/private/tmp";
+        return p;
+      });
+      const symlinkNormalizer = new PathNormalizer("linux", "/private/tmp");
+      expect(
+        symlinkNormalizer.isOutsideWorkingDirectory("/tmp/workspace/file.ts"),
+      ).toBe(false);
+    });
+
     test("comparableValue returns the lexical absolute form (no FS)", () => {
       expect(normalizer.comparableValue("src/foo.ts")).toBe(
         "/projects/my-app/src/foo.ts",

package/test/path-surfaces.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "vitest";
+
+import {
+  PATH_BEARING_TOOLS,
+  PATH_SURFACES,
+  READ_ONLY_PATH_BEARING_TOOLS,
+} from "#src/path-surfaces";
+
+describe("PATH_BEARING_TOOLS", () => {
+  test("contains the expected tool names", () => {
+    for (const tool of ["read", "write", "edit", "find", "grep", "ls"]) {
+      expect(PATH_BEARING_TOOLS.has(tool)).toBe(true);
+    }
+  });
+
+  test("does not contain bash or mcp", () => {
+    expect(PATH_BEARING_TOOLS.has("bash")).toBe(false);
+    expect(PATH_BEARING_TOOLS.has("mcp")).toBe(false);
+  });
+});
+
+describe("READ_ONLY_PATH_BEARING_TOOLS", () => {
+  test("contains read, find, grep, ls", () => {
+    for (const tool of ["read", "find", "grep", "ls"]) {
+      expect(READ_ONLY_PATH_BEARING_TOOLS.has(tool)).toBe(true);
+    }
+  });
+
+  test("does not contain write or edit", () => {
+    expect(READ_ONLY_PATH_BEARING_TOOLS.has("write")).toBe(false);
+    expect(READ_ONLY_PATH_BEARING_TOOLS.has("edit")).toBe(false);
+  });
+});
+
+describe("PATH_SURFACES", () => {
+  test("contains the path-bearing tools plus the cross-cutting gates", () => {
+    for (const surface of [
+      "read",
+      "write",
+      "edit",
+      "find",
+      "grep",
+      "ls",
+      "external_directory",
+      "path",
+    ]) {
+      expect(PATH_SURFACES.has(surface)).toBe(true);
+    }
+  });
+
+  test("does not contain bash or mcp", () => {
+    expect(PATH_SURFACES.has("bash")).toBe(false);
+    expect(PATH_SURFACES.has("mcp")).toBe(false);
+  });
+});

package/test/permission-manager-unified.test.ts

@@ -9,12 +9,12 @@ import { homedir, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { describe, expect, it, test } from "vitest";
 import type { ResolvedAccessIntent } from "#src/access-intent/access-intent";
+import { getPathPolicyValues } from "#src/access-intent/path-normalization";
 import {
   getGlobalConfigPath,
   getProjectAgentsDir,
   getProjectConfigPath,
 } from "#src/config-paths";
-import { getPathPolicyValues } from "#src/path-utils";
 import {
   PermissionManager,
   type ScopedPermissionManager,

package/test/pi-infrastructure-read.test.ts

@@ -16,7 +16,7 @@ vi.mock("node:child_process", () => ({
 }));
 
 import { discoverGlobalNodeModulesRoot } from "#src/node-modules-discovery";
-import { isPiInfrastructureRead } from "#src/path-utils";
+import { isPiInfrastructureRead } from "#src/pi-infrastructure-read";
 
 // ── discoverGlobalNodeModulesRoot ──────────────────────────────────────────
 
@@ -390,3 +390,43 @@ describe("isPiInfrastructureRead with glob patterns", () => {
     ).toBe(false);
   });
 });
+
+// ── isPiInfrastructureRead — win32 case-insensitive matching ───────────────
+
+describe("isPiInfrastructureRead on win32", () => {
+  test("plain infra dir matches a case-different path", () => {
+    expect(
+      isPiInfrastructureRead(
+        "read",
+        "c:\\users\\foo\\.pi\\agent\\config.json",
+        ["C:\\Users\\Foo\\.pi\\agent"],
+        "C:\\proj",
+        "win32",
+      ),
+    ).toBe(true);
+  });
+
+  test("glob infra dir matches case-insensitively", () => {
+    expect(
+      isPiInfrastructureRead(
+        "read",
+        "c:\\users\\foo\\npm\\node_modules\\@earendil-works\\pi-coding-agent\\skill.md",
+        ["C:\\Users\\Foo\\**\\pi-coding-agent\\**"],
+        "C:\\proj",
+        "win32",
+      ),
+    ).toBe(true);
+  });
+
+  test("rejects a path outside every infra dir", () => {
+    expect(
+      isPiInfrastructureRead(
+        "read",
+        "c:\\windows\\system32\\drivers\\etc\\hosts",
+        ["C:\\Users\\Foo\\.pi\\agent"],
+        "C:\\proj",
+        "win32",
+      ),
+    ).toBe(false);
+  });
+});

package/test/safe-system-paths.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "vitest";
+
+import { isSafeSystemPath, SAFE_SYSTEM_PATHS } from "#src/safe-system-paths";
+
+describe("SAFE_SYSTEM_PATHS", () => {
+  test("contains /dev/null, /dev/stdin, /dev/stdout, /dev/stderr", () => {
+    expect(SAFE_SYSTEM_PATHS.has("/dev/null")).toBe(true);
+    expect(SAFE_SYSTEM_PATHS.has("/dev/stdin")).toBe(true);
+    expect(SAFE_SYSTEM_PATHS.has("/dev/stdout")).toBe(true);
+    expect(SAFE_SYSTEM_PATHS.has("/dev/stderr")).toBe(true);
+  });
+});
+
+describe("isSafeSystemPath", () => {
+  test("returns true for /dev/null", () => {
+    expect(isSafeSystemPath("/dev/null")).toBe(true);
+  });
+
+  test("returns true for /dev/stdin", () => {
+    expect(isSafeSystemPath("/dev/stdin")).toBe(true);
+  });
+
+  test("returns true for /dev/stdout", () => {
+    expect(isSafeSystemPath("/dev/stdout")).toBe(true);
+  });
+
+  test("returns true for /dev/stderr", () => {
+    expect(isSafeSystemPath("/dev/stderr")).toBe(true);
+  });
+
+  test("returns false for an arbitrary absolute path", () => {
+    expect(isSafeSystemPath("/etc/passwd")).toBe(false);
+  });
+
+  test("returns false for a path prefixed with a safe system path", () => {
+    expect(isSafeSystemPath("/dev/null/subdir")).toBe(false);
+  });
+
+  test("returns false for an empty string", () => {
+    expect(isSafeSystemPath("")).toBe(false);
+  });
+
+  test("returns false for a relative path", () => {
+    expect(isSafeSystemPath("dev/null")).toBe(false);
+  });
+});

package/test/tool-input-path.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "vitest";
+import type { ToolAccessExtractorLookup } from "#src/tool-access-extractor-registry";
+import { getPathBearingToolPath, getToolInputPath } from "#src/tool-input-path";
+
+describe("getPathBearingToolPath", () => {
+  test("returns path for a path-bearing tool", () => {
+    expect(getPathBearingToolPath("read", { path: "/src/foo.ts" })).toBe(
+      "/src/foo.ts",
+    );
+  });
+
+  test("returns null for a non-path-bearing tool", () => {
+    expect(getPathBearingToolPath("bash", { path: "/src/foo.ts" })).toBeNull();
+    expect(getPathBearingToolPath("mcp", { path: "/src/foo.ts" })).toBeNull();
+    expect(getPathBearingToolPath("task", { path: "/src/foo.ts" })).toBeNull();
+  });
+
+  test("returns null when input has no path", () => {
+    expect(getPathBearingToolPath("read", {})).toBeNull();
+    expect(getPathBearingToolPath("read", { path: "" })).toBeNull();
+    expect(getPathBearingToolPath("read", null)).toBeNull();
+  });
+});
+
+describe("getToolInputPath", () => {
+  function lookupOf(
+    toolName: string,
+    extractor: (input: Record<string, unknown>) => string | undefined,
+  ): ToolAccessExtractorLookup {
+    return {
+      get: (name) => (name === toolName ? extractor : undefined),
+    };
+  }
+
+  test("returns input.path for a built-in path-bearing tool", () => {
+    expect(getToolInputPath("read", { path: "/src/foo.ts" })).toBe(
+      "/src/foo.ts",
+    );
+    expect(getToolInputPath("write", { path: "/src/bar.ts" })).toBe(
+      "/src/bar.ts",
+    );
+  });
+
+  test("returns null for bash", () => {
+    expect(getToolInputPath("bash", { path: "/src/foo.ts" })).toBeNull();
+  });
+
+  test("returns the MCP arguments.path for an mcp call", () => {
+    expect(getToolInputPath("mcp", { arguments: { path: "/etc/hosts" } })).toBe(
+      "/etc/hosts",
+    );
+  });
+
+  test("returns null for an mcp call without an arguments.path", () => {
+    expect(getToolInputPath("mcp", { arguments: { query: "x" } })).toBeNull();
+    expect(getToolInputPath("mcp", {})).toBeNull();
+  });
+
+  test("defaults to input.path for an unregistered extension tool", () => {
+    expect(getToolInputPath("my-ext", { path: "/work/file.txt" })).toBe(
+      "/work/file.txt",
+    );
+  });
+
+  test("returns null for an extension tool without a path", () => {
+    expect(getToolInputPath("my-ext", { other: true })).toBeNull();
+    expect(getToolInputPath("my-ext", { path: "" })).toBeNull();
+    expect(getToolInputPath("my-ext", null)).toBeNull();
+  });
+
+  test("uses a registered extractor's path over the default convention", () => {
+    const extractors = lookupOf("ffgrep", (input) =>
+      typeof input.target === "string" ? input.target : undefined,
+    );
+    expect(
+      getToolInputPath("ffgrep", { target: "/etc/passwd" }, extractors),
+    ).toBe("/etc/passwd");
+  });
+
+  test("returns null when a registered extractor declines", () => {
+    const extractors = lookupOf("ffgrep", () => undefined);
+    expect(getToolInputPath("ffgrep", { target: "x" }, extractors)).toBeNull();
+  });
+});