@gotgenes/pi-permission-system 10.5.1 → 10.5.2

package/test/input-normalizer.test.ts

@@ -1,7 +1,20 @@
-import { describe, expect, it } from "vitest";
+import { join } from "node:path";
+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 },
+}));
+
 import { normalizeInput } from "#src/input-normalizer";
 import { createMcpPermissionTargets } from "#src/mcp-targets";
 
+afterEach(() => {
+  mockHomedir.mockClear();
+});
+
 describe("normalizeInput — non-MCP surfaces", () => {
   describe("special / path", () => {
     it("uses path from input as the lookup value", () => {
@@ -21,10 +34,40 @@ describe("normalizeInput — non-MCP surfaces", () => {
       expect(result.values).toEqual(["*"]);
     });
 
+    it("falls back to '*' when path is an empty string", () => {
+      const result = normalizeInput("path", { path: "" }, []);
+      expect(result.values).toEqual(["*"]);
+    });
+
+    it("falls back to '*' when path is whitespace-only", () => {
+      const result = normalizeInput("path", { path: "   " }, []);
+      expect(result.values).toEqual(["*"]);
+    });
+
     it("handles null input", () => {
       const result = normalizeInput("path", null, []);
       expect(result.values).toEqual(["*"]);
     });
+
+    it("expands ~/... path value to absolute home path", () => {
+      const result = normalizeInput("path", { path: "~/.ssh/config" }, []);
+      expect(result.values).toEqual([join("/mock/home", ".ssh/config")]);
+    });
+
+    it("expands $HOME/... path value to absolute home path", () => {
+      const result = normalizeInput("path", { path: "$HOME/.ssh/config" }, []);
+      expect(result.values).toEqual([join("/mock/home", ".ssh/config")]);
+    });
+
+    it("does not expand non-home values", () => {
+      const result = normalizeInput("path", { path: ".env" }, []);
+      expect(result.values).toEqual([".env"]);
+    });
+
+    it("does not expand the '*' fallback", () => {
+      const result = normalizeInput("path", {}, []);
+      expect(result.values).toEqual(["*"]);
+    });
   });
 
   describe("special / external_directory", () => {
@@ -49,10 +92,33 @@ describe("normalizeInput — non-MCP surfaces", () => {
       expect(result.values).toEqual(["*"]);
     });
 
+    it("falls back to '*' when path is an empty string", () => {
+      const result = normalizeInput("external_directory", { path: "" }, []);
+      expect(result.values).toEqual(["*"]);
+    });
+
     it("handles null input", () => {
       const result = normalizeInput("external_directory", null, []);
       expect(result.values).toEqual(["*"]);
     });
+
+    it("expands ~/... path value to absolute home path", () => {
+      const result = normalizeInput(
+        "external_directory",
+        { path: "~/dev/project" },
+        [],
+      );
+      expect(result.values).toEqual([join("/mock/home", "dev/project")]);
+    });
+
+    it("expands $HOME/... path value to absolute home path", () => {
+      const result = normalizeInput(
+        "external_directory",
+        { path: "$HOME/dev/project" },
+        [],
+      );
+      expect(result.values).toEqual([join("/mock/home", "dev/project")]);
+    });
   });
 
   describe("skill", () => {
@@ -130,6 +196,16 @@ describe("normalizeInput — non-MCP surfaces", () => {
       const result = normalizeInput("edit", null, []);
       expect(result.values).toEqual(["*"]);
     });
+
+    it("expands ~/... path value to absolute home path", () => {
+      const result = normalizeInput("read", { path: "~/.ssh/config" }, []);
+      expect(result.values).toEqual([join("/mock/home", ".ssh/config")]);
+    });
+
+    it("expands $HOME/... path value to absolute home path", () => {
+      const result = normalizeInput("write", { path: "$HOME/.ssh/config" }, []);
+      expect(result.values).toEqual([join("/mock/home", ".ssh/config")]);
+    });
   });
 
   describe("extension tools (non-path-bearing)", () => {

package/test/logging.test.ts

@@ -0,0 +1,51 @@
+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 });
+  }
+});

package/test/path-utils.test.ts

@@ -47,6 +47,16 @@ describe("normalizePathForComparison", () => {
     );
   });
 
+  test("expands bare $HOME to homedir", () => {
+    expect(normalizePathForComparison("$HOME", cwd)).toBe("/mock/home");
+  });
+
+  test("expands $HOME/... to homedir-relative path", () => {
+    expect(normalizePathForComparison("$HOME/.ssh/config", cwd)).toBe(
+      join("/mock/home", ".ssh/config"),
+    );
+  });
+
   test("strips leading @ before resolving", () => {
     expect(normalizePathForComparison("@/usr/local/bin", cwd)).toBe(
       "/usr/local/bin",

package/test/permission-forwarding.test.ts

@@ -1,5 +1,9 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { afterEach, describe, expect, test, vi } from "vitest";
 import {
+  createPermissionForwardingLocation,
+  isForwardedPermissionRequestForSession,
   resolvePermissionForwardingTargetSessionId,
   SUBAGENT_PARENT_SESSION_ENV_CANDIDATES,
   SUBAGENT_PARENT_SESSION_ENV_KEY,
@@ -240,3 +244,72 @@ describe("resolvePermissionForwardingTargetSessionId — registry resolution", (
     ).toBe("parent-from-env");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Moved from permission-system.test.ts catch-all (#342)
+// ---------------------------------------------------------------------------
+
+test("Permission forwarding resolves the parent interactive session from subagent runtime env", () => {
+  const targetSessionId = resolvePermissionForwardingTargetSessionId({
+    hasUI: false,
+    isSubagent: true,
+    currentSessionId: "child-session",
+    env: {
+      PI_AGENT_ROUTER_PARENT_SESSION_ID: "parent-session",
+    },
+  });
+
+  expect(targetSessionId).toBe("parent-session");
+});
+
+test("Permission forwarding does not guess a target session when subagent runtime env is missing", () => {
+  const targetSessionId = resolvePermissionForwardingTargetSessionId({
+    hasUI: false,
+    isSubagent: true,
+    currentSessionId: "child-session",
+    env: {},
+  });
+
+  expect(targetSessionId).toBe(null);
+});
+
+test("Permission forwarding uses session-scoped directories per interactive session", () => {
+  const forwardingRoot = join(tmpdir(), "pi-permission-system-forwarding-root");
+  const sessionA = createPermissionForwardingLocation(
+    forwardingRoot,
+    "session-a",
+  );
+  const sessionB = createPermissionForwardingLocation(
+    forwardingRoot,
+    "session-b",
+  );
+
+  expect(sessionA.sessionRootDir).not.toBe(sessionB.sessionRootDir);
+  expect(sessionA.requestsDir).not.toBe(sessionB.requestsDir);
+  expect(sessionA.responsesDir).not.toBe(sessionB.responsesDir);
+});
+
+test("Permission forwarding request routing only matches the intended UI session", () => {
+  expect(
+    isForwardedPermissionRequestForSession(
+      { targetSessionId: "session-a" },
+      "session-a",
+    ),
+  ).toBe(true);
+  expect(
+    isForwardedPermissionRequestForSession(
+      { targetSessionId: "session-a" },
+      "session-b",
+    ),
+  ).toBe(false);
+});
+
+test("Permission forwarding rejects unresolved sentinel session ids", () => {
+  const targetSessionId = resolvePermissionForwardingTargetSessionId({
+    hasUI: true,
+    isSubagent: false,
+    currentSessionId: "unknown",
+  });
+
+  expect(targetSessionId).toBe(null);
+});