@lobu/gateway 3.0.5 → 3.0.6

package/src/__tests__/mcp-config-service.test.ts

@@ -0,0 +1,347 @@
+// Set ENCRYPTION_KEY before any imports that use encryption
+process.env.ENCRYPTION_KEY =
+  "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+
+import { describe, expect, test } from "bun:test";
+import { generateWorkerToken } from "@lobu/core";
+import { McpConfigService } from "../auth/mcp/config-service";
+
+function makeToken(agentId = "agent1") {
+  return generateWorkerToken("user1", "conv1", "deploy1", {
+    channelId: "ch1",
+    agentId,
+  });
+}
+
+const BASE_URL = "http://localhost:8080/mcp";
+
+describe("McpConfigService", () => {
+  test("registerGlobalServers - HTTP + stdio", async () => {
+    const service = new McpConfigService();
+    service.registerGlobalServers({
+      "http-server": {
+        url: "https://upstream.example.com/mcp",
+        type: "sse",
+      },
+      "stdio-server": {
+        command: "node",
+        args: ["server.js"],
+        type: "stdio",
+      },
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: makeToken(),
+    });
+
+    // HTTP server should be rewritten
+    expect(config.mcpServers["http-server"]).toBeDefined();
+    expect(config.mcpServers["http-server"].url).toBe(BASE_URL);
+    expect(config.mcpServers["http-server"].type).toBe("sse");
+
+    // Stdio server should be unchanged
+    expect(config.mcpServers["stdio-server"]).toBeDefined();
+    expect(config.mcpServers["stdio-server"].command).toBe("node");
+    expect(config.mcpServers["stdio-server"].args).toEqual(["server.js"]);
+    expect(config.mcpServers["stdio-server"].type).toBe("stdio");
+  });
+
+  test("registerGlobalServers - skip duplicates", async () => {
+    const service = new McpConfigService();
+    service.registerGlobalServers({
+      "my-mcp": { url: "https://first.example.com/mcp", type: "sse" },
+    });
+    service.registerGlobalServers({
+      "my-mcp": { url: "https://second.example.com/mcp", type: "sse" },
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: makeToken(),
+    });
+
+    // Only first registration should stick (url gets rewritten to baseUrl,
+    // but the httpServer entry should reflect the first upstream)
+    expect(config.mcpServers["my-mcp"]).toBeDefined();
+    const servers = await service.getAllHttpServers();
+    expect(servers.get("my-mcp")?.upstreamUrl).toBe(
+      "https://first.example.com/mcp"
+    );
+  });
+
+  test("getWorkerConfig - rewrites HTTP URLs", async () => {
+    const service = new McpConfigService();
+    const token = makeToken();
+    service.registerGlobalServers({
+      "test-mcp": { url: "https://upstream.example.com/mcp", type: "sse" },
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: token,
+    });
+
+    const mcp = config.mcpServers["test-mcp"];
+    expect(mcp.url).toBe(BASE_URL);
+    expect(mcp.type).toBe("sse");
+    expect(mcp.headers.Authorization).toBe(`Bearer ${token}`);
+    expect(mcp.headers["X-Mcp-Id"]).toBe("test-mcp");
+  });
+
+  test("getWorkerConfig - preserves custom headers", async () => {
+    const service = new McpConfigService();
+    const token = makeToken();
+    service.registerGlobalServers({
+      "custom-mcp": {
+        url: "https://upstream.example.com/mcp",
+        type: "sse",
+        headers: { "X-Custom": "value", "X-Another": "data" },
+      },
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: token,
+    });
+
+    const headers = config.mcpServers["custom-mcp"].headers;
+    expect(headers["X-Custom"]).toBe("value");
+    expect(headers["X-Another"]).toBe("data");
+    expect(headers.Authorization).toBe(`Bearer ${token}`);
+    expect(headers["X-Mcp-Id"]).toBe("custom-mcp");
+  });
+
+  test("getWorkerConfig - includes stdio without rewriting", async () => {
+    const service = new McpConfigService();
+    service.registerGlobalServers({
+      "stdio-mcp": {
+        command: "python",
+        args: ["-m", "mcp_server"],
+        type: "stdio",
+      },
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: makeToken(),
+    });
+
+    const mcp = config.mcpServers["stdio-mcp"];
+    expect(mcp.command).toBe("python");
+    expect(mcp.args).toEqual(["-m", "mcp_server"]);
+    expect(mcp.type).toBe("stdio");
+    expect(mcp.headers).toBeUndefined();
+  });
+
+  test("getWorkerConfig - merges per-agent MCPs", async () => {
+    const mockAgentSettingsStore = {
+      getSettings: async (agentId: string) => {
+        if (agentId === "agent1") {
+          return {
+            mcpServers: {
+              "agent-mcp": {
+                url: "https://agent-mcp.example.com/mcp",
+                type: "sse",
+              },
+            },
+          };
+        }
+        return null;
+      },
+    };
+
+    const service = new McpConfigService({
+      agentSettingsStore: mockAgentSettingsStore as any,
+    });
+    service.registerGlobalServers({
+      "global-mcp": { url: "https://global.example.com/mcp", type: "sse" },
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: makeToken("agent1"),
+    });
+
+    expect(config.mcpServers["global-mcp"]).toBeDefined();
+    expect(config.mcpServers["agent-mcp"]).toBeDefined();
+    expect(config.mcpServers["agent-mcp"].url).toBe(BASE_URL);
+    expect(config.mcpServers["agent-mcp"].perAgent).toBe(true);
+  });
+
+  test("getWorkerConfig - rejects invalid tokens", async () => {
+    const service = new McpConfigService();
+    service.registerGlobalServers({
+      "test-mcp": { url: "https://upstream.example.com/mcp", type: "sse" },
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: "invalid-garbage-token",
+    });
+
+    expect(Object.keys(config.mcpServers)).toHaveLength(0);
+  });
+
+  test("getWorkerConfig - skips disabled MCPs", async () => {
+    const mockAgentSettingsStore = {
+      getSettings: async () => ({
+        mcpServers: {
+          "disabled-mcp": {
+            url: "https://disabled.example.com/mcp",
+            type: "sse",
+            enabled: false,
+          },
+          "enabled-mcp": {
+            url: "https://enabled.example.com/mcp",
+            type: "sse",
+          },
+        },
+      }),
+    };
+
+    const service = new McpConfigService({
+      agentSettingsStore: mockAgentSettingsStore as any,
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: makeToken("agent1"),
+    });
+
+    expect(config.mcpServers["disabled-mcp"]).toBeUndefined();
+    expect(config.mcpServers["enabled-mcp"]).toBeDefined();
+  });
+
+  test("getWorkerConfig - global takes precedence over per-agent", async () => {
+    const mockAgentSettingsStore = {
+      getSettings: async () => ({
+        mcpServers: {
+          "shared-mcp": {
+            url: "https://agent-version.example.com/mcp",
+            type: "sse",
+          },
+        },
+      }),
+    };
+
+    const service = new McpConfigService({
+      agentSettingsStore: mockAgentSettingsStore as any,
+    });
+    service.registerGlobalServers({
+      "shared-mcp": {
+        url: "https://global-version.example.com/mcp",
+        type: "sse",
+      },
+    });
+
+    const config = await service.getWorkerConfig({
+      baseUrl: BASE_URL,
+      workerToken: makeToken("agent1"),
+    });
+
+    // Global should win - no perAgent flag
+    expect(config.mcpServers["shared-mcp"]).toBeDefined();
+    expect(config.mcpServers["shared-mcp"].perAgent).toBeUndefined();
+  });
+
+  test("getMcpStatus - returns correct auth and input flags", async () => {
+    const service = new McpConfigService();
+    service.registerGlobalServers({
+      "oauth-mcp": {
+        url: "https://oauth.example.com/mcp",
+        type: "sse",
+        oauth: { clientId: "abc" },
+      },
+      "login-mcp": {
+        url: "https://login.example.com/mcp",
+        type: "sse",
+        loginUrl: "https://login.example.com/auth",
+      },
+      "input-mcp": {
+        url: "https://input.example.com/mcp",
+        type: "sse",
+        inputs: [
+          { type: "promptString", id: "api_key", description: "API key" },
+        ],
+      },
+      "plain-mcp": {
+        url: "https://plain.example.com/mcp",
+        type: "sse",
+      },
+    });
+
+    const statuses = await service.getMcpStatus("agent1");
+
+    const oauthStatus = statuses.find((s) => s.id === "oauth-mcp");
+    expect(oauthStatus?.requiresAuth).toBe(true);
+    expect(oauthStatus?.requiresInput).toBe(false);
+
+    const loginStatus = statuses.find((s) => s.id === "login-mcp");
+    expect(loginStatus?.requiresAuth).toBe(true);
+
+    const inputStatus = statuses.find((s) => s.id === "input-mcp");
+    expect(inputStatus?.requiresInput).toBe(true);
+    expect(inputStatus?.requiresAuth).toBe(false);
+
+    const plainStatus = statuses.find((s) => s.id === "plain-mcp");
+    expect(plainStatus?.requiresAuth).toBe(false);
+    expect(plainStatus?.requiresInput).toBe(false);
+  });
+
+  test("getAllHttpServers - merges global + per-agent, excludes disabled and non-HTTP", async () => {
+    const mockAgentSettingsStore = {
+      getSettings: async () => ({
+        mcpServers: {
+          "agent-http": {
+            url: "https://agent-http.example.com/mcp",
+            type: "sse",
+          },
+          "agent-stdio": {
+            command: "node",
+            args: ["server.js"],
+            type: "stdio",
+          },
+          "agent-disabled": {
+            url: "https://disabled.example.com/mcp",
+            type: "sse",
+            enabled: false,
+          },
+        },
+      }),
+    };
+
+    const service = new McpConfigService({
+      agentSettingsStore: mockAgentSettingsStore as any,
+    });
+    service.registerGlobalServers({
+      "global-http": { url: "https://global.example.com/mcp", type: "sse" },
+    });
+
+    const servers = await service.getAllHttpServers("agent1");
+
+    expect(servers.has("global-http")).toBe(true);
+    expect(servers.has("agent-http")).toBe(true);
+    expect(servers.has("agent-stdio")).toBe(false);
+    expect(servers.has("agent-disabled")).toBe(false);
+  });
+
+  test("getGlobalMcpServers - returns settings-compatible format", async () => {
+    const service = new McpConfigService();
+    service.registerGlobalServers({
+      "http-mcp": { url: "https://example.com/mcp", type: "sse" },
+      "stdio-mcp": { command: "node", args: ["s.js"], type: "stdio" },
+    });
+
+    const result = await service.getGlobalMcpServers();
+
+    expect(result["http-mcp"]).toEqual({
+      url: "https://example.com/mcp",
+      type: "sse",
+    });
+    expect(result["stdio-mcp"]).toEqual({
+      url: undefined,
+      type: "stdio",
+    });
+  });
+});