@gotgenes/pi-permission-system 10.0.0 → 10.2.0

package/test/runtime.test.ts

@@ -1,4 +1,3 @@
-import { join } from "node:path";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 // ── logger stub ────────────────────────────────────────────────────────────
@@ -49,10 +48,6 @@ vi.mock("../src/config-reporter", () => ({
   buildResolvedConfigLogEntry: mockBuildResolvedConfigLogEntry,
 }));
 
-vi.mock("../src/forwarded-permissions/polling", () => ({
-  processForwardedPermissionRequests: vi.fn().mockResolvedValue(undefined),
-}));
-
 vi.mock("../src/subagent-context", () => ({
   isSubagentExecutionContext: vi.fn().mockReturnValue(false),
 }));
@@ -67,19 +62,9 @@ vi.mock("../src/session-rules", () => ({
 }));
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  getGlobalConfigPath,
-  getGlobalLogsDir,
-  getProjectConfigPath,
-} from "#src/config-paths";
+import { getGlobalLogsDir } from "#src/config-paths";
 import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
-import { PermissionManager } from "#src/permission-manager";
-import {
-  createExtensionRuntime,
-  createPermissionManagerForCwd,
-  derivePiProjectPaths,
-  refreshExtensionConfig,
-} from "#src/runtime";
+import { createExtensionRuntime, refreshExtensionConfig } from "#src/runtime";
 
 // ── test suite ─────────────────────────────────────────────────────────────
 
@@ -355,75 +340,6 @@ describe("createExtensionRuntime", () => {
   });
 });
 
