@otto-assistant/bridge 0.4.92

package/src/commands/undo-redo.ts

@@ -0,0 +1,386 @@
+// Undo/Redo commands - /undo, /redo
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { OpencodeClient } from '@opencode-ai/sdk/v2'
+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 { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.UNDO_REDO)
+
+async function waitForSessionIdle({
+  client,
+  sessionId,
+  directory,
+  timeoutMs = 2_000,
+}: {
+  client: OpencodeClient
+  sessionId: string
+  directory: string
+  timeoutMs?: number
+}): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    const statusResponse = await client.session.status({ directory })
+    const sessionStatus = statusResponse.data?.[sessionId]
+    if (!sessionStatus || sessionStatus.type === 'idle') {
+      return
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 50)
+    })
+  }
+}
+
+export async function handleUndoCommand({
+  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
+  }
+
+  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, workingDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.reply({
+      content: 'No active session in this thread',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await command.editReply(`Failed to undo: ${getClient.message}`)
+    return
+  }
+
+  try {
+    const client = getClient()
+    // Fetch session to check existing revert state
+    const sessionResponse = await client.session.get({
+      sessionID: sessionId,
+      directory: workingDirectory,
+    })
+    if (sessionResponse.error) {
+      await command.editReply(`Failed to undo: ${JSON.stringify(sessionResponse.error)}`)
+      return
+    }
+
+    // Abort if session is busy before reverting, matching TUI behavior
+    // (use-session-commands.tsx always aborts non-idle sessions before revert).
+    // session.status() returns a sparse map — only non-idle sessions have entries,
+    // so a missing key means idle.
+    const statusResponse = await client.session.status({
+      directory: workingDirectory,
+    })
+    const sessionStatus = statusResponse.data?.[sessionId]
+    if (sessionStatus && sessionStatus.type !== 'idle') {
+      await client.session.abort({
+        sessionID: sessionId,
+        directory: workingDirectory,
+      }).catch((error) => {
+        logger.warn(`[UNDO] abort failed for ${sessionId}`, error)
+      })
+      await waitForSessionIdle({
+        client,
+        sessionId,
+        directory: workingDirectory,
+      })
+    }
+
+    const messagesResponse = await client.session.messages({
+      sessionID: sessionId,
+      directory: workingDirectory,
+    })
+    if (messagesResponse.error) {
+      await command.editReply(`Failed to undo: ${JSON.stringify(messagesResponse.error)}`)
+      return
+    }
+
+    if (!messagesResponse.data || messagesResponse.data.length === 0) {
+      await command.editReply('No messages to undo')
+      return
+    }
+
+    // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
+    // find the last user message that is before the current revert point
+    // (or the last user message if no revert is active). This matches the
+    // TUI's `findLast(userMessages(), (x) => !revert || x.id < revert)`.
+    const currentRevert = sessionResponse.data?.revert?.messageID
+    const userMessages = messagesResponse.data.filter((m) => {
+      return m.info.role === 'user'
+    })
+    const targetUserMessage = [...userMessages].reverse().find((m) => {
+      return !currentRevert || m.info.id < currentRevert
+    })
+
+    if (!targetUserMessage) {
+      await command.editReply('No messages to undo')
+      return
+    }
+
+    const targetAssistantMessage = [...messagesResponse.data].reverse().find((m) => {
+      return m.info.role === 'assistant' && m.info.parentID === targetUserMessage.info.id
+    })
+    const revertMessageId = targetAssistantMessage?.info.id || targetUserMessage.info.id
+
+    // session.revert() reverts filesystem patches (file edits, writes) and
+    // marks the session with revert.messageID. Messages are NOT deleted — they
+    // get cleaned up automatically on the next promptAsync() call via
+    // SessionRevert.cleanup(). The model only sees messages before the revert
+    // point when processing the next prompt.
+    logger.log(`[UNDO] session.revert start messageId=${revertMessageId}`)
+    let response = await client.session.revert({
+      sessionID: sessionId,
+      directory: workingDirectory,
+      messageID: revertMessageId,
+    })
+    logger.log(`[UNDO] session.revert done error=${Boolean(response.error)}`)
+
+    if (response.error) {
+      logger.log('[UNDO] retry wait idle before revert retry')
+      await waitForSessionIdle({
+        client,
+        sessionId,
+        directory: workingDirectory,
+      })
+      logger.log('[UNDO] retry revert start')
+      response = await client.session.revert({
+        sessionID: sessionId,
+        directory: workingDirectory,
+        messageID: revertMessageId,
+      })
+      logger.log(`[UNDO] retry revert done error=${Boolean(response.error)}`)
+      if (response.error) {
+        await command.editReply(
+          `Failed to undo: ${JSON.stringify(response.error)}`,
+        )
+        return
+      }
+    }
+
+    const diffInfo = response.data?.revert?.diff
+      ? `\n\`\`\`diff\n${response.data.revert.diff.slice(0, 1500)}\n\`\`\``
+      : ''
+
+    await command.editReply(`Undone - reverted last assistant message${diffInfo}`)
+    logger.log(
+      `Session ${sessionId} reverted at message ${revertMessageId}`,
+    )
+  } catch (error) {
+    logger.error('[UNDO] Error:', error)
+    await command.editReply(
+      `Failed to undo: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleRedoCommand({
+  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
+  }
+
+  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, workingDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.reply({
+      content: 'No active session in this thread',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await command.editReply(`Failed to redo: ${getClient.message}`)
+    return
+  }
+
+  try {
+    const client = getClient()
+
+    // Fetch session to check existing revert state
+    const sessionResponse = await client.session.get({
+      sessionID: sessionId,
+      directory: workingDirectory,
+    })
+    if (sessionResponse.error) {
+      await command.editReply(`Failed to redo: ${JSON.stringify(sessionResponse.error)}`)
+      return
+    }
+
+    const revertMessageID = sessionResponse.data?.revert?.messageID
+    if (!revertMessageID) {
+      await command.editReply('Nothing to redo - no previous undo found')
+      return
+    }
+
+    // Abort if session is busy before reverting/unreverting — both enforce
+    // assertNotBusy in OpenCode and would fail with "Session is busy"
+    const redoStatusResponse = await client.session.status({
+      directory: workingDirectory,
+    })
+    const redoSessionStatus = redoStatusResponse.data?.[sessionId]
+    if (redoSessionStatus && redoSessionStatus.type !== 'idle') {
+      await client.session.abort({
+        sessionID: sessionId,
+        directory: workingDirectory,
+      }).catch((error) => {
+        logger.warn(`[REDO] abort failed for ${sessionId}`, error)
+      })
+      await waitForSessionIdle({
+        client,
+        sessionId,
+        directory: workingDirectory,
+      })
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 500)
+    })
+
+    // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
+    // find the next user message after the current revert point. If one exists,
+    // move the revert cursor forward to it (one step redo). If none exists,
+    // fully unrevert — we're at the end of the message history.
+    const messagesResponse = await client.session.messages({
+      sessionID: sessionId,
+      directory: workingDirectory,
+    })
+    if (messagesResponse.error) {
+      await command.editReply(`Failed to redo: ${JSON.stringify(messagesResponse.error)}`)
+      return
+    }
+    const userMessages = (messagesResponse.data ?? []).filter((m) => {
+      return m.info.role === 'user'
+    })
+    const nextMessage = userMessages.find((m) => {
+      return m.info.id > revertMessageID
+    })
+
+    if (!nextMessage) {
+      // No more messages after revert point — fully unrevert
+      const response = await client.session.unrevert({
+        sessionID: sessionId,
+        directory: workingDirectory,
+      })
+      if (response.error) {
+        await command.editReply(
+          `Failed to redo: ${JSON.stringify(response.error)}`,
+        )
+        return
+      }
+      await command.editReply('Restored - session fully back to previous state')
+      logger.log(`Session ${sessionId} unrevert completed`)
+      return
+    }
+
+    // Move revert cursor forward one step to the next user message
+    const response = await client.session.revert({
+      sessionID: sessionId,
+      directory: workingDirectory,
+      messageID: nextMessage.info.id,
+    })
+
+    if (response.error) {
+      await command.editReply(
+        `Failed to redo: ${JSON.stringify(response.error)}`,
+      )
+      return
+    }
+
+    await command.editReply('Restored one step forward')
+    logger.log(`Session ${sessionId} redo: moved revert to ${nextMessage.info.id}`)
+  } catch (error) {
+    logger.error('[REDO] Error:', error)
+    await command.editReply(
+      `Failed to redo: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}

package/src/commands/unset-model.ts

@@ -0,0 +1,173 @@
+// /unset-model-override command - Remove model overrides and use default instead.
+
+import {
+  ChatInputCommandInteraction,
+  ChannelType,
+  type ThreadChannel,
+  type TextChannel,
+  MessageFlags,
+} from 'discord.js'
+import {
+  getChannelModel,
+  getSessionModel,
+  getThreadSession,
+  clearSessionModel,
+} from '../database.js'
+import { getPrisma } from '../db.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
+import { getRuntime } from '../session-handler/thread-session-runtime.js'
+import { getCurrentModelInfo } from './model.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const unsetModelLogger = createLogger(LogPrefix.MODEL)
+
+function formatModelSource(type: string, agentName?: string): string {
+  switch (type) {
+    case 'session':
+      return 'session override'
+    case 'agent':
+      return `agent "${agentName}"`
+    case 'channel':
+      return 'channel override'
+    case 'global':
+      return 'global default'
+    case 'opencode-config':
+    case 'opencode-recent':
+    case 'opencode-provider-default':
+      return 'opencode default'
+    default:
+      return 'none'
+  }
+}
+
+/**
+ * Handle the /unset-model-override slash command.
+ * In thread: clears session override if exists, otherwise channel override.
+ * In channel: clears channel override.
+ */
+export async function handleUnsetModelCommand({
+  interaction,
+  appId,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  unsetModelLogger.log('[UNSET-MODEL] handleUnsetModelCommand called')
+
+  await interaction.deferReply({ flags: MessageFlags.Ephemeral })
+
+  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 targetChannelId: string
+  let sessionId: string | undefined
+
+  if (isThread) {
+    const thread = channel as ThreadChannel
+    const textChannel = await resolveTextChannel(thread)
+    const metadata = await getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    targetChannelId = textChannel?.id || channel.id
+    sessionId = await getThreadSession(thread.id)
+  } else if (channel.type === ChannelType.GuildText) {
+    const textChannel = channel as TextChannel
+    const metadata = await getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    targetChannelId = channel.id
+  } else {
+    await interaction.editReply({
+      content: 'This command can only be used in text channels or threads',
+    })
+    return
+  }
+
+  if (!projectDirectory) {
+    await interaction.editReply({
+      content: 'This channel is not configured with a project directory',
+    })
+    return
+  }
+
+  // Check what overrides exist
+  const [sessionPref, channelPref] = await Promise.all([
+    sessionId ? getSessionModel(sessionId) : Promise.resolve(undefined),
+    getChannelModel(targetChannelId),
+  ])
+
+  let clearedType: 'session' | 'channel' | null = null
+  let clearedModel: string | undefined
+
+  if (isThread && sessionId && sessionPref) {
+    // In thread with session override: clear session
+    await clearSessionModel(sessionId)
+    clearedType = 'session'
+    clearedModel = sessionPref.modelId
+    unsetModelLogger.log(`[UNSET-MODEL] Cleared session model for ${sessionId}`)
+  } else if (channelPref) {
+    // Clear channel override
+    const prisma = await getPrisma()
+    await prisma.channel_models.deleteMany({
+      where: { channel_id: targetChannelId },
+    })
+    clearedType = 'channel'
+    clearedModel = channelPref.modelId
+    unsetModelLogger.log(
+      `[UNSET-MODEL] Cleared channel model for ${targetChannelId}`,
+    )
+  } else {
+    await interaction.editReply({
+      content: 'No model override to clear.',
+    })
+    return
+  }
+
+  // Get the new model that will be used
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  let newModelText = 'unknown'
+
+  if (!(getClient instanceof Error)) {
+    const newModelInfo = await getCurrentModelInfo({
+      sessionId,
+      channelId: targetChannelId,
+      appId,
+      getClient,
+    })
+
+    newModelText =
+      newModelInfo.type === 'none'
+        ? 'none'
+        : `\`${newModelInfo.model}\` (${formatModelSource(newModelInfo.type, 'agentName' in newModelInfo ? newModelInfo.agentName : undefined)})`
+  }
+
+  // Check if there's a running request and abort+retry with new model (only for session changes in threads)
+  let retried = false
+  if (isThread && clearedType === 'session' && sessionId) {
+    const runtime = getRuntime(channel.id)
+    if (runtime) {
+      retried = await runtime.retryLastUserPrompt()
+    }
+  }
+
+  const clearedTypeText = clearedType === 'session' ? 'Session' : 'Channel'
+  const retriedText = retried
+    ? '\n_Restarting current request with new model..._'
+    : ''
+
+  await interaction.editReply({
+    content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}${retriedText}`,
+  })
+}

package/src/commands/upgrade.ts

@@ -0,0 +1,52 @@
+// /upgrade-and-restart command - Upgrade kimaki to the latest version and restart the bot.
+// Checks npm for a newer version, installs it globally, then spawns a new kimaki process.
+// The new process kills the old one on startup (kimaki's single-instance lock).
+
+import type { CommandContext } from './types.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { getCurrentVersion, upgrade } from '../upgrade.js'
+import { spawn } from 'node:child_process'
+
+const logger = createLogger(LogPrefix.CLI)
+
+export async function handleUpgradeAndRestartCommand({
+  command,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  logger.log('[UPGRADE] /upgrade-and-restart triggered')
+
+  try {
+    const currentVersion = getCurrentVersion()
+    const newVersion = await upgrade()
+
+    if (!newVersion) {
+      await command.editReply({
+        content: `Already on latest version: **v${currentVersion}**`,
+      })
+      return
+    }
+
+    await command.editReply({
+      content: `Upgraded kimaki **v${currentVersion}** -> **v${newVersion}**. Restarting bot...`,
+    })
+
+    // Spawning bare `kimaki` works even if the user originally ran via npx/bunx:
+    // `npm i -g kimaki@latest` creates a global bin link, and npx resolves
+    // local -> global -> cache -> registry, so it prefers the global install.
+    // bunx shares the same global cache, so it also picks up the new version.
+    const child = spawn('kimaki', process.argv.slice(2), {
+      shell: true,
+      stdio: 'ignore',
+      detached: true,
+    })
+    child.unref()
+    logger.debug('Started new background kimaki')
+  } catch (error) {
+    logger.error('[UPGRADE] Failed:', error)
+    await command.editReply({
+      content: `Upgrade failed: ${error instanceof Error ? error.message : String(error)}`,
+    })
+  }
+}