@otto-assistant/bridge 0.4.92

package/src/commands/user-command.ts

@@ -0,0 +1,198 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+
+import type { CommandContext, CommandHandler } from './types.js'
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { getChannelDirectory, getThreadSession } from '../database.js'
+import { store } from '../store.js'
+import fs from 'node:fs'
+
+const userCommandLogger = createLogger(LogPrefix.USER_CMD)
+const DISCORD_MESSAGE_LIMIT = 2000
+const DISCORD_THREAD_NAME_LIMIT = 100
+
+export const handleUserCommand: CommandHandler = async ({
+  command,
+  appId,
+}: CommandContext) => {
+  const discordCommandName = command.commandName
+  // Look up the original OpenCode command name from the mapping populated at registration.
+  // The sanitized Discord name is lossy (e.g. foo:bar → foo-bar), so resolving from
+  // the exact registered slash command name avoids collisions.
+  const registered = store.getState().registeredUserCommands.find(
+    (c) => c.discordCommandName === discordCommandName,
+  )
+  const fallbackBase = discordCommandName.replace(/-(cmd|skill|mcp-prompt)$/, '')
+  const commandName = registered?.name || fallbackBase
+  const args = command.options.getString('arguments') || ''
+  const commandInvocation = args ? `/${commandName} ${args}` : `/${commandName}`
+  const threadOpeningMessage =
+    commandInvocation.length <= DISCORD_MESSAGE_LIMIT
+      ? commandInvocation
+      : `${commandInvocation.slice(0, DISCORD_MESSAGE_LIMIT - 14)}... truncated`
+
+  userCommandLogger.log(
+    `Executing /${commandName} (from /${discordCommandName}) argsLength=${args.length}`,
+  )
+
+  const channel = command.channel
+
+  userCommandLogger.log(
+    `Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`,
+  )
+
+  const isThread =
+    channel &&
+    [
+      ChannelType.PublicThread,
+      ChannelType.PrivateThread,
+      ChannelType.AnnouncementThread,
+    ].includes(channel.type)
+
+  const isTextChannel = channel?.type === ChannelType.GuildText
+
+  if (!channel || (!isTextChannel && !isThread)) {
+    await command.reply({
+      content: 'This command can only be used in text channels or threads',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  let projectDirectory: string | undefined
+  let textChannel: TextChannel | null = null
+  let thread: ThreadChannel | null = null
+
+  if (isThread) {
+    // Running in an existing thread - get project directory from parent channel
+    thread = channel as ThreadChannel
+    textChannel = thread.parent as TextChannel | null
+
+    // Verify this thread has an existing session
+    const sessionId = await getThreadSession(thread.id)
+
+    if (!sessionId) {
+      await command.reply({
+        content:
+          'This thread does not have an active session. Use this command in a project channel to create a new thread.',
+        flags: MessageFlags.Ephemeral,
+      })
+      return
+    }
+
+    if (textChannel) {
+      const channelConfig = await getChannelDirectory(textChannel.id)
+      projectDirectory = channelConfig?.directory
+    }
+  } else {
+    // Running in a text channel - will create a new thread
+    textChannel = channel as TextChannel
+
+    const channelConfig = await getChannelDirectory(textChannel.id)
+    projectDirectory = channelConfig?.directory
+  }
+
+  if (!projectDirectory) {
+    await command.reply({
+      content: 'This channel is not configured with a project directory',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    await command.reply({
+      content: `Directory does not exist: ${projectDirectory}`,
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await command.deferReply()
+
+  try {
+    // Use the dedicated session.command API instead of formatting as text prompt
+    const commandPayload = { name: commandName, arguments: args }
+
+    if (isThread && thread) {
+      // Running in existing thread - just send the command
+      await command.editReply(`Running ${commandInvocation}...`)
+
+      const runtime = getOrCreateRuntime({
+        threadId: thread.id,
+        thread,
+        projectDirectory,
+        sdkDirectory: projectDirectory,
+        channelId: textChannel?.id,
+        appId,
+      })
+      await runtime.enqueueIncoming({
+        prompt: '',
+        userId: command.user.id,
+        username: command.user.displayName,
+        command: commandPayload,
+        appId,
+        mode: 'local-queue',
+      })
+    } else if (textChannel) {
+      // Running in text channel - create a new thread
+      const starterMessage = await textChannel.send({
+        content: threadOpeningMessage,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+
+      const newThread = await starterMessage.startThread({
+        name: commandInvocation.slice(0, DISCORD_THREAD_NAME_LIMIT),
+        autoArchiveDuration: 1440,
+        reason: `OpenCode command: ${commandName}`,
+      })
+
+      // Add user to thread so it appears in their sidebar
+      await newThread.members.add(command.user.id)
+
+      await command.editReply(
+        `Started /${commandName} in ${newThread.toString()}`,
+      )
+
+      const runtime = getOrCreateRuntime({
+        threadId: newThread.id,
+        thread: newThread,
+        projectDirectory,
+        sdkDirectory: projectDirectory,
+        channelId: textChannel.id,
+        appId,
+      })
+      await runtime.enqueueIncoming({
+        prompt: '',
+        userId: command.user.id,
+        username: command.user.displayName,
+        command: commandPayload,
+        appId,
+        mode: 'local-queue',
+      })
+    }
+  } catch (error) {
+    userCommandLogger.error(`Error executing /${commandName}:`, error)
+
+    const errorMessage = error instanceof Error ? error.message : String(error)
+
+    if (command.deferred) {
+      await command.editReply({
+        content: `Failed to execute /${commandName}: ${errorMessage}`,
+      })
+    } else {
+      await command.reply({
+        content: `Failed to execute /${commandName}: ${errorMessage}`,
+        flags: MessageFlags.Ephemeral,
+      })
+    }
+  }
+}

package/src/commands/verbosity.ts

@@ -0,0 +1,173 @@
+// /verbosity command.
+// Shows a dropdown to set output verbosity level for sessions in a channel.
+// 'text_and_essential_tools' (default): shows text and essential tools (edits, custom MCP tools)
+// 'tools_and_text': shows all output including tool executions
+// 'text_only': only shows text responses
+
+import {
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+  StringSelectMenuBuilder,
+  ActionRowBuilder,
+  MessageFlags,
+  ChannelType,
+  type ThreadChannel,
+} from 'discord.js'
+import {
+  getChannelVerbosity,
+  setChannelVerbosity,
+  type VerbosityLevel,
+} from '../database.js'
+import { getPrisma } from '../db.js'
+import { store } from '../store.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const verbosityLogger = createLogger(LogPrefix.VERBOSITY)
+
+const VERBOSITY_OPTIONS: Array<{
+  value: VerbosityLevel
+  label: string
+  description: string
+}> = [
+  {
+    value: 'tools_and_text',
+    label: 'Tools and text',
+    description: 'All output including tool executions and status messages',
+  },
+  {
+    value: 'text_and_essential_tools',
+    label: 'Text and essential tools',
+    description: 'Text + essential tools (edits, custom MCP). Hides read/search.',
+  },
+  {
+    value: 'text_only',
+    label: 'Text only',
+    description: 'Only text responses. Hides all tools and status messages.',
+  },
+]
+
+function resolveChannelId(channel: ChatInputCommandInteraction['channel']): string | null {
+  if (!channel) {
+    return null
+  }
+  if (channel.type === ChannelType.GuildText) {
+    return channel.id
+  }
+  if (
+    channel.type === ChannelType.PublicThread ||
+    channel.type === ChannelType.PrivateThread ||
+    channel.type === ChannelType.AnnouncementThread
+  ) {
+    return (channel as ThreadChannel).parentId || channel.id
+  }
+  return channel.id
+}
+
+/**
+ * Check if there is a per-channel verbosity override in the DB.
+ * Returns the override value if it exists, null otherwise.
+ */
+async function getChannelVerbosityOverride(
+  channelId: string,
+): Promise<VerbosityLevel | null> {
+  const prisma = await getPrisma()
+  const row = await prisma.channel_verbosity.findUnique({
+    where: { channel_id: channelId },
+  })
+  if (row?.verbosity) {
+    return row.verbosity as VerbosityLevel
+  }
+  return null
+}
+
+/**
+ * Handle the /verbosity slash command.
+ * Shows a dropdown with the current verbosity level and available options.
+ */
+export async function handleVerbosityCommand({
+  command,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  verbosityLogger.log('[VERBOSITY] Command called')
+
+  const channelId = resolveChannelId(command.channel)
+  if (!channelId) {
+    await command.reply({
+      content: 'Could not determine channel.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const override = await getChannelVerbosityOverride(channelId)
+  const currentLevel = override || store.getState().defaultVerbosity
+  const source = override ? 'channel override' : 'global default'
+
+  const options = VERBOSITY_OPTIONS.map((opt) => ({
+    label: opt.label,
+    value: opt.value,
+    description: opt.description,
+    default: opt.value === currentLevel,
+  }))
+
+  const selectMenu = new StringSelectMenuBuilder()
+    .setCustomId(`verbosity_select:${channelId}`)
+    .setPlaceholder('Select verbosity level')
+    .addOptions(options)
+
+  const actionRow =
+    new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+  await command.reply({
+    content: `**Verbosity**\nCurrent: \`${currentLevel}\` (${source})`,
+    components: [actionRow],
+    flags: MessageFlags.Ephemeral,
+  })
+}
+
+/**
+ * Handle the verbosity select menu interaction.
+ * Sets the selected verbosity level for the channel.
+ */
+export async function handleVerbositySelectMenu(
+  interaction: StringSelectMenuInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('verbosity_select:')) {
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const channelId = customId.replace('verbosity_select:', '')
+  const level = interaction.values[0] as VerbosityLevel | undefined
+
+  if (!level) {
+    await interaction.editReply({
+      content: 'No level selected.',
+      components: [],
+    })
+    return
+  }
+
+  const currentLevel = await getChannelVerbosity(channelId)
+  if (currentLevel === level) {
+    await interaction.editReply({
+      content: `Verbosity is already \`${level}\` for this channel.`,
+      components: [],
+    })
+    return
+  }
+
+  await setChannelVerbosity(channelId, level)
+  verbosityLogger.log(`[VERBOSITY] Set channel ${channelId} to ${level}`)
+
+  const description = VERBOSITY_OPTIONS.find((o) => o.value === level)?.description || ''
+
+  await interaction.editReply({
+    content: `Verbosity set to \`${level}\` for this channel.\n${description}\nApplies immediately, including active sessions.`,
+    components: [],
+  })
+}

package/src/commands/worktree-settings.ts

@@ -0,0 +1,70 @@
+// /toggle-worktrees command.
+// Allows per-channel opt-in for automatic worktree creation,
+// as an alternative to the global --use-worktrees CLI flag.
+
+import {
+  ChatInputCommandInteraction,
+  MessageFlags,
+  ChannelType,
+  type TextChannel,
+} from 'discord.js'
+import {
+  getChannelWorktreesEnabled,
+  setChannelWorktreesEnabled,
+} from '../database.js'
+import { getKimakiMetadata } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE)
+
+/**
+ * Handle the /toggle-worktrees slash command.
+ * Toggles automatic worktree creation for new sessions in this channel.
+ */
+export async function handleToggleWorktreesCommand({
+  command,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  worktreeSettingsLogger.log('[TOGGLE_WORKTREES] 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 getChannelWorktreesEnabled(textChannel.id)
+  const nextEnabled = !wasEnabled
+  await setChannelWorktreesEnabled(textChannel.id, nextEnabled)
+
+  const nextLabel = nextEnabled ? 'enabled' : 'disabled'
+
+  worktreeSettingsLogger.log(
+    `[TOGGLE_WORKTREES] ${nextLabel.toUpperCase()} for channel ${textChannel.id}`,
+  )
+
+  await command.reply({
+    content: nextEnabled
+      ? `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will now automatically create git worktrees.\n\nNew setting for **#${textChannel.name}**: **enabled**.`
+      : `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will use the main project directory.\n\nNew setting for **#${textChannel.name}**: **disabled**.`,
+    flags: MessageFlags.Ephemeral,
+  })
+}