@otto-assistant/otto 0.1.2 → 0.7.16

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/vscode.ts

@@ -0,0 +1,342 @@
+import crypto from 'node:crypto'
+import { spawn, type ChildProcess } from 'node:child_process'
+import net from 'node:net'
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import { TunnelClient } from 'traforo/client'
+import type { CommandContext } from './types.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('VSCODE')
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS
+const MAX_SESSION_MINUTES = 30
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000
+const TUNNEL_BASE_DOMAIN = 'otto.dev'
+const TUNNEL_ID_BYTES = 16
+const READY_TIMEOUT_MS = 60_000
+const LOCAL_HOST = '127.0.0.1'
+
+export type VscodeSession = {
+  coderaftProcess: ChildProcess
+  tunnelClient: TunnelClient
+  url: string
+  workingDirectory: string
+  startedBy: string
+  startedAt: number
+  timeoutTimer: ReturnType<typeof setTimeout>
+}
+
+const activeSessions = new Map<string, VscodeSession>()
+
+export function createVscodeTunnelId(): string {
+  return crypto.randomBytes(TUNNEL_ID_BYTES).toString('hex')
+}
+
+export function buildCoderaftArgs({
+  port,
+  workingDirectory,
+}: {
+  port: number
+  workingDirectory: string
+}): string[] {
+  return [
+    'coderaft',
+    '--port',
+    String(port),
+    '--host',
+    LOCAL_HOST,
+    '--without-connection-token',
+    '--disable-workspace-trust',
+    '--default-folder',
+    workingDirectory,
+  ]
+}
+
+function createPortWaiter({
+  port,
+  process: proc,
+  timeoutMs,
+}: {
+  port: number
+  process: ChildProcess
+  timeoutMs: number
+}): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const maxAttempts = Math.ceil(timeoutMs / 100)
+    let attempts = 0
+
+    const check = (): void => {
+      if (proc.exitCode !== null) {
+        reject(new Error(`coderaft exited with code ${proc.exitCode} before becoming ready`))
+        return
+      }
+
+      const socket = net.createConnection(port, LOCAL_HOST)
+      socket.on('connect', () => {
+        socket.destroy()
+        resolve()
+      })
+      socket.on('error', () => {
+        socket.destroy()
+        attempts += 1
+        if (attempts >= maxAttempts) {
+          reject(new Error(`Port ${port} not reachable after ${timeoutMs}ms`))
+          return
+        }
+        setTimeout(check, 100)
+      })
+    }
+
+    check()
+  })
+}
+
+function getAvailablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.on('error', reject)
+    server.listen(0, LOCAL_HOST, () => {
+      const address = server.address()
+      if (!address || typeof address === 'string') {
+        server.close(() => {
+          reject(new Error('Failed to resolve an available port'))
+        })
+        return
+      }
+      const port = address.port
+      server.close((error) => {
+        if (error) {
+          reject(error)
+          return
+        }
+        resolve(port)
+      })
+    })
+  })
+}
+
+function cleanupSession(session: VscodeSession): void {
+  clearTimeout(session.timeoutTimer)
+  try {
+    session.tunnelClient.close()
+  } catch {}
+  if (session.coderaftProcess.exitCode === null) {
+    try {
+      session.coderaftProcess.kill('SIGTERM')
+    } catch {}
+  }
+}
+
+export function getActiveVscodeSession({ sessionKey }: { sessionKey: string }): VscodeSession | undefined {
+  return activeSessions.get(sessionKey)
+}
+
+export function stopVscode({ sessionKey }: { sessionKey: string }): boolean {
+  const session = activeSessions.get(sessionKey)
+  if (!session) {
+    return false
+  }
+
+  activeSessions.delete(sessionKey)
+  cleanupSession(session)
+  logger.log(`VS Code stopped (key: ${sessionKey})`)
+  return true
+}
+
+export async function startVscode({
+  sessionKey,
+  startedBy,
+  workingDirectory,
+}: {
+  sessionKey: string
+  startedBy: string
+  workingDirectory: string
+}): Promise<VscodeSession> {
+  const existing = activeSessions.get(sessionKey)
+  if (existing) {
+    return existing
+  }
+
+  const port = await getAvailablePort()
+  const tunnelId = createVscodeTunnelId()
+  const args = buildCoderaftArgs({
+    port,
+    workingDirectory,
+  })
+  const coderaftProcess = spawn('bunx', args, {
+    cwd: workingDirectory,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      PORT: String(port),
+    },
+  })
+
+  coderaftProcess.stdout?.on('data', (data: Buffer) => {
+    logger.log(data.toString().trim())
+  })
+  coderaftProcess.stderr?.on('data', (data: Buffer) => {
+    logger.error(data.toString().trim())
+  })
+
+  try {
+    await createPortWaiter({
+      port,
+      process: coderaftProcess,
+      timeoutMs: READY_TIMEOUT_MS,
+    })
+  } catch (error) {
+    if (coderaftProcess.exitCode === null) {
+      coderaftProcess.kill('SIGTERM')
+    }
+    throw error
+  }
+
+  const tunnelClient = new TunnelClient({
+    localPort: port,
+    localHost: LOCAL_HOST,
+    tunnelId,
+    baseDomain: TUNNEL_BASE_DOMAIN,
+  })
+
+  try {
+    await Promise.race([
+      tunnelClient.connect(),
+      new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error('Tunnel connection timed out after 15s'))
+        }, 15_000)
+      }),
+    ])
+  } catch (error) {
+    tunnelClient.close()
+    if (coderaftProcess.exitCode === null) {
+      coderaftProcess.kill('SIGTERM')
+    }
+    throw error
+  }
+
+  const url = tunnelClient.url
+
+  const timeoutTimer = setTimeout(() => {
+    logger.log(`VS Code auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`)
+    stopVscode({ sessionKey })
+  }, MAX_SESSION_MS)
+  timeoutTimer.unref()
+
+  const session: VscodeSession = {
+    coderaftProcess,
+    tunnelClient,
+    url,
+    workingDirectory,
+    startedBy,
+    startedAt: Date.now(),
+    timeoutTimer,
+  }
+
+  coderaftProcess.once('exit', (code, signal) => {
+    const current = activeSessions.get(sessionKey)
+    if (current !== session) {
+      return
+    }
+    logger.log(`VS Code process exited (key: ${sessionKey}, code: ${code}, signal: ${signal ?? 'none'})`)
+    stopVscode({ sessionKey })
+  })
+
+  activeSessions.set(sessionKey, session)
+  logger.log(`VS Code started by ${startedBy}: ${url}`)
+  return session
+}
+
+export async function handleVscodeCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel.',
+      flags: SECURE_REPLY_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 a text channel or thread.',
+      flags: SECURE_REPLY_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: SECURE_REPLY_FLAGS,
+    })
+    return
+  }
+
+  await command.deferReply({ flags: SECURE_REPLY_FLAGS })
+
+  const sessionKey = channel.id
+  const existing = getActiveVscodeSession({ sessionKey })
+  if (existing) {
+    await command.editReply({
+      content:
+        `VS Code is already running for this thread. ` +
+        `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes from startup.\n` +
+        `${existing.url}`,
+    })
+    return
+  }
+
+  try {
+    const session = await startVscode({
+      sessionKey,
+      startedBy: command.user.tag,
+      workingDirectory: resolved.workingDirectory,
+    })
+    await command.editReply({
+      content:
+        `VS Code started for \`${session.workingDirectory}\`. ` +
+        `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes, so open it before it expires.\n` +
+        `${session.url}`,
+    })
+  } catch (error) {
+    logger.error('Failed to start VS Code:', error)
+    await command.editReply({
+      content: `Failed to start VS Code: ${error instanceof Error ? error.message : String(error)}`,
+    })
+  }
+}
+
+export function cleanupAllVscodeSessions(): void {
+  for (const sessionKey of activeSessions.keys()) {
+    stopVscode({ sessionKey })
+  }
+}
+
+function onProcessExit(): void {
+  cleanupAllVscodeSessions()
+}
+
+process.on('SIGINT', onProcessExit)
+process.on('SIGTERM', onProcessExit)
+process.on('exit', onProcessExit)