kimaki 0.4.29 → 0.4.31

package/src/cli.ts

@@ -46,6 +46,7 @@ import { createLogger } from './logger.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 import http from 'node:http'
 import { setDataDir, getDataDir, getLockPort } from './config.js'
+import { extractTagsArrays } from './xml.js'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
@@ -528,8 +529,14 @@ async function run({ restart, addChannels }: CliOptions) {
   }
 
   const s = spinner()
-  s.start('Creating Discord client and connecting...')
 
+  // Start OpenCode server EARLY - let it initialize in parallel with Discord login.
+  // This is the biggest startup bottleneck (can take 1-30 seconds to spawn and wait for ready)
+  const currentDir = process.cwd()
+  s.start('Starting OpenCode server...')
+  const opencodePromise = initializeOpencodeForDirectory(currentDir)
+
+  s.message('Connecting to Discord...')
   const discordClient = await createDiscordClient()
 
   const guilds: Guild[] = []
@@ -541,15 +548,56 @@ async function run({ restart, addChannels }: CliOptions) {
       discordClient.once(Events.ClientReady, async (c) => {
         guilds.push(...Array.from(c.guilds.cache.values()))
 
-        for (const guild of guilds) {
-          const channels = await getChannelsWithDescriptions(guild)
-          const kimakiChans = channels.filter(
-            (ch) =>
-              ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId),
-          )
+        // Process all guilds in parallel for faster startup
+        const guildResults = await Promise.all(
+          guilds.map(async (guild) => {
+            // Create Kimaki role if it doesn't exist, or fix its position (fire-and-forget)
+            guild.roles
+              .fetch()
+              .then(async (roles) => {
+                const existingRole = roles.find(
+                  (role) => role.name.toLowerCase() === 'kimaki',
+                )
+                if (existingRole) {
+                  // Move to bottom if not already there
+                  if (existingRole.position > 1) {
+                    await existingRole.setPosition(1)
+                    cliLogger.info(`Moved "Kimaki" role to bottom in ${guild.name}`)
+                  }
+                  return
+                }
+                return guild.roles.create({
+                  name: 'Kimaki',
+                  position: 1, // Place at bottom so anyone with Manage Roles can assign it
+                  reason:
+                    'Kimaki bot permission role - assign to users who can start sessions, send messages in threads, and use voice features',
+                })
+              })
+              .then((role) => {
+                if (role) {
+                  cliLogger.info(`Created "Kimaki" role in ${guild.name}`)
+                }
+              })
+              .catch((error) => {
+                cliLogger.warn(
+                  `Could not create Kimaki role in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`,
+                )
+              })
+
+            const channels = await getChannelsWithDescriptions(guild)
+            const kimakiChans = channels.filter(
+              (ch) =>
+                ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId),
+            )
+
+            return { guild, channels: kimakiChans }
+          }),
+        )
 
-          if (kimakiChans.length > 0) {
-            kimakiChannels.push({ guild, channels: kimakiChans })
+        // Collect results
+        for (const result of guildResults) {
+          if (result.channels.length > 0) {
+            kimakiChannels.push(result)
           }
         }
 
@@ -612,32 +660,25 @@ async function run({ restart, addChannels }: CliOptions) {
     note(channelList, 'Existing Kimaki Channels')
   }
 
-  s.start('Starting OpenCode server...')
-
-  const currentDir = process.cwd()
-  let getClient = await initializeOpencodeForDirectory(currentDir)
-  s.stop('OpenCode server started!')
+  // Await the OpenCode server that was started in parallel with Discord login
+  s.start('Waiting for OpenCode server...')
+  const getClient = await opencodePromise
+  s.stop('OpenCode server ready!')
 
-  s.start('Fetching OpenCode projects...')
+  s.start('Fetching OpenCode data...')
 
-  let projects: Project[] = []
+  // Fetch projects and commands in parallel
+  const [projects, allUserCommands] = await Promise.all([
+    getClient().project.list({}).then((r) => r.data || []).catch((error) => {
+      s.stop('Failed to fetch projects')
+      cliLogger.error('Error:', error instanceof Error ? error.message : String(error))
+      discordClient.destroy()
+      process.exit(EXIT_NO_RESTART)
+    }),
+    getClient().command.list({ query: { directory: currentDir } }).then((r) => r.data || []).catch(() => []),
+  ])
 
-  try {
-    const projectsResponse = await getClient().project.list({})
-    if (!projectsResponse.data) {
-      throw new Error('Failed to fetch projects')
-    }
-    projects = projectsResponse.data
-    s.stop(`Found ${projects.length} OpenCode project(s)`)
-  } catch (error) {
-    s.stop('Failed to fetch projects')
-    cliLogger.error(
-      'Error:',
-      error instanceof Error ? error.message : String(error),
-    )
-    discordClient.destroy()
-    process.exit(EXIT_NO_RESTART)
-  }
+  s.stop(`Found ${projects.length} OpenCode project(s)`)
 
   const existingDirs = kimakiChannels.flatMap(({ channels }) =>
     channels
@@ -745,19 +786,6 @@ async function run({ restart, addChannels }: CliOptions) {
     }
   }
 
-  // Fetch user-defined commands using the already-running server
-  const allUserCommands: OpencodeCommand[] = []
-  try {
-    const commandsResponse = await getClient().command.list({
-      query: { directory: currentDir },
-    })
-    if (commandsResponse.data) {
-      allUserCommands.push(...commandsResponse.data)
-    }
-  } catch {
-    // Ignore errors fetching commands
-  }
-
   // Log available user commands
   const registrableCommands = allUserCommands.filter(
     (cmd) => !SKIP_USER_COMMANDS.includes(cmd.name),
@@ -838,13 +866,31 @@ cli
     '--data-dir <path>',
     'Data directory for config and database (default: ~/.kimaki)',
   )
-  .action(async (options: { restart?: boolean; addChannels?: boolean; dataDir?: string }) => {
+  .option('--install-url', 'Print the bot install URL and exit')
+  .action(async (options: { restart?: boolean; addChannels?: boolean; dataDir?: string; installUrl?: boolean }) => {
     try {
       // Set data directory early, before any database access
       if (options.dataDir) {
         setDataDir(options.dataDir)
         cliLogger.log(`Using data directory: ${getDataDir()}`)
       }
+
+      if (options.installUrl) {
+        const db = getDatabase()
+        const existingBot = db
+          .prepare(
+            'SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1',
+          )
+          .get() as { app_id: string } | undefined
+
+        if (!existingBot) {
+          cliLogger.error('No bot configured yet. Run `kimaki` first to set up.')
+          process.exit(EXIT_NO_RESTART)
+        }
+
+        console.log(generateBotInstallUrl({ clientId: existingBot.app_id }))
+        process.exit(0)
+      }
       
       await checkSingleInstance()
       await startLockServer()
@@ -958,6 +1004,196 @@ cli
   })
 
 
+// Magic prefix used to identify bot-initiated sessions.
+// The running bot will recognize this prefix and start a session.
+const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**'
+
+cli
+  .command('start-session', 'Start a new session in a Discord channel (creates thread, bot handles the rest)')
+  .option('-c, --channel <channelId>', 'Discord channel ID')
+  .option('-p, --prompt <prompt>', 'Initial prompt for the session')
+  .option('-n, --name [name]', 'Thread name (optional, defaults to prompt preview)')
+  .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
+  .action(async (options: { channel?: string; prompt?: string; name?: string; appId?: string }) => {
+    try {
+      const { channel: channelId, prompt, name, appId: optionAppId } = options
+
+      if (!channelId) {
+        cliLogger.error('Channel ID is required. Use --channel <channelId>')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      if (!prompt) {
+        cliLogger.error('Prompt is required. Use --prompt <prompt>')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      // Get bot token from env var or database
+      const envToken = process.env.KIMAKI_BOT_TOKEN
+      let botToken: string | undefined
+      let appId: string | undefined = optionAppId
+
+      if (envToken) {
+        botToken = envToken
+        if (!appId) {
+          // Try to get app_id from database if available (optional in CI)
+          try {
+            const db = getDatabase()
+            const botRow = db
+              .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+              .get() as { app_id: string } | undefined
+            appId = botRow?.app_id
+          } catch {
+            // Database might not exist in CI, that's ok
+          }
+        }
+      } else {
+        // Fall back to database
+        try {
+          const db = getDatabase()
+          const botRow = db
+            .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+            .get() as { app_id: string; token: string } | undefined
+
+          if (botRow) {
+            botToken = botRow.token
+            appId = appId || botRow.app_id
+          }
+        } catch (e) {
+          // Database error - will fall through to the check below
+          cliLogger.error('Database error:', e instanceof Error ? e.message : String(e))
+        }
+      }
+
+      if (!botToken) {
+        cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const s = spinner()
+      s.start('Fetching channel info...')
+
+      // Get channel info to extract directory from topic
+      const channelResponse = await fetch(
+        `https://discord.com/api/v10/channels/${channelId}`,
+        {
+          headers: {
+            'Authorization': `Bot ${botToken}`,
+          },
+        }
+      )
+
+      if (!channelResponse.ok) {
+        const error = await channelResponse.text()
+        s.stop('Failed to fetch channel')
+        throw new Error(`Discord API error: ${channelResponse.status} - ${error}`)
+      }
+
+      const channelData = await channelResponse.json() as {
+        id: string
+        name: string
+        topic?: string
+        guild_id: string
+      }
+
+      if (!channelData.topic) {
+        s.stop('Channel has no topic')
+        throw new Error(`Channel #${channelData.name} has no topic. It must have a <kimaki.directory> tag.`)
+      }
+
+      const extracted = extractTagsArrays({
+        xml: channelData.topic,
+        tags: ['kimaki.directory', 'kimaki.app'],
+      })
+
+      const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+      const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+
+      if (!projectDirectory) {
+        s.stop('No kimaki.directory tag found')
+        throw new Error(`Channel #${channelData.name} has no <kimaki.directory> tag in topic.`)
+      }
+
+      // Verify app ID matches if both are present
+      if (channelAppId && appId && channelAppId !== appId) {
+        s.stop('Channel belongs to different bot')
+        throw new Error(`Channel belongs to a different bot (expected: ${appId}, got: ${channelAppId})`)
+      }
+
+      s.message('Creating starter message...')
+
+      // Create starter message with magic prefix
+      // The full prompt goes in the message so the bot can read it
+      const starterMessageResponse = await fetch(
+        `https://discord.com/api/v10/channels/${channelId}/messages`,
+        {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bot ${botToken}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            content: `${BOT_SESSION_PREFIX}\n${prompt}`,
+          }),
+        }
+      )
+
+      if (!starterMessageResponse.ok) {
+        const error = await starterMessageResponse.text()
+        s.stop('Failed to create message')
+        throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`)
+      }
+
+      const starterMessage = await starterMessageResponse.json() as { id: string }
+
+      s.message('Creating thread...')
+
+      // Create thread from the message
+      const threadName = name || (prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt)
+      const threadResponse = await fetch(
+        `https://discord.com/api/v10/channels/${channelId}/messages/${starterMessage.id}/threads`,
+        {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bot ${botToken}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            name: threadName.slice(0, 100),
+            auto_archive_duration: 1440, // 1 day
+          }),
+        }
+      )
+
+      if (!threadResponse.ok) {
+        const error = await threadResponse.text()
+        s.stop('Failed to create thread')
+        throw new Error(`Discord API error: ${threadResponse.status} - ${error}`)
+      }
+
+      const threadData = await threadResponse.json() as { id: string; name: string }
+
+      s.stop('Thread created!')
+
+      const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`
+
+      note(
+        `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`,
+        '✅ Thread Created',
+      )
+
+      console.log(threadUrl)
+
+      process.exit(0)
+    } catch (error) {
+      cliLogger.error(
+        'Error:',
+        error instanceof Error ? error.message : String(error),
+      )
+      process.exit(EXIT_NO_RESTART)
+    }
+  })
+
 
 cli.help()
 cli.parse()

package/src/commands/ask-question.ts

@@ -10,7 +10,7 @@ import {
 } from 'discord.js'
 import crypto from 'node:crypto'
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
-import { getOpencodeServerPort } from '../opencode.js'
+import { getOpencodeClientV2 } from '../opencode.js'
 import { createLogger } from '../logger.js'
 
 const logger = createLogger('ASK_QUESTION')
@@ -200,31 +200,20 @@ async function submitQuestionAnswers(
   context: PendingQuestionContext
 ): Promise<void> {
   try {
-    // Build answers array: each element is an array of selected labels for that question
-    const answersPayload = context.questions.map((_, i) => {
-      return context.answers[i] || []
-    })
-
-    // Reply to the question using direct HTTP call to OpenCode API
-    // (v1 SDK doesn't have question.reply, so we call it directly)
-    const port = getOpencodeServerPort(context.directory)
-    if (!port) {
+    const clientV2 = getOpencodeClientV2(context.directory)
+    if (!clientV2) {
       throw new Error('OpenCode server not found for directory')
     }
 
-    const response = await fetch(
-      `http://127.0.0.1:${port}/question/${context.requestId}/reply`,
-      {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ answers: answersPayload }),
-      }
-    )
+    // Build answers array: each element is an array of selected labels for that question
+    const answers = context.questions.map((_, i) => {
+      return context.answers[i] || []
+    })
 
-    if (!response.ok) {
-      const text = await response.text()
-      throw new Error(`Failed to reply to question: ${response.status} ${text}`)
-    }
+    await clientV2.question.reply({
+      requestID: context.requestId,
+      answers,
+    })
 
     logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`)
   } catch (error) {
@@ -275,3 +264,49 @@ export function parseAskUserQuestionTool(part: {
 
   return input
 }
+
+/**
+ * Cancel a pending question for a thread (e.g., when user sends a new message).
+ * Sends cancellation response to OpenCode so the session can continue.
+ */
+export async function cancelPendingQuestion(threadId: string): Promise<boolean> {
+  // Find pending question for this thread
+  let contextHash: string | undefined
+  let context: PendingQuestionContext | undefined
+  for (const [hash, ctx] of pendingQuestionContexts) {
+    if (ctx.thread.id === threadId) {
+      contextHash = hash
+      context = ctx
+      break
+    }
+  }
+
+  if (!contextHash || !context) {
+    return false
+  }
+
+  try {
+    const clientV2 = getOpencodeClientV2(context.directory)
+    if (!clientV2) {
+      throw new Error('OpenCode server not found for directory')
+    }
+
+    // Preserve already-answered questions, mark unanswered as cancelled
+    const answers = context.questions.map((_, i) => {
+      return context.answers[i] || ['(cancelled - user sent new message)']
+    })
+
+    await clientV2.question.reply({
+      requestID: context.requestId,
+      answers,
+    })
+
+    logger.log(`Cancelled question ${context.requestId} due to new user message`)
+  } catch (error) {
+    logger.error('Failed to cancel question:', error)
+  }
+
+  // Clean up regardless of whether the API call succeeded
+  pendingQuestionContexts.delete(contextHash)
+  return true
+}

package/src/discord-bot.ts

@@ -180,7 +180,10 @@ export async function startDiscordBot({
         )
 
         if (!isOwner && !isAdmin && !canManageServer && !hasKimakiRole) {
-          await message.react('🔒')
+          await message.reply({
+            content: `You don't have permission to start sessions.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
+            flags: SILENT_MESSAGE_FLAGS,
+          })
           return
         }
       }
@@ -412,6 +415,99 @@ export async function startDiscordBot({
     }
   })
 
