kimaki 0.4.6 → 0.4.9

package/README.md

@@ -1,7 +1,69 @@
-creating a new bot
+# Kimaki Discord Bot
 
-- first tell user to go to https://discord.com/developers/applications and create a new app
-- get bot app id
-- get bot token in Discord clicking reset bot token. show a password input
+A Discord bot that integrates OpenCode coding sessions with Discord channels and voice.
 
--
+## Installation
+
+```bash
+npm install -g kimaki
+```
+
+## Setup
+
+Run the interactive setup:
+
+```bash
+kimaki
+```
+
+This will guide you through:
+1. Creating a Discord application at https://discord.com/developers/applications
+2. Getting your bot token
+3. Installing the bot to your Discord server
+4. Creating channels for your OpenCode projects
+
+## Commands
+
+### Start the bot
+
+```bash
+kimaki
+```
+
+### Send a session to Discord
+
+Send an OpenCode session to Discord from the CLI:
+
+```bash
+kimaki send-to-discord <session-id>
+```
+
+Options:
+- `-d, --directory <dir>` - Project directory (defaults to current working directory)
+
+### OpenCode Integration
+
+To use the `/send-to-kimaki-discord` command in OpenCode:
+
+```bash
+npx kimaki install-plugin
+```
+
+Then use `/send-to-kimaki-discord` in OpenCode to send the current session to Discord.
+
+## Discord Slash Commands
+
+Once the bot is running, you can use these commands in Discord:
+
+- `/session <prompt>` - Start a new OpenCode session
+- `/resume <session>` - Resume an existing session
+- `/add-project <project>` - Add a new project to Discord
+- `/accept` - Accept a permission request
+- `/accept-always` - Accept and auto-approve similar requests
+- `/reject` - Reject a permission request
+
+## Voice Support
+
+Join a voice channel that has an associated project directory, and the bot will join with Jarvis-like voice interaction powered by Gemini.
+
+Requires a Gemini API key (prompted during setup).

package/dist/cli.js

