@otto-assistant/otto 0.1.1 → 0.7.15

package/src/commands/discord-commands-group-c.test.ts

@@ -0,0 +1,882 @@
+import { ChannelType } from 'discord.js'
+import fs from 'node:fs'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+// Helper to extract first arg from mock.calls without tuple type issues
+function firstCallArg(mockCalls: { at(n: number): unknown }[]): unknown | undefined {
+  return (mockCalls.at(0) as unknown[] | undefined)?.[0]
+}
+function callArg(mockCalls: { at(n: number): unknown }[], index: number): unknown | undefined {
+  return (mockCalls.at(index) as unknown[] | undefined)?.[0]
+}
+
+const mocks = vi.hoisted(() => ({
+  findChannelsByDirectory: vi.fn(),
+  getAllTextChannelDirectories: vi.fn(),
+  deleteChannelDirectoriesByDirectory: vi.fn(),
+  getThreadSession: vi.fn(),
+  listScheduledTasks: vi.fn(),
+  cancelScheduledTask: vi.fn(),
+  initializeOpencodeForDirectory: vi.fn(),
+  getOpencodeClient: vi.fn(),
+  buildExternalDirectoryPermissionRules: vi.fn(),
+  getOpencodeServerPort: vi.fn(),
+  createProjectChannels: vi.fn(),
+  getProjectsDir: vi.fn(),
+  getOrCreateRuntime: vi.fn(),
+  resolveWorkingDirectory: vi.fn(),
+  resolveTextChannel: vi.fn(),
+  getOttoMetadata: vi.fn(),
+  sendThreadMessage: vi.fn(),
+  splitTablesFromMarkdown: vi.fn(),
+  buildHtmlActionCustomId: vi.fn(),
+  cancelHtmlActionsForOwner: vi.fn(),
+  registerHtmlAction: vi.fn(),
+  execAsync: vi.fn(),
+  stripAnsi: vi.fn(),
+  upgrade: vi.fn(),
+  getCurrentVersion: vi.fn(),
+  writeHeapSnapshot: vi.fn(),
+  notifyError: vi.fn(),
+  spawn: vi.fn(),
+}))
+
+vi.mock('../database.js', () => ({
+  findChannelsByDirectory: mocks.findChannelsByDirectory,
+  getAllTextChannelDirectories: mocks.getAllTextChannelDirectories,
+  deleteChannelDirectoriesByDirectory: mocks.deleteChannelDirectoriesByDirectory,
+  getThreadSession: mocks.getThreadSession,
+  listScheduledTasks: mocks.listScheduledTasks,
+  cancelScheduledTask: mocks.cancelScheduledTask,
+}))
+
+vi.mock('../opencode.js', () => ({
+  initializeOpencodeForDirectory: mocks.initializeOpencodeForDirectory,
+  getOpencodeClient: mocks.getOpencodeClient,
+  buildExternalDirectoryPermissionRules: mocks.buildExternalDirectoryPermissionRules,
+  getOpencodeServerPort: mocks.getOpencodeServerPort,
+}))
+
+vi.mock('../channel-management.js', () => ({
+  createProjectChannels: mocks.createProjectChannels,
+}))
+
+vi.mock('../config.js', () => ({
+  getProjectsDir: mocks.getProjectsDir,
+}))
+
+vi.mock('../session-handler/thread-session-runtime.js', () => ({
+  getOrCreateRuntime: mocks.getOrCreateRuntime,
+}))
+
+vi.mock('../discord-utils.js', () => ({
+  SILENT_MESSAGE_FLAGS: 1 << 12,
+  NOTIFY_MESSAGE_FLAGS: 1 << 13,
+  resolveWorkingDirectory: mocks.resolveWorkingDirectory,
+  resolveTextChannel: mocks.resolveTextChannel,
+  getOttoMetadata: mocks.getOttoMetadata,
+  sendThreadMessage: mocks.sendThreadMessage,
+}))
+
+vi.mock('../format-tables.js', () => ({
+  splitTablesFromMarkdown: mocks.splitTablesFromMarkdown,
+}))
+
+vi.mock('../html-actions.js', () => ({
+  buildHtmlActionCustomId: mocks.buildHtmlActionCustomId,
+  cancelHtmlActionsForOwner: mocks.cancelHtmlActionsForOwner,
+  registerHtmlAction: mocks.registerHtmlAction,
+}))
+
+vi.mock('../worktrees.js', () => ({
+  execAsync: mocks.execAsync,
+}))
+
+vi.mock('../utils.js', async () => {
+  const actual = await vi.importActual('../utils.js')
+  return {
+    ...actual,
+    stripAnsi: mocks.stripAnsi,
+  }
+})
+
+vi.mock('../upgrade.js', () => ({
+  getCurrentVersion: mocks.getCurrentVersion,
+  upgrade: mocks.upgrade,
+}))
+
+vi.mock('../heap-monitor.js', () => ({
+  writeHeapSnapshot: mocks.writeHeapSnapshot,
+}))
+
+vi.mock('../sentry.js', () => ({
+  notifyError: mocks.notifyError,
+}))
+
+vi.mock('node:child_process', async () => {
+  const actual = await vi.importActual('node:child_process')
+  return {
+    ...actual,
+    spawn: mocks.spawn,
+  }
+})
+
+import { handleAddProjectCommand } from './add-project.js'
+import { handleRemoveProjectCommand } from './remove-project.js'
+import { handleCreateNewProjectCommand } from './create-new-project.js'
+import { handleAddDirCommand } from './add-dir.js'
+import { handleLoginCommand, handleLoginSelect } from './login.js'
+import { handleRunCommand, runShellCommand } from './run-command.js'
+import { buildNoVncUrl, createScreenshareTunnelId } from './screenshare.js'
+import {
+  formatServerLine,
+  handleMcpCommand,
+  handleMcpSelectMenu,
+  toggleActionLabel,
+} from './mcp.js'
+import { buildCoderaftArgs, createVscodeTunnelId, handleVscodeCommand } from './vscode.js'
+import { handleUpgradeAndRestartCommand } from './upgrade.js'
+import { handleMemorySnapshotCommand } from './memory-snapshot.js'
+import { handleTasksCommand } from './tasks.js'
+import {
+  cancelPendingFileUpload,
+  handleFileUploadButton,
+  handleFileUploadModalSubmit,
+  pendingFileUploadContexts,
+  showFileUploadButton,
+} from './file-upload.js'
+import {
+  handleActionButton,
+  pendingActionButtonContexts,
+  queueActionButtonsRequest,
+  showActionButtons,
+  waitForQueuedActionButtonsRequest,
+} from './action-buttons.js'
+import {
+  cancelPendingQuestion,
+  parseAskUserQuestionTool,
+  pendingQuestionContexts,
+  showAskUserQuestionDropdowns,
+} from './ask-question.js'
+
+function createCommandMock({
+  stringOptions = {},
+  booleanOptions = {},
+  guild,
+  channel,
+  guildId = 'guild-1',
+}: {
+  stringOptions?: Record<string, string>
+  booleanOptions?: Record<string, boolean>
+  guild?: unknown
+  channel?: unknown
+  guildId?: string | null
+}) {
+  const deferReply = vi.fn(async () => {})
+  const editReply = vi.fn(async () => {})
+  const reply = vi.fn(async () => {})
+
+  return {
+    deferReply,
+    editReply,
+    reply,
+    options: {
+      getString: vi.fn((name: string) => stringOptions[name] ?? null),
+      getBoolean: vi.fn((name: string) => booleanOptions[name] ?? null),
+    },
+    guild,
+    guildId,
+    channel,
+    channelId: 'channel-1',
+    client: { user: { username: 'otto-bot' } },
+    user: { id: 'user-1', tag: 'SerhiiD#0001', displayName: 'SerhiiD' },
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  pendingFileUploadContexts.clear()
+  pendingActionButtonContexts.clear()
+  pendingQuestionContexts.clear()
+  mocks.stripAnsi.mockImplementation((value: string) => value)
+  mocks.buildExternalDirectoryPermissionRules.mockImplementation(
+    ({ resolvedPattern, action }: { resolvedPattern: string; action: string }) => {
+      return [{ permission: 'external_directory', pattern: resolvedPattern, action }]
+    },
+  )
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('discord commands group c', () => {
+  test('add-project creates channels for selected project', async () => {
+    const command = createCommandMock({
+      stringOptions: { project: 'proj-1' },
+      guild: {},
+    })
+    mocks.initializeOpencodeForDirectory.mockResolvedValue(() => ({
+      project: {
+        list: vi.fn(async () => ({
+          data: [{ id: 'proj-1', worktree: process.cwd() }],
+        })),
+      },
+    }))
+    mocks.findChannelsByDirectory.mockResolvedValue([])
+    mocks.createProjectChannels.mockResolvedValue({
+      textChannelId: 'text-1',
+      voiceChannelId: 'voice-1',
+      channelName: 'project-1',
+    })
+
+    await handleAddProjectCommand({ command: command as never, appId: 'app-1' })
+
+    const normalizedAddProjectCalls = JSON.parse(
+      JSON.stringify(command.editReply.mock.calls).replaceAll(process.cwd(), '/repo/project'),
+    )
+
+    expect(normalizedAddProjectCalls).toMatchInlineSnapshot(`
+      [
+        [
+          "✅ Created channels for project:
+      📝 Text: <#text-1>
+      🔊 Voice: <#voice-1>
+      📁 Directory: \`/repo/project\`",
+        ],
+      ]
+    `)
+  })
+
+  test('remove-project reports missing channels for selected directory', async () => {
+    const command = createCommandMock({
+      stringOptions: { project: '/repo/project-x' },
+      guild: {},
+    })
+    mocks.findChannelsByDirectory.mockResolvedValue([])
+
+    await handleRemoveProjectCommand({ command: command as never, appId: 'app-1' })
+
+    expect(command.editReply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          "No channels found for directory: \`/repo/project-x\`",
+        ],
+      ]
+    `)
+  })
+
+  test('create-new-project uses name option and starts session thread', async () => {
+    const enqueueIncoming = vi.fn(async () => {})
+    const addMember = vi.fn(async () => {})
+    const startThread = vi.fn(async () => ({
+      id: 'thread-1',
+      members: { add: addMember },
+    }))
+    const send = vi.fn(async () => ({ startThread }))
+    const guildFetch = vi.fn(async () => ({ id: 'text-1', send }))
+
+    const command = createCommandMock({
+      stringOptions: { name: 'Cool Project' },
+      guild: { channels: { fetch: guildFetch } },
+      channel: { type: ChannelType.GuildText },
+    })
+
+    mocks.getProjectsDir.mockReturnValue('/tmp/projects')
+    mocks.createProjectChannels.mockResolvedValue({
+      textChannelId: 'text-1',
+      voiceChannelId: null,
+      channelName: 'cool-project',
+    })
+    mocks.getOrCreateRuntime.mockReturnValue({ enqueueIncoming })
+    mocks.execAsync.mockResolvedValue({ stdout: '', stderr: '' })
+    const existsSpy = vi.spyOn(fs, 'existsSync').mockImplementation((candidatePath) => {
+      return String(candidatePath) === '/tmp/projects/cool-project'
+    })
+
+    await handleCreateNewProjectCommand({ command: command as never, appId: 'app-1' })
+
+    existsSpy.mockRestore()
+
+    expect(callArg(command.editReply.mock.calls, 0)).toMatchInlineSnapshot(`"Project directory already exists: /tmp/projects/cool-project"`)
+  })
+
+  test('add-dir replies when no active session exists', async () => {
+    const command = createCommandMock({
+      channel: { id: 'thread-1', type: ChannelType.PublicThread },
+    })
+    mocks.resolveWorkingDirectory.mockResolvedValue({
+      projectDirectory: '/repo',
+      workingDirectory: '/repo',
+    })
+    mocks.getThreadSession.mockResolvedValue(null)
+
+    await handleAddDirCommand({ command: command as never, appId: 'app-1' })
+
+    expect(command.reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "No active session in this thread",
+            "flags": 4160,
+          },
+        ],
+      ]
+    `)
+  })
+
+  test('login command renders provider selector for auth flow', async () => {
+    const interaction = {
+      deferReply: vi.fn(async () => {}),
+      editReply: vi.fn(async () => {}),
+      channel: { id: 'text-1', type: ChannelType.GuildText },
+    }
+    mocks.getOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' })
+    mocks.initializeOpencodeForDirectory.mockResolvedValue(() => ({
+      provider: {
+        list: vi.fn(async () => ({
+          data: {
+            all: [
+              { id: 'openai', name: 'OpenAI' },
+              { id: 'anthropic', name: 'Anthropic' },
+            ],
+            connected: ['openai'],
+          },
+        })),
+      },
+    }))
+
+    await handleLoginCommand({ interaction: interaction as never, appId: 'app-1' })
+
+    const loginReply = callArg(interaction.editReply.mock.calls, 0)
+    const normalizedLoginReply = JSON.parse(
+      JSON.stringify(loginReply).replace(/login_select:[a-f0-9]+/g, 'login_select:<hash>'),
+    )
+
+    expect(normalizedLoginReply).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "components": [
+              {
+                "custom_id": "login_select:<hash>",
+                "options": [
+                  {
+                    "description": "Not connected",
+                    "label": "Anthropic",
+                    "value": "anthropic",
+                  },
+                  {
+                    "description": "Connected - select to re-authenticate",
+                    "label": "OpenAI ✓",
+                    "value": "openai",
+                  },
+                ],
+                "placeholder": "Select a provider to authenticate",
+                "type": 3,
+              },
+            ],
+            "type": 1,
+          },
+        ],
+        "content": "**Authenticate with Provider**
+      Select a provider:",
+      }
+    `)
+
+  })
+
+  test('login select reports expired context', async () => {
+    const interaction = {
+      customId: 'login_select:missing',
+      values: ['x'],
+      deferUpdate: vi.fn(async () => {}),
+      editReply: vi.fn(async () => {}),
+      deferred: false,
+      replied: false,
+    }
+
+    await handleLoginSelect(interaction as never)
+
+    expect(interaction.editReply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "components": [],
+            "content": "Selection expired. Please run /login again.",
+          },
+        ],
+      ]
+    `)
+  })
+
+  test('run-shell-command formats success output', async () => {
+    mocks.execAsync.mockResolvedValue({ stdout: 'hello', stderr: '' })
+    const result = await runShellCommand({ command: 'echo hello', directory: '/repo' })
+
+    expect(result).toMatchInlineSnapshot(`
+      "\`echo hello\` exited with 0
+      \`\`\`
+      hello
+      \`\`\`"
+    `)
+  })
+
+  test('run-command uses command option and writes result', async () => {
+    const command = createCommandMock({
+      stringOptions: { command: 'ls' },
+      channel: { type: ChannelType.PublicThread },
+    })
+    mocks.resolveWorkingDirectory.mockResolvedValue({
+      projectDirectory: '/repo',
+      workingDirectory: '/repo/wt',
+    })
+    mocks.execAsync.mockResolvedValue({ stdout: 'a.ts', stderr: '' })
+
+    await handleRunCommand({ command: command as never, appId: 'app-1' })
+
+    expect(callArg(command.editReply.mock.calls, 0)).toMatchInlineSnapshot(`
+      {
+        "content": "\`ls\` exited with 0
+      \`\`\`
+      a.ts
+      \`\`\`",
+      }
+    `)
+  })
+
+  test('run-command reports unresolved channel directory', async () => {
+    const command = createCommandMock({
+      stringOptions: { command: 'ls' },
+      channel: { type: ChannelType.PublicThread },
+    })
+    mocks.resolveWorkingDirectory.mockResolvedValue(null)
+
+    await handleRunCommand({ command: command as never, appId: 'app-1' })
+
+    expect(command.reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "Could not determine project directory for this channel.",
+            "flags": 4160,
+          },
+        ],
+      ]
+    `)
+  })
+
+  test('screenshare helpers keep secure defaults', () => {
+    const ids = Array.from({ length: 6 }, () => createScreenshareTunnelId())
+    const url = new URL(buildNoVncUrl({ tunnelHost: 'abcd-tunnel.otto.dev' }))
+
+    expect({
+      uniqueCount: new Set(ids).size,
+      matchesHex: ids.every((id) => /^[0-9a-f]{32}$/.test(id)),
+      host: url.searchParams.get('host'),
+      encrypted: url.searchParams.get('encrypt'),
+      autoconnect: url.searchParams.get('autoconnect'),
+    }).toMatchInlineSnapshot(`
+      {
+        "autoconnect": "true",
+        "encrypted": "1",
+        "host": "abcd-tunnel.otto.dev",
+        "matchesHex": true,
+        "uniqueCount": 6,
+      }
+    `)
+  })
+
+  test('mcp command lists servers with toggle menu', async () => {
+    const command = createCommandMock({
+      channel: { type: ChannelType.PublicThread },
+    })
+    mocks.resolveWorkingDirectory.mockResolvedValue({
+      projectDirectory: '/repo',
+      workingDirectory: '/repo',
+    })
+    mocks.initializeOpencodeForDirectory.mockResolvedValue(() => ({
+      mcp: {
+        status: vi.fn(async () => ({
+          data: {
+            github: { status: 'connected' },
+            notion: { status: 'failed', error: 'boom' },
+          },
+          error: null,
+        })),
+      },
+    }))
+
+    await handleMcpCommand({ command: command as never, appId: 'app-1' })
+
+    const mcpReply = callArg(command.editReply.mock.calls, 0)
+    const normalizedMcpReply = JSON.parse(
+      JSON.stringify(mcpReply).replace(/mcp_toggle:[a-f0-9]+/g, 'mcp_toggle:<hash>'),
+    )
+
+    expect(normalizedMcpReply).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "components": [
+              {
+                "custom_id": "mcp_toggle:<hash>",
+                "options": [
+                  {
+                    "description": "connected — click to disconnect",
+                    "label": "github",
+                    "value": "github",
+                  },
+                  {
+                    "description": "failed — click to reconnect",
+                    "label": "notion",
+                    "value": "notion",
+                  },
+                ],
+                "placeholder": "Select MCP server to toggle",
+                "type": 3,
+              },
+            ],
+            "type": 1,
+          },
+        ],
+        "content": "**MCP Servers** (project-wide)
+      \`connected\` **github**
+      \`failed\` **notion** — boom",
+      }
+    `)
+
+  })
+
+  test('mcp select returns expired message for unknown context', async () => {
+    const interaction = {
+      customId: 'mcp_toggle:missing',
+      values: ['github'],
+      deferUpdate: vi.fn(async () => {}),
+      editReply: vi.fn(async () => {}),
+    }
+
+    await handleMcpSelectMenu(interaction as never)
+
+    expect(callArg(interaction.editReply.mock.calls, 0)).toMatchInlineSnapshot(`
+      {
+        "components": [],
+        "content": "Session expired. Run \`/mcp\` again.",
+      }
+    `)
+  })
+
+  test('mcp helper formatting is stable', () => {
+    expect({
+      connected: formatServerLine({ name: 'github', status: 'connected' }),
+      failed: formatServerLine({ name: 'notion', status: 'failed', error: 'oops' }),
+      connectedAction: toggleActionLabel('connected'),
+      failedAction: toggleActionLabel('failed'),
+      disabledAction: toggleActionLabel('disabled'),
+    }).toMatchInlineSnapshot(`
+      {
+        "connected": "\`connected\` **github**",
+        "connectedAction": "disconnect",
+        "disabledAction": "connect",
+        "failed": "\`failed\` **notion** — oops",
+        "failedAction": "reconnect",
+      }
+    `)
+  })
+
+  test('vscode helper and command validation work', async () => {
+    expect(buildCoderaftArgs({ port: 1337, workingDirectory: '/repo' }))
+      .toMatchInlineSnapshot(`
+      [
+        "coderaft",
+        "--port",
+        "1337",
+        "--host",
+        "127.0.0.1",
+        "--without-connection-token",
+        "--disable-workspace-trust",
+        "--default-folder",
+        "/repo",
+      ]
+    `)
+    expect(createVscodeTunnelId()).toMatch(/^[0-9a-f]{32}$/)
+
+    const command = createCommandMock({ channel: { type: ChannelType.PublicThread } })
+    mocks.resolveWorkingDirectory.mockResolvedValue(null)
+
+    await handleVscodeCommand({ command: command as never, appId: 'app-1' })
+
+    expect(callArg(command.reply.mock.calls, 0)).toMatchInlineSnapshot(`
+      {
+        "content": "Could not determine project directory for this channel.",
+        "flags": 4160,
+      }
+    `)
+  })
+
+  test('upgrade-and-restart handles latest and error flows', async () => {
+    const command = createCommandMock({})
+    mocks.getCurrentVersion.mockReturnValue('1.0.0')
+    mocks.upgrade.mockResolvedValue(null)
+
+    await handleUpgradeAndRestartCommand({ command: command as never, appId: 'app-1' })
+
+    expect(callArg(command.editReply.mock.calls, 0)).toMatchInlineSnapshot(`
+      {
+        "content": "Already on latest version: **v1.0.0**",
+      }
+    `)
+
+    mocks.upgrade.mockRejectedValueOnce(new Error('network down'))
+
+    await handleUpgradeAndRestartCommand({ command: command as never, appId: 'app-1' })
+
+    expect(callArg(command.editReply.mock.calls, 1)).toMatchInlineSnapshot(`
+      {
+        "content": "Upgrade failed: network down",
+      }
+    `)
+  })
+
+  test('memory snapshot command reports success and error', async () => {
+    const command = createCommandMock({})
+    mocks.writeHeapSnapshot.mockResolvedValue('/tmp/heap.heapsnapshot.gz')
+
+    await handleMemorySnapshotCommand({ command: command as never, appId: 'app-1' })
+    mocks.writeHeapSnapshot.mockRejectedValueOnce(new Error('disk full'))
+    await handleMemorySnapshotCommand({ command: command as never, appId: 'app-1' })
+
+    expect(command.editReply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "Heap snapshot written:
+      \`/tmp/heap.heapsnapshot.gz\`",
+          },
+        ],
+        [
+          {
+            "content": "Failed to write heap snapshot: disk full",
+          },
+        ],
+      ]
+    `)
+  })
+
+  test('tasks command lists empty state in components-v2', async () => {
+    const command = createCommandMock({ booleanOptions: { all: false }, guildId: 'guild-1' })
+    mocks.listScheduledTasks.mockResolvedValue([])
+
+    await handleTasksCommand({ command: command as never, appId: 'app-1' })
+
+    expect(callArg(command.editReply.mock.calls, 0)).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "content": "No scheduled tasks found.",
+            "type": 10,
+          },
+        ],
+        "flags": 32768,
+      }
+    `)
+  })
+
+  test('tasks command requires guild context', async () => {
+    const command = createCommandMock({ guildId: null })
+
+    await handleTasksCommand({ command: command as never, appId: 'app-1' })
+
+    expect(command.reply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "This command can only be used in a server.",
+            "flags": 64,
+          },
+        ],
+      ]
+    `)
+  })
+
+  test('file upload button and modal flows handle expiration and empty uploads', async () => {
+    const expiredInteraction = {
+      customId: 'file_upload_btn:missing',
+      reply: vi.fn(async () => {}),
+    }
+    await handleFileUploadButton(expiredInteraction as never)
+
+    const thread = {
+      id: 'thread-1',
+      send: vi.fn(async () => ({ id: 'msg-1' })),
+      messages: { fetch: vi.fn(async () => ({ edit: vi.fn(async () => {}) })) },
+    }
+
+    const waitPromise = showFileUploadButton({
+      thread: thread as never,
+      sessionId: 'ses-1',
+      directory: '/repo',
+      prompt: 'upload logs',
+      maxFiles: 2,
+    })
+
+    const [contextHash] = [...pendingFileUploadContexts.keys()]
+    const modalInteraction = {
+      customId: `file_upload_modal:${contextHash}`,
+      deferReply: vi.fn(async () => {}),
+      editReply: vi.fn(async () => {}),
+      fields: { getField: vi.fn(() => ({ attachments: new Map() })) },
+    }
+    await handleFileUploadModalSubmit(modalInteraction as never)
+
+    expect(callArg(expiredInteraction.reply.mock.calls, 0)).toMatchInlineSnapshot(`
+      {
+        "content": "This file upload request has expired.",
+        "flags": 64,
+      }
+    `)
+    await expect(waitPromise).resolves.toMatchInlineSnapshot(`[]`)
+    await expect(cancelPendingFileUpload('thread-unknown')).resolves.toBe(false)
+  })
+
+  test('action buttons queue and click handling stay consistent', async () => {
+    const waitPromise = waitForQueuedActionButtonsRequest({
+      sessionId: 'ses-1',
+      timeoutMs: 100,
+    })
+
+    queueActionButtonsRequest({
+      sessionId: 'ses-1',
+      threadId: 'thread-1',
+      directory: '/repo',
+      buttons: [{ label: 'Approve', color: 'green' }],
+    })
+
+    await expect(waitPromise).resolves.toMatchInlineSnapshot(`
+      {
+        "buttons": [
+          {
+            "color": "green",
+            "label": "Approve",
+          },
+        ],
+        "directory": "/repo",
+        "sessionId": "ses-1",
+        "threadId": "thread-1",
+      }
+    `)
+
+    const badInteraction = {
+      customId: 'action_button:bad',
+      reply: vi.fn(async () => {}),
+    }
+    await handleActionButton(badInteraction as never)
+    expect(callArg(badInteraction.reply.mock.calls, 0)).toMatchInlineSnapshot(`
+      {
+        "content": "Invalid action button.",
+        "flags": 64,
+      }
+    `)
+
+    const thread = {
+      id: 'thread-1',
+      send: vi.fn(async () => ({ id: 'msg-1' })),
+      messages: { fetch: vi.fn(async () => ({ edit: vi.fn(async () => {}) })) },
+    }
+    await showActionButtons({
+      thread: thread as never,
+      sessionId: 'ses-2',
+      directory: '/repo',
+      buttons: [{ label: 'Approve', color: 'green' }],
+    })
+
+    const [contextHash] = [...pendingActionButtonContexts.keys()]
+    const clickInteraction = {
+      customId: `action_button:${contextHash}:0`,
+      deferUpdate: vi.fn(async () => {}),
+      editReply: vi.fn(async () => {}),
+      channel: { isThread: () => true, id: 'thread-1' },
+      user: { id: 'u1', username: 'u1', globalName: null },
+    }
+    mocks.getThreadSession.mockResolvedValue('different-session')
+
+    await handleActionButton(clickInteraction as never)
+
+    expect(callArg(clickInteraction.editReply.mock.calls, 0)).toMatchInlineSnapshot(`
+      {
+        "components": [],
+        "content": "**Action Required**
+      _Expired due to session change._",
+      }
+    `)
+  })
+
+  test('ask-question parser and cancel flow cover valid and fallback paths', async () => {
+    const parsed = parseAskUserQuestionTool({
+      type: 'tool',
+      tool: 'question',
+      state: {
+        input: {
+          questions: [
+            {
+              question: 'Pick one',
+              header: 'Choice',
+              options: [
+                { label: 'A', description: 'a' },
+                { label: 'B', description: 'b' },
+              ],
+            },
+          ],
+        },
+      },
+    })
+
+    expect(parsed).toMatchInlineSnapshot(`
+      {
+        "questions": [
+          {
+            "header": "Choice",
+            "options": [
+              {
+                "description": "a",
+                "label": "A",
+              },
+              {
+                "description": "b",
+                "label": "B",
+              },
+            ],
+            "question": "Pick one",
+          },
+        ],
+      }
+    `)
+
+    const thread = { id: 'thread-1', send: vi.fn(async () => ({ id: 'm1' })) }
+    await showAskUserQuestionDropdowns({
+      thread: thread as never,
+      sessionId: 'ses-1',
+      directory: '/repo',
+      requestId: 'req-1',
+      input: {
+        questions: [
+          {
+            question: 'Pick',
+            header: 'H',
+            options: [
+              { label: 'A', description: 'a' },
+              { label: 'B', description: 'b' },
+            ],
+          },
+        ],
+      },
+    })
+
+    mocks.getOpencodeClient.mockReturnValue({
+      question: { reply: vi.fn(async () => ({})) },
+    })
+
+    await expect(cancelPendingQuestion('thread-1', 'my answer')).resolves.toBe('replied')
+    await expect(cancelPendingQuestion('thread-missing')).resolves.toBe('no-pending')
+  })
+})