pi-soly 1.9.3 → 1.11.0

package/mcp/__tests__/direct-tools-auto-auth.upstream-test.ts

@@ -0,0 +1,218 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  lazyConnect: vi.fn(),
+  getFailureAgeSeconds: vi.fn(),
+  authenticate: vi.fn(),
+  supportsOAuth: vi.fn(),
+}));
+
+vi.mock("../init.ts", () => ({
+  lazyConnect: mocks.lazyConnect,
+  getFailureAgeSeconds: mocks.getFailureAgeSeconds,
+}));
+
+vi.mock("../mcp-auth-flow.ts", () => ({
+  authenticate: mocks.authenticate,
+  supportsOAuth: mocks.supportsOAuth,
+}));
+
+describe("direct tools auto auth", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    mocks.lazyConnect.mockReset();
+    mocks.getFailureAgeSeconds.mockReset().mockReturnValue(null);
+    mocks.authenticate.mockReset().mockResolvedValue("authenticated");
+    mocks.supportsOAuth.mockReset().mockReturnValue(true);
+  });
+
+  it("auto-authenticates and retries direct tool execution once", async () => {
+    const { createDirectToolExecutor } = await import("../direct-tools.ts");
+
+    let connection: any = { status: "needs-auth" };
+    const connected = {
+      status: "connected",
+      client: {
+        callTool: vi.fn(async () => ({
+          isError: false,
+          content: [{ type: "text", text: "ok" }],
+        })),
+      },
+    };
+
+    mocks.lazyConnect
+      .mockImplementationOnce(async () => false)
+      .mockImplementationOnce(async () => {
+        connection = connected;
+        return true;
+      });
+
+    const state = {
+      config: {
+        settings: { autoAuth: true },
+        mcpServers: {
+          demo: { url: "https://api.example.com/mcp", auth: "oauth" },
+        },
+      },
+      manager: {
+        close: vi.fn(async () => {
+          connection = undefined;
+        }),
+        getConnection: vi.fn(() => connection),
+        touch: vi.fn(),
+        incrementInFlight: vi.fn(),
+        decrementInFlight: vi.fn(),
+      },
+      failureTracker: new Map(),
+      ui: { setStatus: vi.fn() },
+      completedUiSessions: [],
+    } as any;
+
+    const executor = createDirectToolExecutor(
+      () => state,
+      () => null,
+      {
+        serverName: "demo",
+        originalName: "search",
+        prefixedName: "demo_search",
+        description: "Search",
+      },
+    );
+
+    const result = await executor("id", { q: "hello" }, undefined as any, () => {}, undefined as any);
+
+    expect(mocks.authenticate).toHaveBeenCalledWith(
+      "demo",
+      "https://api.example.com/mcp",
+      state.config.mcpServers.demo,
+    );
+    expect(state.manager.close).toHaveBeenCalledWith("demo");
+    expect(result.content[0].text).toContain("ok");
+  });
+
+  it("fails fast in non-ui context for browser-based OAuth", async () => {
+    const { createDirectToolExecutor } = await import("../direct-tools.ts");
+
+    const state = {
+      config: {
+        settings: { autoAuth: true },
+        mcpServers: {
+          demo: { url: "https://api.example.com/mcp", auth: "oauth" },
+        },
+      },
+      manager: {
+        close: vi.fn(async () => {}),
+        getConnection: vi.fn(() => ({ status: "needs-auth" })),
+        touch: vi.fn(),
+        incrementInFlight: vi.fn(),
+        decrementInFlight: vi.fn(),
+      },
+      failureTracker: new Map(),
+      ui: undefined,
+      completedUiSessions: [],
+    } as any;
+
+    mocks.lazyConnect.mockResolvedValue(false);
+
+    const executor = createDirectToolExecutor(
+      () => state,
+      () => null,
+      {
+        serverName: "demo",
+        originalName: "search",
+        prefixedName: "demo_search",
+        description: "Search",
+      },
+    );
+
+    const result = await executor("id", {}, undefined as any, () => {}, undefined as any);
+
+    expect(mocks.authenticate).not.toHaveBeenCalled();
+    expect(result.content[0].text).toContain("auth-start");
+    expect(result.content[0].text).toContain("/mcp-auth demo");
+  });
+
+  it("runs URL elicitations returned by a URL-required tool error", async () => {
+    const { UrlElicitationRequiredError } = await import("@modelcontextprotocol/sdk/types.js");
+    const { createDirectToolExecutor } = await import("../direct-tools.ts");
+    const error = new UrlElicitationRequiredError([{
+      mode: "url",
+      message: "Connect your account",
+      elicitationId: "connect-1",
+      url: "https://example.com/connect",
+    }]);
+    const connection = {
+      status: "connected",
+      client: { callTool: vi.fn().mockRejectedValue(error) },
+    };
+    const state = {
+      config: { settings: {}, mcpServers: { demo: { command: "demo" } } },
+      manager: {
+        getConnection: vi.fn(() => connection),
+        handleUrlElicitationRequired: vi.fn().mockResolvedValue("accept"),
+        touch: vi.fn(),
+        incrementInFlight: vi.fn(),
+        decrementInFlight: vi.fn(),
+      },
+      failureTracker: new Map(),
+      completedUiSessions: [],
+    } as any;
+    mocks.lazyConnect.mockResolvedValue(true);
+
+    const executor = createDirectToolExecutor(() => state, () => null, {
+      serverName: "demo",
+      originalName: "search",
+      prefixedName: "demo_search",
+      description: "Search",
+    });
+    const result = await executor("id", {}, undefined, undefined, undefined as any);
+
+    expect(state.manager.handleUrlElicitationRequired).toHaveBeenCalledWith("demo", error);
+    expect(result.details).toMatchObject({ error: "url_elicitation_required", action: "accept" });
+    expect(result.content[0].text).toContain("retry the tool");
+  });
+
+  it("uses custom authRequiredMessage in non-ui direct tool auth failures", async () => {
+    const { createDirectToolExecutor } = await import("../direct-tools.ts");
+
+    const state = {
+      config: {
+        settings: {
+          autoAuth: true,
+          authRequiredMessage: "Reconnect ${server} from the host app.",
+        },
+        mcpServers: {
+          demo: { url: "https://api.example.com/mcp", auth: "oauth" },
+        },
+      },
+      manager: {
+        close: vi.fn(async () => {}),
+        getConnection: vi.fn(() => ({ status: "needs-auth" })),
+        touch: vi.fn(),
+        incrementInFlight: vi.fn(),
+        decrementInFlight: vi.fn(),
+      },
+      failureTracker: new Map(),
+      ui: undefined,
+      completedUiSessions: [],
+    } as any;
+
+    mocks.lazyConnect.mockResolvedValue(false);
+
+    const executor = createDirectToolExecutor(
+      () => state,
+      () => null,
+      {
+        serverName: "demo",
+        originalName: "search",
+        prefixedName: "demo_search",
+        description: "Search",
+      },
+    );
+
+    const result = await executor("id", {}, undefined as any, () => {}, undefined as any);
+
+    expect(mocks.authenticate).not.toHaveBeenCalled();
+    expect(result.content[0].text).toBe("Reconnect demo from the host app.");
+  });
+});

