@gotgenes/pi-permission-system 3.5.0 → 3.7.0

package/tests/handlers/input.test.ts

@@ -0,0 +1,271 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  extractSkillNameFromInput,
+  handleInput,
+} from "../../src/handlers/input";
+import type { HandlerDeps } from "../../src/handlers/types";
+import type { SkillPromptEntry } from "../../src/skill-prompt-sanitizer";
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+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;
+}
+
+function makeInputEvent(text: string) {
+  return { text };
+}
+
+function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
+  return {
+    getPermissionManager: vi.fn().mockReturnValue({
+      checkPermission: vi.fn().mockReturnValue({ state: "allow" }),
+      getConfigIssues: vi.fn().mockReturnValue([]),
+    }),
+    setPermissionManager: vi.fn(),
+    getRuntimeContext: vi.fn().mockReturnValue(null),
+    setRuntimeContext: vi.fn(),
+    getActiveSkillEntries: vi.fn().mockReturnValue([] as SkillPromptEntry[]),
+    setActiveSkillEntries: vi.fn(),
+    getLastKnownActiveAgentName: vi.fn().mockReturnValue(null),
+    setLastKnownActiveAgentName: vi.fn(),
+    getLastActiveToolsCacheKey: vi.fn().mockReturnValue(null),
+    setLastActiveToolsCacheKey: vi.fn(),
+    getLastPromptStateCacheKey: vi.fn().mockReturnValue(null),
+    setLastPromptStateCacheKey: vi.fn(),
+    sessionApprovalCache: {
+      approve: vi.fn(),
+      has: vi.fn(),
+      findMatchingPrefix: vi.fn(),
+      clear: vi.fn(),
+    } as unknown as HandlerDeps["sessionApprovalCache"],
+    createPermissionManagerForCwd: vi.fn(),
+    refreshExtensionConfig: vi.fn(),
+    notifyWarning: vi.fn(),
+    logResolvedConfigPaths: vi.fn(),
+    resolveAgentName: vi.fn().mockReturnValue(null),
+    canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
+    promptPermission: vi
+      .fn()
+      .mockResolvedValue({ approved: true, state: "approved" }),
+    createPermissionRequestId: vi.fn().mockReturnValue("req-id"),
+    startForwardedPermissionPolling: vi.fn(),
+    stopForwardedPermissionPolling: vi.fn(),
+    writeReviewLog: vi.fn(),
+    writeDebugLog: vi.fn(),
+    getAllTools: vi.fn().mockReturnValue([]),
+    setActiveTools: vi.fn(),
+    ...overrides,
+  };
+}
+
+// ── extractSkillNameFromInput ──────────────────────────────────────────────
+
+describe("extractSkillNameFromInput", () => {
+  it("returns null for plain text", () => {
+    expect(extractSkillNameFromInput("hello world")).toBeNull();
+  });
+
+  it("returns null for empty string", () => {
+    expect(extractSkillNameFromInput("")).toBeNull();
+  });
+
+  it("returns null for bare /skill: with no name", () => {
+    expect(extractSkillNameFromInput("/skill:")).toBeNull();
+  });
+
+  it("extracts skill name from /skill:<name>", () => {
+    expect(extractSkillNameFromInput("/skill:librarian")).toBe("librarian");
+  });
+
+  it("extracts skill name stopping at whitespace", () => {
+    expect(extractSkillNameFromInput("/skill:librarian some extra")).toBe(
+      "librarian",
+    );
+  });
+
+  it("trims leading whitespace before the prefix", () => {
+    expect(extractSkillNameFromInput("  /skill:my-skill")).toBe("my-skill");
+  });
+
+  it("returns null when the skill name after trimming is empty", () => {
+    expect(extractSkillNameFromInput("/skill: ")).toBeNull();
+  });
+});
+
+// ── handleInput ───────────────────────────────────────────────────────────
+
+describe("handleInput", () => {
+  it("sets runtime context", async () => {
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleInput(deps, makeInputEvent("hello"), ctx);
+    expect(deps.setRuntimeContext).toHaveBeenCalledWith(ctx);
+  });
+
+  it("starts forwarded permission polling", async () => {
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleInput(deps, makeInputEvent("hello"), ctx);
+    expect(deps.startForwardedPermissionPolling).toHaveBeenCalledWith(ctx);
+  });
+
+  it("returns continue for non-skill input", async () => {
+    const deps = makeDeps();
+    const result = await handleInput(
+      deps,
+      makeInputEvent("just a message"),
+      makeCtx(),
+    );
+    expect(result).toEqual({ action: "continue" });
+  });
+
+  it("does not check permissions for non-skill input", async () => {
+    const deps = makeDeps();
+    await handleInput(deps, makeInputEvent("just a message"), makeCtx());
+    expect(deps.getPermissionManager().checkPermission).not.toHaveBeenCalled();
+  });
+
+  it("returns continue when skill is allowed", async () => {
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue({
+        checkPermission: vi.fn().mockReturnValue({ state: "allow" }),
+      }),
+    });
+    const result = await handleInput(
+      deps,
+      makeInputEvent("/skill:librarian"),
+      makeCtx(),
+    );
+    expect(result).toEqual({ action: "continue" });
+  });
+
+  it("returns handled when skill is denied", async () => {
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue({
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      }),
+    });
+    const result = await handleInput(
+      deps,
+      makeInputEvent("/skill:librarian"),
+      makeCtx(),
+    );
+    expect(result).toEqual({ action: "handled" });
+  });
+
+  it("shows a warning notification when skill is denied and UI is available", async () => {
+    const ctx = makeCtx({ hasUI: true });
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue({
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      }),
+    });
+    await handleInput(deps, makeInputEvent("/skill:librarian"), ctx);
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      expect.stringContaining("librarian"),
+      "warning",
+    );
+  });
+
+  it("does not show a warning notification when skill is denied and UI is absent", async () => {
+    const ctx = makeCtx({ hasUI: false });
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue({
+        checkPermission: vi.fn().mockReturnValue({ state: "deny" }),
+      }),
+    });
+    await handleInput(deps, makeInputEvent("/skill:librarian"), ctx);
+    expect(ctx.ui.notify).not.toHaveBeenCalled();
+  });
+
+  it("returns handled when skill requires approval but no UI is available", async () => {
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue({
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+      }),
+      canRequestPermissionConfirmation: vi.fn().mockReturnValue(false),
+    });
+    const result = await handleInput(
+      deps,
+      makeInputEvent("/skill:librarian"),
+      makeCtx(),
+    );
+    expect(result).toEqual({ action: "handled" });
+  });
+
+  it("prompts and returns continue when skill ask is approved", async () => {
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue({
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+      }),
+      canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
+      promptPermission: vi
+        .fn()
+        .mockResolvedValue({ approved: true, state: "approved" }),
+    });
+    const result = await handleInput(
+      deps,
+      makeInputEvent("/skill:librarian"),
+      makeCtx(),
+    );
+    expect(result).toEqual({ action: "continue" });
+    expect(deps.promptPermission).toHaveBeenCalledOnce();
+  });
+
+  it("returns handled when skill ask is denied by user", async () => {
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue({
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+      }),
+      canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
+      promptPermission: vi
+        .fn()
+        .mockResolvedValue({ approved: false, state: "denied" }),
+    });
+    const result = await handleInput(
+      deps,
+      makeInputEvent("/skill:librarian"),
+      makeCtx(),
+    );
+    expect(result).toEqual({ action: "handled" });
+  });
+
+  it("passes agentName in the prompt permission request", async () => {
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue({
+        checkPermission: vi.fn().mockReturnValue({ state: "ask" }),
+      }),
+      resolveAgentName: vi.fn().mockReturnValue("code-agent"),
+      canRequestPermissionConfirmation: vi.fn().mockReturnValue(true),
+      promptPermission: vi
+        .fn()
+        .mockResolvedValue({ approved: true, state: "approved" }),
+    });
+    await handleInput(deps, makeInputEvent("/skill:librarian"), makeCtx());
+    expect(deps.promptPermission).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        agentName: "code-agent",
+        skillName: "librarian",
+      }),
+    );
+  });
+});

