pi-soly 1.9.3 → 1.11.0

package/mcp/__tests__/mcp-panel-exclude-tools.upstream-test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { createMcpPanel } from "../mcp-panel.ts";
+import { computeServerHash, type MetadataCache } from "../metadata-cache.ts";
+import type { McpConfig } from "../types.ts";
+
+function stripAnsi(input: string): string {
+  return input.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+describe("mcp-panel excludeTools", () => {
+  it("hides excluded tools from the panel view", () => {
+    const config: McpConfig = {
+      settings: { toolPrefix: "server" },
+      mcpServers: {
+        figma: {
+          command: "npx",
+          args: ["-y", "figma"],
+          directTools: true,
+          excludeTools: ["figma_get_screenshot", "get_figjam"],
+        },
+      },
+    };
+
+    const cache: MetadataCache = {
+      version: 1,
+      servers: {
+        figma: {
+          configHash: computeServerHash(config.mcpServers.figma),
+          cachedAt: Date.now(),
+          tools: [
+            { name: "get_screenshot", description: "Screenshot" },
+            { name: "get_nodes", description: "Nodes" },
+          ],
+          resources: [
+            { name: "figjam", uri: "ui://figjam", description: "FigJam" },
+          ],
+        },
+      },
+    };
+
+    const panel = createMcpPanel(
+      config,
+      cache,
+      new Map(),
+      {
+        reconnect: async () => true,
+        canAuthenticate: () => false,
+        authenticate: async () => ({ ok: false }),
+        getConnectionStatus: () => "idle",
+        refreshCacheAfterReconnect: () => null,
+      },
+      { requestRender: () => {} },
+      () => {},
+    );
+
+    panel.handleInput("g");
+    panel.handleInput("e");
+    panel.handleInput("t");
+    panel.handleInput("_");
+
+    const output = stripAnsi(panel.render(120).join("\n"));
+
+    expect(output).toContain("get_nodes");
+    expect(output).not.toContain("get_screenshot");
+    expect(output).not.toContain("get_figjam");
+
+    panel.dispose();
+  });
+});

package/mcp/__tests__/mcp-panel-keybindings.upstream-test.ts

@@ -0,0 +1,186 @@
+import { KeybindingsManager, TUI_KEYBINDINGS } from "@earendil-works/pi-tui";
+import { describe, expect, it, vi } from "vitest";
+import { createMcpPanel } from "../mcp-panel.ts";
+import { createMcpSetupPanel, type SetupPanelCallbacks } from "../mcp-setup-panel.ts";
+import { createPanelKeys } from "../panel-keys.ts";
+import type { McpDiscoverySummary } from "../config.ts";
+import type { McpConfig, McpPanelCallbacks } from "../types.ts";
+
+const CTRL_P = "\x10";
+const CTRL_N = "\x0e";
+const UP = "\x1b[A";
+const DOWN = "\x1b[B";
+const ENTER = "\r";
+
+function createEmacsKeybindings(): KeybindingsManager {
+  return new KeybindingsManager(TUI_KEYBINDINGS, {
+    "tui.select.up": ["up", "ctrl+p"],
+    "tui.select.down": ["down", "ctrl+n"],
+  });
+}
+
+function createTwoServerConfig(): McpConfig {
+  return {
+    mcpServers: {
+      alpha: { url: "https://alpha.example.com/mcp", auth: "oauth" },
+      beta: { url: "https://beta.example.com/mcp", auth: "oauth" },
+    },
+  };
+}
+
+function createAuthCallbacks(): McpPanelCallbacks {
+  return {
+    reconnect: async () => true,
+    canAuthenticate: () => true,
+    authenticate: vi.fn(async () => ({ ok: true })),
+    getConnectionStatus: () => "needs-auth",
+    refreshCacheAfterReconnect: () => null,
+  };
+}
+
+function createEmptyDiscovery(): McpDiscoverySummary {
+  return {
+    sources: [],
+    imports: [],
+    hasAnyConfig: false,
+    hasAnyDetectedPaths: false,
+    hasSharedServers: false,
+    hasPiOwnedServers: false,
+    totalServerCount: 0,
+    fingerprint: "test",
+    repoPrompt: { configured: false },
+  };
+}
+
+function createSetupCallbacks(): SetupPanelCallbacks {
+  const preview = { path: "/tmp/x", existed: false, changed: true, beforeText: "", afterText: "", diffText: "" };
+  return {
+    previewImports: () => preview,
+    previewStarterProject: () => preview,
+    previewRepoPrompt: () => null,
+    adoptImports: async () => ({ added: [], path: "/tmp/x" }),
+    scaffoldProjectConfig: vi.fn(async () => ({ path: "/tmp/x" })),
+    addRepoPrompt: async () => ({ path: "/tmp/x", serverName: "repoprompt" }),
+    openPath: async () => {},
+    markSetupCompleted: () => {},
+  };
+}
+
+describe("panel-keys", () => {
+  it("honors user keybindings when a manager is provided", () => {
+    const keys = createPanelKeys(createEmacsKeybindings());
+    expect(keys.selectUp(CTRL_P)).toBe(true);
+    expect(keys.selectUp(UP)).toBe(true);
+    expect(keys.selectDown(CTRL_N)).toBe(true);
+    expect(keys.selectDown(DOWN)).toBe(true);
+    expect(keys.selectConfirm(ENTER)).toBe(true);
+  });
+
+  it("falls back to hardcoded defaults without a manager", () => {
+    const keys = createPanelKeys();
+    expect(keys.selectUp(UP)).toBe(true);
+    expect(keys.selectUp(CTRL_P)).toBe(false);
+    expect(keys.selectDown(DOWN)).toBe(true);
+    expect(keys.selectDown(CTRL_N)).toBe(false);
+    expect(keys.selectConfirm(ENTER)).toBe(true);
+  });
+
+  it("respects rebinding that removes a default key", () => {
+    const manager = new KeybindingsManager(TUI_KEYBINDINGS, {
+      "tui.select.up": "ctrl+p",
+    });
+    const keys = createPanelKeys(manager);
+    expect(keys.selectUp(CTRL_P)).toBe(true);
+    expect(keys.selectUp(UP)).toBe(false);
+  });
+});
+
+describe("mcp-panel custom keybindings", () => {
+  it("navigates with ctrl+n/ctrl+p when bound to tui.select.down/up", async () => {
+    const callbacks = createAuthCallbacks();
+    const panel = createMcpPanel(
+      createTwoServerConfig(),
+      null,
+      new Map(),
+      callbacks,
+      { requestRender: () => {} },
+      () => {},
+      { authOnly: true, keybindings: createEmacsKeybindings() },
+    );
+
+    panel.handleInput(CTRL_N);
+    panel.handleInput(ENTER);
+    await Promise.resolve();
+    expect(callbacks.authenticate).toHaveBeenLastCalledWith("beta");
+
+    panel.handleInput(CTRL_P);
+    panel.handleInput(ENTER);
+    await Promise.resolve();
+    expect(callbacks.authenticate).toHaveBeenLastCalledWith("alpha");
+    panel.dispose();
+  });
+
+  it("keeps arrow keys working alongside custom bindings", async () => {
+    const callbacks = createAuthCallbacks();
+    const panel = createMcpPanel(
+      createTwoServerConfig(),
+      null,
+      new Map(),
+      callbacks,
+      { requestRender: () => {} },
+      () => {},
+      { authOnly: true, keybindings: createEmacsKeybindings() },
+    );
+
+    panel.handleInput(DOWN);
+    panel.handleInput(ENTER);
+    await Promise.resolve();
+    expect(callbacks.authenticate).toHaveBeenLastCalledWith("beta");
+    panel.dispose();
+  });
+
+  it("treats ctrl+p/ctrl+n as unbound without a keybindings manager", async () => {
+    const callbacks = createAuthCallbacks();
+    const panel = createMcpPanel(
+      createTwoServerConfig(),
+      null,
+      new Map(),
+      callbacks,
+      { requestRender: () => {} },
+      () => {},
+      { authOnly: true },
+    );
+
+    panel.handleInput(CTRL_N);
+    panel.handleInput(ENTER);
+    await Promise.resolve();
+    // Cursor did not move: still authenticates the first server.
+    expect(callbacks.authenticate).toHaveBeenLastCalledWith("alpha");
+    panel.dispose();
+  });
+});
+
+describe("mcp-setup-panel custom keybindings", () => {
+  it("navigates actions with ctrl+n and confirms with enter", async () => {
+    const callbacks = createSetupCallbacks();
+    const panel = createMcpSetupPanel(
+      createEmptyDiscovery(),
+      callbacks,
+      {
+        mode: "setup",
+        onboardingState: { version: 1, sharedConfigHintShown: false, setupCompleted: false },
+        keybindings: createEmacsKeybindings(),
+      },
+      { requestRender: () => {} },
+      () => {},
+    );
+
+    // Actions for this discovery: view-example, scaffold-project, show-precedence, close.
+    panel.handleInput(CTRL_N);
+    panel.handleInput(ENTER);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(callbacks.scaffoldProjectConfig).toHaveBeenCalledTimes(1);
+    panel.dispose();
+  });
+});

package/mcp/__tests__/npx-resolver.upstream-test.ts

@@ -0,0 +1,54 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("npx-resolver cache path", () => {
+  const originalHome = process.env.HOME;
+  const originalAgentDir = process.env.PI_CODING_AGENT_DIR;
+  const originalNpmCache = process.env.NPM_CONFIG_CACHE;
+
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (originalAgentDir === undefined) {
+      delete process.env.PI_CODING_AGENT_DIR;
+    } else {
+      process.env.PI_CODING_AGENT_DIR = originalAgentDir;
+    }
+    if (originalNpmCache === undefined) {
+      delete process.env.NPM_CONFIG_CACHE;
+    } else {
+      process.env.NPM_CONFIG_CACHE = originalNpmCache;
+    }
+  });
+
+  it("writes mcp-npx-cache.json to PI_CODING_AGENT_DIR", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-npx-home-"));
+    const agentDir = mkdtempSync(join(tmpdir(), "pi-mcp-npx-agent-"));
+    const npmCache = mkdtempSync(join(tmpdir(), "pi-mcp-npx-cache-"));
+
+    process.env.HOME = home;
+    process.env.PI_CODING_AGENT_DIR = agentDir;
+    process.env.NPM_CONFIG_CACHE = npmCache;
+
+    const packageDir = join(npmCache, "_npx", "fixture", "node_modules", "demo-pkg");
+    mkdirSync(join(packageDir, "bin"), { recursive: true });
+    writeFileSync(
+      join(packageDir, "package.json"),
+      JSON.stringify({ name: "demo-pkg", version: "1.0.0", bin: "bin/cli.js" }),
+      "utf-8",
+    );
+    writeFileSync(join(packageDir, "bin", "cli.js"), "#!/usr/bin/env node\nconsole.log('ok')\n", "utf-8");
+
+    const { resolveNpxBinary } = await import("../npx-resolver.ts");
+    const result = await resolveNpxBinary("npx", ["-y", "demo-pkg"]);
+
+    expect(result).not.toBeNull();
+    expect(existsSync(join(agentDir, "mcp-npx-cache.json"))).toBe(true);
+    expect(existsSync(join(home, ".pi", "agent", "mcp-npx-cache.json"))).toBe(false);
+  });
+});

