kimaki 0.4.13 → 0.4.15

package/dist/cli.js

@@ -3,7 +3,7 @@ import { cac } from 'cac';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl } from './utils.js';
 import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discordBot.js';
-import { Events, ChannelType, REST, Routes, SlashCommandBuilder, } from 'discord.js';
+import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
@@ -78,12 +78,16 @@ async function registerCommands(token, appId) {
             .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);
     try {
@@ -558,22 +562,87 @@ 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, options) => {
+    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);
+        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();
+        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');
-        fs.copyFileSync(pluginSrc, pluginDest);
-        fs.copyFileSync(commandSrc, commandDest);
-        note(`Plugin: ${pluginDest}\nCommand: ${commandDest}\n\nUse /send-to-kimaki-discord in OpenCode to send the current session to Discord.`, '✅ Installed');
+        const sendCommandDest = path.join(commandDir, 'send-to-kimaki-discord.md');
+        const uploadCommandDest = path.join(commandDir, 'upload-to-discord.md');
+        fs.copyFileSync(sendCommandSrc, sendCommandDest);
+        fs.copyFileSync(uploadCommandSrc, uploadCommandDest);
+        note(`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');
         process.exit(0);
     }
     catch (error) {

package/dist/discordBot.js

@@ -22,9 +22,25 @@ import { isAbortError } from './utils.js';
 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 = `
+function parseSlashCommand(text) {
+    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 }) {
+    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
@@ -66,6 +82,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');
 const opencodeLogger = createLogger('OPENCODE');
@@ -1023,7 +1040,7 @@ export async function createDiscordClient() {
         ],
     });
 }
