@gotgenes/pi-permission-system 5.8.0 → 5.10.0

package/src/permission-session.ts

@@ -0,0 +1,252 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+import {
+  getActiveAgentName,
+  getActiveAgentNameFromSystemPrompt,
+} from "./active-agent";
+import type { PermissionSystemExtensionConfig } from "./extension-config";
+import type { ExtensionPaths } from "./extension-paths";
+import type { ForwardingController } from "./forwarding-manager";
+import type { PermissionManager } from "./permission-manager";
+import type { Rule } from "./rule";
+import { createPermissionManagerForCwd } from "./runtime";
+import type { SessionLogger } from "./session-logger";
+import { SessionRules } from "./session-rules";
+import type { SkillPromptEntry } from "./skill-prompt-sanitizer";
+import type { PermissionCheckResult, PermissionState } from "./types";
+
+/**
+ * Runtime operations that `PermissionSession` delegates to but does not own.
+ *
+ * Injected at construction time from the composition root (`index.ts`),
+ * where the `ExtensionRuntime` is available.
+ */
+export interface PermissionSessionRuntimeDeps {
+  /** Reload merged config from disk; optionally update the stored runtime context. */
+  refreshExtensionConfig(ctx?: ExtensionContext): void;
+  /** Write the resolved config path set to the review and debug logs. */
+  logResolvedConfigPaths(): void;
+  /** Read current extension config (called at query time). */
+  getConfig(): PermissionSystemExtensionConfig;
+}
+
+/**
+ * Encapsulates all mutable session state and exposes operations instead of
+ * fields.
+ *
+ * Replaces the `SessionState` interface + scattered handler field mutations
+ * with a single class that owns the `PermissionManager`, `SessionRules`,
+ * cache keys, skill entries, and runtime context.
+ *
+ * Constructor deps:
+ * - `ExtensionPaths` — immutable path constants
+ * - `SessionLogger` — debug + review + warn
+ * - `ForwardingController` — polling lifecycle
+ * - `PermissionSessionRuntimeDeps` — config refresh + log delegates
+ */
+export class PermissionSession {
+  private context: ExtensionContext | null = null;
+  private permissionManager: PermissionManager;
+  private readonly sessionRules = new SessionRules();
+  private skillEntries: SkillPromptEntry[] = [];
+  private knownAgentName: string | null = null;
+  private toolsCacheKey: string | null = null;
+  private promptCacheKey: string | null = null;
+
+  constructor(
+    private readonly paths: ExtensionPaths,
+    readonly logger: SessionLogger,
+    private readonly forwarding: ForwardingController,
+    private readonly runtimeDeps: PermissionSessionRuntimeDeps,
+  ) {
+    this.permissionManager = createPermissionManagerForCwd(
+      paths.agentDir,
+      undefined,
+    );
+  }
+
+  // ── Context lifecycle ──────────────────────────────────────────────────
+
+  /** Store the current extension context and start forwarding. */
+  activate(ctx: ExtensionContext): void {
+    this.context = ctx;
+    this.forwarding.start(ctx);
+  }
+
+  /** Clear the context and stop forwarding. */
+  deactivate(): void {
+    this.context = null;
+    this.forwarding.stop();
+  }
+
+  /** Return the current runtime context, or null if not activated. */
+  getRuntimeContext(): ExtensionContext | null {
+    return this.context;
+  }
+
+  // ── Permission checking (delegates to PermissionManager) ───────────────
+
+  checkPermission(
+    surface: string,
+    input: unknown,
+    agentName?: string,
+    sessionRules?: Rule[],
+  ): PermissionCheckResult {
+    return this.permissionManager.checkPermission(
+      surface,
+      input,
+      agentName,
+      sessionRules,
+    );
+  }
+
+  getToolPermission(toolName: string, agentName?: string): PermissionState {
+    return this.permissionManager.getToolPermission(toolName, agentName);
+  }
+
+  getConfigIssues(agentName?: string): string[] {
+    return this.permissionManager.getConfigIssues(agentName);
+  }
+
+  getPolicyCacheStamp(agentName?: string): string {
+    return this.permissionManager.getPolicyCacheStamp(agentName);
+  }
+
+  // ── Session rules (delegates to SessionRules) ──────────────────────────
+
+  getSessionRuleset(): Rule[] {
+    return this.sessionRules.getRuleset();
+  }
+
+  approveSessionRule(surface: string, pattern: string): void {
+    this.sessionRules.approve(surface, pattern);
+  }
+
+  // ── Session lifecycle ────────────────────────────────────────────────────
+
+  /**
+   * Reset all mutable state for a new session.
+   *
+   * Creates a fresh PermissionManager scoped to `ctx.cwd`, clears caches,
+   * skill entries, and activates the new context.
+   */
+  resetForNewSession(ctx: ExtensionContext): void {
+    this.permissionManager = createPermissionManagerForCwd(
+      this.paths.agentDir,
+      ctx.cwd,
+    );
+    this.skillEntries = [];
+    this.toolsCacheKey = null;
+    this.promptCacheKey = null;
+    this.activate(ctx);
+  }
+
+  /**
+   * Shut down the session: clear rules, caches, skill entries, and
+   * deactivate context + forwarding.
+   */
+  shutdown(): void {
+    this.sessionRules.clear();
+    this.skillEntries = [];
+    this.toolsCacheKey = null;
+    this.promptCacheKey = null;
+    this.deactivate();
+  }
+
+  /**
+   * Reload permission manager and clear caches for the current context.
+   * Used on config reload (e.g. `resources_discover` with reason "reload").
+   */
+  reload(): void {
+    this.permissionManager = createPermissionManagerForCwd(
+      this.paths.agentDir,
+      this.context?.cwd,
+    );
+    this.skillEntries = [];
+    this.toolsCacheKey = null;
+    this.promptCacheKey = null;
+  }
+
+  // ── Agent-start caching ────────────────────────────────────────────────
+
+  shouldUpdateActiveTools(cacheKey: string): boolean {
+    return this.toolsCacheKey !== cacheKey;
+  }
+
+  commitActiveToolsCacheKey(cacheKey: string): void {
+    this.toolsCacheKey = cacheKey;
+  }
+
+  shouldUpdatePromptState(cacheKey: string): boolean {
+    return this.promptCacheKey !== cacheKey;
+  }
+
+  commitPromptStateCacheKey(cacheKey: string): void {
+    this.promptCacheKey = cacheKey;
+  }
+
+  // ── Skill entries ──────────────────────────────────────────────────────
+
+  getActiveSkillEntries(): SkillPromptEntry[] {
+    return this.skillEntries;
+  }
+
+  setActiveSkillEntries(entries: SkillPromptEntry[]): void {
+    this.skillEntries = entries;
+  }
+
+  // ── Agent name ─────────────────────────────────────────────────────────
+
+  /**
+   * Resolve the active agent name from the session context, system prompt,
+   * or last known name. Updates lastKnownActiveAgentName as a side effect.
+   */
+  resolveAgentName(
+    ctx: ExtensionContext,
+    systemPrompt?: string,
+  ): string | null {
+    const fromSession = getActiveAgentName(ctx);
+    if (fromSession) {
+      this.knownAgentName = fromSession;
+      return fromSession;
+    }
+    const fromSystemPrompt = getActiveAgentNameFromSystemPrompt(systemPrompt);
+    if (fromSystemPrompt) {
+      this.knownAgentName = fromSystemPrompt;
+      return fromSystemPrompt;
+    }
+    return this.knownAgentName;
+  }
+
+  get lastKnownActiveAgentName(): string | null {
+    return this.knownAgentName;
+  }
+
+  // ── Config ─────────────────────────────────────────────────────────────
+
+  /** Reload merged config from disk; optionally update the stored runtime context. */
+  refreshConfig(ctx?: ExtensionContext): void {
+    this.runtimeDeps.refreshExtensionConfig(ctx);
+  }
+
+  /** Write the resolved config path set to the review and debug logs. */
+  logResolvedConfigPaths(): void {
+    this.runtimeDeps.logResolvedConfigPaths();
+  }
+
+  /** Read current extension config. */
+  get config(): PermissionSystemExtensionConfig {
+    return this.runtimeDeps.getConfig();
+  }
+
+  // ── Infrastructure paths ───────────────────────────────────────────────
+
+  getInfrastructureDirs(): readonly string[] {
+    return this.paths.piInfrastructureDirs;
+  }
+
+  /** Config-derived infrastructure read paths (current at call time). */
+  getInfrastructureReadPaths(): string[] {
+    return this.config.piInfrastructureReadPaths ?? [];
+  }
+}

