kimaki 0.4.13 → 0.4.14

package/src/cli.ts

@@ -33,6 +33,7 @@ import {
   REST,
   Routes,
   SlashCommandBuilder,
+  AttachmentBuilder,
 } from 'discord.js'
 import path from 'node:path'
 import fs from 'node:fs'
@@ -134,12 +135,16 @@ async function registerCommands(token: string, appId: string) {
       .toJSON(),
     new SlashCommandBuilder()
       .setName('accept-always')
-      .setDescription('Accept and auto-approve future requests matching this pattern (e.g. "git *" approves all git commands)')
+      .setDescription('Accept and auto-approve future requests matching this pattern')
       .toJSON(),
     new SlashCommandBuilder()
       .setName('reject')
       .setDescription('Reject a pending permission request')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('abort')
+      .setDescription('Abort the current OpenCode request in this thread')
+      .toJSON(),
   ]
 
   const rest = new REST().setToken(token)
@@ -832,28 +837,120 @@ cli
   })
 
 cli
-  .command('install-plugin', 'Install the OpenCode plugin for /send-to-kimaki-discord command')
+  .command('upload-to-discord [...files]', 'Upload files to a Discord thread for a session')
+  .option('-s, --session <sessionId>', 'OpenCode session ID')
+  .action(async (files: string[], options: { session?: string }) => {
+    try {
+      const { session: sessionId } = options
+
+      if (!sessionId) {
+        cliLogger.error('Session ID is required. Use --session <sessionId>')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      if (!files || files.length === 0) {
+        cliLogger.error('At least one file path is required')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const resolvedFiles = files.map((f) => path.resolve(f))
+      for (const file of resolvedFiles) {
+        if (!fs.existsSync(file)) {
+          cliLogger.error(`File not found: ${file}`)
+          process.exit(EXIT_NO_RESTART)
+        }
+      }
+
+      const db = getDatabase()
+
+      const threadRow = db
+        .prepare('SELECT thread_id FROM thread_sessions WHERE session_id = ?')
+        .get(sessionId) as { thread_id: string } | undefined
+
+      if (!threadRow) {
+        cliLogger.error(`No Discord thread found for session: ${sessionId}`)
+        cliLogger.error('Make sure the session has been sent to Discord first using /send-to-kimaki-discord')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      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) {
+        cliLogger.error('No bot credentials found. Run `kimaki` first to set up the bot.')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const s = spinner()
+      s.start(`Uploading ${resolvedFiles.length} file(s)...`)
+
+      for (const file of resolvedFiles) {
+        const buffer = fs.readFileSync(file)
+
+        const formData = new FormData()
+        formData.append('payload_json', JSON.stringify({
+          attachments: [{ id: 0, filename: path.basename(file) }]
+        }))
+        formData.append('files[0]', new Blob([buffer]), path.basename(file))
+
+        const response = await fetch(
+          `https://discord.com/api/v10/channels/${threadRow.thread_id}/messages`,
+          {
+            method: 'POST',
+            headers: {
+              'Authorization': `Bot ${botRow.token}`,
+            },
+            body: formData,
+          }
+        )
+
+        if (!response.ok) {
+          const error = await response.text()
+          throw new Error(`Discord API error: ${response.status} - ${error}`)
+        }
+      }
+
+      s.stop(`Uploaded ${resolvedFiles.length} file(s)!`)
+
+      note(
+        `Files uploaded to Discord thread!\n\nFiles: ${resolvedFiles.map((f) => path.basename(f)).join(', ')}`,
+        '✅ Success',
+      )
+
+      process.exit(0)
+    } catch (error) {
+      cliLogger.error(
+        'Error:',
+        error instanceof Error ? error.message : String(error),
+      )
+      process.exit(EXIT_NO_RESTART)
+    }
+  })
+
+cli
+  .command('install-plugin', 'Install the OpenCode commands for kimaki Discord integration')
   .action(async () => {
     try {
       const require = createRequire(import.meta.url)
-      const pluginSrc = require.resolve('./opencode-plugin.ts')
-      const commandSrc = require.resolve('./opencode-command.md')
+      const sendCommandSrc = require.resolve('./opencode-command-send-to-discord.md')
+      const uploadCommandSrc = require.resolve('./opencode-command-upload-to-discord.md')
 
       const opencodeConfig = path.join(os.homedir(), '.config', 'opencode')
-      const pluginDir = path.join(opencodeConfig, 'plugin')
       const commandDir = path.join(opencodeConfig, 'command')
 
-      fs.mkdirSync(pluginDir, { recursive: true })
       fs.mkdirSync(commandDir, { recursive: true })
 
-      const pluginDest = path.join(pluginDir, 'send-to-kimaki-discord.ts')
-      const commandDest = path.join(commandDir, 'send-to-kimaki-discord.md')
+      const sendCommandDest = path.join(commandDir, 'send-to-kimaki-discord.md')
+      const uploadCommandDest = path.join(commandDir, 'upload-to-discord.md')
 
-      fs.copyFileSync(pluginSrc, pluginDest)
-      fs.copyFileSync(commandSrc, commandDest)
+      fs.copyFileSync(sendCommandSrc, sendCommandDest)
+      fs.copyFileSync(uploadCommandSrc, uploadCommandDest)
 
       note(
-        `Plugin: ${pluginDest}\nCommand: ${commandDest}\n\nUse /send-to-kimaki-discord in OpenCode to send the current session to Discord.`,
+        `Commands installed:\n- ${sendCommandDest}\n- ${uploadCommandDest}\n\nUse /send-to-kimaki-discord to send session to Discord.\nUse /upload-to-discord to upload files to the thread.`,
         '✅ Installed',
       )
 

package/src/discordBot.ts

@@ -54,9 +54,34 @@ import { setGlobalDispatcher, Agent } from 'undici'
 // disables the automatic 5 minutes abort after no body
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }))
 
-export const OPENCODE_SYSTEM_MESSAGE = `
+type ParsedCommand = {
+  isCommand: true
+  command: string
+  arguments: string
+} | {
+  isCommand: false
+}
+
+function parseSlashCommand(text: string): ParsedCommand {
+  const trimmed = text.trim()
+  if (!trimmed.startsWith('/')) {
+    return { isCommand: false }
+  }
+  const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/)
+  if (!match) {
+    return { isCommand: false }
+  }
+  const command = match[1]!
+  const args = match[2]?.trim() || ''
+  return { isCommand: true, command, arguments: args }
+}
+
+export function getOpencodeSystemMessage({ sessionId }: { sessionId: string }) {
+  return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
+Your current OpenCode session ID is: ${sessionId}
+
 After each message, if you implemented changes, you can show the user a diff via an url running the command, to show the changes in working directory:
 
 bunx critique web
@@ -98,6 +123,7 @@ code blocks for tables and diagrams MUST have Max length of 85 characters. other
 
 you can create diagrams wrapping them in code blocks too.
 `
+}
 
 const discordLogger = createLogger('DISCORD')
 const voiceLogger = createLogger('VOICE')
@@ -1349,12 +1375,14 @@ async function handleOpencodeSession({
   projectDirectory,
   originalMessage,
   images = [],
+  parsedCommand,
 }: {
   prompt: string
   thread: ThreadChannel
   projectDirectory?: string
   originalMessage?: Message
   images?: FilePartInput[]
+  parsedCommand?: ParsedCommand
 }): Promise<{ sessionID: string; result: any; port?: number } | undefined> {
   voiceLogger.log(
     `[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
@@ -1477,6 +1505,8 @@ async function handleOpencodeSession({
   let currentParts: Part[] = []
   let stopTyping: (() => void) | null = null
   let usedModel: string | undefined
+  let usedProviderID: string | undefined
+  let inputTokens = 0
 
   const sendPartMessage = async (part: Part) => {
     const content = formatPart(part) + '\n\n'
@@ -1487,22 +1517,12 @@ async function handleOpencodeSession({
 
     // Skip if already sent
     if (partIdToMessage.has(part.id)) {
-      voiceLogger.log(
-        `[SEND SKIP] Part ${part.id} already sent as message ${partIdToMessage.get(part.id)?.id}`,
-      )
       return
     }
 
     try {
-      voiceLogger.log(
-        `[SEND] Sending part ${part.id} (type: ${part.type}) to Discord, content length: ${content.length}`,
-      )
-
       const firstMessage = await sendThreadMessage(thread, content)
       partIdToMessage.set(part.id, firstMessage)
-      voiceLogger.log(
-        `[SEND SUCCESS] Part ${part.id} sent as message ${firstMessage.id}`,
-      )
 
       // Store part-message mapping in database
       getDatabase()
@@ -1525,13 +1545,10 @@ async function handleOpencodeSession({
         discordLogger.log(`Not starting typing, already aborted`)
         return () => {}
       }
-      discordLogger.log(`Starting typing for thread ${thread.id}`)
-
       // Clear any previous typing interval
       if (typingInterval) {
         clearInterval(typingInterval)
         typingInterval = null
-        discordLogger.log(`Cleared previous typing interval`)
       }
 
       // Send initial typing
@@ -1567,7 +1584,6 @@ async function handleOpencodeSession({
         if (typingInterval) {
           clearInterval(typingInterval)
           typingInterval = null
-          discordLogger.log(`Stopped typing for thread ${thread.id}`)
         }
       }
     }
@@ -1576,45 +1592,31 @@ async function handleOpencodeSession({
       let assistantMessageId: string | undefined
 
       for await (const event of events) {
-        sessionLogger.log(`Received: ${event.type}`)
         if (event.type === 'message.updated') {
           const msg = event.properties.info
 
           if (msg.sessionID !== session.id) {
-            voiceLogger.log(
-              `[EVENT IGNORED] Message from different session (expected: ${session.id}, got: ${msg.sessionID})`,
-            )
             continue
           }
 
           // Track assistant message ID
           if (msg.role === 'assistant') {
             assistantMessageId = msg.id
-
-
             usedModel = msg.modelID
-
-            voiceLogger.log(
-              `[EVENT] Tracking assistant message ${assistantMessageId}`,
-            )
-          } else {
-            sessionLogger.log(`Message role: ${msg.role}`)
+            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) {
-            voiceLogger.log(
-              `[EVENT IGNORED] Part from different session (expected: ${session.id}, got: ${part.sessionID})`,
-            )
             continue
           }
 
           // Only process parts from assistant messages
           if (part.messageID !== assistantMessageId) {
-            voiceLogger.log(
-              `[EVENT IGNORED] Part from non-assistant message (expected: ${assistantMessageId}, got: ${part.messageID})`,
-            )
             continue
           }
 
@@ -1627,9 +1629,7 @@ async function handleOpencodeSession({
             currentParts.push(part)
           }
 
-          voiceLogger.log(
-            `[PART] Update: id=${part.id}, type=${part.type}, text=${'text' in part && typeof part.text === 'string' ? part.text.slice(0, 50) : ''}`,
-          )
+
 
           // Start typing on step-start
           if (part.type === 'step-start') {
@@ -1638,10 +1638,12 @@ async function handleOpencodeSession({
 
           // 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
-            voiceLogger.log(
-              `[STEP-FINISH] Sending ${currentParts.length} parts to Discord`,
-            )
             for (const p of currentParts) {
               // Skip step-start and step-finish parts as they have no visual content
               if (p.type !== 'step-start' && p.type !== 'step-finish') {
@@ -1728,10 +1730,6 @@ async function handleOpencodeSession({
           if (pending && pending.permission.id === permissionID) {
             pendingPermissions.delete(thread.id)
           }
-        } else if (event.type === 'file.edited') {
-          sessionLogger.log(`File edited event received`)
-        } else {
-          sessionLogger.log(`Unhandled event type: ${event.type}`)
         }
       }
     } catch (e) {
@@ -1745,37 +1743,20 @@ async function handleOpencodeSession({
       throw e
     } finally {
       // Send any remaining parts that weren't sent
-      voiceLogger.log(
-        `[CLEANUP] Checking ${currentParts.length} parts for unsent messages`,
-      )
-      let unsentCount = 0
       for (const part of currentParts) {
         if (!partIdToMessage.has(part.id)) {
-          unsentCount++
-          voiceLogger.log(
-            `[CLEANUP] Sending unsent part: id=${part.id}, type=${part.type}`,
-          )
           try {
             await sendPartMessage(part)
           } catch (error) {
-            sessionLogger.log(
-              `Failed to send part ${part.id} during cleanup:`,
-              error,
-            )
+            sessionLogger.error(`Failed to send part ${part.id}:`, error)
           }
         }
       }
-      if (unsentCount === 0) {
-        sessionLogger.log(`All parts were already sent`)
-      } else {
-        sessionLogger.log(`Sent ${unsentCount} previously unsent parts`)
-      }
 
       // Stop typing when session ends
       if (stopTyping) {
         stopTyping()
         stopTyping = null
-        sessionLogger.log(`Stopped typing for session`)
       }
 
       // Only send duration message if request was not aborted or was aborted with 'finished' reason
@@ -1788,8 +1769,22 @@ async function handleOpencodeSession({
         )
         const attachCommand = port ? ` ⋅ ${session.id}` : ''
         const modelInfo = usedModel ? ` ⋅ ${usedModel}` : ''
-        await sendThreadMessage(thread, `_Completed in ${sessionDuration}_${attachCommand}${modelInfo}`)
-        sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${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)
+          }
+        }
+        await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`)
+        sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${inputTokens}`)
       } else {
         sessionLogger.log(
           `Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`,
@@ -1799,27 +1794,42 @@ async function handleOpencodeSession({
   }
 
   try {
-    voiceLogger.log(
-      `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
-    )
-    if (images.length > 0) {
-      sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })))
-    }
-
     // Start the event handler
     const eventHandlerPromise = eventHandler()
 
