@gotgenes/pi-permission-system 18.1.1 → 18.1.2

package/test/helpers/handler-fixtures.ts

@@ -1,335 +0,0 @@
-/**
- * Shared handler-level test fixtures for PermissionGateHandler tests.
- *
- * `makeHandler` builds a real PermissionSession + PermissionResolver and wires
- * them into the handler and pipelines exactly as `index.ts` does.
- * Call-site overrides for permission results flow through
- * `permissionManager.check`; session state overrides are applied
- * via vi.spyOn on the real session instance.
- */
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { vi } from "vitest";
-
-import type { ResolvedAccessIntent } from "#src/access-intent/access-intent";
-import { GateDecisionReporter } from "#src/decision-reporter";
-import type { GatePrompter } from "#src/gate-prompter";
-import { GateRunner } from "#src/handlers/gates/runner";
-import {
-  type SkillInputGateInputs,
-  SkillInputGatePipeline,
-} from "#src/handlers/gates/skill-input-gate-pipeline";
-import {
-  type ToolCallGateInputs,
-  ToolCallGatePipeline,
-} from "#src/handlers/gates/tool-call-gate-pipeline";
-import { PermissionGateHandler } from "#src/handlers/permission-gate-handler";
-import type { PermissionDecisionEvent } from "#src/permission-events";
-import { PERMISSIONS_DECISION_CHANNEL } from "#src/permission-events";
-import type { Rule } from "#src/rule";
-import { SessionRules } from "#src/session-rules";
-import type { ToolRegistry } from "#src/tool-registry";
-import type { PermissionCheckResult, PermissionState } from "#src/types";
-import {
-  makeRealResolver,
-  makeRealSession,
-} from "#test/helpers/session-fixtures";
-
-// ── MockGateHandlerSession ────────────────────────────────────────────────
-
-/**
- * Mock type for gate-pipeline inputs (ToolCallGateInputs + SkillInputGateInputs).
- *
- * Used by `makeSurfaceCheck`, `makeBashCommandCheck`, and the `session`
- * override bag in `makeHandler`.  The `GateHandlerSession` role (activate +
- * resolveAgentName) is now satisfied by the real `PermissionSession`; this
- * type covers only the pipeline input surface.
- *
- * The 4-arg `checkPermission` is a superset of `SkillInputGateInputs` —
- * it routes through `permissionManager.checkPermission` in production.
- */
-export type MockGateHandlerSession = ToolCallGateInputs &
-  SkillInputGateInputs & {
-    /** 4-arg form so surface-check mocks can receive optional rules. */
-    checkPermission(
-      surface: string,
-      input: unknown,
-      agentName?: string,
-      rules?: Rule[],
-    ): PermissionCheckResult;
-  };
-
-// ── Small utility factories ───────────────────────────────────────────────
-
-export function makeEvents() {
-  return {
-    emit: vi.fn(),
-    on: vi.fn().mockReturnValue(() => undefined),
-  };
-}
-
-export function makeCtx(
-  overrides: Partial<ExtensionContext> = {},
-): ExtensionContext {
-  return {
-    cwd: "/test/project",
-    hasUI: true,
-    ui: {
-      setStatus: vi.fn(),
-      notify: vi.fn(),
-      select: vi.fn(),
-      input: vi.fn(),
-    },
-    sessionManager: {
-      getEntries: vi.fn().mockReturnValue([]),
-      getSessionDir: vi.fn().mockReturnValue("/sessions/test"),
-      addEntry: vi.fn(),
-    },
-    ...overrides,
-  } as unknown as ExtensionContext;
-}
-
-export function makeToolCallEvent(
-  toolName: string,
-  extraFields: Record<string, unknown> = {},
-) {
-  return {
-    type: "tool_call",
-    toolCallId: "tc-1",
-    name: toolName,
-    input: {},
-    ...extraFields,
-  };
-}
-
-/**
- * Neutral-default check-result builder.
- *
- * Pass exactly the fields the original fixture hard-coded so divergent
- * defaults across test files are preserved at their call sites.
- */
-export function makeCheckResult(
-  overrides: Partial<PermissionCheckResult> = {},
-): PermissionCheckResult {
-  return {
-    state: "allow",
-    toolName: "read",
-    source: "tool",
-    origin: "builtin",
-    ...overrides,
-  };
-}
-
-export function makeToolRegistry(
-  overrides: Partial<ToolRegistry> = {},
-): ToolRegistry {
-  return {
-    getAll: vi.fn().mockReturnValue([{ name: "read" }, { name: "bash" }]),
-    getActive: vi.fn().mockReturnValue(["read", "bash"]),
-    setActive: vi.fn(),
-    ...overrides,
-  };
-}
-
-// ── Surface-check factories ────────────────────────────────────────────────
-
-/**
- * Surface-dispatching `checkPermission` mock.
- *
- * Returns the matching per-surface result or `defaultResult`.
- * Pass the returned function as `session.checkPermission` in a `makeHandler`
- * override bag — it is applied to `permissionManager.checkPermission`.
- *
- * Return type is intentionally unannotated so callers retain full `vi.fn()`
- * mock access (`mock.calls`, `toHaveBeenCalledWith`, etc.).
- */
-export function makeSurfaceCheck(
-  bySurface: Record<
-    string,
-    Partial<PermissionCheckResult> & { state: PermissionState }
-  >,
-  defaultResult: Partial<PermissionCheckResult> & { state: PermissionState } = {
-    state: "allow",
-  },
-) {
-  return vi
-    .fn<MockGateHandlerSession["checkPermission"]>()
-    .mockImplementation((surface): PermissionCheckResult => {
-      const base = bySurface[surface] ?? defaultResult;
-      return {
-        toolName: surface,
-        source: "tool",
-        origin: "builtin",
-        ...base,
-      };
-    });
-}
-
-/**
- * Bash-surface `checkPermission` mock that dispatches on a command regex.
- *
- * Pass the returned function as `session.checkPermission` in a `makeHandler`
- * override bag — it is applied to `permissionManager.checkPermission`.
- *
- * Return type is intentionally unannotated so callers retain full `vi.fn()`
- * mock access.
- */
-export function makeBashCommandCheck(opts: {
-  deny: RegExp;
-  denyMatched: string;
-  allowMatched?: string;
-}) {
-  return vi
-    .fn<MockGateHandlerSession["checkPermission"]>()
-    .mockImplementation((surface, input): PermissionCheckResult => {
-      if (surface === "bash") {
-        const command = (input as { command?: string }).command ?? "";
-        return opts.deny.test(command)
-          ? makeCheckResult({
-              state: "deny",
-              source: "bash",
-              command,
-              matchedPattern: opts.denyMatched,
-            })
-          : makeCheckResult({
-              state: "allow",
-              source: "bash",
-              command,
-              matchedPattern: opts.allowMatched,
-            });
-      }
-      return makeCheckResult({ state: "allow" });
-    });
-}
-
-// ── makeHandler ────────────────────────────────────────────────────────────
-
-/**
- * Constructs a PermissionGateHandler wired with real collaborators.
- *
- * The `session` override bag maps to the real collaborators:
- * - `checkPermission` → applied to `permissionManager.checkPermission`
- * - `getActiveSkillEntries`, `getInfrastructureReadDirs`, `getToolPreviewLimits`
- *   → applied as vi.spyOn overrides on the real session
- * - `resolveAgentName` → applied as a vi.spyOn override on the real session
- *
- * Returns `{ handler, events, session, toolRegistry, prompter, recorder,
- * permissionManager, forwarding }` so each test file can destructure only
- * what it needs.
- * `session.activate` is not a mock — use `forwarding.start` to assert it
- * was called.
- */
-export function makeHandler(overrides?: {
-  session?: Partial<MockGateHandlerSession> & {
-    resolveAgentName?: (
-      ctx: ExtensionContext,
-      systemPrompt?: string,
-    ) => string | null;
-  };
-  /** Override the GatePrompter passed to GateRunner. Defaults to an allow-all stub. */
-  prompter?: GatePrompter;
-  toolRegistry?: Partial<ToolRegistry>;
-  /** Sugar: builds the `getAll` mock from a list of tool names. */
-  tools?: string[];
-}) {
-  const { session, permissionManager, sessionRules, forwarding, logger } =
-    makeRealSession();
-  const { resolver } = makeRealResolver(permissionManager, sessionRules);
-
-  // Apply session override bag to the real collaborators.
-  const so = overrides?.session;
-  const surfaceCheck = so?.checkPermission;
-  if (surfaceCheck) {
-    // Route the unified check(intent) through the surface dispatcher so
-    // makeSurfaceCheck / makeBashCommandCheck overrides apply to all gate
-    // paths via the single manager entry point (#478).
-    vi.mocked(permissionManager.check).mockImplementation(
-      (intent: ResolvedAccessIntent, sessionRules) => {
-        if (intent.kind === "path-values") {
-          return surfaceCheck(
-            intent.surface,
-            { path: intent.values[0] ?? "*" },
-            intent.agentName,
-            sessionRules,
-          );
-        }
-        return surfaceCheck(
-          intent.surface,
-          intent.input,
-          intent.agentName,
-          sessionRules,
-        );
-      },
-    );
-  }
-  if (so?.getActiveSkillEntries) {
-    vi.spyOn(session, "getActiveSkillEntries").mockImplementation(
-      so.getActiveSkillEntries,
-    );
-  }
-  if (so?.getInfrastructureReadDirs) {
-    vi.spyOn(session, "getInfrastructureReadDirs").mockImplementation(
-      so.getInfrastructureReadDirs,
-    );
-  }
-  if (so?.getToolPreviewLimits) {
-    vi.spyOn(session, "getToolPreviewLimits").mockImplementation(
-      so.getToolPreviewLimits,
-    );
-  }
-  if (so?.resolveAgentName) {
-    vi.spyOn(session, "resolveAgentName").mockImplementation(
-      so.resolveAgentName,
-    );
-  }
-
-  const events = makeEvents();
-  const toolRegistry =
-    overrides?.tools !== undefined
-      ? makeToolRegistry({
-          getAll: vi
-            .fn()
-            .mockReturnValue(overrides.tools.map((name) => ({ name }))),
-        })
-      : makeToolRegistry(overrides?.toolRegistry);
-
-  const recorder = new SessionRules();
-  const pipeline = new ToolCallGatePipeline(resolver, session);
-  const skillInputPipeline = new SkillInputGatePipeline(resolver);
-  const reporter = new GateDecisionReporter(logger, events);
-  const prompter: GatePrompter = overrides?.prompter ?? {
-    canConfirm: vi.fn().mockReturnValue(true),
-    prompt: vi
-      .fn<GatePrompter["prompt"]>()
-      .mockResolvedValue({ approved: true, state: "approved" }),
-  };
-  const runner = new GateRunner(resolver, recorder, prompter, reporter);
-  const handler = new PermissionGateHandler(
-    session,
-    toolRegistry,
-    pipeline,
-    skillInputPipeline,
-    runner,
-  );
-  return {
-    handler,
-    events,
-    session,
-    logger,
-    toolRegistry,
-    prompter,
-    recorder,
-    permissionManager,
-    forwarding,
-  };
-}
-
-// ── Decision-event helper ─────────────────────────────────────────────────
-
-/** Extract all permissions:decision payloads from the events.emit mock. */
-export function getDecisionEvents(
-  events: ReturnType<typeof makeEvents>,
-): PermissionDecisionEvent[] {
-  return events.emit.mock.calls
-    .filter(([channel]) => channel === PERMISSIONS_DECISION_CHANNEL)
-    .map(([, payload]) => payload as PermissionDecisionEvent);
-}