+  // Magic prefix used by `kimaki start-session` CLI command to initiate sessions
+  const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**'
+
+  // Handle bot-initiated threads created by `kimaki start-session`
+  discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
+    try {
+      if (!newlyCreated) {
+        return
+      }
+
+      // Only handle threads in text channels
+      const parent = thread.parent as TextChannel | null
+      if (!parent || parent.type !== ChannelType.GuildText) {
+        return
+      }
+
+      // Get the starter message to check for magic prefix
+      const starterMessage = await thread.fetchStarterMessage().catch(() => null)
+      if (!starterMessage) {
+        discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`)
+        return
+      }
+
+      // Only handle messages from this bot with the magic prefix
+      if (starterMessage.author.id !== discordClient.user?.id) {
+        return
+      }
+
+      if (!starterMessage.content.startsWith(BOT_SESSION_PREFIX)) {
+        return
+      }
+
+      discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`)
+
+      // Extract the prompt (everything after the prefix)
+      const prompt = starterMessage.content.slice(BOT_SESSION_PREFIX.length).trim()
+      if (!prompt) {
+        discordLogger.log(`[BOT_SESSION] No prompt found in starter message`)
+        return
+      }
+
+      // Extract directory from parent channel topic
+      if (!parent.topic) {
+        discordLogger.log(`[BOT_SESSION] Parent channel has no topic`)
+        return
+      }
+
+      const extracted = extractTagsArrays({
+        xml: parent.topic,
+        tags: ['kimaki.directory', 'kimaki.app'],
+      })
+
+      const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+      const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+
+      if (!projectDirectory) {
+        discordLogger.log(`[BOT_SESSION] No kimaki.directory in parent channel topic`)
+        return
+      }
+
+      if (channelAppId && channelAppId !== currentAppId) {
+        discordLogger.log(`[BOT_SESSION] Channel belongs to different bot app`)
+        return
+      }
+
+      if (!fs.existsSync(projectDirectory)) {
+        discordLogger.error(`[BOT_SESSION] Directory does not exist: ${projectDirectory}`)
+        await thread.send({
+          content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory)}`,
+          flags: SILENT_MESSAGE_FLAGS,
+        })
+        return
+      }
+
+      discordLogger.log(`[BOT_SESSION] Starting session for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}..."`)
+
+      await handleOpencodeSession({
+        prompt,
+        thread,
+        projectDirectory,
+        channelId: parent.id,
+      })
+    } catch (error) {
+      voiceLogger.error('[BOT_SESSION] Error handling bot-initiated thread:', error)
+      try {
+        const errMsg = error instanceof Error ? error.message : String(error)
+        await thread.send({ content: `Error: ${errMsg}`, flags: SILENT_MESSAGE_FLAGS })
+      } catch {
+        // Ignore send errors
+      }
+    }
+  })
+
   await discordClient.login(token)
 
   const handleShutdown = async (signal: string, { skipExit = false } = {}) => {

package/src/discord-utils.ts

@@ -11,6 +11,7 @@ import {
 import { Lexer } from 'marked'
 import { extractTagsArrays } from './xml.js'
 import { formatMarkdownTables } from './format-tables.js'
+import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js'
 import { createLogger } from './logger.js'
 
 const discordLogger = createLogger('DISCORD')
@@ -125,7 +126,8 @@ export function splitMarkdownForDiscord({
 
         // calculate overhead for code block markers
         const codeBlockOverhead = line.inCodeBlock ? ('```' + line.lang + '\n').length + '```\n'.length : 0
-        const availablePerChunk = maxLength - codeBlockOverhead - 50 // safety margin
+        // 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)
 
@@ -198,6 +200,7 @@ export async function sendThreadMessage(
   const MAX_LENGTH = 2000
 
   content = formatMarkdownTables(content)
+  content = unnestCodeBlocksFromLists(content)
   content = escapeBackticksInCodeBlocks(content)
 
   // If custom flags provided, send as single message (no chunking)

package/src/escape-backticks.test.ts

@@ -376,11 +376,19 @@ test('splitMarkdownForDiscord handles very long line inside code block', () => {
     \`\`\`
     ",
       "\`\`\`js
-    veryverylonglinethatexceedsmaxlength
-    \`\`\`
+    veryverylo\`\`\`
     ",
       "\`\`\`js
-    short
+    nglinethat\`\`\`
+    ",
+      "\`\`\`js
+    exceedsmax\`\`\`
+    ",
+      "\`\`\`js
+    length
+    \`\`\`
+    ",
+      "short
     \`\`\`
     ",
     ]