@gotgenes/pi-permission-system 9.2.0 → 10.0.0

package/test/permission-event-rpc.test.ts

@@ -13,6 +13,7 @@ import {
   PERMISSIONS_PROTOCOL_VERSION,
   PERMISSIONS_RPC_CHECK_CHANNEL,
   PERMISSIONS_RPC_PROMPT_CHANNEL,
+  PERMISSIONS_UI_PROMPT_CHANNEL,
 } from "#src/permission-events";
 
 // ── Helpers ────────────────────────────────────────────────────────────────
@@ -317,6 +318,44 @@ describe("registerPermissionRpcHandlers — permissions:rpc:prompt", () => {
     }
   });
 
+  it("emits a UI prompt broadcast before awaiting the UI decision", async () => {
+    const bus = createEventBus();
+    const ctx = makeCtxWithUi();
+    const requestUi = vi
+      .fn()
+      .mockResolvedValue({ approved: true, state: "approved" as const });
+    const deps = makeDeps({
+      getRuntimeContext: vi.fn().mockReturnValue(ctx),
+      requestPermissionDecisionFromUi: requestUi,
+    });
+    registerPermissionRpcHandlers(bus, deps);
+
+    const promptPromise = waitForReply(bus, PERMISSIONS_UI_PROMPT_CHANNEL);
+    const replyPromise = waitForReply(
+      bus,
+      `${PERMISSIONS_RPC_PROMPT_CHANNEL}:reply:req-prompt-broadcast`,
+    );
+    bus.emit(PERMISSIONS_RPC_PROMPT_CHANNEL, {
+      requestId: "req-prompt-broadcast",
+      surface: "bash",
+      value: "git push",
+      message: "Allow git push?",
+      agentName: "Worker",
+      sessionLabel: "Allow git *",
+    });
+
+    await expect(promptPromise).resolves.toEqual({
+      requestId: "req-prompt-broadcast",
+      source: "rpc_prompt",
+      surface: "bash",
+      value: "git push",
+      agentName: "Worker",
+      message: "Allow git push?",
+      forwarding: null,
+    });
+    await replyPromise;
+  });
+
   it("passes the message to requestPermissionDecisionFromUi", async () => {
     const bus = createEventBus();
     const ctx = makeCtxWithUi();

package/test/permission-events.test.ts

@@ -14,15 +14,18 @@ import type {
   PermissionsPromptRequest,
   PermissionsReadyEvent,
   PermissionsRpcReply,
+  PermissionUiPromptEvent,
 } from "#src/permission-events";
 import {
   emitDecisionEvent,
   emitReadyEvent,
+  emitUiPromptEvent,
   PERMISSIONS_DECISION_CHANNEL,
   PERMISSIONS_PROTOCOL_VERSION,
   PERMISSIONS_READY_CHANNEL,
   PERMISSIONS_RPC_CHECK_CHANNEL,
   PERMISSIONS_RPC_PROMPT_CHANNEL,
+  PERMISSIONS_UI_PROMPT_CHANNEL,
 } from "#src/permission-events";
 
 // ── Minimal EventBus stub ──────────────────────────────────────────────────
@@ -43,6 +46,7 @@ describe("constants", () => {
 
   it("channel names have the correct values", () => {
     expect(PERMISSIONS_READY_CHANNEL).toBe("permissions:ready");
+    expect(PERMISSIONS_UI_PROMPT_CHANNEL).toBe("permissions:ui_prompt");
     expect(PERMISSIONS_DECISION_CHANNEL).toBe("permissions:decision");
     expect(PERMISSIONS_RPC_CHECK_CHANNEL).toBe("permissions:rpc:check");
     expect(PERMISSIONS_RPC_PROMPT_CHANNEL).toBe("permissions:rpc:prompt");
@@ -52,20 +56,75 @@ describe("constants", () => {
 // ── emitReadyEvent ─────────────────────────────────────────────────────────
 
 describe("emitReadyEvent", () => {
-  it("emits on the permissions:ready channel with protocol version", () => {
+  it("emits an empty payload on the permissions:ready channel", () => {
     const bus = makeEventBus();
     emitReadyEvent(bus);
     expect(bus.emit).toHaveBeenCalledOnce();
-    expect(bus.emit).toHaveBeenCalledWith("permissions:ready", {
-      protocolVersion: 1,
-    });
+    expect(bus.emit).toHaveBeenCalledWith("permissions:ready", {});
   });
 
-  it("emitted payload satisfies PermissionsReadyEvent shape", () => {
+  it("carries no protocolVersion (version lives in the RPC envelope)", () => {
     const bus = makeEventBus();
     emitReadyEvent(bus);
     const payload = bus.emit.mock.calls[0][1] as PermissionsReadyEvent;
-    expect(typeof payload.protocolVersion).toBe("number");
+    expect(payload).not.toHaveProperty("protocolVersion");
+  });
+
+  it("swallows event bus errors because broadcasts are best-effort", () => {
+    const bus = {
+      emit: vi.fn(() => {
+        throw new Error("listener failed");
+      }),
+      on: vi.fn().mockReturnValue(() => undefined),
+    };
+
+    expect(() => emitReadyEvent(bus)).not.toThrow();
+  });
+});
+
+// ── emitUiPromptEvent ──────────────────────────────────────────────────────
+
+describe("emitUiPromptEvent", () => {
+  function makeUiPromptEvent(
+    overrides: Partial<PermissionUiPromptEvent> = {},
+  ): PermissionUiPromptEvent {
+    return {
+      requestId: "req-123",
+      source: "tool_call",
+      surface: "bash",
+      value: "git status",
+      agentName: "Explore",
+      message: "Allow git status?",
+      forwarding: null,
+      ...overrides,
+    };
+  }
+
+  it("emits on the permissions:ui_prompt channel", () => {
+    const bus = makeEventBus();
+    emitUiPromptEvent(bus, makeUiPromptEvent());
+    expect(bus.emit).toHaveBeenCalledOnce();
+    expect(bus.emit.mock.calls[0][0]).toBe("permissions:ui_prompt");
+  });
+
+  it("forwards the full payload unchanged", () => {
+    const bus = makeEventBus();
+    const event = makeUiPromptEvent({
+      forwarding: { requesterAgentName: "Worker", requesterSessionId: "child" },
+    });
+    emitUiPromptEvent(bus, event);
+    expect(bus.emit.mock.calls[0][1]).toEqual(event);
+  });
+
+  it("swallows event bus errors because UI prompt broadcasts are observational", () => {
+    const bus = {
+      emit: vi.fn(() => {
+        throw new Error("listener failed");
+      }),
+      on: vi.fn().mockReturnValue(() => undefined),
+    };
+
+    expect(() => emitUiPromptEvent(bus, makeUiPromptEvent())).not.toThrow();
   });
 });
 
@@ -143,6 +202,17 @@ describe("emitDecisionEvent", () => {
     expect(payload.agentName).toBeNull();
     expect(payload.matchedPattern).toBeNull();
   });
+
+  it("swallows event bus errors because broadcasts are best-effort", () => {
+    const bus = {
+      emit: vi.fn(() => {
+        throw new Error("listener failed");
+      }),
+      on: vi.fn().mockReturnValue(() => undefined),
+    };
+
+    expect(() => emitDecisionEvent(bus, makeDecisionEvent())).not.toThrow();
+  });
 });
 
 // ── Type-shape compile-time checks (runtime assertions on literal values) ──
@@ -279,7 +349,7 @@ describe("piPermissionSystemExtension ready event wiring", () => {
     rmSync(baseDir, { recursive: true, force: true });
   });
 
-  it("emits permissions:ready with protocolVersion at session_start", async () => {
+  it("emits permissions:ready at session_start", async () => {
     const emitSpy = vi.fn();
     const handlers = new Map<
       string,
@@ -324,8 +394,6 @@ describe("piPermissionSystemExtension ready event wiring", () => {
       ([channel]) => channel === PERMISSIONS_READY_CHANNEL,
     );
     expect(readyCalls).toHaveLength(1);
-    expect(readyCalls[0][1]).toEqual({
-      protocolVersion: PERMISSIONS_PROTOCOL_VERSION,
-    });
+    expect(readyCalls[0][1]).toEqual({});
   });
 });

package/test/permission-forwarding.test.ts

@@ -1,5 +1,14 @@
+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,
@@ -240,3 +249,276 @@ 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-prompter.test.ts

@@ -53,6 +53,7 @@ function makeDeps(
     writeReviewLog: vi.fn(),
     subagentSessionsDir: "/sessions/subagents",
     forwardingDir: "/sessions/permission-forwarding",
+    events: { emit: vi.fn(), on: vi.fn().mockReturnValue(() => undefined) },
     requestPermissionDecisionFromUi: vi
       .fn()
       .mockResolvedValue({ approved: true, state: "approved" }),
@@ -71,8 +72,13 @@ describe("PermissionPrompter", () => {
 
   describe("yolo-mode auto-approve", () => {
     it("returns approved without calling confirmPermission when yoloMode is true", async () => {
+      const events = {
+        emit: vi.fn(),
+        on: vi.fn().mockReturnValue(() => undefined),
+      };
       const deps = makeDeps({
         getConfig: () => ({ ...DEFAULT_EXTENSION_CONFIG, yoloMode: true }),
+        events,
       });
       const prompter = new PermissionPrompter(deps);
 
@@ -84,6 +90,10 @@ describe("PermissionPrompter", () => {
         autoApproved: true,
       });
       expect(mockConfirmPermission).not.toHaveBeenCalled();
+      expect(events.emit).not.toHaveBeenCalledWith(
+        "permissions:ui_prompt",
+        expect.anything(),
+      );
     });
 
     it("logs permission_request.auto_approved in yolo mode", async () => {
@@ -154,6 +164,90 @@ describe("PermissionPrompter", () => {
       );
     });
 
+    it("emits a UI prompt event with normalized surface and value when the session has UI", async () => {
+      const events = {
+        emit: vi.fn(),
+        on: vi.fn().mockReturnValue(() => undefined),
+      };
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps({ events });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(
+        makeCtx(true),
+        makeDetails({
+          toolName: "bash",
+          command: "git push",
+          toolInputPreview: "git push",
+        }),
+      );
+
+      expect(events.emit).toHaveBeenCalledWith("permissions:ui_prompt", {
+        requestId: "req-123",
+        source: "tool_call",
+        surface: "bash",
+        value: "git push",
+        agentName: "test-agent",
+        message: "Allow read?",
+        forwarding: null,
+      });
+    });
+
+    it("normalizes skill UI prompt events to the skill surface", async () => {
+      const events = {
+        emit: vi.fn(),
+        on: vi.fn().mockReturnValue(() => undefined),
+      };
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps({ events });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(
+        makeCtx(true),
+        makeDetails({
+          source: "skill_input",
+          toolName: undefined,
+          skillName: "deploy-helper",
+        }),
+      );
+
+      expect(events.emit).toHaveBeenCalledWith("permissions:ui_prompt", {
+        requestId: "req-123",
+        source: "skill_input",
+        surface: "skill",
+        value: "deploy-helper",
+        agentName: "test-agent",
+        message: "Allow read?",
+        forwarding: null,
+      });
+    });
+
+    it("does not emit a UI prompt event when the session has no UI", async () => {
+      const events = {
+        emit: vi.fn(),
+        on: vi.fn().mockReturnValue(() => undefined),
+      };
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps({ events });
+      const prompter = new PermissionPrompter(deps);
+
+      await prompter.prompt(makeCtx(false), makeDetails());
+
+      expect(events.emit).not.toHaveBeenCalledWith(
+        "permissions:ui_prompt",
+        expect.anything(),
+      );
+    });
+
     it("logs permission_request.approved when confirmPermission returns approved", async () => {
       const writeReviewLog = vi.fn();
       mockConfirmPermission.mockResolvedValue({
@@ -245,6 +339,30 @@ describe("PermissionPrompter", () => {
         expect.any(String),
         expect.anything(),
         { sessionLabel: "Yes, for 'read' tool" },
+        { source: "tool_call", surface: "read", value: "read" },
+      );
+    });
+
+    it("passes the display fields (source/surface/value) to confirmPermission", async () => {
+      mockConfirmPermission.mockResolvedValue({
+        approved: true,
+        state: "approved",
+      });
+      const deps = makeDeps();
+      const prompter = new PermissionPrompter(deps);
+      const details = makeDetails({
+        toolName: "bash",
+        command: "git push",
+      });
+
+      await prompter.prompt(makeCtx(false), details);
+
+      expect(mockConfirmPermission).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.any(String),
+        expect.anything(),
+        undefined,
+        { source: "tool_call", surface: "bash", value: "git push" },
       );
     });
 
@@ -263,6 +381,7 @@ describe("PermissionPrompter", () => {
         expect.any(String),
         expect.anything(),
         undefined,
+        { source: "tool_call", surface: "read", value: "read" },
       );
     });
 
@@ -282,6 +401,7 @@ describe("PermissionPrompter", () => {
         "Allow bash: git status?",
         expect.anything(),
         undefined,
+        { source: "tool_call", surface: "read", value: "read" },
       );
     });
   });