-async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], }) {
+async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], parsedCommand, }) {
     voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
     // Track session start time
     const sessionStartTime = Date.now();
@@ -1117,6 +1134,8 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
     let currentParts = [];
     let stopTyping = null;
     let usedModel;
+    let usedProviderID;
+    let inputTokens = 0;
     const sendPartMessage = async (part) => {
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
@@ -1125,14 +1144,11 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
         // 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()
                 .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
@@ -1151,12 +1167,10 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 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
             thread.sendTyping().catch((e) => {
@@ -1184,39 +1198,34 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 if (typingInterval) {
                     clearInterval(typingInterval);
                     typingInterval = null;
-                    discordLogger.log(`Stopped typing for thread ${thread.id}`);
                 }
             };
         }
         try {
             let assistantMessageId;
             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;
                     }
                     const existingIndex = currentParts.findIndex((p) => p.id === part.id);
@@ -1226,15 +1235,18 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                     else {
                         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') {
                         stopTyping = startTyping(thread);
                     }
                     // 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') {
@@ -1305,12 +1317,6 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                         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) {
@@ -1323,31 +1329,20 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
         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
             if (!abortController.signal.aborted ||
@@ -1355,8 +1350,23 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
                 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`);
@@ -1364,22 +1374,36 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
     };
     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', text: prompt }, ...images];
-        sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
-        const response = await getClient().session.prompt({
-            path: { id: session.id },
-            body: {
-                parts,
-                system: OPENCODE_SYSTEM_MESSAGE,
-            },
-            signal: abortController.signal,
-        });
+        let 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 ? '...' : ''}"`);
+            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 parts = [{ type: 'text', 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`);
         // Update reaction to success
@@ -1493,7 +1517,6 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
     discordClient.on(Events.MessageCreate, async (message) => {
         try {
             if (message.author?.bot) {
-                voiceLogger.log(`[IGNORED] Bot message from ${message.author.tag} in channel ${message.channelId}`);
                 return;
             }
             if (message.partial) {
@@ -1511,10 +1534,8 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 const isOwner = message.member.id === message.guild.ownerId;
                 const isAdmin = message.member.permissions.has(PermissionsBitField.Flags.Administrator);
                 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;
             const isThread = [
@@ -1568,12 +1589,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     messageContent = transcription;
                 }
                 const images = getImageAttachments(message);
+                const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
                     prompt: messageContent,
                     thread,
                     projectDirectory,
                     originalMessage: message,
                     images,
+                    parsedCommand,
                 });
                 return;
             }
@@ -1634,12 +1657,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     messageContent = transcription;
                 }
                 const images = getImageAttachments(message);
+                const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
                     prompt: messageContent,
                     thread,
                     projectDirectory,
                     originalMessage: message,
                     images,
+                    parsedCommand,
                 });
             }
             else {
@@ -1895,10 +1920,12 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         await command.editReply(`Created new session in ${thread.toString()}`);
                         // Start the OpenCode session
+                        const parsedCommand = parseSlashCommand(fullPrompt);
                         await handleOpencodeSession({
                             prompt: fullPrompt,
                             thread,
                             projectDirectory,
+                            parsedCommand,
                         });
                     }
                     catch (error) {
@@ -2167,6 +2194,68 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                     }
                 }
+                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);
+                    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);
+                    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/dist/tools.js

@@ -8,7 +8,7 @@ const toolsLogger = createLogger('TOOLS');
 import { formatDistanceToNow } from 'date-fns';
 import { ShareMarkdown } from './markdown.js';
 import pc from 'picocolors';
-import { initializeOpencodeForDirectory, OPENCODE_SYSTEM_MESSAGE, } from './discordBot.js';
+import { initializeOpencodeForDirectory, getOpencodeSystemMessage, } from './discordBot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
     const client = getClient();
@@ -48,7 +48,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     body: {
                         parts: [{ type: 'text', text: message }],
                         model: sessionModel,
-                        system: OPENCODE_SYSTEM_MESSAGE,
+                        system: getOpencodeSystemMessage({ sessionId }),
                     },
                 })
                     .then(async (response) => {
@@ -115,7 +115,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         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/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.13",
+  "version": "0.4.15",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",

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...

package/src/opencode-plugin.ts

@@ -1,75 +0,0 @@
-/**
- * Kimaki Discord Plugin for OpenCode
- *
- * Adds /send-to-kimaki-discord command that sends the current session to Discord.
- *
- * Installation:
- *   kimaki install-plugin
- *
- * Use in OpenCode TUI:
- *   /send-to-kimaki-discord
- */
-
-import type { Plugin } from '@opencode-ai/plugin'
-
-export const KimakiDiscordPlugin: Plugin = async ({
-  client,
-  $,
-  directory,
-}) => {
-  return {
-    event: async ({ event }) => {
-      if (event.type !== 'command.executed') {
-        return
-      }
-
-      const { name, sessionID } = event.properties as {
-        name: string
-        sessionID: string
-      }
-
-      if (name !== 'send-to-kimaki-discord') {
-        return
-      }
-
-      if (!sessionID) {
-        await client.tui.showToast({
-          body: { message: 'No session ID available', variant: 'error' },
-        })
-        return
-      }
-
-      await client.tui.showToast({
-        body: { message: 'Creating Discord thread...', variant: 'info' },
-      })
-
-      try {
-        const result =
-          await $`npx -y kimaki send-to-discord ${sessionID} -d ${directory}`.text()
-
-        const urlMatch = result.match(/https:\/\/discord\.com\/channels\/\S+/)
-        const url = urlMatch ? urlMatch[0] : null
-
-        await client.tui.showToast({
-          body: {
-            message: url ? `Sent to Discord: ${url}` : 'Session sent to Discord',
-            variant: 'success',
-          },
-        })
-      } catch (error: any) {
-        const message =
-          error.stderr?.toString().trim() ||
-          error.stdout?.toString().trim() ||
-          error.message ||
-          String(error)
-
-        await client.tui.showToast({
-          body: {
-            message: `Failed: ${message.slice(0, 100)}`,
-            variant: 'error',
-          },
-        })
-      }
-    },
-  }
-}