package/mcp/__tests__/oauth-handler.upstream-test.ts

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("oauth-handler path resolution", () => {
+  const originalHome = process.env.HOME;
+  const originalAgentDir = process.env.PI_CODING_AGENT_DIR;
+  const originalOAuthDir = process.env.MCP_OAUTH_DIR;
+
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (originalAgentDir === undefined) {
+      delete process.env.PI_CODING_AGENT_DIR;
+    } else {
+      process.env.PI_CODING_AGENT_DIR = originalAgentDir;
+    }
+    if (originalOAuthDir === undefined) {
+      delete process.env.MCP_OAUTH_DIR;
+    } else {
+      process.env.MCP_OAUTH_DIR = originalOAuthDir;
+    }
+  });
+
+  it("reads tokens from PI_CODING_AGENT_DIR when MCP_OAUTH_DIR is unset", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-oauth-handler-home-"));
+    const agentDir = mkdtempSync(join(tmpdir(), "pi-mcp-oauth-handler-agent-"));
+    process.env.HOME = home;
+    process.env.PI_CODING_AGENT_DIR = agentDir;
+    delete process.env.MCP_OAUTH_DIR;
+
+    const { getAuthEntryFilePath } = await import("../mcp-auth.ts");
+    const tokensPath = getAuthEntryFilePath("demo");
+    mkdirSync(dirname(tokensPath), { recursive: true });
+    writeFileSync(tokensPath, JSON.stringify({ access_token: "abc", token_type: "bearer" }), "utf-8");
+
+    const { getStoredTokens } = await import("../oauth-handler.ts");
+    expect(getStoredTokens("demo")).toEqual({
+      access_token: "abc",
+      token_type: "bearer",
+      refresh_token: undefined,
+      expires_in: undefined,
+    });
+  });
+
+  it("prefers MCP_OAUTH_DIR over PI_CODING_AGENT_DIR", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-oauth-handler-home-"));
+    const agentDir = mkdtempSync(join(tmpdir(), "pi-mcp-oauth-handler-agent-"));
+    const oauthDir = mkdtempSync(join(tmpdir(), "pi-mcp-oauth-handler-oauth-"));
+    process.env.HOME = home;
+    process.env.PI_CODING_AGENT_DIR = agentDir;
+    process.env.MCP_OAUTH_DIR = oauthDir;
+
+    const { getAuthEntryFilePath } = await import("../mcp-auth.ts");
+
+    delete process.env.MCP_OAUTH_DIR;
+    const agentTokensPath = getAuthEntryFilePath("demo");
+    mkdirSync(dirname(agentTokensPath), { recursive: true });
+    writeFileSync(agentTokensPath, JSON.stringify({ access_token: "from-agent" }), "utf-8");
+
+    process.env.MCP_OAUTH_DIR = oauthDir;
+    const overrideTokensPath = getAuthEntryFilePath("demo");
+    mkdirSync(dirname(overrideTokensPath), { recursive: true });
+    writeFileSync(
+      overrideTokensPath,
+      JSON.stringify({ access_token: "from-override", token_type: "bearer" }),
+      "utf-8",
+    );
+
+    const { getStoredTokens } = await import("../oauth-handler.ts");
+    expect(getStoredTokens("demo")?.access_token).toBe("from-override");
+  });
+});