-// ── derivePiProjectPaths ───────────────────────────────────────────────────
-
-describe("derivePiProjectPaths", () => {
-  it("returns null for null cwd", () => {
-    expect(derivePiProjectPaths(null)).toBeNull();
-  });
-
-  it("returns null for undefined cwd", () => {
-    expect(derivePiProjectPaths(undefined)).toBeNull();
-  });
-
-  it("returns null for empty string cwd", () => {
-    expect(derivePiProjectPaths("")).toBeNull();
-  });
-
-  it("returns projectGlobalConfigPath via getProjectConfigPath", () => {
-    const result = derivePiProjectPaths("/my/project");
-    expect(result?.projectGlobalConfigPath).toBe(
-      getProjectConfigPath("/my/project"),
-    );
-  });
-
-  it("returns projectAgentsDir as .pi/agent/agents under cwd", () => {
-    const result = derivePiProjectPaths("/my/project");
-    expect(result?.projectAgentsDir).toBe(
-      join("/my/project", ".pi", "agent", "agents"),
-    );
-  });
-});
-
-// ── createPermissionManagerForCwd ─────────────────────────────────────────
-
-describe("createPermissionManagerForCwd", () => {
-  beforeEach(() => {
-    // PermissionManager is already mocked as vi.fn() at module scope.
-  });
-
-  it("creates a PermissionManager with globalConfigPath from agentDir", () => {
-    const MockPM = PermissionManager as ReturnType<typeof vi.fn>;
-    MockPM.mockClear();
-    createPermissionManagerForCwd("/test/agent", null);
-    expect(MockPM).toHaveBeenCalledWith(
-      expect.objectContaining({
-        globalConfigPath: getGlobalConfigPath("/test/agent"),
-      }),
-    );
-  });
-
-  it("includes projectGlobalConfigPath when cwd is provided", () => {
-    const MockPM = PermissionManager as ReturnType<typeof vi.fn>;
-    MockPM.mockClear();
-    createPermissionManagerForCwd("/test/agent", "/my/project");
-    expect(MockPM).toHaveBeenCalledWith(
-      expect.objectContaining({
-        globalConfigPath: getGlobalConfigPath("/test/agent"),
-        projectGlobalConfigPath: getProjectConfigPath("/my/project"),
-      }),
-    );
-  });
-
-  it("excludes projectGlobalConfigPath when cwd is null", () => {
-    const MockPM = PermissionManager as ReturnType<typeof vi.fn>;
-    MockPM.mockClear();
-    createPermissionManagerForCwd("/test/agent", null);
-    const callArg = MockPM.mock.calls[0][0] as Record<string, unknown>;
-    expect(callArg.projectGlobalConfigPath).toBeUndefined();
-  });
-});
-
 // ── refreshExtensionConfig ────────────────────────────────────────────────
 
 describe("refreshExtensionConfig", () => {

package/test/service-lifecycle.test.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PermissionsService } from "#src/service";
+import {
+  PermissionServiceLifecycle,
+  type ServiceLifecycle,
+} from "#src/service-lifecycle";
+import type { SubagentSessionRegistry } from "#src/subagent-registry";
+
+import { makeCtx } from "#test/helpers/handler-fixtures";
+
+// ── module stubs ───────────────────────────────────────────────────────────
+
+const mockIsRegisteredSubagentChild = vi.hoisted(() =>
+  vi.fn<(ctx: unknown, registry: unknown) => boolean>().mockReturnValue(false),
+);
+const mockPublishPermissionsService = vi.hoisted(() => vi.fn<() => void>());
+const mockUnpublishPermissionsService = vi.hoisted(() => vi.fn<() => void>());
+const mockEmitReadyEvent = vi.hoisted(() => vi.fn<() => void>());
+
+vi.mock("#src/subagent-context", () => ({
+  isRegisteredSubagentChild: mockIsRegisteredSubagentChild,
+}));
+vi.mock("#src/service", () => ({
+  publishPermissionsService: mockPublishPermissionsService,
+  unpublishPermissionsService: mockUnpublishPermissionsService,
+}));
+vi.mock("#src/permission-events", () => ({
+  emitReadyEvent: mockEmitReadyEvent,
+}));
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+function makeService(): PermissionsService {
+  return {
+    checkPermission: vi.fn(),
+    getToolPermission: vi.fn(),
+    registerToolInputFormatter: vi.fn(),
+  };
+}
+
+function makeRegistry(): SubagentSessionRegistry {
+  return {
+    has: vi.fn().mockReturnValue(false),
+  } as unknown as SubagentSessionRegistry;
+}
+
+function makeLifecycle(overrides?: { subscriptions?: (() => void)[] }) {
+  const service = makeService();
+  const registry = makeRegistry();
+  const events = { emit: vi.fn(), on: vi.fn() };
+  const subscriptions = overrides?.subscriptions ?? [];
+  const lifecycle = new PermissionServiceLifecycle(
+    service,
+    registry,
+    events,
+    subscriptions,
+  );
+  return { lifecycle, service, registry, events, subscriptions };
+}
+
+beforeEach(() => {
+  mockIsRegisteredSubagentChild.mockReset();
+  mockIsRegisteredSubagentChild.mockReturnValue(false);
+  mockPublishPermissionsService.mockReset();
+  mockUnpublishPermissionsService.mockReset();
+  mockEmitReadyEvent.mockReset();
+});
+
+// ── ServiceLifecycle interface shape ──────────────────────────────────────
+
+it("PermissionServiceLifecycle satisfies ServiceLifecycle", () => {
+  const { lifecycle } = makeLifecycle();
+  const _: ServiceLifecycle = lifecycle;
+  expect(_).toBeDefined();
+});
+
+// ── activate ──────────────────────────────────────────────────────────────
+
+describe("activate", () => {
+  it("publishes the service for a non-child session", () => {
+    const ctx = makeCtx();
+    const { lifecycle, service } = makeLifecycle();
+    mockIsRegisteredSubagentChild.mockReturnValue(false);
+    lifecycle.activate(ctx);
+    expect(mockPublishPermissionsService).toHaveBeenCalledWith(service);
+  });
+
+  it("skips publishing for a registered child session", () => {
+    const ctx = makeCtx();
+    const { lifecycle } = makeLifecycle();
+    mockIsRegisteredSubagentChild.mockReturnValue(true);
+    lifecycle.activate(ctx);
+    expect(mockPublishPermissionsService).not.toHaveBeenCalled();
+  });
+
+  it("always emits the ready event, even for a child session", () => {
+    const ctx = makeCtx();
+    const { lifecycle, events } = makeLifecycle();
+    mockIsRegisteredSubagentChild.mockReturnValue(true);
+    lifecycle.activate(ctx);
+    expect(mockEmitReadyEvent).toHaveBeenCalledWith(events);
+  });
+
+  it("emits ready after publishing the service", () => {
+    const ctx = makeCtx();
+    const order: string[] = [];
+    mockPublishPermissionsService.mockImplementation(() =>
+      order.push("publish"),
+    );
+    mockEmitReadyEvent.mockImplementation(() => order.push("ready"));
+    const { lifecycle } = makeLifecycle();
+    lifecycle.activate(ctx);
+    expect(order).toEqual(["publish", "ready"]);
+  });
+
+  it("passes ctx and registry to isRegisteredSubagentChild", () => {
+    const ctx = makeCtx();
+    const { lifecycle, registry } = makeLifecycle();
+    lifecycle.activate(ctx);
+    expect(mockIsRegisteredSubagentChild).toHaveBeenCalledWith(ctx, registry);
+  });
+});
+
+// ── teardown ──────────────────────────────────────────────────────────────
+
+describe("teardown", () => {
+  it("calls each subscription unsubscribe function", () => {
+    const unsub1 = vi.fn();
+    const unsub2 = vi.fn();
+    const unsub3 = vi.fn();
+    const { lifecycle } = makeLifecycle({
+      subscriptions: [unsub1, unsub2, unsub3],
+    });
+    lifecycle.teardown();
+    expect(unsub1).toHaveBeenCalledOnce();
+    expect(unsub2).toHaveBeenCalledOnce();
+    expect(unsub3).toHaveBeenCalledOnce();
+  });
+
+  it("unpublishes the service after running subscriptions", () => {
+    const order: string[] = [];
+    const unsub = vi.fn(() => order.push("unsub"));
+    mockUnpublishPermissionsService.mockImplementation(() =>
+      order.push("unpublish"),
+    );
+    const { lifecycle } = makeLifecycle({ subscriptions: [unsub] });
+    lifecycle.teardown();
+    expect(order).toEqual(["unsub", "unpublish"]);
+  });
+
+  it("passes the service to unpublishPermissionsService", () => {
+    const { lifecycle, service } = makeLifecycle();
+    lifecycle.teardown();
+    expect(mockUnpublishPermissionsService).toHaveBeenCalledWith(service);
+  });
+
+  it("works with no subscriptions", () => {
+    const { lifecycle } = makeLifecycle({ subscriptions: [] });
+    expect(() => lifecycle.teardown()).not.toThrow();
+    expect(mockUnpublishPermissionsService).toHaveBeenCalledOnce();
+  });
+});

package/test/tool-input-preview.test.ts

@@ -9,10 +9,6 @@ import { safeJsonStringify } from "#src/logging";
 import {
   countTextLines,
   formatCount,
-  formatEditInputForPrompt,
-  formatReadInputForPrompt,
-  formatWriteInputForPrompt,
-  getPromptPath,
   serializeToolInputPreview,
   TOOL_INPUT_LOG_PREVIEW_MAX_LENGTH,
   TOOL_INPUT_PREVIEW_MAX_LENGTH,
@@ -102,113 +98,6 @@ describe("formatCount", () => {
   });
 });
 
