@gotgenes/pi-permission-system 18.1.1 → 18.1.2

package/test/handlers/gates/skill-input.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { describeSkillInputGate } from "#src/handlers/gates/skill-input";
-import { makeCheckResult } from "#test/helpers/handler-fixtures";
-
-// ── helpers ────────────────────────────────────────────────────────────────
-
-function makeSkillCheck(state: "allow" | "deny" | "ask") {
-  return makeCheckResult({
-    state,
-    toolName: "skill",
-    source: "skill",
-    origin: "global",
-    matchedPattern: "*",
-  });
-}
-
-// ── describeSkillInputGate ─────────────────────────────────────────────────
-
-describe("describeSkillInputGate", () => {
-  it("sets surface to 'skill'", () => {
-    const descriptor = describeSkillInputGate(
-      "librarian",
-      null,
-      makeSkillCheck("allow"),
-    );
-    expect(descriptor.surface).toBe("skill");
-  });
-
-  it("sets input.name to the skill name", () => {
-    const descriptor = describeSkillInputGate(
-      "librarian",
-      null,
-      makeSkillCheck("allow"),
-    );
-    expect(descriptor.input).toEqual({ name: "librarian" });
-  });
-
-  it("passes preCheck through verbatim", () => {
-    const check = makeSkillCheck("deny");
-    const descriptor = describeSkillInputGate("librarian", null, check);
-    expect(descriptor.preCheck).toBe(check);
-  });
-
-  it("sets denialContext with kind skill_input and skill name", () => {
-    const descriptor = describeSkillInputGate(
-      "librarian",
-      null,
-      makeSkillCheck("allow"),
-    );
-    expect(descriptor.denialContext).toEqual({
-      kind: "skill_input",
-      skillName: "librarian",
-      agentName: undefined,
-    });
-  });
-
-  it("includes agentName in denialContext when provided", () => {
-    const descriptor = describeSkillInputGate(
-      "librarian",
-      "code-agent",
-      makeSkillCheck("allow"),
-    );
-    expect(descriptor.denialContext).toEqual({
-      kind: "skill_input",
-      skillName: "librarian",
-      agentName: "code-agent",
-    });
-  });
-
-  it("sets promptDetails source to 'skill_input' with skill name and agent", () => {
-    const descriptor = describeSkillInputGate(
-      "librarian",
-      "code-agent",
-      makeSkillCheck("ask"),
-    );
-    expect(descriptor.promptDetails).toMatchObject({
-      source: "skill_input",
-      agentName: "code-agent",
-      skillName: "librarian",
-    });
-  });
-
-  it("includes a non-empty message in promptDetails", () => {
-    const descriptor = describeSkillInputGate(
-      "librarian",
-      null,
-      makeSkillCheck("ask"),
-    );
-    expect(typeof descriptor.promptDetails.message).toBe("string");
-    expect(descriptor.promptDetails.message.length).toBeGreaterThan(0);
-  });
-
-  it("sets logContext source to 'skill_input' with skill name and agent", () => {
-    const descriptor = describeSkillInputGate(
-      "librarian",
-      "code-agent",
-      makeSkillCheck("allow"),
-    );
-    expect(descriptor.logContext).toMatchObject({
-      source: "skill_input",
-      skillName: "librarian",
-      agentName: "code-agent",
-    });
-  });
-
-  it("sets decision surface to 'skill' and value to the skill name", () => {
-    const descriptor = describeSkillInputGate(
-      "my-skill",
-      null,
-      makeSkillCheck("allow"),
-    );
-    expect(descriptor.decision).toEqual({
-      surface: "skill",
-      value: "my-skill",
-    });
-  });
-
-  it("does not set preResolved or sessionApproval", () => {
-    const descriptor = describeSkillInputGate(
-      "librarian",
-      null,
-      makeSkillCheck("allow"),
-    );
-    expect(descriptor.preResolved).toBeUndefined();
-    expect(descriptor.sessionApproval).toBeUndefined();
-  });
-});

