@gotgenes/pi-permission-system 10.0.0 → 10.1.0

package/src/tool-input-prompt-formatters.ts

@@ -0,0 +1,63 @@
+import { getNonEmptyString, toRecord } from "./common";
+import { countTextLines, formatCount } from "./tool-input-preview";
+
+export function getPromptPath(input: Record<string, unknown>): string | null {
+  return getNonEmptyString(input.path) ?? getNonEmptyString(input.file_path);
+}
+
+export function formatEditInputForPrompt(
+  input: Record<string, unknown>,
+): string {
+  const path = getPromptPath(input);
+  const rawEdits = Array.isArray(input.edits)
+    ? input.edits
+    : typeof input.oldText === "string" && typeof input.newText === "string"
+      ? [{ oldText: input.oldText, newText: input.newText }]
+      : [];
+
+  const edits = rawEdits
+    .map((edit) => toRecord(edit))
+    .filter(
+      (edit) =>
+        typeof edit.oldText === "string" && typeof edit.newText === "string",
+    );
+
+  const pathPart = path ? `for '${path}'` : "";
+  if (edits.length === 0) {
+    return pathPart ? `${pathPart} with edit input` : "with edit input";
+  }
+
+  const firstEdit = edits[0];
+  const oldText = String(firstEdit.oldText);
+  const newText = String(firstEdit.newText);
+  const firstEditSummary = `edit #1 replaces ${formatCount(countTextLines(oldText), "line", "lines")} with ${formatCount(countTextLines(newText), "line", "lines")}`;
+  const extraEdits =
+    edits.length > 1
+      ? `, plus ${formatCount(edits.length - 1, "additional edit", "additional edits")}`
+      : "";
+  const summary = `(${formatCount(edits.length, "replacement", "replacements")}: ${firstEditSummary}${extraEdits})`;
+  return pathPart ? `${pathPart} ${summary}` : summary;
+}
+
+export function formatWriteInputForPrompt(
+  input: Record<string, unknown>,
+): string {
+  const path = getPromptPath(input);
+  const content = typeof input.content === "string" ? input.content : "";
+  const summary = `(${formatCount(countTextLines(content), "line", "lines")}, ${formatCount(content.length, "character", "characters")})`;
+  return path ? `for '${path}' ${summary}` : summary;
+}
+
+export function formatReadInputForPrompt(
+  input: Record<string, unknown>,
+): string {
+  const path = getPromptPath(input);
+  const parts = path ? [`path '${path}'`] : [];
+  if (typeof input.offset === "number") {
+    parts.push(`offset ${input.offset}`);
+  }
+  if (typeof input.limit === "number") {
+    parts.push(`limit ${input.limit}`);
+  }
+  return parts.length > 0 ? `for ${parts.join(", ")}` : "";
+}

package/src/tool-preview-formatter.ts

@@ -2,16 +2,18 @@ import { getNonEmptyString, toRecord } from "./common";
 import type { PermissionSystemExtensionConfig } from "./extension-config";
 import type { ToolInputFormatterLookup } from "./tool-input-formatter-registry";
 import {
-  formatEditInputForPrompt,
-  formatReadInputForPrompt,
-  formatWriteInputForPrompt,
-  getPromptPath,
   serializeToolInputPreview,
   TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
   TOOL_INPUT_PREVIEW_MAX_LENGTH,
   TOOL_TEXT_SUMMARY_MAX_LENGTH,
   truncateInlineText,
 } from "./tool-input-preview";