-describe("getPromptPath", () => {
-  test("returns path from 'path' key", () => {
-    expect(getPromptPath({ path: "/foo/bar" })).toBe("/foo/bar");
-  });
-
-  test("falls back to 'file_path' key", () => {
-    expect(getPromptPath({ file_path: "/baz" })).toBe("/baz");
-  });
-
-  test("returns null when neither key is present", () => {
-    expect(getPromptPath({})).toBeNull();
-  });
-
-  test("returns null when path is empty string", () => {
-    expect(getPromptPath({ path: "" })).toBeNull();
-  });
-});
-
-describe("formatEditInputForPrompt", () => {
-  test("returns path-only description when no edits provided", () => {
-    const result = formatEditInputForPrompt({ path: "/foo.ts" });
-    expect(result).toBe("for '/foo.ts' with edit input");
-  });
-
-  test("formats single replacement with line counts", () => {
-    const result = formatEditInputForPrompt({
-      path: "/foo.ts",
-      edits: [{ oldText: "line1\nline2", newText: "replaced" }],
-    });
-    expect(result).toContain("for '/foo.ts'");
-    expect(result).toContain("1 replacement");
-    expect(result).toContain("2 lines");
-    expect(result).toContain("1 line");
-  });
-
-  test("formats multiple replacements mentioning additional edits", () => {
-    const result = formatEditInputForPrompt({
-      path: "/foo.ts",
-      edits: [
-        { oldText: "a", newText: "b" },
-        { oldText: "c", newText: "d" },
-        { oldText: "e", newText: "f" },
-      ],
-    });
-    expect(result).toContain("3 replacements");
-    expect(result).toContain("2 additional edits");
-  });
-
-  test("falls back to oldText/newText when no edits array", () => {
-    const result = formatEditInputForPrompt({
-      path: "/bar.ts",
-      oldText: "old",
-      newText: "new",
-    });
-    expect(result).toContain("for '/bar.ts'");
-    expect(result).toContain("1 replacement");
-  });
-
-  test("works without a path", () => {
-    const result = formatEditInputForPrompt({
-      edits: [{ oldText: "x", newText: "y" }],
-    });
-    expect(result).not.toContain("for '");
-    expect(result).toContain("1 replacement");
-  });
-});
-
-describe("formatWriteInputForPrompt", () => {
-  test("includes path, line count, and character count", () => {
-    const result = formatWriteInputForPrompt({
-      path: "/out.ts",
-      content: "line1\nline2",
-    });
-    expect(result).toContain("for '/out.ts'");
-    expect(result).toContain("2 lines");
-    expect(result).toContain("11 characters");
-  });
-
-  test("handles missing content as empty", () => {
-    const result = formatWriteInputForPrompt({ path: "/out.ts" });
-    expect(result).toContain("0 lines");
-    expect(result).toContain("0 characters");
-  });
-});
-
-describe("formatReadInputForPrompt", () => {
-  test("includes path", () => {
-    expect(formatReadInputForPrompt({ path: "/src/foo.ts" })).toBe(
-      "for path '/src/foo.ts'",
-    );
-  });
-
-  test("includes offset and limit when present", () => {
-    const result = formatReadInputForPrompt({
-      path: "/x",
-      offset: 10,
-      limit: 50,
-    });
-    expect(result).toContain("offset 10");
-    expect(result).toContain("limit 50");
-  });
-
-  test("returns empty string when no path and no options", () => {
-    expect(formatReadInputForPrompt({})).toBe("");
-  });
-});
-
 describe("serializeToolInputPreview", () => {
   test("delegates serialization to safeJsonStringify", () => {
     mockedStringify.mockReturnValue('{"key":"value"}');

package/test/tool-input-prompt-formatters.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from "vitest";
+
+import {
+  formatEditInputForPrompt,
+  formatReadInputForPrompt,
+  formatWriteInputForPrompt,
+  getPromptPath,
+} from "#src/tool-input-prompt-formatters";
+
+describe("getPromptPath", () => {
+  test("returns path from 'path' key", () => {
+    expect(getPromptPath({ path: "/foo/bar" })).toBe("/foo/bar");
+  });
+
+  test("falls back to 'file_path' key", () => {
+    expect(getPromptPath({ file_path: "/baz" })).toBe("/baz");
+  });
+
+  test("returns null when neither key is present", () => {
+    expect(getPromptPath({})).toBeNull();
+  });
+
+  test("returns null when path is empty string", () => {
+    expect(getPromptPath({ path: "" })).toBeNull();
+  });
+});
+
+describe("formatEditInputForPrompt", () => {
+  test("returns path-only description when no edits provided", () => {
+    const result = formatEditInputForPrompt({ path: "/foo.ts" });
+    expect(result).toBe("for '/foo.ts' with edit input");
+  });
+
+  test("formats single replacement with line counts", () => {
+    const result = formatEditInputForPrompt({
+      path: "/foo.ts",
+      edits: [{ oldText: "line1\nline2", newText: "replaced" }],
+    });
+    expect(result).toContain("for '/foo.ts'");
+    expect(result).toContain("1 replacement");
+    expect(result).toContain("2 lines");
+    expect(result).toContain("1 line");
+  });
+
+  test("formats multiple replacements mentioning additional edits", () => {
+    const result = formatEditInputForPrompt({
+      path: "/foo.ts",
+      edits: [
+        { oldText: "a", newText: "b" },
+        { oldText: "c", newText: "d" },
+        { oldText: "e", newText: "f" },
+      ],
+    });
+    expect(result).toContain("3 replacements");
+    expect(result).toContain("2 additional edits");
+  });
+
+  test("falls back to oldText/newText when no edits array", () => {
+    const result = formatEditInputForPrompt({
+      path: "/bar.ts",
+      oldText: "old",
+      newText: "new",
+    });
+    expect(result).toContain("for '/bar.ts'");
+    expect(result).toContain("1 replacement");
+  });
+
+  test("works without a path", () => {
+    const result = formatEditInputForPrompt({
+      edits: [{ oldText: "x", newText: "y" }],
+    });
+    expect(result).not.toContain("for '");
+    expect(result).toContain("1 replacement");
+  });
+});
+
+describe("formatWriteInputForPrompt", () => {
+  test("includes path, line count, and character count", () => {
+    const result = formatWriteInputForPrompt({
+      path: "/out.ts",
+      content: "line1\nline2",
+    });
+    expect(result).toContain("for '/out.ts'");
+    expect(result).toContain("2 lines");
+    expect(result).toContain("11 characters");
+  });
+
+  test("handles missing content as empty", () => {
+    const result = formatWriteInputForPrompt({ path: "/out.ts" });
+    expect(result).toContain("0 lines");
+    expect(result).toContain("0 characters");
+  });
+});
+
+describe("formatReadInputForPrompt", () => {
+  test("includes path", () => {
+    expect(formatReadInputForPrompt({ path: "/src/foo.ts" })).toBe(
+      "for path '/src/foo.ts'",
+    );
+  });
+
+  test("includes offset and limit when present", () => {
+    const result = formatReadInputForPrompt({
+      path: "/x",
+      offset: 10,
+      limit: 50,
+    });
+    expect(result).toContain("offset 10");
+    expect(result).toContain("limit 50");
+  });
+
+  test("returns empty string when no path and no options", () => {
+    expect(formatReadInputForPrompt({})).toBe("");
+  });
+});