package/test/handlers/gates/skill-read.test.ts

@@ -1,161 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { describeSkillReadGate } from "#src/handlers/gates/skill-read";
-import type { ToolCallContext } from "#src/handlers/gates/types";
-import { PathNormalizer } from "#src/path-normalizer";
-import type { SkillPromptEntry } from "#src/skill-prompt-sanitizer";
-
-// All test tccs use cwd "/test/project"; one normalizer serves every call.
-const normalizer = new PathNormalizer("linux", "/test/project");
-
-// ── SDK stubs ──────────────────────────────────────────────────────────────
-vi.mock("@earendil-works/pi-coding-agent", async (importOriginal) => {
-  const original =
-    await importOriginal<typeof import("@earendil-works/pi-coding-agent")>();
-  return { ...original };
-});
-
-// ── helpers ────────────────────────────────────────────────────────────────
-
-function makeSkillEntry(
-  overrides: Partial<SkillPromptEntry> = {},
-): SkillPromptEntry {
-  return {
-    name: "librarian",
-    description: "Research skills",
-    location: "/skills/librarian/SKILL.md",
-    state: "ask",
-    normalizedLocation: "/skills/librarian/SKILL.md",
-    normalizedBaseDir: "/skills/librarian",
-    ...overrides,
-  };
-}
-
-function makeTcc(overrides: Partial<ToolCallContext> = {}): ToolCallContext {
-  return {
-    toolName: "read",
-    agentName: null,
-    input: { path: "/skills/librarian/SKILL.md" },
-    toolCallId: "tc-1",
-    cwd: "/test/project",
-    ...overrides,
-  };
-}
-
-// ── tests ──────────────────────────────────────────────────────────────────
-
-describe("describeSkillReadGate", () => {
-  it("returns null when tool is not read", () => {
-    const result = describeSkillReadGate(
-      makeTcc({ toolName: "write" }),
-      normalizer,
-      () => [makeSkillEntry()],
-    );
-    expect(result).toBeNull();
-  });
-
-  it("returns null when no active skill entries", () => {
-    const result = describeSkillReadGate(makeTcc(), normalizer, () => []);
-    expect(result).toBeNull();
-  });
-
-  it("returns null when read path does not match any skill", () => {
-    const result = describeSkillReadGate(
-      makeTcc({ input: { path: "/test/project/src/index.ts" } }),
-      normalizer,
-      () => [makeSkillEntry()],
-    );
-    expect(result).toBeNull();
-  });
-
-  it("returns null when input has no path", () => {
-    const result = describeSkillReadGate(
-      makeTcc({ input: {} }),
-      normalizer,
-      () => [makeSkillEntry()],
-    );
-    expect(result).toBeNull();
-  });
-
-  it("returns GateDescriptor with preResolved.state matching skill entry state (ask)", () => {
-    const result = describeSkillReadGate(makeTcc(), normalizer, () => [
-      makeSkillEntry({ state: "ask" }),
-    ]);
-    expect(result).not.toBeNull();
-    const desc = result!;
-    expect(desc.preResolved).toEqual({ state: "ask" });
-  });
-
-  it("returns GateDescriptor with preResolved.state matching skill entry state (allow)", () => {
-    const result = describeSkillReadGate(makeTcc(), normalizer, () => [
-      makeSkillEntry({ state: "allow" }),
-    ]);
-    expect(result).not.toBeNull();
-    const desc = result!;
-    expect(desc.preResolved).toEqual({ state: "allow" });
-  });
-
-  it("returns GateDescriptor with preResolved.state matching skill entry state (deny)", () => {
-    const result = describeSkillReadGate(makeTcc(), normalizer, () => [
-      makeSkillEntry({ state: "deny" }),
-    ]);
-    expect(result).not.toBeNull();
-    const desc = result!;
-    expect(desc.preResolved).toEqual({ state: "deny" });
-  });
-
-  it("decision surface is 'skill' and decision value is the skill name", () => {
-    const result = describeSkillReadGate(makeTcc(), normalizer, () => [
-      makeSkillEntry({ name: "my-skill" }),
-    ])!;
-    expect(result.decision.surface).toBe("skill");
-    expect(result.decision.value).toBe("my-skill");
-  });
-
-  it("denialContext contains the skill name and read path", () => {
-    const result = describeSkillReadGate(makeTcc(), normalizer, () => [
-      makeSkillEntry({ name: "librarian" }),
-    ])!;
-    expect(result.denialContext).toEqual({
-      kind: "skill_read",
-      skillName: "librarian",
-      readPath: "/skills/librarian/SKILL.md",
-      agentName: undefined,
-    });
-  });
-
-  it("promptDetails includes skill_read source and skillName", () => {
-    const result = describeSkillReadGate(
-      makeTcc({ agentName: "test-agent", toolCallId: "tc-42" }),
-      normalizer,
-      () => [makeSkillEntry({ name: "my-skill" })],
-    )!;
-    expect(result.promptDetails).toMatchObject({
-      source: "skill_read",
-      agentName: "test-agent",
-      toolCallId: "tc-42",
-      toolName: "read",
-      skillName: "my-skill",
-    });
-    expect(result.promptDetails.message).toBeDefined();
-  });
-
-  it("logContext includes skill_read source and skillName", () => {
-    const result = describeSkillReadGate(
-      makeTcc({ agentName: "agent-1" }),
-      normalizer,
-      () => [makeSkillEntry({ name: "librarian" })],
-    )!;
-    expect(result.logContext).toMatchObject({
-      source: "skill_read",
-      skillName: "librarian",
-      agentName: "agent-1",
-    });
-  });
-
-  it("surface is 'skill' on the descriptor", () => {
-    const result = describeSkillReadGate(makeTcc(), normalizer, () => [
-      makeSkillEntry(),
-    ])!;
-    expect(result.surface).toBe("skill");
-  });
-});

