kimaki 0.4.18 → 0.4.20

package/src/discordBot.ts

@@ -80,6 +80,8 @@ export function getOpencodeSystemMessage({ sessionId }: { sessionId: string }) {
   return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
+The user cannot see bash tool outputs. If there is important information in bash output, include it in your text response.
+
 Your current OpenCode session ID is: ${sessionId}
 
 ## uploading files to discord
@@ -620,6 +622,7 @@ export function getDatabase(): Database.Database {
       CREATE TABLE IF NOT EXISTS bot_api_keys (
         app_id TEXT PRIMARY KEY,
         gemini_api_key TEXT,
+        xai_api_key TEXT,
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
       )
     `)
@@ -877,14 +880,64 @@ async function processVoiceAttachment({
   return transcription
 }
 
-function getImageAttachments(message: Message): FilePartInput[] {
-  const imageAttachments = Array.from(message.attachments.values()).filter(
-    (attachment) => attachment.contentType?.startsWith('image/'),
+const TEXT_MIME_TYPES = [
+  'text/',
+  'application/json',
+  'application/xml',
+  'application/javascript',
+  'application/typescript',
+  'application/x-yaml',
+  'application/toml',
+]
+
+function isTextMimeType(contentType: string | null): boolean {
+  if (!contentType) {
+    return false
+  }
+  return TEXT_MIME_TYPES.some((prefix) => contentType.startsWith(prefix))
+}
+
+async function getTextAttachments(message: Message): Promise<string> {
+  const textAttachments = Array.from(message.attachments.values()).filter(
+    (attachment) => isTextMimeType(attachment.contentType),
+  )
+
+  if (textAttachments.length === 0) {
+    return ''
+  }
+
+  const textContents = await Promise.all(
+    textAttachments.map(async (attachment) => {
+      try {
+        const response = await fetch(attachment.url)
+        if (!response.ok) {
+          return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`
+        }
+        const text = await response.text()
+        return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error)
+        return `<attachment filename="${attachment.name}" error="${errMsg}" />`
+      }
+    }),
+  )
+
+  return textContents.join('\n\n')
+}
+
+function getFileAttachments(message: Message): FilePartInput[] {
+  const fileAttachments = Array.from(message.attachments.values()).filter(
+    (attachment) => {
+      const contentType = attachment.contentType || ''
+      return (
+        contentType.startsWith('image/') || contentType === 'application/pdf'
+      )
+    },
   )
 
-  return imageAttachments.map((attachment) => ({
+  return fileAttachments.map((attachment) => ({
     type: 'file' as const,
-    mime: attachment.contentType || 'image/png',
+    mime: attachment.contentType || 'application/octet-stream',
     filename: attachment.name,
     url: attachment.url,
   }))
@@ -1204,13 +1257,6 @@ export async function initializeOpencodeForDirectory(directory: string) {
 
 function getToolSummaryText(part: Part): string {
   if (part.type !== 'tool') return ''
-  if (part.state.status !== 'completed' && part.state.status !== 'error') return ''
-
-  if (part.tool === 'bash') {
-    const output = part.state.status === 'completed' ? part.state.output : part.state.error
-    const lines = (output || '').split('\n').filter((l: string) => l.trim())
-    return `(${lines.length} line${lines.length === 1 ? '' : 's'})`
-  }
 
   if (part.tool === 'edit') {
     const newString = (part.state.input?.newString as string) || ''
@@ -1233,6 +1279,7 @@ function getToolSummaryText(part: Part): string {
   }
 
   if (
+    part.tool === 'bash' ||
     part.tool === 'read' ||
     part.tool === 'list' ||
     part.tool === 'glob' ||
@@ -1250,7 +1297,7 @@ function getToolSummaryText(part: Part): string {
     .map(([key, value]) => {
       if (value === null || value === undefined) return null
       const stringValue = typeof value === 'string' ? value : JSON.stringify(value)
-      const truncatedValue = stringValue.length > 100 ? stringValue.slice(0, 100) + '…' : stringValue
+      const truncatedValue = stringValue.length > 300 ? stringValue.slice(0, 300) + '…' : stringValue
       return `${key}: ${truncatedValue}`
     })
     .filter(Boolean)
@@ -1260,17 +1307,6 @@ function getToolSummaryText(part: Part): string {
   return `(${inputFields.join(', ')})`
 }
 
-function getToolOutputToDisplay(part: Part): string {
-  if (part.type !== 'tool') return ''
-  if (part.state.status !== 'completed' && part.state.status !== 'error') return ''
-
-  if (part.state.status === 'error') {
-    return part.state.error || 'Unknown error'
-  }
-
-  return ''
-}
-
 function formatTodoList(part: Part): string {
   if (part.type !== 'tool' || part.tool !== 'todowrite') return ''
   const todos =
@@ -1324,36 +1360,35 @@ function formatPart(part: Part): string {
       return formatTodoList(part)
     }
 
-    if (part.state.status !== 'completed' && part.state.status !== 'error') {
+    if (part.state.status === 'pending') {
       return ''
     }
 
     const summaryText = getToolSummaryText(part)
-    const outputToDisplay = getToolOutputToDisplay(part)
+    const stateTitle = 'title' in part.state ? part.state.title : undefined
 
     let toolTitle = ''
     if (part.state.status === 'error') {
-      toolTitle = 'error'
+      toolTitle = part.state.error || 'error'
     } else if (part.tool === 'bash') {
       const command = (part.state.input?.command as string) || ''
       const isSingleLine = !command.includes('\n')
       const hasBackticks = command.includes('`')
       if (isSingleLine && command.length <= 120 && !hasBackticks) {
-        toolTitle = `\`${command}\``
+        toolTitle = `_${command}_`
       } else {
-        toolTitle = part.state.title ? `*${part.state.title}*` : ''
+        toolTitle = stateTitle ? `_${stateTitle}_` : ''
       }
-    } else if (part.state.title) {
-      toolTitle = `*${part.state.title}*`
+    } else if (part.tool === 'edit' || part.tool === 'write') {
+      const filePath = (part.state.input?.filePath as string) || ''
+      const fileName = filePath.split('/').pop() || filePath
+      toolTitle = fileName ? `_${fileName}_` : ''
+    } else if (stateTitle) {
+      toolTitle = `_${stateTitle}_`
     }
 
-    const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : ''
-    const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`
-
-    if (outputToDisplay) {
-      return title + '\n\n' + outputToDisplay
-    }
-    return title
+    const icon = part.state.status === 'error' ? '⨯' : '◼︎'
+    return `${icon} ${part.tool} ${toolTitle} ${summaryText}`
   }
 
   discordLogger.warn('Unknown part type:', part)
@@ -1399,16 +1434,6 @@ async function handleOpencodeSession({
   // Track session start time
   const sessionStartTime = Date.now()
 
-  // Add processing reaction to original message
-  if (originalMessage) {
-    try {
-      await originalMessage.react('⏳')
-      discordLogger.log(`Added processing reaction to message`)
-    } catch (e) {
-      discordLogger.log(`Could not add processing reaction:`, e)
-    }
-  }
-
   // Use default directory if not specified
   const directory = projectDirectory || process.cwd()
   sessionLogger.log(`Using directory: ${directory}`)
@@ -1444,11 +1469,12 @@ async function handleOpencodeSession({
   }
 
   if (!session) {
+    const sessionTitle = prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt.slice(0, 80)
     voiceLogger.log(
-      `[SESSION] Creating new session with title: "${prompt.slice(0, 80)}"`,
+      `[SESSION] Creating new session with title: "${sessionTitle}"`,
     )
     const sessionResponse = await getClient().session.create({
-      body: { title: prompt.slice(0, 80) },
+      body: { title: sessionTitle },
     })
     session = sessionResponse.data
     sessionLogger.log(`Created new session ${session?.id}`)
@@ -1475,46 +1501,46 @@ async function handleOpencodeSession({
     existingController.abort(new Error('New request started'))
   }
 
-  if (abortControllers.has(session.id)) {
-    abortControllers.get(session.id)?.abort(new Error('new reply'))
-  }
   const abortController = new AbortController()
-  // Store this controller for this session
   abortControllers.set(session.id, abortController)
 
+  if (existingController) {
+    await new Promise((resolve) => { setTimeout(resolve, 200) })
+    if (abortController.signal.aborted) {
+      sessionLogger.log(`[DEBOUNCE] Request was superseded during wait, exiting`)
+      return
+    }
+  }
+
+  if (abortController.signal.aborted) {
+    sessionLogger.log(`[DEBOUNCE] Aborted before subscribe, exiting`)
+    return
+  }
+
   const eventsResult = await getClient().event.subscribe({
     signal: abortController.signal,
   })
+
+  if (abortController.signal.aborted) {
+    sessionLogger.log(`[DEBOUNCE] Aborted during subscribe, exiting`)
+    return
+  }
+
   const events = eventsResult.stream
   sessionLogger.log(`Subscribed to OpenCode events`)
 
-  // Load existing part-message mappings from database
-  const partIdToMessage = new Map<string, Message>()
-  const existingParts = getDatabase()
-    .prepare(
-      'SELECT part_id, message_id FROM part_messages WHERE thread_id = ?',
-    )
-    .all(thread.id) as { part_id: string; message_id: string }[]
-
-  // Pre-populate map with existing messages
-  for (const row of existingParts) {
-    try {
-      const message = await thread.messages.fetch(row.message_id)
-      if (message) {
-        partIdToMessage.set(row.part_id, message)
-      }
-    } catch (error) {
-      voiceLogger.log(
-        `Could not fetch message ${row.message_id} for part ${row.part_id}`,
-      )
-    }
-  }
+  const sentPartIds = new Set<string>(
+    (getDatabase()
+      .prepare('SELECT part_id FROM part_messages WHERE thread_id = ?')
+      .all(thread.id) as { part_id: string }[])
+      .map((row) => row.part_id)
+  )
 
   let currentParts: Part[] = []
   let stopTyping: (() => void) | null = null
   let usedModel: string | undefined
   let usedProviderID: string | undefined
-  let inputTokens = 0
+  let tokensUsedInSession = 0
 
   const sendPartMessage = async (part: Part) => {
     const content = formatPart(part) + '\n\n'
@@ -1524,13 +1550,13 @@ async function handleOpencodeSession({
     }
 
     // Skip if already sent
-    if (partIdToMessage.has(part.id)) {
+    if (sentPartIds.has(part.id)) {
       return
     }
 
     try {
       const firstMessage = await sendThreadMessage(thread, content)
-      partIdToMessage.set(part.id, firstMessage)
+      sentPartIds.add(part.id)
 
       // Store part-message mapping in database
       getDatabase()
@@ -1603,22 +1629,27 @@ async function handleOpencodeSession({
         if (event.type === 'message.updated') {
           const msg = event.properties.info
 
+
+
           if (msg.sessionID !== session.id) {
             continue
           }
 
           // Track assistant message ID
           if (msg.role === 'assistant') {
+            const newTokensTotal = msg.tokens.input + msg.tokens.output + msg.tokens.reasoning + msg.tokens.cache.read + msg.tokens.cache.write
+            if (newTokensTotal > 0) {
+              tokensUsedInSession = newTokensTotal
+            }
+
             assistantMessageId = msg.id
             usedModel = msg.modelID
             usedProviderID = msg.providerID
-            if (msg.tokens.input > 0) {
-              inputTokens = msg.tokens.input
-            }
           }
         } else if (event.type === 'message.part.updated') {
           const part = event.properties.part
 
+
           if (part.sessionID !== session.id) {
             continue
           }
@@ -1644,13 +1675,19 @@ async function handleOpencodeSession({
             stopTyping = startTyping(thread)
           }
 
+          // Send tool parts immediately when they start running
+          if (part.type === 'tool' && part.state.status === 'running') {
+            await sendPartMessage(part)
+          }
+
+          // Send reasoning parts immediately (shows "◼︎ thinking" indicator early)
+          if (part.type === 'reasoning') {
+            await sendPartMessage(part)
+          }
+
           // Check if this is a step-finish part
           if (part.type === 'step-finish') {
-            // Track tokens from step-finish part
-            if (part.tokens?.input && part.tokens.input > 0) {
-              inputTokens = part.tokens.input
-              voiceLogger.log(`[STEP-FINISH] Captured tokens: ${inputTokens}`)
-            }
+
             // Send all parts accumulated so far to Discord
             for (const p of currentParts) {
               // Skip step-start and step-finish parts as they have no visual content
@@ -1752,7 +1789,7 @@ async function handleOpencodeSession({
     } finally {
       // Send any remaining parts that weren't sent
       for (const part of currentParts) {
-        if (!partIdToMessage.has(part.id)) {
+        if (!sentPartIds.has(part.id)) {
           try {
             await sendPartMessage(part)
           } catch (error) {
@@ -1778,21 +1815,22 @@ async function handleOpencodeSession({
         const attachCommand = port ? ` ⋅ ${session.id}` : ''
         const modelInfo = usedModel ? ` ⋅ ${usedModel}` : ''
         let contextInfo = ''
-        if (inputTokens > 0 && usedProviderID && usedModel) {
-          try {
-            const providersResponse = await getClient().provider.list({ query: { directory } })
-            const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID)
-            const model = provider?.models?.[usedModel]
-            if (model?.limit?.context) {
-              const percentage = Math.round((inputTokens / model.limit.context) * 100)
-              contextInfo = ` ⋅ ${percentage}%`
-            }
-          } catch (e) {
-            sessionLogger.error('Failed to fetch provider info for context percentage:', e)
+
+
+        try {
+          const providersResponse = await getClient().provider.list({ query: { directory } })
+          const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID)
+          const model = provider?.models?.[usedModel || '']
+          if (model?.limit?.context) {
+            const percentage = Math.round((tokensUsedInSession / model.limit.context) * 100)
+            contextInfo = ` ⋅ ${percentage}%`
           }
+        } catch (e) {
+          sessionLogger.error('Failed to fetch provider info for context percentage:', e)
         }
+
         await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`)
-        sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${inputTokens}`)
+        sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`)
       } else {
         sessionLogger.log(
           `Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`,
@@ -1802,10 +1840,22 @@ async function handleOpencodeSession({
   }
 
   try {
-    // Start the event handler
     const eventHandlerPromise = eventHandler()
 
-    let response: { data?: unknown }
+    if (abortController.signal.aborted) {
+      sessionLogger.log(`[DEBOUNCE] Aborted before prompt, exiting`)
+      return
+    }
+
+    if (originalMessage) {
+      try {
+        await originalMessage.react('⏳')
+      } catch (e) {
+        discordLogger.log(`Could not add processing reaction:`, e)
+      }
+    }
+
+    let response: { data?: unknown; error?: unknown; response: Response }
     if (parsedCommand?.isCommand) {
       sessionLogger.log(
         `[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`,
@@ -1838,18 +1888,33 @@ async function handleOpencodeSession({
         signal: abortController.signal,
       })
     }
+
+    if (response.error) {
+      const errorMessage = (() => {
+        const err = response.error
+        if (err && typeof err === 'object') {
+          if ('data' in err && err.data && typeof err.data === 'object' && 'message' in err.data) {
+            return String(err.data.message)
+          }
+          if ('errors' in err && Array.isArray(err.errors) && err.errors.length > 0) {
+            return JSON.stringify(err.errors)
+          }
+        }
+        return JSON.stringify(err)
+      })()
+      throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`)
+    }
+
     abortController.abort('finished')
 
     sessionLogger.log(`Successfully sent prompt, got response`)
 
-    // Update reaction to success
     if (originalMessage) {
       try {
         await originalMessage.reactions.removeAll()
         await originalMessage.react('✅')
-        discordLogger.log(`Added success reaction to message`)
       } catch (e) {
-        discordLogger.log(`Could not update reaction:`, e)
+        discordLogger.log(`Could not update reactions:`, e)
       }
     }
 
@@ -2091,14 +2156,18 @@ export async function startDiscordBot({
           messageContent = transcription
         }
 
-        const images = getImageAttachments(message)
+        const fileAttachments = getFileAttachments(message)
+        const textAttachmentsContent = await getTextAttachments(message)
+        const promptWithAttachments = textAttachmentsContent
+          ? `${messageContent}\n\n${textAttachmentsContent}`
+          : messageContent
         const parsedCommand = parseSlashCommand(messageContent)
         await handleOpencodeSession({
-          prompt: messageContent,
+          prompt: promptWithAttachments,
           thread,
           projectDirectory,
           originalMessage: message,
-          images,
+          images: fileAttachments,
           parsedCommand,
         })
         return
@@ -2188,14 +2257,18 @@ export async function startDiscordBot({
           messageContent = transcription
         }
 
-        const images = getImageAttachments(message)
+        const fileAttachments = getFileAttachments(message)
+        const textAttachmentsContent = await getTextAttachments(message)
+        const promptWithAttachments = textAttachmentsContent
+          ? `${messageContent}\n\n${textAttachmentsContent}`
+          : messageContent
         const parsedCommand = parseSlashCommand(messageContent)
         await handleOpencodeSession({
-          prompt: messageContent,
+          prompt: promptWithAttachments,
           thread,
           projectDirectory,
           originalMessage: message,
-          images,
+          images: fileAttachments,
           parsedCommand,
         })
       } else {
@@ -2783,6 +2856,94 @@ export async function startDiscordBot({
                 `Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`,
               )
             }
+          } else if (command.commandName === 'add-new-project') {
+            await command.deferReply({ ephemeral: false })
+
+            const projectName = command.options.getString('name', true)
+            const guild = command.guild
+            const channel = command.channel
+
+            if (!guild) {
+              await command.editReply('This command can only be used in a guild')
+              return
+            }
+
+            if (!channel || channel.type !== ChannelType.GuildText) {
+              await command.editReply('This command can only be used in a text channel')
+              return
+            }
+
+            const sanitizedName = projectName
+              .toLowerCase()
+              .replace(/[^a-z0-9-]/g, '-')
+              .replace(/-+/g, '-')
+              .replace(/^-|-$/g, '')
+              .slice(0, 100)
+
+            if (!sanitizedName) {
+              await command.editReply('Invalid project name')
+              return
+            }
+
+            const kimakiDir = path.join(os.homedir(), 'kimaki')
+            const projectDirectory = path.join(kimakiDir, sanitizedName)
+
+            try {
+              if (!fs.existsSync(kimakiDir)) {
+                fs.mkdirSync(kimakiDir, { recursive: true })
+                discordLogger.log(`Created kimaki directory: ${kimakiDir}`)
+              }
+
+              if (fs.existsSync(projectDirectory)) {
+                await command.editReply(`Project directory already exists: ${projectDirectory}`)
+                return
+              }
+
+              fs.mkdirSync(projectDirectory, { recursive: true })
+              discordLogger.log(`Created project directory: ${projectDirectory}`)
+
+              const { execSync } = await import('node:child_process')
+              execSync('git init', { cwd: projectDirectory, stdio: 'pipe' })
+              discordLogger.log(`Initialized git in: ${projectDirectory}`)
+
+              const { textChannelId, voiceChannelId, channelName } =
+                await createProjectChannels({
+                  guild,
+                  projectDirectory,
+                  appId: currentAppId!,
+                })
+
+              const textChannel = await guild.channels.fetch(textChannelId) as TextChannel
+
+              await command.editReply(
+                `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`,
+              )
+
+              const starterMessage = await textChannel.send({
+                content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+              })
+
+              const thread = await starterMessage.startThread({
+                name: `Init: ${sanitizedName}`,
+                autoArchiveDuration: 1440,
+                reason: 'New project session',
+              })
+
+              await handleOpencodeSession({
+                prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
+                thread,
+                projectDirectory,
+              })
+
+              discordLogger.log(
+                `Created new project ${channelName} at ${projectDirectory}`,
+              )
+            } catch (error) {
+              voiceLogger.error('[ADD-NEW-PROJECT] Error:', error)
+              await command.editReply(
+                `Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`,
+              )
+            }
           } else if (
             command.commandName === 'accept' ||
             command.commandName === 'accept-always'
@@ -2976,6 +3137,79 @@ export async function startDiscordBot({
                 ephemeral: true,
               })
             }
+          } else if (command.commandName === 'share') {
+            const channel = command.channel
+
+            if (!channel) {
+              await command.reply({
+                content: 'This command can only be used in a channel',
+                ephemeral: true,
+              })
+              return
+            }
+
+            const isThread = [
+              ChannelType.PublicThread,
+              ChannelType.PrivateThread,
+              ChannelType.AnnouncementThread,
+            ].includes(channel.type)
+
+            if (!isThread) {
+              await command.reply({
+                content: 'This command can only be used in a thread with an active session',
+                ephemeral: true,
+              })
+              return
+            }
+
+            const textChannel = resolveTextChannel(channel as ThreadChannel)
+            const { projectDirectory: directory } = getKimakiMetadata(textChannel)
+
+            if (!directory) {
+              await command.reply({
+                content: 'Could not determine project directory for this channel',
+                ephemeral: true,
+              })
+              return
+            }
+
+            const row = getDatabase()
+              .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+              .get(channel.id) as { session_id: string } | undefined
+
+            if (!row?.session_id) {
+              await command.reply({
+                content: 'No active session in this thread',
+                ephemeral: true,
+              })
+              return
+            }
+
+            const sessionId = row.session_id
+
+            try {
+              const getClient = await initializeOpencodeForDirectory(directory)
+              const response = await getClient().session.share({
+                path: { id: sessionId },
+              })
+
+              if (!response.data?.share?.url) {
+                await command.reply({
+                  content: 'Failed to generate share URL',
+                  ephemeral: true,
+                })
+                return
+              }
+
+              await command.reply(`🔗 **Session shared:** ${response.data.share.url}`)
+              sessionLogger.log(`Session ${sessionId} shared: ${response.data.share.url}`)
+            } catch (error) {
+              voiceLogger.error('[SHARE] Error:', error)
+              await command.reply({
+                content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ephemeral: true,
+              })
+            }
           }
         }
       } catch (error) {
@@ -3261,7 +3495,7 @@ export async function startDiscordBot({
 
   await discordClient.login(token)
 
-  const handleShutdown = async (signal: string) => {
+  const handleShutdown = async (signal: string, { skipExit = false } = {}) => {
     discordLogger.log(`Received ${signal}, cleaning up...`)
 
     // Prevent multiple shutdown calls
@@ -3310,11 +3544,15 @@ export async function startDiscordBot({
       discordLogger.log('Destroying Discord client...')
       discordClient.destroy()
 
-      discordLogger.log('Cleanup complete, exiting.')
-      process.exit(0)
+      discordLogger.log('Cleanup complete.')
+      if (!skipExit) {
+        process.exit(0)
+      }
     } catch (error) {
       voiceLogger.error('[SHUTDOWN] Error during cleanup:', error)
-      process.exit(1)
+      if (!skipExit) {
+        process.exit(1)
+      }
     }
   }
 
@@ -3337,6 +3575,23 @@ export async function startDiscordBot({
     }
   })
 
+  process.on('SIGUSR2', async () => {
+    discordLogger.log('Received SIGUSR2, restarting after cleanup...')
+    try {
+      await handleShutdown('SIGUSR2', { skipExit: true })
+    } catch (error) {
+      voiceLogger.error('[SIGUSR2] Error during shutdown:', error)
+    }
+    const { spawn } = await import('node:child_process')
+    spawn(process.argv[0]!, [...process.execArgv, ...process.argv.slice(1)], {
+      stdio: 'inherit',
+      detached: true,
+      cwd: process.cwd(),
+      env: process.env,
+    }).unref()
+    process.exit(0)
+  })
+
   // Prevent unhandled promise rejections from crashing the process during shutdown
   process.on('unhandledRejection', (reason, promise) => {
     if ((global as any).shuttingDown) {