@otto-assistant/otto 0.1.1 → 0.7.15

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.otto.dev' }),
+    )
+
+    expect(url.origin).toBe('https://novnc.com')
+    expect(url.searchParams.get('host')).toBe(
+      '0123456789abcdef-tunnel.otto.dev',
+    )
+    expect(url.searchParams.get('port')).toBe('443')
+    expect(url.searchParams.get('encrypt')).toBe('1')
+  })
+})