pi-soly 1.10.0 → 1.11.0

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

@@ -0,0 +1,157 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+
+function writeJson(path: string, value: unknown): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+
+const mocks = {
+  createMcpPanel: vi.fn(),
+  createMcpSetupPanel: vi.fn(),
+};
+
+vi.mock("../mcp-panel.ts", () => ({
+  createMcpPanel: mocks.createMcpPanel,
+}));
+
+vi.mock("../mcp-setup-panel.ts", () => ({
+  createMcpSetupPanel: mocks.createMcpSetupPanel,
+}));
+
+describe("commands onboarding", () => {
+  const originalHome = process.env.HOME;
+  const originalOAuthDir = process.env.MCP_OAUTH_DIR;
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    vi.resetModules();
+    mocks.createMcpPanel.mockReset().mockImplementation((_config, _cache, _prov, _callbacks, _tui, done) => {
+      done({ cancelled: true, changes: new Map() });
+      return { dispose() {} };
+    });
+    mocks.createMcpSetupPanel.mockReset().mockImplementation((_discovery, _callbacks, _options, _tui, done) => {
+      done();
+      return { dispose() {} };
+    });
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (originalOAuthDir === undefined) {
+      delete process.env.MCP_OAUTH_DIR;
+    } else {
+      process.env.MCP_OAUTH_DIR = originalOAuthDir;
+    }
+    process.chdir(originalCwd);
+  });
+
+  function createUi() {
+    return {
+      notify: vi.fn(),
+      setStatus: vi.fn(),
+      custom: vi.fn((renderer: any) => renderer({ requestRender: vi.fn() }, {}, {}, vi.fn())),
+    };
+  }
+
+  it("opens setup mode when no MCP servers are configured", async () => {
+    process.env.HOME = mkdtempSync(join(tmpdir(), "pi-mcp-commands-home-"));
+    const ui = createUi();
+    const { openMcpPanel } = await import("../commands.ts");
+
+    await openMcpPanel({
+      config: { mcpServers: {} },
+      manager: { getConnection: () => null },
+      toolMetadata: new Map(),
+      failureTracker: new Map(),
+    } as any, { getFlag: () => undefined } as any, { hasUI: true, ui } as any);
+
+    expect(mocks.createMcpSetupPanel).toHaveBeenCalled();
+    expect(mocks.createMcpPanel).not.toHaveBeenCalled();
+  });
+
+  it("shows a one-time shared-config notice in the MCP panel", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-commands-home-"));
+    const project = mkdtempSync(join(tmpdir(), "pi-mcp-commands-project-"));
+    process.env.HOME = home;
+    process.chdir(project);
+
+    writeJson(join(home, ".config", "mcp", "mcp.json"), {
+      mcpServers: {
+        sharedServer: { command: "shared" },
+      },
+    });
+
+    const ui = createUi();
+    const { loadMcpConfig } = await import("../config.ts");
+    const { openMcpPanel } = await import("../commands.ts");
+    const { loadOnboardingState } = await import("../onboarding-state.ts");
+
+    await openMcpPanel({
+      config: loadMcpConfig(),
+      manager: { getConnection: () => null },
+      toolMetadata: new Map(),
+      failureTracker: new Map(),
+    } as any, { getFlag: () => undefined } as any, { hasUI: true, ui } as any);
+
+    expect(mocks.createMcpPanel).toHaveBeenCalled();
+    const options = mocks.createMcpPanel.mock.calls[0]?.[6];
+    expect(options.noticeLines[0]).toContain("Using standard MCP config");
+    expect(loadOnboardingState().sharedConfigHintShown).toBe(true);
+  });
+
+  it("clears OAuth credentials, cancels pending auth, and closes the server on logout", async () => {
+    process.env.MCP_OAUTH_DIR = mkdtempSync(join(tmpdir(), "pi-mcp-commands-logout-"));
+    const ui = createUi();
+    const close = vi.fn();
+    const { getAuthEntry, updateOAuthState, updateTokens } = await import("../mcp-auth.ts");
+    const { waitForCallback } = await import("../mcp-callback-server.ts");
+    const { logoutServer } = await import("../commands.ts");
+
+    updateTokens("oauth-server", { accessToken: "token", refreshToken: "refresh" }, "https://example.com/mcp");
+    updateOAuthState("oauth-server", "pending-state", "https://example.com/mcp");
+    const pendingCallback = waitForCallback("pending-state");
+    const pendingCallbackRejection = expect(pendingCallback).rejects.toThrow("Authorization cancelled");
+
+    const result = await logoutServer("oauth-server", {
+      config: { mcpServers: { "oauth-server": { url: "https://example.com/mcp", auth: "oauth" } } },
+      manager: { close },
+      toolMetadata: new Map(),
+      failureTracker: new Map(),
+    } as any, { hasUI: true, ui } as any);
+
+    await pendingCallbackRejection;
+    expect(result.ok).toBe(true);
+    expect(getAuthEntry("oauth-server")).toBeUndefined();
+    expect(close).toHaveBeenCalledWith("oauth-server");
+    expect(ui.notify).toHaveBeenCalledWith(expect.stringContaining("OAuth credentials cleared"), "info");
+  });
+
+  it("marks explicit OAuth servers as needs-auth when only stale URL tokens exist", async () => {
+    process.env.MCP_OAUTH_DIR = mkdtempSync(join(tmpdir(), "pi-mcp-commands-oauth-"));
+    const ui = createUi();
+    const { updateTokens } = await import("../mcp-auth.ts");
+    const { openMcpPanel } = await import("../commands.ts");
+
+    updateTokens("legacy", { accessToken: "legacy-token" });
+    updateTokens("stale", { accessToken: "stale-token" }, "https://old.example.com/mcp");
+
+    await openMcpPanel({
+      config: {
+        mcpServers: {
+          legacy: { url: "https://new.example.com/mcp", auth: "oauth" },
+          stale: { url: "https://new.example.com/mcp", auth: "oauth" },
+        },
+      },
+      manager: { getConnection: () => null },
+      toolMetadata: new Map(),
+      failureTracker: new Map(),
+    } as any, { getFlag: () => undefined } as any, { hasUI: true, ui } as any);
+
+    const callbacks = mocks.createMcpPanel.mock.calls[0]?.[3];
+    expect(callbacks.getConnectionStatus("legacy")).toBe("needs-auth");
+    expect(callbacks.getConnectionStatus("stale")).toBe("needs-auth");
+  });
+});

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

