@gotgenes/pi-permission-system 3.0.0 → 3.0.1

package/tests/tool-registry.test.ts

@@ -0,0 +1,155 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+import {
+  checkRequestedToolRegistration,
+  getToolNameFromValue,
+} from "../src/tool-registry.js";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("getToolNameFromValue", () => {
+  test("returns string value directly", () => {
+    expect(getToolNameFromValue("read")).toBe("read");
+  });
+
+  test("returns null for empty string", () => {
+    expect(getToolNameFromValue("")).toBeNull();
+  });
+
+  test("returns null for whitespace-only string", () => {
+    expect(getToolNameFromValue("   ")).toBeNull();
+  });
+
+  test("returns null for null", () => {
+    expect(getToolNameFromValue(null)).toBeNull();
+  });
+
+  test("returns null for undefined", () => {
+    expect(getToolNameFromValue(undefined)).toBeNull();
+  });
+
+  test("extracts toolName from object", () => {
+    expect(getToolNameFromValue({ toolName: "write" })).toBe("write");
+  });
+
+  test("extracts name from object", () => {
+    expect(getToolNameFromValue({ name: "edit" })).toBe("edit");
+  });
+
+  test("extracts tool from object", () => {
+    expect(getToolNameFromValue({ tool: "bash" })).toBe("bash");
+  });
+
+  test("prefers toolName over name over tool", () => {
+    expect(
+      getToolNameFromValue({
+        toolName: "first",
+        name: "second",
+        tool: "third",
+      }),
+    ).toBe("first");
+  });
+
+  test("falls back to name when toolName is empty", () => {
+    expect(getToolNameFromValue({ toolName: "", name: "edit" })).toBe("edit");
+  });
+
+  test("returns null for object with no recognised keys", () => {
+    expect(getToolNameFromValue({ unknown: "read" })).toBeNull();
+  });
+
+  test("returns null for number input", () => {
+    expect(getToolNameFromValue(42)).toBeNull();
+  });
+});
+
+describe("checkRequestedToolRegistration", () => {
+  test("returns missing-tool-name for null requested name", () => {
+    const result = checkRequestedToolRegistration(null, []);
+    expect(result.status).toBe("missing-tool-name");
+  });
+
+  test("returns missing-tool-name for whitespace-only requested name", () => {
+    const result = checkRequestedToolRegistration("   ", []);
+    expect(result.status).toBe("missing-tool-name");
+  });
+
+  test("returns registered when tool name matches a string entry", () => {
+    const result = checkRequestedToolRegistration("read", ["read", "write"]);
+    expect(result.status).toBe("registered");
+    if (result.status === "registered") {
+      expect(result.requestedToolName).toBe("read");
+      expect(result.normalizedToolName).toBe("read");
+    }
+  });
+
+  test("returns registered when tool name matches an object entry by name", () => {
+    const result = checkRequestedToolRegistration("edit", [{ name: "edit" }]);
+    expect(result.status).toBe("registered");
+  });
+
+  test("returns registered when tool name matches an object entry by toolName", () => {
+    const result = checkRequestedToolRegistration("bash", [
+      { toolName: "bash" },
+    ]);
+    expect(result.status).toBe("registered");
+  });
+
+  test("returns unregistered when tool is not in the list", () => {
+    const result = checkRequestedToolRegistration("ghost", ["read", "write"]);
+    expect(result.status).toBe("unregistered");
+    if (result.status === "unregistered") {
+      expect(result.requestedToolName).toBe("ghost");
+      expect(result.availableToolNames).toContain("read");
+      expect(result.availableToolNames).toContain("write");
+    }
+  });
+
+  test("available tool names are sorted alphabetically", () => {
+    const result = checkRequestedToolRegistration("ghost", [
+      "write",
+      "read",
+      "edit",
+    ]);
+    if (result.status === "unregistered") {
+      expect(result.availableToolNames).toEqual(["edit", "read", "write"]);
+    }
+  });
+
+  test("resolves alias: requested alias maps to registered canonical name", () => {
+    const aliases = { Execute: "bash" };
+    const result = checkRequestedToolRegistration("Execute", ["bash"], aliases);
+    expect(result.status).toBe("registered");
+    if (result.status === "registered") {
+      expect(result.normalizedToolName).toBe("bash");
+    }
+  });
+
+  test("resolves alias: registered canonical is found via reverse alias lookup", () => {
+    // "bash" is registered; alias maps "Execute" → "bash"
+    // requesting "bash" directly should still resolve via the alias table
+    const aliases = { Execute: "bash" };
+    const result = checkRequestedToolRegistration("bash", ["bash"], aliases);
+    expect(result.status).toBe("registered");
+  });
+
+  test("returns unregistered with empty availableToolNames for empty tool list", () => {
+    const result = checkRequestedToolRegistration("read", []);
+    expect(result.status).toBe("unregistered");
+    if (result.status === "unregistered") {
+      expect(result.availableToolNames).toEqual([]);
+    }
+  });
+
+  test("skips tool list entries that yield no name", () => {
+    const result = checkRequestedToolRegistration("read", [
+      null,
+      {},
+      { unrelated: "x" },
+      "read",
+    ]);
+    expect(result.status).toBe("registered");
+  });
+});