package/src/runtime.ts

@@ -12,10 +12,6 @@ import {
   getAgentDir,
 } from "@mariozechner/pi-coding-agent";
 
-import {
-  getActiveAgentName,
-  getActiveAgentNameFromSystemPrompt,
-} from "./active-agent";
 import { loadAndMergeConfigs, loadUnifiedConfig } from "./config-loader";
 import {
   DEBUG_LOG_FILENAME,
@@ -38,24 +34,19 @@ import { computeExtensionPaths, type ExtensionPaths } from "./extension-paths";
 
 export type { ExtensionPaths } from "./extension-paths";
 
-import {
-  type PermissionForwardingDeps,
-  processForwardedPermissionRequests,
-} from "./forwarded-permissions/polling";
 import { createPermissionSystemLogger } from "./logging";
-import { PERMISSION_FORWARDING_POLL_INTERVAL_MS } from "./permission-forwarding";
 import { PermissionManager } from "./permission-manager";
 import { SessionRules } from "./session-rules";
 import type { SkillPromptEntry } from "./skill-prompt-sanitizer";
 import { syncPermissionSystemStatus } from "./status";
-import { isSubagentExecutionContext } from "./subagent-context";
 
 /**
- * Mutable session state — the subset of ExtensionRuntime that handlers
- * read and write. Lifecycle handlers reset fields here on session
- * start/shutdown; gate adapters read permissionManager and sessionRules.
+ * Mutable session state — the subset of ExtensionRuntime that holds
+ * per-session fields. `PermissionSession` now owns these for handler
+ * use; this interface remains so `ExtensionRuntime` can still serve
+ * as the internal composition root (config-modal, RPC handlers).
  */
-export interface SessionState {
+interface SessionState {
   runtimeContext: ExtensionContext | null;
   permissionManager: PermissionManager;
   readonly sessionRules: SessionRules;
@@ -81,11 +72,6 @@ export interface ExtensionRuntime extends ExtensionPaths, SessionState {
   config: PermissionSystemExtensionConfig;
   lastConfigWarning: string | null;
 
-  // ── Forwarding polling state ───────────────────────────────────────────
-  permissionForwardingContext: ExtensionContext | null;
-  permissionForwardingTimer: NodeJS.Timeout | null;
-  isProcessingForwardedRequests: boolean;
-
   // ── Logging (backed by logger created at construction) ─────────────────
   writeDebugLog(event: string, details?: Record<string, unknown>): void;
   writeReviewLog(event: string, details?: Record<string, unknown>): void;
@@ -220,28 +206,6 @@ export function saveExtensionConfig(
   });
 }
 
-/**
- * Resolve the active agent name from the Pi session, system prompt, or last
- * known name. Updates `runtime.lastKnownActiveAgentName` as a side effect.
- */
-export function resolveAgentName(
-  runtime: ExtensionRuntime,
-  ctx: ExtensionContext,
-  systemPrompt?: string,
-): string | null {
-  const fromSession = getActiveAgentName(ctx);
-  if (fromSession) {
-    runtime.lastKnownActiveAgentName = fromSession;
-    return fromSession;
-  }
-  const fromSystemPrompt = getActiveAgentNameFromSystemPrompt(systemPrompt);
-  if (fromSystemPrompt) {
-    runtime.lastKnownActiveAgentName = fromSystemPrompt;
-    return fromSystemPrompt;
-  }
-  return runtime.lastKnownActiveAgentName;
-}
-
 /**
  * Write the resolved config path set (global, project, legacy) to the review
  * and debug logs.
@@ -277,58 +241,6 @@ export function logResolvedConfigPaths(runtime: ExtensionRuntime): void {
   );
 }
 
-// ── Forwarding polling lifecycle ───────────────────────────────────────────
-
-/** Stop the forwarded-permission polling interval and clear related state. */
-export function stopForwardedPermissionPolling(
-  runtime: ExtensionRuntime,
-): void {
-  if (runtime.permissionForwardingTimer) {
-    clearInterval(runtime.permissionForwardingTimer);
-    runtime.permissionForwardingTimer = null;
-  }
-  runtime.permissionForwardingContext = null;
-  runtime.isProcessingForwardedRequests = false;
-}
-
-/**
- * Start the forwarded-permission polling interval.
- * No-ops (and stops any existing poll) when the context has no UI or is a
- * subagent execution context.
- */
-export function startForwardedPermissionPolling(
-  runtime: ExtensionRuntime,
-  forwardingDeps: PermissionForwardingDeps,
-  ctx: ExtensionContext,
-): void {
-  if (
-    !ctx.hasUI ||
-    isSubagentExecutionContext(ctx, runtime.subagentSessionsDir)
-  ) {
-    stopForwardedPermissionPolling(runtime);
-    return;
-  }
-  runtime.permissionForwardingContext = ctx;
-  if (runtime.permissionForwardingTimer) {
-    return;
-  }
-  runtime.permissionForwardingTimer = setInterval(() => {
-    if (
-      !runtime.permissionForwardingContext ||
-      runtime.isProcessingForwardedRequests
-    ) {
-      return;
-    }
-    runtime.isProcessingForwardedRequests = true;
-    void processForwardedPermissionRequests(
-      runtime.permissionForwardingContext,
-      forwardingDeps,
-    ).finally(() => {
-      runtime.isProcessingForwardedRequests = false;
-    });
-  }, PERMISSION_FORWARDING_POLL_INTERVAL_MS);
-}
-
 // ── Factory ────────────────────────────────────────────────────────────────
 
 /**
@@ -356,9 +268,6 @@ export function createExtensionRuntime(options?: {
     lastPromptStateCacheKey: null,
     lastConfigWarning: null,
     sessionRules: new SessionRules(),
-    permissionForwardingContext: null,
-    permissionForwardingTimer: null,
-    isProcessingForwardedRequests: false,
     // Logging methods are replaced below after the logger is constructed.
     writeDebugLog: () => {},
     writeReviewLog: () => {},

package/src/skill-prompt-sanitizer.ts

@@ -4,8 +4,19 @@ import {
   isPathWithinDirectory,
   normalizePathForComparison,
 } from "./path-utils";
-import type { PermissionManager } from "./permission-manager";
-import type { PermissionState } from "./types";
+import type { PermissionCheckResult, PermissionState } from "./types";
+
+/**
+ * Narrow interface for the permission checker used by skill prompt resolution.
+ * Both `PermissionManager` and `PermissionSession` satisfy this structurally.
+ */
+export interface SkillPermissionChecker {
+  checkPermission(
+    surface: string,
+    input: unknown,
+    agentName?: string,
+  ): PermissionCheckResult;
+}
 
 const AVAILABLE_SKILLS_OPEN_TAG = "<available_skills>";
 const AVAILABLE_SKILLS_CLOSE_TAG = "</available_skills>";
@@ -148,7 +159,7 @@ export function parseAllSkillPromptSections(
 
 function resolvePermissionState(
   skillName: string,
-  permissionManager: PermissionManager,
+  permissionManager: SkillPermissionChecker,
   agentName: string | null,
   cache: Map<string, PermissionState>,
 ): PermissionState {
@@ -205,7 +216,7 @@ function removePromptRange(prompt: string, start: number, end: number): string {
 
 export function resolveSkillPromptEntries(
   prompt: string,
-  permissionManager: PermissionManager,
+  permissionManager: SkillPermissionChecker,
   agentName: string | null,
   cwd: string,
 ): { prompt: string; entries: SkillPromptEntry[] } {

package/tests/forwarding-manager.test.ts

@@ -0,0 +1,211 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ForwardingManager } from "../src/forwarding-manager";
+
+// ── Mocks ─────────────────────────────────────────────────────────────────
+
+const mockProcessForwardedPermissionRequests = vi.hoisted(() => vi.fn());
+const mockIsSubagentExecutionContext = vi.hoisted(() => vi.fn());
+
+vi.mock("../src/forwarded-permissions/polling", () => ({
+  processForwardedPermissionRequests: mockProcessForwardedPermissionRequests,
+}));
+
+vi.mock("../src/subagent-context", () => ({
+  isSubagentExecutionContext: mockIsSubagentExecutionContext,
+}));
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+function makeCtx(overrides: { hasUI?: boolean; sessionId?: string } = {}) {
+  return {
+    hasUI: overrides.hasUI ?? true,
+    sessionManager: {
+      getSessionId: vi.fn().mockReturnValue(overrides.sessionId ?? "sess-1"),
+    },
+    cwd: "/project",
+  } as unknown as import("@mariozechner/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 makeManager() {
+  return new ForwardingManager(
+    "/agent/subagent-sessions",
+    makeForwardingDeps(),
+  );
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────
+
+describe("ForwardingManager", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockIsSubagentExecutionContext.mockReset();
+    mockIsSubagentExecutionContext.mockReturnValue(false);
+    mockProcessForwardedPermissionRequests.mockReset();
+    mockProcessForwardedPermissionRequests.mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe("stop()", () => {
+    it("is a no-op when not started", () => {
+      const manager = makeManager();
+      expect(() => manager.stop()).not.toThrow();
+    });
+
+    it("clears the timer and processing state after start()", async () => {
+      const manager = makeManager();
+      const ctx = makeCtx();
+      manager.start(ctx);
+      manager.stop();
+
+      // After stop, the timer fires no more callbacks.
+      mockProcessForwardedPermissionRequests.mockClear();
+      await vi.advanceTimersByTimeAsync(500);
+      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("start()", () => {
+    it("does not start polling when hasUI is false", async () => {
+      const manager = makeManager();
+      const ctx = makeCtx({ hasUI: false });
+      manager.start(ctx);
+
+      await vi.advanceTimersByTimeAsync(500);
+      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+    });
+
+    it("stops any existing poll and does not start a new one when hasUI is false", async () => {
+      const manager = makeManager();
+      const uiCtx = makeCtx({ hasUI: true });
+      const noUiCtx = makeCtx({ hasUI: false });
+
+      manager.start(uiCtx);
+      // Now stop the polling by calling start() with no-UI ctx.
+      manager.start(noUiCtx);
+
+      mockProcessForwardedPermissionRequests.mockClear();
+      await vi.advanceTimersByTimeAsync(500);
+      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+    });
+
+    it("does not start polling when isSubagentExecutionContext returns true", async () => {
+      mockIsSubagentExecutionContext.mockReturnValue(true);
+      const manager = makeManager();
+      const ctx = makeCtx();
+      manager.start(ctx);
+
+      await vi.advanceTimersByTimeAsync(500);
+      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+    });
+
+    it("stops any existing poll when called with a subagent context", async () => {
+      mockIsSubagentExecutionContext.mockReturnValueOnce(false);
+      const manager = makeManager();
+      const ctx1 = makeCtx();
+      manager.start(ctx1);
+
+      // Second call with a subagent context.
+      mockIsSubagentExecutionContext.mockReturnValue(true);
+      const ctx2 = makeCtx();
+      manager.start(ctx2);
+
+      mockProcessForwardedPermissionRequests.mockClear();
+      await vi.advanceTimersByTimeAsync(500);
+      expect(mockProcessForwardedPermissionRequests).not.toHaveBeenCalled();
+    });
+
+    it("starts polling and calls processForwardedPermissionRequests on tick", async () => {
+      const manager = makeManager();
+      const ctx = makeCtx();
+      manager.start(ctx);
+
+      await vi.advanceTimersByTimeAsync(250);
+      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledWith(
+        ctx,
+        expect.anything(),
+      );
+    });
+
+    it("is idempotent — calling start() twice does not create a second timer", async () => {
+      const manager = makeManager();
+      const ctx = makeCtx();
+      manager.start(ctx);
+      manager.start(ctx);
+
+      await vi.advanceTimersByTimeAsync(250);
+      // Only one tick should fire per interval, not two.
+      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+    });
+
+    it("updates the context when called again while already running", async () => {
+      const manager = makeManager();
+      const ctx1 = makeCtx({ sessionId: "sess-1" });
+      const ctx2 = makeCtx({ sessionId: "sess-2" });
+      manager.start(ctx1);
+      manager.start(ctx2);
+
+      await vi.advanceTimersByTimeAsync(250);
+      // The process call should use the newer context.
+      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledWith(
+        ctx2,
+        expect.anything(),
+      );
+    });
+
+    it("skips a tick while processing is in progress", async () => {
+      // Make processForwardedPermissionRequests hang so processing=true persists.
+      let resolveProcess: () => void;
+      mockProcessForwardedPermissionRequests.mockReturnValue(
+        new Promise<void>((resolve) => {
+          resolveProcess = resolve;
+        }),
+      );
+
+      const manager = makeManager();
+      const ctx = makeCtx();
+      manager.start(ctx);
+
+      // First tick starts processing.
+      await vi.advanceTimersByTimeAsync(250);
+      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+
+      // Second tick is skipped because processing flag is still true.
+      await vi.advanceTimersByTimeAsync(250);
+      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(1);
+
+      // Resolve and a third tick should fire.
+      resolveProcess!();
+      await vi.advanceTimersByTimeAsync(250);
+      expect(mockProcessForwardedPermissionRequests).toHaveBeenCalledTimes(2);
+    });
+
+    it("passes subagentSessionsDir from the constructor to isSubagentExecutionContext", () => {
+      const manager = new ForwardingManager(
+        "/custom/subagent-dir",
+        makeForwardingDeps(),
+      );
+      const ctx = makeCtx();
+      manager.start(ctx);
+
+      expect(mockIsSubagentExecutionContext).toHaveBeenCalledWith(
+        ctx,
+        "/custom/subagent-dir",
+      );
+    });
+  });
+});