@otto-assistant/bridge 0.4.92

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}`,
+  })
+}

package/src/commands/resume.ts

@@ -0,0 +1,230 @@
+// /resume command - Resume an existing OpenCode session.
+
+import {
+  ChannelType,
+  ThreadAutoArchiveDuration,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import fs from 'node:fs'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import {
+  getChannelDirectory,
+  setThreadSession,
+  setPartMessagesBatch,
+  getAllThreadSessionIds,
+} from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  sendThreadMessage,
+  resolveProjectDirectoryFromAutocomplete,
+  NOTIFY_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import * as errore from 'errore'
+
+const logger = createLogger(LogPrefix.RESUME)
+
+export async function handleResumeCommand({
+  command,
+}: CommandContext): Promise<void> {
+  await command.deferReply()
+
+  const sessionId = command.options.getString('session', true)
+  const channel = command.channel
+
+  const isThread =
+    channel &&
+    [
+      ChannelType.PublicThread,
+      ChannelType.PrivateThread,
+      ChannelType.AnnouncementThread,
+    ].includes(channel.type)
+
+  if (isThread) {
+    await command.editReply(
+      'This command can only be used in project channels, not threads',
+    )
+    return
+  }
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in text channels')
+    return
+  }
+
+  const textChannel = channel as TextChannel
+
+  const channelConfig = await getChannelDirectory(textChannel.id)
+  const projectDirectory = channelConfig?.directory
+
+  if (!projectDirectory) {
+    await command.editReply(
+      'This channel is not configured with a project directory',
+    )
+    return
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    await command.editReply(`Directory does not exist: ${projectDirectory}`)
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await command.editReply(getClient.message)
+      return
+    }
+
+    const sessionResponse = await getClient().session.get({
+      sessionID: sessionId,
+    })
+
+    if (!sessionResponse.data) {
+      await command.editReply('Session not found')
+      return
+    }
+
+    const sessionTitle = sessionResponse.data.title
+
+    const thread = await textChannel.threads.create({
+      name: `Resume: ${sessionTitle}`.slice(0, 100),
+      autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+      reason: `Resuming session ${sessionId}`,
+    })
+
+    // Claim the resumed session immediately so external polling does not race
+    // and create a duplicate Sync thread before the rest of this setup runs.
+    await setThreadSession(thread.id, sessionId)
+
+    // Add user to thread so it appears in their sidebar
+    await thread.members.add(command.user.id)
+
+    logger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`)
+
+    const messagesResponse = await getClient().session.messages({
+      sessionID: sessionId,
+    })
+
+    if (!messagesResponse.data) {
+      throw new Error('Failed to fetch session messages')
+    }
+
+    const messages = messagesResponse.data
+
+    await command.editReply(
+      `Resumed session "${sessionTitle}" in ${thread.toString()}`,
+    )
+
+    await sendThreadMessage(
+      thread,
+      `**Resumed session:** ${sessionTitle}\n**Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`,
+    )
+
+    try {
+      const { chunks, skippedCount } = collectSessionChunks({
+        messages,
+        limit: 30,
+      })
+
+      if (skippedCount > 0) {
+        await sendThreadMessage(
+          thread,
+          `*Skipped ${skippedCount} older assistant parts...*`,
+        )
+      }
+
+      const batched = batchChunksForDiscord(chunks)
+      for (const batch of batched) {
+        const discordMessage = await sendThreadMessage(thread, batch.content)
+        await setPartMessagesBatch(
+          batch.partIds.map((partId) => ({
+            partId,
+            messageId: discordMessage.id,
+            threadId: thread.id,
+          })),
+        )
+      }
+
+      const messageCount = messages.length
+
+      await sendThreadMessage(
+        thread,
+        `**Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`,
+      )
+    } catch (sendError) {
+      logger.error('[RESUME] Error sending messages to thread:', sendError)
+      await sendThreadMessage(
+        thread,
+        `Failed to load message history, but session is connected. You can still send new messages.`,
+        { flags: NOTIFY_MESSAGE_FLAGS },
+      )
+    }
+  } catch (error) {
+    logger.error('[RESUME] Error:', error)
+    await command.editReply(
+      `Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleResumeAutocomplete({
+  interaction,
+}: AutocompleteContext): Promise<void> {
+  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
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await interaction.respond([])
+      return
+    }
+
+    const sessionsResponse = await getClient().session.list()
+    if (!sessionsResponse.data) {
+      await interaction.respond([])
+      return
+    }
+
+    const existingSessionIds = new Set(await getAllThreadSessionIds())
+
+    const sessions = sessionsResponse.data
+      .filter((session) => !existingSessionIds.has(session.id))
+      .filter((session) =>
+        session.title.toLowerCase().includes(focusedValue.toLowerCase()),
+      )
+      .slice(0, 25)
+      .map((session) => {
+        const dateStr = new Date(session.time.updated).toLocaleString()
+        const suffix = ` (${dateStr})`
+        const maxTitleLength = 100 - suffix.length
+
+        let title = session.title
+        if (title.length > maxTitleLength) {
+          title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…'
+        }
+
+        return {
+          name: `${title}${suffix}`,
+          value: session.id,
+        }
+      })
+
+    await interaction.respond(sessions)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching sessions:', error)
+    await interaction.respond([])
+  }
+}

package/src/commands/run-command.ts

@@ -0,0 +1,123 @@
+// /run-shell-command command - Run an arbitrary shell command in the project directory.
+// Resolves the project directory from the channel and executes the command with it as cwd.
+// Also used by the ! prefix shortcut in discord messages (e.g. "!ls -la").
+// Messages starting with ! are intercepted before session handling and routed here.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import { execAsync } from '../worktrees.js'
+import { stripAnsi } from '../utils.js'
+
+const logger = createLogger(LogPrefix.INTERACTION)
+
+const MAX_OUTPUT_CHARS = 1900
+
+export async function runShellCommand({
+  command,
+  directory,
+}: {
+  command: string
+  directory: string
+}): Promise<string> {
+  try {
+    const { stdout, stderr } = await execAsync(command, { cwd: directory })
+    const output = stripAnsi([stdout, stderr].filter(Boolean).join('\n').trim())
+
+    const header = `\`${command}\` exited with 0`
+    if (!output) {
+      return header
+    }
+    return formatOutput(output, header)
+  } catch (error) {
+    const execError = error as {
+      stdout?: string
+      stderr?: string
+      message?: string
+      code?: number | string
+    }
+    const output = stripAnsi(
+      [execError.stdout, execError.stderr].filter(Boolean).join('\n').trim(),
+    )
+    const exitCode = execError.code ?? 1
+    logger.error(
+      `[RUN-COMMAND] Command "${command}" exited with ${exitCode}:`,
+      error,
+    )
+
+    const header = `\`${command}\` exited with ${exitCode}`
+    return formatOutput(output || execError.message || 'Unknown error', header)
+  }
+}
+
+export async function handleRunCommand({
+  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 a text channel or thread.',
+      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 input = command.options.getString('command', true)
+
+  await command.deferReply()
+
+  const result = await runShellCommand({
+    command: input,
+    directory: resolved.workingDirectory,
+  })
+  await command.editReply({ content: result })
+}
+
+function formatOutput(output: string, header: string): string {
+  // Reserve space for header + newline + code block delimiters (```\n...\n```)
+  const overhead = header.length + 1 + 3 + 1 + 1 + 3 // header\n```\n...\n```
+  const maxContent = MAX_OUTPUT_CHARS - overhead
+  const truncated =
+    output.length > maxContent
+      ? output.slice(0, maxContent - 14) + '\n... truncated'
+      : output
+  return `${header}\n\`\`\`\n${truncated}\n\`\`\``
+}

package/src/commands/screenshare.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'vitest'
+import { buildNoVncUrl, createScreenshareTunnelId } from './screenshare.js'
+
+describe('screenshare security defaults', () => {
+  test('generates a 128-bit tunnel id', () => {
+    const ids = new Set(
+      Array.from({ length: 32 }, () => {
+        return createScreenshareTunnelId()
+      }),
+    )
+
+    expect(ids.size).toBe(32)
+    for (const id of ids) {
+      expect(id).toMatch(/^[0-9a-f]{32}$/)
+    }
+  })
+
+  test('builds a secure noVNC URL', () => {
+    const url = new URL(
+      buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.kimaki.xyz' }),
+    )
+
+    expect(url.origin).toBe('https://novnc.com')
+    expect(url.searchParams.get('host')).toBe(
+      '0123456789abcdef-tunnel.kimaki.xyz',
+    )
+    expect(url.searchParams.get('port')).toBe('443')
+    expect(url.searchParams.get('encrypt')).toBe('1')
+  })
+})