pi-extended-teams 2.1.16

package/extensions/ui/agent-navigation.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it, vi } from "vitest";
+import { installAgentNavigation, wrapEditorForAgentNavigation } from "./agent-navigation";
+
+describe("agent navigation editor", () => {
+  it("opens the agent view on down only when the editor is empty", () => {
+    let text = "";
+    const originalHandleInput = vi.fn();
+    const editor = {
+      getText: () => text,
+      handleInput: originalHandleInput,
+    };
+    const openAgentView = vi.fn(() => true);
+    const wrapped = wrapEditorForAgentNavigation(editor, openAgentView);
+
+    wrapped.handleInput("\x1b[B");
+    expect(openAgentView).toHaveBeenCalledOnce();
+    expect(originalHandleInput).not.toHaveBeenCalled();
+
+    text = "draft";
+    wrapped.handleInput("\x1b[B");
+    expect(openAgentView).toHaveBeenCalledOnce();
+    expect(originalHandleInput).toHaveBeenCalledWith("\x1b[B");
+  });
+
+  it("replaces its own editor wrapper on reload instead of stacking wrappers", () => {
+    let currentFactory: any;
+    const ctx = {
+      mode: "tui",
+      ui: {
+        getEditorComponent: () => currentFactory,
+        setEditorComponent: vi.fn((factory: any) => { currentFactory = factory; }),
+      },
+    };
+
+    installAgentNavigation(ctx, { getAgents: () => [] });
+    const firstFactory = currentFactory;
+    installAgentNavigation(ctx, { getAgents: () => [] });
+
+    expect(currentFactory).not.toBe(firstFactory);
+    expect(currentFactory.piExtendedTeamsBaseFactory).toBeNull();
+  });
+
+  it("preserves normal down behavior when there is no active agent", () => {
+    const originalHandleInput = vi.fn();
+    const editor = { getText: () => "", handleInput: originalHandleInput };
+    const wrapped = wrapEditorForAgentNavigation(editor, () => false);
+
+    wrapped.handleInput("\x1b[B");
+
+    expect(originalHandleInput).toHaveBeenCalledWith("\x1b[B");
+  });
+});

package/extensions/ui/agent-navigation.ts

@@ -0,0 +1,55 @@
+import { CustomEditor } from "@mariozechner/pi-coding-agent";
+import { Key, matchesKey } from "@mariozechner/pi-tui";
+import type { RunningReadAgent } from "../runtime/types";
+import { openAgentFollowView } from "./agent-follow-view";
+
+export interface AgentNavigationOptions {
+  getAgents(): RunningReadAgent[];
+  stopAgent?(name: string): void | Promise<void>;
+  sendMessage?(name: string, content: string): void | Promise<void>;
+}
+
+type NavigationEditorFactory = ((tui: any, theme: any, keybindings: any) => any) & {
+  piExtendedTeamsBaseFactory?: ((tui: any, theme: any, keybindings: any) => any) | null;
+};
+
+export function wrapEditorForAgentNavigation(editor: any, openAgentView: () => boolean): any {
+  const originalHandleInput = editor.handleInput.bind(editor);
+  editor.handleInput = (data: string) => {
+    if (matchesKey(data, Key.down) && editor.getText?.().length === 0 && openAgentView()) return;
+    originalHandleInput(data);
+  };
+  return editor;
+}
+
+export function installAgentNavigation(ctx: any, options: AgentNavigationOptions): void {
+  if (ctx.mode && ctx.mode !== "tui") return;
+  if (!ctx.ui?.setEditorComponent) return;
+
+  const currentFactory = ctx.ui.getEditorComponent?.() as NavigationEditorFactory | undefined;
+  const baseFactory = currentFactory && Object.hasOwn(currentFactory, "piExtendedTeamsBaseFactory")
+    ? currentFactory.piExtendedTeamsBaseFactory ?? undefined
+    : currentFactory;
+  let opening = false;
+
+  const navigationFactory: NavigationEditorFactory = (tui: any, theme: any, keybindings: any) => {
+    const editor = baseFactory
+      ? baseFactory(tui, theme, keybindings)
+      : new CustomEditor(tui, theme, keybindings);
+
+    return wrapEditorForAgentNavigation(editor, () => {
+      const agents = options.getAgents();
+      if (opening || agents.length === 0) return false;
+      opening = true;
+      void openAgentFollowView(ctx, {
+        getAgents: options.getAgents,
+        initialAgentName: agents.slice().sort((a, b) => a.name.localeCompare(b.name))[0]?.name,
+        stopAgent: options.stopAgent,
+        sendMessage: options.sendMessage,
+      }).catch(() => {}).finally(() => { opening = false; });
+      return true;
+    });
+  };
+  navigationFactory.piExtendedTeamsBaseFactory = baseFactory ?? null;
+  ctx.ui.setEditorComponent(navigationFactory);
+}

