@otto-assistant/bridge 0.4.92

package/src/commands/file-upload.ts

@@ -0,0 +1,389 @@
+// File upload tool handler - Shows Discord modal with FileUploadBuilder.
+// When the AI uses the kimaki_file_upload tool, the plugin inserts a row into
+// the ipc_requests DB table. The bot polls this table, picks up the request,
+// and shows a button in the thread. User clicks it to open a modal with a
+// native file picker. Uploaded files are downloaded to the project directory.
+// The bot writes file paths back to ipc_requests.response, and the plugin
+// polls until the response appears.
+
+import {
+  ButtonBuilder,
+  ButtonStyle,
+  ActionRowBuilder,
+  ModalBuilder,
+  FileUploadBuilder,
+  LabelBuilder,
+  ComponentType,
+  type ButtonInteraction,
+  type ModalSubmitInteraction,
+  type ThreadChannel,
+  MessageFlags,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { createLogger, LogPrefix } from '../logger.js'
+import { notifyError } from '../sentry.js'
+import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
+
+const logger = createLogger(LogPrefix.FILE_UPLOAD)
+
+// 5 minute TTL for pending contexts - if user doesn't click within this time,
+// clean up the context and resolve with empty array to unblock the plugin tool
+const PENDING_TTL_MS = 5 * 60 * 1000
+
+export type FileUploadRequest = {
+  sessionId: string
+  threadId: string
+  directory: string
+  prompt: string
+  maxFiles: number
+}
+
+type PendingFileUploadContext = {
+  sessionId: string
+  directory: string
+  thread: ThreadChannel
+  prompt: string
+  maxFiles: number
+  contextHash: string
+  resolve: (filePaths: string[]) => void
+  reject: (error: Error) => void
+  messageId?: string
+  resolved: boolean
+  timer: ReturnType<typeof setTimeout>
+}
+
+export const pendingFileUploadContexts = new Map<
+  string,
+  PendingFileUploadContext
+>()
+
+/**
+ * Sanitize an attachment filename to prevent path traversal.
+ * Strips directory separators, .., and null bytes from the name.
+ * Prepends a short random prefix to avoid collisions between uploads.
+ */
+function sanitizeFilename(name: string): string {
+  // Extract just the base name (strips any directory components)
+  let sanitized = path.basename(name)
+  // Remove null bytes and other dangerous characters
+  sanitized = sanitized.replace(/[\x00]/g, '')
+  // If somehow still empty or just dots, give it a safe name
+  if (!sanitized || sanitized === '.' || sanitized === '..') {
+    sanitized = 'upload'
+  }
+  // Prefix with short random id to avoid collisions
+  const prefix = crypto.randomBytes(4).toString('hex')
+  return `${prefix}-${sanitized}`
+}
+
+/**
+ * Safely resolve a pending context exactly once. Prevents double-resolve from
+ * cancel/submit races by checking the `resolved` flag.
+ */
+function resolveContext(
+  context: PendingFileUploadContext,
+  filePaths: string[],
+): boolean {
+  if (context.resolved) {
+    return false
+  }
+  context.resolved = true
+  clearTimeout(context.timer)
+  pendingFileUploadContexts.delete(context.contextHash)
+  context.resolve(filePaths)
+  return true
+}
+
+/**
+ * Show a button in the thread that opens a file upload modal when clicked.
+ * Returns a promise that resolves with the downloaded file paths.
+ */
+export function showFileUploadButton({
+  thread,
+  sessionId,
+  directory,
+  prompt,
+  maxFiles,
+}: {
+  thread: ThreadChannel
+  sessionId: string
+  directory: string
+  prompt: string
+  maxFiles: number
+}): Promise<string[]> {
+  return new Promise((resolve, reject) => {
+    const contextHash = crypto.randomBytes(8).toString('hex')
+
+    // TTL timer: auto-cleanup if user never clicks the button
+    const timer = setTimeout(() => {
+      const ctx = pendingFileUploadContexts.get(contextHash)
+      if (ctx && !ctx.resolved) {
+        logger.log(
+          `File upload timed out for session ${sessionId}, hash=${contextHash}`,
+        )
+        resolveContext(ctx, [])
+        // Remove button from message
+        if (ctx.messageId) {
+          ctx.thread.messages
+            .fetch(ctx.messageId)
+            .then((msg) => {
+              return msg.edit({
+                content: `**File Upload Requested**\n${prompt.slice(0, 1900)}\n_Timed out_`,
+                components: [],
+              })
+            })
+            .catch(() => {})
+        }
+      }
+    }, PENDING_TTL_MS)
+
+    const context: PendingFileUploadContext = {
+      sessionId,
+      directory,
+      thread,
+      prompt,
+      maxFiles,
+      contextHash,
+      resolve,
+      reject,
+      resolved: false,
+      timer,
+    }
+
+    pendingFileUploadContexts.set(contextHash, context)
+
+    const uploadButton = new ButtonBuilder()
+      .setCustomId(`file_upload_btn:${contextHash}`)
+      .setLabel('Upload Files')
+      .setStyle(ButtonStyle.Primary)
+
+    const actionRow = new ActionRowBuilder<ButtonBuilder>().addComponents(
+      uploadButton,
+    )
+
+    thread
+      .send({
+        content: `**File Upload Requested**\n${prompt.slice(0, 1900)}`,
+        components: [actionRow],
+        flags: NOTIFY_MESSAGE_FLAGS,
+      })
+      .then((msg) => {
+        context.messageId = msg.id
+        logger.log(
+          `Showed file upload button for session ${sessionId}, hash=${contextHash}`,
+        )
+      })
+      .catch((err) => {
+        clearTimeout(timer)
+        pendingFileUploadContexts.delete(contextHash)
+        reject(new Error('Failed to send file upload button', { cause: err }))
+      })
+  })
+}
+
+/**
+ * Handle the file upload button click - opens a modal with FileUploadBuilder.
+ */
+export async function handleFileUploadButton(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('file_upload_btn:')) {
+    return
+  }
+
+  const contextHash = customId.replace('file_upload_btn:', '')
+  const context = pendingFileUploadContexts.get(contextHash)
+
+  if (!context || context.resolved) {
+    await interaction.reply({
+      content: 'This file upload request has expired.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const fileUpload = new FileUploadBuilder()
+    .setCustomId('uploaded_files')
+    .setMinValues(1)
+    .setMaxValues(context.maxFiles)
+
+  const label = new LabelBuilder()
+    .setLabel('Files')
+    .setDescription(context.prompt.slice(0, 100))
+    .setFileUploadComponent(fileUpload)
+
+  const modal = new ModalBuilder()
+    .setCustomId(`file_upload_modal:${contextHash}`)
+    .setTitle('Upload Files')
+    .addLabelComponents(label)
+
+  await interaction.showModal(modal)
+}
+
+/**
+ * Handle the modal submission - download files and resolve the pending promise.
+ */
+export async function handleFileUploadModalSubmit(
+  interaction: ModalSubmitInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('file_upload_modal:')) {
+    return
+  }
+
+  const contextHash = customId.replace('file_upload_modal:', '')
+  const context = pendingFileUploadContexts.get(contextHash)
+
+  if (!context || context.resolved) {
+    await interaction.reply({
+      content: 'This file upload request has expired.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  try {
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral })
+
+    // File upload data is nested in the LabelModalData -> FileUploadModalData
+    const fileField = interaction.fields.getField(
+      'uploaded_files',
+      ComponentType.FileUpload,
+    )
+    const attachments = fileField.attachments
+    if (!attachments || attachments.size === 0) {
+      await interaction.editReply({ content: 'No files were uploaded.' })
+      updateButtonMessage(context, '_No files uploaded_')
+      resolveContext(context, [])
+      return
+    }
+
+    const uploadsDir = path.join(context.directory, 'uploads')
+    fs.mkdirSync(uploadsDir, { recursive: true })
+
+    const downloadedPaths: string[] = []
+    const errors: string[] = []
+
+    for (const [, attachment] of attachments) {
+      // Check if context was cancelled (e.g. user sent new message) while
+      // we were downloading previous files - stop downloading more
+      if (context.resolved) {
+        break
+      }
+      try {
+        const response = await fetch(attachment.url)
+        if (!response.ok) {
+          errors.push(
+            `Failed to download ${attachment.name}: HTTP ${response.status}`,
+          )
+          continue
+        }
+        const buffer = Buffer.from(await response.arrayBuffer())
+        const safeName = sanitizeFilename(attachment.name)
+        const filePath = path.join(uploadsDir, safeName)
+        fs.writeFileSync(filePath, buffer)
+        downloadedPaths.push(filePath)
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        errors.push(`Failed to download ${attachment.name}: ${msg}`)
+      }
+    }
+
+    // If context was resolved by cancel/timeout during download, don't try to
+    // resolve again - just update the ephemeral reply
+    if (context.resolved) {
+      await interaction.editReply({ content: 'Upload was cancelled.' })
+      return
+    }
+
+    const fileNames = downloadedPaths.map((p) => {
+      return path.basename(p)
+    })
+    updateButtonMessage(
+      context,
+      downloadedPaths.length > 0
+        ? `Uploaded: ${fileNames.join(', ')}`
+        : '_Upload failed_',
+    )
+
+    const summary = (() => {
+      if (downloadedPaths.length > 0 && errors.length === 0) {
+        return `Uploaded ${downloadedPaths.length} file(s) successfully.`
+      }
+      if (downloadedPaths.length > 0 && errors.length > 0) {
+        return `Uploaded ${downloadedPaths.length} file(s). Errors: ${errors.join('; ')}`
+      }
+      return `Upload failed: ${errors.join('; ')}`
+    })()
+
+    await interaction.editReply({ content: summary })
+
+    resolveContext(context, downloadedPaths)
+
+    logger.log(
+      `File upload completed for session ${context.sessionId}: ${downloadedPaths.length} files`,
+    )
+  } catch (err) {
+    // Ensure context is always resolved even on unexpected errors
+    // so the plugin tool doesn't hang indefinitely
+    logger.error('Error in file upload modal submit:', err)
+    void notifyError(err, 'File upload modal submit error')
+    resolveContext(context, [])
+  }
+}
+
+/**
+ * Best-effort update of the original button message (remove button, append status).
+ */
+function updateButtonMessage(
+  context: PendingFileUploadContext,
+  status: string,
+): void {
+  if (!context.messageId) {
+    return
+  }
+  context.thread.messages
+    .fetch(context.messageId)
+    .then((msg) => {
+      return msg.edit({
+        content: `**File Upload Requested**\n${context.prompt.slice(0, 1900)}\n${status}`,
+        components: [],
+      })
+    })
+    .catch(() => {})
+}
+
+/**
+ * Cancel ALL pending file uploads for a thread (e.g. when user sends a new message).
+ */
+export async function cancelPendingFileUpload(
+  threadId: string,
+): Promise<boolean> {
+  const toCancel: PendingFileUploadContext[] = []
+  for (const [, ctx] of pendingFileUploadContexts) {
+    if (ctx.thread.id === threadId) {
+      toCancel.push(ctx)
+    }
+  }
+
+  if (toCancel.length === 0) {
+    return false
+  }
+
+  let cancelled = 0
+  for (const context of toCancel) {
+    const didResolve = resolveContext(context, [])
+    if (didResolve) {
+      updateButtonMessage(context, '_Cancelled - user sent a new message_')
+      cancelled++
+    }
+  }
+
+  if (cancelled > 0) {
+    logger.log(`Cancelled ${cancelled} file upload(s) for thread ${threadId}`)
+  }
+  return cancelled > 0
+}

package/src/commands/fork.ts

@@ -0,0 +1,321 @@
+// /fork command - Fork the session from a past user message.
+
+import {
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+  StringSelectMenuBuilder,
+  ActionRowBuilder,
+  ChannelType,
+  ThreadAutoArchiveDuration,
+  type ThreadChannel,
+  MessageFlags,
+} from 'discord.js'
+import {
+  getThreadSession,
+  setThreadSession,
+  setPartMessagesBatch,
+} from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  resolveTextChannel,
+  sendThreadMessage,
+} from '../discord-utils.js'
+import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import * as errore from 'errore'
+
+const sessionLogger = createLogger(LogPrefix.SESSION)
+const forkLogger = createLogger(LogPrefix.FORK)
+
+export async function handleForkCommand(
+  interaction: ChatInputCommandInteraction,
+): Promise<void> {
+  const channel = interaction.channel
+
+  if (!channel) {
+    await interaction.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await interaction.reply({
+      content:
+        'This command can only be used in a thread with an active session',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as ThreadChannel,
+  })
+
+  if (!resolved) {
+    await interaction.reply({
+      content: 'Could not determine project directory for this channel',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const { projectDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await interaction.reply({
+      content: 'No active session in this thread',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  // Defer reply before API calls to avoid 3-second timeout
+  await interaction.deferReply({ flags: MessageFlags.Ephemeral })
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await interaction.editReply({
+      content: `Failed to load messages: ${getClient.message}`,
+    })
+    return
+  }
+
+  try {
+    const messagesResponse = await getClient().session.messages({
+      sessionID: sessionId,
+    })
+
+    if (!messagesResponse.data) {
+      await interaction.editReply({
+        content: 'Failed to fetch session messages',
+      })
+      return
+    }
+
+    const userMessages = messagesResponse.data.filter(
+      (m: { info: { role: string } }) => m.info.role === 'user',
+    )
+
+    if (userMessages.length === 0) {
+      await interaction.editReply({
+        content: 'No user messages found in this session',
+      })
+      return
+    }
+
+    const recentMessages = userMessages.slice(-25)
+
+    // Filter out synthetic parts (branch context, memory reminders, etc.)
+    // injected by the opencode plugin — they clutter the dropdown preview.
+    const options = recentMessages
+      .map(
+        (
+          m: {
+            parts: Array<{ type: string; text?: string; synthetic?: boolean }>
+            info: { id: string; time: { created: number } }
+          },
+          index: number,
+        ) => {
+          const textPart = m.parts.find(
+            (p) => p.type === 'text' && !p.synthetic,
+          ) as { type: 'text'; text: string } | undefined
+          if (!textPart?.text) {
+            return null
+          }
+          const preview = textPart.text.slice(0, 80)
+          const label = `${index + 1}. ${preview}${preview.length >= 80 ? '...' : ''}`
+
+          return {
+            label: label.slice(0, 100),
+            value: m.info.id,
+            description: new Date(m.info.time.created)
+              .toLocaleString()
+              .slice(0, 50),
+          }
+        },
+      )
+      .filter(
+        (o): o is NonNullable<typeof o> => o !== null,
+      )
+
+    const selectMenu = new StringSelectMenuBuilder()
+      // Discord component custom_id max length is 100 chars.
+      // Avoid embedding long directory paths (or base64 of them) in the custom ID.
+      // handleForkSelectMenu resolves the directory from the current thread instead.
+      .setCustomId(`fork_select:${sessionId}`)
+      .setPlaceholder('Select a message to fork from')
+      .addOptions(options)
+
+    const actionRow =
+      new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+    await interaction.editReply({
+      content:
+        '**Fork Session**\nSelect the user message to fork from. The forked session will continue as if you had not sent that message:',
+      components: [actionRow],
+    })
+  } catch (error) {
+    forkLogger.error('Error loading messages:', error)
+    await interaction.editReply({
+      content: `Failed to load messages: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}
+
+export async function handleForkSelectMenu(
+  interaction: StringSelectMenuInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+
+  if (!customId.startsWith('fork_select:')) {
+    return
+  }
+
+  const [, sessionId] = customId.split(':')
+  if (!sessionId) {
+    await interaction.reply({
+      content: 'Invalid selection data',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+  const selectedMessageId = interaction.values[0]
+
+  if (!selectedMessageId) {
+    await interaction.reply({
+      content: 'No message selected',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await interaction.deferReply()
+
+  const threadChannel = interaction.channel
+  if (!threadChannel) {
+    await interaction.editReply('Could not access thread channel')
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: threadChannel as ThreadChannel,
+  })
+  if (!resolved) {
+    await interaction.editReply(
+      'Could not determine project directory for this channel',
+    )
+    return
+  }
+
+  const { projectDirectory } = resolved
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await interaction.editReply(`Failed to fork session: ${getClient.message}`)
+    return
+  }
+
+  try {
+    const forkResponse = await getClient().session.fork({
+      sessionID: sessionId,
+      messageID: selectedMessageId,
+    })
+
+    if (!forkResponse.data) {
+      await interaction.editReply('Failed to fork session')
+      return
+    }
+
+    const forkedSession = forkResponse.data
+    const parentChannel = interaction.channel
+
+    if (
+      !parentChannel ||
+      ![
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+      ].includes(parentChannel.type)
+    ) {
+      await interaction.editReply('Could not access parent channel')
+      return
+    }
+
+    const textChannel = await resolveTextChannel(parentChannel as ThreadChannel)
+
+    if (!textChannel) {
+      await interaction.editReply('Could not resolve parent text channel')
+      return
+    }
+
+    const thread = await textChannel.threads.create({
+      name: `Fork: ${forkedSession.title}`.slice(0, 100),
+      autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+      reason: `Forked from session ${sessionId}`,
+    })
+
+    // Claim the forked 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, forkedSession.id)
+
+    // Add user to thread so it appears in their sidebar
+    await thread.members.add(interaction.user.id)
+
+    sessionLogger.log(
+      `Created forked session ${forkedSession.id} in thread ${thread.id}`,
+    )
+
+    await sendThreadMessage(
+      thread,
+      `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\``,
+    )
+
+    // Fetch and display the last assistant messages from the forked session
+    const messagesResponse = await getClient().session.messages({
+      sessionID: forkedSession.id,
+    })
+
+    if (messagesResponse.data) {
+      const { chunks } = collectSessionChunks({
+        messages: messagesResponse.data,
+        limit: 30,
+      })
+      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,
+          })),
+        )
+      }
+    }
+
+    await sendThreadMessage(
+      thread,
+      `You can now continue the conversation from this point.`,
+    )
+
+    await interaction.editReply(
+      `Session forked! Continue in ${thread.toString()}`,
+    )
+  } catch (error) {
+    forkLogger.error('Error forking session:', error)
+    await interaction.editReply(
+      `Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}