chore: import upstream snapshot with attribution

apps/sim/app/api/tools/discord/channels/route.ts

@@ -0,0 +1,141 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { discordChannelsContract } from '@/lib/api/contracts/tools/communication/discord'
+import { parseRequest } from '@/lib/api/server'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { validateNumericId } from '@/lib/core/security/input-validation'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+interface DiscordChannel {
+  id: string
+  name: string
+  type: number
+  guild_id?: string
+}
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('DiscordChannelsAPI')
+
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  const auth = await checkInternalAuth(request)
+  if (!auth.success || !auth.userId) {
+    return NextResponse.json({ error: auth.error || 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const parsed = await parseRequest(discordChannelsContract, request, {})
+    if (!parsed.success) return parsed.response
+    const { botToken, serverId, channelId } = parsed.data.body
+
+    const serverIdValidation = validateNumericId(serverId, 'serverId')
+    if (!serverIdValidation.isValid) {
+      logger.error(`Invalid server ID: ${serverIdValidation.error}`)
+      return NextResponse.json({ error: serverIdValidation.error }, { status: 400 })
+    }
+
+    if (channelId) {
+      const channelIdValidation = validateNumericId(channelId, 'channelId')
+      if (!channelIdValidation.isValid) {
+        logger.error(`Invalid channel ID: ${channelIdValidation.error}`)
+        return NextResponse.json({ error: channelIdValidation.error }, { status: 400 })
+      }
+
+      logger.info(`Fetching single Discord channel: ${channelId}`)
+
+      const response = await fetch(`https://discord.com/api/v10/channels/${channelId}`, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bot ${botToken}`,
+          'Content-Type': 'application/json',
+        },
+      })
+
+      if (!response.ok) {
+        logger.error('Discord API error fetching channel:', {
+          status: response.status,
+          statusText: response.statusText,
+        })
+
+        let errorMessage
+        try {
+          const errorData = await response.json()
+          logger.error('Error details:', errorData)
+          errorMessage = errorData.message || `Failed to fetch channel (${response.status})`
+        } catch (_e) {
+          errorMessage = `Failed to fetch channel: ${response.status} ${response.statusText}`
+        }
+        return NextResponse.json({ error: errorMessage }, { status: response.status })
+      }
+
+      const channel = (await response.json()) as DiscordChannel
+
+      if (channel.guild_id !== serverId) {
+        logger.error('Channel does not belong to the specified server')
+        return NextResponse.json(
+          { error: 'Channel not found in specified server' },
+          { status: 404 }
+        )
+      }
+
+      if (channel.type !== 0) {
+        logger.warn('Requested channel is not a text channel')
+        return NextResponse.json({ error: 'Channel is not a text channel' }, { status: 400 })
+      }
+
+      logger.info(`Successfully fetched channel: ${channel.name}`)
+
+      return NextResponse.json({
+        channel: {
+          id: channel.id,
+          name: channel.name,
+          type: channel.type,
+        },
+      })
+    }
+
+    logger.info(`Fetching all Discord channels for server: ${serverId}`)
+
+    const response = await fetch(`https://discord.com/api/v10/guilds/${serverId}/channels`, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bot ${botToken}`,
+        'Content-Type': 'application/json',
+      },
+    })
+
+    if (!response.ok) {
+      logger.warn(
+        'Discord API returned non-OK for channels; returning empty list to avoid UX break',
+        {
+          status: response.status,
+          statusText: response.statusText,
+        }
+      )
+      return NextResponse.json({ channels: [] })
+    }
+
+    const channels = (await response.json()) as DiscordChannel[]
+
+    const textChannels = channels.filter((channel: DiscordChannel) => channel.type === 0)
+
+    logger.info(`Successfully fetched ${textChannels.length} text channels`)
+
+    return NextResponse.json({
+      channels: textChannels.map((channel: DiscordChannel) => ({
+        id: channel.id,
+        name: channel.name,
+        type: channel.type,
+      })),
+    })
+  } catch (error) {
+    logger.error('Error processing request:', error)
+    return NextResponse.json(
+      {
+        error: 'Failed to retrieve Discord channels',
+        details: (error as Error).message,
+      },
+      { status: 500 }
+    )
+  }
+})

apps/sim/app/api/tools/discord/send-message/route.ts