package/test/helpers/make-fake-pi.ts

@@ -1,100 +0,0 @@
-/**
- * `makeFakePi()` — a composition-root test harness.
- *
- * Lets a test run the real `piPermissionSystemExtension(pi)` factory and then
- * introspect and drive the result. Unlike the per-handler unit fixtures in
- * `handler-fixtures.ts` (which inject collaborators), this harness exercises the
- * factory itself — the wiring layer where registration completeness, shared-
- * instance contracts, teardown, and event ordering live.
- *
- * It provides:
- * - `events` — a real `createEventBus()` so cross-extension pub/sub and RPC
- *   behave as in production (tests can inject a shared bus to model parent/child
- *   instances).
- * - `handlers` — every `pi.on(event, handler)` registration, keyed by event
- *   name, so a test can assert completeness and fire handlers.
- * - `commands` — every `pi.registerCommand(name, …)` registration.
- * - `fire(event, input, ctx)` — drive a registered handler; resolves to its
- *   (possibly async) result.
- *
- * The harness object is cast to `ExtensionAPI` at the call to the factory; the
- * `FakePi` interface itself stays narrow (ISP — only what the factory touches).
- */
-import { createEventBus, type EventBus } from "@earendil-works/pi-coding-agent";
-import { vi } from "vitest";
-
-/** A handler recorded by `pi.on(...)`, kept generic over event/result shapes. */
-export type RecordedHandler = (event: unknown, ctx: unknown) => unknown;
-
-export interface FakePi {
-  /** Real event bus so cross-extension pub/sub and RPC behave as in production. */
-  events: EventBus;
-  /** Every `pi.on(event, handler)` registration, keyed by event name. */
-  handlers: Map<string, RecordedHandler>;
-  /** Every `pi.registerCommand(name, …)` registration, keyed by command name. */
-  commands: Map<string, unknown>;
-  /**
-   * Drive a registered handler; resolves to its (possibly async) result.
-   *
-   * Throws if no handler is registered for `event` so a typo in a test surfaces
-   * loudly instead of silently resolving to `undefined`.
-   */
-  fire(event: string, input?: unknown, ctx?: unknown): Promise<unknown>;
-  /** Minimal tool registry — returns the configured tool names. */
-  getAllTools(): { name: string }[];
-  /** Active tool names (`pi.getActiveTools()` shape — bare strings). */
-  getActiveTools(): string[];
-  setActiveTools(names: string[]): void;
-}
-
-export interface MakeFakePiOptions {
-  /** Inject a shared bus to model parent/child instances; defaults to a fresh bus. */
-  events?: EventBus;
-  /** Tool names returned by `getAllTools()`; defaults to a small set. */
-  toolNames?: readonly string[];
-}
-
-const DEFAULT_TOOL_NAMES = ["read", "write", "edit", "bash", "ls", "grep"];
-
-/**
- * Build a fake `ExtensionAPI` for composition-root tests.
- *
- * The returned object is structurally a `FakePi`; pass it to the factory as
- * `piPermissionSystemExtension(pi as unknown as ExtensionAPI)`.
- */
-export function makeFakePi(options: MakeFakePiOptions = {}): FakePi {
-  const events = options.events ?? createEventBus();
-  const toolNames = options.toolNames ?? DEFAULT_TOOL_NAMES;
-  const handlers = new Map<string, RecordedHandler>();
-  const commands = new Map<string, unknown>();
-
-  return {
-    events,
-    handlers,
-    commands,
-    fire(event, input, ctx): Promise<unknown> {
-      const handler = handlers.get(event);
-      if (!handler) {
-        throw new Error(`No handler registered for event "${event}"`);
-      }
-      return Promise.resolve(handler(input, ctx));
-    },
-    getAllTools(): { name: string }[] {
-      return toolNames.map((name) => ({ name }));
-    },
-    getActiveTools(): string[] {
-      return [...toolNames];
-    },
-    setActiveTools: vi.fn(),
-    // ── ExtensionAPI methods the factory touches (recorded) ────────────────
-    on(event: string, handler: RecordedHandler): void {
-      handlers.set(event, handler);
-    },
-    registerCommand(name: string, optionsArg: unknown): void {
-      commands.set(name, optionsArg);
-    },
-    // ── ExtensionAPI methods present for the cast but unused by the factory ─
-    registerProvider: vi.fn(),
-    exec: vi.fn(),
-  } as FakePi & Record<string, unknown>;
-}

