@brianli/kimaki 0.4.72-brianli.1

package/src/commands/permissions.ts

@@ -0,0 +1,261 @@
+// Permission button handler - Shows buttons for permission requests.
+// When OpenCode asks for permission, this module renders 3 buttons:
+// Accept, Accept Always, and Deny.
+
+import {
+  ButtonBuilder,
+  ButtonStyle,
+  type ButtonInteraction,
+  ActionRowBuilder,
+  type ThreadChannel,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import type { PermissionRequest } from '@opencode-ai/sdk/v2'
+import { getOpencodeClient } from '../opencode.js'
+import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.PERMISSIONS)
+
+function wildcardMatch({
+  value,
+  pattern,
+}: {
+  value: string
+  pattern: string
+}): boolean {
+  let escapedPattern = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '.*')
+    .replace(/\?/g, '.')
+
+  if (escapedPattern.endsWith(' .*')) {
+    escapedPattern = escapedPattern.slice(0, -3) + '( .*)?'
+  }
+
+  return new RegExp(`^${escapedPattern}$`, 's').test(value)
+}
+
+export function arePatternsCoveredBy({
+  patterns,
+  coveringPatterns,
+}: {
+  patterns: string[]
+  coveringPatterns: string[]
+}): boolean {
+  return patterns.every((pattern) => {
+    return coveringPatterns.some((coveringPattern) => {
+      return wildcardMatch({ value: pattern, pattern: coveringPattern })
+    })
+  })
+}
+
+export function compactPermissionPatterns(patterns: string[]): string[] {
+  const uniquePatterns = Array.from(new Set(patterns))
+  return uniquePatterns.filter((pattern, index) => {
+    return !uniquePatterns.some((candidate, candidateIndex) => {
+      if (candidateIndex === index) {
+        return false
+      }
+      return wildcardMatch({ value: pattern, pattern: candidate })
+    })
+  })
+}
+
+type PendingPermissionContext = {
+  permission: PermissionRequest
+  requestIds: string[]
+  directory: string
+  permissionDirectory: string
+  thread: ThreadChannel
+  contextHash: string
+}
+
+// Store pending permission contexts by hash
+export const pendingPermissionContexts = new Map<
+  string,
+  PendingPermissionContext
+>()
+
+/**
+ * Show permission buttons for a permission request.
+ * Displays 3 buttons in a row: Accept, Accept Always, Deny.
+ * Returns the message ID and context hash for tracking.
+ */
+export async function showPermissionButtons({
+  thread,
+  permission,
+  directory,
+  permissionDirectory,
+  subtaskLabel,
+}: {
+  thread: ThreadChannel
+  permission: PermissionRequest
+  directory: string
+  permissionDirectory: string
+  subtaskLabel?: string
+}): Promise<{ messageId: string; contextHash: string }> {
+  const contextHash = crypto.randomBytes(8).toString('hex')
+
+  const context: PendingPermissionContext = {
+    permission,
+    requestIds: [permission.id],
+    directory,
+    permissionDirectory,
+    thread,
+    contextHash,
+  }
+
+  pendingPermissionContexts.set(contextHash, context)
+
+  const patternStr = compactPermissionPatterns(permission.patterns).join(', ')
+
+  // Build 3 buttons for permission actions
+  const acceptButton = new ButtonBuilder()
+    .setCustomId(`permission_once:${contextHash}`)
+    .setLabel('Accept')
+    .setStyle(ButtonStyle.Success)
+
+  const acceptAlwaysButton = new ButtonBuilder()
+    .setCustomId(`permission_always:${contextHash}`)
+    .setLabel('Accept Always')
+    .setStyle(ButtonStyle.Success)
+
+  const denyButton = new ButtonBuilder()
+    .setCustomId(`permission_reject:${contextHash}`)
+    .setLabel('Deny')
+    .setStyle(ButtonStyle.Secondary)
+
+  const actionRow = new ActionRowBuilder<ButtonBuilder>().addComponents(
+    acceptButton,
+    acceptAlwaysButton,
+    denyButton,
+  )
+
+  const subtaskLine = subtaskLabel ? `**From:** \`${subtaskLabel}\`\n` : ''
+  const fullContent =
+    `⚠️ **Permission Required**\n` +
+    subtaskLine +
+    `**Type:** \`${permission.permission}\`\n` +
+    (patternStr ? `**Pattern:** \`${patternStr}\`` : '')
+  const permissionMessage = await thread.send({
+    content: fullContent.slice(0, 1900),
+    components: [actionRow],
+    flags: NOTIFY_MESSAGE_FLAGS,
+  })
+
+  logger.log(`Showed permission buttons for ${permission.id}`)
+
+  return { messageId: permissionMessage.id, contextHash }
+}
+
+/**
+ * Handle button click for permission.
+ */
+export async function handlePermissionButton(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+
+  // Extract action and hash from customId (e.g., "permission_once:abc123")
+  const [actionPart, contextHash] = customId.split(':')
+  if (!actionPart || !contextHash) {
+    return
+  }
+
+  const response = actionPart.replace('permission_', '') as
+    | 'once'
+    | 'always'
+    | 'reject'
+
+  const context = pendingPermissionContexts.get(contextHash)
+
+  if (!context) {
+    await interaction.update({ components: [] })
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  try {
+    const permClient = getOpencodeClient(context.directory)
+    if (!permClient) {
+      throw new Error('OpenCode server not found for directory')
+    }
+    const requestIds =
+      context.requestIds.length > 0
+        ? context.requestIds
+        : [context.permission.id]
+    await Promise.all(
+      requestIds.map((requestId) => {
+        return permClient.permission.reply({
+          requestID: requestId,
+          directory: context.permissionDirectory,
+          reply: response,
+        })
+      }),
+    )
+
+    pendingPermissionContexts.delete(contextHash)
+
+    // Update message: show result and remove dropdown
+    const resultText = (() => {
+      switch (response) {
+        case 'once':
+          return '✅ Permission **accepted**'
+        case 'always':
+          return '✅ Permission **accepted** (auto-approve similar requests)'
+        case 'reject':
+          return '❌ Permission **rejected**'
+      }
+    })()
+
+    const patternStr = compactPermissionPatterns(
+      context.permission.patterns,
+    ).join(', ')
+    await interaction.editReply({
+      content:
+        `⚠️ **Permission Required**\n` +
+        `**Type:** \`${context.permission.permission}\`\n` +
+        (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+        resultText,
+      components: [], // Remove the buttons
+    })
+
+    logger.log(
+      `Permission ${context.permission.id} ${response} (${requestIds.length} request(s))`,
+    )
+  } catch (error) {
+    logger.error('Error handling permission:', error)
+    await interaction.editReply({
+      content: `Failed to process permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      components: [],
+    })
+  }
+}
+
+export function addPermissionRequestToContext({
+  contextHash,
+  requestId,
+}: {
+  contextHash: string
+  requestId: string
+}): boolean {
+  const context = pendingPermissionContexts.get(contextHash)
+  if (!context) {
+    return false
+  }
+  if (context.requestIds.includes(requestId)) {
+    return false
+  }
+  context.requestIds = [...context.requestIds, requestId]
+  pendingPermissionContexts.set(contextHash, context)
+  return true
+}
+
+/**
+ * Clean up a pending permission context (e.g., on auto-reject).
+ */
+export function cleanupPermissionContext(contextHash: string): void {
+  pendingPermissionContexts.delete(contextHash)
+}

package/src/commands/queue.ts

@@ -0,0 +1,296 @@
+// Queue commands - /queue, /queue-command, /clear-queue
+
+import { ChannelType, MessageFlags, type ThreadChannel } from 'discord.js'
+import type { AutocompleteContext, CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import {
+  resolveWorkingDirectory,
+  sendThreadMessage,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import {
+  handleOpencodeSession,
+  abortControllers,
+  addToQueue,
+  getQueueLength,
+  clearQueue,
+  queueOrSendMessage,
+} from '../session-handler.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { notifyError } from '../sentry.js'
+import { registeredUserCommands } from '../config.js'
+
+const logger = createLogger(LogPrefix.QUEUE)
+
+export async function handleQueueCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  const message = command.options.getString('message', true)
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    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',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const result = await queueOrSendMessage({
+    thread: channel as ThreadChannel,
+    prompt: message,
+    userId: command.user.id,
+    username: command.user.displayName,
+    appId,
+  })
+
+  if (result.action === 'no-session') {
+    await command.reply({
+      content:
+        'No active session in this thread. Send a message directly instead.',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  if (result.action === 'no-directory') {
+    await command.reply({
+      content: 'Could not determine project directory',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  if (result.action === 'sent') {
+    await command.reply({
+      content: `» **${command.user.displayName}:** ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  await command.reply({
+    content: `Message queued (position: ${result.position}). Will be sent after current response.`,
+    flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+  })
+}
+
+export async function handleClearQueueCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    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',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const queueLength = getQueueLength(channel.id)
+
+  if (queueLength === 0) {
+    await command.reply({
+      content: 'No messages in queue',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  clearQueue(channel.id)
+
+  await command.reply({
+    content: `🗑 Cleared ${queueLength} queued message${queueLength > 1 ? 's' : ''}`,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+
+  logger.log(
+    `[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`,
+  )
+}
+
+export async function handleQueueCommandCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  const commandName = command.options.getString('command', true)
+  const args = command.options.getString('arguments') || ''
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    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',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.reply({
+      content:
+        'No active session in this thread. Send a message directly instead.',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Validate command exists in registered user commands
+  const isKnownCommand = registeredUserCommands.some((cmd) => {
+    return cmd.name === commandName
+  })
+  if (!isKnownCommand) {
+    await command.reply({
+      content: `Unknown command: /${commandName}. Use autocomplete to pick from available commands.`,
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const commandPayload = { name: commandName, arguments: args }
+  const displayText = `/${commandName}`
+
+  // Check if there's an active request running
+  const existingController = abortControllers.get(sessionId)
+  const hasActiveRequest = Boolean(
+    existingController && !existingController.signal.aborted,
+  )
+  if (existingController && existingController.signal.aborted) {
+    abortControllers.delete(sessionId)
+  }
+
+  if (!hasActiveRequest) {
+    const resolved = await resolveWorkingDirectory({
+      channel: channel as ThreadChannel,
+    })
+
+    if (!resolved) {
+      await command.reply({
+        content: 'Could not determine project directory',
+        flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+      })
+      return
+    }
+
+    await command.reply({
+      content: `» **${command.user.displayName}:** ${displayText}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    logger.log(
+      `[QUEUE] No active request, sending command immediately in thread ${channel.id}`,
+    )
+
+    handleOpencodeSession({
+      prompt: '',
+      thread: channel as ThreadChannel,
+      projectDirectory: resolved.projectDirectory,
+      channelId: (channel as ThreadChannel).parentId || channel.id,
+      command: commandPayload,
+      appId,
+    }).catch(async (e) => {
+      logger.error(`[QUEUE] Failed to send command:`, e)
+      void notifyError(e, 'Queue: failed to send command')
+      const errorMsg = e instanceof Error ? e.message : String(e)
+      await sendThreadMessage(
+        channel as ThreadChannel,
+        `Failed: ${errorMsg.slice(0, 200)}`,
+      )
+    })
+
+    return
+  }
+
+  // Add to queue with command payload
+  const queuePosition = addToQueue({
+    threadId: channel.id,
+    message: {
+      prompt: '',
+      userId: command.user.id,
+      username: command.user.displayName,
+      queuedAt: Date.now(),
+      appId,
+      command: commandPayload,
+    },
+  })
+
+  await command.reply({
+    content: `Command queued (position: ${queuePosition}): ${displayText}`,
+    flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+  })
+
+  logger.log(
+    `[QUEUE] User ${command.user.displayName} queued command /${commandName} in thread ${channel.id}`,
+  )
+}
+
+export async function handleQueueCommandAutocomplete({
+  interaction,
+}: AutocompleteContext): Promise<void> {
+  const focused = interaction.options.getFocused(true)
+
+  if (focused.name !== 'command') {
+    await interaction.respond([])
+    return
+  }
+
+  const query = focused.value.toLowerCase()
+  const choices = registeredUserCommands
+    .filter((cmd) => {
+      return cmd.name.toLowerCase().includes(query)
+    })
+    .slice(0, 25)
+    .map((cmd) => ({
+      name: `/${cmd.name} - ${cmd.description}`.slice(0, 100),
+      value: cmd.name.slice(0, 100),
+    }))
+
+  await interaction.respond(choices)
+}

package/src/commands/remove-project.ts

@@ -0,0 +1,155 @@
+// /remove-project command - Remove Discord channels for a project.
+
+import path from 'node:path'
+import * as errore from 'errore'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import {
+  findChannelsByDirectory,
+  deleteChannelDirectoriesByDirectory,
+  getAllTextChannelDirectories,
+} from '../database.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { abbreviatePath } from '../utils.js'
+
+const logger = createLogger(LogPrefix.REMOVE_PROJECT)
+
+export async function handleRemoveProjectCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const directory = command.options.getString('project', true)
+  const guild = command.guild
+
+  if (!guild) {
+    await command.editReply('This command can only be used in a guild')
+    return
+  }
+
+  try {
+    // Get channel IDs for this directory
+    const channels = await findChannelsByDirectory({ directory })
+
+    if (channels.length === 0) {
+      await command.editReply(
+        `No channels found for directory: \`${directory}\``,
+      )
+      return
+    }
+
+    const deletedChannels: string[] = []
+    const failedChannels: string[] = []
+
+    for (const { channel_id, channel_type } of channels as Array<{
+      channel_id: string
+      channel_type: string
+    }>) {
+      const channel = await errore.tryAsync({
+        try: () => guild.channels.fetch(channel_id),
+        catch: (e) => e as Error,
+      })
+
+      if (channel instanceof Error) {
+        logger.error(`Failed to fetch channel ${channel_id}:`, channel)
+        failedChannels.push(`${channel_type}: ${channel_id}`)
+        continue
+      }
+
+      if (channel) {
+        try {
+          await channel.delete(`Removed by /remove-project command`)
+          deletedChannels.push(`${channel_type}: ${channel_id}`)
+        } catch (error) {
+          logger.error(`Failed to delete channel ${channel_id}:`, error)
+          failedChannels.push(`${channel_type}: ${channel_id}`)
+        }
+      } else {
+        deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`)
+      }
+    }
+
+    // Remove from database
+    await deleteChannelDirectoriesByDirectory(directory)
+
+    const projectName = path.basename(directory)
+    let message = `Removed project **${projectName}**\n`
+    message += `Directory: \`${directory}\`\n\n`
+
+    if (deletedChannels.length > 0) {
+      message += `Deleted channels:\n${deletedChannels.map((c) => `- ${c}`).join('\n')}`
+    }
+
+    if (failedChannels.length > 0) {
+      message += `\n\nFailed to delete (may be in another server):\n${failedChannels.map((c) => `- ${c}`).join('\n')}`
+    }
+
+    await command.editReply(message)
+    logger.log(`Removed project ${projectName} at ${directory}`)
+  } catch (error) {
+    logger.error('[REMOVE-PROJECT] Error:', error)
+    await command.editReply(
+      `Failed to remove project: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleRemoveProjectAutocomplete({
+  interaction,
+  appId,
+}: AutocompleteContext): Promise<void> {
+  const focusedValue = interaction.options.getFocused()
+  const guild = interaction.guild
+
+  if (!guild) {
+    await interaction.respond([])
+    return
+  }
+
+  try {
+    // Get all directories with channels
+    const allChannels = (await findChannelsByDirectory({
+      channelType: 'text',
+    })) as Array<{
+      directory: string
+      channel_id: string
+    }>
+
+    // Filter to only channels that exist in this guild
+    const projectsInGuild: { directory: string; channelId: string }[] = []
+
+    for (const { directory, channel_id } of allChannels) {
+      const channel = await errore.tryAsync({
+        try: () => guild.channels.fetch(channel_id),
+        catch: (e) => e as Error,
+      })
+      if (channel instanceof Error) {
+        // Channel not in this guild, skip
+        continue
+      }
+      if (channel) {
+        projectsInGuild.push({ directory, channelId: channel_id })
+      }
+    }
+
+    const projects = projectsInGuild
+      .filter(({ directory }) => {
+        const baseName = path.basename(directory)
+        const searchText = `${baseName} ${directory}`.toLowerCase()
+        return searchText.includes(focusedValue.toLowerCase())
+      })
+      .slice(0, 25)
+      .map(({ directory }) => {
+        const name = `${path.basename(directory)} (${abbreviatePath(directory)})`
+        return {
+          name: name.length > 100 ? name.slice(0, 99) + '...' : name,
+          value: directory,
+        }
+      })
+
+    await interaction.respond(projects)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching projects:', error)
+    await interaction.respond([])
+  }
+}