@otto-assistant/otto 0.1.2 → 0.7.15

package/src/commands/abort.ts

@@ -0,0 +1,89 @@
+// /abort command - Abort the current OpenCode request in this thread.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { getRuntime } from '../session-handler/thread-session-runtime.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.ABORT)
+
+export async function handleAbortCommand({
+  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)
+
+  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
+  }
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+
+  if (!resolved) {
+    await command.editReply('Could not determine project directory for this channel')
+    return
+  }
+
+  const { projectDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.editReply('No active session in this thread')
+    return
+  }
+
+  // abortActiveRun delegates to session.abort(), run settlement stays event-driven.
+  const runtime = getRuntime(channel.id)
+  if (runtime) {
+    runtime.abortActiveRun('user-requested')
+  } else {
+    // No runtime but session exists — fall back to direct API abort
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (getClient instanceof Error) {
+      await command.editReply(`Failed to abort: ${getClient.message}`)
+      return
+    }
+    try {
+      await getClient().session.abort({ sessionID: sessionId })
+    } catch (error) {
+      logger.error('[ABORT] API abort failed:', error)
+    }
+  }
+
+  await command.editReply('Request **aborted**')
+  logger.log(`Session ${sessionId} aborted by user`)
+}

package/src/commands/action-buttons.ts