@@ -6,6 +6,8 @@ import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDis
 import { Events, ChannelType, REST, Routes, SlashCommandBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
 import { createLogger } from './logger.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 const cliLogger = createLogger('CLI');
@@ -70,6 +72,18 @@ async function registerCommands(token, appId) {
             return option;
         })
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('accept')
+            .setDescription('Accept a pending permission request (this request only)')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('accept-always')
+            .setDescription('Accept and auto-approve future requests matching this pattern (e.g. "git *" approves all git commands)')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('reject')
+            .setDescription('Reject a pending permission request')
+            .toJSON(),
     ];
     const rest = new REST().setToken(token);
     try {
@@ -423,5 +437,149 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('send-to-discord <sessionId>', 'Send an OpenCode session to Discord and create a thread for it')
+    .option('-d, --directory <dir>', 'Project directory (defaults to current working directory)')
+    .action(async (sessionId, options) => {
+    try {
+        const directory = options.directory || process.cwd();
+        const db = getDatabase();
+        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 channelRow = db
+            .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+            .get(directory, 'text');
+        if (!channelRow) {
+            cliLogger.error(`No Discord channel found for directory: ${directory}\n` +
+                'Run `kimaki --add-channels` to create a channel for this project.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const s = spinner();
+        s.start('Connecting to Discord...');
+        const discordClient = await createDiscordClient();
+        await new Promise((resolve, reject) => {
+            discordClient.once(Events.ClientReady, () => {
+                resolve();
+            });
+            discordClient.once(Events.Error, reject);
+            discordClient.login(botRow.token).catch(reject);
+        });
+        s.stop('Connected to Discord!');
+        const channel = await discordClient.channels.fetch(channelRow.channel_id);
+        if (!channel || channel.type !== ChannelType.GuildText) {
+            cliLogger.error('Could not find the text channel or it is not a text channel');
+            discordClient.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        const textChannel = channel;
+        s.start('Fetching session from OpenCode...');
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const sessionResponse = await getClient().session.get({
+            path: { id: sessionId },
+        });
+        if (!sessionResponse.data) {
+            s.stop('Session not found');
+            discordClient.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        const session = sessionResponse.data;
+        s.stop(`Found session: ${session.title}`);
+        s.start('Creating Discord thread...');
+        const thread = await textChannel.threads.create({
+            name: `Resume: ${session.title}`.slice(0, 100),
+            autoArchiveDuration: 1440,
+            reason: `Resuming session ${sessionId} from CLI`,
+        });
+        db.prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)').run(thread.id, sessionId);
+        s.stop('Created Discord thread!');
+        s.start('Loading session messages...');
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data) {
+            s.stop('Failed to fetch session messages');
+            discordClient.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        const messages = messagesResponse.data;
+        await thread.send(`📂 **Resumed session:** ${session.title}\n📅 **Created:** ${new Date(session.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`);
+        let messageCount = 0;
+        for (const message of messages) {
+            if (message.info.role === 'user') {
+                const userParts = message.parts.filter((p) => p.type === 'text' && !p.synthetic);
+                const userTexts = userParts
+                    .map((p) => {
+                    if (p.type === 'text') {
+                        return p.text;
+                    }
+                    return '';
+                })
+                    .filter((t) => t.trim());
+                const userText = userTexts.join('\n\n');
+                if (userText) {
+                    const truncated = userText.length > 1900 ? userText.slice(0, 1900) + '…' : userText;
+                    await thread.send(`**User:**\n${truncated}`);
+                }
+            }
+            else if (message.info.role === 'assistant') {
+                const textParts = message.parts.filter((p) => p.type === 'text');
+                const texts = textParts
+                    .map((p) => {
+                    if (p.type === 'text') {
+                        return p.text;
+                    }
+                    return '';
+                })
+                    .filter((t) => t?.trim());
+                if (texts.length > 0) {
+                    const combinedText = texts.join('\n\n');
+                    const truncated = combinedText.length > 1900 ? combinedText.slice(0, 1900) + '…' : combinedText;
+                    await thread.send(truncated);
+                }
+            }
+            messageCount++;
+        }
+        await thread.send(`✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`);
+        s.stop(`Loaded ${messageCount} messages`);
+        const guildId = textChannel.guildId;
+        const threadUrl = `https://discord.com/channels/${guildId}/${thread.id}`;
+        note(`Session "${session.title}" has been sent to Discord!\n\nThread: ${threadUrl}`, '✅ Success');
+        discordClient.destroy();
+        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 plugin for /send-to-kimaki-discord command')
+    .action(async () => {
+    try {
+        const require = createRequire(import.meta.url);
+        const pluginSrc = require.resolve('./opencode-plugin.ts');
+        const commandSrc = require.resolve('./opencode-command.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');
+        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/dist/discordBot.js

@@ -35,6 +35,8 @@ const abortControllers = new Map();
 const voiceConnections = new Map();
 // Map of directory to retry count for server restarts
 const serverRetryCount = new Map();
+// Map of thread ID to pending permission (only one pending permission per thread)
+const pendingPermissions = new Map();
 let db = null;
 function convertToMono16k(buffer) {
     // Parameters
@@ -1160,6 +1162,38 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                     }
                     break;
                 }
+                else if (event.type === 'permission.updated') {
+                    const permission = event.properties;
+                    if (permission.sessionID !== session.id) {
+                        voiceLogger.log(`[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`);
+                        continue;
+                    }
+                    sessionLogger.log(`Permission requested: type=${permission.type}, title=${permission.title}`);
+                    const patternStr = Array.isArray(permission.pattern)
+                        ? permission.pattern.join(', ')
+                        : permission.pattern || '';
+                    const permissionMessage = await sendThreadMessage(thread, `⚠️ **Permission Required**\n\n` +
+                        `**Type:** \`${permission.type}\`\n` +
+                        `**Action:** ${permission.title}\n` +
+                        (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+                        `\nUse \`/accept\` or \`/reject\` to respond.`);
+                    pendingPermissions.set(thread.id, {
+                        permission,
+                        messageId: permissionMessage.id,
+                        directory,
+                    });
+                }
+                else if (event.type === 'permission.replied') {
+                    const { permissionID, response, sessionID } = event.properties;
+                    if (sessionID !== session.id) {
+                        continue;
+                    }
+                    sessionLogger.log(`Permission ${permissionID} replied with: ${response}`);
+                    const pending = pendingPermissions.get(thread.id);
+                    if (pending && pending.permission.id === permissionID) {
+                        pendingPermissions.delete(thread.id);
+                    }
+                }
                 else if (event.type === 'file.edited') {
                     sessionLogger.log(`File edited event received`);
                 }
@@ -1927,6 +1961,115 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
                     }
                 }
+                else if (command.commandName === 'accept' ||
+                    command.commandName === 'accept-always') {
+                    const scope = command.commandName === 'accept-always' ? 'always' : 'once';
+                    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 pending = pendingPermissions.get(channel.id);
+                    if (!pending) {
+                        await command.reply({
+                            content: 'No pending permission request in this thread',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(pending.directory);
+                        await getClient().postSessionIdPermissionsPermissionId({
+                            path: {
+                                id: pending.permission.sessionID,
+                                permissionID: pending.permission.id,
+                            },
+                            body: {
+                                response: scope,
+                            },
+                        });
+                        pendingPermissions.delete(channel.id);
+                        const msg = scope === 'always'
+                            ? `✅ Permission **accepted** (auto-approve similar requests)`
+                            : `✅ Permission **accepted**`;
+                        await command.reply(msg);
+                        sessionLogger.log(`Permission ${pending.permission.id} accepted with scope: ${scope}`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[ACCEPT] Error:', error);
+                        await command.reply({
+                            content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                        });
+                    }
+                }
+                else if (command.commandName === 'reject') {
+                    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 pending = pendingPermissions.get(channel.id);
+                    if (!pending) {
+                        await command.reply({
+                            content: 'No pending permission request in this thread',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(pending.directory);
+                        await getClient().postSessionIdPermissionsPermissionId({
+                            path: {
+                                id: pending.permission.sessionID,
+                                permissionID: pending.permission.id,
+                            },
+                            body: {
+                                response: 'reject',
+                            },
+                        });
+                        pendingPermissions.delete(channel.id);
+                        await command.reply(`❌ Permission **rejected**`);
+                        sessionLogger.log(`Permission ${pending.permission.id} rejected`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[REJECT] Error:', error);
+                        await command.reply({
+                            content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                        });
+                    }
+                }
             }
         }
         catch (error) {

package/dist/opencode-plugin.js

@@ -0,0 +1,53 @@
+/**
+ * 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
+ */
+export const KimakiDiscordPlugin = async ({ client, $, directory, }) => {
+    return {
+        event: async ({ event }) => {
+            if (event.type !== 'command.executed') {
+                return;
+            }
+            const { name, sessionID } = event.properties;
+            if (name !== 'send-to-kimaki-discord') {
+                return;
+            }
+            if (!sessionID) {
+                await client.tui.showToast({
+                    body: { message: 'No session ID available', variant: 'error' },
+                });
+                return;
+            }
+            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) {
+                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',
+                    },
+                });
+            }
+        },
+    };
+};

package/package.json

@@ -2,7 +2,17 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.6",
+  "version": "0.4.9",
+  "scripts": {
+    "dev": "tsx --env-file .env src/cli.ts",
+    "prepublishOnly": "pnpm tsc",
+    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
+    "watch": "tsx scripts/watch-session.ts",
+    "test:events": "tsx test-events.ts",
+    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts"
+  },
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -11,6 +21,7 @@
     "bin.js"
   ],
   "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.119",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest",
     "@types/js-yaml": "^4.0.9",
@@ -43,14 +54,5 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.0.17"
-  },
-  "scripts": {
-    "dev": "tsx --env-file .env src/cli.ts",
-    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
-    "watch": "tsx scripts/watch-session.ts",
-    "test:events": "tsx test-events.ts",
-    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
-    "test:send": "tsx send-test-message.ts",
-    "register-commands": "tsx scripts/register-commands.ts"
   }
-}
+}

package/src/cli.ts

@@ -36,6 +36,8 @@ import {
 } from 'discord.js'
 import path from 'node:path'
 import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import os from 'node:os'
 import { createLogger } from './logger.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 
@@ -126,6 +128,18 @@ async function registerCommands(token: string, appId: string) {
         return option
       })
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('accept')
+      .setDescription('Accept a pending permission request (this request only)')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('accept-always')
+      .setDescription('Accept and auto-approve future requests matching this pattern (e.g. "git *" approves all git commands)')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('reject')
+      .setDescription('Reject a pending permission request')
+      .toJSON(),
   ]
 
   const rest = new REST().setToken(token)
@@ -643,5 +657,215 @@ cli
     }
   })
 
