@otto-assistant/otto 0.1.2 → 0.7.16

package/src/discord-utils.ts

@@ -0,0 +1,846 @@
+// Discord-specific utility functions.
+// Handles markdown splitting for Discord's 2000-char limit, code block escaping,
+// thread message sending, and channel metadata extraction from topic tags.
+
+// Use namespace import for CJS interop — discord.js is CJS and its named
+// exports aren't detectable by all ESM loaders (e.g. tsx/esbuild) because
+// discord.js uses tslib's __exportStar which is opaque to static analysis.
+import * as discord from 'discord.js'
+import type {
+  APIInteractionGuildMember,
+  AutocompleteInteraction,
+  GuildMember as GuildMemberType,
+  Guild,
+  Message,
+  REST as RESTType,
+  TextChannel,
+  ThreadChannel,
+} from 'discord.js'
+const { ChannelType, GuildMember, MessageFlags, PermissionsBitField, REST, Routes } = discord
+import type { OpencodeClient } from '@opencode-ai/sdk/v2'
+import { discordApiUrl } from './discord-urls.js'
+import { Lexer } from 'marked'
+import { splitTablesFromMarkdown } from './format-tables.js'
+import { getChannelDirectory, getThreadWorktree } from './database.js'
+import { limitHeadingDepth } from './limit-heading-depth.js'
+import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js'
+import { createLogger, LogPrefix } from './logger.js'
+import * as errore from 'errore'
+import mime from 'mime'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const discordLogger = createLogger(LogPrefix.DISCORD)
+
+/**
+ * Centralized permission check for Otto bot access.
+ * Returns true if the member has permission to use the bot:
+ * - Server owner, Administrator, Manage Server, or "Otto" role (case-insensitive).
+ * Also accepts the legacy "Kimaki" role for backward compat on existing servers.
+ * Returns false if member is null or has the "no-otto" / "no-otto" role (overrides all).
+ */
+export function hasOttoBotPermission(
+  member: GuildMemberType | APIInteractionGuildMember | null,
+  guild?: Guild | null,
+): boolean {
+  if (!member) {
+    return false
+  }
+  // Accept both "no-otto" and legacy "no-otto" as deny roles
+  const isDenied =
+    hasRoleByName(member, 'no-otto', guild) ||
+    hasRoleByName(member, 'no-otto', guild)
+  if (isDenied) {
+    return false
+  }
+  const memberPermissions =
+    member instanceof GuildMember
+      ? member.permissions
+      : new PermissionsBitField(BigInt(member.permissions))
+  const ownerId = member instanceof GuildMember ? member.guild.ownerId : guild?.ownerId
+  const memberId = member instanceof GuildMember ? member.id : member.user.id
+  const isOwner = ownerId ? memberId === ownerId : false
+  const isAdmin = memberPermissions.has(PermissionsBitField.Flags.Administrator)
+  const canManageServer = memberPermissions.has(PermissionsBitField.Flags.ManageGuild)
+  // Accept both "otto" and legacy "otto" as allow roles
+  const hasOttoRole =
+    hasRoleByName(member, 'otto', guild) || hasRoleByName(member, 'otto', guild)
+  return isOwner || isAdmin || canManageServer || hasOttoRole
+}
+
+// Keep legacy name as alias for callers not yet updated
+export const hasKimakiBotPermission = hasOttoBotPermission
+
+function hasRoleByName(
+  member: GuildMemberType | APIInteractionGuildMember,
+  roleName: string,
+  guild?: Guild | null,
+): boolean {
+  const target = roleName.toLowerCase()
+
+  if (member instanceof GuildMember) {
+    return member.roles.cache.some((role) => role.name.toLowerCase() === target)
+  }
+
+  if (!guild) {
+    return false
+  }
+
+  const roleIds = Array.isArray(member.roles) ? member.roles : []
+  for (const roleId of roleIds) {
+    const role = guild.roles.cache.get(roleId)
+    if (role?.name.toLowerCase() === target) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Check if the member has the "no-otto" (or legacy "no-otto") role that blocks bot access.
+ * Separate from hasOttoBotPermission so callers can show a specific error message.
+ */
+export function hasNoOttoRole(member: GuildMemberType | null): boolean {
+  if (!member?.roles?.cache) {
+    return false
+  }
+  return member.roles.cache.some(
+    (role) =>
+      role.name.toLowerCase() === 'no-otto' ||
+      role.name.toLowerCase() === 'no-otto',
+  )
+}
+
+// Keep legacy name as alias
+export const hasNoKimakiRole = hasNoOttoRole
+
+/**
+ * React to a thread's starter message with an emoji.
+ * Thread ID equals the starter message ID in Discord.
+ */
+export async function reactToThread({
+  rest,
+  threadId,
+  channelId,
+  emoji,
+}: {
+  rest: RESTType
+  threadId: string
+  /** Parent channel ID where the thread starter message lives.
+   * If not provided, fetches the thread info from Discord API to resolve it. */
+  channelId?: string
+  emoji: string
+}): Promise<void> {
+  const parentChannelId = await (async () => {
+    if (channelId) {
+      return channelId
+    }
+    // Fetch the thread to get its parent channel ID
+    const threadResult = await errore.tryAsync(() => {
+      return rest.get(Routes.channel(threadId)) as Promise<{
+        parent_id?: string
+      }>
+    })
+    if (threadResult instanceof Error) {
+      discordLogger.warn(
+        `Failed to fetch thread ${threadId}:`,
+        threadResult.message,
+      )
+      return null
+    }
+    return threadResult.parent_id || null
+  })()
+
+  if (!parentChannelId) {
+    discordLogger.warn(
+      `Could not resolve parent channel for thread ${threadId}`,
+    )
+    return
+  }
+
+  // React to the thread starter message in the parent channel.
+  // Thread ID equals the starter message ID for threads created from messages.
+  const result = await errore.tryAsync(() => {
+    return rest.put(
+      Routes.channelMessageOwnReaction(
+        parentChannelId,
+        threadId,
+        encodeURIComponent(emoji),
+      ),
+    )
+  })
+  if (result instanceof Error) {
+    discordLogger.warn(
+      `Failed to react to thread ${threadId} with ${emoji}:`,
+      result.message,
+    )
+  }
+}
+
+export async function archiveThread({
+  rest,
+  threadId,
+  parentChannelId,
+  sessionId,
+  client,
+  archiveDelay = 0,
+}: {
+  rest: RESTType
+  threadId: string
+  parentChannelId?: string
+  sessionId?: string
+  client?: OpencodeClient | null
+  archiveDelay?: number
+}): Promise<void> {
+  await reactToThread({
+    rest,
+    threadId,
+    channelId: parentChannelId,
+    emoji: '📁',
+  })
+
+  if (client && sessionId) {
+    await softArchiveSession({ client, sessionId })
+  }
+
+  if (archiveDelay > 0) {
+    await new Promise<void>((resolve) => {
+      setTimeout(() => {
+        resolve()
+      }, archiveDelay)
+    })
+  }
+
+  await rest.patch(Routes.channel(threadId), {
+    body: { archived: true },
+  })
+}
+
+export async function softArchiveSession({
+  client,
+  sessionId,
+}: {
+  client: OpencodeClient
+  sessionId: string
+}): Promise<void> {
+  const updateResult = await errore.tryAsync({
+    try: async () => {
+      const sessionResponse = await client.session.get({
+        sessionID: sessionId,
+      })
+      if (!sessionResponse.data) {
+        return
+      }
+      const currentTitle = sessionResponse.data.title || ''
+      const newTitle = currentTitle.startsWith('📁')
+        ? currentTitle
+        : `📁 ${currentTitle}`.trim()
+      await client.session.update({
+        sessionID: sessionId,
+        title: newTitle,
+      })
+    },
+    catch: (e) => new Error('Failed to update session title', { cause: e }),
+  })
+  if (updateResult instanceof Error) {
+    discordLogger.warn(`[archive-thread] ${updateResult.message}`)
+  }
+
+  const abortResult = await errore.tryAsync({
+    try: async () => {
+      await client.session.abort({ sessionID: sessionId })
+    },
+    catch: (e) => new Error('Failed to abort session', { cause: e }),
+  })
+  if (abortResult instanceof Error) {
+    discordLogger.warn(`[archive-thread] ${abortResult.message}`)
+  }
+}
+
+export async function applyThreadDeletionSyncPolicy({
+  client,
+  sessionId,
+  mode,
+}: {
+  client: OpencodeClient
+  sessionId: string
+  mode: 'soft' | 'hard'
+}): Promise<'soft' | 'hard'> {
+  if (mode === 'hard') {
+    await client.session.delete({ sessionID: sessionId })
+    return 'hard'
+  }
+  await softArchiveSession({ client, sessionId })
+  return 'soft'
+}
+
+/** Remove Discord mentions from text so they don't appear in thread titles */
+export function stripMentions(text: string): string {
+  return text
+    .replace(/<@!?\d+>/g, '') // user mentions
+    .replace(/<@&\d+>/g, '') // role mentions
+    .replace(/<#\d+>/g, '') // channel mentions
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+export const SILENT_MESSAGE_FLAGS = 4 | 4096
+// Same as SILENT but without SuppressNotifications - triggers badge/notification
+export const NOTIFY_MESSAGE_FLAGS = 4
+
+export function escapeBackticksInCodeBlocks(markdown: string): string {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+
+  let result = ''
+
+  for (const token of tokens) {
+    if (token.type === 'code') {
+      const escapedCode = token.text.replace(/`/g, '\\`')
+      result += '```' + (token.lang || '') + '\n' + escapedCode + '\n```\n'
+    } else {
+      result += token.raw
+    }
+  }
+
+  return result
+}
+
+type LineInfo = {
+  text: string
+  inCodeBlock: boolean
+  lang: string
+  isOpeningFence: boolean
+  isClosingFence: boolean
+}
+
+export function splitMarkdownForDiscord({
+  content,
+  maxLength,
+}: {
+  content: string
+  maxLength: number
+}): string[] {
+  if (content.length <= maxLength) {
+    return [content]
+  }
+
+  const lexer = new Lexer()
+  const tokens = lexer.lex(content)
+
+  const lines: LineInfo[] = []
+  const ensureNewlineBeforeCode = (): void => {
+    const last = lines[lines.length - 1]
+    if (!last) {
+      return
+    }
+    if (last.text.endsWith('\n')) {
+      return
+    }
+    lines.push({
+      text: '\n',
+      inCodeBlock: false,
+      lang: '',
+      isOpeningFence: false,
+      isClosingFence: false,
+    })
+  }
+  for (const token of tokens) {
+    if (token.type === 'code') {
+      ensureNewlineBeforeCode()
+      const lang = token.lang || ''
+      lines.push({
+        text: '```' + lang + '\n',
+        inCodeBlock: false,
+        lang,
+        isOpeningFence: true,
+        isClosingFence: false,
+      })
+      const codeLines = token.text.split('\n')
+      for (const codeLine of codeLines) {
+        lines.push({
+          text: codeLine + '\n',
+          inCodeBlock: true,
+          lang,
+          isOpeningFence: false,
+          isClosingFence: false,
+        })
+      }
+      lines.push({
+        text: '```\n',
+        inCodeBlock: false,
+        lang: '',
+        isOpeningFence: false,
+        isClosingFence: true,
+      })
+    } else {
+      const rawLines = token.raw.split('\n')
+      for (let i = 0; i < rawLines.length; i++) {
+        const isLast = i === rawLines.length - 1
+        const text = isLast ? rawLines[i]! : rawLines[i]! + '\n'
+        if (text) {
+          lines.push({
+            text,
+            inCodeBlock: false,
+            lang: '',
+            isOpeningFence: false,
+            isClosingFence: false,
+          })
+        }
+      }
+    }
+  }
+
+  const chunks: string[] = []
+  let currentChunk = ''
+  let currentLang: string | null = null
+
+  // helper to split a long line into smaller pieces at word boundaries or hard breaks
+  const splitLongLine = (
+    text: string,
+    available: number,
+    inCode: boolean,
+  ): string[] => {
+    const pieces: string[] = []
+    let remaining = text
+
+    while (remaining.length > available) {
+      let splitAt = available
+      // for non-code, try to split at word boundary
+      if (!inCode) {
+        const lastSpace = remaining.lastIndexOf(' ', available)
+        if (lastSpace > available * 0.5) {
+          splitAt = lastSpace + 1
+        }
+      }
+      pieces.push(remaining.slice(0, splitAt))
+      remaining = remaining.slice(splitAt)
+    }
+    if (remaining) {
+      pieces.push(remaining)
+    }
+    return pieces
+  }
+
+  const closingFence = '```\n'
+
+  for (const line of lines) {
+    // openingFenceSize accounts for the fence text when starting a fresh chunk
+    const openingFenceSize =
+      currentChunk.length === 0 && (line.inCodeBlock || line.isOpeningFence)
+        ? ('```' + line.lang + '\n').length
+        : 0
+    // When opening fence starts a fresh chunk, its size is in openingFenceSize.
+    // Otherwise count it normally so the overflow check doesn't miss the fence text.
+    const lineLength =
+      line.isOpeningFence && currentChunk.length === 0 ? 0 : line.text.length
+    const activeFenceOverhead =
+      currentLang !== null || openingFenceSize > 0 ? closingFence.length : 0
+    const wouldExceed =
+      currentChunk.length +
+        openingFenceSize +
+        lineLength +
+        activeFenceOverhead >
+      maxLength
+
+    if (wouldExceed) {
+      // handle case where single line is longer than maxLength
+      if (line.text.length > maxLength) {
+        // first, flush current chunk if any
+        if (currentChunk) {
+          if (currentLang !== null) {
+            currentChunk += '```\n'
+          }
+          chunks.push(currentChunk)
+          currentChunk = ''
+        }
+
+        // calculate overhead for code block markers
+        const codeBlockOverhead = line.inCodeBlock
+          ? ('```' + line.lang + '\n').length + '```\n'.length
+          : 0
+        // ensure at least 10 chars available, even if maxLength is very small
+        const availablePerChunk = Math.max(
+          10,
+          maxLength - codeBlockOverhead - 50,
+        )
+
+        const pieces = splitLongLine(
+          line.text,
+          availablePerChunk,
+          line.inCodeBlock,
+        )
+
+        for (let i = 0; i < pieces.length; i++) {
+          const piece = pieces[i]!
+          if (line.inCodeBlock) {
+            chunks.push('```' + line.lang + '\n' + piece + '```\n')
+          } else {
+            chunks.push(piece)
+          }
+        }
+
+        currentLang = null
+        continue
+      }
+
+      // normal case: line fits in a chunk but current chunk would overflow
+      if (currentChunk) {
+        if (currentLang !== null) {
+          currentChunk += '```\n'
+        }
+        chunks.push(currentChunk)
+
+        if (line.isClosingFence && currentLang !== null) {
+          currentChunk = ''
+          currentLang = null
+          continue
+        }
+
+        if (line.inCodeBlock || line.isOpeningFence) {
+          const lang = line.lang
+          currentChunk = '```' + lang + '\n'
+          if (!line.isOpeningFence) {
+            currentChunk += line.text
+          }
+          currentLang = lang
+        } else {
+          currentChunk = line.text
+          currentLang = null
+        }
+      } else {
+        // currentChunk is empty but line still exceeds - shouldn't happen after above check
+        const openingFence = line.inCodeBlock || line.isOpeningFence
+        const openingFenceSize = openingFence
+          ? ('```' + line.lang + '\n').length
+          : 0
+        if (
+          line.text.length + openingFenceSize + activeFenceOverhead >
+          maxLength
+        ) {
+          const fencedOverhead = openingFence
+            ? ('```' + line.lang + '\n').length + closingFence.length
+            : 0
+          const availablePerChunk = Math.max(
+            10,
+            maxLength - fencedOverhead - 50,
+          )
+          const pieces = splitLongLine(
+            line.text,
+            availablePerChunk,
+            line.inCodeBlock,
+          )
+          for (const piece of pieces) {
+            if (openingFence) {
+              chunks.push('```' + line.lang + '\n' + piece + closingFence)
+            } else {
+              chunks.push(piece)
+            }
+          }
+          currentChunk = ''
+          currentLang = null
+        } else {
+          if (openingFence) {
+            currentChunk = '```' + line.lang + '\n'
+            if (!line.isOpeningFence) {
+              currentChunk += line.text
+            }
+            currentLang = line.lang
+          } else {
+            currentChunk = line.text
+            currentLang = null
+          }
+        }
+      }
+    } else {
+      currentChunk += line.text
+      if (line.inCodeBlock || line.isOpeningFence) {
+        currentLang = line.lang
+      } else if (line.isClosingFence) {
+        currentLang = null
+      }
+    }
+  }
+
+  if (currentChunk) {
+    if (currentLang !== null) {
+      currentChunk += closingFence
+    }
+    chunks.push(currentChunk)
+  }
+
+  return chunks
+}
+
+export async function sendThreadMessage(
+  thread: ThreadChannel,
+  content: string,
+  options?: { flags?: number },
+): Promise<Message> {
+  const MAX_LENGTH = 2000
+
+  // Split content into text and CV2 component segments (tables → Container components)
+  const segments = splitTablesFromMarkdown(content)
+  const baseFlags = options?.flags ?? SILENT_MESSAGE_FLAGS
+
+  let firstMessage: Message | undefined
+
+  for (const segment of segments) {
+    if (segment.type === 'components') {
+      const message = await thread.send({
+        components: segment.components,
+        flags: MessageFlags.IsComponentsV2 | baseFlags,
+      })
+      if (!firstMessage) {
+        firstMessage = message
+      }
+      continue
+    }
+
+    // Apply text transformations to text segments
+    let text = segment.text
+    text = unnestCodeBlocksFromLists(text)
+    text = limitHeadingDepth(text)
+    text = escapeBackticksInCodeBlocks(text)
+
+    if (!text.trim()) {
+      continue
+    }
+
+    const sendFlags = options?.flags ?? SILENT_MESSAGE_FLAGS
+    const chunks = splitMarkdownForDiscord({
+      content: text,
+      maxLength: MAX_LENGTH,
+    })
+
+    if (chunks.length > 1) {
+      discordLogger.log(
+        `MESSAGE: Splitting ${text.length} chars into ${chunks.length} messages`,
+      )
+    }
+
+    for (let chunk of chunks) {
+      if (!chunk) {
+        continue
+      }
+      // Safety net: hard-truncate if splitting still produced an oversized chunk
+      if (chunk.length > MAX_LENGTH) {
+        chunk = chunk.slice(0, MAX_LENGTH - 4) + '...'
+      }
+      const message = await thread.send({ content: chunk, flags: sendFlags })
+      if (!firstMessage) {
+        firstMessage = message
+      }
+    }
+  }
+
+  return firstMessage!
+}
+
+export async function resolveTextChannel(
+  channel: TextChannel | ThreadChannel | null | undefined,
+): Promise<TextChannel | null> {
+  if (!channel) {
+    return null
+  }
+
+  if (channel.type === ChannelType.GuildText) {
+    return channel as TextChannel
+  }
+
+  if (
+    channel.type === ChannelType.PublicThread ||
+    channel.type === ChannelType.PrivateThread ||
+    channel.type === ChannelType.AnnouncementThread
+  ) {
+    const parentId = channel.parentId
+    if (parentId) {
+      const parent = await channel.guild.channels.fetch(parentId)
+      if (parent?.type === ChannelType.GuildText) {
+        return parent as TextChannel
+      }
+    }
+  }
+
+  return null
+}
+
+export function escapeDiscordFormatting(text: string): string {
+  return text.replace(/```/g, '\\`\\`\\`').replace(/````/g, '\\`\\`\\`\\`')
+}
+
+export async function getOttoMetadata(
+  textChannel: TextChannel | null,
+): Promise<{
+  projectDirectory?: string
+}> {
+  if (!textChannel) {
+    return {}
+  }
+
+  const channelConfig = await getChannelDirectory(textChannel.id)
+
+  if (!channelConfig) {
+    return {}
+  }
+
+  return {
+    projectDirectory: channelConfig.directory,
+  }
+}
+
+// Legacy alias kept for backward compat
+export const getKimakiMetadata = getOttoMetadata
+
+/**
+ * Resolve project directory from an autocomplete interaction.
+ * Uses interaction.channelId (always available from raw payload) instead of
+ * interaction.channel (cache-based getter, often null with gateway-proxy).
+ * Checks the channel ID directly in DB, then tries thread worktree lookup,
+ * then falls back to fetching the channel to resolve thread parent.
+ */
+export async function resolveProjectDirectoryFromAutocomplete(
+  interaction: Pick<AutocompleteInteraction, 'channelId' | 'channel' | 'client'>,
+): Promise<string | undefined> {
+  const channelId = interaction.channelId
+
+  // Direct channel lookup — works when the command is run from a project text channel
+  const channelConfig = await getChannelDirectory(channelId)
+  if (channelConfig) {
+    return channelConfig.directory
+  }
+
+  // If we're in a thread, try worktree info first (has project_directory)
+  const worktreeInfo = await getThreadWorktree(channelId)
+  if (worktreeInfo?.project_directory) {
+    return worktreeInfo.project_directory
+  }
+
+  // Thread fallback: resolve parent channel ID and look up its directory.
+  // Try cached channel first, then fetch if cache misses (gateway-proxy scenario).
+  const cachedParentId = interaction.channel?.isThread() ? interaction.channel.parentId : null
+  if (cachedParentId) {
+    const parentConfig = await getChannelDirectory(cachedParentId)
+    if (parentConfig) {
+      return parentConfig.directory
+    }
+  }
+
+  // Last resort: fetch the channel from Discord API to get parentId for threads
+  // when the channel isn't cached at all (common with gateway-proxy).
+  if (!cachedParentId) {
+    const fetched = await errore.tryAsync({
+      try: () => { return interaction.client.channels.fetch(channelId) },
+      catch: (e) => { return e as Error },
+    })
+    if (!(fetched instanceof Error) && fetched?.isThread() && fetched.parentId) {
+      const parentConfig = await getChannelDirectory(fetched.parentId)
+      if (parentConfig) {
+        return parentConfig.directory
+      }
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Resolve the working directory for a channel or thread.
+ * Returns both the base project directory (for server init) and the working directory
+ * (worktree directory if in a worktree thread, otherwise same as projectDirectory).
+ * This prevents commands from accidentally running in the base project dir when a
+ * worktree is active — the bug that caused /diff, /compact, etc. to use wrong cwd.
+ */
+export async function resolveWorkingDirectory({
+  channel,
+}: {
+  channel: TextChannel | ThreadChannel
+}): Promise<
+  | {
+      projectDirectory: string
+      workingDirectory: string
+    }
+  | undefined
+> {
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  const textChannel = isThread
+    ? await resolveTextChannel(channel as ThreadChannel)
+    : (channel as TextChannel)
+
+  const metadata = await getOttoMetadata(textChannel)
+  if (!metadata.projectDirectory) {
+    return undefined
+  }
+
+  let workingDirectory = metadata.projectDirectory
+  if (isThread) {
+    const worktreeInfo = await getThreadWorktree(channel.id)
+    if (worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory) {
+      workingDirectory = worktreeInfo.worktree_directory
+    }
+  }
+
+  return {
+    projectDirectory: metadata.projectDirectory,
+    workingDirectory,
+  }
+}
+
+/**
+ * Upload files to a Discord thread/channel in a single message.
+ * Sending all files in one message causes Discord to display images in a grid layout.
+ */
+export async function uploadFilesToDiscord({
+  threadId,
+  botToken,
+  files,
+}: {
+  threadId: string
+  botToken: string
+  files: string[]
+}): Promise<void> {
+  if (files.length === 0) {
+    return
+  }
+
+  // Build attachments array for all files
+  const attachments = files.map((file, index) => ({
+    id: index,
+    filename: path.basename(file),
+  }))
+
+  const formData = new FormData()
+  formData.append('payload_json', JSON.stringify({ attachments }))
+
+  // Append each file with its array index, with correct MIME type for grid display
+  files.forEach((file, index) => {
+    const buffer = fs.readFileSync(file)
+    const mimeType = mime.getType(file) || 'application/octet-stream'
+    formData.append(
+      `files[${index}]`,
+      new Blob([buffer], { type: mimeType }),
+      path.basename(file),
+    )
+  })
+
+  const response = await fetch(
+    discordApiUrl(`/channels/${threadId}/messages`),
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Bot ${botToken}`,
+      },
+      body: formData,
+    },
+  )
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`Discord API error: ${response.status} - ${error}`)
+  }
+}