@gotgenes/pi-permission-system 18.1.1 → 18.2.0

package/test/helpers/session-fixtures.ts

@@ -1,199 +0,0 @@
-/**
- * Shared real-instance test fixtures for PermissionSession and
- * PermissionResolver.
- *
- * Use these instead of hand-rolling per-file mock intersection types.
- * Build a real PermissionSession from small per-collaborator fakes so tests
- * assert against actual behavior rather than mock contracts.
- *
- * Note: tests that exercise `resolveAgentName` must mock `active-agent` in
- * their own file (the vi.hoisted / vi.mock pattern from permission-session.test.ts)
- * since that mock is module-scoped.
- */
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { vi } from "vitest";
-
-import type { ResolvedAccessIntent } from "#src/access-intent/access-intent";
-import type { SessionConfigStore } from "#src/config-store";
-import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
-import type { ExtensionPaths } from "#src/extension-paths";
-import type { ForwardingController } from "#src/forwarding-manager";
-import type { ScopedPermissionManager } from "#src/permission-manager";
-import { PermissionResolver } from "#src/permission-resolver";
-import { PermissionSession } from "#src/permission-session";
-import type { PromptingGatewayLifecycle } from "#src/prompting-gateway";
-import type { Ruleset } from "#src/rule";
-import type { SessionLogger } from "#src/session-logger";
-import { SessionRules } from "#src/session-rules";
-import type {
-  PathRuleTokenMatcher,
-  PermissionCheckResult,
-  PermissionState,
-} from "#src/types";
-
-// ── Per-collaborator fake factories ────────────────────────────────────────
-
-export function makePaths(
-  overrides: Partial<ExtensionPaths> = {},
-): ExtensionPaths {
-  return {
-    agentDir: "/test/agent",
-    sessionsDir: "/test/agent/sessions",
-    subagentSessionsDir: "/test/agent/subagent-sessions",
-    forwardingDir: "/test/agent/sessions/permission-forwarding",
-    globalLogsDir: "/test/agent/logs",
-    piInfrastructureDirs: ["/test/agent", "/test/agent/git"],
-    ...overrides,
-  };
-}
-
-export function makeLogger(): SessionLogger {
-  return {
-    debug: vi.fn(),
-    review: vi.fn(),
-    warn: vi.fn(),
-  };
-}
-
-export function makeConfigStore(
-  overrides: Partial<SessionConfigStore> = {},
-): SessionConfigStore {
-  return {
-    current:
-      overrides.current ??
-      vi
-        .fn<() => typeof DEFAULT_EXTENSION_CONFIG>()
-        .mockReturnValue({ ...DEFAULT_EXTENSION_CONFIG }),
-    refresh: overrides.refresh ?? vi.fn<(ctx?: ExtensionContext) => void>(),
-    logResolvedPaths: overrides.logResolvedPaths ?? vi.fn<() => void>(),
-  };
-}
-
-export function makeGateway(): PromptingGatewayLifecycle {
-  return {
-    activate: vi.fn<PromptingGatewayLifecycle["activate"]>(),
-    deactivate: vi.fn<PromptingGatewayLifecycle["deactivate"]>(),
-  };
-}
-
-export function makeForwarding(): ForwardingController {
-  return {
-    start: vi.fn(),
-    stop: vi.fn(),
-  };
-}
-
-/**
- * Fake `ScopedPermissionManager` with vi.fn() stubs.
- *
- * Return type is intentionally unannotated so callers retain full `vi.fn()`
- * mock access (`mock.calls`, `toHaveBeenCalledWith`, `mockReturnValue`, etc.).
- */
-export function makeFakePermissionManager() {
-  return {
-    configureForCwd: vi.fn<(cwd: string | undefined | null) => void>(),
-    check: vi
-      .fn<
-        (
-          intent: ResolvedAccessIntent,
-          sessionRules?: Ruleset,
-        ) => PermissionCheckResult
-      >()
-      .mockReturnValue({
-        state: "allow",
-        toolName: "read",
-        source: "tool",
-        origin: "builtin",
-      }),
-    getToolPermission: vi
-      .fn<(toolName: string, agentName?: string) => PermissionState>()
-      .mockReturnValue("allow"),
-    getConfigIssues: vi.fn((): string[] => []),
-    getPromotablePathTokenMatcher: vi
-      .fn<(agentName?: string) => PathRuleTokenMatcher>()
-      .mockReturnValue(() => false),
-  };
-}
-
-// ── Real-instance factories ────────────────────────────────────────────────
-
-/**
- * Build a real PermissionSession from per-collaborator fakes.
- *
- * Returns the session and every collaborator so callers can destructure only
- * what they need and assert against collaborator spies directly.
- * The `permissionManager` is a `makeFakePermissionManager()` result unless
- * the caller passes an explicit `ScopedPermissionManager`.
- */
-export function makeRealSession(overrides?: {
-  paths?: Partial<ExtensionPaths>;
-  logger?: SessionLogger;
-  forwarding?: ForwardingController;
-  permissionManager?: ScopedPermissionManager;
-  sessionRules?: SessionRules;
-  configStore?: SessionConfigStore;
-  gateway?: PromptingGatewayLifecycle;
-  platform?: NodeJS.Platform;
-}): {
-  session: PermissionSession;
-  paths: ExtensionPaths;
-  logger: SessionLogger;
-  forwarding: ForwardingController;
-  permissionManager: ReturnType<typeof makeFakePermissionManager>;
-  sessionRules: SessionRules;
-  configStore: SessionConfigStore;
-  gateway: PromptingGatewayLifecycle;
-} {
-  const paths = makePaths(overrides?.paths);
-  const logger = overrides?.logger ?? makeLogger();
-  const forwarding = overrides?.forwarding ?? makeForwarding();
-  const permissionManager =
-    (overrides?.permissionManager as
-      | ReturnType<typeof makeFakePermissionManager>
-      | undefined) ?? makeFakePermissionManager();
-  const sessionRules = overrides?.sessionRules ?? new SessionRules();
-  const configStore = overrides?.configStore ?? makeConfigStore();
-  const gateway = overrides?.gateway ?? makeGateway();
-  const platform = overrides?.platform ?? process.platform;
-  const session = new PermissionSession(
-    paths,
-    forwarding,
-    permissionManager,
-    sessionRules,
-    configStore,
-    gateway,
-    platform,
-  );
-  return {
-    session,
-    paths,
-    logger,
-    forwarding,
-    permissionManager,
-    sessionRules,
-    configStore,
-    gateway,
-  };
-}
-
-/**
- * Build a real PermissionResolver from a fake manager and a SessionRules
- * instance.
- *
- * When called with no arguments, creates a fresh fake manager and fresh
- * SessionRules.  Pass shared instances to connect the resolver to the same
- * manager/rules used by a real session.
- */
-export function makeRealResolver(
-  manager?: ReturnType<typeof makeFakePermissionManager>,
-  sessionRules?: SessionRules,
-): {
-  resolver: PermissionResolver;
-  manager: ReturnType<typeof makeFakePermissionManager>;
-  sessionRules: SessionRules;
-} {
-  const resolvedManager = manager ?? makeFakePermissionManager();
-  const resolvedRules = sessionRules ?? new SessionRules();
-  const resolver = new PermissionResolver(resolvedManager, resolvedRules);
-  return { resolver, manager: resolvedManager, sessionRules: resolvedRules };
-}