package/test/helpers/manager-harness.ts

@@ -1,112 +0,0 @@
-/**
- * Filesystem-backed PermissionManager harness for integration tests.
- *
- * Writes a real config file and agents directory to a temp directory so
- * PermissionManager can load them without mocking the file system.
- */
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { PermissionManager } from "#src/permission-manager";
-import type { ScopeConfig } from "#src/types";
-
-export type CreateManagerOptions = {
-  mcpServerNames?: readonly string[];
-};
-
-export type CreateManagerWithProjectOptions = CreateManagerOptions & {
-  projectConfig?: ScopeConfig;
-  projectAgentFiles?: Record<string, string>;
-};
-
-export function createManager(
-  config: ScopeConfig,
-  agentFiles: Record<string, string> = {},
-  options: CreateManagerOptions = {},
-) {
-  const baseDir = mkdtempSync(join(tmpdir(), "pi-permission-system-test-"));
-  const globalConfigPath = join(baseDir, "pi-permissions.jsonc");
-  const agentsDir = join(baseDir, "agents");
-
-  mkdirSync(agentsDir, { recursive: true });
-  writeFileSync(
-    globalConfigPath,
-    `${JSON.stringify(config, null, 2)}\n`,
-    "utf8",
-  );
-
-  for (const [name, content] of Object.entries(agentFiles)) {
-    writeFileSync(join(agentsDir, `${name}.md`), content, "utf8");
-  }
-
-  const manager = new PermissionManager({
-    globalConfigPath,
-    agentsDir,
-    mcpServerNames: options.mcpServerNames,
-  });
-
-  return {
-    manager,
-    globalConfigPath,
-    cleanup: (): void => {
-      rmSync(baseDir, { recursive: true, force: true });
-    },
-  };
-}
-
-export function createManagerWithProject(
-  config: ScopeConfig,
-  agentFiles: Record<string, string> = {},
-  options: CreateManagerWithProjectOptions = {},
-) {
-  const baseDir = mkdtempSync(
-    join(tmpdir(), "pi-permission-system-proj-test-"),
-  );
-  const globalConfigPath = join(baseDir, "pi-permissions.jsonc");
-  const agentsDir = join(baseDir, "agents");
-  const projectRoot = join(baseDir, "project");
-  const projectGlobalConfigPath = join(projectRoot, "pi-permissions.jsonc");
-  const projectAgentsDir = join(projectRoot, "agents");
-
-  mkdirSync(agentsDir, { recursive: true });
-  mkdirSync(projectAgentsDir, { recursive: true });
-
-  writeFileSync(
-    globalConfigPath,
-    `${JSON.stringify(config, null, 2)}\n`,
-    "utf8",
-  );
-  if (options.projectConfig) {
-    writeFileSync(
-      projectGlobalConfigPath,
-      `${JSON.stringify(options.projectConfig, null, 2)}\n`,
-      "utf8",
-    );
-  }
-
-  for (const [name, content] of Object.entries(agentFiles)) {
-    writeFileSync(join(agentsDir, `${name}.md`), content, "utf8");
-  }
-
-  for (const [name, content] of Object.entries(
-    options.projectAgentFiles ?? {},
-  )) {
-    writeFileSync(join(projectAgentsDir, `${name}.md`), content, "utf8");
-  }
-
-  const manager = new PermissionManager({
-    globalConfigPath,
-    agentsDir,
-    projectGlobalConfigPath,
-    projectAgentsDir,
-    mcpServerNames: options.mcpServerNames,
-  });
-
-  return {
-    manager,
-    cleanup: (): void => {
-      rmSync(baseDir, { recursive: true, force: true });
-    },
-  };
-}