@otto-assistant/otto 0.1.2 → 0.7.16

package/src/commands/queue.ts

@@ -0,0 +1,293 @@
+// 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 {
+  getRuntime,
+  getOrCreateRuntime,
+} from '../session-handler/thread-session-runtime.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { notifyError } from '../sentry.js'
+import { store } from '../store.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 thread = channel as ThreadChannel
+  const sessionId = await getThreadSession(thread.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
+  }
+
+  const resolved = await resolveWorkingDirectory({ channel: thread })
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const runtime = getOrCreateRuntime({
+    threadId: thread.id,
+    thread,
+    projectDirectory: resolved.projectDirectory,
+    sdkDirectory: resolved.workingDirectory,
+    channelId: thread.parentId || thread.id,
+    appId,
+  })
+
+  // /queue explicitly uses otto local queue mode.
+  const enqueueResult = await runtime.enqueueIncoming({
+    prompt: message,
+    userId: command.user.id,
+    username: command.user.displayName,
+    appId,
+    mode: 'local-queue',
+  })
+
+  const responseText = enqueueResult.queued
+    ? `Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`
+    : `» **${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`
+
+  await command.reply({
+    content: responseText,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+}
+
+export async function handleClearQueueCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+  const position = command.options.getInteger('position') ?? undefined
+
+  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 runtime = getRuntime(channel.id)
+  const queueLength = runtime?.getQueueLength() ?? 0
+
+  if (queueLength === 0) {
+    await command.reply({
+      content: 'No messages in queue',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  if (position !== undefined) {
+    const removed = runtime?.removeQueuePosition(position)
+    if (!removed) {
+      await command.reply({
+        content: `No queued message at position ${position}`,
+        flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+      })
+      return
+    }
+
+    await command.reply({
+      content: `Cleared queued message at position ${position}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    logger.log(
+      `[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`,
+    )
+    return
+  }
+
+  runtime?.clearQueue()
+
+  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 = store.getState().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}`
+  const thread = channel as ThreadChannel
+
+  const resolved = await resolveWorkingDirectory({ channel: thread })
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const runtime = getOrCreateRuntime({
+    threadId: thread.id,
+    thread,
+    projectDirectory: resolved.projectDirectory,
+    sdkDirectory: resolved.workingDirectory,
+    channelId: thread.parentId || thread.id,
+    appId,
+  })
+
+  // /queue-command explicitly uses otto local queue mode.
+  const enqueueResult = await runtime.enqueueIncoming({
+    prompt: '',
+    userId: command.user.id,
+    username: command.user.displayName,
+    appId,
+    command: commandPayload,
+    mode: 'local-queue',
+  })
+
+  const responseText = enqueueResult.queued
+    ? `Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`
+    : `» **${command.user.displayName}:** ${displayText}`
+
+  await command.reply({
+    content: responseText,
+    flags: 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 = store.getState().registeredUserCommands
+    .filter((cmd) => {
+      return cmd.name.toLowerCase().includes(query)
+    })
+    .slice(0, 25)
+    .map((cmd) => ({
+      name: `/${cmd.name} [${cmd.source === 'skill' ? 'skill' : cmd.source === 'mcp' ? 'mcp' : 'cmd'}] - ${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()
+
+  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([])
+  }
+}

package/src/commands/restart-opencode-server.ts

@@ -0,0 +1,162 @@
+// /restart-opencode-server command - Restart the single shared opencode server
+// and re-register Discord slash commands.
+// Used for resolving opencode state issues, internal bugs, refreshing auth state,
+// plugins, and picking up new/changed slash commands or agents. Aborts in-progress
+// sessions in this channel before restarting. Note: since there is one shared server,
+// this restart affects all projects. Other runtimes reconnect through their listener
+// backoff loop once the shared server comes back.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type ThreadChannel,
+  type TextChannel,
+} from 'discord.js'
+import type { Command as OpencodeCommand } from '@opencode-ai/sdk/v2'
+import type { CommandContext } from './types.js'
+import { initializeOpencodeForDirectory, restartOpencodeServer } from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { disposeRuntimesForDirectory } from '../session-handler/thread-session-runtime.js'
+import { registerCommands, type AgentInfo } from '../discord-command-registration.js'
+
+const logger = createLogger(LogPrefix.OPENCODE)
+
+export async function handleRestartOpencodeServerCommand({
+  command,
+  appId,
+}: 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
+
+  // Defer reply since restart may take a moment
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  // Dispose all runtimes for this directory/channel scope.
+  // disposeRuntimesForDirectory aborts active runs, kills listeners, and
+  // removes runtimes from the registry. Scoped by channelId so runtimes
+  // in other channels sharing the same project directory are not affected.
+  const parentChannelId = isThread
+    ? (channel as ThreadChannel).parentId
+    : channel.id
+  const abortedCount = disposeRuntimesForDirectory({
+    directory: projectDirectory,
+    channelId: parentChannelId || undefined,
+  })
+
+  logger.log(`[RESTART] Restarting shared opencode server`)
+
+  const result = await restartOpencodeServer()
+
+  if (result instanceof Error) {
+    logger.error('[RESTART] Failed:', result)
+    await command.editReply({
+      content: `Failed to restart opencode server: ${result.message}`,
+    })
+    return
+  }
+
+  const abortMsg =
+    abortedCount > 0
+      ? ` (aborted ${abortedCount} active session${abortedCount > 1 ? 's' : ''})`
+      : ''
+  await command.editReply({
+    content: `Opencode server **restarted** successfully${abortMsg}. Re-registering slash commands...`,
+  })
+  logger.log('[RESTART] Shared opencode server restarted')
+
+  // Re-register Discord slash commands after restart so new/changed
+  // commands, agents, and plugins are picked up immediately.
+  const token = command.client.token
+  if (!token) {
+    logger.error('[RESTART] No bot token available, skipping command registration')
+    await command.editReply({
+      content: `Opencode server **restarted**${abortMsg}, but slash command re-registration skipped (no bot token)`,
+    })
+    return
+  }
+  const guildIds = [...command.client.guilds.cache.keys()]
+
+  const opencodeResult = await initializeOpencodeForDirectory(projectDirectory)
+  const [userCommands, agents]: [OpencodeCommand[], AgentInfo[]] =
+    await (async (): Promise<[OpencodeCommand[], AgentInfo[]]> => {
+      if (opencodeResult instanceof Error) {
+        logger.warn('[RESTART] OpenCode init failed, registering without user commands:', opencodeResult.message)
+        return [[], []]
+      }
+      const getClient = opencodeResult
+      const [cmds, ags] = await Promise.all([
+        getClient()
+          .command.list({ directory: projectDirectory })
+          .then((r) => r.data || [])
+          .catch((e) => {
+            logger.warn('[RESTART] Failed to load user commands:', e instanceof Error ? e.stack : String(e))
+            return [] as OpencodeCommand[]
+          }),
+        getClient()
+          .app.agents({ directory: projectDirectory })
+          .then((r) => r.data || [])
+          .catch((e) => {
+            logger.warn('[RESTART] Failed to load agents:', e instanceof Error ? e.stack : String(e))
+            return [] as AgentInfo[]
+          }),
+      ])
+      return [cmds, ags]
+    })()
+
+  const registerResult = await registerCommands({ token, appId, guildIds, userCommands, agents })
+    .then(() => null)
+    .catch((e: unknown) => (e instanceof Error ? e : new Error(String(e))))
+  if (registerResult instanceof Error) {
+    logger.error('[RESTART] Failed to re-register commands:', registerResult.message)
+    await command.editReply({
+      content: `Opencode server **restarted**${abortMsg}, but slash command re-registration failed: ${registerResult.message}`,
+    })
+    return
+  }
+
+  logger.log('[RESTART] Slash commands re-registered')
+  await command.editReply({
+    content: `Opencode server **restarted** and slash commands **re-registered**${abortMsg}`,
+  })
+}