chore: import upstream snapshot with attribution

apps/sim/app/api/mcp/workflow-servers/[id]/route.ts

@@ -0,0 +1,186 @@
+import { db } from '@sim/db'
+import { workflowMcpServer, workflowMcpTool } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { and, eq, isNull } from 'drizzle-orm'
+import type { NextRequest } from 'next/server'
+import {
+  updateWorkflowMcpServerBodySchema,
+  workflowMcpServerParamsSchema,
+} from '@/lib/api/contracts/workflow-mcp-servers'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import {
+  mcpBodyReadErrorResponse,
+  readMcpJsonBodyWithLimit,
+  withMcpAuth,
+} from '@/lib/mcp/middleware'
+import {
+  performDeleteWorkflowMcpServer,
+  performUpdateWorkflowMcpServer,
+} from '@/lib/mcp/orchestration'
+import {
+  createMcpErrorResponse,
+  createMcpSuccessResponse,
+  mcpOrchestrationStatus,
+} from '@/lib/mcp/utils'
+
+const logger = createLogger('WorkflowMcpServerAPI')
+
+export const dynamic = 'force-dynamic'
+
+interface RouteParams {
+  id: string
+}
+
+/**
+ * GET - Get a specific workflow MCP server with its tools
+ */
+export const GET = withRouteHandler(
+  withMcpAuth<RouteParams>('read')(
+    async (request: NextRequest, { userId, workspaceId, requestId }, { params }) => {
+      try {
+        const { id: serverId } = workflowMcpServerParamsSchema.parse(await params)
+
+        logger.info(`[${requestId}] Getting workflow MCP server: ${serverId}`)
+
+        const [server] = await db
+          .select({
+            id: workflowMcpServer.id,
+            workspaceId: workflowMcpServer.workspaceId,
+            createdBy: workflowMcpServer.createdBy,
+            name: workflowMcpServer.name,
+            description: workflowMcpServer.description,
+            isPublic: workflowMcpServer.isPublic,
+            createdAt: workflowMcpServer.createdAt,
+            updatedAt: workflowMcpServer.updatedAt,
+          })
+          .from(workflowMcpServer)
+          .where(
+            and(
+              eq(workflowMcpServer.id, serverId),
+              eq(workflowMcpServer.workspaceId, workspaceId),
+              isNull(workflowMcpServer.deletedAt)
+            )
+          )
+          .limit(1)
+
+        if (!server) {
+          return createMcpErrorResponse(new Error('Server not found'), 'Server not found', 404)
+        }
+
+        const tools = await db
+          .select()
+          .from(workflowMcpTool)
+          .where(and(eq(workflowMcpTool.serverId, serverId), isNull(workflowMcpTool.archivedAt)))
+
+        logger.info(
+          `[${requestId}] Found workflow MCP server: ${server.name} with ${tools.length} tools`
+        )
+
+        return createMcpSuccessResponse({ server, tools })
+      } catch (error) {
+        logger.error(`[${requestId}] Error getting workflow MCP server:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to get workflow MCP server', 500)
+      }
+    }
+  )
+)
+
+/**
+ * PATCH - Update a workflow MCP server
+ */
+export const PATCH = withRouteHandler(
+  withMcpAuth<RouteParams>('write')(
+    async (
+      request: NextRequest,
+      { userId, userName, userEmail, workspaceId, requestId },
+      { params }
+    ) => {
+      try {
+        const { id: serverId } = workflowMcpServerParamsSchema.parse(await params)
+        const rawBody = await readMcpJsonBodyWithLimit(request)
+        const parsedBody = updateWorkflowMcpServerBodySchema.safeParse(rawBody)
+
+        if (!parsedBody.success) {
+          return createMcpErrorResponse(parsedBody.error, 'Invalid request format', 400)
+        }
+
+        const body = parsedBody.data
+
+        logger.info(`[${requestId}] Updating workflow MCP server: ${serverId}`)
+
+        const result = await performUpdateWorkflowMcpServer({
+          serverId,
+          workspaceId,
+          userId,
+          actorName: userName,
+          actorEmail: userEmail,
+          name: body.name,
+          description: body.description,
+          isPublic: body.isPublic,
+        })
+        if (!result.success || !result.server) {
+          const status = mcpOrchestrationStatus(result.errorCode)
+          return createMcpErrorResponse(
+            new Error(result.error || 'Failed to update workflow MCP server'),
+            result.error || 'Failed to update workflow MCP server',
+            status
+          )
+        }
+
+        const updatedServer = result.server
+
+        logger.info(`[${requestId}] Successfully updated workflow MCP server: ${serverId}`)
+
+        return createMcpSuccessResponse({ server: updatedServer })
+      } catch (error) {
+        const bodyErrorResponse = mcpBodyReadErrorResponse(error, request)
+        if (bodyErrorResponse) return bodyErrorResponse
+        logger.error(`[${requestId}] Error updating workflow MCP server:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to update workflow MCP server', 500)
+      }
+    }
+  )
+)
+
+/**
+ * DELETE - Delete a workflow MCP server and all its tools
+ */
+export const DELETE = withRouteHandler(
+  withMcpAuth<RouteParams>('write')(
+    async (
+      request: NextRequest,
+      { userId, userName, userEmail, workspaceId, requestId },
+      { params }
+    ) => {
+      try {
+        const { id: serverId } = workflowMcpServerParamsSchema.parse(await params)
+
+        logger.info(`[${requestId}] Deleting workflow MCP server: ${serverId}`)
+
+        const result = await performDeleteWorkflowMcpServer({
+          serverId,
+          workspaceId,
+          userId,
+          actorName: userName,
+          actorEmail: userEmail,
+        })
+        if (!result.success || !result.server) {
+          return createMcpErrorResponse(
+            new Error(result.error || 'Server not found'),
+            result.error || 'Server not found',
+            mcpOrchestrationStatus(result.errorCode)
+          )
+        }
+        const deletedServer = result.server
+
+        logger.info(`[${requestId}] Successfully deleted workflow MCP server: ${serverId}`)
+
+        return createMcpSuccessResponse({ message: `Server ${serverId} deleted successfully` })
+      } catch (error) {
+        logger.error(`[${requestId}] Error deleting workflow MCP server:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to delete workflow MCP server', 500)
+      }
+    }
+  )
+)

apps/sim/app/api/mcp/workflow-servers/[id]/tools/[toolId]/route.ts

@@ -0,0 +1,184 @@
+import { db } from '@sim/db'
+import { workflowMcpServer, workflowMcpTool } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { and, eq, isNull } from 'drizzle-orm'
+import type { NextRequest } from 'next/server'
+import {
+  updateWorkflowMcpToolBodySchema,
+  workflowMcpToolParamsSchema,
+} from '@/lib/api/contracts/workflow-mcp-servers'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import {
+  mcpBodyReadErrorResponse,
+  readMcpJsonBodyWithLimit,
+  withMcpAuth,
+} from '@/lib/mcp/middleware'
+import { performDeleteWorkflowMcpTool, performUpdateWorkflowMcpTool } from '@/lib/mcp/orchestration'
+import {
+  createMcpErrorResponse,
+  createMcpSuccessResponse,
+  mcpOrchestrationStatus,
+} from '@/lib/mcp/utils'
+
+const logger = createLogger('WorkflowMcpToolAPI')
+
+export const dynamic = 'force-dynamic'
+
+interface RouteParams {
+  id: string
+  toolId: string
+}
+
+/**
+ * GET - Get a specific tool
+ */
+export const GET = withRouteHandler(
+  withMcpAuth<RouteParams>('read')(
+    async (request: NextRequest, { userId, workspaceId, requestId }, { params }) => {
+      try {
+        const { id: serverId, toolId } = workflowMcpToolParamsSchema.parse(await params)
+
+        logger.info(`[${requestId}] Getting tool ${toolId} from server ${serverId}`)
+
+        const [server] = await db
+          .select({ id: workflowMcpServer.id })
+          .from(workflowMcpServer)
+          .where(
+            and(
+              eq(workflowMcpServer.id, serverId),
+              eq(workflowMcpServer.workspaceId, workspaceId),
+              isNull(workflowMcpServer.deletedAt)
+            )
+          )
+          .limit(1)
+
+        if (!server) {
+          return createMcpErrorResponse(new Error('Server not found'), 'Server not found', 404)
+        }
+
+        const [tool] = await db
+          .select()
+          .from(workflowMcpTool)
+          .where(
+            and(
+              eq(workflowMcpTool.id, toolId),
+              eq(workflowMcpTool.serverId, serverId),
+              isNull(workflowMcpTool.archivedAt)
+            )
+          )
+          .limit(1)
+
+        if (!tool) {
+          return createMcpErrorResponse(new Error('Tool not found'), 'Tool not found', 404)
+        }
+
+        return createMcpSuccessResponse({ tool })
+      } catch (error) {
+        logger.error(`[${requestId}] Error getting tool:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to get tool', 500)
+      }
+    }
+  )
+)
+
+/**
+ * PATCH - Update a tool's configuration
+ */
+export const PATCH = withRouteHandler(
+  withMcpAuth<RouteParams>('write')(
+    async (
+      request: NextRequest,
+      { userId, userName, userEmail, workspaceId, requestId },
+      { params }
+    ) => {
+      try {
+        const { id: serverId, toolId } = workflowMcpToolParamsSchema.parse(await params)
+        const rawBody = await readMcpJsonBodyWithLimit(request)
+        const parsedBody = updateWorkflowMcpToolBodySchema.safeParse(rawBody)
+
+        if (!parsedBody.success) {
+          return createMcpErrorResponse(parsedBody.error, 'Invalid request format', 400)
+        }
+
+        const body = parsedBody.data
+
+        logger.info(`[${requestId}] Updating tool ${toolId} in server ${serverId}`)
+
+        const result = await performUpdateWorkflowMcpTool({
+          serverId,
+          toolId,
+          workspaceId,
+          userId,
+          actorName: userName,
+          actorEmail: userEmail,
+          toolName: body.toolName,
+          toolDescription: body.toolDescription,
+          parameterDescriptionOverrides: body.parameterDescriptionOverrides,
+          parameterSchema: body.parameterSchema,
+        })
+        if (!result.success || !result.tool) {
+          return createMcpErrorResponse(
+            new Error(result.error || 'Failed to update tool'),
+            result.error || 'Failed to update tool',
+            mcpOrchestrationStatus(result.errorCode)
+          )
+        }
+
+        const updatedTool = result.tool
+
+        logger.info(`[${requestId}] Successfully updated tool ${toolId}`)
+
+        return createMcpSuccessResponse({ tool: updatedTool })
+      } catch (error) {
+        const bodyErrorResponse = mcpBodyReadErrorResponse(error, request)
+        if (bodyErrorResponse) return bodyErrorResponse
+        logger.error(`[${requestId}] Error updating tool:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to update tool', 500)
+      }
+    }
+  )
+)
+
+/**
+ * DELETE - Remove a tool from an MCP server
+ */
+export const DELETE = withRouteHandler(
+  withMcpAuth<RouteParams>('write')(
+    async (
+      request: NextRequest,
+      { userId, userName, userEmail, workspaceId, requestId },
+      { params }
+    ) => {
+      try {
+        const { id: serverId, toolId } = workflowMcpToolParamsSchema.parse(await params)
+
+        logger.info(`[${requestId}] Deleting tool ${toolId} from server ${serverId}`)
+
+        const result = await performDeleteWorkflowMcpTool({
+          serverId,
+          toolId,
+          workspaceId,
+          userId,
+          actorName: userName,
+          actorEmail: userEmail,
+        })
+        if (!result.success || !result.tool) {
+          return createMcpErrorResponse(
+            new Error(result.error || 'Tool not found'),
+            result.error || 'Tool not found',
+            mcpOrchestrationStatus(result.errorCode)
+          )
+        }
+        const deletedTool = result.tool
+
+        logger.info(`[${requestId}] Successfully deleted tool ${toolId}`)
+
+        return createMcpSuccessResponse({ message: `Tool ${toolId} deleted successfully` })
+      } catch (error) {
+        logger.error(`[${requestId}] Error deleting tool:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to delete tool', 500)
+      }
+    }
+  )
+)

apps/sim/app/api/mcp/workflow-servers/[id]/tools/route.ts

@@ -0,0 +1,152 @@
+import { db } from '@sim/db'
+import { workflow, workflowMcpServer, workflowMcpTool } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { and, eq, isNull } from 'drizzle-orm'
+import type { NextRequest } from 'next/server'
+import {
+  createWorkflowMcpToolBodySchema,
+  workflowMcpServerParamsSchema,
+} from '@/lib/api/contracts/workflow-mcp-servers'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import {
+  mcpBodyReadErrorResponse,
+  readMcpJsonBodyWithLimit,
+  withMcpAuth,
+} from '@/lib/mcp/middleware'
+import { performCreateWorkflowMcpTool } from '@/lib/mcp/orchestration'
+import {
+  createMcpErrorResponse,
+  createMcpSuccessResponse,
+  mcpOrchestrationStatus,
+} from '@/lib/mcp/utils'
+
+const logger = createLogger('WorkflowMcpToolsAPI')
+
+export const dynamic = 'force-dynamic'
+
+interface RouteParams {
+  id: string
+}
+
+/**
+ * GET - List all tools for a workflow MCP server
+ */
+export const GET = withRouteHandler(
+  withMcpAuth<RouteParams>('read')(
+    async (request: NextRequest, { userId, workspaceId, requestId }, { params }) => {
+      try {
+        const { id: serverId } = workflowMcpServerParamsSchema.parse(await params)
+
+        logger.info(`[${requestId}] Listing tools for workflow MCP server: ${serverId}`)
+
+        const [server] = await db
+          .select({ id: workflowMcpServer.id })
+          .from(workflowMcpServer)
+          .where(
+            and(
+              eq(workflowMcpServer.id, serverId),
+              eq(workflowMcpServer.workspaceId, workspaceId),
+              isNull(workflowMcpServer.deletedAt)
+            )
+          )
+          .limit(1)
+
+        if (!server) {
+          return createMcpErrorResponse(new Error('Server not found'), 'Server not found', 404)
+        }
+
+        const tools = await db
+          .select({
+            id: workflowMcpTool.id,
+            serverId: workflowMcpTool.serverId,
+            workflowId: workflowMcpTool.workflowId,
+            toolName: workflowMcpTool.toolName,
+            toolDescription: workflowMcpTool.toolDescription,
+            parameterSchema: workflowMcpTool.parameterSchema,
+            parameterDescriptionOverrides: workflowMcpTool.parameterDescriptionOverrides,
+            createdAt: workflowMcpTool.createdAt,
+            updatedAt: workflowMcpTool.updatedAt,
+            workflowName: workflow.name,
+            workflowDescription: workflow.description,
+            isDeployed: workflow.isDeployed,
+          })
+          .from(workflowMcpTool)
+          .leftJoin(
+            workflow,
+            and(eq(workflowMcpTool.workflowId, workflow.id), isNull(workflow.archivedAt))
+          )
+          .where(and(eq(workflowMcpTool.serverId, serverId), isNull(workflowMcpTool.archivedAt)))
+
+        logger.info(`[${requestId}] Found ${tools.length} tools for server ${serverId}`)
+
+        return createMcpSuccessResponse({ tools })
+      } catch (error) {
+        logger.error(`[${requestId}] Error listing tools:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to list tools', 500)
+      }
+    }
+  )
+)
+
+/**
+ * POST - Add a workflow as a tool to an MCP server
+ */
+export const POST = withRouteHandler(
+  withMcpAuth<RouteParams>('write')(
+    async (
+      request: NextRequest,
+      { userId, userName, userEmail, workspaceId, requestId },
+      { params }
+    ) => {
+      try {
+        const { id: serverId } = workflowMcpServerParamsSchema.parse(await params)
+        const rawBody = await readMcpJsonBodyWithLimit(request)
+        const parsedBody = createWorkflowMcpToolBodySchema.safeParse(rawBody)
+
+        if (!parsedBody.success) {
+          return createMcpErrorResponse(parsedBody.error, 'Invalid request format', 400)
+        }
+
+        const body = parsedBody.data
+
+        logger.info(`[${requestId}] Adding tool to workflow MCP server: ${serverId}`, {
+          workflowId: body.workflowId,
+        })
+
+        const result = await performCreateWorkflowMcpTool({
+          serverId,
+          workspaceId,
+          userId,
+          actorName: userName,
+          actorEmail: userEmail,
+          workflowId: body.workflowId,
+          toolName: body.toolName,
+          toolDescription: body.toolDescription,
+          parameterDescriptionOverrides: body.parameterDescriptionOverrides,
+          parameterSchema: body.parameterSchema,
+        })
+        if (!result.success || !result.tool) {
+          return createMcpErrorResponse(
+            new Error(result.error || 'Failed to add tool'),
+            result.error || 'Failed to add tool',
+            mcpOrchestrationStatus(result.errorCode)
+          )
+        }
+
+        const tool = result.tool
+
+        logger.info(
+          `[${requestId}] Successfully added tool ${tool.toolName} (workflow: ${body.workflowId}) to server ${serverId}`
+        )
+
+        return createMcpSuccessResponse({ tool }, 201)
+      } catch (error) {
+        const bodyErrorResponse = mcpBodyReadErrorResponse(error, request)
+        if (bodyErrorResponse) return bodyErrorResponse
+        logger.error(`[${requestId}] Error adding tool:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to add tool', 500)
+      }
+    }
+  )
+)

apps/sim/app/api/mcp/workflow-servers/route.ts

@@ -0,0 +1,152 @@
+import { db } from '@sim/db'
+import { workflowMcpServer, workflowMcpTool } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { and, eq, inArray, isNull, sql } from 'drizzle-orm'
+import type { NextRequest } from 'next/server'
+import { createWorkflowMcpServerBodySchema } from '@/lib/api/contracts/workflow-mcp-servers'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import {
+  mcpBodyReadErrorResponse,
+  readMcpJsonBodyWithLimit,
+  withMcpAuth,
+} from '@/lib/mcp/middleware'
+import { performCreateWorkflowMcpServer } from '@/lib/mcp/orchestration'
+import {
+  createMcpErrorResponse,
+  createMcpSuccessResponse,
+  mcpOrchestrationStatus,
+} from '@/lib/mcp/utils'
+
+const logger = createLogger('WorkflowMcpServersAPI')
+
+export const dynamic = 'force-dynamic'
+
+/**
+ * GET - List all workflow MCP servers for the workspace
+ */
+export const GET = withRouteHandler(
+  withMcpAuth('read')(async (request: NextRequest, { userId, workspaceId, requestId }) => {
+    try {
+      logger.info(`[${requestId}] Listing workflow MCP servers for workspace ${workspaceId}`)
+
+      const servers = await db
+        .select({
+          id: workflowMcpServer.id,
+          workspaceId: workflowMcpServer.workspaceId,
+          createdBy: workflowMcpServer.createdBy,
+          name: workflowMcpServer.name,
+          description: workflowMcpServer.description,
+          isPublic: workflowMcpServer.isPublic,
+          createdAt: workflowMcpServer.createdAt,
+          updatedAt: workflowMcpServer.updatedAt,
+          toolCount: sql<number>`(
+            SELECT COUNT(*)::int
+            FROM "workflow_mcp_tool"
+            WHERE "workflow_mcp_tool"."server_id" = "workflow_mcp_server"."id"
+              AND "workflow_mcp_tool"."archived_at" IS NULL
+          )`.as('tool_count'),
+        })
+        .from(workflowMcpServer)
+        .where(
+          and(eq(workflowMcpServer.workspaceId, workspaceId), isNull(workflowMcpServer.deletedAt))
+        )
+
+      const serverIds = servers.map((s) => s.id)
+      const tools =
+        serverIds.length > 0
+          ? await db
+              .select({
+                serverId: workflowMcpTool.serverId,
+                toolName: workflowMcpTool.toolName,
+              })
+              .from(workflowMcpTool)
+              .where(
+                and(
+                  inArray(workflowMcpTool.serverId, serverIds),
+                  isNull(workflowMcpTool.archivedAt)
+                )
+              )
+          : []
+
+      const toolNamesByServer: Record<string, string[]> = {}
+      for (const tool of tools) {
+        if (!toolNamesByServer[tool.serverId]) {
+          toolNamesByServer[tool.serverId] = []
+        }
+        toolNamesByServer[tool.serverId].push(tool.toolName)
+      }
+
+      const serversWithToolNames = servers.map((server) => ({
+        ...server,
+        toolNames: toolNamesByServer[server.id] || [],
+      }))
+
+      logger.info(
+        `[${requestId}] Listed ${servers.length} workflow MCP servers for workspace ${workspaceId}`
+      )
+      return createMcpSuccessResponse({ servers: serversWithToolNames })
+    } catch (error) {
+      logger.error(`[${requestId}] Error listing workflow MCP servers:`, error)
+      return createMcpErrorResponse(toError(error), 'Failed to list workflow MCP servers', 500)
+    }
+  })
+)
+
+/**
+ * POST - Create a new workflow MCP server
+ */
+export const POST = withRouteHandler(
+  withMcpAuth('write')(
+    async (request: NextRequest, { userId, userName, userEmail, workspaceId, requestId }) => {
+      try {
+        const rawBody = await readMcpJsonBodyWithLimit(request)
+        const parsedBody = createWorkflowMcpServerBodySchema.safeParse(rawBody)
+
+        if (!parsedBody.success) {
+          return createMcpErrorResponse(parsedBody.error, 'Invalid request format', 400)
+        }
+
+        const body = parsedBody.data
+
+        logger.info(`[${requestId}] Creating workflow MCP server:`, {
+          name: body.name,
+          workspaceId,
+          workflowIds: body.workflowIds,
+        })
+
+        const result = await performCreateWorkflowMcpServer({
+          workspaceId,
+          userId,
+          actorName: userName,
+          actorEmail: userEmail,
+          name: body.name,
+          description: body.description,
+          isPublic: body.isPublic,
+          workflowIds: body.workflowIds,
+        })
+        if (!result.success || !result.server) {
+          return createMcpErrorResponse(
+            new Error(result.error || 'Failed to create workflow MCP server'),
+            result.error || 'Failed to create workflow MCP server',
+            mcpOrchestrationStatus(result.errorCode)
+          )
+        }
+
+        const { server } = result
+        const addedTools = result.addedTools || []
+
+        logger.info(
+          `[${requestId}] Successfully created workflow MCP server: ${body.name} (ID: ${server.id})`
+        )
+
+        return createMcpSuccessResponse({ server, addedTools }, 201)
+      } catch (error) {
+        const bodyErrorResponse = mcpBodyReadErrorResponse(error, request)
+        if (bodyErrorResponse) return bodyErrorResponse
+        logger.error(`[${requestId}] Error creating workflow MCP server:`, error)
+        return createMcpErrorResponse(toError(error), 'Failed to create workflow MCP server', 500)
+      }
+    }
+  )
+)