mcpico 0.1.1 → 0.2.0

package/src/server.test.ts

@@ -0,0 +1,324 @@
+import { describe, it, expect, vi } from "vitest";
+import { textResult, mergeGroups, handleToolCall, validateAllServerConfigs, buildGroupDescription } from "./server.js";
+import type { ToolGroup } from "./grouper.js";
+import type { DiscoveredServer, UpstreamTool } from "./discoverer.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+
+function makeTool(overrides: Partial<UpstreamTool> = {}): UpstreamTool {
+  return {
+    name: "test_tool",
+    description: "A test tool",
+    inputSchema: { type: "object", properties: {} },
+    ...overrides,
+  };
+}
+
+function makeGroup(overrides: Partial<ToolGroup> = {}): ToolGroup {
+  return {
+    groupName: "test_group",
+    serverName: "test-server",
+    tools: [makeTool()],
+    ...overrides,
+  };
+}
+
+function makeServer(overrides: Partial<DiscoveredServer> = {}): DiscoveredServer {
+  return {
+    name: "test-server",
+    tools: [makeTool()],
+    resources: [],
+    prompts: [],
+    client: {} as any,
+    ...overrides,
+  };
+}
+
+function makeTextResult(text: string): CallToolResult {
+  return { content: [{ type: "text", text }] };
+}
+
+describe("textResult", () => {
+  it("wraps text in content array", () => {
+    const result = textResult("hello");
+    expect(result).toEqual({
+      content: [{ type: "text", text: "hello" }],
+    });
+  });
+
+  it("handles empty string", () => {
+    const result = textResult("");
+    expect(result).toEqual({
+      content: [{ type: "text", text: "" }],
+    });
+  });
+});
+
+describe("mergeGroups", () => {
+  it("returns empty map for empty input", () => {
+    const result = mergeGroups([]);
+    expect(result.size).toBe(0);
+  });
+
+  it("preserves single group", () => {
+    const group = makeGroup({ groupName: "filesystem" });
+    const result = mergeGroups([group]);
+    expect(result.size).toBe(1);
+    const entry = result.get("filesystem")!;
+    expect(entry.groupName).toBe("filesystem");
+    expect(entry.tools).toHaveLength(1);
+  });
+
+  it("keeps different groups separate", () => {
+    const groups = [
+      makeGroup({ groupName: "filesystem" }),
+      makeGroup({ groupName: "database" }),
+    ];
+    const result = mergeGroups(groups);
+    expect(result.size).toBe(2);
+    expect(result.has("filesystem")).toBe(true);
+    expect(result.has("database")).toBe(true);
+  });
+
+  it("merges groups with same name across servers", () => {
+    const groups = [
+      makeGroup({
+        groupName: "filesystem",
+        serverName: "server-a",
+        tools: [makeTool({ name: "read" })],
+      }),
+      makeGroup({
+        groupName: "filesystem",
+        serverName: "server-b",
+        tools: [makeTool({ name: "write" })],
+      }),
+    ];
+    const result = mergeGroups(groups);
+    expect(result.size).toBe(1);
+    const merged = result.get("filesystem")!;
+    expect(merged.tools).toHaveLength(2);
+    expect(merged.tools.map((t) => t.name)).toEqual(["read", "write"]);
+    expect(merged.serverName).toContain("server-a");
+    expect(merged.serverName).toContain("server-b");
+  });
+
+  it("does not duplicate server name when already present", () => {
+    const groups = [
+      makeGroup({
+        groupName: "filesystem",
+        serverName: "server-a + server-b",
+        tools: [makeTool({ name: "read" })],
+      }),
+      makeGroup({
+        groupName: "filesystem",
+        serverName: "server-b",
+        tools: [makeTool({ name: "write" })],
+      }),
+    ];
+    const result = mergeGroups(groups);
+    const merged = result.get("filesystem")!;
+    // server-b is already in "server-a + server-b", should not be added again
+    expect(merged.serverName).toBe("server-a + server-b");
+  });
+});
+
+describe("validateAllServerConfigs", () => {
+  it("returns empty for valid configs", () => {
+    const errors = validateAllServerConfigs([
+      { name: "server-a", transport: { type: "stdio" as const, command: "echo" } },
+    ]);
+    expect(errors).toEqual([]);
+  });
+
+  it("returns errors for invalid configs", () => {
+    const errors = validateAllServerConfigs([
+      { name: "", transport: { type: "stdio" as const, command: "" } },
+    ]);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it("validates multiple configs and collects all errors", () => {
+    const errors = validateAllServerConfigs([
+      { name: "", transport: { type: "stdio" as const, command: "" } },
+      { name: "missing-transport" } as any,
+    ]);
+    expect(errors.length).toBe(2);
+  });
+
+  it("handles empty servers array", () => {
+    const errors = validateAllServerConfigs([]);
+    expect(errors).toEqual([]);
+  });
+});
+
+describe("buildGroupDescription", () => {
+  it("includes group name", () => {
+    const desc = buildGroupDescription(makeGroup({ groupName: "filesystem" }));
+    expect(desc).toContain("MCPico filesystem");
+  });
+
+  it("shows singular for 1 tool", () => {
+    const desc = buildGroupDescription(makeGroup());
+    expect(desc).toContain("1 tool");
+  });
+
+  it("shows plural for multiple tools", () => {
+    const group = makeGroup({
+      tools: [makeTool({ name: "a" }), makeTool({ name: "b" })],
+    });
+    const desc = buildGroupDescription(group);
+    expect(desc).toContain("2 tools");
+  });
+
+  it("includes server name", () => {
+    const desc = buildGroupDescription(makeGroup({ serverName: "my-upstream" }));
+    expect(desc).toContain("Source: my-upstream");
+  });
+
+  it("includes usage hints", () => {
+    const desc = buildGroupDescription(makeGroup());
+    expect(desc).toContain("Use 'help'");
+    expect(desc).toContain("<subcommand>");
+  });
+});
+
+describe("handleToolCall", () => {
+  const servers = [makeServer()];
+  const group = makeGroup();
+  const helpText = "Help text here";
+
+  it("returns help for 'help' command", async () => {
+    const result = await handleToolCall("help", group, servers, helpText);
+    expect(result).toEqual(makeTextResult(helpText));
+  });
+
+  it("returns help for empty command", async () => {
+    const result = await handleToolCall("", group, servers, helpText);
+    expect(result).toEqual(makeTextResult(helpText));
+  });
+
+  it("returns help for whitespace command", async () => {
+    const result = await handleToolCall("  ", group, servers, helpText);
+    expect(result).toEqual(makeTextResult(helpText));
+  });
+
+  it("returns parse error for invalid JSON args", async () => {
+    const result = await handleToolCall(
+      "test_tool {bad json}",
+      group,
+      servers,
+      helpText
+    );
+    expect(result.content?.[0]).toBeDefined();
+    if (result.content?.[0] && "text" in result.content[0]) {
+      expect(result.content[0].text).toContain("Could not parse arguments as JSON");
+    }
+  });
+
+  it("returns error for unknown subcommand", async () => {
+    const result = await handleToolCall(
+      "nonexistent",
+      group,
+      servers,
+      helpText
+    );
+    expect(result.content?.[0]).toBeDefined();
+    if (result.content?.[0] && "text" in result.content[0]) {
+      expect(result.content[0].text).toContain('Unknown subcommand: "nonexistent"');
+      expect(result.content[0].text).toContain("test_tool");
+    }
+  });
+
+  it("returns internal error when server not found for valid tool", async () => {
+    // Tool exists in group but no server has it
+    const orphanTool = makeTool({ name: "orphan_tool" });
+    const orphanGroup = makeGroup({ tools: [orphanTool] });
+    const emptyServers: DiscoveredServer[] = [];
+
+    const result = await handleToolCall(
+      "orphan_tool",
+      orphanGroup,
+      emptyServers,
+      helpText
+    );
+    expect(result.content?.[0]).toBeDefined();
+    if (result.content?.[0] && "text" in result.content[0]) {
+      expect(result.content[0].text).toContain("Internal error");
+    }
+  });
+
+  it("dispatches to forwardFn for valid tool", async () => {
+    const forwardFn = vi.fn().mockResolvedValue(makeTextResult("forwarded!"));
+
+    const result = await handleToolCall(
+      "test_tool",
+      group,
+      servers,
+      helpText,
+      forwardFn
+    );
+
+    expect(forwardFn).toHaveBeenCalledTimes(1);
+    expect(forwardFn).toHaveBeenCalledWith(servers[0], "test_tool", {});
+    expect(result).toEqual(makeTextResult("forwarded!"));
+  });
+
+  it("passes parsed args to forwardFn", async () => {
+    const forwardFn = vi.fn().mockResolvedValue(makeTextResult("ok"));
+
+    await handleToolCall(
+      'test_tool {"key":"value","count":42}',
+      group,
+      servers,
+      helpText,
+      forwardFn
+    );
+
+    expect(forwardFn).toHaveBeenCalledWith(servers[0], "test_tool", {
+      key: "value",
+      count: 42,
+    });
+  });
+
+  it("returns error when forwardFn throws", async () => {
+    const forwardFn = vi.fn().mockRejectedValue(new Error("Connection lost"));
+
+    const result = await handleToolCall(
+      "test_tool",
+      group,
+      servers,
+      helpText,
+      forwardFn
+    );
+
+    expect(result.content?.[0]).toBeDefined();
+    if (result.content?.[0] && "text" in result.content[0]) {
+      expect(result.content[0].text).toContain('Error calling "test_tool"');
+      expect(result.content[0].text).toContain("Connection lost");
+    }
+  });
+
+  it("finds correct server when multiple servers exist", async () => {
+    const serverA = makeServer({
+      name: "server-a",
+      tools: [makeTool({ name: "tool_a" })],
+    });
+    const serverB = makeServer({
+      name: "server-b",
+      tools: [makeTool({ name: "tool_b" })],
+    });
+    const multiGroup = makeGroup({
+      tools: [makeTool({ name: "tool_a" }), makeTool({ name: "tool_b" })],
+    });
+    const forwardFn = vi.fn().mockResolvedValue(makeTextResult("ok"));
+
+    await handleToolCall(
+      "tool_b",
+      multiGroup,
+      [serverA, serverB],
+      helpText,
+      forwardFn
+    );
+
+    expect(forwardFn).toHaveBeenCalledWith(serverB, "tool_b", {});
+  });
+});

package/src/server.ts

@@ -1,5 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "node:http";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod/v4";
 import type { MCPicoConfig } from "./config.js";
@@ -13,14 +15,125 @@ import { groupTools, type ToolGroup } from "./grouper.js";
 import { parseCommand } from "./parser.js";
 import { generateHelpText } from "./help.js";
 import { forwardToolCall } from "./proxy.js";
+import type { ResolvedListenAuth } from "./auth-types.js";
+import { resolveUpstreamAuth, resolveListenAuth, extractBearerToken, validateBearerToken, sendUnauthorized } from "./auth.js";
 
 /** Helper: create a simple text content result */
-function textResult(text: string): CallToolResult {
+export function textResult(text: string): CallToolResult {
   return {
     content: [{ type: "text" as const, text }],
   };
 }
 
+/**
+ * Merge tool groups from multiple upstream servers.
+ *
+ * Groups with the same name are merged:
+ * - Tools are concatenated
+ * - serverName is joined with " + "
+ */
+export function mergeGroups(allGroups: ToolGroup[]): Map<string, ToolGroup> {
+  const mergedGroups = new Map<string, ToolGroup>();
+  for (const group of allGroups) {
+    const existing = mergedGroups.get(group.groupName);
+    if (existing) {
+      existing.tools.push(...group.tools);
+      if (!existing.serverName.includes(group.serverName)) {
+        existing.serverName += ` + ${group.serverName}`;
+      }
+    } else {
+      mergedGroups.set(group.groupName, { ...group });
+    }
+  }
+  return mergedGroups;
+}
+
+/**
+ * Handle a tool call command for a given group.
+ *
+ * Dispatches: help → error → unknown subcommand → forward to upstream server.
+ *
+ * Exported for testing; allows injecting a mock forwardFn to avoid
+ * connecting to real upstream servers.
+ */
+export async function handleToolCall(
+  command: string,
+  group: ToolGroup,
+  servers: DiscoveredServer[],
+  helpText: string,
+  forwardFn: (
+    server: DiscoveredServer,
+    toolName: string,
+    args: Record<string, unknown>
+  ) => Promise<CallToolResult> = forwardToolCall
+): Promise<CallToolResult> {
+  const parsed = parseCommand(command);
+
+  if (parsed.isHelp) {
+    return textResult(helpText);
+  }
+
+  if (parsed.error) {
+    return textResult(parsed.error);
+  }
+
+  const toolName = parsed.subcommand!;
+  const upstreamTool = group.tools.find((t) => t.name === toolName);
+  if (!upstreamTool) {
+    const available = group.tools.map((t) => t.name).join(", ");
+    return textResult(
+      `Unknown subcommand: "${toolName}"\n\nAvailable in ${group.groupName}: ${available}\n\nUse 'help' for full documentation.`
+    );
+  }
+
+  const serverForTool = servers.find((s) =>
+    s.tools.some((t) => t.name === toolName)
+  );
+
+  if (!serverForTool) {
+    return textResult(
+      `Internal error: could not find upstream server for tool "${toolName}"`
+    );
+  }
+
+  try {
+    const result = await forwardFn(serverForTool, toolName, parsed.args);
+    return result;
+  } catch (err) {
+    return textResult(
+      `Error calling "${toolName}": ${(err as Error).message}`
+    );
+  }
+}
+
+/**
+ * Build the description string for a tool group.
+ */
+export function buildGroupDescription(group: ToolGroup): string {
+  const toolCount = group.tools.length;
+  return [
+    `MCPico ${group.groupName} — ${toolCount} tool${toolCount === 1 ? "" : "s"}`,
+    `Source: ${group.serverName}`,
+    `Use 'help' to see all subcommands and their parameters.`,
+    `Format: <subcommand> {"key":"value",...}`,
+  ].join(" | ");
+}
+
+/**
+ * Validate all server configs, returning an array of error messages.
+ * Returns empty array if all configs are valid.
+ */
+export function validateAllServerConfigs(servers: MCPicoConfig["servers"]): string[] {
+  const errors: string[] = [];
+  for (const serverConfig of servers) {
+    const err = validateServerConfig(serverConfig);
+    if (err) {
+      errors.push(err);
+    }
+  }
+  return errors;
+}
+
 /**
  * Start the MCPico proxy server.
  *
@@ -36,13 +149,7 @@ export async function startServer(config: MCPicoConfig): Promise<void> {
   const allGroups: ToolGroup[] = [];
 
   // Validate server configs
-  const validationErrors: string[] = [];
-  for (const serverConfig of config.servers) {
-    const err = validateServerConfig(serverConfig);
-    if (err) {
-      validationErrors.push(err);
-    }
-  }
+  const validationErrors = validateAllServerConfigs(config.servers);
   if (validationErrors.length > 0) {
     console.error("Configuration errors:");
     for (const err of validationErrors) {
@@ -63,10 +170,14 @@ export async function startServer(config: MCPicoConfig): Promise<void> {
           ? serverConfig.transport.url
           : serverConfig.transport.command;
       console.error(`  Connecting to "${serverConfig.name}" (${serverConfig.transport.type}: ${transportLabel})...`);
+      const resolvedAuth = serverConfig.auth
+        ? resolveUpstreamAuth(serverConfig.auth)
+        : undefined;
       const discovered = await discoverServer(
         serverConfig.name,
         serverConfig.transport,
-        serverConfig.connectTimeoutMs
+        serverConfig.connectTimeoutMs,
+        resolvedAuth
       );
       servers.push(discovered);
 
@@ -96,22 +207,11 @@ export async function startServer(config: MCPicoConfig): Promise<void> {
   }
 
   // Build lookup: groupName → ToolGroup (merged across servers)
-  const mergedGroups = new Map<string, ToolGroup>();
-  for (const group of allGroups) {
-    const existing = mergedGroups.get(group.groupName);
-    if (existing) {
-      existing.tools.push(...group.tools);
-      if (!existing.serverName.includes(group.serverName)) {
-        existing.serverName += ` + ${group.serverName}`;
-      }
-    } else {
-      mergedGroups.set(group.groupName, { ...group });
-    }
-  }
+  const mergedGroups = mergeGroups(allGroups);
 
   // Create the MCPico server
   const server = new McpServer(
-    { name: "MCPico", version: "0.1.0" },
+    { name: "MCPico", version: "0.2.0" },
     {
       capabilities: { tools: {}, resources: {}, prompts: {} },
       instructions:
@@ -124,12 +224,7 @@ export async function startServer(config: MCPicoConfig): Promise<void> {
   // Register each group as a tool
   for (const [groupName, group] of mergedGroups) {
     const toolCount = group.tools.length;
-    const description = [
-      `MCPico ${groupName} — ${toolCount} tool${toolCount === 1 ? "" : "s"}`,
-      `Source: ${group.serverName}`,
-      `Use 'help' to see all subcommands and their parameters.`,
-      `Format: <subcommand> {"key":"value",...}`,
-    ].join(" | ");
+    const description = buildGroupDescription(group);
 
     const helpText = generateHelpText(group);
 
@@ -148,47 +243,7 @@ export async function startServer(config: MCPicoConfig): Promise<void> {
         },
       },
       async (args: { command: string }) => {
-        const parsed = parseCommand(args.command);
-
-        if (parsed.isHelp) {
-          return textResult(helpText);
-        }
-
-        if (parsed.error) {
-          return textResult(parsed.error);
-        }
-
-        const toolName = parsed.subcommand!;
-        const upstreamTool = group.tools.find((t) => t.name === toolName);
-        if (!upstreamTool) {
-          const available = group.tools.map((t) => t.name).join(", ");
-          return textResult(
-            `Unknown subcommand: "${toolName}"\n\nAvailable in ${groupName}: ${available}\n\nUse 'help' for full documentation.`
-          );
-        }
-
-        const serverForTool = servers.find((s) =>
-          s.tools.some((t) => t.name === toolName)
-        );
-
-        if (!serverForTool) {
-          return textResult(
-            `Internal error: could not find upstream server for tool "${toolName}"`
-          );
-        }
-
-        try {
-          const result = await forwardToolCall(
-            serverForTool,
-            toolName,
-            parsed.args
-          );
-          return result;
-        } catch (err) {
-          return textResult(
-            `Error calling "${toolName}": ${(err as Error).message}`
-          );
-        }
+        return handleToolCall(args.command, group, servers, helpText);
       }
     );
 
@@ -273,13 +328,48 @@ export async function startServer(config: MCPicoConfig): Promise<void> {
     console.error(`  Registered ${promptCount} prompt(s)`);
   }
 
-  // Connect to client via stdio
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  // Connect to client via configured transport
+  const listenConfig = config.listen || { type: "stdio" };
 
-  console.error(
-    `MCPico ready — ${mergedGroups.size} group(s), ${servers.length} upstream server(s)`
-  );
+  if (listenConfig.type === "sse") {
+    // Resolve listen auth
+    let listenAuth: ResolvedListenAuth | undefined;
+    if (listenConfig.auth) {
+      listenAuth = resolveListenAuth(listenConfig.auth);
+    }
+
+    const transport = new StreamableHTTPServerTransport();
+    const httpServer = createServer(async (req, res) => {
+      // Auth check
+      if (listenAuth) {
+        const providedToken = extractBearerToken(req);
+        if (!validateBearerToken(providedToken, listenAuth.token)) {
+          sendUnauthorized(res);
+          return;
+        }
+      }
+
+      // Collect body for handleRequest
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) {
+        chunks.push(chunk);
+      }
+      const body = chunks.length > 0 ? Buffer.concat(chunks).toString() : undefined;
+      await transport.handleRequest(req, res, body);
+    });
+    await server.connect(transport);
+    const host = listenConfig.host || "localhost";
+    httpServer.listen(listenConfig.port, host);
+    console.error(
+      `MCPico ready — ${mergedGroups.size} group(s), ${servers.length} upstream server(s) — listening on http://${host}:${listenConfig.port}`
+    );
+  } else {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(
+      `MCPico ready — ${mergedGroups.size} group(s), ${servers.length} upstream server(s)`
+    );
+  }
 
   // Handle shutdown
   let shuttingDown = false;