package/tests/wildcard-matcher.test.ts

@@ -0,0 +1,180 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+import {
+  compileWildcardPattern,
+  compileWildcardPatternEntries,
+  findCompiledWildcardMatch,
+  findCompiledWildcardMatchForNames,
+} from "../src/wildcard-matcher.js";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("compileWildcardPatternEntries", () => {
+  test("returns empty array for empty iterable", () => {
+    const result = compileWildcardPatternEntries([]);
+    expect(result).toEqual([]);
+  });
+
+  test("compiles a single exact pattern", () => {
+    const result = compileWildcardPatternEntries([["read", "allow"]]);
+    expect(result).toHaveLength(1);
+    expect(result[0].pattern).toBe("read");
+    expect(result[0].state).toBe("allow");
+  });
+
+  test("compiles multiple patterns in order", () => {
+    const entries: [string, string][] = [
+      ["read", "allow"],
+      ["write", "deny"],
+      ["bash *", "ask"],
+    ];
+    const result = compileWildcardPatternEntries(entries);
+    expect(result).toHaveLength(3);
+    expect(result.map((r) => r.pattern)).toEqual(["read", "write", "bash *"]);
+  });
+});
+
+describe("findCompiledWildcardMatch", () => {
+  test("returns null for empty patterns array", () => {
+    const result = findCompiledWildcardMatch([], "read");
+    expect(result).toBeNull();
+  });
+
+  test("matches exact pattern", () => {
+    const patterns = compileWildcardPatternEntries([["read", "allow"]]);
+    const result = findCompiledWildcardMatch(patterns, "read");
+    expect(result).not.toBeNull();
+    expect(result?.state).toBe("allow");
+    expect(result?.matchedPattern).toBe("read");
+    expect(result?.matchedName).toBe("read");
+  });
+
+  test("returns null when no pattern matches", () => {
+    const patterns = compileWildcardPatternEntries([["read", "allow"]]);
+    const result = findCompiledWildcardMatch(patterns, "write");
+    expect(result).toBeNull();
+  });
+
+  test("matches glob * pattern", () => {
+    const patterns = compileWildcardPatternEntries([["git *", "allow"]]);
+    const result = findCompiledWildcardMatch(patterns, "git status");
+    expect(result).not.toBeNull();
+    expect(result?.state).toBe("allow");
+    expect(result?.matchedPattern).toBe("git *");
+  });
+
+  test("glob * matches zero or more characters", () => {
+    const patterns = compileWildcardPatternEntries([["git*", "allow"]]);
+    expect(findCompiledWildcardMatch(patterns, "git")).not.toBeNull();
+    expect(findCompiledWildcardMatch(patterns, "git status")).not.toBeNull();
+    expect(findCompiledWildcardMatch(patterns, "npm install")).toBeNull();
+  });
+
+  test("last-match-wins precedence: later pattern overrides earlier", () => {
+    const patterns = compileWildcardPatternEntries([
+      ["git *", "allow"],
+      ["git push *", "deny"],
+    ]);
+    const result = findCompiledWildcardMatch(patterns, "git push origin main");
+    expect(result).not.toBeNull();
+    expect(result?.state).toBe("deny");
+    expect(result?.matchedPattern).toBe("git push *");
+  });
+
+  test("last-match-wins: specific deny before broad allow matches the later one", () => {
+    const patterns = compileWildcardPatternEntries([
+      ["*", "deny"],
+      ["git status", "allow"],
+    ]);
+    const result = findCompiledWildcardMatch(patterns, "git status");
+    expect(result).not.toBeNull();
+    expect(result?.state).toBe("allow");
+  });
+
+  test("exact pattern does not match partial name", () => {
+    const patterns = compileWildcardPatternEntries([["read", "allow"]]);
+    expect(findCompiledWildcardMatch(patterns, "read ")).toBeNull();
+    expect(findCompiledWildcardMatch(patterns, "readonly")).toBeNull();
+  });
+
+  test("regex special characters in pattern are escaped", () => {
+    const patterns = compileWildcardPatternEntries([
+      ["tool.name", "allow"],
+      ["tool+extra", "deny"],
+    ]);
+    // "tool.name" should not match "toolXname" (dot is escaped)
+    expect(findCompiledWildcardMatch(patterns, "toolXname")).toBeNull();
+    // Exact match works
+    expect(findCompiledWildcardMatch(patterns, "tool.name")).not.toBeNull();
+    expect(findCompiledWildcardMatch(patterns, "tool+extra")).not.toBeNull();
+  });
+});
+
+describe("findCompiledWildcardMatchForNames", () => {
+  test("returns null for empty names array", () => {
+    const patterns = compileWildcardPatternEntries([["read", "allow"]]);
+    const result = findCompiledWildcardMatchForNames(patterns, []);
+    expect(result).toBeNull();
+  });
+
+  test("returns null when all names are whitespace", () => {
+    const patterns = compileWildcardPatternEntries([["  ", "allow"]]);
+    const result = findCompiledWildcardMatchForNames(patterns, ["  ", "\t"]);
+    expect(result).toBeNull();
+  });
+
+  test("matches first name that has a pattern match", () => {
+    const patterns = compileWildcardPatternEntries([
+      ["read", "allow"],
+      ["write", "deny"],
+    ]);
+    const result = findCompiledWildcardMatchForNames(patterns, [
+      "grep",
+      "write",
+    ]);
+    expect(result).not.toBeNull();
+    expect(result?.matchedName).toBe("write");
+    expect(result?.state).toBe("deny");
+  });
+
+  test("trims whitespace from names before matching", () => {
+    const patterns = compileWildcardPatternEntries([["read", "allow"]]);
+    const result = findCompiledWildcardMatchForNames(patterns, ["  read  "]);
+    expect(result).not.toBeNull();
+    expect(result?.state).toBe("allow");
+  });
+
+  test("returns null when no name matches any pattern", () => {
+    const patterns = compileWildcardPatternEntries([["read", "allow"]]);
+    const result = findCompiledWildcardMatchForNames(patterns, [
+      "write",
+      "grep",
+    ]);
+    expect(result).toBeNull();
+  });
+
+  test("multi-name lookup: returns match for first matching name in order", () => {
+    const patterns = compileWildcardPatternEntries([
+      ["read", "allow"],
+      ["write", "deny"],
+    ]);
+    // "read" comes before "write" in names array, so "read" should match first
+    const result = findCompiledWildcardMatchForNames(patterns, [
+      "read",
+      "write",
+    ]);
+    expect(result).not.toBeNull();
+    expect(result?.matchedName).toBe("read");
+    expect(result?.state).toBe("allow");
+  });
+
+  test("compileWildcardPattern produces correct pattern metadata", () => {
+    const compiled = compileWildcardPattern("bash *", "ask");
+    expect(compiled.pattern).toBe("bash *");
+    expect(compiled.state).toBe("ask");
+    expect(compiled.regex.test("bash ls -la")).toBe(true);
+    expect(compiled.regex.test("echo hello")).toBe(false);
+  });
+});

