@gotgenes/pi-permission-system 9.2.0 → 10.1.0

package/test/permission-session.test.ts

@@ -217,6 +217,79 @@ describe("PermissionSession", () => {
     });
   });
 
+  describe("resolve", () => {
+    it("forwards surface, input, and agentName, applying the empty session ruleset", () => {
+      const pm = makePermissionManager();
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm);
+      const { session } = createSession();
+
+      session.resolve("bash", { command: "ls" }, "agent-x");
+
+      expect(pm.checkPermission).toHaveBeenCalledWith(
+        "bash",
+        { command: "ls" },
+        "agent-x",
+        [],
+      );
+    });
+
+    it("defaults agentName to undefined when omitted", () => {
+      const pm = makePermissionManager();
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm);
+      const { session } = createSession();
+
+      session.resolve("read", { path: ".env" });
+
+      expect(pm.checkPermission).toHaveBeenCalledWith(
+        "read",
+        { path: ".env" },
+        undefined,
+        [],
+      );
+    });
+
+    it("applies a recorded session approval on the next resolve", () => {
+      const pm = makePermissionManager();
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm);
+      const { session } = createSession();
+
+      session.recordSessionApproval(SessionApproval.single("bash", "git *"));
+      session.resolve("bash", { command: "git status" });
+
+      const sessionRules = vi.mocked(pm.checkPermission).mock.calls[0][3];
+      expect(sessionRules).toHaveLength(1);
+      expect(sessionRules?.[0]).toMatchObject({
+        surface: "bash",
+        pattern: "git *",
+        action: "allow",
+      });
+    });
+
+    it("returns the PermissionManager's check result", () => {
+      const pm = makePermissionManager({
+        checkPermission: vi.fn().mockReturnValue({
+          state: "deny",
+          toolName: "bash",
+          source: "bash",
+          origin: "global",
+          matchedPattern: "rm *",
+        }),
+      });
+      mockCreatePermissionManagerForCwd.mockReturnValue(pm);
+      const { session } = createSession();
+
+      const result = session.resolve("bash", { command: "rm -rf /" });
+
+      expect(result).toEqual({
+        state: "deny",
+        toolName: "bash",
+        source: "bash",
+        origin: "global",
+        matchedPattern: "rm *",
+      });
+    });
+  });
+
   describe("activate and deactivate", () => {
     it("stores the context on activate", () => {
       const { session, forwarding } = createSession();
@@ -432,26 +505,25 @@ describe("PermissionSession", () => {
   });
 
   describe("infrastructure paths", () => {
-    it("getInfrastructureDirs returns paths from ExtensionPaths", () => {
-      const { session } = createSession();
-      expect(session.getInfrastructureDirs()).toEqual([
-        "/test/agent",
-        "/test/agent/git",
-      ]);
-    });
-
-    it("getInfrastructureReadPaths returns config paths", () => {
+    it("getInfrastructureReadDirs combines piInfrastructureDirs and piInfrastructureReadPaths", () => {
       const runtimeDeps = makeRuntimeDeps();
       (runtimeDeps.getConfig as ReturnType<typeof vi.fn>).mockReturnValue({
         piInfrastructureReadPaths: ["/extra/path"],
       });
       const { session } = createSession({ runtimeDeps });
-      expect(session.getInfrastructureReadPaths()).toEqual(["/extra/path"]);
+      expect(session.getInfrastructureReadDirs()).toEqual([
+        "/test/agent",
+        "/test/agent/git",
+        "/extra/path",
+      ]);
     });
 
-    it("getInfrastructureReadPaths returns empty when config omits the field", () => {
+    it("getInfrastructureReadDirs returns only piInfrastructureDirs when config omits the field", () => {
       const { session } = createSession();
-      expect(session.getInfrastructureReadPaths()).toEqual([]);
+      expect(session.getInfrastructureReadDirs()).toEqual([
+        "/test/agent",
+        "/test/agent/git",
+      ]);
     });
   });
 
@@ -478,6 +550,26 @@ describe("PermissionSession", () => {
       const { session } = createSession({ runtimeDeps });
       expect(session.config).toBe(fakeConfig);
     });
+
+    it("getToolPreviewLimits returns resolved preview limits from config", () => {
+      const runtimeDeps = makeRuntimeDeps();
+      (runtimeDeps.getConfig as ReturnType<typeof vi.fn>).mockReturnValue({
+        toolInputPreviewMaxLength: 400,
+        toolTextSummaryMaxLength: 120,
+      });
+      const { session } = createSession({ runtimeDeps });
+      const limits = session.getToolPreviewLimits();
+      expect(limits.toolInputPreviewMaxLength).toBe(400);
+      expect(limits.toolTextSummaryMaxLength).toBe(120);
+    });
+
+    it("getToolPreviewLimits falls back to built-in defaults when config omits fields", () => {
+      const { session } = createSession();
+      const limits = session.getToolPreviewLimits();
+      expect(limits.toolInputPreviewMaxLength).toBeGreaterThan(0);
+      expect(limits.toolTextSummaryMaxLength).toBeGreaterThan(0);
+      expect(limits.toolInputLogPreviewMaxLength).toBeGreaterThan(0);
+    });
   });
 
   describe("reload", () => {
@@ -532,6 +624,62 @@ describe("PermissionSession", () => {
     });
   });
 
+  describe("canConfirm", () => {
+    it("returns true when context is active and canPrompt returns true", () => {
+      const { session } = createSession();
+      session.activate(makeCtx());
+      expect(session.canConfirm()).toBe(true);
+    });
+
+    it("returns false when no context is active", () => {
+      const { session } = createSession();
+      expect(session.canConfirm()).toBe(false);
+    });
+
+    it("returns false when canPrompt returns false", () => {
+      const runtimeDeps = makeRuntimeDeps();
+      (
+        runtimeDeps.canRequestPermissionConfirmation as ReturnType<typeof vi.fn>
+      ).mockReturnValue(false);
+      const { session } = createSession({ runtimeDeps });
+      session.activate(makeCtx());
+      expect(session.canConfirm()).toBe(false);
+    });
+  });
+
+  describe("promptPermission", () => {
+    it("delegates to prompt with stored context", async () => {
+      const { session, runtimeDeps } = createSession();
+      const ctx = makeCtx();
+      session.activate(ctx);
+      const details = {
+        requestId: "req-1",
+        source: "tool_call" as const,
+        agentName: null,
+        message: "Allow?",
+      };
+
+      const result = await session.promptPermission(details);
+
+      expect(runtimeDeps.promptPermission).toHaveBeenCalledWith(ctx, details);
+      expect(result).toEqual({ approved: true, state: "approved" });
+    });
+
+    it("throws when no context is active", async () => {
+      const { session } = createSession();
+      const details = {
+        requestId: "req-1",
+        source: "tool_call" as const,
+        agentName: null,
+        message: "Allow?",
+      };
+
+      await expect(session.promptPermission(details)).rejects.toThrow(
+        "promptPermission called before the session was activated",
+      );
+    });
+  });
+
   describe("canPrompt", () => {
     it("delegates to runtimeDeps.canRequestPermissionConfirmation", () => {
       const { session, runtimeDeps } = createSession();
@@ -573,19 +721,4 @@ describe("PermissionSession", () => {
       expect(result).toEqual({ approved: true, state: "approved" });
     });
   });
-
-  describe("createPermissionRequestId", () => {
-    it("starts with the given prefix", () => {
-      const { session } = createSession();
-      const id = session.createPermissionRequestId("skill-input");
-      expect(id.startsWith("skill-input-")).toBe(true);
-    });
-
-    it("generates unique IDs on repeated calls", () => {
-      const { session } = createSession();
-      const id1 = session.createPermissionRequestId("test");
-      const id2 = session.createPermissionRequestId("test");
-      expect(id1).not.toBe(id2);
-    });
-  });
 });

package/test/permission-ui-prompt.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildDirectUiPrompt,
+  buildForwardedUiPrompt,
+  buildRpcUiPrompt,
+} from "#src/permission-ui-prompt";
+
+describe("buildDirectUiPrompt", () => {
+  it("maps a tool_call prompt to the tool surface and command value", () => {
+    expect(
+      buildDirectUiPrompt({
+        requestId: "req-1",
+        source: "tool_call",
+        agentName: "Explore",
+        message: "Allow git push?",
+        toolName: "bash",
+        command: "git push",
+      }),
+    ).toEqual({
+      requestId: "req-1",
+      source: "tool_call",
+      surface: "bash",
+      value: "git push",
+      agentName: "Explore",
+      message: "Allow git push?",
+      forwarding: null,
+    });
+  });
+
+  it("normalizes a skill prompt to the skill surface and skill-name value", () => {
+    expect(
+      buildDirectUiPrompt({
+        requestId: "req-2",
+        source: "skill_input",
+        agentName: null,
+        message: "Allow skill?",
+        skillName: "deploy-helper",
+      }),
+    ).toEqual({
+      requestId: "req-2",
+      source: "skill_input",
+      surface: "skill",
+      value: "deploy-helper",
+      agentName: null,
+      message: "Allow skill?",
+      forwarding: null,
+    });
+  });
+
+  it("derives value with command > path > target > skillName > toolName precedence", () => {
+    expect(
+      buildDirectUiPrompt({
+        requestId: "req-3",
+        source: "tool_call",
+        agentName: null,
+        message: "m",
+        toolName: "read",
+        path: "/etc/hosts",
+        target: "ignored",
+      }).value,
+    ).toBe("/etc/hosts");
+  });
+});
+
+describe("buildRpcUiPrompt", () => {
+  it("maps an RPC prompt to the rpc_prompt source with passthrough surface/value", () => {
+    expect(
+      buildRpcUiPrompt({
+        requestId: "req-rpc",
+        surface: "bash",
+        value: "git push",
+        agentName: "Worker",
+        message: "Allow git push?",
+      }),
+    ).toEqual({
+      requestId: "req-rpc",
+      source: "rpc_prompt",
+      surface: "bash",
+      value: "git push",
+      agentName: "Worker",
+      message: "Allow git push?",
+      forwarding: null,
+    });
+  });
+
+  it("defaults missing surface, value, and agentName to null", () => {
+    expect(
+      buildRpcUiPrompt({ requestId: "req-rpc-2", message: "Allow?" }),
+    ).toEqual({
+      requestId: "req-rpc-2",
+      source: "rpc_prompt",
+      surface: null,
+      value: null,
+      agentName: null,
+      message: "Allow?",
+      forwarding: null,
+    });
+  });
+});
+
+describe("buildForwardedUiPrompt", () => {
+  it("populates forwarding context and carries the original source/surface/value", () => {
+    expect(
+      buildForwardedUiPrompt({
+        requestId: "req-fwd",
+        message: "Subagent 'Explore' requested permission.\n\nAllow git push?",
+        requesterAgentName: "Explore",
+        requesterSessionId: "child-session",
+        source: "tool_call",
+        surface: "bash",
+        value: "git push",
+      }),
+    ).toEqual({
+      requestId: "req-fwd",
+      source: "tool_call",
+      surface: "bash",
+      value: "git push",
+      agentName: "Explore",
+      message: "Subagent 'Explore' requested permission.\n\nAllow git push?",
+      forwarding: {
+        requesterAgentName: "Explore",
+        requesterSessionId: "child-session",
+      },
+    });
+  });
+
+  it("falls back to source tool_call with null surface/value when the request omits them", () => {
+    expect(
+      buildForwardedUiPrompt({
+        requestId: "req-fwd-old",
+        message: "Allow?",
+        requesterAgentName: null,
+        requesterSessionId: null,
+      }),
+    ).toEqual({
+      requestId: "req-fwd-old",
+      source: "tool_call",
+      surface: null,
+      value: null,
+      agentName: null,
+      message: "Allow?",
+      forwarding: { requesterAgentName: null, requesterSessionId: null },
+    });
+  });
+});

package/test/permissions-service.test.ts

@@ -0,0 +1,151 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PermissionManager } from "#src/permission-manager";
+import { LocalPermissionsService } from "#src/permissions-service";
+import type { Ruleset } from "#src/rule";
+import type { SessionRules } from "#src/session-rules";
+import type {
+  ToolInputFormatter,
+  ToolInputFormatterRegistry,
+} from "#src/tool-input-formatter-registry";
+
+import { makeCheckResult } from "#test/helpers/handler-fixtures";
+
+// ── input-normalizer stub ──────────────────────────────────────────────────
+
+const mockBuildInputForSurface = vi.hoisted(() =>
+  vi.fn<(surface: string, value?: string) => unknown>(),
+);
+
+vi.mock("#src/input-normalizer", () => ({
+  buildInputForSurface: mockBuildInputForSurface,
+}));
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+function makePermissionManager(): PermissionManager {
+  return {
+    checkPermission: vi
+      .fn<PermissionManager["checkPermission"]>()
+      .mockReturnValue(makeCheckResult()),
+    getToolPermission: vi
+      .fn<PermissionManager["getToolPermission"]>()
+      .mockReturnValue("allow"),
+  } as unknown as PermissionManager;
+}
+
+function makeSessionRules(rules: Ruleset = []): SessionRules {
+  return {
+    getRuleset: vi.fn<SessionRules["getRuleset"]>().mockReturnValue(rules),
+  } as unknown as SessionRules;
+}
+
+function makeFormatterRegistry(): ToolInputFormatterRegistry {
+  return {
+    register: vi
+      .fn<ToolInputFormatterRegistry["register"]>()
+      .mockReturnValue(vi.fn()),
+  } as unknown as ToolInputFormatterRegistry;
+}
+
+function makeService(overrides?: {
+  permissionManager?: PermissionManager;
+  sessionRules?: SessionRules;
+  formatterRegistry?: ToolInputFormatterRegistry;
+}) {
+  const permissionManager =
+    overrides?.permissionManager ?? makePermissionManager();
+  const sessionRules = overrides?.sessionRules ?? makeSessionRules();
+  const formatterRegistry =
+    overrides?.formatterRegistry ?? makeFormatterRegistry();
+  const service = new LocalPermissionsService(
+    permissionManager,
+    sessionRules,
+    formatterRegistry,
+  );
+  return { service, permissionManager, sessionRules, formatterRegistry };
+}
+
+// ── tests ──────────────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  mockBuildInputForSurface.mockReset();
+  mockBuildInputForSurface.mockReturnValue({ type: "tool-input" });
+});
+
+describe("checkPermission", () => {
+  it("builds the surface input from surface and value", () => {
+    const { service } = makeService();
+    service.checkPermission("bash", "echo hi");
+    expect(mockBuildInputForSurface).toHaveBeenCalledWith("bash", "echo hi");
+  });
+
+  it("builds the surface input with undefined value when value is omitted", () => {
+    const { service } = makeService();
+    service.checkPermission("read");
+    expect(mockBuildInputForSurface).toHaveBeenCalledWith("read", undefined);
+  });
+
+  it("calls permissionManager.checkPermission with surface, built input, agentName, and current ruleset", () => {
+    const ruleset: Ruleset = [
+      { surface: "bash", pattern: "*", action: "allow", origin: "global" },
+    ];
+    const builtInput = { type: "bash-input" };
+    mockBuildInputForSurface.mockReturnValue(builtInput);
+    const { service, permissionManager, sessionRules } = makeService({
+      sessionRules: makeSessionRules(ruleset),
+    });
+    service.checkPermission("bash", "echo hi", "my-agent");
+    expect(permissionManager.checkPermission).toHaveBeenCalledWith(
+      "bash",
+      builtInput,
+      "my-agent",
+      ruleset,
+    );
+    void sessionRules; // used indirectly
+  });
+
+  it("returns the result from permissionManager.checkPermission", () => {
+    const expected = makeCheckResult({ state: "deny", toolName: "bash" });
+    const { service, permissionManager } = makeService();
+    vi.mocked(permissionManager.checkPermission).mockReturnValue(expected);
+    const result = service.checkPermission("bash", "rm -rf /");
+    expect(result).toBe(expected);
+  });
+});
+
+describe("getToolPermission", () => {
+  it("delegates to permissionManager.getToolPermission", () => {
+    const { service, permissionManager } = makeService();
+    vi.mocked(permissionManager.getToolPermission).mockReturnValue("deny");
+    const result = service.getToolPermission("write", "my-agent");
+    expect(permissionManager.getToolPermission).toHaveBeenCalledWith(
+      "write",
+      "my-agent",
+    );
+    expect(result).toBe("deny");
+  });
+
+  it("omits agentName when not provided", () => {
+    const { service, permissionManager } = makeService();
+    service.getToolPermission("read");
+    expect(permissionManager.getToolPermission).toHaveBeenCalledWith(
+      "read",
+      undefined,
+    );
+  });
+});
+
+describe("registerToolInputFormatter", () => {
+  it("delegates to formatterRegistry.register and returns the unsubscribe function", () => {
+    const unsub = vi.fn();
+    const { service, formatterRegistry } = makeService();
+    vi.mocked(formatterRegistry.register).mockReturnValue(unsub);
+    const formatter: ToolInputFormatter = vi.fn();
+    const result = service.registerToolInputFormatter("my-tool", formatter);
+    expect(formatterRegistry.register).toHaveBeenCalledWith(
+      "my-tool",
+      formatter,
+    );
+    expect(result).toBe(unsub);
+  });
+});

package/test/runtime.test.ts

@@ -49,10 +49,6 @@ vi.mock("../src/config-reporter", () => ({
   buildResolvedConfigLogEntry: mockBuildResolvedConfigLogEntry,
 }));
 
-vi.mock("../src/forwarded-permissions/polling", () => ({
-  processForwardedPermissionRequests: vi.fn().mockResolvedValue(undefined),
-}));
-
 vi.mock("../src/subagent-context", () => ({
   isSubagentExecutionContext: vi.fn().mockReturnValue(false),
 }));

package/test/service-lifecycle.test.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PermissionsService } from "#src/service";
+import {
+  PermissionServiceLifecycle,
+  type ServiceLifecycle,
+} from "#src/service-lifecycle";
+import type { SubagentSessionRegistry } from "#src/subagent-registry";
+
+import { makeCtx } from "#test/helpers/handler-fixtures";
+
+// ── module stubs ───────────────────────────────────────────────────────────
+
+const mockIsRegisteredSubagentChild = vi.hoisted(() =>
+  vi.fn<(ctx: unknown, registry: unknown) => boolean>().mockReturnValue(false),
+);
+const mockPublishPermissionsService = vi.hoisted(() => vi.fn<() => void>());
+const mockUnpublishPermissionsService = vi.hoisted(() => vi.fn<() => void>());
+const mockEmitReadyEvent = vi.hoisted(() => vi.fn<() => void>());
+
+vi.mock("#src/subagent-context", () => ({
+  isRegisteredSubagentChild: mockIsRegisteredSubagentChild,
+}));
+vi.mock("#src/service", () => ({
+  publishPermissionsService: mockPublishPermissionsService,
+  unpublishPermissionsService: mockUnpublishPermissionsService,
+}));
+vi.mock("#src/permission-events", () => ({
+  emitReadyEvent: mockEmitReadyEvent,
+}));
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+function makeService(): PermissionsService {
+  return {
+    checkPermission: vi.fn(),
+    getToolPermission: vi.fn(),
+    registerToolInputFormatter: vi.fn(),
+  };
+}
+
+function makeRegistry(): SubagentSessionRegistry {
+  return {
+    has: vi.fn().mockReturnValue(false),
+  } as unknown as SubagentSessionRegistry;
+}
+
+function makeLifecycle(overrides?: { subscriptions?: (() => void)[] }) {
+  const service = makeService();
+  const registry = makeRegistry();
+  const events = { emit: vi.fn(), on: vi.fn() };
+  const subscriptions = overrides?.subscriptions ?? [];
+  const lifecycle = new PermissionServiceLifecycle(
+    service,
+    registry,
+    events,
+    subscriptions,
+  );
+  return { lifecycle, service, registry, events, subscriptions };
+}
+
+beforeEach(() => {
+  mockIsRegisteredSubagentChild.mockReset();
+  mockIsRegisteredSubagentChild.mockReturnValue(false);
+  mockPublishPermissionsService.mockReset();
+  mockUnpublishPermissionsService.mockReset();
+  mockEmitReadyEvent.mockReset();
+});
+
+// ── ServiceLifecycle interface shape ──────────────────────────────────────
+
+it("PermissionServiceLifecycle satisfies ServiceLifecycle", () => {
+  const { lifecycle } = makeLifecycle();
+  const _: ServiceLifecycle = lifecycle;
+  expect(_).toBeDefined();
+});
+
+// ── activate ──────────────────────────────────────────────────────────────
+
+describe("activate", () => {
+  it("publishes the service for a non-child session", () => {
+    const ctx = makeCtx();
+    const { lifecycle, service } = makeLifecycle();
+    mockIsRegisteredSubagentChild.mockReturnValue(false);
+    lifecycle.activate(ctx);
+    expect(mockPublishPermissionsService).toHaveBeenCalledWith(service);
+  });
+
+  it("skips publishing for a registered child session", () => {
+    const ctx = makeCtx();
+    const { lifecycle } = makeLifecycle();
+    mockIsRegisteredSubagentChild.mockReturnValue(true);
+    lifecycle.activate(ctx);
+    expect(mockPublishPermissionsService).not.toHaveBeenCalled();
+  });
+
+  it("always emits the ready event, even for a child session", () => {
+    const ctx = makeCtx();
+    const { lifecycle, events } = makeLifecycle();
+    mockIsRegisteredSubagentChild.mockReturnValue(true);
+    lifecycle.activate(ctx);
+    expect(mockEmitReadyEvent).toHaveBeenCalledWith(events);
+  });
+
+  it("emits ready after publishing the service", () => {
+    const ctx = makeCtx();
+    const order: string[] = [];
+    mockPublishPermissionsService.mockImplementation(() =>
+      order.push("publish"),
+    );
+    mockEmitReadyEvent.mockImplementation(() => order.push("ready"));
+    const { lifecycle } = makeLifecycle();
+    lifecycle.activate(ctx);
+    expect(order).toEqual(["publish", "ready"]);
+  });
+
+  it("passes ctx and registry to isRegisteredSubagentChild", () => {
+    const ctx = makeCtx();
+    const { lifecycle, registry } = makeLifecycle();
+    lifecycle.activate(ctx);
+    expect(mockIsRegisteredSubagentChild).toHaveBeenCalledWith(ctx, registry);
+  });
+});
+
+// ── teardown ──────────────────────────────────────────────────────────────
+
+describe("teardown", () => {
+  it("calls each subscription unsubscribe function", () => {
+    const unsub1 = vi.fn();
+    const unsub2 = vi.fn();
+    const unsub3 = vi.fn();
+    const { lifecycle } = makeLifecycle({
+      subscriptions: [unsub1, unsub2, unsub3],
+    });
+    lifecycle.teardown();
+    expect(unsub1).toHaveBeenCalledOnce();
+    expect(unsub2).toHaveBeenCalledOnce();
+    expect(unsub3).toHaveBeenCalledOnce();
+  });
+
+  it("unpublishes the service after running subscriptions", () => {
+    const order: string[] = [];
+    const unsub = vi.fn(() => order.push("unsub"));
+    mockUnpublishPermissionsService.mockImplementation(() =>
+      order.push("unpublish"),
+    );
+    const { lifecycle } = makeLifecycle({ subscriptions: [unsub] });
+    lifecycle.teardown();
+    expect(order).toEqual(["unsub", "unpublish"]);
+  });
+
+  it("passes the service to unpublishPermissionsService", () => {
+    const { lifecycle, service } = makeLifecycle();
+    lifecycle.teardown();
+    expect(mockUnpublishPermissionsService).toHaveBeenCalledWith(service);
+  });
+
+  it("works with no subscriptions", () => {
+    const { lifecycle } = makeLifecycle({ subscriptions: [] });
+    expect(() => lifecycle.teardown()).not.toThrow();
+    expect(mockUnpublishPermissionsService).toHaveBeenCalledOnce();
+  });
+});