@otto-assistant/otto 0.1.1 → 0.7.15

package/dist/commands/discord-commands-group-c.test.js

@@ -0,0 +1,739 @@
+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) {
+    return mockCalls.at(0)?.[0];
+}
+function callArg(mockCalls, index) {
+    return mockCalls.at(index)?.[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', }) {
+    const deferReply = vi.fn(async () => { });
+    const editReply = vi.fn(async () => { });
+    const reply = vi.fn(async () => { });
+    return {
+        deferReply,
+        editReply,
+        reply,
+        options: {
+            getString: vi.fn((name) => stringOptions[name] ?? null),
+            getBoolean: vi.fn((name) => 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) => value);
+    mocks.buildExternalDirectoryPermissionRules.mockImplementation(({ resolvedPattern, action }) => {
+        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, 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, 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, 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, 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, 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);
+        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, 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, 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, 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);
+        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, 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, 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, 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, appId: 'app-1' });
+        mocks.writeHeapSnapshot.mockRejectedValueOnce(new Error('disk full'));
+        await handleMemorySnapshotCommand({ command: command, 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, 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, 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);
+        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,
+            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);
+        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);
+        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,
+            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);
+        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,
+            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');
+    });
+});