@@ -0,0 +1,226 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import { discordSendMessageContract } from '@/lib/api/contracts/tools/communication/discord'
+import { parseRequest } from '@/lib/api/server'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { validateNumericId } from '@/lib/core/security/input-validation'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { processFilesToUserFiles } from '@/lib/uploads/utils/file-utils'
+import { downloadServableFileFromStorage } from '@/lib/uploads/utils/file-utils.server'
+import { docNotReadyResponse } from '@/lib/uploads/utils/servable-file-response'
+import { assertToolFileAccess } from '@/app/api/files/authorization'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('DiscordSendMessageAPI')
+
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request, { requireWorkflowId: false })
+
+    if (!authResult.success || !authResult.userId) {
+      logger.warn(`[${requestId}] Unauthorized Discord send attempt: ${authResult.error}`)
+      return NextResponse.json(
+        {
+          success: false,
+          error: authResult.error || 'Authentication required',
+        },
+        { status: 401 }
+      )
+    }
+
+    const userId = authResult.userId
+    logger.info(`[${requestId}] Authenticated Discord send request via ${authResult.authType}`, {
+      userId,
+    })
+
+    const parsed = await parseRequest(discordSendMessageContract, request, {})
+    if (!parsed.success) return parsed.response
+    const validatedData = parsed.data.body
+
+    const channelIdValidation = validateNumericId(validatedData.channelId, 'channelId')
+    if (!channelIdValidation.isValid) {
+      logger.warn(`[${requestId}] Invalid channelId format`, {
+        error: channelIdValidation.error,
+      })
+      return NextResponse.json(
+        { success: false, error: channelIdValidation.error },
+        { status: 400 }
+      )
+    }
+
+    logger.info(`[${requestId}] Sending Discord message`, {
+      channelId: validatedData.channelId,
+      hasFiles: !!(validatedData.files && validatedData.files.length > 0),
+      fileCount: validatedData.files?.length || 0,
+    })
+
+    const discordApiUrl = `https://discord.com/api/v10/channels/${validatedData.channelId}/messages`
+
+    if (!validatedData.files || validatedData.files.length === 0) {
+      logger.info(`[${requestId}] No files, using JSON POST`)
+
+      const response = await fetch(discordApiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bot ${validatedData.botToken}`,
+        },
+        body: JSON.stringify({
+          content: validatedData.content || '',
+        }),
+      })
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}))
+        logger.error(`[${requestId}] Discord API error:`, errorData)
+        return NextResponse.json(
+          {
+            success: false,
+            error: errorData.message || 'Failed to send message',
+          },
+          { status: response.status }
+        )
+      }
+
+      const data = await response.json()
+      logger.info(`[${requestId}] Message sent successfully`)
+      return NextResponse.json({
+        success: true,
+        output: {
+          message: data.content,
+          data: data,
+        },
+      })
+    }
+
+    logger.info(`[${requestId}] Processing ${validatedData.files.length} file(s)`)
+
+    const userFiles = processFilesToUserFiles(validatedData.files, requestId, logger)
+    const filesOutput: Array<{
+      name: string
+      mimeType: string
+      data: string
+      size: number
+    }> = []
+
+    if (userFiles.length === 0) {
+      logger.warn(`[${requestId}] No valid files to upload, falling back to text-only`)
+      const response = await fetch(discordApiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bot ${validatedData.botToken}`,
+        },
+        body: JSON.stringify({
+          content: validatedData.content || '',
+        }),
+      })
+
+      const data = await response.json()
+      return NextResponse.json({
+        success: true,
+        output: {
+          message: data.content,
+          data: data,
+        },
+      })
+    }
+
+    const formData = new FormData()
+
+    const payload = {
+      content: validatedData.content || '',
+    }
+    formData.append('payload_json', JSON.stringify(payload))
+
+    const accessResults = await Promise.all(
+      userFiles.map((file) => assertToolFileAccess(file.key, userId, requestId, logger))
+    )
+    const denied = accessResults.find((r) => r !== null)
+    if (denied) return denied
+
+    let resolved: Array<{ buffer: Buffer; contentType: string }>
+    try {
+      resolved = await Promise.all(
+        userFiles.map(async (file, i) => {
+          logger.info(`[${requestId}] Downloading file ${i}: ${file.name}`)
+          return await downloadServableFileFromStorage(file, requestId, logger)
+        })
+      )
+    } catch (error) {
+      const notReady = docNotReadyResponse(error)
+      if (notReady) return notReady
+      logger.error(`[${requestId}] Failed to download an attachment:`, error)
+      return NextResponse.json(
+        {
+          success: false,
+          error: `Failed to download attachment: ${getErrorMessage(error, 'Unknown error')}`,
+        },
+        { status: 500 }
+      )
+    }
+
+    for (let i = 0; i < userFiles.length; i++) {
+      const userFile = userFiles[i]
+      const buffer = resolved[i].buffer
+      const mimeType = resolved[i].contentType || userFile.type || 'application/octet-stream'
+      logger.info(`[${requestId}] Added file ${i}: ${userFile.name} (${buffer.length} bytes)`)
+      filesOutput.push({
+        name: userFile.name,
+        mimeType,
+        data: buffer.toString('base64'),
+        size: buffer.length,
+      })
+      const blob = new Blob([new Uint8Array(buffer)], { type: mimeType })
+      formData.append(`files[${i}]`, blob, userFile.name)
+    }
+
+    logger.info(`[${requestId}] Sending multipart request with ${userFiles.length} file(s)`)
+    const response = await fetch(discordApiUrl, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bot ${validatedData.botToken}`,
+      },
+      body: formData,
+    })
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}))
+      logger.error(`[${requestId}] Discord API error:`, errorData)
+      return NextResponse.json(
+        {
+          success: false,
+          error: errorData.message || 'Failed to send message with files',
+        },
+        { status: response.status }
+      )
+    }
+
+    const data = await response.json()
+    logger.info(`[${requestId}] Message with files sent successfully`)
+
+    return NextResponse.json({
+      success: true,
+      output: {
+        message: data.content,
+        data: data,
+        fileCount: userFiles.length,
+        files: filesOutput,
+      },
+    })
+  } catch (error) {
+    logger.error(`[${requestId}] Error sending Discord message:`, error)
+    return NextResponse.json(
+      {
+        success: false,
+        error: getErrorMessage(error, 'Unknown error occurred'),
+      },
+      { status: 500 }
+    )
+  }
+})

apps/sim/app/api/tools/discord/servers/route.ts

@@ -0,0 +1,92 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { discordServersContract } from '@/lib/api/contracts/tools/communication/discord'
+import { parseRequest } from '@/lib/api/server'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { validateNumericId } from '@/lib/core/security/input-validation'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+interface DiscordServer {
+  id: string
+  name: string
+  icon: string | null
+}
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('DiscordServersAPI')
+
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  const auth = await checkInternalAuth(request)
+  if (!auth.success || !auth.userId) {
+    return NextResponse.json({ error: auth.error || 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const parsed = await parseRequest(discordServersContract, request, {})
+    if (!parsed.success) return parsed.response
+    const { botToken, serverId } = parsed.data.body
+
+    if (serverId) {
+      const serverIdValidation = validateNumericId(serverId, 'serverId')
+      if (!serverIdValidation.isValid) {
+        logger.error(`Invalid server ID: ${serverIdValidation.error}`)
+        return NextResponse.json({ error: serverIdValidation.error }, { status: 400 })
+      }
+
+      logger.info(`Fetching single Discord server: ${serverId}`)
+
+      const response = await fetch(`https://discord.com/api/v10/guilds/${serverId}`, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bot ${botToken}`,
+          'Content-Type': 'application/json',
+        },
+      })
+
+      if (!response.ok) {
+        logger.error('Discord API error fetching server:', {
+          status: response.status,
+          statusText: response.statusText,
+        })
+
+        let errorMessage
+        try {
+          const errorData = await response.json()
+          logger.error('Error details:', errorData)
+          errorMessage = errorData.message || `Failed to fetch server (${response.status})`
+        } catch (_e) {
+          errorMessage = `Failed to fetch server: ${response.status} ${response.statusText}`
+        }
+        return NextResponse.json({ error: errorMessage }, { status: response.status })
+      }
+
+      const server = (await response.json()) as DiscordServer
+      logger.info(`Successfully fetched server: ${server.name}`)
+
+      return NextResponse.json({
+        server: {
+          id: server.id,
+          name: server.name,
+          icon: server.icon
+            ? `https://cdn.discordapp.com/icons/${server.id}/${server.icon}.png`
+            : null,
+        },
+      })
+    }
+
+    logger.info(
+      'Skipping guild listing: bot token cannot list /users/@me/guilds; returning empty list'
+    )
+    return NextResponse.json({ servers: [] })
+  } catch (error) {
+    logger.error('Error processing request:', error)
+    return NextResponse.json(
+      {
+        error: 'Failed to retrieve Discord servers',
+        details: (error as Error).message,
+      },
+      { status: 500 }
+    )
+  }
+})