+import {
+  formatEditInputForPrompt,
+  formatReadInputForPrompt,
+  formatWriteInputForPrompt,
+  getPromptPath,
+} from "./tool-input-prompt-formatters";
 import type { PermissionCheckResult } from "./types";
 
 export interface ToolPreviewFormatterOptions {

package/test/decision-reporter.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  type DecisionReporter,
+  GateDecisionReporter,
+} from "#src/decision-reporter";
+import {
+  PERMISSIONS_DECISION_CHANNEL,
+  type PermissionDecisionEvent,
+} from "#src/permission-events";
+import type { SessionLogger } from "#src/session-logger";
+
+// ── fixtures ───────────────────────────────────────────────────────────────
+
+function makeLogger(): SessionLogger {
+  return {
+    debug: vi.fn(),
+    review: vi.fn(),
+    warn: vi.fn(),
+  };
+}
+
+function makeEvents() {
+  return {
+    emit: vi.fn(),
+    on: vi.fn().mockReturnValue(() => undefined),
+  };
+}
+
+function makeDecisionEvent(
+  overrides: Partial<PermissionDecisionEvent> = {},
+): PermissionDecisionEvent {
+  return {
+    surface: "read",
+    value: "read",
+    result: "allow",
+    resolution: "policy_allow",
+    origin: "global",
+    agentName: null,
+    matchedPattern: null,
+    ...overrides,
+  };
+}
+
+// ── tests ──────────────────────────────────────────────────────────────────
+
+describe("GateDecisionReporter", () => {
+  it("satisfies the DecisionReporter interface", () => {
+    const reporter: DecisionReporter = new GateDecisionReporter(
+      makeLogger(),
+      makeEvents(),
+    );
+    expect(reporter).toBeDefined();
+  });
+
+  describe("writeReviewLog", () => {
+    it("delegates to logger.review with event and details", () => {
+      const logger = makeLogger();
+      const reporter = new GateDecisionReporter(logger, makeEvents());
+      reporter.writeReviewLog("permission_request.blocked", { tool: "bash" });
+      expect(logger.review).toHaveBeenCalledWith("permission_request.blocked", {
+        tool: "bash",
+      });
+    });
+
+    it("delegates with an empty details object", () => {
+      const logger = makeLogger();
+      const reporter = new GateDecisionReporter(logger, makeEvents());
+      reporter.writeReviewLog("permission_request.session_approved", {});
+      expect(logger.review).toHaveBeenCalledWith(
+        "permission_request.session_approved",
+        {},
+      );
+    });
+
+    it("does not call emitDecision", () => {
+      const events = makeEvents();
+      const reporter = new GateDecisionReporter(makeLogger(), events);
+      reporter.writeReviewLog("some.event", { key: "val" });
+      expect(events.emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("emitDecision", () => {
+    it("emits on the PERMISSIONS_DECISION_CHANNEL with the event", () => {
+      const events = makeEvents();
+      const reporter = new GateDecisionReporter(makeLogger(), events);
+      const event = makeDecisionEvent();
+      reporter.emitDecision(event);
+      expect(events.emit).toHaveBeenCalledWith(
+        PERMISSIONS_DECISION_CHANNEL,
+        event,
+      );
+    });
+
+    it("does not call writeReviewLog", () => {
+      const logger = makeLogger();
+      const reporter = new GateDecisionReporter(logger, makeEvents());
+      reporter.emitDecision(makeDecisionEvent());
+      expect(logger.review).not.toHaveBeenCalled();
+    });
+
+    it("does not propagate a throwing listener", () => {
+      const events = makeEvents();
+      events.emit.mockImplementation(() => {
+        throw new Error("listener boom");
+      });
+      const reporter = new GateDecisionReporter(makeLogger(), events);
+      expect(() => reporter.emitDecision(makeDecisionEvent())).not.toThrow();
+    });
+  });
+});

package/test/denial-messages.test.ts

@@ -265,6 +265,31 @@ describe("formatDenyReason", () => {
       );
     });
   });
+
+  describe("skill_input context", () => {
+    test("without agent", () => {
+      expect(
+        formatDenyReason({
+          kind: "skill_input",
+          skillName: "librarian",
+        }),
+      ).toBe(
+        "[pi-permission-system] Current agent is not permitted to access skill 'librarian'.",
+      );
+    });
+
+    test("with agent", () => {
+      expect(
+        formatDenyReason({
+          kind: "skill_input",
+          skillName: "librarian",
+          agentName: "my-agent",
+        }),
+      ).toBe(
+        "[pi-permission-system] Agent 'my-agent' is not permitted to access skill 'librarian'.",
+      );
+    });
+  });
 });
 
 // ── formatUnavailableReason ────────────────────────────────────────────────
@@ -353,6 +378,17 @@ describe("formatUnavailableReason", () => {
       "[pi-permission-system] Accessing skill 'librarian' requires approval, but no interactive UI is available.",
     );
   });
