@otto-assistant/bridge 0.4.92

package/src/commands/abort.ts

@@ -0,0 +1,89 @@
+// /abort command - Abort the current OpenCode request in this thread.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { getRuntime } from '../session-handler/thread-session-runtime.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.ABORT)
+
+export async function handleAbortCommand({
+  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 with an active session',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+
+  if (!resolved) {
+    await command.editReply('Could not determine project directory for this channel')
+    return
+  }
+
+  const { projectDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.editReply('No active session in this thread')
+    return
+  }
+
+  // abortActiveRun delegates to session.abort(), run settlement stays event-driven.
+  const runtime = getRuntime(channel.id)
+  if (runtime) {
+    runtime.abortActiveRun('user-requested')
+  } else {
+    // No runtime but session exists — fall back to direct API abort
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await command.editReply(`Failed to abort: ${getClient.message}`)
+      return
+    }
+    try {
+      await getClient().session.abort({ sessionID: sessionId })
+    } catch (error) {
+      logger.error('[ABORT] API abort failed:', error)
+    }
+  }
+
+  await command.editReply('Request **aborted**')
+  logger.log(`Session ${sessionId} aborted by user`)
+}

package/src/commands/action-buttons.ts

@@ -0,0 +1,364 @@
+// Action button tool handler - Shows Discord buttons for quick model actions.
+// Used by the kimaki_action_buttons tool to render up to 3 buttons and route
+// button clicks back into the session as a new user message.
+
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  MessageFlags,
+  type ButtonInteraction,
+  type ThreadChannel,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import { getThreadSession } from '../database.js'
+import {
+  NOTIFY_MESSAGE_FLAGS,
+  SILENT_MESSAGE_FLAGS,
+  resolveWorkingDirectory,
+  sendThreadMessage,
+} from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+import { notifyError } from '../sentry.js'
+import {
+  getOrCreateRuntime,
+} from '../session-handler/thread-session-runtime.js'
+
+const logger = createLogger('ACT_BTN')
+const PENDING_TTL_MS = 24 * 60 * 60 * 1000
+
+export type ActionButtonColor = 'white' | 'blue' | 'green' | 'red'
+
+export type ActionButtonOption = {
+  label: string
+  color?: ActionButtonColor
+}
+
+export type ActionButtonsRequest = {
+  sessionId: string
+  threadId: string
+  directory: string
+  buttons: ActionButtonOption[]
+}
+
+type PendingActionButtonsContext = {
+  sessionId: string
+  directory: string
+  thread: ThreadChannel
+  buttons: ActionButtonOption[]
+  contextHash: string
+  messageId?: string
+  resolved: boolean
+  timer: ReturnType<typeof setTimeout>
+}
+
+export const pendingActionButtonContexts = new Map<
+  string,
+  PendingActionButtonsContext
+>()
+const pendingActionButtonRequests = new Map<string, ActionButtonsRequest>()
+const pendingActionButtonRequestWaiters = new Map<
+  string,
+  (request: ActionButtonsRequest) => void
+>()
+
+export function queueActionButtonsRequest(request: ActionButtonsRequest): void {
+  pendingActionButtonRequests.set(request.sessionId, request)
+  const waiter = pendingActionButtonRequestWaiters.get(request.sessionId)
+  if (!waiter) {
+    return
+  }
+  pendingActionButtonRequestWaiters.delete(request.sessionId)
+  waiter(request)
+}
+
+export async function waitForQueuedActionButtonsRequest({
+  sessionId,
+  timeoutMs,
+}: {
+  sessionId: string
+  timeoutMs: number
+}): Promise<ActionButtonsRequest | undefined> {
+  const queued = pendingActionButtonRequests.get(sessionId)
+  if (queued) {
+    pendingActionButtonRequests.delete(sessionId)
+    return queued
+  }
+
+  return await new Promise<ActionButtonsRequest | undefined>((resolve) => {
+    const timeout = setTimeout(() => {
+      const currentWaiter = pendingActionButtonRequestWaiters.get(sessionId)
+      if (!currentWaiter || currentWaiter !== onRequest) {
+        return
+      }
+      pendingActionButtonRequestWaiters.delete(sessionId)
+      resolve(undefined)
+    }, timeoutMs)
+
+    const onRequest = (request: ActionButtonsRequest) => {
+      clearTimeout(timeout)
+      pendingActionButtonRequests.delete(sessionId)
+      resolve(request)
+    }
+
+    pendingActionButtonRequestWaiters.set(sessionId, onRequest)
+  })
+}
+
+function toButtonStyle(color?: ActionButtonColor): ButtonStyle {
+  if (color === 'blue') {
+    return ButtonStyle.Primary
+  }
+  if (color === 'green') {
+    return ButtonStyle.Success
+  }
+  if (color === 'red') {
+    return ButtonStyle.Danger
+  }
+  return ButtonStyle.Secondary
+}
+
+function resolveContext(context: PendingActionButtonsContext): boolean {
+  if (context.resolved) {
+    return false
+  }
+  context.resolved = true
+  clearTimeout(context.timer)
+  pendingActionButtonContexts.delete(context.contextHash)
+  return true
+}
+
+function updateButtonMessage({
+  context,
+  status,
+}: {
+  context: PendingActionButtonsContext
+  status: string
+}): void {
+  if (!context.messageId) {
+    return
+  }
+  context.thread.messages
+    .fetch(context.messageId)
+    .then((message) => {
+      return message.edit({
+        content: `**Action Required**\n${status}`,
+        components: [],
+      })
+    })
+    .catch(() => {})
+}
+
+async function sendClickedActionToModel({
+  interaction,
+  thread,
+  prompt,
+}: {
+  interaction: ButtonInteraction
+  thread: ThreadChannel
+  prompt: string
+}): Promise<void> {
+  const resolved = await resolveWorkingDirectory({ channel: thread })
+  if (!resolved) {
+    throw new Error('Could not resolve project directory for thread')
+  }
+
+  const username = interaction.user.globalName || interaction.user.username
+
+  // Action button clicks use opencode queue mode.
+  const runtime = getOrCreateRuntime({
+    threadId: thread.id,
+    thread,
+    projectDirectory: resolved.projectDirectory,
+    sdkDirectory: resolved.workingDirectory,
+    channelId: thread.parentId || thread.id,
+  })
+  await runtime.enqueueIncoming({
+    prompt,
+    userId: interaction.user.id,
+    username,
+    mode: 'opencode',
+  })
+}
+
+export async function showActionButtons({
+  thread,
+  sessionId,
+  directory,
+  buttons,
+  silent,
+}: {
+  thread: ThreadChannel
+  sessionId: string
+  directory: string
+  buttons: ActionButtonOption[]
+  /** Suppress notification when queue has pending items */
+  silent?: boolean
+}): Promise<void> {
+  const safeButtons = buttons
+    .slice(0, 3)
+    .map((button) => {
+      return {
+        label: button.label.trim().slice(0, 80),
+        color: button.color,
+      }
+    })
+    .filter((button) => {
+      return button.label.length > 0
+    })
+
+  if (safeButtons.length === 0) {
+    throw new Error('No valid buttons to display')
+  }
+
+  const contextHash = crypto.randomBytes(8).toString('hex')
+  const timer = setTimeout(() => {
+    const current = pendingActionButtonContexts.get(contextHash)
+    if (!current || current.resolved) {
+      return
+    }
+    resolveContext(current)
+    updateButtonMessage({ context: current, status: '_Expired_' })
+  }, PENDING_TTL_MS)
+
+  const context: PendingActionButtonsContext = {
+    sessionId,
+    directory,
+    thread,
+    buttons: safeButtons,
+    contextHash,
+    resolved: false,
+    timer,
+  }
+
+  pendingActionButtonContexts.set(contextHash, context)
+
+  const row = new ActionRowBuilder<ButtonBuilder>().addComponents(
+    ...safeButtons.map((button, index) => {
+      return new ButtonBuilder()
+        .setCustomId(`action_button:${contextHash}:${index}`)
+        .setLabel(button.label)
+        .setStyle(toButtonStyle(button.color))
+    }),
+  )
+
+  try {
+    const message = await thread.send({
+      content: '**Action Required**',
+      components: [row],
+      flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
+    })
+
+    context.messageId = message.id
+    logger.log(
+      `Showed ${safeButtons.length} action button(s) for session ${sessionId}`,
+    )
+  } catch (error) {
+    clearTimeout(timer)
+    pendingActionButtonContexts.delete(contextHash)
+    throw new Error('Failed to send action buttons', { cause: error })
+  }
+}
+
+export async function handleActionButton(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('action_button:')) {
+    return
+  }
+
+  const [, contextHash, indexPart] = customId.split(':')
+  if (!contextHash || !indexPart) {
+    await interaction.reply({
+      content: 'Invalid action button.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const context = pendingActionButtonContexts.get(contextHash)
+  if (!context || context.resolved) {
+    await interaction.reply({
+      content: 'This action is no longer available.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const buttonIndex = Number.parseInt(indexPart, 10)
+  const button = context.buttons[buttonIndex]
+  if (!button) {
+    await interaction.reply({
+      content: 'This action is no longer available.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await interaction.deferUpdate()
+  const claimed = resolveContext(context)
+  if (!claimed) {
+    return
+  }
+
+  const thread = interaction.channel
+  if (!thread?.isThread()) {
+    logger.warn('[ACTION] Button clicked outside thread channel')
+    await interaction.editReply({
+      content: '**Action Required**\n_This action is no longer available._',
+      components: [],
+    })
+    return
+  }
+
+  const currentSessionId = await getThreadSession(thread.id)
+  if (!currentSessionId || currentSessionId !== context.sessionId) {
+    await interaction.editReply({
+      content: '**Action Required**\n_Expired due to session change._',
+      components: [],
+    })
+    return
+  }
+
+  await interaction.editReply({
+    content: `**Action Required**\n_Selected: ${button.label}_`,
+    components: [],
+  })
+
+  const prompt = `User clicked: ${button.label}`
+
+  try {
+    await sendClickedActionToModel({
+      interaction,
+      thread,
+      prompt,
+    })
+  } catch (error) {
+    logger.error('[ACTION] Failed to send click to model:', error)
+    void notifyError(error, 'Action button click send to model failed')
+    await sendThreadMessage(
+      thread,
+      `Failed to send action click: ${error instanceof Error ? error.message : String(error)}`,
+      { flags: NOTIFY_MESSAGE_FLAGS },
+    )
+  }
+}
+
+/**
+ * Dismiss pending action buttons for a thread (e.g. user sent a new message).
+ * Removes buttons from the message and cleans up context.
+ */
+export function cancelPendingActionButtons(threadId: string): boolean {
+  for (const [, ctx] of pendingActionButtonContexts) {
+    if (ctx.thread.id !== threadId) {
+      continue
+    }
+    if (!resolveContext(ctx)) {
+      continue
+    }
+    updateButtonMessage({ context: ctx, status: '_Buttons dismissed._' })
+    return true
+  }
+  return false
+}

package/src/commands/add-project.ts

@@ -0,0 +1,149 @@
+// /add-project command - Create Discord channels for an existing OpenCode project.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import {
+  findChannelsByDirectory,
+  getAllTextChannelDirectories,
+} from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { createProjectChannels } from '../channel-management.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { abbreviatePath } from '../utils.js'
+import * as errore from 'errore'
+
+const logger = createLogger(LogPrefix.ADD_PROJECT)
+
+export async function handleAddProjectCommand({
+  command,
+}: CommandContext): Promise<void> {
+  await command.deferReply()
+
+  const projectId = 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 {
+    const currentDir = process.cwd()
+    const getClient = await initializeOpencodeForDirectory(currentDir)
+    if (getClient instanceof Error) {
+      await command.editReply(getClient.message)
+      return
+    }
+
+    const projectsResponse = await getClient().project.list({})
+    if (!projectsResponse.data) {
+      await command.editReply('Failed to fetch projects')
+      return
+    }
+
+    const project = projectsResponse.data.find((p) => p.id === projectId)
+
+    if (!project) {
+      await command.editReply('Project not found')
+      return
+    }
+
+    const directory = project.worktree
+
+    if (!fs.existsSync(directory)) {
+      await command.editReply(`Directory does not exist: ${directory}`)
+      return
+    }
+
+    const existingChannels = await findChannelsByDirectory({
+      directory,
+      channelType: 'text',
+    })
+
+    if (existingChannels.length > 0) {
+      await command.editReply(
+        `A channel already exists for this directory: <#${existingChannels[0]!.channel_id}>`,
+      )
+      return
+    }
+
+    const { textChannelId, voiceChannelId, channelName } =
+      await createProjectChannels({
+        guild,
+        projectDirectory: directory,
+        botName: command.client.user?.username,
+      })
+
+    const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : ''
+    await command.editReply(
+      `✅ Created channels for project:\n📝 Text: <#${textChannelId}>${voiceInfo}\n📁 Directory: \`${directory}\``,
+    )
+
+    logger.log(`Created channels for project ${channelName} at ${directory}`)
+  } catch (error) {
+    logger.error('[ADD-PROJECT] Error:', error)
+    await command.editReply(
+      `Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleAddProjectAutocomplete({
+  interaction,
+}: AutocompleteContext): Promise<void> {
+  const focusedValue = interaction.options.getFocused()
+
+  try {
+    const currentDir = process.cwd()
+    const getClient = await initializeOpencodeForDirectory(currentDir)
+    if (getClient instanceof Error) {
+      await interaction.respond([])
+      return
+    }
+
+    const projectsResponse = await getClient().project.list({})
+    if (!projectsResponse.data) {
+      await interaction.respond([])
+      return
+    }
+
+    const existingDirs = await getAllTextChannelDirectories()
+    const existingDirSet = new Set(existingDirs)
+
+    const availableProjects = projectsResponse.data.filter((project) => {
+      if (existingDirSet.has(project.worktree)) {
+        return false
+      }
+      if (path.basename(project.worktree).startsWith('opencode-test-')) {
+        return false
+      }
+      return true
+    })
+
+    const projects = availableProjects
+      .filter((project) => {
+        const baseName = path.basename(project.worktree)
+        const searchText = `${baseName} ${project.worktree}`.toLowerCase()
+        return searchText.includes(focusedValue.toLowerCase())
+      })
+      .sort((a, b) => {
+        const aTime = a.time.initialized || a.time.created
+        const bTime = b.time.initialized || b.time.created
+        return bTime - aTime
+      })
+      .slice(0, 25)
+      .map((project) => {
+        const name = `${path.basename(project.worktree)} (${abbreviatePath(project.worktree)})`
+        return {
+          name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+          value: project.id,
+        }
+      })
+
+    await interaction.respond(projects)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching projects:', error)
+    await interaction.respond([])
+  }
+}