package/mcp/__tests__/onboarding-state.upstream-test.ts

@@ -0,0 +1,52 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("onboarding state", () => {
+  const originalHome = process.env.HOME;
+
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+  });
+
+  it("returns the default state when no file exists", async () => {
+    process.env.HOME = mkdtempSync(join(tmpdir(), "pi-mcp-onboarding-home-"));
+    const { loadOnboardingState, getOnboardingStatePath } = await import("../onboarding-state.ts");
+
+    expect(loadOnboardingState()).toEqual({
+      version: 1,
+      sharedConfigHintShown: false,
+      setupCompleted: false,
+    });
+    expect(existsSync(getOnboardingStatePath())).toBe(false);
+  });
+
+  it("persists hint and setup completion state", async () => {
+    process.env.HOME = mkdtempSync(join(tmpdir(), "pi-mcp-onboarding-home-"));
+    const {
+      markSharedConfigHintShown,
+      markSetupCompleted,
+      loadOnboardingState,
+      getOnboardingStatePath,
+    } = await import("../onboarding-state.ts");
+
+    markSharedConfigHintShown("first");
+    markSetupCompleted("second");
+
+    expect(loadOnboardingState()).toEqual({
+      version: 1,
+      sharedConfigHintShown: true,
+      setupCompleted: true,
+      lastDiscoveryFingerprint: "second",
+    });
+
+    const raw = JSON.parse(readFileSync(getOnboardingStatePath(), "utf-8"));
+    expect(raw.sharedConfigHintShown).toBe(true);
+    expect(raw.setupCompleted).toBe(true);
+  });
+});

package/mcp/__tests__/package-manifest.upstream-test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const packageJson = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf-8")) as {
+  files?: string[];
+};
+
+describe("package.json files", () => {
+  it("publishes every root runtime TypeScript module", () => {
+    const publishedFiles = new Set(packageJson.files ?? []);
+    const runtimeModules = readdirSync(repoRoot)
+      .filter((entry) => entry.endsWith(".ts"))
+      .filter((entry) => !entry.endsWith(".test.ts"))
+      .filter((entry) => entry !== "vitest.config.ts");
+
+    expect(runtimeModules.length).toBeGreaterThan(0);
+    expect(runtimeModules.filter((entry) => !publishedFiles.has(entry))).toEqual([]);
+  });
+});