package/test/input-normalizer.test.ts

@@ -1,325 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const mockHomedir = vi.hoisted(() => vi.fn(() => "/mock/home"));
-
-vi.mock("node:os", () => ({
-  homedir: mockHomedir,
-  default: { homedir: mockHomedir },
-}));
-
-// Mock node:fs so realpathSync (used by the canonical alias) is controllable.
-// Default implementation is identity — lexical tests are unaffected.
-const realpathSync = vi.hoisted(() =>
-  vi.fn<(path: string) => string>((p) => p),
-);
-vi.mock("node:fs", () => ({
-  realpathSync,
-  default: { realpathSync },
-}));
-
-import {
-  buildAccessIntentForSurface,
-  normalizeInput,
-} from "#src/input-normalizer";
-import { createMcpPermissionTargets } from "#src/mcp-targets";
-import { PathNormalizer } from "#src/path-normalizer";
-
-afterEach(() => {
-  mockHomedir.mockClear();
-  realpathSync.mockReset();
-  realpathSync.mockImplementation((p: string) => p);
-});
-
-describe("normalizeInput — non-MCP surfaces", () => {
-  // Path-bearing and special surfaces no longer derive path lookup values
-  // through normalizeInput — that is now done by the access-path gate (#502)
-  // and the service/RPC builder (#503). normalizeInput's tool branch collapses
-  // every path-bearing or special surface to the catch-all ["*"] exactly as it
-  // does for any unrecognised extension tool.
-  describe("path-bearing and special surfaces collapse to '*'", () => {
-    it("path surface ignores input.path and returns ['*']", () => {
-      // After #504 removal: path no longer has a special branch.
-      const result = normalizeInput("path", { path: ".env" }, []);
-      expect(result.surface).toBe("path");
-      expect(result.values).toEqual(["*"]);
-      expect(result.resultExtras).toEqual({});
-    });
-
-    it("external_directory surface ignores input.path and returns ['*']", () => {
-      const result = normalizeInput(
-        "external_directory",
-        { path: "/other/project" },
-        [],
-      );
-      expect(result.surface).toBe("external_directory");
-      expect(result.values).toEqual(["*"]);
-      expect(result.resultExtras).toEqual({});
-    });
-
-    it("read surface ignores input.path and returns ['*']", () => {
-      const result = normalizeInput("read", { path: ".env" }, []);
-      expect(result.surface).toBe("read");
-      expect(result.values).toEqual(["*"]);
-      expect(result.resultExtras).toEqual({});
-    });
-
-    it("missing path also returns ['*'] (unchanged fallback)", () => {
-      for (const surface of [
-        "path",
-        "external_directory",
-        "read",
-        "write",
-        "edit",
-        "grep",
-        "find",
-        "ls",
-      ]) {
-        const result = normalizeInput(surface, {}, []);
-        expect(result.values).toEqual(["*"]);
-      }
-    });
-  });
-
-  describe("skill", () => {
-    it("uses skill name from input.name", () => {
-      const result = normalizeInput("skill", { name: "librarian" }, []);
-      expect(result.surface).toBe("skill");
-      expect(result.values).toEqual(["librarian"]);
-      expect(result.resultExtras).toEqual({});
-    });
-
-    it("falls back to '*' when name is missing", () => {
-      const result = normalizeInput("skill", {}, []);
-      expect(result.values).toEqual(["*"]);
-    });
-
-    it("falls back to '*' when name is not a string", () => {
-      const result = normalizeInput("skill", { name: 99 }, []);
-      expect(result.values).toEqual(["*"]);
-    });
-  });
-
-  describe("bash", () => {
-    it("uses command from input.command", () => {
-      const result = normalizeInput("bash", { command: "git status" }, []);
-      expect(result.surface).toBe("bash");
-      expect(result.values).toEqual(["git status"]);
-      expect(result.resultExtras).toEqual({ command: "git status" });
-    });
-
-    it("uses empty string when command is missing", () => {
-      const result = normalizeInput("bash", {}, []);
-      expect(result.values).toEqual([""]);
-      expect(result.resultExtras).toEqual({ command: "" });
-    });
-
-    it("uses empty string when command is not a string", () => {
-      const result = normalizeInput("bash", { command: 42 }, []);
-      expect(result.values).toEqual([""]);
-      expect(result.resultExtras).toEqual({ command: "" });
-    });
-
-    it("strips leading comment lines from values but keeps original in resultExtras", () => {
-      const cmd = "# Check debug logs\nfind /home -path '*debug*' -type f";
-      const result = normalizeInput("bash", { command: cmd }, []);
-      expect(result.values).toEqual(["find /home -path '*debug*' -type f"]);
-      expect(result.resultExtras).toEqual({ command: cmd });
-    });
-
-    it("strips multiple comment lines", () => {
-      const cmd = "# Step 1\n# Step 2\ngit status --short";
-      const result = normalizeInput("bash", { command: cmd }, []);
-      expect(result.values).toEqual(["git status --short"]);
-    });
-
-    it("preserves command when no comment lines present", () => {
-      const result = normalizeInput(
-        "bash",
-        { command: "grep -rn foo src/" },
-        [],
-      );
-      expect(result.values).toEqual(["grep -rn foo src/"]);
-    });
-
-    it("falls back to original when all lines are comments", () => {
-      const cmd = "# just a comment";
-      const result = normalizeInput("bash", { command: cmd }, []);
-      expect(result.values).toEqual(["# just a comment"]);
-    });
-  });
-
-  describe("extension tools (non-path-bearing)", () => {
-    it("uses '*' as the lookup value for extension tools", () => {
-      const result = normalizeInput("my_extension_tool", { some: "input" }, []);
-      expect(result.surface).toBe("my_extension_tool");
-      expect(result.values).toEqual(["*"]);
-      expect(result.resultExtras).toEqual({});
-    });
-
-    it("uses '*' even when extension tool has a path field", () => {
-      const result = normalizeInput(
-        "my_extension_tool",
-        { path: "/some/path" },
-        [],
-      );
-      expect(result.values).toEqual(["*"]);
-    });
-  });
-});
-
-describe("normalizeInput — MCP surface", () => {
-  it("surface is 'mcp'", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, []);
-    expect(result.surface).toBe("mcp");
-  });
-
-  it("values end with the catch-all 'mcp' target", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, []);
-    expect(result.values.at(-1)).toBe("mcp");
-  });
-
-  it("values include specific targets before the catch-all for a qualified tool call", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, []);
-    expect(result.values).toContain("exa_search");
-    expect(result.values).toContain("exa:search");
-    expect(result.values).toContain("exa");
-    expect(result.values).toContain("mcp_call");
-    // 'mcp' is always last
-    expect(result.values.at(-1)).toBe("mcp");
-  });
-
-  it("matches createMcpPermissionTargets output + 'mcp' appended", () => {
-    const rawTargets = createMcpPermissionTargets({ tool: "exa:search" }, [
-      "exa",
-    ]);
-    const result = normalizeInput("mcp", { tool: "exa:search" }, ["exa"]);
-    expect(result.values).toEqual([...rawTargets, "mcp"]);
-  });
-
-  it("resultExtras.target is the first specific target (most-specific)", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, []);
-    expect(result.resultExtras.target).toBe(result.values[0]);
-  });
-
-  it("resultExtras.target is 'mcp' when no specific targets are derived", () => {
-    // Empty input → only mcp_status then mcp appended
-    const result = normalizeInput("mcp", {}, []);
-    expect(result.resultExtras.target).toBe("mcp_status");
-  });
-
-  it("values contain no duplicates", () => {
-    const result = normalizeInput("mcp", { tool: "exa:search" }, ["exa"]);
-    const unique = [...new Set(result.values)];
-    expect(result.values).toEqual(unique);
-  });
-
-  it("produces mcp_status + mcp for status input", () => {
-    const result = normalizeInput("mcp", {}, []);
-    expect(result.values).toEqual(["mcp_status", "mcp"]);
-  });
-
-  it("produces connect targets + mcp for connect input", () => {
-    const result = normalizeInput("mcp", { connect: "exa" }, []);
-    expect(result.values).toContain("mcp_connect_exa");
-    expect(result.values).toContain("mcp_connect");
-    expect(result.values.at(-1)).toBe("mcp");
-  });
-});
-
-describe("buildAccessIntentForSurface", () => {
-  const normalizer = new PathNormalizer("linux", "/test/project");
-
-  it("emits an access-path intent carrying the canonical alias for the path surface", () => {
-    realpathSync.mockImplementation((p: string) =>
-      p === "/test/project/link" ? "/test/project/real" : p,
-    );
-    const intent = buildAccessIntentForSurface(
-      "path",
-      "link",
-      normalizer,
-      undefined,
-    );
-    expect(intent.kind).toBe("access-path");
-    if (intent.kind === "access-path") {
-      expect(intent.surface).toBe("path");
-      expect(intent.path.matchValues()).toContain("/test/project/real");
-      expect(intent.path.value()).toBe("/test/project/link");
-    }
-  });
-
-  it("emits an access-path intent for the external_directory surface", () => {
-    const intent = buildAccessIntentForSurface(
-      "external_directory",
-      "/outside/dir",
-      normalizer,
-      undefined,
-    );
-    expect(intent.kind).toBe("access-path");
-    if (intent.kind === "access-path") {
-      expect(intent.surface).toBe("external_directory");
-      expect(intent.path.value()).toBe("/outside/dir");
-    }
-  });
-
-  it("emits an access-path intent for a path-bearing tool surface (read)", () => {
-    const intent = buildAccessIntentForSurface(
-      "read",
-      "/test/project/.env",
-      normalizer,
-      undefined,
-    );
-    expect(intent.kind).toBe("access-path");
-    if (intent.kind === "access-path") {
-      expect(intent.surface).toBe("read");
-      expect(intent.path.value()).toBe("/test/project/.env");
-    }
-  });
-
-  it("emits a tool intent for a non-path surface (bash)", () => {
-    const intent = buildAccessIntentForSurface(
-      "bash",
-      "echo hi",
-      normalizer,
-      "my-agent",
-    );
-    expect(intent).toEqual({
-      kind: "tool",
-      surface: "bash",
-      input: { command: "echo hi" },
-      agentName: "my-agent",
-    });
-  });
-
-  it("passes agentName through on the access-path branch", () => {
-    const intent = buildAccessIntentForSurface(
-      "path",
-      "/some/file",
-      normalizer,
-      "Explore",
-    );
-    expect(intent.agentName).toBe("Explore");
-  });
-
-  it("falls back to a tool intent for a value-less path surface", () => {
-    const intent = buildAccessIntentForSurface(
-      "path",
-      undefined,
-      normalizer,
-      undefined,
-    );
-    expect(intent.kind).toBe("tool");
-    if (intent.kind === "tool") {
-      expect(intent.surface).toBe("path");
-    }
-  });
-
-  it("falls back to a tool intent for a whitespace-only path value", () => {
-    const intent = buildAccessIntentForSurface(
-      "external_directory",
-      "   ",
-      normalizer,
-      undefined,
-    );
-    expect(intent.kind).toBe("tool");
-  });
-});

