kimaki 0.4.22 → 0.4.23

package/src/discord-bot.ts

@@ -0,0 +1,506 @@
+import { getDatabase, closeDatabase } from './database.js'
+import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js'
+import {
+  escapeBackticksInCodeBlocks,
+  splitMarkdownForDiscord,
+  SILENT_MESSAGE_FLAGS,
+} from './discord-utils.js'
+import { getOpencodeSystemMessage } from './system-message.js'
+import { getFileAttachments, getTextAttachments } from './message-formatting.js'
+import {
+  ensureKimakiCategory,
+  ensureKimakiAudioCategory,
+  createProjectChannels,
+  getChannelsWithDescriptions,
+  type ChannelWithTags,
+} from './channel-management.js'
+import {
+  voiceConnections,
+  cleanupVoiceConnection,
+  processVoiceAttachment,
+  registerVoiceStateHandler,
+} from './voice-handler.js'
+import {
+  handleOpencodeSession,
+  parseSlashCommand,
+} from './session-handler.js'
+import { registerInteractionHandler } from './interaction-handler.js'
+
+export { getDatabase, closeDatabase } from './database.js'
+export { initializeOpencodeForDirectory } from './opencode.js'
+export { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discord-utils.js'
+export { getOpencodeSystemMessage } from './system-message.js'
+export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions } from './channel-management.js'
+export type { ChannelWithTags } from './channel-management.js'
+
+import {
+  ChannelType,
+  Client,
+  Events,
+  GatewayIntentBits,
+  Partials,
+  PermissionsBitField,
+  ThreadAutoArchiveDuration,
+  type Message,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import fs from 'node:fs'
+import { extractTagsArrays } from './xml.js'
+import { createLogger } from './logger.js'
+import { setGlobalDispatcher, Agent } from 'undici'
+
+setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }))
+
+const discordLogger = createLogger('DISCORD')
+const voiceLogger = createLogger('VOICE')
+
+type StartOptions = {
+  token: string
+  appId?: string
+}
+
+export async function createDiscordClient() {
+  return new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.GuildVoiceStates,
+    ],
+    partials: [
+      Partials.Channel,
+      Partials.Message,
+      Partials.User,
+      Partials.ThreadMember,
+    ],
+  })
+}
+
+export async function startDiscordBot({
+  token,
+  appId,
+  discordClient,
+}: StartOptions & { discordClient?: Client }) {
+  if (!discordClient) {
+    discordClient = await createDiscordClient()
+  }
+
+  let currentAppId: string | undefined = appId
+
+  const setupHandlers = async (c: Client<true>) => {
+    discordLogger.log(`Discord bot logged in as ${c.user.tag}`)
+    discordLogger.log(`Connected to ${c.guilds.cache.size} guild(s)`)
+    discordLogger.log(`Bot user ID: ${c.user.id}`)
+
+    if (!currentAppId) {
+      await c.application?.fetch()
+      currentAppId = c.application?.id
+
+      if (!currentAppId) {
+        discordLogger.error('Could not get application ID')
+        throw new Error('Failed to get bot application ID')
+      }
+      discordLogger.log(`Bot Application ID (fetched): ${currentAppId}`)
+    } else {
+      discordLogger.log(`Bot Application ID (provided): ${currentAppId}`)
+    }
+
+    for (const guild of c.guilds.cache.values()) {
+      discordLogger.log(`${guild.name} (${guild.id})`)
+
+      const channels = await getChannelsWithDescriptions(guild)
+      const kimakiChannels = channels.filter(
+        (ch) =>
+          ch.kimakiDirectory &&
+          (!ch.kimakiApp || ch.kimakiApp === currentAppId),
+      )
+
+      if (kimakiChannels.length > 0) {
+        discordLogger.log(
+          `  Found ${kimakiChannels.length} channel(s) for this bot:`,
+        )
+        for (const channel of kimakiChannels) {
+          discordLogger.log(`  - #${channel.name}: ${channel.kimakiDirectory}`)
+        }
+      } else {
+        discordLogger.log(`  No channels for this bot`)
+      }
+    }
+
+    voiceLogger.log(
+      `[READY] Bot is ready and will only respond to channels with app ID: ${currentAppId}`,
+    )
+
+    registerInteractionHandler({ discordClient: c, appId: currentAppId })
+    registerVoiceStateHandler({ discordClient: c, appId: currentAppId })
+  }
+
+  // If client is already ready (was logged in before being passed to us),
+  // run setup immediately. Otherwise wait for the ClientReady event.
+  if (discordClient.isReady()) {
+    await setupHandlers(discordClient)
+  } else {
+    discordClient.once(Events.ClientReady, setupHandlers)
+  }
+
+  discordClient.on(Events.MessageCreate, async (message: Message) => {
+    try {
+      if (message.author?.bot) {
+        return
+      }
+      if (message.partial) {
+        discordLogger.log(`Fetching partial message ${message.id}`)
+        try {
+          await message.fetch()
+        } catch (error) {
+          discordLogger.log(
+            `Failed to fetch partial message ${message.id}:`,
+            error,
+          )
+          return
+        }
+      }
+
+      if (message.guild && message.member) {
+        const isOwner = message.member.id === message.guild.ownerId
+        const isAdmin = message.member.permissions.has(
+          PermissionsBitField.Flags.Administrator,
+        )
+        const canManageServer = message.member.permissions.has(
+          PermissionsBitField.Flags.ManageGuild,
+        )
+        const hasKimakiRole = message.member.roles.cache.some(
+          (role) => role.name.toLowerCase() === 'kimaki',
+        )
+
+        if (!isOwner && !isAdmin && !canManageServer && !hasKimakiRole) {
+          await message.react('🔒')
+          return
+        }
+      }
+
+      const channel = message.channel
+      const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+      ].includes(channel.type)
+
+      if (isThread) {
+        const thread = channel as ThreadChannel
+        discordLogger.log(`Message in thread ${thread.name} (${thread.id})`)
+
+        const row = getDatabase()
+          .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+          .get(thread.id) as { session_id: string } | undefined
+
+        if (!row) {
+          discordLogger.log(`No session found for thread ${thread.id}`)
+          return
+        }
+
+        voiceLogger.log(
+          `[SESSION] Found session ${row.session_id} for thread ${thread.id}`,
+        )
+
+        const parent = thread.parent as TextChannel | null
+        let projectDirectory: string | undefined
+        let channelAppId: string | undefined
+
+        if (parent?.topic) {
+          const extracted = extractTagsArrays({
+            xml: parent.topic,
+            tags: ['kimaki.directory', 'kimaki.app'],
+          })
+
+          projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+          channelAppId = extracted['kimaki.app']?.[0]?.trim()
+        }
+
+        if (channelAppId && channelAppId !== currentAppId) {
+          voiceLogger.log(
+            `[IGNORED] Thread belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`,
+          )
+          return
+        }
+
+        if (projectDirectory && !fs.existsSync(projectDirectory)) {
+          discordLogger.error(`Directory does not exist: ${projectDirectory}`)
+          await message.reply({
+            content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory)}`,
+            flags: SILENT_MESSAGE_FLAGS,
+          })
+          return
+        }
+
+        let messageContent = message.content || ''
+
+        let sessionMessagesText: string | undefined
+        if (projectDirectory && row.session_id) {
+          try {
+            const getClient = await initializeOpencodeForDirectory(projectDirectory)
+            const messagesResponse = await getClient().session.messages({
+              path: { id: row.session_id },
+            })
+            const messages = messagesResponse.data || []
+            const recentMessages = messages.slice(-10)
+            sessionMessagesText = recentMessages
+              .map((m) => {
+                const role = m.info.role === 'user' ? 'User' : 'Assistant'
+                const text = (() => {
+                  if (m.info.role === 'user') {
+                    const textParts = (m.parts || []).filter((p) => p.type === 'text')
+                    return textParts
+                      .map((p) => ('text' in p ? p.text : ''))
+                      .filter(Boolean)
+                      .join('\n')
+                  }
+                  const assistantInfo = m.info as { text?: string }
+                  return assistantInfo.text?.slice(0, 500)
+                })()
+                return `[${role}]: ${text || '(no text)'}`
+              })
+              .join('\n\n')
+          } catch (e) {
+            voiceLogger.log(`Could not get session messages:`, e)
+          }
+        }
+
+        const transcription = await processVoiceAttachment({
+          message,
+          thread,
+          projectDirectory,
+          appId: currentAppId,
+          sessionMessages: sessionMessagesText,
+        })
+        if (transcription) {
+          messageContent = transcription
+        }
+
+        const fileAttachments = getFileAttachments(message)
+        const textAttachmentsContent = await getTextAttachments(message)
+        const promptWithAttachments = textAttachmentsContent
+          ? `${messageContent}\n\n${textAttachmentsContent}`
+          : messageContent
+        const parsedCommand = parseSlashCommand(messageContent)
+        await handleOpencodeSession({
+          prompt: promptWithAttachments,
+          thread,
+          projectDirectory,
+          originalMessage: message,
+          images: fileAttachments,
+          parsedCommand,
+          channelId: parent?.id,
+        })
+        return
+      }
+
+      if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel as TextChannel
+        voiceLogger.log(
+          `[GUILD_TEXT] Message in text channel #${textChannel.name} (${textChannel.id})`,
+        )
+
+        if (!textChannel.topic) {
+          voiceLogger.log(
+            `[IGNORED] Channel #${textChannel.name} has no description`,
+          )
+          return
+        }
+
+        const extracted = extractTagsArrays({
+          xml: textChannel.topic,
+          tags: ['kimaki.directory', 'kimaki.app'],
+        })
+
+        const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+        const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+
+        if (!projectDirectory) {
+          voiceLogger.log(
+            `[IGNORED] Channel #${textChannel.name} has no kimaki.directory tag`,
+          )
+          return
+        }
+
+        if (channelAppId && channelAppId !== currentAppId) {
+          voiceLogger.log(
+            `[IGNORED] Channel belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`,
+          )
+          return
+        }
+
+        discordLogger.log(
+          `DIRECTORY: Found kimaki.directory: ${projectDirectory}`,
+        )
+        if (channelAppId) {
+          discordLogger.log(`APP: Channel app ID: ${channelAppId}`)
+        }
+
+        if (!fs.existsSync(projectDirectory)) {
+          discordLogger.error(`Directory does not exist: ${projectDirectory}`)
+          await message.reply({
+            content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory)}`,
+            flags: SILENT_MESSAGE_FLAGS,
+          })
+          return
+        }
+
+        const hasVoice = message.attachments.some((a) =>
+          a.contentType?.startsWith('audio/'),
+        )
+
+        const threadName = hasVoice
+          ? 'Voice Message'
+          : message.content?.replace(/\s+/g, ' ').trim() || 'Claude Thread'
+
+        const thread = await message.startThread({
+          name: threadName.slice(0, 80),
+          autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+          reason: 'Start Claude session',
+        })
+
+        discordLogger.log(`Created thread "${thread.name}" (${thread.id})`)
+
+        let messageContent = message.content || ''
+
+        const transcription = await processVoiceAttachment({
+          message,
+          thread,
+          projectDirectory,
+          isNewThread: true,
+          appId: currentAppId,
+        })
+        if (transcription) {
+          messageContent = transcription
+        }
+
+        const fileAttachments = getFileAttachments(message)
+        const textAttachmentsContent = await getTextAttachments(message)
+        const promptWithAttachments = textAttachmentsContent
+          ? `${messageContent}\n\n${textAttachmentsContent}`
+          : messageContent
+        const parsedCommand = parseSlashCommand(messageContent)
+        await handleOpencodeSession({
+          prompt: promptWithAttachments,
+          thread,
+          projectDirectory,
+          originalMessage: message,
+          images: fileAttachments,
+          parsedCommand,
+          channelId: textChannel.id,
+        })
+      } else {
+        discordLogger.log(`Channel type ${channel.type} is not supported`)
+      }
+    } catch (error) {
+      voiceLogger.error('Discord handler error:', error)
+      try {
+        const errMsg = error instanceof Error ? error.message : String(error)
+        await message.reply({ content: `Error: ${errMsg}`, flags: SILENT_MESSAGE_FLAGS })
+      } catch {
+        voiceLogger.error('Discord handler error (fallback):', error)
+      }
+    }
+  })
+
+  await discordClient.login(token)
+
+  const handleShutdown = async (signal: string, { skipExit = false } = {}) => {
+    discordLogger.log(`Received ${signal}, cleaning up...`)
+
+    if ((global as any).shuttingDown) {
+      discordLogger.log('Already shutting down, ignoring duplicate signal')
+      return
+    }
+    ;(global as any).shuttingDown = true
+
+    try {
+      const cleanupPromises: Promise<void>[] = []
+      for (const [guildId] of voiceConnections) {
+        voiceLogger.log(
+          `[SHUTDOWN] Cleaning up voice connection for guild ${guildId}`,
+        )
+        cleanupPromises.push(cleanupVoiceConnection(guildId))
+      }
+
+      if (cleanupPromises.length > 0) {
+        voiceLogger.log(
+          `[SHUTDOWN] Waiting for ${cleanupPromises.length} voice connection(s) to clean up...`,
+        )
+        await Promise.allSettled(cleanupPromises)
+        discordLogger.log(`All voice connections cleaned up`)
+      }
+
+      for (const [dir, server] of getOpencodeServers()) {
+        if (!server.process.killed) {
+          voiceLogger.log(
+            `[SHUTDOWN] Stopping OpenCode server on port ${server.port} for ${dir}`,
+          )
+          server.process.kill('SIGTERM')
+        }
+      }
+      getOpencodeServers().clear()
+
+      discordLogger.log('Closing database...')
+      closeDatabase()
+
+      discordLogger.log('Destroying Discord client...')
+      discordClient.destroy()
+
+      discordLogger.log('Cleanup complete.')
+      if (!skipExit) {
+        process.exit(0)
+      }
+    } catch (error) {
+      voiceLogger.error('[SHUTDOWN] Error during cleanup:', error)
+      if (!skipExit) {
+        process.exit(1)
+      }
+    }
+  }
+
+  process.on('SIGTERM', async () => {
+    try {
+      await handleShutdown('SIGTERM')
+    } catch (error) {
+      voiceLogger.error('[SIGTERM] Error during shutdown:', error)
+      process.exit(1)
+    }
+  })
+
+  process.on('SIGINT', async () => {
+    try {
+      await handleShutdown('SIGINT')
+    } catch (error) {
+      voiceLogger.error('[SIGINT] Error during shutdown:', error)
+      process.exit(1)
+    }
+  })
+
+  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)
+  })
+
+  process.on('unhandledRejection', (reason, promise) => {
+    if ((global as any).shuttingDown) {
+      discordLogger.log('Ignoring unhandled rejection during shutdown:', reason)
+      return
+    }
+    discordLogger.error('Unhandled Rejection at:', promise, 'reason:', reason)
+  })
+}

package/src/discord-utils.ts

@@ -0,0 +1,208 @@
+import {
+  ChannelType,
+  type Message,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import { Lexer } from 'marked'
+import { extractTagsArrays } from './xml.js'
+import { formatMarkdownTables } from './format-tables.js'
+import { createLogger } from './logger.js'
+
+const discordLogger = createLogger('DISCORD')
+
+export const SILENT_MESSAGE_FLAGS = 4 | 4096
+
+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[] = []
+  for (const token of tokens) {
+    if (token.type === 'code') {
+      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
+
+  for (const line of lines) {
+    const wouldExceed = currentChunk.length + line.text.length > maxLength
+
+    if (wouldExceed && 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 += line.text
+      if (line.inCodeBlock || line.isOpeningFence) {
+        currentLang = line.lang
+      } else if (line.isClosingFence) {
+        currentLang = null
+      }
+    }
+  }
+
+  if (currentChunk) {
+    chunks.push(currentChunk)
+  }
+
+  return chunks
+}
+
+export async function sendThreadMessage(
+  thread: ThreadChannel,
+  content: string,
+): Promise<Message> {
+  const MAX_LENGTH = 2000
+
+  content = formatMarkdownTables(content)
+  content = escapeBackticksInCodeBlocks(content)
+
+  const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH })
+
+  if (chunks.length > 1) {
+    discordLogger.log(
+      `MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`,
+    )
+  }
+
+  let firstMessage: Message | undefined
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i]
+    if (!chunk) {
+      continue
+    }
+    const message = await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+    if (i === 0) {
+      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 function getKimakiMetadata(textChannel: TextChannel | null): {
+  projectDirectory?: string
+  channelAppId?: string
+} {
+  if (!textChannel?.topic) {
+    return {}
+  }
+
+  const extracted = extractTagsArrays({
+    xml: textChannel.topic,
+    tags: ['kimaki.directory', 'kimaki.app'],
+  })
+
+  const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+  const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+
+  return { projectDirectory, channelAppId }
+}