package/tests/yolo-mode.test.ts

@@ -0,0 +1,110 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import type { PermissionSystemExtensionConfig } from "../src/extension-config.js";
+import {
+  canResolveAskPermissionRequest,
+  shouldAutoApprovePermissionState,
+} from "../src/yolo-mode.js";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+function makeConfig(
+  yoloMode: boolean | undefined,
+): PermissionSystemExtensionConfig {
+  return { yoloMode } as PermissionSystemExtensionConfig;
+}
+
+describe("shouldAutoApprovePermissionState", () => {
+  test("returns true for 'ask' when yolo mode is on", () => {
+    expect(shouldAutoApprovePermissionState("ask", makeConfig(true))).toBe(
+      true,
+    );
+  });
+
+  test("returns false for 'ask' when yolo mode is off", () => {
+    expect(shouldAutoApprovePermissionState("ask", makeConfig(false))).toBe(
+      false,
+    );
+  });
+
+  test("returns false for 'ask' when yolo mode is undefined", () => {
+    expect(shouldAutoApprovePermissionState("ask", makeConfig(undefined))).toBe(
+      false,
+    );
+  });
+
+  test("returns false for 'allow' even when yolo mode is on", () => {
+    expect(shouldAutoApprovePermissionState("allow", makeConfig(true))).toBe(
+      false,
+    );
+  });
+
+  test("returns false for 'deny' even when yolo mode is on", () => {
+    expect(shouldAutoApprovePermissionState("deny", makeConfig(true))).toBe(
+      false,
+    );
+  });
+});
+
+describe("canResolveAskPermissionRequest", () => {
+  test("returns true when hasUI is true regardless of other flags", () => {
+    expect(
+      canResolveAskPermissionRequest({
+        config: makeConfig(false),
+        hasUI: true,
+        isSubagent: false,
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true when isSubagent is true regardless of other flags", () => {
+    expect(
+      canResolveAskPermissionRequest({
+        config: makeConfig(false),
+        hasUI: false,
+        isSubagent: true,
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true when yolo mode is on regardless of UI/subagent flags", () => {
+    expect(
+      canResolveAskPermissionRequest({
+        config: makeConfig(true),
+        hasUI: false,
+        isSubagent: false,
+      }),
+    ).toBe(true);
+  });
+
+  test("returns false when no UI, not a subagent, and yolo mode is off", () => {
+    expect(
+      canResolveAskPermissionRequest({
+        config: makeConfig(false),
+        hasUI: false,
+        isSubagent: false,
+      }),
+    ).toBe(false);
+  });
+
+  test("returns false when no UI, not a subagent, and yolo mode is undefined", () => {
+    expect(
+      canResolveAskPermissionRequest({
+        config: makeConfig(undefined),
+        hasUI: false,
+        isSubagent: false,
+      }),
+    ).toBe(false);
+  });
+
+  test("returns true when all three conditions are true", () => {
+    expect(
+      canResolveAskPermissionRequest({
+        config: makeConfig(true),
+        hasUI: true,
+        isSubagent: true,
+      }),
+    ).toBe(true);
+  });
+});