package/test/handlers/gates/tool-call-gate-pipeline.test.ts

@@ -1,356 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { AccessPath } from "#src/access-intent/access-path";
-import { ToolCallGatePipeline } from "#src/handlers/gates/tool-call-gate-pipeline";
-import { PathNormalizer } from "#src/path-normalizer";
-
-import {
-  makeGateInputs,
-  makeGateRunner,
-  makeResolver,
-  makeTcc,
-} from "#test/helpers/gate-fixtures";
-import { makeCheckResult } from "#test/helpers/handler-fixtures";
-
-// ── BashProgram.parse mock ─────────────────────────────────────────────────
-
-const { mockBashProgramParse } = vi.hoisted(() => ({
-  mockBashProgramParse: vi.fn(),
-}));
-
-vi.mock("#src/access-intent/bash/program", () => ({
-  BashProgram: { parse: mockBashProgramParse },
-}));
-
-// Mock node:fs so realpathSync (used by canonicalizePath) is controllable for
-// the per-tool symlink-resolution test. Default implementation is identity.
-const realpathSync = vi.hoisted(() =>
-  vi.fn<(path: string) => string>((p) => p),
-);
-vi.mock("node:fs", () => ({
-  realpathSync,
-  default: { realpathSync },
-}));
-
-function makeMockBashProgram() {
-  return {
-    commands: vi.fn<() => []>(() => []),
-    pathRuleCandidates: vi.fn<() => []>(() => []),
-    externalPaths: vi.fn<() => AccessPath[]>(() => []),
-  };
-}
-
-// ── ToolCallGatePipeline ───────────────────────────────────────────────────
-
-describe("ToolCallGatePipeline", () => {
-  beforeEach(() => {
-    mockBashProgramParse.mockReset();
-    mockBashProgramParse.mockResolvedValue(makeMockBashProgram());
-    realpathSync.mockReset();
-    realpathSync.mockImplementation((p: string) => p);
-  });
-
-  // ── non-bash tools ───────────────────────────────────────────────────────
-
-  describe("evaluate — non-bash tool", () => {
-    it("returns allow when all gates pass", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      const result = await pipeline.evaluate(
-        makeTcc({ toolName: "read", input: {} }),
-        runner,
-      );
-
-      expect(result).toEqual({ action: "allow" });
-    });
-
-    it("returns block when the tool gate denies", async () => {
-      const resolver = makeResolver(
-        makeCheckResult({ state: "deny", matchedPattern: "*" }),
-      );
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      const result = await pipeline.evaluate(
-        makeTcc({ toolName: "read", input: {} }),
-        runner,
-      );
-
-      expect(result).toMatchObject({ action: "block" });
-    });
-
-    it("short-circuits after the first blocking gate without evaluating later ones", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const runSpy = vi
-        .spyOn(runner, "run")
-        .mockResolvedValue({ action: "block", reason: "first gate blocked" });
-
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-      const result = await pipeline.evaluate(
-        makeTcc({ toolName: "read", input: {} }),
-        runner,
-      );
-
-      expect(result).toEqual({ action: "block", reason: "first gate blocked" });
-      // Pipeline looped to the first gate, got block, and stopped — not all 6 gates.
-      expect(runSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("calls getToolPreviewLimits() during evaluate", async () => {
-      const getToolPreviewLimits = vi.fn(() => ({
-        toolInputPreviewMaxLength: 500,
-        toolTextSummaryMaxLength: 100,
-        toolInputLogPreviewMaxLength: 200,
-      }));
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs({ getToolPreviewLimits });
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
-
-      expect(getToolPreviewLimits).toHaveBeenCalled();
-    });
-
-    it("calls getInfrastructureReadDirs() during evaluate", async () => {
-      const getInfrastructureReadDirs = vi.fn<() => string[]>(() => []);
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs({ getInfrastructureReadDirs });
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
-
-      expect(getInfrastructureReadDirs).toHaveBeenCalled();
-    });
-
-    it("calls getActiveSkillEntries() during evaluate", async () => {
-      const getActiveSkillEntries = vi.fn<() => []>(() => []);
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs({ getActiveSkillEntries });
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
-
-      expect(getActiveSkillEntries).toHaveBeenCalled();
-    });
-
-    it("does not call BashProgram.parse for non-bash tools", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
-
-      expect(mockBashProgramParse).not.toHaveBeenCalled();
-    });
-  });
-
-  // ── bash tool ────────────────────────────────────────────────────────────
-
-  describe("evaluate — bash tool", () => {
-    it("returns allow when the bash command is permitted", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      const result = await pipeline.evaluate(
-        makeTcc({ toolName: "bash", input: { command: "echo hello" } }),
-        runner,
-      );
-
-      expect(result).toEqual({ action: "allow" });
-    });
-
-    it("parses BashProgram exactly once per evaluate for bash tools with a command", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(
-        makeTcc({ toolName: "bash", input: { command: "echo hello" } }),
-        runner,
-      );
-
-      expect(mockBashProgramParse).toHaveBeenCalledTimes(1);
-      expect(mockBashProgramParse).toHaveBeenCalledWith(
-        "echo hello",
-        expect.any(PathNormalizer),
-        expect.any(Function),
-      );
-    });
-
-    it("does not parse BashProgram when the bash command is empty", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(
-        makeTcc({ toolName: "bash", input: { command: "" } }),
-        runner,
-      );
-
-      expect(mockBashProgramParse).not.toHaveBeenCalled();
-    });
-
-    it("passes the session's promotable path-token matcher into BashProgram.parse (#509)", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const isPromotable = vi.fn((token: string) => token === "id_rsa");
-      const getPromotablePathTokenMatcher = vi.fn(() => isPromotable);
-      const inputs = makeGateInputs({ getPromotablePathTokenMatcher });
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(
-        makeTcc({
-          toolName: "bash",
-          input: { command: "cat id_rsa" },
-          agentName: "my-agent",
-        }),
-        runner,
-      );
-
-      expect(getPromotablePathTokenMatcher).toHaveBeenCalledWith("my-agent");
-      expect(mockBashProgramParse).toHaveBeenCalledWith(
-        "cat id_rsa",
-        expect.any(PathNormalizer),
-        isPromotable,
-      );
-    });
-  });
-
-  // ── customExtractors threading (#352) ────────────────────────────────────
-
-  describe("evaluate — customExtractors threading (#352)", () => {
-    // Deny only the cross-cutting `path` surface; allow everything else, so a
-    // block can only come from the path gate seeing the extracted path.
-    function pathDenyingResolver() {
-      const resolver = makeResolver();
-      resolver.resolve.mockImplementation((intent) =>
-        intent.surface === "path"
-          ? makeCheckResult({ state: "deny", matchedPattern: "*" })
-          : makeCheckResult(),
-      );
-      return resolver;
-    }
-
-    const extractors = {
-      get: (name: string) =>
-        name === "ffgrep"
-          ? (input: Record<string, unknown>) =>
-              typeof input.target === "string" ? input.target : undefined
-          : undefined,
-    };
-
-    it("forwards extractors so a custom-shaped tool is path-gated", async () => {
-      const resolver = pathDenyingResolver();
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(
-        resolver,
-        inputs,
-        undefined,
-        extractors,
-      );
-
-      const result = await pipeline.evaluate(
-        makeTcc({
-          toolName: "ffgrep",
-          input: { target: "/test/project/secret.env" },
-        }),
-        runner,
-      );
-
-      expect(result).toMatchObject({ action: "block" });
-    });
-
-    it("without extractors the custom-shaped tool is not path-gated", async () => {
-      const resolver = pathDenyingResolver();
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      const result = await pipeline.evaluate(
-        makeTcc({
-          toolName: "ffgrep",
-          input: { target: "/test/project/secret.env" },
-        }),
-        runner,
-      );
-
-      expect(result).toEqual({ action: "allow" });
-    });
-  });
-
-  // ── per-tool path-bearing gate (#502) ────────────────────────────────────
-
-  describe("evaluate — per-tool path-bearing gate (#502)", () => {
-    it("emits an access-path intent on the tool-name surface for a path-bearing tool", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(
-        makeTcc({ toolName: "read", input: { path: "/test/cwd/foo.ts" } }),
-        runner,
-      );
-
-      const perTool = resolver.resolve.mock.calls.find(
-        ([intent]) => intent.surface === "read",
-      );
-      expect(perTool?.[0].kind).toBe("access-path");
-    });
-
-    it("keeps a path-bearing tool with no path on the tool intent", async () => {
-      const resolver = makeResolver(makeCheckResult());
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      await pipeline.evaluate(makeTcc({ toolName: "read", input: {} }), runner);
-
-      const perTool = resolver.resolve.mock.calls.find(
-        ([intent]) => intent.surface === "read",
-      );
-      expect(perTool?.[0].kind).toBe("tool");
-    });
-
-    it("blocks when a per-tool rule matches the symlink-resolved form", async () => {
-      // /test/cwd/foo.env is a symlink to /vault/foo.env; the per-tool rule is
-      // keyed on the resolved target, which is only reachable via matchValues().
-      realpathSync.mockImplementation((p: string) =>
-        p === "/test/cwd/foo.env" ? "/vault/foo.env" : p,
-      );
-      const resolver = makeResolver();
-      resolver.resolve.mockImplementation((intent) =>
-        intent.kind === "access-path" &&
-        intent.surface === "read" &&
-        intent.path.matchValues().includes("/vault/foo.env")
-          ? makeCheckResult({ state: "deny", matchedPattern: "*.env" })
-          : makeCheckResult(),
-      );
-      const inputs = makeGateInputs();
-      const { runner } = makeGateRunner();
-      const pipeline = new ToolCallGatePipeline(resolver, inputs);
-
-      const result = await pipeline.evaluate(
-        makeTcc({ toolName: "read", input: { path: "/test/cwd/foo.env" } }),
-        runner,
-      );
-
-      expect(result).toMatchObject({ action: "block" });
-    });
-  });
-});