-    const parts = [{ type: 'text' as const, text: prompt }, ...images]
-    sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
+    let response: { data?: unknown }
+    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 ? '...' : ''}"`,
+      )
+      response = await getClient().session.command({
+        path: { id: session.id },
+        body: {
+          command: parsedCommand.command,
+          arguments: parsedCommand.arguments,
+        },
+        signal: abortController.signal,
+      })
+    } else {
+      voiceLogger.log(
+        `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
+      )
+      if (images.length > 0) {
+        sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })))
+      }
 
-    const response = await getClient().session.prompt({
-      path: { id: session.id },
-      body: {
-        parts,
-        system: OPENCODE_SYSTEM_MESSAGE,
-      },
-      signal: abortController.signal,
-    })
+      const parts = [{ type: 'text' as const, text: prompt }, ...images]
+      sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
+
+      response = await getClient().session.prompt({
+        path: { id: session.id },
+        body: {
+          parts,
+          system: getOpencodeSystemMessage({ sessionId: session.id }),
+        },
+        signal: abortController.signal,
+      })
+    }
     abortController.abort('finished')
 
     sessionLogger.log(`Successfully sent prompt, got response`)
@@ -1976,9 +1986,6 @@ export async function startDiscordBot({
   discordClient.on(Events.MessageCreate, async (message: Message) => {
     try {
       if (message.author?.bot) {
-        voiceLogger.log(
-          `[IGNORED] Bot message from ${message.author.tag} in channel ${message.channelId}`,
-        )
         return
       }
       if (message.partial) {
@@ -2002,15 +2009,8 @@ export async function startDiscordBot({
         )
 
         if (!isOwner && !isAdmin) {
-          voiceLogger.log(
-            `[IGNORED] Non-authoritative user ${message.author.tag} (ID: ${message.author.id}) - not owner or admin`,
-          )
           return
         }
-
-        voiceLogger.log(
-          `[AUTHORIZED] Message from ${message.author.tag} (Owner: ${isOwner}, Admin: ${isAdmin})`,
-        )
       }
 
       const channel = message.channel
@@ -2084,12 +2084,14 @@ export async function startDiscordBot({
         }
 
         const images = getImageAttachments(message)
+        const parsedCommand = parseSlashCommand(messageContent)
         await handleOpencodeSession({
           prompt: messageContent,
           thread,
           projectDirectory,
           originalMessage: message,
           images,
+          parsedCommand,
         })
         return
       }
@@ -2179,12 +2181,14 @@ export async function startDiscordBot({
         }
 
         const images = getImageAttachments(message)
+        const parsedCommand = parseSlashCommand(messageContent)
         await handleOpencodeSession({
           prompt: messageContent,
           thread,
           projectDirectory,
           originalMessage: message,
           images,
+          parsedCommand,
         })
       } else {
         discordLogger.log(`Channel type ${channel.type} is not supported`)
@@ -2520,10 +2524,12 @@ export async function startDiscordBot({
               )
 
               // Start the OpenCode session
+              const parsedCommand = parseSlashCommand(fullPrompt)
               await handleOpencodeSession({
                 prompt: fullPrompt,
                 thread,
                 projectDirectory,
+                parsedCommand,
               })
             } catch (error) {
               voiceLogger.error('[SESSION] Error:', error)
@@ -2891,6 +2897,77 @@ export async function startDiscordBot({
                 ephemeral: true,
               })
             }
+          } else if (command.commandName === 'abort') {
+            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 existingController = abortControllers.get(sessionId)
+              if (existingController) {
+                existingController.abort(new Error('User requested abort'))
+                abortControllers.delete(sessionId)
+              }
+
+              const getClient = await initializeOpencodeForDirectory(directory)
+              await getClient().session.abort({
+                path: { id: sessionId },
+              })
+
+              await command.reply(`🛑 Request **aborted**`)
+              sessionLogger.log(`Session ${sessionId} aborted by user`)
+            } catch (error) {
+              voiceLogger.error('[ABORT] Error:', error)
+              await command.reply({
+                content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ephemeral: true,
+              })
+            }
           }
         }
       } catch (error) {

package/src/opencode-command-send-to-discord.md

@@ -0,0 +1,12 @@
+---
+description: Send current session to Discord
+---
+Run the following command to send this session to Discord:
+
+```bash
+npx -y kimaki send-to-discord <sessionId>
+```
+
+Replace `<sessionId>` with your current OpenCode session ID (available in the system prompt).
+
+The command will create a Discord thread with your session history and return the Discord URL.

package/src/opencode-command-upload-to-discord.md

@@ -0,0 +1,22 @@
+---
+description: Upload files to Discord thread
+---
+Upload files to the current Discord thread by running:
+
+```bash
+npx -y kimaki upload-to-discord --session <sessionId> <file1> [file2] [file3] ...
+```
+
+Replace `<sessionId>` with your current OpenCode session ID (available in the system prompt).
+
+Examples:
+
+```bash
+# Upload a single file
+npx -y kimaki upload-to-discord --session ses_abc123 ./screenshot.png
+
+# Upload multiple files
+npx -y kimaki upload-to-discord --session ses_abc123 ./image1.png ./image2.jpg ./document.pdf
+```
+
+The session must have been sent to Discord first using `/send-to-kimaki-discord`.

package/src/tools.ts

@@ -17,7 +17,7 @@ import { ShareMarkdown } from './markdown.js'
 import pc from 'picocolors'
 import {
   initializeOpencodeForDirectory,
-  OPENCODE_SYSTEM_MESSAGE,
+  getOpencodeSystemMessage,
 } from './discordBot.js'
 
 export async function getTools({
@@ -78,7 +78,7 @@ export async function getTools({
             body: {
               parts: [{ type: 'text', text: message }],
               model: sessionModel,
-              system: OPENCODE_SYSTEM_MESSAGE,
+              system: getOpencodeSystemMessage({ sessionId }),
             },
           })
           .then(async (response) => {
@@ -152,7 +152,7 @@ export async function getTools({
               path: { id: session.data.id },
               body: {
                 parts: [{ type: 'text', text: message }],
-                system: OPENCODE_SYSTEM_MESSAGE,
+                system: getOpencodeSystemMessage({ sessionId: session.data.id }),
               },
             })
             .then(async (response) => {

package/src/opencode-command.md

@@ -1,4 +0,0 @@
----
-description: Create Discord thread for current session
----
-Creating Discord thread for this session...