package/test/logging.test.ts

@@ -1,51 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { expect, test } from "vitest";
-import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
-import { createPermissionSystemLogger } from "#src/logging";
-
-test("Permission-system logger respects debug toggle and keeps review log enabled by default", () => {
-  const baseDir = mkdtempSync(join(tmpdir(), "pi-permission-system-logs-"));
-  const logsDir = join(baseDir, "logs");
-  const debugLogPath = join(logsDir, "debug.jsonl");
-  const reviewLogPath = join(logsDir, "review.jsonl");
-  const config = { ...DEFAULT_EXTENSION_CONFIG };
-  const logger = createPermissionSystemLogger({
-    getConfig: () => config,
-    debugLogPath,
-    reviewLogPath,
-    ensureLogsDirectory: () => {
-      mkdirSync(logsDir, { recursive: true });
-      return undefined;
-    },
-  });
-
-  try {
-    const initialDebugWarning = logger.debug("debug.disabled", {
-      sample: true,
-    });
-    const reviewWarning = logger.review("permission_request.waiting", {
-      toolName: "write",
-    });
-
-    expect(initialDebugWarning).toBe(undefined);
-    expect(reviewWarning).toBe(undefined);
-    expect(existsSync(debugLogPath)).toBe(false);
-    expect(existsSync(reviewLogPath)).toBe(true);
-
-    config.debugLog = true;
-    const enabledDebugWarning = logger.debug("debug.enabled", { sample: true });
-    expect(enabledDebugWarning).toBe(undefined);
-    expect(existsSync(debugLogPath)).toBe(true);
-    expect(readFileSync(debugLogPath, "utf8")).toMatch(/debug\.enabled/);
-  } finally {
-    rmSync(baseDir, { recursive: true, force: true });
-  }
-});