@gotgenes/pi-permission-system 8.1.0 → 8.2.1

package/test/helpers/manager-harness.ts

@@ -0,0 +1,51 @@
+/**
+ * Filesystem-backed PermissionManager harness for integration tests.
+ *
+ * Writes a real config file and agents directory to a temp directory so
+ * PermissionManager can load them without mocking the file system.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { PermissionManager } from "#src/permission-manager";
+import type { ScopeConfig } from "#src/types";
+
+export type CreateManagerOptions = {
+  mcpServerNames?: readonly string[];
+};
+
+export function createManager(
+  config: ScopeConfig,
+  agentFiles: Record<string, string> = {},
+  options: CreateManagerOptions = {},
+) {
+  const baseDir = mkdtempSync(join(tmpdir(), "pi-permission-system-test-"));
+  const globalConfigPath = join(baseDir, "pi-permissions.jsonc");
+  const agentsDir = join(baseDir, "agents");
+
+  mkdirSync(agentsDir, { recursive: true });
+  writeFileSync(
+    globalConfigPath,
+    `${JSON.stringify(config, null, 2)}\n`,
+    "utf8",
+  );
+
+  for (const [name, content] of Object.entries(agentFiles)) {
+    writeFileSync(join(agentsDir, `${name}.md`), content, "utf8");
+  }
+
+  const manager = new PermissionManager({
+    globalConfigPath,
+    agentsDir,
+    mcpServerNames: options.mcpServerNames,
+  });
+
+  return {
+    manager,
+    globalConfigPath,
+    cleanup: (): void => {
+      rmSync(baseDir, { recursive: true, force: true });
+    },
+  };
+}

package/test/permission-session.test.ts

@@ -36,8 +36,10 @@ import {
   PermissionSession,
   type PermissionSessionRuntimeDeps,
 } from "#src/permission-session";
+import { SessionApproval } from "#src/session-approval";
 import type { SessionLogger } from "#src/session-logger";
 import type { SkillPromptEntry } from "#src/skill-prompt-sanitizer";
+import { makeCtx } from "#test/helpers/handler-fixtures";
 
 function makeSkillEntry(
   name: string,
@@ -93,25 +95,6 @@ function makeForwarding(): ForwardingController {
   };
 }
 
-function makeCtx(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
-  return {
-    cwd: "/test/project",
-    hasUI: true,
-    ui: {
-      setStatus: vi.fn(),
-      notify: vi.fn(),
-      select: vi.fn(),
-      input: vi.fn(),
-    },
-    sessionManager: {
-      getEntries: vi.fn().mockReturnValue([]),
-      getSessionDir: vi.fn().mockReturnValue("/sessions/test"),
-      addEntry: vi.fn(),
-    },
-    ...overrides,
-  } as unknown as ExtensionContext;
-}
-
 function makePermissionManager(
   overrides: Partial<PermissionManager> = {},
 ): PermissionManager {
@@ -219,9 +202,11 @@ describe("PermissionSession", () => {
       expect(rules).toEqual([]);
     });
 
-    it("delegates approveSessionRule to internal SessionRules", () => {
+    it("delegates recordSessionApproval to internal SessionRules", () => {
       const { session } = createSession();
-      session.approveSessionRule("bash", "/usr/bin/*");
+      session.recordSessionApproval(
+        SessionApproval.single("bash", "/usr/bin/*"),
+      );
       const rules = session.getSessionRuleset();
       expect(rules).toHaveLength(1);
       expect(rules[0]).toMatchObject({
@@ -325,7 +310,7 @@ describe("PermissionSession", () => {
   describe("shutdown", () => {
     it("clears session rules", () => {
       const { session } = createSession();
-      session.approveSessionRule("bash", "*");
+      session.recordSessionApproval(SessionApproval.single("bash", "*"));
       expect(session.getSessionRuleset()).toHaveLength(1);
 
       session.shutdown();

package/test/permission-system.test.ts

@@ -9,7 +9,6 @@ import {
 import { homedir, tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { expect, test } from "vitest";
-
 import {
   createActiveToolsCacheKey,
   createBeforeAgentStartPromptStateKey,
@@ -47,45 +46,10 @@ import {
   canResolveAskPermissionRequest,
   shouldAutoApprovePermissionState,
 } from "#src/yolo-mode";
-
-type CreateManagerOptions = {
-  mcpServerNames?: readonly string[];
-};
-
-function createManager(
-  config: ScopeConfig,
-  agentFiles: Record<string, string> = {},
-  options: CreateManagerOptions = {},
-) {
-  const baseDir = mkdtempSync(join(tmpdir(), "pi-permission-system-test-"));
-  const globalConfigPath = join(baseDir, "pi-permissions.jsonc");
-  const agentsDir = join(baseDir, "agents");
-
-  mkdirSync(agentsDir, { recursive: true });
-  writeFileSync(
-    globalConfigPath,
-    `${JSON.stringify(config, null, 2)}\n`,
-    "utf8",
-  );
-
-  for (const [name, content] of Object.entries(agentFiles)) {
-    writeFileSync(join(agentsDir, `${name}.md`), content, "utf8");
-  }
-
-  const manager = new PermissionManager({
-    globalConfigPath,
-    agentsDir,
-    mcpServerNames: options.mcpServerNames,
-  });
-
-  return {
-    manager,
-    globalConfigPath,
-    cleanup: (): void => {
-      rmSync(baseDir, { recursive: true, force: true });
-    },
-  };
-}
+import {
+  type CreateManagerOptions,
+  createManager,
+} from "#test/helpers/manager-harness";
 
 type MockHandler = (
   event: Record<string, unknown>,

package/test/scope-merge.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+import type { MergedScopes } from "#src/scope-merge";
+import { mergeScopesWithOrigins } from "#src/scope-merge";
+
+describe("mergeScopesWithOrigins", () => {
+  it("returns empty result for empty scopes array", () => {
+    const result: MergedScopes = mergeScopesWithOrigins([]);
+    expect(result.mergedPermission).toEqual({});
+    expect(result.origins.size).toBe(0);
+  });
+
+  it("attributes a string surface value to the contributing scope via the '*' pattern", () => {
+    const result = mergeScopesWithOrigins([
+      ["global", { permission: { bash: "allow" } }],
+    ]);
+    expect(result.mergedPermission).toEqual({ bash: "allow" });
+    expect(result.origins.get("bash")?.get("*")).toBe("global");
+  });
+
+  it("attributes each pattern of an object surface value to the contributing scope", () => {
+    const result = mergeScopesWithOrigins([
+      [
+        "project",
+        { permission: { bash: { "git *": "allow", "npm *": "deny" } } },
+      ],
+    ]);
+    expect(result.mergedPermission).toEqual({
+      bash: { "git *": "allow", "npm *": "deny" },
+    });
+    expect(result.origins.get("bash")?.get("git *")).toBe("project");
+    expect(result.origins.get("bash")?.get("npm *")).toBe("project");
+  });
+
+  it(
+    "shallow-merge: patterns not redefined by the higher scope keep their lower-scope origin;" +
+      " patterns the higher scope defines switch to the higher scope",
+    () => {
+      const result = mergeScopesWithOrigins([
+        [
+          "global",
+          { permission: { bash: { "ls *": "allow", "git *": "allow" } } },
+        ],
+        ["project", { permission: { bash: { "git *": "deny" } } }],
+      ]);
+      expect(result.mergedPermission).toEqual({
+        bash: { "ls *": "allow", "git *": "deny" },
+      });
+      // "ls *" was not touched by project — retains global attribution
+      expect(result.origins.get("bash")?.get("ls *")).toBe("global");
+      // "git *" was overridden by project — switches to project attribution
+      expect(result.origins.get("bash")?.get("git *")).toBe("project");
+    },
+  );
+
+  it("full replacement (string over object): higher scope re-attributes the entire surface to its own origin", () => {
+    const result = mergeScopesWithOrigins([
+      ["global", { permission: { bash: { "ls *": "allow" } } }],
+      ["project", { permission: { bash: "deny" } }],
+    ]);
+    expect(result.mergedPermission).toEqual({ bash: "deny" });
+    // The string value produces a single "*" pattern for the replacing scope
+    expect(result.origins.get("bash")?.get("*")).toBe("project");
+    // The former "ls *" pattern from global is gone — origins are replaced, not merged
+    expect(result.origins.get("bash")?.has("ls *")).toBe(false);
+  });
+
+  it("full replacement (object over string): higher scope re-attributes the entire surface to its own origin", () => {
+    const result = mergeScopesWithOrigins([
+      ["global", { permission: { bash: "ask" } }],
+      ["project", { permission: { bash: { "git *": "deny" } } }],
+    ]);
+    expect(result.mergedPermission).toEqual({ bash: { "git *": "deny" } });
+    // The object value attributes each pattern to the replacing scope
+    expect(result.origins.get("bash")?.get("git *")).toBe("project");
+    // The former "*" attribution from global is gone
+    expect(result.origins.get("bash")?.has("*")).toBe(false);
+  });
+
+  it("applies four-scope precedence in lowest→highest order (global → project → agent → project-agent)", () => {
+    const result = mergeScopesWithOrigins([
+      ["global", { permission: { read: "ask" } }],
+      ["project", { permission: { write: "deny" } }],
+      ["agent", { permission: { bash: "deny" } }],
+      ["project-agent", { permission: { mcp: "allow" } }],
+    ]);
+    expect(result.mergedPermission).toEqual({
+      read: "ask",
+      write: "deny",
+      bash: "deny",
+      mcp: "allow",
+    });
+    expect(result.origins.get("read")?.get("*")).toBe("global");
+    expect(result.origins.get("write")?.get("*")).toBe("project");
+    expect(result.origins.get("bash")?.get("*")).toBe("agent");
+    expect(result.origins.get("mcp")?.get("*")).toBe("project-agent");
+  });
+
+  it("skips scopes with no permission key, contributing nothing to either map", () => {
+    const result = mergeScopesWithOrigins([
+      ["global", {}],
+      ["project", { permission: { bash: "allow" } }],
+    ]);
+    expect(result.mergedPermission).toEqual({ bash: "allow" });
+    expect(result.origins.get("bash")?.get("*")).toBe("project");
+  });
+
+  it("attributes the universal '*' surface like any other (downstream reads origins.get('*')?.get('*') for universalFallbackOrigin)", () => {
+    const result = mergeScopesWithOrigins([
+      ["global", { permission: { "*": "deny" } }],
+      ["project", { permission: { "*": "allow" } }],
+    ]);
+    expect(result.mergedPermission).toEqual({ "*": "allow" });
+    // Both scopes write a string — each is a full replacement; project wins last
+    expect(result.origins.get("*")?.get("*")).toBe("project");
+  });
+});

package/test/session-approval.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+
+import { SessionApproval } from "#src/session-approval";
+
+describe("SessionApproval", () => {
+  describe("single", () => {
+    it("stores surface and one pattern", () => {
+      const approval = SessionApproval.single("bash", "git *");
+      expect(approval.surface).toBe("bash");
+      expect(approval.patterns).toEqual(["git *"]);
+    });
+
+    it("representativePattern returns the pattern", () => {
+      const approval = SessionApproval.single("bash", "git *");
+      expect(approval.representativePattern).toBe("git *");
+    });
+
+    it("toGateApproval returns { surface, pattern }", () => {
+      const approval = SessionApproval.single("bash", "git *");
+      expect(approval.toGateApproval()).toEqual({
+        surface: "bash",
+        pattern: "git *",
+      });
+    });
+  });
+
+  describe("multiple", () => {
+    it("stores surface and all patterns", () => {
+      const approval = SessionApproval.multiple("external_directory", [
+        "/outside/a/*",
+        "/outside/b/*",
+      ]);
+      expect(approval.surface).toBe("external_directory");
+      expect(approval.patterns).toEqual(["/outside/a/*", "/outside/b/*"]);
+    });
+
+    it("representativePattern returns the first pattern", () => {
+      const approval = SessionApproval.multiple("external_directory", [
+        "/outside/a/*",
+        "/outside/b/*",
+      ]);
+      expect(approval.representativePattern).toBe("/outside/a/*");
+    });
+
+    it("toGateApproval returns { surface, pattern } using the first pattern", () => {
+      const approval = SessionApproval.multiple("external_directory", [
+        "/outside/a/*",
+        "/outside/b/*",
+      ]);
+      expect(approval.toGateApproval()).toEqual({
+        surface: "external_directory",
+        pattern: "/outside/a/*",
+      });
+    });
+
+    it("defensive copy — mutating the source array does not affect patterns", () => {
+      const source = ["/outside/a/*", "/outside/b/*"];
+      const approval = SessionApproval.multiple("external_directory", source);
+      source.push("/outside/c/*");
+      expect(approval.patterns).toEqual(["/outside/a/*", "/outside/b/*"]);
+    });
+  });
+
+  describe("empty patterns (degenerate case)", () => {
+    it("representativePattern returns undefined", () => {
+      const approval = SessionApproval.multiple("external_directory", []);
+      expect(approval.representativePattern).toBeUndefined();
+    });
+
+    it("toGateApproval returns undefined", () => {
+      const approval = SessionApproval.multiple("external_directory", []);
+      expect(approval.toGateApproval()).toBeUndefined();
+    });
+  });
+});

package/test/session-rules.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 
 import { evaluate } from "#src/rule";
+import { SessionApproval } from "#src/session-approval";
 import { deriveApprovalPattern, SessionRules } from "#src/session-rules";
 
 // ── SessionRules ───────────────────────────────────────────────────────────
@@ -66,6 +67,54 @@ describe("SessionRules", () => {
     });
   });
 
+  describe("record", () => {
+    it("records a single-pattern approval as one rule", () => {
+      const rules = new SessionRules();
+      rules.record(SessionApproval.single("bash", "git *"));
+      expect(rules.getRuleset()).toEqual([
+        {
+          surface: "bash",
+          pattern: "git *",
+          action: "allow",
+          layer: "session",
+          origin: "session",
+        },
+      ]);
+    });
+
+    it("records a multi-pattern approval as one rule per pattern", () => {
+      const rules = new SessionRules();
+      rules.record(
+        SessionApproval.multiple("external_directory", [
+          "/outside/a/*",
+          "/outside/b/*",
+        ]),
+      );
+      expect(rules.getRuleset()).toHaveLength(2);
+      expect(rules.getRuleset()[0].pattern).toBe("/outside/a/*");
+      expect(rules.getRuleset()[1].pattern).toBe("/outside/b/*");
+    });
+
+    it("records each rule with the correct surface", () => {
+      const rules = new SessionRules();
+      rules.record(
+        SessionApproval.multiple("external_directory", [
+          "/outside/a/*",
+          "/outside/b/*",
+        ]),
+      );
+      for (const rule of rules.getRuleset()) {
+        expect(rule.surface).toBe("external_directory");
+      }
+    });
+
+    it("records nothing for an empty patterns list", () => {
+      const rules = new SessionRules();
+      rules.record(SessionApproval.multiple("external_directory", []));
+      expect(rules.getRuleset()).toEqual([]);
+    });
+  });
+
   describe("evaluate() integration", () => {
     it("returns allow for a path under an approved directory", () => {
       const session = new SessionRules();