package/tests/handlers/lifecycle.test.ts

@@ -0,0 +1,331 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  handleResourcesDiscover,
+  handleSessionShutdown,
+  handleSessionStart,
+} from "../../src/handlers/lifecycle";
+import type { HandlerDeps } from "../../src/handlers/types";
+import type { PermissionManager } from "../../src/permission-manager";
+import type { SessionApprovalCache } from "../../src/session-approval-cache";
+import type { SkillPromptEntry } from "../../src/skill-prompt-sanitizer";
+
+// ── active-agent stub ──────────────────────────────────────────────────────
+const { mockGetActiveAgentName } = vi.hoisted(() => ({
+  mockGetActiveAgentName: vi.fn<(ctx: ExtensionContext) => string | null>(),
+}));
+
+vi.mock("../../src/active-agent", () => ({
+  getActiveAgentName: mockGetActiveAgentName,
+  getActiveAgentNameFromSystemPrompt: vi.fn().mockReturnValue(null),
+}));
+
+// ── PERMISSION_SYSTEM_STATUS_KEY stub ──────────────────────────────────────
+// status.ts is re-exported through the handler; the key value doesn't matter
+// for these tests.
+vi.mock("../../src/status", () => ({
+  PERMISSION_SYSTEM_STATUS_KEY: "permission-system",
+  syncPermissionSystemStatus: vi.fn(),
+  getPermissionSystemStatus: vi.fn(),
+}));
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+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;
+}
+
+function makePermissionManager(
+  issues: string[] = [],
+): Pick<PermissionManager, "getConfigIssues"> {
+  return {
+    getConfigIssues: vi.fn().mockReturnValue(issues),
+  };
+}
+
+function makeSessionApprovalCache(): SessionApprovalCache {
+  return {
+    approve: vi.fn(),
+    has: vi.fn().mockReturnValue(false),
+    findMatchingPrefix: vi.fn().mockReturnValue(null),
+    clear: vi.fn(),
+  } as unknown as SessionApprovalCache;
+}
+
+function makeDeps(overrides: Partial<HandlerDeps> = {}): HandlerDeps {
+  const pm = makePermissionManager();
+  return {
+    getPermissionManager: vi.fn().mockReturnValue(pm),
+    setPermissionManager: vi.fn(),
+    getRuntimeContext: vi.fn().mockReturnValue(null),
+    setRuntimeContext: vi.fn(),
+    getActiveSkillEntries: vi.fn().mockReturnValue([] as SkillPromptEntry[]),
+    setActiveSkillEntries: vi.fn(),
+    getLastKnownActiveAgentName: vi.fn().mockReturnValue(null),
+    setLastKnownActiveAgentName: vi.fn(),
+    getLastActiveToolsCacheKey: vi.fn().mockReturnValue(null),
+    setLastActiveToolsCacheKey: vi.fn(),
+    getLastPromptStateCacheKey: vi.fn().mockReturnValue(null),
+    setLastPromptStateCacheKey: vi.fn(),
+    sessionApprovalCache: makeSessionApprovalCache(),
+    createPermissionManagerForCwd: vi
+      .fn()
+      .mockReturnValue(makePermissionManager()),
+    refreshExtensionConfig: vi.fn(),
+    notifyWarning: vi.fn(),
+    logResolvedConfigPaths: vi.fn(),
+    resolveAgentName: vi.fn().mockReturnValue(null),
+    canRequestPermissionConfirmation: vi.fn().mockReturnValue(false),
+    promptPermission: vi
+      .fn()
+      .mockResolvedValue({ approved: true, state: "approved" }),
+    createPermissionRequestId: vi.fn().mockReturnValue("test-id"),
+    startForwardedPermissionPolling: vi.fn(),
+    stopForwardedPermissionPolling: vi.fn(),
+    writeReviewLog: vi.fn(),
+    writeDebugLog: vi.fn(),
+    getAllTools: vi.fn().mockReturnValue([]),
+    setActiveTools: vi.fn(),
+    ...overrides,
+  };
+}
+
+// ── handleSessionStart ─────────────────────────────────────────────────────
+
+describe("handleSessionStart", () => {
+  beforeEach(() => {
+    mockGetActiveAgentName.mockReset();
+    mockGetActiveAgentName.mockReturnValue(null);
+  });
+
+  it("sets the runtime context", async () => {
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, ctx);
+    expect(deps.setRuntimeContext).toHaveBeenCalledWith(ctx);
+  });
+
+  it("refreshes extension config with ctx", async () => {
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, ctx);
+    expect(deps.refreshExtensionConfig).toHaveBeenCalledWith(ctx);
+  });
+
+  it("creates a new permission manager for ctx.cwd and stores it", async () => {
+    const ctx = makeCtx({ cwd: "/my/project" });
+    const newPm = makePermissionManager();
+    const deps = makeDeps({
+      createPermissionManagerForCwd: vi.fn().mockReturnValue(newPm),
+    });
+    await handleSessionStart(deps, { reason: "startup" }, ctx);
+    expect(deps.createPermissionManagerForCwd).toHaveBeenCalledWith(
+      "/my/project",
+    );
+    expect(deps.setPermissionManager).toHaveBeenCalledWith(newPm);
+  });
+
+  it("clears the before_agent_start cache", async () => {
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, ctx);
+    expect(deps.setActiveSkillEntries).toHaveBeenCalledWith([]);
+    expect(deps.setLastActiveToolsCacheKey).toHaveBeenCalledWith(null);
+    expect(deps.setLastPromptStateCacheKey).toHaveBeenCalledWith(null);
+  });
+
+  it("sets lastKnownActiveAgentName from getActiveAgentName", async () => {
+    mockGetActiveAgentName.mockReturnValue("my-agent");
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, ctx);
+    expect(deps.setLastKnownActiveAgentName).toHaveBeenCalledWith("my-agent");
+  });
+
+  it("sets lastKnownActiveAgentName to null when no agent is active", async () => {
+    mockGetActiveAgentName.mockReturnValue(null);
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, ctx);
+    expect(deps.setLastKnownActiveAgentName).toHaveBeenCalledWith(null);
+  });
+
+  it("starts forwarded permission polling", async () => {
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, ctx);
+    expect(deps.startForwardedPermissionPolling).toHaveBeenCalledWith(ctx);
+  });
+
+  it("logs resolved config paths", async () => {
+    const ctx = makeCtx();
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, ctx);
+    expect(deps.logResolvedConfigPaths).toHaveBeenCalledOnce();
+  });
+
+  it("notifies each policy issue", async () => {
+    const pm = makePermissionManager(["issue A", "issue B"]);
+    const deps = makeDeps({
+      getPermissionManager: vi.fn().mockReturnValue(pm),
+    });
+    await handleSessionStart(deps, { reason: "startup" }, makeCtx());
+    expect(deps.notifyWarning).toHaveBeenCalledWith("issue A");
+    expect(deps.notifyWarning).toHaveBeenCalledWith("issue B");
+  });
+
+  it("does not call notifyWarning when there are no policy issues", async () => {
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, makeCtx());
+    expect(deps.notifyWarning).not.toHaveBeenCalled();
+  });
+
+  it("writes lifecycle.reload debug log when reason is reload", async () => {
+    const ctx = makeCtx({ cwd: "/proj" });
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "reload" }, ctx);
+    expect(deps.writeDebugLog).toHaveBeenCalledWith("lifecycle.reload", {
+      triggeredBy: "session_start",
+      reason: "reload",
+      cwd: "/proj",
+    });
+  });
+
+  it("does not write lifecycle.reload debug log for non-reload reasons", async () => {
+    const deps = makeDeps();
+    await handleSessionStart(deps, { reason: "startup" }, makeCtx());
+    expect(deps.writeDebugLog).not.toHaveBeenCalled();
+  });
+});
+
+// ── handleResourcesDiscover ────────────────────────────────────────────────
+
+describe("handleResourcesDiscover", () => {
+  it("does nothing when reason is not reload", async () => {
+    const deps = makeDeps();
+    await handleResourcesDiscover(deps, { reason: "startup" });
+    expect(deps.setPermissionManager).not.toHaveBeenCalled();
+    expect(deps.writeDebugLog).not.toHaveBeenCalled();
+  });
+
+  it("creates and stores a new PM using runtimeContext.cwd on reload", async () => {
+    const ctx = makeCtx({ cwd: "/runtime/cwd" });
+    const newPm = makePermissionManager();
+    const deps = makeDeps({
+      getRuntimeContext: vi.fn().mockReturnValue(ctx),
+      createPermissionManagerForCwd: vi.fn().mockReturnValue(newPm),
+    });
+    await handleResourcesDiscover(deps, { reason: "reload" });
+    expect(deps.createPermissionManagerForCwd).toHaveBeenCalledWith(
+      "/runtime/cwd",
+    );
+    expect(deps.setPermissionManager).toHaveBeenCalledWith(newPm);
+  });
+
+  it("uses undefined cwd when runtimeContext is null on reload", async () => {
+    const deps = makeDeps({
+      getRuntimeContext: vi.fn().mockReturnValue(null),
+    });
+    await handleResourcesDiscover(deps, { reason: "reload" });
+    expect(deps.createPermissionManagerForCwd).toHaveBeenCalledWith(undefined);
+  });
+
+  it("clears the before_agent_start cache on reload", async () => {
+    const deps = makeDeps({ getRuntimeContext: vi.fn().mockReturnValue(null) });
+    await handleResourcesDiscover(deps, { reason: "reload" });
+    expect(deps.setActiveSkillEntries).toHaveBeenCalledWith([]);
+    expect(deps.setLastActiveToolsCacheKey).toHaveBeenCalledWith(null);
+    expect(deps.setLastPromptStateCacheKey).toHaveBeenCalledWith(null);
+  });
+
+  it("writes lifecycle.reload debug log on reload", async () => {
+    const ctx = makeCtx({ cwd: "/proj" });
+    const deps = makeDeps({ getRuntimeContext: vi.fn().mockReturnValue(ctx) });
+    await handleResourcesDiscover(deps, { reason: "reload" });
+    expect(deps.writeDebugLog).toHaveBeenCalledWith("lifecycle.reload", {
+      triggeredBy: "resources_discover",
+      reason: "reload",
+      cwd: "/proj",
+    });
+  });
+
+  it("logs cwd as null when runtimeContext is null on reload", async () => {
+    const deps = makeDeps({
+      getRuntimeContext: vi.fn().mockReturnValue(null),
+    });
+    await handleResourcesDiscover(deps, { reason: "reload" });
+    expect(deps.writeDebugLog).toHaveBeenCalledWith("lifecycle.reload", {
+      triggeredBy: "resources_discover",
+      reason: "reload",
+      cwd: null,
+    });
+  });
+});
+
+// ── handleSessionShutdown ──────────────────────────────────────────────────
+
+describe("handleSessionShutdown", () => {
+  it("clears the UI status when a runtime context is present", async () => {
+    const ctx = makeCtx();
+    const deps = makeDeps({
+      getRuntimeContext: vi.fn().mockReturnValue(ctx),
+    });
+    await handleSessionShutdown(deps);
+    expect(ctx.ui.setStatus).toHaveBeenCalledWith(
+      "permission-system",
+      undefined,
+    );
+  });
+
+  it("does not throw when runtime context is null", async () => {
+    const deps = makeDeps({ getRuntimeContext: vi.fn().mockReturnValue(null) });
+    await expect(handleSessionShutdown(deps)).resolves.not.toThrow();
+  });
+
+  it("sets runtime context to null", async () => {
+    const deps = makeDeps();
+    await handleSessionShutdown(deps);
+    expect(deps.setRuntimeContext).toHaveBeenCalledWith(null);
+  });
+
+  it("clears the before_agent_start cache", async () => {
+    const deps = makeDeps();
+    await handleSessionShutdown(deps);
+    expect(deps.setActiveSkillEntries).toHaveBeenCalledWith([]);
+    expect(deps.setLastActiveToolsCacheKey).toHaveBeenCalledWith(null);
+    expect(deps.setLastPromptStateCacheKey).toHaveBeenCalledWith(null);
+  });
+
+  it("clears the session approval cache", async () => {
+    const deps = makeDeps();
+    await handleSessionShutdown(deps);
+    expect(deps.sessionApprovalCache.clear).toHaveBeenCalledOnce();
+  });
+
+  it("stops forwarded permission polling", async () => {
+    const deps = makeDeps();
+    await handleSessionShutdown(deps);
+    expect(deps.stopForwardedPermissionPolling).toHaveBeenCalledOnce();
+  });
+
+  it("does not reset lastKnownActiveAgentName", async () => {
+    const deps = makeDeps();
+    await handleSessionShutdown(deps);
+    expect(deps.setLastKnownActiveAgentName).not.toHaveBeenCalled();
+  });
+});