kimaki 0.4.25 → 0.4.26

package/src/channel-management.ts

@@ -12,14 +12,19 @@ import path from 'node:path'
 import { getDatabase } from './database.js'
 import { extractTagsArrays } from './xml.js'
 
-export async function ensureKimakiCategory(guild: Guild): Promise<CategoryChannel> {
+export async function ensureKimakiCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  const categoryName = botName ? `Kimaki ${botName}` : 'Kimaki'
+
   const existingCategory = guild.channels.cache.find(
     (channel): channel is CategoryChannel => {
       if (channel.type !== ChannelType.GuildCategory) {
         return false
       }
 
-      return channel.name.toLowerCase() === 'kimaki'
+      return channel.name.toLowerCase() === categoryName.toLowerCase()
     },
   )
 
@@ -28,19 +33,24 @@ export async function ensureKimakiCategory(guild: Guild): Promise<CategoryChanne
   }
 
   return guild.channels.create({
-    name: 'Kimaki',
+    name: categoryName,
     type: ChannelType.GuildCategory,
   })
 }
 
-export async function ensureKimakiAudioCategory(guild: Guild): Promise<CategoryChannel> {
+export async function ensureKimakiAudioCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  const categoryName = botName ? `Kimaki Audio ${botName}` : 'Kimaki Audio'
+
   const existingCategory = guild.channels.cache.find(
     (channel): channel is CategoryChannel => {
       if (channel.type !== ChannelType.GuildCategory) {
         return false
       }
 
-      return channel.name.toLowerCase() === 'kimaki audio'
+      return channel.name.toLowerCase() === categoryName.toLowerCase()
     },
   )
 
@@ -49,7 +59,7 @@ export async function ensureKimakiAudioCategory(guild: Guild): Promise<CategoryC
   }
 
   return guild.channels.create({
-    name: 'Kimaki Audio',
+    name: categoryName,
     type: ChannelType.GuildCategory,
   })
 }
@@ -58,10 +68,12 @@ export async function createProjectChannels({
   guild,
   projectDirectory,
   appId,
+  botName,
 }: {
   guild: Guild
   projectDirectory: string
   appId: string
+  botName?: string
 }): Promise<{ textChannelId: string; voiceChannelId: string; channelName: string }> {
   const baseName = path.basename(projectDirectory)
   const channelName = `${baseName}`
@@ -69,8 +81,8 @@ export async function createProjectChannels({
     .replace(/[^a-z0-9-]/g, '-')
     .slice(0, 100)
 
-  const kimakiCategory = await ensureKimakiCategory(guild)
-  const kimakiAudioCategory = await ensureKimakiAudioCategory(guild)
+  const kimakiCategory = await ensureKimakiCategory(guild, botName)
+  const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName)
 
   const textChannel = await guild.channels.create({
     name: channelName,

package/src/cli.ts

@@ -27,7 +27,7 @@ import {
   createProjectChannels,
   type ChannelWithTags,
 } from './discord-bot.js'
-import type { OpencodeClient } from '@opencode-ai/sdk'
+import type { OpencodeClient, Command as OpencodeCommand } from '@opencode-ai/sdk'
 import {
   Events,
   ChannelType,
@@ -82,13 +82,14 @@ async function killProcessOnPort(port: number): Promise<boolean> {
       // Filter out our own PID and take the first (oldest)
       const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid)
       if (targetPid) {
-        cliLogger.log(`Killing existing kimaki process (PID: ${targetPid})`)
-        process.kill(parseInt(targetPid, 10), 'SIGKILL')
+        const pid = parseInt(targetPid, 10)
+        cliLogger.log(`Stopping existing kimaki process (PID: ${pid})`)
+        process.kill(pid, 'SIGKILL')
         return true
       }
     }
-  } catch {
-    // Failed to kill, continue anyway
+  } catch (e) {
+    cliLogger.debug(`Failed to kill process on port ${port}:`, e)
   }
   return false
 }
@@ -105,7 +106,7 @@ async function checkSingleInstance(): Promise<void> {
       await new Promise((resolve) => { setTimeout(resolve, 500) })
     }
   } catch {
-    // Connection refused means no instance running, continue
+    cliLogger.debug('No other kimaki instance detected on lock port')
   }
 }
 
@@ -152,7 +153,10 @@ type CliOptions = {
   addChannels?: boolean
 }
 
