@gotgenes/pi-permission-system 10.0.0 → 10.2.0

package/test/permission-forwarding.test.ts

@@ -1,14 +1,5 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { afterEach, describe, expect, test, vi } from "vitest";
 import {
-  confirmPermission,
-  processForwardedPermissionRequests,
-} from "#src/forwarded-permissions/polling";
-import {
-  createPermissionForwardingLocation,
   resolvePermissionForwardingTargetSessionId,
   SUBAGENT_PARENT_SESSION_ENV_CANDIDATES,
   SUBAGENT_PARENT_SESSION_ENV_KEY,
@@ -249,276 +240,3 @@ describe("resolvePermissionForwardingTargetSessionId — registry resolution", (
     ).toBe("parent-from-env");
   });
 });
-
-describe("processForwardedPermissionRequests", () => {
-  test("emits a UI prompt event before showing a forwarded permission dialog", async () => {
-    const root = mkdtempSync(join(tmpdir(), "permission-forwarding-"));
-    try {
-      const forwardingDir = join(root, "forwarding");
-      const location = createPermissionForwardingLocation(
-        forwardingDir,
-        "parent-session",
-      );
-      mkdirSync(location.requestsDir, { recursive: true });
-      mkdirSync(location.responsesDir, { recursive: true });
-      writeFileSync(
-        join(location.requestsDir, "req-forwarded.json"),
-        JSON.stringify({
-          id: "req-forwarded",
-          createdAt: Date.now(),
-          requesterSessionId: "child-session",
-          targetSessionId: "parent-session",
-          requesterAgentName: "Explore",
-          message: "Allow git push?",
-        }),
-        "utf-8",
-      );
-
-      const events = {
-        emit: vi.fn(),
-        on: vi.fn().mockReturnValue(() => undefined),
-      };
-      const requestPermissionDecisionFromUi = vi
-        .fn()
-        .mockResolvedValue({ approved: true, state: "approved" as const });
-
-      await processForwardedPermissionRequests(
-        {
-          hasUI: true,
-          ui: { select: vi.fn(), input: vi.fn() },
-          sessionManager: {
-            getSessionId: vi.fn().mockReturnValue("parent-session"),
-          },
-        } as unknown as ExtensionContext,
-        {
-          forwardingDir,
-          subagentSessionsDir: join(root, "subagents"),
-          events,
-          logger: { writeReviewLog: vi.fn(), writeDebugLog: vi.fn() },
-          writeReviewLog: vi.fn(),
-          requestPermissionDecisionFromUi,
-          shouldAutoApprove: () => false,
-        },
-      );
-
-      expect(events.emit).toHaveBeenCalledWith(
-        "permissions:ui_prompt",
-        expect.objectContaining({
-          requestId: "req-forwarded",
-          source: "tool_call",
-          surface: null,
-          value: null,
-          agentName: "Explore",
-          message: expect.stringContaining("Allow git push?"),
-          forwarding: {
-            requesterAgentName: "Explore",
-            requesterSessionId: "child-session",
-          },
-        }),
-      );
-      expect(requestPermissionDecisionFromUi).toHaveBeenCalled();
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test("emits a non-degraded UI prompt event when the request carries display fields", async () => {
-    const root = mkdtempSync(join(tmpdir(), "permission-forwarding-"));
-    try {
-      const forwardingDir = join(root, "forwarding");
-      const location = createPermissionForwardingLocation(
-        forwardingDir,
-        "parent-session",
-      );
-      mkdirSync(location.requestsDir, { recursive: true });
-      mkdirSync(location.responsesDir, { recursive: true });
-      writeFileSync(
-        join(location.requestsDir, "req-forwarded-rich.json"),
-        JSON.stringify({
-          id: "req-forwarded-rich",
-          createdAt: Date.now(),
-          requesterSessionId: "child-session",
-          targetSessionId: "parent-session",
-          requesterAgentName: "Explore",
-          message: "Allow git push?",
-          source: "tool_call",
-          surface: "bash",
-          value: "git push",
-        }),
-        "utf-8",
-      );
-
-      const events = {
-        emit: vi.fn(),
-        on: vi.fn().mockReturnValue(() => undefined),
-      };
-      const requestPermissionDecisionFromUi = vi
-        .fn()
-        .mockResolvedValue({ approved: true, state: "approved" as const });
-
-      await processForwardedPermissionRequests(
-        {
-          hasUI: true,
-          ui: { select: vi.fn(), input: vi.fn() },
-          sessionManager: {
-            getSessionId: vi.fn().mockReturnValue("parent-session"),
-          },
-        } as unknown as ExtensionContext,
-        {
-          forwardingDir,
-          subagentSessionsDir: join(root, "subagents"),
-          events,
-          logger: { writeReviewLog: vi.fn(), writeDebugLog: vi.fn() },
-          writeReviewLog: vi.fn(),
-          requestPermissionDecisionFromUi,
-          shouldAutoApprove: () => false,
-        },
-      );
-
-      expect(events.emit).toHaveBeenCalledWith(
-        "permissions:ui_prompt",
-        expect.objectContaining({
-          requestId: "req-forwarded-rich",
-          source: "tool_call",
-          surface: "bash",
-          value: "git push",
-          agentName: "Explore",
-          message: expect.stringContaining("Allow git push?"),
-          forwarding: {
-            requesterAgentName: "Explore",
-            requesterSessionId: "child-session",
-          },
-        }),
-      );
-      expect(requestPermissionDecisionFromUi).toHaveBeenCalled();
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test("does not emit a UI prompt event when forwarded permission auto-approves", async () => {
-    const root = mkdtempSync(join(tmpdir(), "permission-forwarding-"));
-    try {
-      const forwardingDir = join(root, "forwarding");
-      const location = createPermissionForwardingLocation(
-        forwardingDir,
-        "parent-session",
-      );
-      mkdirSync(location.requestsDir, { recursive: true });
-      mkdirSync(location.responsesDir, { recursive: true });
-      writeFileSync(
-        join(location.requestsDir, "req-forwarded-auto.json"),
-        JSON.stringify({
-          id: "req-forwarded-auto",
-          createdAt: Date.now(),
-          requesterSessionId: "child-session",
-          targetSessionId: "parent-session",
-          requesterAgentName: "Explore",
-          message: "Allow git push?",
-        }),
-        "utf-8",
-      );
-
-      const events = {
-        emit: vi.fn(),
-        on: vi.fn().mockReturnValue(() => undefined),
-      };
-      const requestPermissionDecisionFromUi = vi.fn();
-
-      await processForwardedPermissionRequests(
-        {
-          hasUI: true,
-          ui: { select: vi.fn(), input: vi.fn() },
-          sessionManager: {
-            getSessionId: vi.fn().mockReturnValue("parent-session"),
-          },
-        } as unknown as ExtensionContext,
-        {
-          forwardingDir,
-          subagentSessionsDir: join(root, "subagents"),
-          events,
-          logger: { writeReviewLog: vi.fn(), writeDebugLog: vi.fn() },
-          writeReviewLog: vi.fn(),
-          requestPermissionDecisionFromUi,
-          shouldAutoApprove: () => true,
-        },
-      );
-
-      expect(events.emit).not.toHaveBeenCalledWith(
-        "permissions:ui_prompt",
-        expect.anything(),
-      );
-      expect(requestPermissionDecisionFromUi).not.toHaveBeenCalled();
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("confirmPermission", () => {
-  test("shows the UI dialog but does not emit a UI prompt event (the prompter does)", async () => {
-    const events = {
-      emit: vi.fn(),
-      on: vi.fn().mockReturnValue(() => undefined),
-    };
-    const requestPermissionDecisionFromUi = vi
-      .fn()
-      .mockResolvedValue({ approved: true, state: "approved" as const });
-
-    await confirmPermission(
-      {
-        hasUI: true,
-        ui: { select: vi.fn(), input: vi.fn() },
-      } as unknown as ExtensionContext,
-      "Allow git push?",
-      {
-        forwardingDir: "/tmp/forwarding",
-        subagentSessionsDir: "/tmp/subagents",
-        events,
-        logger: { writeReviewLog: vi.fn(), writeDebugLog: vi.fn() },
-        writeReviewLog: vi.fn(),
-        requestPermissionDecisionFromUi,
-        shouldAutoApprove: () => false,
-      },
-    );
-
-    expect(requestPermissionDecisionFromUi).toHaveBeenCalled();
-    expect(events.emit).not.toHaveBeenCalledWith(
-      "permissions:ui_prompt",
-      expect.anything(),
-    );
-  });
-
-  test("does not show a dialog or emit when there is no active UI", async () => {
-    const events = {
-      emit: vi.fn(),
-      on: vi.fn().mockReturnValue(() => undefined),
-    };
-    const requestPermissionDecisionFromUi = vi.fn();
-
-    await confirmPermission(
-      {
-        hasUI: false,
-        sessionManager: {
-          getSessionDir: vi.fn().mockReturnValue(null),
-        },
-      } as unknown as ExtensionContext,
-      "Allow git push?",
-      {
-        forwardingDir: "/tmp/forwarding",
-        subagentSessionsDir: "/tmp/subagents",
-        events,
-        logger: { writeReviewLog: vi.fn(), writeDebugLog: vi.fn() },
-        writeReviewLog: vi.fn(),
-        requestPermissionDecisionFromUi,
-        shouldAutoApprove: () => false,
-      },
-    );
-
-    expect(events.emit).not.toHaveBeenCalledWith(
-      "permissions:ui_prompt",
-      expect.anything(),
-    );
-    expect(requestPermissionDecisionFromUi).not.toHaveBeenCalled();
-  });
-});

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

@@ -8,7 +8,11 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
-import { PermissionManager } from "#src/permission-manager";
+import { getGlobalConfigPath, getProjectConfigPath } from "#src/config-paths";
+import {
+  PermissionManager,
+  type ScopedPermissionManager,
+} from "#src/permission-manager";
 import type { Rule, Ruleset } from "#src/rule";
 
 // ---------------------------------------------------------------------------
@@ -1349,3 +1353,157 @@ describe("cross-cutting path surface", () => {
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// configureForCwd and agentDir construction
+// ---------------------------------------------------------------------------
+
+describe("PermissionManager — configureForCwd and agentDir option", () => {
+  /**
+   * Build a temp agentDir with a global config and an optional cwd with a
+   * project config.  Returns the paths and a cleanup function.
+   */
+  function makeAgentDirSetup(opts: {
+    globalPermission: Record<string, unknown>;
+    projectPermission?: Record<string, unknown>;
+  }): {
+    agentDir: string;
+    cwd: string;
+    globalConfigPath: string;
+    projectConfigPath: string;
+    cleanup: () => void;
+  } {
+    const baseDir = mkdtempSync(join(tmpdir(), "pm-agent-dir-test-"));
+    const agentDir = join(baseDir, "agent");
+    const cwd = join(baseDir, "project");
+
+    // Write global config under getGlobalConfigPath(agentDir)
+    const globalConfigPath = getGlobalConfigPath(agentDir);
+    mkdirSync(join(agentDir, "extensions", "pi-permission-system"), {
+      recursive: true,
+    });
+    writeFileSync(
+      globalConfigPath,
+      JSON.stringify({ permission: opts.globalPermission }, null, 2),
+    );
+
+    // Write project config under getProjectConfigPath(cwd)
+    const projectConfigPath = getProjectConfigPath(cwd);
+    mkdirSync(join(cwd, ".pi", "extensions", "pi-permission-system"), {
+      recursive: true,
+    });
+    if (opts.projectPermission) {
+      writeFileSync(
+        projectConfigPath,
+        JSON.stringify({ permission: opts.projectPermission }, null, 2),
+      );
+    }
+
+    return {
+      agentDir,
+      cwd,
+      globalConfigPath,
+      projectConfigPath,
+      cleanup: () => rmSync(baseDir, { recursive: true, force: true }),
+    };
+  }
+
+  it("ScopedPermissionManager is exported and PermissionManager satisfies it", () => {
+    // Type-level assertion: assigning PermissionManager to ScopedPermissionManager compiles.
+    const manager = new PermissionManager({
+      globalConfigPath: "/nonexistent/config.json",
+      agentsDir: "/nonexistent/agents",
+    });
+    const scoped: ScopedPermissionManager = manager;
+    expect(typeof scoped.configureForCwd).toBe("function");
+    expect(typeof scoped.checkPermission).toBe("function");
+    expect(typeof scoped.getToolPermission).toBe("function");
+    expect(typeof scoped.getConfigIssues).toBe("function");
+    expect(typeof scoped.getPolicyCacheStamp).toBe("function");
+  });
+
+  it("construction with { agentDir } reads global config from getGlobalConfigPath(agentDir)", () => {
+    const { agentDir, cleanup } = makeAgentDirSetup({
+      globalPermission: { read: "deny" },
+    });
+    try {
+      const manager = new PermissionManager({ agentDir });
+      const result = manager.checkPermission("read", { path: "foo.txt" });
+      expect(result.state).toBe("deny");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("configureForCwd(cwd) applies project config (project overrides global)", () => {
+    const { agentDir, cwd, cleanup } = makeAgentDirSetup({
+      globalPermission: { read: "deny" },
+      projectPermission: { read: "allow" },
+    });
+    try {
+      const manager = new PermissionManager({ agentDir });
+      // Before configureForCwd: global policy applies
+      expect(manager.checkPermission("read", { path: "foo.txt" }).state).toBe(
+        "deny",
+      );
+
+      manager.configureForCwd(cwd);
+
+      // After configureForCwd: project override applies (last-match-wins)
+      expect(manager.checkPermission("read", { path: "foo.txt" }).state).toBe(
+        "allow",
+      );
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("configureForCwd(undefined) reverts to global-only", () => {
+    const { agentDir, cwd, cleanup } = makeAgentDirSetup({
+      globalPermission: { read: "deny" },
+      projectPermission: { read: "allow" },
+    });
+    try {
+      const manager = new PermissionManager({ agentDir });
+      manager.configureForCwd(cwd);
+      expect(manager.checkPermission("read", { path: "foo.txt" }).state).toBe(
+        "allow",
+      );
+
+      manager.configureForCwd(undefined);
+
+      // After reverting: global policy applies again
+      expect(manager.checkPermission("read", { path: "foo.txt" }).state).toBe(
+        "deny",
+      );
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("configureForCwd clears the resolved-permissions cache", () => {
+    const { agentDir, globalConfigPath, cleanup } = makeAgentDirSetup({
+      globalPermission: { read: "allow" },
+    });
+    try {
+      const manager = new PermissionManager({ agentDir });
+      // Warm the cache
+      expect(manager.checkPermission("read", { path: "foo.txt" }).state).toBe(
+        "allow",
+      );
+      // Update global config on disk to deny read
+      writeFileSync(
+        globalConfigPath,
+        JSON.stringify({ permission: { read: "deny" } }, null, 2),
+      );
+      // configureForCwd clears cache + rebuilds loader
+      manager.configureForCwd(undefined);
+      // Should pick up the changed global config
+      expect(manager.checkPermission("read", { path: "foo.txt" }).state).toBe(
+        "deny",
+      );
+    } finally {
+      cleanup();
+    }
+  });
+});