@@ -0,0 +1,303 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+
+function writeJson(path: string, value: unknown): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+
+describe("config discovery", () => {
+  const originalHome = process.env.HOME;
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    process.chdir(originalCwd);
+  });
+
+  it("loads standard MCP files first, then Pi overrides", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-config-home-"));
+    const project = mkdtempSync(join(tmpdir(), "pi-mcp-config-project-"));
+    process.env.HOME = home;
+    process.chdir(project);
+    const realProject = realpathSync(project);
+
+    writeJson(join(home, ".config", "mcp", "mcp.json"), {
+      settings: { idleTimeout: 5 },
+      mcpServers: {
+        shared: { command: "generic" },
+        genericOnly: { command: "generic-only" },
+      },
+    });
+
+    writeJson(join(home, ".pi", "agent", "mcp.json"), {
+      settings: { toolPrefix: "short", directTools: true },
+      mcpServers: {
+        shared: { command: "pi-global" },
+        piOnly: { command: "pi-only" },
+      },
+    });
+
+    writeJson(join(project, ".mcp.json"), {
+      settings: { toolPrefix: "none" },
+      mcpServers: {
+        shared: { command: "project" },
+        projectOnly: { command: "project-only" },
+      },
+    });
+
+    writeJson(join(project, ".pi", "mcp.json"), {
+      settings: { autoAuth: true },
+      mcpServers: {
+        shared: { command: "project-pi" },
+        projectPiOnly: { command: "project-pi-only" },
+      },
+    });
+
+    const { loadMcpConfig } = await import("../config.ts");
+    const config = loadMcpConfig();
+
+    expect(config.mcpServers.shared).toMatchObject({ command: "project-pi" });
+    expect(config.mcpServers.genericOnly).toMatchObject({ command: "generic-only" });
+    expect(config.mcpServers.piOnly).toMatchObject({ command: "pi-only" });
+    expect(config.mcpServers.projectOnly).toMatchObject({ command: "project-only" });
+    expect(config.mcpServers.projectPiOnly).toMatchObject({ command: "project-pi-only" });
+    expect(config.settings).toEqual({
+      idleTimeout: 5,
+      toolPrefix: "none",
+      directTools: true,
+      autoAuth: true,
+    });
+  });
+
+  it("prefers modern Claude Code config detection over legacy paths", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-import-home-"));
+    const project = mkdtempSync(join(tmpdir(), "pi-mcp-import-project-"));
+    process.env.HOME = home;
+    process.chdir(project);
+    const realProject = realpathSync(project);
+
+    writeJson(join(home, ".claude", "mcp.json"), { mcpServers: { modern: { command: "modern" } } });
+    writeJson(join(home, ".claude.json"), { mcpServers: { old: { command: "old" } } });
+    writeJson(join(project, ".vscode", "mcp.json"), { mcpServers: { editor: { command: "code" } } });
+
+    const { findAvailableImportConfigs } = await import("../config.ts");
+    const imports = findAvailableImportConfigs();
+
+    expect(imports).toEqual(
+      expect.arrayContaining([
+        { kind: "claude-code", path: join(home, ".claude", "mcp.json") },
+        { kind: "vscode", path: resolve(realProject, ".vscode", "mcp.json") },
+      ]),
+    );
+  });
+
+  it("tracks provenance so project servers write locally and shared/imported servers write to Pi config", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-provenance-home-"));
+    const project = mkdtempSync(join(tmpdir(), "pi-mcp-provenance-project-"));
+    process.env.HOME = home;
+    process.chdir(project);
+    const realProject = realpathSync(project);
+
+    writeJson(join(home, ".config", "mcp", "mcp.json"), {
+      mcpServers: {
+        genericServer: { command: "generic" },
+      },
+    });
+
+    writeJson(join(home, ".pi", "agent", "mcp.json"), {
+      imports: ["cursor"],
+      mcpServers: {
+        userServer: { command: "user" },
+      },
+    });
+
+    writeJson(join(home, ".cursor", "mcp.json"), {
+      mcpServers: {
+        importedServer: { command: "cursor" },
+      },
+    });
+
+    writeJson(join(project, ".mcp.json"), {
+      mcpServers: {
+        projectServer: { command: "project" },
+      },
+    });
+
+    writeJson(join(project, ".pi", "mcp.json"), {
+      mcpServers: {
+        projectPiServer: { command: "project-pi" },
+      },
+    });
+
+    const { getServerProvenance, getPiGlobalConfigPath } = await import("../config.ts");
+    const provenance = getServerProvenance();
+    const piConfigPath = getPiGlobalConfigPath();
+
+    expect(provenance.get("genericServer")).toEqual({
+      path: piConfigPath,
+      kind: "import",
+      importKind: "global MCP config",
+    });
+    expect(provenance.get("importedServer")).toEqual({
+      path: piConfigPath,
+      kind: "import",
+      importKind: "cursor",
+    });
+    expect(provenance.get("userServer")).toEqual({
+      path: piConfigPath,
+      kind: "user",
+      importKind: undefined,
+    });
+    expect(provenance.get("projectServer")).toEqual({
+      path: resolve(realProject, ".mcp.json"),
+      kind: "project",
+      importKind: undefined,
+    });
+    expect(provenance.get("projectPiServer")).toEqual({
+      path: resolve(realProject, ".pi", "mcp.json"),
+      kind: "project",
+      importKind: undefined,
+    });
+  });
+
+  it("summarizes discovery and detects RepoPrompt suggestions", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-summary-home-"));
+    const project = mkdtempSync(join(tmpdir(), "pi-mcp-summary-project-"));
+    process.env.HOME = home;
+    process.chdir(project);
+    const realProject = realpathSync(project);
+
+    writeJson(join(home, ".config", "mcp", "mcp.json"), {
+      mcpServers: {
+        sharedServer: { command: "shared" },
+      },
+    });
+
+    writeJson(join(project, "package.json"), { name: "fixture" });
+    writeJson(join(home, "RepoPrompt", "repoprompt_cli"), "#!/bin/sh\n");
+    writeJson(join(home, ".cursor", "mcp.json"), {
+      mcpServers: {
+        importedServer: { command: "cursor" },
+      },
+    });
+
+    const { getMcpDiscoverySummary } = await import("../config.ts");
+    const summary = getMcpDiscoverySummary();
+
+    expect(summary.hasSharedServers).toBe(true);
+    expect(summary.sources.find((source) => source.id === "shared-global")?.serverCount).toBe(1);
+    expect(summary.imports).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ kind: "cursor", serverCount: 1 }),
+      ]),
+    );
+    expect(summary.repoPrompt).toMatchObject({
+      configured: false,
+      executablePath: join(home, "RepoPrompt", "repoprompt_cli"),
+      targetPath: resolve(realProject, ".mcp.json"),
+      serverName: "repoprompt",
+    });
+  });
+
+  it("writes imported/global changes to Pi config and project changes to the project file", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-write-home-"));
+    const project = mkdtempSync(join(tmpdir(), "pi-mcp-write-project-"));
+    process.env.HOME = home;
+    process.chdir(project);
+
+    writeJson(join(home, ".config", "mcp", "mcp.json"), {
+      mcpServers: {
+        genericServer: { command: "generic" },
+      },
+    });
+
+    writeJson(join(home, ".pi", "agent", "mcp.json"), {
+      mcpServers: {},
+    });
+
+    writeJson(join(project, ".mcp.json"), {
+      mcpServers: {
+        projectServer: { command: "project" },
+      },
+    });
+
+    const { getServerProvenance, loadMcpConfig, writeDirectToolsConfig, getPiGlobalConfigPath } = await import("../config.ts");
+    const fullConfig = loadMcpConfig();
+    const provenance = getServerProvenance();
+
+    writeDirectToolsConfig(
+      new Map([
+        ["genericServer", true],
+        ["projectServer", ["search"]],
+      ]),
+      provenance,
+      fullConfig,
+    );
+
+    const userConfig = JSON.parse(readFileSync(getPiGlobalConfigPath(), "utf-8"));
+    expect(userConfig.mcpServers.genericServer).toMatchObject({ command: "generic", directTools: true });
+
+    const projectConfig = JSON.parse(readFileSync(join(project, ".mcp.json"), "utf-8"));
+    expect(projectConfig.mcpServers.projectServer).toMatchObject({ command: "project", directTools: ["search"] });
+  });
+
+  it("builds real diff previews for compatibility imports and shared server writes", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-preview-home-"));
+    const project = mkdtempSync(join(tmpdir(), "pi-mcp-preview-project-"));
+    process.env.HOME = home;
+    process.chdir(project);
+
+    writeJson(join(home, ".pi", "agent", "mcp.json"), {
+      imports: ["cursor"],
+      mcpServers: {
+        existing: { command: "demo" },
+      },
+    });
+
+    const {
+      previewCompatibilityImports,
+      previewSharedServerEntry,
+      getGenericGlobalConfigPath,
+    } = await import("../config.ts");
+
+    const importsPreview = previewCompatibilityImports(["cursor", "codex"]);
+    expect(importsPreview.path).toContain(".pi/agent/mcp.json");
+    expect(importsPreview.changed).toBe(true);
+    expect(importsPreview.diffText).toContain("+++ after");
+    expect(importsPreview.diffText).toContain('+     "codex"');
+
+    const sharedPreview = previewSharedServerEntry(getGenericGlobalConfigPath(), "repoprompt", {
+      command: "/tmp/repoprompt_cli",
+      args: [],
+      lifecycle: "lazy",
+    });
+    expect(sharedPreview.existed).toBe(false);
+    expect(sharedPreview.diffText).toContain('+   "mcpServers": {');
+    expect(sharedPreview.diffText).toContain('+     "repoprompt": {');
+  });
+
+  it("writes selected compatibility imports and a starter project config", async () => {
+    const home = mkdtempSync(join(tmpdir(), "pi-mcp-setup-home-"));
+    const project = mkdtempSync(join(tmpdir(), "pi-mcp-setup-project-"));
+    process.env.HOME = home;
+    process.chdir(project);
+
+    const { ensureCompatibilityImports, getPiGlobalConfigPath, writeStarterProjectConfig } = await import("../config.ts");
+    const importResult = ensureCompatibilityImports(["cursor", "codex"]);
+    expect(importResult.added).toEqual(["cursor", "codex"]);
+
+    const piConfig = JSON.parse(readFileSync(getPiGlobalConfigPath(), "utf-8"));
+    expect(piConfig.imports).toEqual(["cursor", "codex"]);
+
+    const starterPath = writeStarterProjectConfig();
+    const starter = JSON.parse(readFileSync(starterPath, "utf-8"));
+    expect(starter.mcpServers).toEqual({});
+  });
+});