-async function registerCommands(token: string, appId: string) {
+// Commands to skip when registering user commands (reserved names)
+const SKIP_USER_COMMANDS = ['init']
+
+async function registerCommands(token: string, appId: string, userCommands: OpencodeCommand[] = []) {
   const commands = [
     new SlashCommandBuilder()
       .setName('resume')
@@ -231,6 +235,10 @@ async function registerCommands(token: string, appId: string) {
       .setName('abort')
       .setDescription('Abort the current OpenCode request in this thread')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('stop')
+      .setDescription('Abort the current OpenCode request in this thread')
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('share')
       .setDescription('Share the current session as a public URL')
@@ -243,6 +251,10 @@ async function registerCommands(token: string, appId: string) {
       .setName('model')
       .setDescription('Set the preferred model for this channel or session')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('agent')
+      .setDescription('Set the preferred agent for this channel or session')
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('queue')
       .setDescription('Queue a message to be sent after the current response finishes')
@@ -269,6 +281,30 @@ async function registerCommands(token: string, appId: string) {
       .toJSON(),
   ]
 
+  // Add user-defined commands with -cmd suffix
+  for (const cmd of userCommands) {
+    if (SKIP_USER_COMMANDS.includes(cmd.name)) {
+      continue
+    }
+
+    const commandName = `${cmd.name}-cmd`
+    const description = cmd.description || `Run /${cmd.name} command`
+
+    commands.push(
+      new SlashCommandBuilder()
+        .setName(commandName)
+        .setDescription(description.slice(0, 100)) // Discord limits to 100 chars
+        .addStringOption((option) => {
+          option
+            .setName('arguments')
+            .setDescription('Arguments to pass to the command')
+            .setRequired(false)
+          return option
+        })
+        .toJSON(),
+    )
+  }
+
   const rest = new REST().setToken(token)
 
   try {
@@ -686,6 +722,7 @@ async function run({ restart, addChannels }: CliOptions) {
             guild: targetGuild,
             projectDirectory: project.worktree,
             appId,
+            botName: discordClient.user?.username,
           })
 
           createdChannels.push({
@@ -709,8 +746,37 @@ async function run({ restart, addChannels }: CliOptions) {
     }
   }
 
+  // Fetch user-defined commands using the already-running server
+  const allUserCommands: OpencodeCommand[] = []
+  try {
+    const commandsResponse = await getClient().command.list({
+      query: { directory: currentDir },
+    })
+    if (commandsResponse.data) {
+      allUserCommands.push(...commandsResponse.data)
+    }
+  } catch {
+    // Ignore errors fetching commands
+  }
+
+  // Log available user commands
+  const registrableCommands = allUserCommands.filter(
+    (cmd) => !SKIP_USER_COMMANDS.includes(cmd.name),
+  )
+
+  if (registrableCommands.length > 0) {
+    const commandList = registrableCommands
+      .map((cmd) => `  /${cmd.name}-cmd - ${cmd.description || 'No description'}`)
+      .join('\n')
+
+    note(
+      `Found ${registrableCommands.length} user-defined command(s):\n${commandList}`,
+      'OpenCode Commands',
+    )
+  }
+
   cliLogger.log('Registering slash commands asynchronously...')
-  void registerCommands(token, appId)
+  void registerCommands(token, appId, allUserCommands)
     .then(() => {
       cliLogger.log('Slash commands registered!')
     })

package/src/commands/add-project.ts

@@ -67,6 +67,7 @@ export async function handleAddProjectCommand({
         guild,
         projectDirectory: directory,
         appId,
+        botName: command.client.user?.username,
       })
 
     await command.editReply(

package/src/commands/agent.ts

@@ -0,0 +1,201 @@
+// /agent command - Set the preferred agent for this channel or session.
+
+import {
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+  StringSelectMenuBuilder,
+  ActionRowBuilder,
+  ChannelType,
+  type ThreadChannel,
+  type TextChannel,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import { getDatabase, setChannelAgent, setSessionAgent, runModelMigrations } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const agentLogger = createLogger('AGENT')
+
+const pendingAgentContexts = new Map<string, {
+  dir: string
+  channelId: string
+  sessionId?: string
+  isThread: boolean
+}>()
+
+export async function handleAgentCommand({
+  interaction,
+  appId,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  await interaction.deferReply({ ephemeral: true })
+
+  runModelMigrations()
+
+  const channel = interaction.channel
+
+  if (!channel) {
+    await interaction.editReply({ content: 'This command can only be used in a channel' })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+  let targetChannelId: string
+  let sessionId: string | undefined
+
+  if (isThread) {
+    const thread = channel as ThreadChannel
+    const textChannel = await resolveTextChannel(thread)
+    const metadata = getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = textChannel?.id || channel.id
+
+    const row = getDatabase()
+      .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+      .get(thread.id) as { session_id: string } | undefined
+    sessionId = row?.session_id
+  } else if (channel.type === ChannelType.GuildText) {
+    const textChannel = channel as TextChannel
+    const metadata = getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = channel.id
+  } else {
+    await interaction.editReply({ content: 'This command can only be used in text channels or threads' })
+    return
+  }
+
+  if (channelAppId && channelAppId !== appId) {
+    await interaction.editReply({ content: 'This channel is not configured for this bot' })
+    return
+  }
+
+  if (!projectDirectory) {
+    await interaction.editReply({ content: 'This channel is not configured with a project directory' })
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+
+    const agentsResponse = await getClient().app.agents({
+      query: { directory: projectDirectory },
+    })
+
+    if (!agentsResponse.data || agentsResponse.data.length === 0) {
+      await interaction.editReply({ content: 'No agents available' })
+      return
+    }
+
+    const agents = agentsResponse.data
+      .filter((a) => a.mode === 'primary' || a.mode === 'all')
+      .slice(0, 25)
+
+    if (agents.length === 0) {
+      await interaction.editReply({ content: 'No primary agents available' })
+      return
+    }
+
+    const contextHash = crypto.randomBytes(8).toString('hex')
+    pendingAgentContexts.set(contextHash, {
+      dir: projectDirectory,
+      channelId: targetChannelId,
+      sessionId,
+      isThread,
+    })
+
+    const options = agents.map((agent) => ({
+      label: agent.name.slice(0, 100),
+      value: agent.name,
+      description: (agent.description || `${agent.mode} agent`).slice(0, 100),
+    }))
+
+    const selectMenu = new StringSelectMenuBuilder()
+      .setCustomId(`agent_select:${contextHash}`)
+      .setPlaceholder('Select an agent')
+      .addOptions(options)
+
+    const actionRow = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+    await interaction.editReply({
+      content: '**Set Agent Preference**\nSelect an agent:',
+      components: [actionRow],
+    })
+  } catch (error) {
+    agentLogger.error('Error loading agents:', error)
+    await interaction.editReply({
+      content: `Failed to load agents: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}
+
+export async function handleAgentSelectMenu(
+  interaction: StringSelectMenuInteraction
+): Promise<void> {
+  const customId = interaction.customId
+
+  if (!customId.startsWith('agent_select:')) {
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const contextHash = customId.replace('agent_select:', '')
+  const context = pendingAgentContexts.get(contextHash)
+
+  if (!context) {
+    await interaction.editReply({
+      content: 'Selection expired. Please run /agent again.',
+      components: [],
+    })
+    return
+  }
+
+  const selectedAgent = interaction.values[0]
+  if (!selectedAgent) {
+    await interaction.editReply({
+      content: 'No agent selected',
+      components: [],
+    })
+    return
+  }
+
+  try {
+    if (context.isThread && context.sessionId) {
+      setSessionAgent(context.sessionId, selectedAgent)
+      agentLogger.log(`Set agent ${selectedAgent} for session ${context.sessionId}`)
+
+      await interaction.editReply({
+        content: `Agent preference set for this session: **${selectedAgent}**`,
+        components: [],
+      })
+    } else {
+      setChannelAgent(context.channelId, selectedAgent)
+      agentLogger.log(`Set agent ${selectedAgent} for channel ${context.channelId}`)
+
+      await interaction.editReply({
+        content: `Agent preference set for this channel: **${selectedAgent}**\n\nAll new sessions in this channel will use this agent.`,
+        components: [],
+      })
+    }
+
+    pendingAgentContexts.delete(contextHash)
+  } catch (error) {
+    agentLogger.error('Error saving agent preference:', error)
+    await interaction.editReply({
+      content: `Failed to save agent preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      components: [],
+    })
+  }
+}