@axiom-lattice/gateway 2.1.34 → 2.1.35

package/dist/index.mjs

@@ -3544,12 +3544,441 @@ function registerMetricsServerConfigRoutes(app2) {
   app2.post("/api/metrics-configs/test-datasources/:datasourceId/meta", testDatasourceMetrics);
 }
 
+// src/controllers/mcp-configs.ts
+import {
+  getStoreLattice as getStoreLattice8,
+  mcpManager,
+  toolLatticeManager as toolLatticeManager2
+} from "@axiom-lattice/core";
+import { randomUUID as randomUUID5 } from "crypto";
+function getTenantId3(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+async function getMcpServerConfigList(request, reply) {
+  const tenantId = getTenantId3(request);
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const configs = await store.getAllConfigs(tenantId);
+    return {
+      success: true,
+      message: "MCP server configurations retrieved successfully",
+      data: {
+        records: configs,
+        total: configs.length
+      }
+    };
+  } catch (error) {
+    console.error("Failed to get MCP server configs:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve MCP server configurations",
+      data: {
+        records: [],
+        total: 0
+      }
+    };
+  }
+}
+async function getMcpServerConfig(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    return {
+      success: true,
+      message: "MCP server configuration retrieved successfully",
+      data: config
+    };
+  } catch (error) {
+    console.error("Failed to get MCP server config:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve MCP server configuration"
+    };
+  }
+}
+async function createMcpServerConfig(request, reply) {
+  const tenantId = getTenantId3(request);
+  const body = request.body;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const existing = await store.getConfigByKey(tenantId, body.key);
+    if (existing) {
+      reply.code(409);
+      return {
+        success: false,
+        message: "MCP server configuration with this key already exists"
+      };
+    }
+    const id = body.id || randomUUID5();
+    const config = await store.createConfig(tenantId, id, body);
+    try {
+      await connectAndRegisterTools(config);
+      await store.updateConfig(tenantId, id, { status: "connected" });
+      config.status = "connected";
+    } catch (error) {
+      console.warn("Failed to auto-connect MCP server:", error);
+      await store.updateConfig(tenantId, id, { status: "error" });
+      config.status = "error";
+    }
+    reply.code(201);
+    return {
+      success: true,
+      message: "MCP server configuration created successfully",
+      data: config
+    };
+  } catch (error) {
+    console.error("Failed to create MCP server config:", error);
+    return {
+      success: false,
+      message: "Failed to create MCP server configuration"
+    };
+  }
+}
+async function updateMcpServerConfig(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  const updates = request.body;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const existing = await store.getConfigByKey(tenantId, key);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    const shouldReconnect = updates.config !== void 0;
+    const updated = await store.updateConfig(tenantId, existing.id, updates);
+    if (!updated) {
+      return {
+        success: false,
+        message: "Failed to update MCP server configuration"
+      };
+    }
+    if (shouldReconnect) {
+      try {
+        if (mcpManager.hasServer(key)) {
+          await mcpManager.removeServer(key);
+        }
+        await connectAndRegisterTools(updated);
+        await store.updateConfig(tenantId, existing.id, { status: "connected" });
+        updated.status = "connected";
+      } catch (error) {
+        console.warn("Failed to reconnect MCP server:", error);
+        await store.updateConfig(tenantId, existing.id, { status: "error" });
+        updated.status = "error";
+      }
+    }
+    return {
+      success: true,
+      message: "MCP server configuration updated successfully",
+      data: updated
+    };
+  } catch (error) {
+    console.error("Failed to update MCP server config:", error);
+    return {
+      success: false,
+      message: "Failed to update MCP server configuration"
+    };
+  }
+}
+async function deleteMcpServerConfig(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { keyOrId } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    let config = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+    if (!config) {
+      config = await store.getConfigById(tenantId, keyOrId);
+      if (config) {
+        configKey = config.key;
+      }
+    }
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    try {
+      if (mcpManager.hasServer(configKey)) {
+        await mcpManager.removeServer(configKey);
+      }
+    } catch (error) {
+      console.warn("Failed to remove from MCP manager:", error);
+    }
+    const deleted = await store.deleteConfig(tenantId, config.id);
+    if (!deleted) {
+      return {
+        success: false,
+        message: "Failed to delete MCP server configuration"
+      };
+    }
+    return {
+      success: true,
+      message: "MCP server configuration deleted successfully"
+    };
+  } catch (error) {
+    console.error("Failed to delete MCP server config:", error);
+    return {
+      success: false,
+      message: "Failed to delete MCP server configuration"
+    };
+  }
+}
+async function testMcpServerConnection(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    const startTime = Date.now();
+    try {
+      const testKey = `__test_${key}_${Date.now()}`;
+      const connection = convertToConnection(config.config);
+      mcpManager.addServer(testKey, connection);
+      await mcpManager.connect();
+      const tools = await mcpManager.getAllTools();
+      const latency = Date.now() - startTime;
+      await mcpManager.removeServer(testKey);
+      return {
+        success: true,
+        message: "Connection test successful",
+        data: {
+          connected: true,
+          latency
+        }
+      };
+    } catch (error) {
+      return {
+        success: true,
+        message: "Connection test failed",
+        data: {
+          connected: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        }
+      };
+    }
+  } catch (error) {
+    console.error("Failed to test MCP server connection:", error);
+    return {
+      success: false,
+      message: "Failed to test MCP server connection",
+      data: {
+        connected: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      }
+    };
+  }
+}
+async function listMcpServerTools(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    if (!mcpManager.hasServer(key)) {
+      await connectAndRegisterTools(config);
+    }
+    const tools = await mcpManager.getAllTools();
+    return {
+      success: true,
+      message: "Tools retrieved successfully",
+      data: {
+        tools
+      }
+    };
+  } catch (error) {
+    console.error("Failed to list MCP tools:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve tools"
+    };
+  }
+}
+async function connectMcpServer(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    await connectAndRegisterTools(config);
+    const updated = await store.updateConfig(tenantId, config.id, {
+      status: "connected"
+    });
+    return {
+      success: true,
+      message: "MCP server connected successfully",
+      data: updated || config
+    };
+  } catch (error) {
+    console.error("Failed to connect MCP server:", error);
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (config) {
+      await store.updateConfig(tenantId, config.id, { status: "error" });
+    }
+    return {
+      success: false,
+      message: `Failed to connect MCP server: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+async function disconnectMcpServer(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    if (mcpManager.hasServer(key)) {
+      await mcpManager.removeServer(key);
+    }
+    const updated = await store.updateConfig(tenantId, config.id, {
+      status: "disconnected"
+    });
+    return {
+      success: true,
+      message: "MCP server disconnected successfully",
+      data: updated || config
+    };
+  } catch (error) {
+    console.error("Failed to disconnect MCP server:", error);
+    return {
+      success: false,
+      message: "Failed to disconnect MCP server"
+    };
+  }
+}
+async function testMcpServerTools(request, reply) {
+  const body = request.body;
+  try {
+    if (!body.config) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "config is required"
+      };
+    }
+    const testKey = `__test_${Date.now()}`;
+    const connection = convertToConnection(body.config);
+    mcpManager.addServer(testKey, connection);
+    await mcpManager.connect();
+    const tools = await mcpManager.getAllTools();
+    await mcpManager.removeServer(testKey);
+    return {
+      success: true,
+      message: "Tools retrieved successfully",
+      data: {
+        tools
+      }
+    };
+  } catch (error) {
+    console.error("Failed to test MCP server tools:", error);
+    return {
+      success: false,
+      message: `Failed to retrieve tools: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function convertToConnection(config) {
+  const baseConfig = {
+    env: config.env
+  };
+  if (config.transport === "stdio") {
+    return {
+      ...baseConfig,
+      transport: "stdio",
+      command: config.command,
+      args: config.args || []
+    };
+  } else {
+    return {
+      ...baseConfig,
+      transport: config.transport === "streamable_http" ? "http" : config.transport,
+      url: config.url
+    };
+  }
+}
+async function connectAndRegisterTools(config) {
+  const connection = convertToConnection(config.config);
+  mcpManager.addServer(config.key, connection);
+  await mcpManager.connect();
+  const allTools = await mcpManager.getAllTools();
+  const selectedTools = allTools.filter(
+    (tool) => config.selectedTools.includes(tool.name)
+  );
+  for (const tool of selectedTools) {
+    toolLatticeManager2.registerExistingTool(tool.name, tool);
+  }
+}
+function registerMcpServerConfigRoutes(app2) {
+  app2.get("/api/mcp-servers", getMcpServerConfigList);
+  app2.get("/api/mcp-servers/:key", getMcpServerConfig);
+  app2.post("/api/mcp-servers", createMcpServerConfig);
+  app2.put("/api/mcp-servers/:key", updateMcpServerConfig);
+  app2.delete("/api/mcp-servers/:keyOrId", deleteMcpServerConfig);
+  app2.post("/api/mcp-servers/:key/test", testMcpServerConnection);
+  app2.get("/api/mcp-servers/:key/tools", listMcpServerTools);
+  app2.post("/api/mcp-servers/:key/connect", connectMcpServer);
+  app2.post("/api/mcp-servers/:key/disconnect", disconnectMcpServer);
+  app2.post("/api/mcp-servers/test-tools", testMcpServerTools);
+}
+
 // src/controllers/users.ts
-import { getStoreLattice as getStoreLattice8 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice9 } from "@axiom-lattice/core";
 import { v4 as uuidv42 } from "uuid";
 var UsersController = class {
   constructor() {
-    this.userStore = getStoreLattice8("default", "user").store;
+    this.userStore = getStoreLattice9("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -3627,11 +4056,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-import { getStoreLattice as getStoreLattice9 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice10 } from "@axiom-lattice/core";
 import { v4 as uuidv43 } from "uuid";
 var TenantsController = class {
   constructor() {
-    this.tenantStore = getStoreLattice9("default", "tenant").store;
+    this.tenantStore = getStoreLattice10("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -3695,7 +4124,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-import { getStoreLattice as getStoreLattice10 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice11 } from "@axiom-lattice/core";
 import { v4 as uuidv44 } from "uuid";
 var defaultAuthConfig = {
   autoApproveUsers: true,
@@ -3704,9 +4133,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = getStoreLattice10("default", "user").store;
-    this.tenantStore = getStoreLattice10("default", "tenant").store;
-    this.userTenantLinkStore = getStoreLattice10("default", "userTenantLink").store;
+    this.userStore = getStoreLattice11("default", "user").store;
+    this.tenantStore = getStoreLattice11("default", "tenant").store;
+    this.userTenantLinkStore = getStoreLattice11("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -4143,6 +4572,7 @@ var registerLatticeRoutes = (app2) => {
   registerWorkspaceRoutes(app2);
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
+  registerMcpServerConfigRoutes(app2);
   registerUserRoutes(app2);
   registerTenantRoutes(app2);
   registerAuthRoutes(app2, {