@otto-assistant/bridge 0.4.92

package/src/commands/mcp.ts

@@ -0,0 +1,307 @@
+// /mcp command - List and toggle MCP servers for the current project.
+// Uses OpenCode SDK mcp.status/connect/disconnect to manage servers.
+// MCP state is project-scoped (per channel), not per thread or session.
+// No database storage needed — state lives in OpenCode's config.
+
+import crypto from 'node:crypto'
+import {
+  MessageFlags,
+  StringSelectMenuBuilder,
+  ActionRowBuilder,
+  ChannelType,
+  type StringSelectMenuInteraction,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { McpStatus } from '@opencode-ai/sdk/v2'
+import type { CommandContext } from './types.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.MCP)
+
+// Short-lived context map: contextHash → projectDirectory.
+// Avoids embedding long directory paths in Discord customId (100 char limit).
+// Entries auto-expire after 5 minutes to prevent unbounded growth from
+// abandoned menus (user runs /mcp but never clicks the select menu).
+const MCP_CONTEXT_TTL_MS = 5 * 60_000
+const pendingMcpContexts = new Map<string, string>()
+
+const STATUS_LABELS: Record<string, string> = {
+  connected: 'connected',
+  disabled: 'disabled',
+  failed: 'failed',
+  needs_auth: 'needs auth',
+  needs_client_registration: 'needs registration',
+}
+
+function formatStatusLabel(status: string): string {
+  return STATUS_LABELS[status] || status
+}
+
+/** Extract error string from McpStatus using discriminated union narrowing. */
+function getStatusError(info: McpStatus): string | undefined {
+  if (info.status === 'failed') {
+    return info.error
+  }
+  if (info.status === 'needs_client_registration') {
+    return info.error
+  }
+  return undefined
+}
+
+/** Build a one-line description for a server entry in the list. */
+export function formatServerLine({
+  name,
+  status,
+  error,
+}: {
+  name: string
+  status: string
+  error?: string
+}): string {
+  const label = formatStatusLabel(status)
+  const errorSuffix = error ? ` — ${error}` : ''
+  return `\`${label}\` **${name}**${errorSuffix}`
+}
+
+/** Determine the select menu option label for toggling a server. */
+export function toggleActionLabel(status: string): string {
+  if (status === 'connected') {
+    return 'disconnect'
+  }
+  if (status === 'failed') {
+    return 'reconnect'
+  }
+  return 'connect'
+}
+
+export async function handleMcpCommand({
+  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)
+  const isTextChannel = channel.type === ChannelType.GuildText
+
+  if (!isThread && !isTextChannel) {
+    await command.reply({
+      content: 'This command can only be used in text channels or threads.',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel.',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const { projectDirectory } = resolved
+
+  await command.deferReply({ flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS })
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await command.editReply({
+      content: `Failed to connect to OpenCode server: ${getClient.message}`,
+    })
+    return
+  }
+
+  const client = getClient()
+  const { data, error } = await client.mcp.status({
+    directory: projectDirectory,
+  })
+
+  if (error || !data) {
+    await command.editReply({
+      content: 'Failed to fetch MCP server status.',
+    })
+    return
+  }
+
+  const servers = Object.entries(data)
+  if (servers.length === 0) {
+    await command.editReply({
+      content:
+        'No MCP servers configured for this project.\nAdd MCP servers in your project\'s `opencode.json` configuration.',
+    })
+    return
+  }
+
+  const lines = servers.map(([name, info]) => {
+    return formatServerLine({ name, status: info.status, error: getStatusError(info) })
+  })
+
+  const content = `**MCP Servers** (project-wide)\n${lines.join('\n')}`
+
+  const contextHash = crypto.randomBytes(8).toString('hex')
+  pendingMcpContexts.set(contextHash, projectDirectory)
+  setTimeout(() => {
+    pendingMcpContexts.delete(contextHash)
+  }, MCP_CONTEXT_TTL_MS)
+
+  // Discord select option limits: label max 100 chars, description max 100 chars
+  const options = servers.map(([name, info]) => ({
+    label: name.slice(0, 100),
+    value: name.slice(0, 100),
+    description: `${formatStatusLabel(info.status)} — click to ${toggleActionLabel(info.status)}`.slice(0, 100),
+  }))
+
+  const selectMenu = new StringSelectMenuBuilder()
+    .setCustomId(`mcp_toggle:${contextHash}`)
+    .setPlaceholder('Select MCP server to toggle')
+    .addOptions(options.slice(0, 25)) // Discord max 25 options
+
+  const actionRow =
+    new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+  await command.editReply({
+    content,
+    components: [actionRow],
+  })
+}
+
+export async function handleMcpSelectMenu(
+  interaction: StringSelectMenuInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('mcp_toggle:')) {
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const contextHash = customId.slice('mcp_toggle:'.length)
+  const projectDirectory = pendingMcpContexts.get(contextHash)
+
+  if (!projectDirectory) {
+    await interaction.editReply({
+      content: 'Session expired. Run `/mcp` again.',
+      components: [],
+    })
+    return
+  }
+
+  const serverName = interaction.values[0]
+  if (!serverName) {
+    await interaction.editReply({
+      content: 'No server selected.',
+      components: [],
+    })
+    return
+  }
+
+  pendingMcpContexts.delete(contextHash)
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await interaction.editReply({
+      content: `Failed to connect to OpenCode server: ${getClient.message}`,
+      components: [],
+    })
+    return
+  }
+
+  const client = getClient()
+
+  const { data: statusData, error: statusError } = await client.mcp.status({
+    directory: projectDirectory,
+  })
+
+  if (statusError || !statusData) {
+    await interaction.editReply({
+      content: 'Failed to refresh MCP server status.',
+      components: [],
+    })
+    return
+  }
+
+  if (!statusData[serverName]) {
+    await interaction.editReply({
+      content: `Server **${serverName}** not found.`,
+      components: [],
+    })
+    return
+  }
+
+  const serverInfo = statusData[serverName]
+
+  if (serverInfo.status === 'connected') {
+    const { error } = await client.mcp.disconnect({
+      name: serverName,
+      directory: projectDirectory,
+    })
+    if (error) {
+      logger.error(`[MCP] Failed to disconnect ${serverName}:`, error)
+      await interaction.editReply({
+        content: `Failed to disconnect **${serverName}**.`,
+        components: [],
+      })
+      return
+    }
+    logger.log(`[MCP] Disconnected server: ${serverName}`)
+    await interaction.editReply({
+      content: `**${serverName}** disconnected`,
+      components: [],
+    })
+    return
+  }
+
+  if (serverInfo.status === 'needs_auth') {
+    await interaction.editReply({
+      content: `**${serverName}** needs authentication.\nRun \`opencode\` in the project directory to complete the OAuth flow.`,
+      components: [],
+    })
+    return
+  }
+
+  if (serverInfo.status === 'needs_client_registration') {
+    await interaction.editReply({
+      content: `**${serverName}** needs client registration.${serverInfo.error ? `\n${serverInfo.error}` : ''}`,
+      components: [],
+    })
+    return
+  }
+
+  // Connect (handles disabled and failed)
+  const { error } = await client.mcp.connect({
+    name: serverName,
+    directory: projectDirectory,
+  })
+  if (error) {
+    logger.error(`[MCP] Failed to connect ${serverName}:`, error)
+    await interaction.editReply({
+      content: `Failed to connect **${serverName}**.`,
+      components: [],
+    })
+    return
+  }
+  logger.log(`[MCP] Connected server: ${serverName}`)
+  await interaction.editReply({
+    content: `**${serverName}** connected`,
+    components: [],
+  })
+}

package/src/commands/memory-snapshot.ts

@@ -0,0 +1,30 @@
+// /memory-snapshot command - Write a V8 heap snapshot and show the file path.
+// Reuses writeHeapSnapshot() from heap-monitor.ts which writes gzip-compressed
+// .heapsnapshot.gz files to ~/.kimaki/heap-snapshots/.
+
+import { MessageFlags } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { writeHeapSnapshot } from '../heap-monitor.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.HEAP)
+
+export async function handleMemorySnapshotCommand({
+  command,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  try {
+    const filepath = await writeHeapSnapshot()
+    await command.editReply({
+      content: `Heap snapshot written:\n\`${filepath}\``,
+    })
+    logger.log(`Memory snapshot requested via /memory-snapshot: ${filepath}`)
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    await command.editReply({
+      content: `Failed to write heap snapshot: ${msg}`,
+    })
+  }
+}

package/src/commands/mention-mode.ts

@@ -0,0 +1,68 @@
+// /toggle-mention-mode command.
+// Toggles mention-only mode for a channel.
+// When enabled, bot only responds to messages that @mention it.
+// Messages in threads are not affected - they always work without mentions.
+
+import {
+  ChatInputCommandInteraction,
+  MessageFlags,
+  ChannelType,
+  type TextChannel,
+} from 'discord.js'
+import { getChannelMentionMode, setChannelMentionMode } from '../database.js'
+import { getKimakiMetadata } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const mentionModeLogger = createLogger(LogPrefix.CLI)
+
+/**
+ * Handle the /toggle-mention-mode slash command.
+ * Toggles whether the bot only responds when @mentioned in this channel.
+ */
+export async function handleToggleMentionModeCommand({
+  command,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  mentionModeLogger.log('[TOGGLE_MENTION_MODE] Command called')
+
+  const channel = command.channel
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.reply({
+      content: 'This command can only be used in text channels (not threads).',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const textChannel = channel as TextChannel
+  const metadata = await getKimakiMetadata(textChannel)
+
+  if (!metadata.projectDirectory) {
+    await command.reply({
+      content:
+        'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const wasEnabled = await getChannelMentionMode(textChannel.id)
+  const nextEnabled = !wasEnabled
+  await setChannelMentionMode(textChannel.id, nextEnabled)
+
+  const nextLabel = nextEnabled ? 'enabled' : 'disabled'
+
+  mentionModeLogger.log(
+    `[TOGGLE_MENTION_MODE] ${nextLabel.toUpperCase()} for channel ${textChannel.id}`,
+  )
+
+  await command.reply({
+    content: nextEnabled
+      ? `Mention mode **enabled** for this channel.\nThe bot will only start new sessions when @mentioned.\nMessages in existing threads are not affected.`
+      : `Mention mode **disabled** for this channel.\nThe bot will respond to all messages in **#${textChannel.name}**.`,
+    flags: MessageFlags.Ephemeral,
+  })
+}

package/src/commands/merge-worktree.ts

@@ -0,0 +1,223 @@
+// /merge-worktree command - Merge worktree commits into default branch.
+// Pipeline: rebase worktree commits onto target -> local fast-forward push.
+// Preserves all commits (no squash). On rebase conflicts, asks the AI model
+// in the thread to resolve them.
+
+import { type TextChannel, type ThreadChannel } from 'discord.js'
+import type { AutocompleteContext, CommandContext } from './types.js'
+import {
+  getThreadWorktree,
+  getThreadSession,
+  getChannelDirectory,
+} from '../database.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { notifyError } from '../sentry.js'
+import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../worktrees.js'
+import {
+  sendThreadMessage,
+  resolveWorkingDirectory,
+  resolveProjectDirectoryFromAutocomplete,
+} from '../discord-utils.js'
+import {
+  getOrCreateRuntime,
+} from '../session-handler/thread-session-runtime.js'
+import { RebaseConflictError, DirtyWorktreeError } from '../errors.js'
+
+const logger = createLogger(LogPrefix.WORKTREE)
+
+/** Worktree thread title prefix - indicates unmerged worktree */
+export const WORKTREE_PREFIX = '⬦ '
+
+async function removeWorktreePrefixFromTitle(
+  thread: ThreadChannel,
+): Promise<void> {
+  if (!thread.name.startsWith(WORKTREE_PREFIX)) {
+    return
+  }
+  const newName = thread.name.slice(WORKTREE_PREFIX.length)
+  const timeoutMs = 5000
+  await Promise.race([
+    thread.setName(newName).catch((e) => {
+      logger.warn(
+        `Failed to update thread title: ${e instanceof Error ? e.message : String(e)}`,
+      )
+    }),
+    new Promise<void>((resolve) => {
+      setTimeout(() => {
+        logger.warn(`Thread title update timed out after ${timeoutMs}ms`)
+        resolve()
+      }, timeoutMs)
+    }),
+  ])
+}
+
+/**
+ * Send a prompt to the AI model in the thread.
+ * If a session is actively streaming, queues it. Otherwise sends directly.
+ * Routes through ThreadSessionRuntime.
+ */
+async function sendPromptToModel({
+  prompt,
+  thread,
+  projectDirectory,
+  command,
+  appId,
+}: {
+  prompt: string
+  thread: ThreadChannel
+  projectDirectory: string
+  command: CommandContext['command']
+  appId?: string
+}): Promise<void> {
+  const resolved = await resolveWorkingDirectory({ channel: thread })
+
+  // Merge prompts use opencode queue mode.
+  const runtime = getOrCreateRuntime({
+    threadId: thread.id,
+    thread,
+    projectDirectory: resolved?.projectDirectory || projectDirectory,
+    sdkDirectory: resolved?.workingDirectory || projectDirectory,
+    channelId: thread.parentId || thread.id,
+    appId,
+  })
+  await runtime.enqueueIncoming({
+    prompt,
+    userId: command.user.id,
+    username: command.user.displayName,
+    appId,
+    mode: 'opencode',
+  })
+}
+
+export async function handleMergeWorktreeCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply()
+
+  const channel = command.channel
+  if (!channel || !channel.isThread()) {
+    await command.editReply('This command can only be used in a thread')
+    return
+  }
+
+  const thread = channel as ThreadChannel
+  const worktreeInfo = await getThreadWorktree(thread.id)
+  if (!worktreeInfo) {
+    await command.editReply('This thread is not associated with a worktree')
+    return
+  }
+
+  if (worktreeInfo.status !== 'ready' || !worktreeInfo.worktree_directory) {
+    await command.editReply(
+      `Worktree is not ready (status: ${worktreeInfo.status})${worktreeInfo.error_message ? `: ${worktreeInfo.error_message}` : ''}`,
+    )
+    return
+  }
+
+
+
+  const rawTargetBranch = command.options.getString('target-branch') || undefined
+  let targetBranch = rawTargetBranch
+  if (targetBranch) {
+    const validated = await validateBranchRef({
+      directory: worktreeInfo.project_directory,
+      ref: targetBranch,
+    })
+    if (validated instanceof Error) {
+      await command.editReply(`Invalid target branch: \`${targetBranch}\``)
+      return
+    }
+    targetBranch = validated
+  }
+
+  const result = await mergeWorktree({
+    worktreeDir: worktreeInfo.worktree_directory,
+    mainRepoDir: worktreeInfo.project_directory,
+    worktreeName: worktreeInfo.worktree_name,
+    targetBranch,
+    onProgress: (msg) => {
+      logger.log(`[merge] ${msg}`)
+    },
+  })
+
+  if (result instanceof Error) {
+    if (result instanceof DirtyWorktreeError) {
+      await command.editReply(
+        'Merge failed: uncommitted changes in the worktree. Commit changes first, then run `/merge-worktree` again.',
+      )
+      return
+    }
+
+    if (result instanceof RebaseConflictError) {
+      await command.editReply(
+        'Rebase conflict detected. Asking the model to resolve...',
+      )
+      await sendPromptToModel({
+        prompt: [
+          'A rebase conflict occurred while merging this worktree into the default branch.',
+          'Rebasing multiple commits can pause on each commit that conflicts, so you may need to repeat the resolve/continue loop several times.',
+          'Please resolve the rebase conflicts:',
+          '1. Check `git status` to see which files have conflicts',
+          '2. Edit the conflicted files to resolve the merge markers',
+          '3. Stage resolved files with `git add`',
+          '4. Continue the rebase with `git rebase --continue`',
+          '5. If git reports more conflicts, repeat steps 1-4 until the rebase finishes (no more MERGE markers, `git status` shows no rebase in progress)',
+          '6. Once the rebase is fully complete, tell me so I can run `/merge-worktree` again',
+        ].join('\n'),
+        thread,
+        projectDirectory: worktreeInfo.project_directory,
+        command,
+        appId,
+      })
+      return
+    }
+
+    await command.editReply(`Merge failed: ${result.message}`)
+    return
+  }
+
+  void removeWorktreePrefixFromTitle(thread)
+  await command.editReply(
+    `Merged \`${result.branchName}\` into \`${result.defaultBranch}\` @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})\nWorktree now at detached HEAD.`,
+  )
+}
+
+/**
+ * Autocomplete handler for /merge-worktree target-branch option.
+ * Lists local branches only (no remotes) sorted by most recent commit date.
+ * Resolves directory from the thread's worktree info or parent channel.
+ */
+export async function handleMergeWorktreeAutocomplete({
+  interaction,
+}: AutocompleteContext): Promise<void> {
+  try {
+    const focusedValue = interaction.options.getFocused()
+
+    // interaction.channel can be null when the channel isn't cached
+    // (common with gateway-proxy). Use channelId which is always available
+    // from the raw interaction payload.
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction)
+
+    if (!projectDirectory) {
+      await interaction.respond([])
+      return
+    }
+
+    // Local branches only — merge targets must be local refs
+    const branches = await listBranchesByLastCommit({
+      directory: projectDirectory,
+      query: focusedValue,
+      includeRemote: false,
+    })
+
+    await interaction.respond(
+      branches.map((name) => {
+        return { name, value: name }
+      }),
+    )
+  } catch (e) {
+    logger.error('[MERGE-WORKTREE] Autocomplete error:', e)
+    await interaction.respond([]).catch(() => {})
+  }
+}