package/mcp/__tests__/consent-manager.upstream-test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { ConsentManager, type ToolConsentMode } from "../consent-manager.ts";
+
+describe("ConsentManager", () => {
+  describe("mode: never", () => {
+    let manager: ConsentManager;
+
+    beforeEach(() => {
+      manager = new ConsentManager("never");
+    });
+
+    it("never requires prompt", () => {
+      expect(manager.requiresPrompt("any-server")).toBe(false);
+      expect(manager.requiresPrompt("another-server")).toBe(false);
+    });
+
+    it("should not cache consent", () => {
+      // "never" mode means no consent needed, so caching is irrelevant
+      // but the API returns true for consistency
+      expect(manager.shouldCacheConsent()).toBe(true);
+    });
+
+    it("ensureApproved never throws", () => {
+      expect(() => manager.ensureApproved("any-server")).not.toThrow();
+    });
+
+    it("registering denial has no effect", () => {
+      manager.registerDecision("test-server", false);
+      expect(manager.requiresPrompt("test-server")).toBe(false);
+      expect(() => manager.ensureApproved("test-server")).not.toThrow();
+    });
+  });
+
+  describe("mode: once-per-server (default)", () => {
+    let manager: ConsentManager;
+
+    beforeEach(() => {
+      manager = new ConsentManager("once-per-server");
+    });
+
+    it("requires prompt for new servers", () => {
+      expect(manager.requiresPrompt("server-a")).toBe(true);
+      expect(manager.requiresPrompt("server-b")).toBe(true);
+    });
+
+    it("does not require prompt after approval", () => {
+      manager.registerDecision("server-a", true);
+      expect(manager.requiresPrompt("server-a")).toBe(false);
+      // Other servers still require prompt
+      expect(manager.requiresPrompt("server-b")).toBe(true);
+    });
+
+    it("requires prompt after denial", () => {
+      manager.registerDecision("server-a", false);
+      expect(manager.requiresPrompt("server-a")).toBe(true);
+    });
+
+    it("should cache consent", () => {
+      expect(manager.shouldCacheConsent()).toBe(true);
+    });
+
+    it("ensureApproved throws for unapproved server", () => {
+      expect(() => manager.ensureApproved("server-a")).toThrow(
+        'Tool call approval required for "server-a"'
+      );
+    });
+
+    it("ensureApproved throws for denied server", () => {
+      manager.registerDecision("server-a", false);
+      expect(() => manager.ensureApproved("server-a")).toThrow(
+        'Tool calls for "server-a" were denied for this session'
+      );
+    });
+
+    it("ensureApproved succeeds after approval", () => {
+      manager.registerDecision("server-a", true);
+      expect(() => manager.ensureApproved("server-a")).not.toThrow();
+    });
+
+    it("approval overrides previous denial", () => {
+      manager.registerDecision("server-a", false);
+      manager.registerDecision("server-a", true);
+      expect(manager.requiresPrompt("server-a")).toBe(false);
+      expect(() => manager.ensureApproved("server-a")).not.toThrow();
+    });
+
+    it("denial overrides previous approval", () => {
+      manager.registerDecision("server-a", true);
+      manager.registerDecision("server-a", false);
+      expect(manager.requiresPrompt("server-a")).toBe(true);
+      expect(() => manager.ensureApproved("server-a")).toThrow();
+    });
+  });
+
+  describe("mode: always", () => {
+    let manager: ConsentManager;
+
+    beforeEach(() => {
+      manager = new ConsentManager("always");
+    });
+
+    it("always requires prompt", () => {
+      expect(manager.requiresPrompt("server-a")).toBe(true);
+    });
+
+    it("still requires prompt after approval", () => {
+      manager.registerDecision("server-a", true);
+      expect(manager.requiresPrompt("server-a")).toBe(true);
+    });
+
+    it("should not cache consent", () => {
+      expect(manager.shouldCacheConsent()).toBe(false);
+    });
+
+    it("ensureApproved consumes the approval", () => {
+      manager.registerDecision("server-a", true);
+      // First call succeeds
+      expect(() => manager.ensureApproved("server-a")).not.toThrow();
+      // Second call fails (approval was consumed)
+      expect(() => manager.ensureApproved("server-a")).toThrow(
+        'Tool call approval required for "server-a"'
+      );
+    });
+  });
+
+  describe("clear", () => {
+    let manager: ConsentManager;
+
+    beforeEach(() => {
+      manager = new ConsentManager("once-per-server");
+      manager.registerDecision("server-a", true);
+      manager.registerDecision("server-b", false);
+    });
+
+    it("clears specific server", () => {
+      manager.clear("server-a");
+      expect(manager.requiresPrompt("server-a")).toBe(true);
+      // server-b unchanged
+      expect(() => manager.ensureApproved("server-b")).toThrow(/denied/);
+    });
+
+    it("clears all servers", () => {
+      manager.clear();
+      expect(manager.requiresPrompt("server-a")).toBe(true);
+      expect(manager.requiresPrompt("server-b")).toBe(true);
+      // Neither approved nor denied
+      expect(() => manager.ensureApproved("server-a")).toThrow(/approval required/);
+      expect(() => manager.ensureApproved("server-b")).toThrow(/approval required/);
+    });
+  });
+});