@@ -0,0 +1,364 @@
+// Action button tool handler - Shows Discord buttons for quick model actions.
+// Used by the otto_action_buttons tool to render up to 3 buttons and route
+// button clicks back into the session as a new user message.
+
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  MessageFlags,
+  type ButtonInteraction,
+  type ThreadChannel,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import { getThreadSession } from '../database.js'
+import {
+  NOTIFY_MESSAGE_FLAGS,
+  SILENT_MESSAGE_FLAGS,
+  resolveWorkingDirectory,
+  sendThreadMessage,
+} from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+import { notifyError } from '../sentry.js'
+import {
+  getOrCreateRuntime,
+} from '../session-handler/thread-session-runtime.js'
+
+const logger = createLogger('ACT_BTN')
+const PENDING_TTL_MS = 24 * 60 * 60 * 1000
+
+export type ActionButtonColor = 'white' | 'blue' | 'green' | 'red'
+
+export type ActionButtonOption = {
+  label: string
+  color?: ActionButtonColor
+}
+
+export type ActionButtonsRequest = {
+  sessionId: string
+  threadId: string
+  directory: string
+  buttons: ActionButtonOption[]
+}
+
+type PendingActionButtonsContext = {
+  sessionId: string
+  directory: string
+  thread: ThreadChannel
+  buttons: ActionButtonOption[]
+  contextHash: string
+  messageId?: string
+  resolved: boolean
+  timer: ReturnType<typeof setTimeout>
+}
+
+export const pendingActionButtonContexts = new Map<
+  string,
+  PendingActionButtonsContext
+>()
+const pendingActionButtonRequests = new Map<string, ActionButtonsRequest>()
+const pendingActionButtonRequestWaiters = new Map<
+  string,
+  (request: ActionButtonsRequest) => void
+>()
+
+export function queueActionButtonsRequest(request: ActionButtonsRequest): void {
+  pendingActionButtonRequests.set(request.sessionId, request)
+  const waiter = pendingActionButtonRequestWaiters.get(request.sessionId)
+  if (!waiter) {
+    return
+  }
+  pendingActionButtonRequestWaiters.delete(request.sessionId)
+  waiter(request)
+}
+
+export async function waitForQueuedActionButtonsRequest({
+  sessionId,
+  timeoutMs,
+}: {
+  sessionId: string
+  timeoutMs: number
+}): Promise<ActionButtonsRequest | undefined> {
+  const queued = pendingActionButtonRequests.get(sessionId)
+  if (queued) {
+    pendingActionButtonRequests.delete(sessionId)
+    return queued
+  }
+
+  return await new Promise<ActionButtonsRequest | undefined>((resolve) => {
+    const timeout = setTimeout(() => {
+      const currentWaiter = pendingActionButtonRequestWaiters.get(sessionId)
+      if (!currentWaiter || currentWaiter !== onRequest) {
+        return
+      }
+      pendingActionButtonRequestWaiters.delete(sessionId)
+      resolve(undefined)
+    }, timeoutMs)
+
+    const onRequest = (request: ActionButtonsRequest) => {
+      clearTimeout(timeout)
+      pendingActionButtonRequests.delete(sessionId)
+      resolve(request)
+    }
+
+    pendingActionButtonRequestWaiters.set(sessionId, onRequest)
+  })
+}
+
+function toButtonStyle(color?: ActionButtonColor): ButtonStyle {
+  if (color === 'blue') {
+    return ButtonStyle.Primary
+  }
+  if (color === 'green') {
+    return ButtonStyle.Success
+  }
+  if (color === 'red') {
+    return ButtonStyle.Danger
+  }
+  return ButtonStyle.Secondary
+}
+
+function resolveContext(context: PendingActionButtonsContext): boolean {
+  if (context.resolved) {
+    return false
+  }
+  context.resolved = true
+  clearTimeout(context.timer)
+  pendingActionButtonContexts.delete(context.contextHash)
+  return true
+}
+
+function updateButtonMessage({
+  context,
+  status,
+}: {
+  context: PendingActionButtonsContext
+  status: string
+}): void {
+  if (!context.messageId) {
+    return
+  }
+  context.thread.messages
+    .fetch(context.messageId)
+    .then((message) => {
+      return message.edit({
+        content: `**Action Required**\n${status}`,
+        components: [],
+      })
+    })
+    .catch(() => {})
+}
+
+async function sendClickedActionToModel({
+  interaction,
+  thread,
+  prompt,
+}: {
+  interaction: ButtonInteraction
+  thread: ThreadChannel
+  prompt: string
+}): Promise<void> {
+  const resolved = await resolveWorkingDirectory({ channel: thread })
+  if (!resolved) {
+    throw new Error('Could not resolve project directory for thread')
+  }
+
+  const username = interaction.user.globalName || interaction.user.username
+
+  // Action button clicks use opencode queue mode.
+  const runtime = getOrCreateRuntime({
+    threadId: thread.id,
+    thread,
+    projectDirectory: resolved.projectDirectory,
+    sdkDirectory: resolved.workingDirectory,
+    channelId: thread.parentId || thread.id,
+  })
+  await runtime.enqueueIncoming({
+    prompt,
+    userId: interaction.user.id,
+    username,
+    mode: 'opencode',
+  })
+}
+
+export async function showActionButtons({
+  thread,
+  sessionId,
+  directory,
+  buttons,
+  silent,
+}: {
+  thread: ThreadChannel
+  sessionId: string
+  directory: string
+  buttons: ActionButtonOption[]
+  /** Suppress notification when queue has pending items */
+  silent?: boolean
+}): Promise<void> {
+  const safeButtons = buttons
+    .slice(0, 3)
+    .map((button) => {
+      return {
+        label: button.label.trim().slice(0, 80),
+        color: button.color,
+      }
+    })
+    .filter((button) => {
+      return button.label.length > 0
+    })
+
+  if (safeButtons.length === 0) {
+    throw new Error('No valid buttons to display')
+  }
+
+  const contextHash = crypto.randomBytes(8).toString('hex')
+  const timer = setTimeout(() => {
+    const current = pendingActionButtonContexts.get(contextHash)
+    if (!current || current.resolved) {
+      return
+    }
+    resolveContext(current)
+    updateButtonMessage({ context: current, status: '_Expired_' })
+  }, PENDING_TTL_MS)
+
+  const context: PendingActionButtonsContext = {
+    sessionId,
+    directory,
+    thread,
+    buttons: safeButtons,
+    contextHash,
+    resolved: false,
+    timer,
+  }
+
+  pendingActionButtonContexts.set(contextHash, context)
+
+  const row = new ActionRowBuilder<ButtonBuilder>().addComponents(
+    ...safeButtons.map((button, index) => {
+      return new ButtonBuilder()
+        .setCustomId(`action_button:${contextHash}:${index}`)
+        .setLabel(button.label)
+        .setStyle(toButtonStyle(button.color))
+    }),
+  )
+
+  try {
+    const message = await thread.send({
+      content: '**Action Required**',
+      components: [row],
+      flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
+    })
+
+    context.messageId = message.id
+    logger.log(
+      `Showed ${safeButtons.length} action button(s) for session ${sessionId}`,
+    )
+  } catch (error) {
+    clearTimeout(timer)
+    pendingActionButtonContexts.delete(contextHash)
+    throw new Error('Failed to send action buttons', { cause: error })
+  }
+}
+
+export async function handleActionButton(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('action_button:')) {
+    return
+  }
+
+  const [, contextHash, indexPart] = customId.split(':')
+  if (!contextHash || !indexPart) {
+    await interaction.reply({
+      content: 'Invalid action button.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const context = pendingActionButtonContexts.get(contextHash)
+  if (!context || context.resolved) {
+    await interaction.reply({
+      content: 'This action is no longer available.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const buttonIndex = Number.parseInt(indexPart, 10)
+  const button = context.buttons[buttonIndex]
+  if (!button) {
+    await interaction.reply({
+      content: 'This action is no longer available.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await interaction.deferUpdate()
+  const claimed = resolveContext(context)
+  if (!claimed) {
+    return
+  }
+
+  const thread = interaction.channel
+  if (!thread?.isThread()) {
+    logger.warn('[ACTION] Button clicked outside thread channel')
+    await interaction.editReply({
+      content: '**Action Required**\n_This action is no longer available._',
+      components: [],
+    })
+    return
+  }
+
+  const currentSessionId = await getThreadSession(thread.id)
+  if (!currentSessionId || currentSessionId !== context.sessionId) {
+    await interaction.editReply({
+      content: '**Action Required**\n_Expired due to session change._',
+      components: [],
+    })
+    return
+  }
+
+  await interaction.editReply({
+    content: `**Action Required**\n_Selected: ${button.label}_`,
+    components: [],
+  })
+
+  const prompt = `User clicked: ${button.label}`
+
+  try {
+    await sendClickedActionToModel({
+      interaction,
+      thread,
+      prompt,
+    })
+  } catch (error) {
+    logger.error('[ACTION] Failed to send click to model:', error)
+    void notifyError(error, 'Action button click send to model failed')
+    await sendThreadMessage(
+      thread,
+      `Failed to send action click: ${error instanceof Error ? error.message : String(error)}`,
+      { flags: NOTIFY_MESSAGE_FLAGS },
+    )
+  }
+}
+
+/**
+ * Dismiss pending action buttons for a thread (e.g. user sent a new message).
+ * Removes buttons from the message and cleans up context.
+ */
+export function cancelPendingActionButtons(threadId: string): boolean {
+  for (const [, ctx] of pendingActionButtonContexts) {
+    if (ctx.thread.id !== threadId) {
+      continue
+    }
+    if (!resolveContext(ctx)) {
+      continue
+    }
+    updateButtonMessage({ context: ctx, status: '_Buttons dismissed._' })
+    return true
+  }
+  return false
+}

package/src/commands/add-dir.test.ts

@@ -0,0 +1,154 @@
+// Tests for /add-dir permission helpers.
+
+import { describe, expect, test } from 'vitest'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import {
+  buildAddDirPermissionRules,
+  resolveDirectoryPermissionPattern,
+} from './add-dir.js'
+import {
+  buildExternalDirectoryPermissionRules,
+  buildSessionPermissions,
+} from '../opencode.js'
+
+describe('resolveDirectoryPermissionPattern', () => {
+  test('resolves relative directories against the working directory', () => {
+    const root = path.resolve(process.cwd(), 'tmp', 'add-dir-test')
+    const nested = path.join(root, 'nested')
+    fs.mkdirSync(nested, { recursive: true })
+
+    const result = resolveDirectoryPermissionPattern({
+      input: './nested',
+      workingDirectory: root,
+    })
+
+    expect(result).toBe(nested.replaceAll('\\', '/'))
+  })
+
+  test('supports allowing every directory with *', () => {
+    expect(
+      resolveDirectoryPermissionPattern({
+        input: ' * ',
+        workingDirectory: '/repo',
+      }),
+    ).toBe('*')
+
+    expect(
+      buildAddDirPermissionRules({
+        resolvedPattern: '*',
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "allow",
+          "pattern": "*",
+          "permission": "external_directory",
+        },
+      ]
+    `)
+  })
+
+  test('builds allow rules for a specific directory', () => {
+    expect(
+      buildAddDirPermissionRules({
+        resolvedPattern: '/repo/extra',
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "allow",
+          "pattern": "/repo/extra",
+          "permission": "external_directory",
+        },
+        {
+          "action": "allow",
+          "pattern": "/repo/extra/*",
+          "permission": "external_directory",
+        },
+      ]
+    `)
+  })
+
+  test('builds deny rules for a specific directory', () => {
+    expect(
+      buildExternalDirectoryPermissionRules({
+        resolvedPattern: '/repo',
+        action: 'deny',
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "/repo",
+          "permission": "external_directory",
+        },
+        {
+          "action": "deny",
+          "pattern": "/repo/*",
+          "permission": "external_directory",
+        },
+      ]
+    `)
+  })
+
+  test('worktree sessions deny the original checkout last', () => {
+    expect(
+      buildSessionPermissions({
+        directory: '/Users/me/.otto/worktrees/hash/feature',
+        originalRepoDirectory: '/Users/me/project',
+      }).slice(-2),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "/Users/me/project",
+          "permission": "external_directory",
+        },
+        {
+          "action": "deny",
+          "pattern": "/Users/me/project/*",
+          "permission": "external_directory",
+        },
+      ]
+    `)
+  })
+
+  test('pre-allows common toolchain caches under home with ~ patterns', () => {
+    const home = os.homedir().replaceAll('\\', '/')
+    expect(
+      buildSessionPermissions({
+        directory: '/Users/me/project',
+      }).filter((rule) => {
+        return [
+          `${home}/.cache/zig`,
+          `${home}/.cargo`,
+          `${home}/.cache/go-build`,
+          `${home}/go/pkg`,
+        ].includes(rule.pattern)
+      }),
+    ).toEqual([
+      {
+        permission: 'external_directory',
+        pattern: `${home}/.cache/zig`,
+        action: 'allow',
+      },
+      {
+        permission: 'external_directory',
+        pattern: `${home}/.cargo`,
+        action: 'allow',
+      },
+      {
+        permission: 'external_directory',
+        pattern: `${home}/.cache/go-build`,
+        action: 'allow',
+      },
+      {
+        permission: 'external_directory',
+        pattern: `${home}/go/pkg`,
+        action: 'allow',
+      },
+    ])
+  })
+})