@yawlabs/mcp-connect 0.1.0

package/dist/index.js

@@ -0,0 +1,508 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { request } from "undici";
+
+// src/logger.ts
+function log(level, msg, data) {
+  const entry = JSON.stringify({ level, msg, ts: (/* @__PURE__ */ new Date()).toISOString(), ...data });
+  process.stderr.write(entry + "\n");
+}
+
+// src/config.ts
+async function fetchConfig(apiUrl2, token2) {
+  const url = apiUrl2.replace(/\/$/, "") + "/api/connect/config";
+  const res = await request(url, {
+    method: "GET",
+    headers: {
+      Authorization: "Bearer " + token2,
+      Accept: "application/json"
+    },
+    headersTimeout: 1e4,
+    bodyTimeout: 1e4
+  });
+  if (res.statusCode === 401) {
+    throw new ConfigError("Invalid MCP_HOSTING_TOKEN \u2014 check your token at mcp.hosting", true);
+  }
+  if (res.statusCode === 403) {
+    throw new ConfigError("Access denied \u2014 your token may have expired", true);
+  }
+  if (res.statusCode !== 200) {
+    const body = await res.body.text().catch(() => "");
+    throw new ConfigError("Config fetch failed (HTTP " + res.statusCode + "): " + body, false);
+  }
+  const data = await res.body.json();
+  if (!data.servers || !Array.isArray(data.servers)) {
+    throw new ConfigError("Invalid config response from server", false);
+  }
+  log("info", "Config loaded", { serverCount: data.servers.length, version: data.configVersion });
+  return data;
+}
+var ConfigError = class extends Error {
+  constructor(message, fatal) {
+    super(message);
+    this.fatal = fatal;
+    this.name = "ConfigError";
+  }
+  fatal;
+};
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/meta-tools.ts
+var META_TOOLS = {
+  discover: {
+    name: "mcp_connect_discover",
+    description: "List all available MCP servers configured in your mcp.hosting account. Shows server names, namespaces, types, and whether they are currently active. Call this first to see what servers are available before activating them.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    annotations: {
+      title: "Discover MCP Servers",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    }
+  },
+  activate: {
+    name: "mcp_connect_activate",
+    description: 'Activate an MCP server by its namespace. This connects to the server and makes its tools available. After activation, the tool list will update with the new tools prefixed by the namespace (e.g., "gh_create_issue" for namespace "gh").',
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: 'The namespace of the server to activate (e.g., "gh", "slack", "stripe")'
+        }
+      },
+      required: ["server"]
+    },
+    annotations: {
+      title: "Activate MCP Server",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    }
+  },
+  deactivate: {
+    name: "mcp_connect_deactivate",
+    description: "Deactivate an MCP server by its namespace. This disconnects from the server and removes its tools from the available tool list. Use this to free up context when you no longer need a server.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "The namespace of the server to deactivate"
+        }
+      },
+      required: ["server"]
+    },
+    annotations: {
+      title: "Deactivate MCP Server",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    }
+  }
+};
+var META_TOOL_NAMES = /* @__PURE__ */ new Set([
+  META_TOOLS.discover.name,
+  META_TOOLS.activate.name,
+  META_TOOLS.deactivate.name
+]);
+
+// src/proxy.ts
+function buildToolList(activeConnections) {
+  const tools = [];
+  for (const meta of Object.values(META_TOOLS)) {
+    tools.push({
+      name: meta.name,
+      description: meta.description,
+      inputSchema: meta.inputSchema,
+      annotations: meta.annotations
+    });
+  }
+  for (const conn of activeConnections.values()) {
+    for (const tool of conn.tools) {
+      tools.push({
+        name: tool.namespacedName,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        annotations: tool.annotations
+      });
+    }
+  }
+  return tools;
+}
+function buildToolRoutes(activeConnections) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const conn of activeConnections.values()) {
+    for (const tool of conn.tools) {
+      routes.set(tool.namespacedName, {
+        namespace: conn.config.namespace,
+        originalName: tool.name
+      });
+    }
+  }
+  return routes;
+}
+async function routeToolCall(toolName, args, toolRoutes, activeConnections) {
+  const route = toolRoutes.get(toolName);
+  if (!route) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Unknown tool: " + toolName + ". Use mcp_connect_discover to see available servers, then mcp_connect_activate to load tools."
+        }
+      ],
+      isError: true
+    };
+  }
+  const connection = activeConnections.get(route.namespace);
+  if (!connection || connection.status !== "connected") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: 'Server "' + route.namespace + '" is no longer connected. Use mcp_connect_activate("' + route.namespace + '") to reconnect.'
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const result = await connection.client.callTool({
+      name: route.originalName,
+      arguments: args
+    });
+    return result;
+  } catch (err) {
+    log("error", "Tool call failed", { tool: toolName, namespace: route.namespace, error: err.message });
+    return {
+      content: [{ type: "text", text: "Error calling " + toolName + ": " + err.message }],
+      isError: true
+    };
+  }
+}
+
+// src/upstream.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var CONNECT_TIMEOUT = 15e3;
+async function connectToUpstream(config) {
+  const client = new Client({ name: "mcp-connect", version: "0.1.0" }, { capabilities: {} });
+  let transport;
+  if (config.type === "local") {
+    if (!config.command) {
+      throw new Error("command is required for local servers");
+    }
+    transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args ?? [],
+      env: { ...process.env, ...config.env },
+      stderr: "pipe"
+    });
+  } else {
+    if (!config.url) {
+      throw new Error("url is required for remote servers");
+    }
+    transport = new StreamableHTTPClientTransport(new URL(config.url));
+  }
+  const connectPromise = client.connect(transport);
+  const timeoutPromise = new Promise(
+    (_, reject) => setTimeout(() => reject(new Error("Connection timeout after " + CONNECT_TIMEOUT + "ms")), CONNECT_TIMEOUT)
+  );
+  await Promise.race([connectPromise, timeoutPromise]);
+  log("info", "Connected to upstream", { name: config.name, namespace: config.namespace, type: config.type });
+  const tools = await fetchToolsFromUpstream(client, config.namespace);
+  return {
+    config,
+    client,
+    transport,
+    tools,
+    status: "connected"
+  };
+}
+async function disconnectFromUpstream(connection) {
+  try {
+    await connection.client.close();
+  } catch (err) {
+    log("warn", "Error disconnecting from upstream", {
+      namespace: connection.config.namespace,
+      error: err.message
+    });
+  }
+  connection.status = "disconnected";
+  log("info", "Disconnected from upstream", { namespace: connection.config.namespace });
+}
+async function fetchToolsFromUpstream(client, namespace) {
+  const result = await client.listTools();
+  return (result.tools ?? []).map((tool) => ({
+    name: tool.name,
+    namespacedName: namespace + "_" + tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: tool.annotations
+  }));
+}
+
+// src/server.ts
+var POLL_INTERVAL = 6e4;
+var ConnectServer = class {
+  constructor(apiUrl2, token2) {
+    this.apiUrl = apiUrl2;
+    this.token = token2;
+    this.server = new Server(
+      { name: "mcp-connect", version: "0.1.0" },
+      { capabilities: { tools: { listChanged: true } } }
+    );
+    this.setupHandlers();
+  }
+  apiUrl;
+  token;
+  server;
+  connections = /* @__PURE__ */ new Map();
+  config = null;
+  configVersion = null;
+  pollTimer = null;
+  toolRoutes = /* @__PURE__ */ new Map();
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: buildToolList(this.connections)
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request2) => {
+      const { name, arguments: args } = request2.params;
+      return this.handleToolCall(name, args ?? {});
+    });
+  }
+  async start() {
+    try {
+      await this.fetchAndApplyConfig();
+    } catch (err) {
+      if (err instanceof ConfigError && err.fatal) {
+        throw err;
+      }
+      log("warn", "Initial config fetch failed, starting with empty config", { error: err.message });
+      this.config = { servers: [], configVersion: "" };
+    }
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    this.startPolling();
+    log("info", "mcp-connect started", {
+      apiUrl: this.apiUrl,
+      servers: this.config?.servers.length ?? 0
+    });
+  }
+  async handleToolCall(name, args) {
+    if (name === META_TOOLS.discover.name) {
+      return this.handleDiscover();
+    }
+    if (name === META_TOOLS.activate.name) {
+      return this.handleActivate(args.server);
+    }
+    if (name === META_TOOLS.deactivate.name) {
+      return this.handleDeactivate(args.server);
+    }
+    return routeToolCall(name, args, this.toolRoutes, this.connections);
+  }
+  handleDiscover() {
+    if (!this.config || this.config.servers.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No servers configured. Add servers at mcp.hosting to get started."
+          }
+        ]
+      };
+    }
+    const lines = ["Available MCP servers:\n"];
+    for (const server2 of this.config.servers) {
+      if (!server2.isActive) continue;
+      const connection = this.connections.get(server2.namespace);
+      const status = connection ? "ACTIVE (" + connection.tools.length + " tools)" : "available";
+      lines.push("  " + server2.namespace + " \u2014 " + server2.name + " [" + status + "] (" + server2.type + ")");
+    }
+    const inactive = this.config.servers.filter((s) => !s.isActive);
+    if (inactive.length > 0) {
+      lines.push("\nDisabled servers:");
+      for (const server2 of inactive) {
+        lines.push("  " + server2.namespace + " \u2014 " + server2.name + " (disabled in dashboard)");
+      }
+    }
+    const activeCount = this.connections.size;
+    const totalTools = Array.from(this.connections.values()).reduce((sum, c) => sum + c.tools.length, 0);
+    lines.push("\n" + activeCount + " active, " + totalTools + " tools loaded.");
+    lines.push('Use mcp_connect_activate({ server: "namespace" }) to activate a server.');
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+  async handleActivate(namespace) {
+    if (!namespace) {
+      return {
+        content: [
+          { type: "text", text: "server namespace is required. Use mcp_connect_discover to see available servers." }
+        ],
+        isError: true
+      };
+    }
+    const existing = this.connections.get(namespace);
+    if (existing && existing.status === "connected") {
+      const toolNames = existing.tools.map((t) => t.namespacedName).join(", ");
+      return {
+        content: [
+          {
+            type: "text",
+            text: 'Server "' + namespace + '" is already active with ' + existing.tools.length + " tools: " + toolNames
+          }
+        ]
+      };
+    }
+    const serverConfig = this.config?.servers.find((s) => s.namespace === namespace && s.isActive);
+    if (!serverConfig) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: 'Server "' + namespace + '" not found or disabled. Use mcp_connect_discover to see available servers.'
+          }
+        ],
+        isError: true
+      };
+    }
+    try {
+      const connection = await connectToUpstream(serverConfig);
+      this.connections.set(namespace, connection);
+      this.toolRoutes = buildToolRoutes(this.connections);
+      await this.server.sendToolListChanged();
+      const toolNames = connection.tools.map((t) => t.namespacedName).join(", ");
+      return {
+        content: [
+          {
+            type: "text",
+            text: 'Activated "' + namespace + '" \u2014 ' + connection.tools.length + " tools available: " + toolNames
+          }
+        ]
+      };
+    } catch (err) {
+      log("error", "Failed to activate upstream", { namespace, error: err.message });
+      return {
+        content: [{ type: "text", text: 'Failed to activate "' + namespace + '": ' + err.message }],
+        isError: true
+      };
+    }
+  }
+  async handleDeactivate(namespace) {
+    if (!namespace) {
+      return {
+        content: [{ type: "text", text: "server namespace is required." }],
+        isError: true
+      };
+    }
+    const connection = this.connections.get(namespace);
+    if (!connection) {
+      return {
+        content: [{ type: "text", text: 'Server "' + namespace + '" is not active.' }],
+        isError: true
+      };
+    }
+    await disconnectFromUpstream(connection);
+    this.connections.delete(namespace);
+    this.toolRoutes = buildToolRoutes(this.connections);
+    await this.server.sendToolListChanged();
+    return {
+      content: [{ type: "text", text: 'Deactivated "' + namespace + '". Tools removed.' }]
+    };
+  }
+  async fetchAndApplyConfig() {
+    const newConfig = await fetchConfig(this.apiUrl, this.token);
+    if (newConfig.configVersion === this.configVersion) {
+      return;
+    }
+    await this.reconcileConfig(newConfig);
+    this.config = newConfig;
+    this.configVersion = newConfig.configVersion;
+  }
+  async reconcileConfig(newConfig) {
+    const newNamespaces = new Set(newConfig.servers.map((s) => s.namespace));
+    let changed = false;
+    for (const [namespace, connection] of this.connections) {
+      const newServerConfig = newConfig.servers.find((s) => s.namespace === namespace);
+      if (!newServerConfig || !newServerConfig.isActive) {
+        log("info", "Server removed or disabled in config, deactivating", { namespace });
+        await disconnectFromUpstream(connection);
+        this.connections.delete(namespace);
+        changed = true;
+        continue;
+      }
+      const oldConfig = connection.config;
+      if (oldConfig.command !== newServerConfig.command || JSON.stringify(oldConfig.args) !== JSON.stringify(newServerConfig.args) || oldConfig.url !== newServerConfig.url || JSON.stringify(oldConfig.env) !== JSON.stringify(newServerConfig.env)) {
+        log("info", "Server config changed, deactivating stale connection", { namespace });
+        await disconnectFromUpstream(connection);
+        this.connections.delete(namespace);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.toolRoutes = buildToolRoutes(this.connections);
+      await this.server.sendToolListChanged();
+    }
+  }
+  startPolling() {
+    this.pollTimer = setInterval(async () => {
+      try {
+        await this.fetchAndApplyConfig();
+      } catch (err) {
+        log("warn", "Config poll failed", { error: err.message });
+      }
+    }, POLL_INTERVAL);
+    if (this.pollTimer.unref) {
+      this.pollTimer.unref();
+    }
+  }
+  async shutdown() {
+    log("info", "Shutting down mcp-connect");
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    const disconnects = Array.from(this.connections.values()).map((conn) => disconnectFromUpstream(conn));
+    await Promise.allSettled(disconnects);
+    this.connections.clear();
+    await this.server.close();
+    log("info", "mcp-connect shutdown complete");
+  }
+};
+
+// src/index.ts
+var token = process.env.MCP_HOSTING_TOKEN;
+var apiUrl = process.env.MCP_HOSTING_URL ?? "https://mcp.hosting";
+if (!token) {
+  process.stderr.write(
+    '\n  mcp-connect: MCP_HOSTING_TOKEN is required.\n\n  1. Create a token at https://mcp.hosting \u2192 Settings \u2192 API Tokens\n  2. Add it to your MCP client config:\n\n     {\n       "mcpServers": {\n         "mcp-connect": {\n           "command": "npx",\n           "args": ["@yawlabs/mcp-connect"],\n           "env": {\n             "MCP_HOSTING_TOKEN": "mcp_pat_your_token_here"\n           }\n         }\n       }\n     }\n\n'
+  );
+  process.exit(1);
+}
+var server = new ConnectServer(apiUrl, token);
+var shutdown = async () => {
+  await server.shutdown();
+  process.exit(0);
+};
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+server.start().catch((err) => {
+  if (err instanceof ConfigError && err.fatal) {
+    process.stderr.write("\n  mcp-connect: " + err.message + "\n\n");
+    process.exit(1);
+  }
+  log("error", "Fatal startup error", { error: err.message });
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@yawlabs/mcp-connect",
+  "version": "0.1.0",
+  "description": "MCP orchestrator — one install, all your MCP servers, managed from the cloud",
+  "license": "MIT",
+  "author": "Yaw Labs <contact@yaw.sh> (https://yaw.sh)",
+  "type": "module",
+  "bin": {
+    "mcp-connect": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "lint": "biome check src/",
+    "lint:fix": "biome check --write src/",
+    "typecheck": "tsc --noEmit",
+    "test:ci": "npm run build && npm test",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "undici": "^7.8.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "orchestrator",
+    "mcp-server",
+    "ai",
+    "mcp-connect",
+    "mcp-hosting"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YawLabs/mcp-connect.git"
+  },
+  "bugs": {
+    "url": "https://github.com/YawLabs/mcp-connect/issues"
+  },
+  "homepage": "https://mcp.hosting"
+}