+
+  test("skill_input", () => {
+    expect(
+      formatUnavailableReason({
+        kind: "skill_input",
+        skillName: "librarian",
+      }),
+    ).toBe(
+      "[pi-permission-system] Accessing skill 'librarian' requires approval, but no interactive UI is available.",
+    );
+  });
 });
 
 // ── formatUserDeniedReason ─────────────────────────────────────────────────
@@ -530,4 +566,30 @@ describe("formatUserDeniedReason", () => {
       );
     });
   });
+
+  describe("skill_input context", () => {
+    test("without agent and without reason", () => {
+      expect(
+        formatUserDeniedReason({
+          kind: "skill_input",
+          skillName: "librarian",
+        }),
+      ).toBe("[pi-permission-system] User denied access to skill 'librarian'.");
+    });
+
+    test("with agent and with reason", () => {
+      expect(
+        formatUserDeniedReason(
+          {
+            kind: "skill_input",
+            skillName: "librarian",
+            agentName: "code-agent",
+          },
+          "not permitted",
+        ),
+      ).toBe(
+        "[pi-permission-system] User denied access to skill 'librarian'. Reason: not permitted.",
+      );
+    });
+  });
 });

package/test/forwarding-manager.test.ts

@@ -4,13 +4,11 @@ import { ForwardingManager } from "#src/forwarding-manager";
 
 // ── Mocks ─────────────────────────────────────────────────────────────────
 
-const mockProcessForwardedPermissionRequests = vi.hoisted(() => vi.fn());
+const mockProcessInbox = vi.hoisted(() =>
+  vi.fn((): Promise<void> => Promise.resolve()),
+);
 const mockIsSubagentExecutionContext = vi.hoisted(() => vi.fn());
 
-vi.mock("../src/forwarded-permissions/polling", () => ({
-  processForwardedPermissionRequests: mockProcessForwardedPermissionRequests,
-}));
-
 vi.mock("../src/subagent-context", () => ({
   isSubagentExecutionContext: mockIsSubagentExecutionContext,
 }));
@@ -27,22 +25,12 @@ function makeCtx(overrides: { hasUI?: boolean; sessionId?: string } = {}) {
   } as unknown as import("@earendil-works/pi-coding-agent").ExtensionContext;
 }
 
