kimaki 0.4.6 → 0.4.7

package/dist/cli.js

@@ -70,6 +70,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 {

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/package.json

@@ -2,7 +2,17 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.6",
+  "version": "0.4.7",
+  "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": [
@@ -43,14 +53,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

@@ -126,6 +126,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)

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) {