package/extensions/ui/ansi.ts

@@ -0,0 +1,16 @@
+export const ANSI_RESET = "\x1b[0m";
+export const ANSI_PINK = "\x1b[38;5;213m";
+export const ANSI_PURPLE = "\x1b[38;5;141m";
+export const ANSI_DIM = "\x1b[2m";
+
+export function pink(text: string): string {
+  return `${ANSI_PINK}${text}${ANSI_RESET}`;
+}
+
+export function purple(text: string): string {
+  return `${ANSI_PURPLE}${text}${ANSI_RESET}`;
+}
+
+export function dimAnsi(text: string): string {
+  return `${ANSI_DIM}${text}${ANSI_RESET}`;
+}

package/extensions/ui/extensions-command.test.ts

@@ -0,0 +1,336 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import {
+  globalSettingsPath,
+  loadSettings,
+  projectSettingsPath,
+  replaceGlobalExtensionAllow,
+} from "../../src/utils/settings";
+import type { SpawnResourcePlan } from "../resources/spawn-resource-plan";
+
+vi.mock("@mariozechner/pi-coding-agent", () => ({
+  getSettingsListTheme: () => ({
+    label: (text: string) => text,
+    value: (text: string) => text,
+    description: (text: string) => text,
+    cursor: ">",
+    hint: (text: string) => text,
+  }),
+}));
+import {
+  explicitAllowFromPicker,
+  formatExtensionsPlan,
+  registerExtensionsCommand,
+} from "./extensions-command";
+
+function makePlan(): SpawnResourcePlan {
+  return Object.freeze({
+    selectionMode: "explicit" as const,
+    extensionPaths: Object.freeze(["/extensions/selected/index.ts"]),
+    selfExtensionPath: "/pi-extended-teams/extensions/index.ts",
+    extensions: Object.freeze([
+      Object.freeze({
+        name: "selected",
+        selector: "selected",
+        identity: "/extensions/selected/index.ts",
+        path: "/extensions/selected/index.ts",
+        selected: true,
+        state: "selected" as const,
+        isSelf: false,
+        sourceInfo: Object.freeze({ path: "/extensions/selected/index.ts", source: "npm:selected-package", scope: "user" as const, origin: "package" as const }),
+      }),
+      Object.freeze({
+        name: "off",
+        selector: "off",
+        identity: "/project/.pi/extensions/off.ts",
+        path: "/project/.pi/extensions/off.ts",
+        selected: false,
+        state: "available" as const,
+        isSelf: false,
+        sourceInfo: Object.freeze({ path: "/project/.pi/extensions/off.ts", source: "local", scope: "project" as const, origin: "top-level" as const }),
+      }),
+      Object.freeze({
+        name: "pi-extended-teams",
+        selector: "pi-extended-teams",
+        identity: "/pi-extended-teams/extensions/index.ts",
+        path: "/pi-extended-teams/extensions/index.ts",
+        selected: false,
+        state: "self" as const,
+        isSelf: true,
+        sourceInfo: Object.freeze({ path: "/pi-extended-teams/extensions/index.ts", source: "local", scope: "user" as const, origin: "top-level" as const }),
+      }),
+    ]),
+    diagnostics: Object.freeze([
+      Object.freeze({
+        code: "stale-selection" as const,
+        configuredEntry: "missing-extension",
+        message: "Configured extension is not observable in the lead Pi session: missing-extension",
+      }),
+    ]),
+    skills: "all" as const,
+    trust: Object.freeze({ cwd: "/project", projectTrusted: true }),
+  });
+}
+
+function theme() {
+  return {
+    fg: (_color: string, value: string) => value,
+    bold: (value: string) => value,
+  };
+}
+
+function setupFileBackedCommand(options: {
+  homeDir: string;
+  projectDir: string;
+  trusted: boolean;
+  custom?: (factory: any) => Promise<any>;
+}) {
+  const commands = new Map<string, any>();
+  const pi = { registerCommand: vi.fn((name: string, command: any) => commands.set(name, command)) };
+  const ctx = {
+    cwd: options.projectDir,
+    mode: "tui",
+    isProjectTrusted: () => options.trusted,
+    ui: {
+      notify: vi.fn(),
+      custom: options.custom ? vi.fn(options.custom) : vi.fn(),
+    },
+  };
+  registerExtensionsCommand(pi, {
+    createResourcePlan: vi.fn(async () => makePlan()),
+    loadTeamsSettings: (loadOptions) => loadSettings({ homeDir: options.homeDir, projectDir: loadOptions?.projectDir }),
+    saveAllow: (allow) => replaceGlobalExtensionAllow(allow, { homeDir: options.homeDir }),
+    getGlobalSettingsPath: () => globalSettingsPath(options.homeDir),
+  });
+  return { command: commands.get("agents-extensions"), ctx };
+}
+
+function setupCommand(custom?: (factory: any) => Promise<any>) {
+  const commands = new Map<string, any>();
+  const pi = { registerCommand: vi.fn((name: string, command: any) => commands.set(name, command)) };
+  const saveAllow = vi.fn();
+  const createResourcePlan = vi.fn(async () => makePlan());
+  const loadTeamsSettings = vi.fn(() => ({ extensions: { allow: ["selected", "missing-extension"], block: [] } } as any));
+  registerExtensionsCommand(pi, {
+    createResourcePlan,
+    loadTeamsSettings,
+    saveAllow,
+  });
+  const ctx = {
+    cwd: "/project",
+    mode: "tui",
+    isProjectTrusted: () => true,
+    ui: {
+      notify: vi.fn(),
+      custom: custom ? vi.fn(custom) : vi.fn(),
+    },
+  };
+  return { command: commands.get("agents-extensions"), ctx, saveAllow, createResourcePlan, loadTeamsSettings, pi };
+}
+
+describe("/agents-extensions", () => {
+  it("formats textual enabled, disabled, self, missing, and provenance states", async () => {
+    const plan = makePlan();
+    const text = formatExtensionsPlan(plan);
+    expect(text).toContain("Skills use normal Pi discovery and trust. pi-extended-teams is handled internally.");
+    expect(text).toContain("event-only extensions cannot be propagated");
+    expect(text).toContain("enabled · selected · user · package · npm:selected-package");
+    expect(text).toContain("disabled · off.ts · project · top-level · local");
+    expect(text).toContain("internal · extensions · user · top-level · local");
+    expect(text).toContain("Configured extension is not observable in the lead Pi session: missing-extension");
+
+    const setup = setupCommand();
+    await setup.command.handler("list", setup.ctx);
+    expect(setup.loadTeamsSettings).toHaveBeenCalledWith({ projectDir: "/project" });
+    expect(setup.createResourcePlan).toHaveBeenCalledWith(expect.objectContaining({
+      cwd: "/project",
+      projectTrusted: true,
+    }));
+    expect(setup.ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("missing-extension"), "info");
+    expect(setup.saveAllow).not.toHaveBeenCalled();
+  });
+
+  it("does not read project-local policy when the parent project is untrusted", async () => {
+    const setup = setupCommand();
+    setup.ctx.mode = "print";
+    setup.ctx.isProjectTrusted = () => false;
+
+    await setup.command.handler("list", setup.ctx);
+
+    expect(setup.loadTeamsSettings).toHaveBeenCalledWith({ projectDir: undefined });
+    expect(setup.createResourcePlan).toHaveBeenCalledWith(expect.objectContaining({ projectTrusted: false }));
+  });
+
+  it("writes nothing when the native SettingsList is cancelled", async () => {
+    const setup = setupCommand(async (factory: any) => {
+      return new Promise((resolve) => {
+        const component = factory({ requestRender: vi.fn() }, theme(), {}, resolve);
+        component.handleInput("\u001b");
+      });
+    });
+
+    await setup.command.handler("", setup.ctx);
+    expect(setup.saveAllow).not.toHaveBeenCalled();
+  });
+
+  it("saves explicit resolver-ordered paths while retaining stale configured entries", async () => {
+    const setup = setupCommand(async (factory: any) => {
+      return new Promise((resolve) => {
+        const component = factory({ requestRender: vi.fn() }, theme(), {}, resolve);
+        component.handleInput("\u001b[B");
+        component.handleInput("\r");
+        component.handleInput("\u0013");
+      });
+    });
+
+    await setup.command.handler("", setup.ctx);
+    expect(setup.saveAllow).toHaveBeenCalledWith(["missing-extension"]);
+    expect(setup.ctx.ui.notify).toHaveBeenCalledWith("Spawned-agent extension choices saved.", "info");
+  });
+
+  it("supports durable default and none policies without opening the selector", async () => {
+    const setup = setupCommand();
+    await setup.command.handler("default", setup.ctx);
+    await setup.command.handler("none", setup.ctx);
+
+    expect(setup.saveAllow.mock.calls).toEqual([[null], [[]]]);
+    expect(setup.createResourcePlan).not.toHaveBeenCalled();
+    expect(setup.ctx.ui.custom).not.toHaveBeenCalled();
+  });
+
+  it("saves default and none globally while a trusted project policy remains effective", async () => {
+    const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "pet-command-home-"));
+    const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "pet-command-project-"));
+    try {
+      const globalPath = globalSettingsPath(homeDir);
+      const projectPath = projectSettingsPath(projectDir);
+      fs.mkdirSync(path.dirname(globalPath), { recursive: true });
+      fs.mkdirSync(path.dirname(projectPath), { recursive: true });
+      fs.writeFileSync(globalPath, JSON.stringify({ unknownGlobal: true, extensions: { allow: ["global"], block: ["blocked"] } }));
+      fs.writeFileSync(projectPath, JSON.stringify({ unknownProject: true, extensions: { allow: ["project"], block: ["project-block"] } }));
+      const projectBefore = fs.readFileSync(projectPath, "utf-8");
+      const setup = setupFileBackedCommand({ homeDir, projectDir, trusted: true });
+
+      await setup.command.handler("default", setup.ctx);
+      expect(JSON.parse(fs.readFileSync(globalPath, "utf-8"))).toMatchObject({
+        unknownGlobal: true,
+        extensions: { allow: null, block: ["blocked"] },
+      });
+      expect(loadSettings({ homeDir, projectDir }).extensions.allow).toEqual(["project"]);
+      expect(fs.readFileSync(projectPath, "utf-8")).toBe(projectBefore);
+      expect(setup.ctx.ui.notify).toHaveBeenLastCalledWith(
+        expect.stringContaining(`Global spawned-agent extension policy was saved to ${globalPath}`),
+        "warning",
+      );
+      expect(setup.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining(projectPath), "warning");
+
+      await setup.command.handler("none", setup.ctx);
+      expect(JSON.parse(fs.readFileSync(globalPath, "utf-8")).extensions.allow).toEqual([]);
+      expect(loadSettings({ homeDir, projectDir }).extensions.allow).toEqual(["project"]);
+    } finally {
+      fs.rmSync(homeDir, { recursive: true, force: true });
+      fs.rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+
+  it("saves picker choices globally but leaves a trusted project override authoritative", async () => {
+    const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "pet-command-home-"));
+    const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "pet-command-project-"));
+    try {
+      const globalPath = globalSettingsPath(homeDir);
+      const projectPath = projectSettingsPath(projectDir);
+      fs.mkdirSync(path.dirname(globalPath), { recursive: true });
+      fs.mkdirSync(path.dirname(projectPath), { recursive: true });
+      fs.writeFileSync(globalPath, JSON.stringify({ extensions: { allow: ["global"], block: ["blocked"], unknownNested: true } }));
+      fs.writeFileSync(projectPath, JSON.stringify({ extensions: { allow: [], block: ["project-block"] }, projectOnly: true }));
+      const projectBefore = fs.readFileSync(projectPath, "utf-8");
+      const setup = setupFileBackedCommand({
+        homeDir,
+        projectDir,
+        trusted: true,
+        custom: async () => ({ mode: "explicit", selectedIdentities: ["/extensions/selected/index.ts"] }),
+      });
+
+      await setup.command.handler("", setup.ctx);
+
+      expect(JSON.parse(fs.readFileSync(globalPath, "utf-8"))).toMatchObject({
+        extensions: { allow: ["/extensions/selected/index.ts", "missing-extension"], block: ["blocked"], unknownNested: true },
+      });
+      expect(fs.readFileSync(projectPath, "utf-8")).toBe(projectBefore);
+      expect(loadSettings({ homeDir, projectDir }).extensions.allow).toEqual([]);
+      expect(setup.ctx.ui.notify).toHaveBeenLastCalledWith(expect.stringContaining(projectPath), "warning");
+    } finally {
+      fs.rmSync(homeDir, { recursive: true, force: true });
+      fs.rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+
+  it("ignores an untrusted project override and leaves files unchanged when picker is cancelled", async () => {
+    const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "pet-command-home-"));
+    const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "pet-command-project-"));
+    try {
+      const globalPath = globalSettingsPath(homeDir);
+      const projectPath = projectSettingsPath(projectDir);
+      fs.mkdirSync(path.dirname(globalPath), { recursive: true });
+      fs.mkdirSync(path.dirname(projectPath), { recursive: true });
+      fs.writeFileSync(globalPath, JSON.stringify({ extensions: { allow: ["global"], block: ["blocked"] } }));
+      fs.writeFileSync(projectPath, JSON.stringify({ extensions: { allow: ["project"] } }));
+      const projectBefore = fs.readFileSync(projectPath, "utf-8");
+      const setup = setupFileBackedCommand({ homeDir, projectDir, trusted: false });
+
+      await setup.command.handler("none", setup.ctx);
+      expect(JSON.parse(fs.readFileSync(globalPath, "utf-8")).extensions.allow).toEqual([]);
+      expect(loadSettings({ homeDir }).extensions.allow).toEqual([]);
+      expect(fs.readFileSync(projectPath, "utf-8")).toBe(projectBefore);
+      expect(setup.ctx.ui.notify).toHaveBeenLastCalledWith(
+        "Spawned agents will load no external extensions. Skills remain enabled.",
+        "info",
+      );
+
+      const globalBeforeCancel = fs.readFileSync(globalPath, "utf-8");
+      const cancelled = setupFileBackedCommand({
+        homeDir,
+        projectDir,
+        trusted: true,
+        custom: async () => null,
+      });
+      await cancelled.command.handler("", cancelled.ctx);
+      expect(fs.readFileSync(globalPath, "utf-8")).toBe(globalBeforeCancel);
+      expect(fs.readFileSync(projectPath, "utf-8")).toBe(projectBefore);
+      expect(loadSettings({ homeDir, projectDir }).extensions.allow).toEqual(["project"]);
+    } finally {
+      fs.rmSync(homeDir, { recursive: true, force: true });
+      fs.rmSync(projectDir, { recursive: true, force: true });
+    }
+  });
+
+  it("persists canonical identities, excludes self, and preserves stale or blocked entries", () => {
+    const plan = makePlan();
+    const withBlockedDiagnostic: SpawnResourcePlan = Object.freeze({
+      ...plan,
+      diagnostics: Object.freeze([
+        ...plan.diagnostics,
+        Object.freeze({
+          code: "blocked-selection" as const,
+          configuredEntry: "/extensions/blocked/index.ts",
+          message: "Configured extension is blocked for spawned agents: /extensions/blocked/index.ts",
+        }),
+      ]),
+    });
+
+    expect(explicitAllowFromPicker(withBlockedDiagnostic, {
+      mode: "explicit",
+      selectedIdentities: [
+        "/extensions/selected/index.ts",
+        "/pi-extended-teams/extensions/index.ts",
+      ],
+    })).toEqual([
+      "/extensions/selected/index.ts",
+      "missing-extension",
+      "/extensions/blocked/index.ts",
+    ]);
+    expect(explicitAllowFromPicker(plan, { mode: "default", selectedIdentities: [] })).toBeNull();
+  });
+});