+cli
+  .command(
+    'send-to-discord <sessionId>',
+    'Send an OpenCode session to Discord and create a thread for it',
+  )
+  .option('-d, --directory <dir>', 'Project directory (defaults to current working directory)')
+  .action(async (sessionId: string, options: { directory?: string }) => {
+    try {
+      const directory = options.directory || process.cwd()
+      
+      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) {
+        cliLogger.error('No bot credentials found. Run `kimaki` first to set up the bot.')
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const channelRow = db
+        .prepare(
+          'SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?',
+        )
+        .get(directory, 'text') as { channel_id: string } | undefined
+
+      if (!channelRow) {
+        cliLogger.error(
+          `No Discord channel found for directory: ${directory}\n` +
+            'Run `kimaki --add-channels` to create a channel for this project.',
+        )
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const s = spinner()
+      s.start('Connecting to Discord...')
+
+      const discordClient = await createDiscordClient()
+
+      await new Promise<void>((resolve, reject) => {
+        discordClient.once(Events.ClientReady, () => {
+          resolve()
+        })
+        discordClient.once(Events.Error, reject)
+        discordClient.login(botRow.token).catch(reject)
+      })
+
+      s.stop('Connected to Discord!')
+
+      const channel = await discordClient.channels.fetch(channelRow.channel_id)
+      if (!channel || channel.type !== ChannelType.GuildText) {
+        cliLogger.error('Could not find the text channel or it is not a text channel')
+        discordClient.destroy()
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const textChannel = channel as import('discord.js').TextChannel
+
+      s.start('Fetching session from OpenCode...')
+
+      const getClient = await initializeOpencodeForDirectory(directory)
+      const sessionResponse = await getClient().session.get({
+        path: { id: sessionId },
+      })
+
+      if (!sessionResponse.data) {
+        s.stop('Session not found')
+        discordClient.destroy()
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const session = sessionResponse.data
+      s.stop(`Found session: ${session.title}`)
+
+      s.start('Creating Discord thread...')
+
+      const thread = await textChannel.threads.create({
+        name: `Resume: ${session.title}`.slice(0, 100),
+        autoArchiveDuration: 1440,
+        reason: `Resuming session ${sessionId} from CLI`,
+      })
+
+      db.prepare(
+        'INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)',
+      ).run(thread.id, sessionId)
+
+      s.stop('Created Discord thread!')
+
+      s.start('Loading session messages...')
+
+      const messagesResponse = await getClient().session.messages({
+        path: { id: sessionId },
+      })
+
+      if (!messagesResponse.data) {
+        s.stop('Failed to fetch session messages')
+        discordClient.destroy()
+        process.exit(EXIT_NO_RESTART)
+      }
+
+      const messages = messagesResponse.data
+
+      await thread.send(
+        `📂 **Resumed session:** ${session.title}\n📅 **Created:** ${new Date(session.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`,
+      )
+
+      let messageCount = 0
+      for (const message of messages) {
+        if (message.info.role === 'user') {
+          const userParts = message.parts.filter(
+            (p) => p.type === 'text' && !p.synthetic,
+          )
+          const userTexts = userParts
+            .map((p) => {
+              if (p.type === 'text') {
+                return p.text
+              }
+              return ''
+            })
+            .filter((t) => t.trim())
+
+          const userText = userTexts.join('\n\n')
+          if (userText) {
+            const truncated = userText.length > 1900 ? userText.slice(0, 1900) + '…' : userText
+            await thread.send(`**User:**\n${truncated}`)
+          }
+        } else if (message.info.role === 'assistant') {
+          const textParts = message.parts.filter((p) => p.type === 'text')
+          const texts = textParts
+            .map((p) => {
+              if (p.type === 'text') {
+                return p.text
+              }
+              return ''
+            })
+            .filter((t) => t?.trim())
+
+          if (texts.length > 0) {
+            const combinedText = texts.join('\n\n')
+            const truncated = combinedText.length > 1900 ? combinedText.slice(0, 1900) + '…' : combinedText
+            await thread.send(truncated)
+          }
+        }
+        messageCount++
+      }
+
+      await thread.send(
+        `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`,
+      )
+
+      s.stop(`Loaded ${messageCount} messages`)
+
+      const guildId = textChannel.guildId
+      const threadUrl = `https://discord.com/channels/${guildId}/${thread.id}`
+
+      note(
+        `Session "${session.title}" has been sent to Discord!\n\nThread: ${threadUrl}`,
+        '✅ Success',
+      )
+
+      discordClient.destroy()
+      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 plugin for /send-to-kimaki-discord command')
+  .action(async () => {
+    try {
+      const require = createRequire(import.meta.url)
+      const pluginSrc = require.resolve('./opencode-plugin.ts')
+      const commandSrc = require.resolve('./opencode-command.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',
+      )
+
+      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/discordBot.ts

@@ -4,6 +4,7 @@ import {
   type Part,
   type Config,
   type FilePartInput,
+  type Permission,
 } from '@opencode-ai/sdk'
 
 import { createGenAIWorker, type GenAIWorker } from './genai-worker-wrapper.js'
@@ -90,6 +91,12 @@ const voiceConnections = new Map<
 // Map of directory to retry count for server restarts
 const serverRetryCount = new Map<string, number>()
 
+// Map of thread ID to pending permission (only one pending permission per thread)
+const pendingPermissions = new Map<
+  string,
+  { permission: Permission; messageId: string; directory: string }
+>()
+
 let db: Database.Database | null = null
 
 function convertToMono16k(buffer: Buffer): Buffer {
@@ -1547,6 +1554,51 @@ async function handleOpencodeSession({
             )
           }
           break
+        } else if (event.type === 'permission.updated') {
+          const permission = event.properties
+          if (permission.sessionID !== session.id) {
+            voiceLogger.log(
+              `[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`,
+            )
+            continue
+          }
+
+          sessionLogger.log(
+            `Permission requested: type=${permission.type}, title=${permission.title}`,
+          )
+
+          const patternStr = Array.isArray(permission.pattern)
+            ? permission.pattern.join(', ')
+            : permission.pattern || ''
+
+          const permissionMessage = await sendThreadMessage(
+            thread,
+            `⚠️ **Permission Required**\n\n` +
+              `**Type:** \`${permission.type}\`\n` +
+              `**Action:** ${permission.title}\n` +
+              (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+              `\nUse \`/accept\` or \`/reject\` to respond.`,
+          )
+
+          pendingPermissions.set(thread.id, {
+            permission,
+            messageId: permissionMessage.id,
+            directory,
+          })
+        } else if (event.type === 'permission.replied') {
+          const { permissionID, response, sessionID } = event.properties
+          if (sessionID !== session.id) {
+            continue
+          }
+
+          sessionLogger.log(
+            `Permission ${permissionID} replied with: ${response}`,
+          )
+
+          const pending = pendingPermissions.get(thread.id)
+          if (pending && pending.permission.id === permissionID) {
+            pendingPermissions.delete(thread.id)
+          }
         } else if (event.type === 'file.edited') {
           sessionLogger.log(`File edited event received`)
         } else {
@@ -2599,6 +2651,128 @@ export async function startDiscordBot({
                 `Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`,
               )
             }
+          } else if (
+            command.commandName === 'accept' ||
+            command.commandName === 'accept-always'
+          ) {
+            const scope = command.commandName === 'accept-always' ? 'always' : 'once'
+            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 pending = pendingPermissions.get(channel.id)
+            if (!pending) {
+              await command.reply({
+                content: 'No pending permission request in this thread',
+                ephemeral: true,
+              })
+              return
+            }
+
+            try {
+              const getClient = await initializeOpencodeForDirectory(pending.directory)
+              await getClient().postSessionIdPermissionsPermissionId({
+                path: {
+                  id: pending.permission.sessionID,
+                  permissionID: pending.permission.id,
+                },
+                body: {
+                  response: scope,
+                },
+              })
+
+              pendingPermissions.delete(channel.id)
+              const msg =
+                scope === 'always'
+                  ? `✅ Permission **accepted** (auto-approve similar requests)`
+                  : `✅ Permission **accepted**`
+              await command.reply(msg)
+              sessionLogger.log(
+                `Permission ${pending.permission.id} accepted with scope: ${scope}`,
+              )
+            } catch (error) {
+              voiceLogger.error('[ACCEPT] Error:', error)
+              await command.reply({
+                content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ephemeral: true,
+              })
+            }
+          } else if (command.commandName === 'reject') {
+            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 pending = pendingPermissions.get(channel.id)
+            if (!pending) {
+              await command.reply({
+                content: 'No pending permission request in this thread',
+                ephemeral: true,
+              })
+              return
+            }
+
+            try {
+              const getClient = await initializeOpencodeForDirectory(pending.directory)
+              await getClient().postSessionIdPermissionsPermissionId({
+                path: {
+                  id: pending.permission.sessionID,
+                  permissionID: pending.permission.id,
+                },
+                body: {
+                  response: 'reject',
+                },
+              })
+
+              pendingPermissions.delete(channel.id)
+              await command.reply(`❌ Permission **rejected**`)
+              sessionLogger.log(`Permission ${pending.permission.id} rejected`)
+            } catch (error) {
+              voiceLogger.error('[REJECT] Error:', error)
+              await command.reply({
+                content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ephemeral: true,
+              })
+            }
           }
         }
       } catch (error) {

package/src/opencode-command.md

@@ -0,0 +1,4 @@
+---
+description: Send current session to Kimaki Discord
+---
+say "Session sent to discord!"

package/src/opencode-plugin.ts

@@ -0,0 +1,71 @@
+/**
+ * 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
+      }
+
+      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',
+          },
+        })
+      }
+    },
+  }
+}