package/mcp/__tests__/direct-tools.upstream-test.ts

@@ -0,0 +1,299 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { buildProxyDescription, resolveDirectTools } from "../direct-tools.ts";
+import { computeServerHash, isServerCacheValid, type MetadataCache } from "../metadata-cache.ts";
+import { buildToolMetadata } from "../tool-metadata.ts";
+import type { McpConfig } from "../types.ts";
+import { reconstructToolMetadata } from "../metadata-cache.ts";
+
+const originalHashEnv = {
+  MCP_HASH_CWD: process.env.MCP_HASH_CWD,
+  MCP_HASH_ENV: process.env.MCP_HASH_ENV,
+  MCP_HASH_HEADER: process.env.MCP_HASH_HEADER,
+  MCP_HASH_TOKEN: process.env.MCP_HASH_TOKEN,
+};
+
+afterEach(() => {
+  for (const [key, value] of Object.entries(originalHashEnv)) {
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+});
+
+describe("buildProxyDescription", () => {
+  it("documents the ui-messages action", () => {
+    const config: McpConfig = {
+      mcpServers: {
+        demo: {
+          command: "npx",
+          args: ["-y", "demo-server"],
+        },
+      },
+    };
+
+    const cache: MetadataCache = {
+      version: 1,
+      servers: {
+        demo: {
+          configHash: "hash",
+          cachedAt: Date.now(),
+          tools: [
+            {
+              name: "launch_app",
+              description: "Launch the demo app",
+              inputSchema: { type: "object", properties: {} },
+            },
+          ],
+          resources: [],
+        },
+      },
+    };
+
+    const description = buildProxyDescription(config, cache, []);
+
+    expect(description).toContain('mcp({ action: "ui-messages" })');
+    expect(description).toContain("Retrieve accumulated messages from completed UI sessions");
+    expect(description).toContain("Search MCP tools by name/description");
+    expect(description).toContain("Non-MCP Pi tools should be called directly, not through mcp.");
+    expect(description).not.toContain("MCP + pi");
+  });
+
+  it("excludes configured tools from proxy summaries", () => {
+    const config: McpConfig = {
+      settings: { toolPrefix: "server" },
+      mcpServers: {
+        figma: {
+          command: "npx",
+          args: ["-y", "figma"],
+          excludeTools: ["get_figjam", "figma_get_screenshot"],
+        },
+      },
+    };
+
+    const cache: MetadataCache = {
+      version: 1,
+      servers: {
+        figma: {
+          configHash: computeServerHash(config.mcpServers.figma),
+          cachedAt: Date.now(),
+          tools: [
+            { name: "get_screenshot", description: "Take screenshot" },
+            { name: "get_nodes", description: "Get nodes" },
+          ],
+          resources: [
+            { name: "figjam", uri: "ui://figjam", description: "FigJam" },
+          ],
+        },
+      },
+    };
+
+    const description = buildProxyDescription(config, cache, []);
+
+    expect(description).toContain("Servers: figma (1 tools)");
+    expect(description).not.toContain("figma (3 tools)");
+  });
+});
+
+describe("metadata cache hashing", () => {
+  it("hashes interpolated cwd", () => {
+    process.env.MCP_HASH_CWD = "/tmp/mcp-one";
+    const first = computeServerHash({ command: "node", cwd: "${MCP_HASH_CWD}/server" });
+
+    process.env.MCP_HASH_CWD = "/tmp/mcp-two";
+    const second = computeServerHash({ command: "node", cwd: "${MCP_HASH_CWD}/server" });
+
+    expect(first).not.toBe(second);
+    expect(computeServerHash({ command: "node", cwd: "${MCP_HASH_CWD}/server" })).toBe(
+      computeServerHash({ command: "node", cwd: "/tmp/mcp-two/server" }),
+    );
+  });
+
+  it("hashes interpolated env values", () => {
+    process.env.MCP_HASH_ENV = "/tmp/data-one";
+    const first = computeServerHash({ command: "node", env: { DATA_DIR: "${MCP_HASH_ENV}" } });
+
+    process.env.MCP_HASH_ENV = "/tmp/data-two";
+    const second = computeServerHash({ command: "node", env: { DATA_DIR: "${MCP_HASH_ENV}" } });
+
+    expect(first).not.toBe(second);
+    expect(computeServerHash({ command: "node", env: { DATA_DIR: "${MCP_HASH_ENV}" } })).toBe(
+      computeServerHash({ command: "node", env: { DATA_DIR: "/tmp/data-two" } }),
+    );
+  });
+
+  it("hashes interpolated header values", () => {
+    process.env.MCP_HASH_HEADER = "header-one";
+    const first = computeServerHash({ url: "https://example.test/mcp", headers: { "x-root": "$env:MCP_HASH_HEADER" } });
+
+    process.env.MCP_HASH_HEADER = "header-two";
+    const second = computeServerHash({ url: "https://example.test/mcp", headers: { "x-root": "$env:MCP_HASH_HEADER" } });
+
+    expect(first).not.toBe(second);
+    expect(computeServerHash({ url: "https://example.test/mcp", headers: { "x-root": "$env:MCP_HASH_HEADER" } })).toBe(
+      computeServerHash({ url: "https://example.test/mcp", headers: { "x-root": "header-two" } }),
+    );
+  });
+
+  it("hashes tilde cwd as the home directory", () => {
+    expect(computeServerHash({ command: "node", cwd: "~/server" })).toBe(
+      computeServerHash({ command: "node", cwd: join(homedir(), "server") }),
+    );
+  });
+
+  it("hashes the effective bearerTokenEnv value", () => {
+    process.env.MCP_HASH_TOKEN = "token-one";
+    const first = computeServerHash({ url: "https://example.test/mcp", auth: "bearer", bearerTokenEnv: "MCP_HASH_TOKEN" });
+
+    process.env.MCP_HASH_TOKEN = "token-two";
+    const second = computeServerHash({ url: "https://example.test/mcp", auth: "bearer", bearerTokenEnv: "MCP_HASH_TOKEN" });
+
+    expect(first).not.toBe(second);
+    expect(computeServerHash({ url: "https://example.test/mcp", auth: "bearer", bearerTokenEnv: "MCP_HASH_TOKEN" })).toBe(
+      computeServerHash({ url: "https://example.test/mcp", auth: "bearer", bearerToken: "token-two", bearerTokenEnv: "MCP_HASH_TOKEN" }),
+    );
+  });
+
+  it("hashes interpolated bearerToken values", () => {
+    process.env.MCP_HASH_TOKEN = "token-one";
+    const first = computeServerHash({ url: "https://example.test/mcp", auth: "bearer", bearerToken: "${MCP_HASH_TOKEN}" });
+
+    process.env.MCP_HASH_TOKEN = "token-two";
+    const second = computeServerHash({ url: "https://example.test/mcp", auth: "bearer", bearerToken: "${MCP_HASH_TOKEN}" });
+
+    expect(first).not.toBe(second);
+    expect(computeServerHash({ url: "https://example.test/mcp", auth: "bearer", bearerToken: "$env:MCP_HASH_TOKEN" })).toBe(
+      computeServerHash({ url: "https://example.test/mcp", auth: "bearer", bearerToken: "token-two" }),
+    );
+  });
+
+  it("invalidates cached metadata when an interpolated bearerToken env value changes", () => {
+    const definition = { url: "https://example.test/mcp", auth: "bearer" as const, bearerToken: "${MCP_HASH_TOKEN}" };
+    process.env.MCP_HASH_TOKEN = "token-one";
+    const entry = {
+      configHash: computeServerHash(definition),
+      cachedAt: Date.now(),
+      tools: [],
+      resources: [],
+    };
+
+    expect(isServerCacheValid(entry, definition)).toBe(true);
+
+    process.env.MCP_HASH_TOKEN = "token-two";
+
+    expect(isServerCacheValid(entry, definition)).toBe(false);
+  });
+});
+
+describe("excludeTools filtering", () => {
+  it("filters excluded tools from live and cached metadata", () => {
+    const definition = {
+      command: "npx",
+      args: ["-y", "figma"],
+      excludeTools: ["figma_get_screenshot", "get_figjam"],
+    };
+
+    const { metadata } = buildToolMetadata(
+      [
+        { name: "get_screenshot", description: "Screenshot" },
+        { name: "get_nodes", description: "Nodes" },
+      ] as any,
+      [
+        { name: "figjam", uri: "ui://figjam", description: "FigJam" },
+      ] as any,
+      definition,
+      "figma",
+      "server",
+    );
+
+    expect(metadata.map((tool) => tool.name)).toEqual(["figma_get_nodes"]);
+
+    const reconstructed = reconstructToolMetadata(
+      "figma",
+      {
+        configHash: computeServerHash(definition),
+        cachedAt: Date.now(),
+        tools: [
+          { name: "get_screenshot", description: "Screenshot" },
+          { name: "get_nodes", description: "Nodes" },
+        ],
+        resources: [{ name: "figjam", uri: "ui://figjam", description: "FigJam" }],
+      },
+      "server",
+      definition,
+    );
+
+    expect(reconstructed.map((tool) => tool.name)).toEqual(["figma_get_nodes"]);
+  });
+
+  it("filters excluded tools during direct tool registration from cache", () => {
+    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 specs = resolveDirectTools(config, cache, "server");
+
+    expect(specs.map((spec) => spec.prefixedName)).toEqual(["figma_get_nodes"]);
+  });
+
+  it("matches prefixed exclusions even when toolPrefix is none", () => {
+    const config: McpConfig = {
+      settings: { toolPrefix: "none" },
+      mcpServers: {
+        figma: {
+          command: "npx",
+          args: ["-y", "figma"],
+          directTools: true,
+          excludeTools: ["figma_get_screenshot"],
+        },
+      },
+    };
+
+    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: [],
+        },
+      },
+    };
+
+    const specs = resolveDirectTools(config, cache, "none");
+
+    expect(specs.map((spec) => spec.prefixedName)).toEqual(["get_nodes"]);
+  });
+});