-function makeForwardingDeps() {
-  return {
-    forwardingDir: "/agent/sessions/permission-forwarding",
-    subagentSessionsDir: "/agent/subagent-sessions",
-    logger: { writeReviewLog: vi.fn(), writeDebugLog: vi.fn() },
-    writeReviewLog: vi.fn(),
-    requestPermissionDecisionFromUi: vi.fn(),
-    shouldAutoApprove: vi.fn().mockReturnValue(false),
-  } as unknown as import("../src/forwarded-permissions/polling").PermissionForwardingDeps;
+function makeForwarder() {
+  return { processInbox: mockProcessInbox };
 }
 
 function makeManager() {
-  return new ForwardingManager(
-    "/agent/subagent-sessions",
-    makeForwardingDeps(),
-  );
+  return new ForwardingManager("/agent/subagent-sessions", makeForwarder());
 }
 
 // ── Tests ─────────────────────────────────────────────────────────────────
@@ -52,8 +40,8 @@ describe("ForwardingManager", () => {
     vi.useFakeTimers();
     mockIsSubagentExecutionContext.mockReset();
     mockIsSubagentExecutionContext.mockReturnValue(false);
-    mockProcessForwardedPermissionRequests.mockReset();
-    mockProcessForwardedPermissionRequests.mockResolvedValue(undefined);
+    mockProcessInbox.mockReset();
+    mockProcessInbox.mockResolvedValue(undefined);
   });
 
   afterEach(() => {
@@ -73,9 +61,9 @@ describe("ForwardingManager", () => {
       manager.stop();
 
       // After stop, the timer fires no more callbacks.
-      mockProcessForwardedPermissionRequests.mockClear();
+      mockProcessInbox.mockClear();
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
   });
 
@@ -86,7 +74,7 @@ describe("ForwardingManager", () => {
       manager.start(ctx);
 
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
 
     it("stops any existing poll and does not start a new one when hasUI is false", async () => {
@@ -98,9 +86,9 @@ describe("ForwardingManager", () => {
       // Now stop the polling by calling start() with no-UI ctx.
       manager.start(noUiCtx);
 
-      mockProcessForwardedPermissionRequests.mockClear();
+      mockProcessInbox.mockClear();
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
 
     it("does not start polling when isSubagentExecutionContext returns true", async () => {
@@ -110,7 +98,7 @@ describe("ForwardingManager", () => {
       manager.start(ctx);
 
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
 
     it("stops any existing poll when called with a subagent context", async () => {
@@ -124,21 +112,18 @@ describe("ForwardingManager", () => {
       const ctx2 = makeCtx();
       manager.start(ctx2);
 
-      mockProcessForwardedPermissionRequests.mockClear();
+      mockProcessInbox.mockClear();
       await vi.advanceTimersByTimeAsync(500);
-      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+      expect(mockProcessInbox).not.toHaveBeenCalled();
     });
 
-    it("starts polling and calls processForwardedPermissionRequests on tick", async () => {
+    it("starts polling and calls processInbox on tick", async () => {
       const manager = makeManager();
       const ctx = makeCtx();
       manager.start(ctx);
 
       await vi.advanceTimersByTimeAsync(250);
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledWith(
-        ctx,
-        expect.anything(),
-      );
+      expect(mockProcessInbox).toHaveBeenCalledWith(ctx);
     });
 
     it("is idempotent — calling start() twice does not create a second timer", async () => {
@@ -149,7 +134,7 @@ describe("ForwardingManager", () => {
 
       await vi.advanceTimersByTimeAsync(250);
       // Only one tick should fire per interval, not two.
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+      expect(mockProcessInbox).toHaveBeenCalledTimes(1);
     });
 
     it("updates the context when called again while already running", async () => {
@@ -161,16 +146,13 @@ describe("ForwardingManager", () => {
 
       await vi.advanceTimersByTimeAsync(250);
       // The process call should use the newer context.
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledWith(
-        ctx2,
-        expect.anything(),
-      );
+      expect(mockProcessInbox).toHaveBeenCalledWith(ctx2);
     });
 
     it("skips a tick while processing is in progress", async () => {
-      // Make processForwardedPermissionRequests hang so processing=true persists.
+      // Make processInbox hang so processing=true persists.
       let resolveProcess: () => void;
-      mockProcessForwardedPermissionRequests.mockReturnValue(
+      mockProcessInbox.mockReturnValue(
         new Promise<void>((resolve) => {
           resolveProcess = resolve;
         }),
@@ -182,22 +164,22 @@ describe("ForwardingManager", () => {
 
       // First tick starts processing.
       await vi.advanceTimersByTimeAsync(250);
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+      expect(mockProcessInbox).toHaveBeenCalledTimes(1);
 
       // Second tick is skipped because processing flag is still true.
       await vi.advanceTimersByTimeAsync(250);
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+      expect(mockProcessInbox).toHaveBeenCalledTimes(1);
 
       // Resolve and a third tick should fire.
       resolveProcess!();
       await vi.advanceTimersByTimeAsync(250);
-      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(2);
+      expect(mockProcessInbox).toHaveBeenCalledTimes(2);
     });
 
     it("passes subagentSessionsDir from the constructor to isSubagentExecutionContext", () => {
       const manager = new ForwardingManager(
         "/custom/subagent-dir",
-        makeForwardingDeps(),
+        makeForwarder(),
       );
       const ctx = makeCtx();
       manager.start(ctx);

package/test/handlers/before-agent-start.test.ts

@@ -1,13 +1,13 @@
 import { describe, expect, it, vi } from "vitest";
 
+import type { AgentPrepSession } from "#src/agent-prep-session";
 import {
   AgentPrepHandler,
   shouldExposeTool,
 } from "#src/handlers/before-agent-start";
-import type { PermissionSession } from "#src/permission-session";
 import type { ToolRegistry } from "#src/tool-registry";
 
-import { makeCtx } from "#test/helpers/handler-fixtures";
+import { makeCheckResult, makeCtx } from "#test/helpers/handler-fixtures";
 
 // ── SDK stubs ──────────────────────────────────────────────────────────────
 vi.mock("@earendil-works/pi-coding-agent", async (importOriginal) => {
@@ -26,24 +26,48 @@ function makeEvent(systemPrompt = "You are an assistant.") {
 }
 
 function makeSession(
-  overrides: Partial<Record<keyof PermissionSession, unknown>> = {},
-): PermissionSession {
+  overrides: Partial<AgentPrepSession> = {},
+): AgentPrepSession {
   return {
-    logger: { debug: vi.fn(), review: vi.fn(), warn: vi.fn() },
-    activate: vi.fn(),
-    refreshConfig: vi.fn(),
-    resolveAgentName: vi.fn().mockReturnValue(null),
-    getToolPermission: vi.fn().mockReturnValue("allow"),
-    checkPermission: vi.fn().mockReturnValue({ state: "allow" }),
-    shouldUpdateActiveTools: vi.fn().mockReturnValue(true),
-    commitActiveToolsCacheKey: vi.fn(),
-    getPolicyCacheStamp: vi.fn().mockReturnValue("stamp-1"),
-    shouldUpdatePromptState: vi.fn().mockReturnValue(true),
-    commitPromptStateCacheKey: vi.fn(),
-    setActiveSkillEntries: vi.fn(),
-    getActiveSkillEntries: vi.fn().mockReturnValue([]),
-    ...overrides,
-  } as unknown as PermissionSession;
+    activate: overrides.activate ?? vi.fn<AgentPrepSession["activate"]>(),
+    refreshConfig:
+      overrides.refreshConfig ?? vi.fn<AgentPrepSession["refreshConfig"]>(),
+    resolveAgentName:
+      overrides.resolveAgentName ??
+      vi.fn<AgentPrepSession["resolveAgentName"]>().mockReturnValue(null),
+    checkPermission:
+      overrides.checkPermission ??
+      vi
+        .fn<AgentPrepSession["checkPermission"]>()
+        .mockReturnValue(makeCheckResult()),
+    getToolPermission:
+      overrides.getToolPermission ??
+      vi.fn<AgentPrepSession["getToolPermission"]>().mockReturnValue("allow"),
+    shouldUpdateActiveTools:
+      overrides.shouldUpdateActiveTools ??
+      vi
+        .fn<AgentPrepSession["shouldUpdateActiveTools"]>()
+        .mockReturnValue(true),
+    commitActiveToolsCacheKey:
+      overrides.commitActiveToolsCacheKey ??
+      vi.fn<AgentPrepSession["commitActiveToolsCacheKey"]>(),
+    getPolicyCacheStamp:
+      overrides.getPolicyCacheStamp ??
+      vi
+        .fn<AgentPrepSession["getPolicyCacheStamp"]>()
+        .mockReturnValue("stamp-1"),
+    shouldUpdatePromptState:
+      overrides.shouldUpdatePromptState ??
+      vi
+        .fn<AgentPrepSession["shouldUpdatePromptState"]>()
+        .mockReturnValue(true),
+    commitPromptStateCacheKey:
+      overrides.commitPromptStateCacheKey ??
+      vi.fn<AgentPrepSession["commitPromptStateCacheKey"]>(),
+    setActiveSkillEntries:
+      overrides.setActiveSkillEntries ??
+      vi.fn<AgentPrepSession["setActiveSkillEntries"]>(),
+  };
 }
 
 function makeToolRegistry(overrides: Partial<ToolRegistry> = {}): ToolRegistry {
@@ -55,11 +79,11 @@ function makeToolRegistry(overrides: Partial<ToolRegistry> = {}): ToolRegistry {
 }
 
 function makeHandler(overrides?: {
-  session?: Partial<Record<keyof PermissionSession, unknown>>;
+  session?: Partial<AgentPrepSession>;
   toolRegistry?: Partial<ToolRegistry>;
 }): {
   handler: AgentPrepHandler;
-  session: PermissionSession;
+  session: AgentPrepSession;
   toolRegistry: ToolRegistry;
 } {
   const session = makeSession(overrides?.session);