@otto-assistant/otto 0.1.2 → 0.7.16

package/src/queue-drain-after-interactive-ui.e2e.test.ts

@@ -0,0 +1,151 @@
+// E2e test: queued messages must drain immediately when the session is idle,
+// even if action buttons are still pending. The isSessionBusy check is
+// sufficient — hasPendingInteractiveUi() should NOT block queue drain.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForFooterMessage,
+} from './test-utils.js'
+import { getThreadSession } from './database.js'
+import {
+  pendingActionButtonContexts,
+  showActionButtons,
+} from './commands/action-buttons.js'
+
+const TEXT_CHANNEL_ID = '200000000000001020'
+
+describe('queue drain with pending interactive UI', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-drain-interactive-ui',
+    dirName: 'qa-drain-interactive-ui',
+    username: 'drain-ui-tester',
+  })
+
+  test(
+    'queued message drains immediately while action buttons are still pending',
+    async () => {
+      // 1. Create a thread with a first completed reply
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: drain-button-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: drain-button-setup'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'ok',
+        timeout: 4_000,
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      // 2. Show action buttons (session is idle, buttons are pending)
+      const currentSessionId = await getThreadSession(thread.id)
+      if (!currentSessionId) {
+        throw new Error('Expected thread session id')
+      }
+
+      const channel = await ctx.botClient.channels.fetch(thread.id)
+      if (!channel || !channel.isThread()) {
+        throw new Error('Expected Discord thread channel')
+      }
+
+      await showActionButtons({
+        thread: channel,
+        sessionId: currentSessionId,
+        directory: ctx.directories.projectDirectory,
+        buttons: [{ label: 'Pending button', color: 'white' }],
+      })
+
+      // Verify buttons are pending
+      const start = Date.now()
+      while (Date.now() - start < 4_000) {
+        const entry = [...pendingActionButtonContexts.entries()].find(([, context]) => {
+          return context.thread.id === thread.id && Boolean(context.messageId)
+        })
+        if (entry) {
+          break
+        }
+        await new Promise<void>((resolve) => {
+          setTimeout(resolve, 100)
+        })
+      }
+      expect(
+        [...pendingActionButtonContexts.values()].some((c) => {
+          return c.thread.id === thread.id
+        }),
+      ).toBe(true)
+
+      // 3. Queue a message via /queue while buttons are still pending.
+      //    The queue should drain immediately because session is idle.
+      //    Currently FAILS: hasPendingInteractiveUi() blocks tryDrainQueue().
+      const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-button-drain' }],
+        })
+
+      const queueAck = await th.waitForInteractionAck({
+        interactionId: queueInteractionId,
+        timeout: 4_000,
+      })
+      if (!queueAck.messageId) {
+        throw new Error('Expected /queue response message id')
+      }
+
+      // 4. Queued message should dispatch immediately (not stay "Queued").
+      //    The dispatch indicator should appear quickly.
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: '» **drain-ui-tester:** Reply with exactly: post-button-drain',
+        timeout: 4_000,
+      })
+
+      // 5. Wait for the footer after the drained message completes
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: '» **drain-ui-tester:**',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      const timeline = await th.text({ showInteractions: true })
+      expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (drain-ui-tester)
+        Reply with exactly: drain-button-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        **Action Required**
+        [user interaction]
+        » **drain-ui-tester:** Reply with exactly: post-button-drain
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+    },
+    20_000,
+  )
+})

package/src/queue-interrupt-drain.e2e.test.ts

@@ -0,0 +1,166 @@
+// E2e test for queue + interrupt interaction.
+// Validates that a user can queue a command via /queue while a slow session
+// is in progress, then send a normal (non-queued) message to interrupt.
+//
+// Expected behavior:
+//   1. Slow session is running
+//   2. User queues a message via /queue (enters otto local queue)
+//   3. User sends a normal message (interrupt)
+//   4. Session aborts the slow task, processes the interrupt message immediately
+//   5. Interrupt response appears in Discord with a ⬥ ok reply
+//   6. When interrupt response completes, the queued message drains and runs
+//
+// Uses opencode-deterministic-provider (no real LLM calls).
+// Poll timeouts: 4s max, 100ms interval. Slow matcher uses 100s delay.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForFooterMessage,
+  waitForBotMessageContaining,
+  waitForMessageById,
+} from './test-utils.js'
+
+const TEXT_CHANNEL_ID = '200000000000001099'
+
+const e2eTest = describe
+
+e2eTest('queue + interrupt drain ordering', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-interrupt-drain-e2e',
+    dirName: 'qa-interrupt-drain-e2e',
+    username: 'interrupt-tester',
+  })
+
+  test(
+    'queued message via /queue + normal interrupt: interrupt reply should appear, then queue drains',
+    async () => {
+      // 1. Establish session with a quick first message
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: setup-interrupt-drain',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: setup-interrupt-drain'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+      await th.waitForBotReply({ timeout: 4_000 })
+
+      // Wait for first run to fully complete (footer) so state is clean
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+      })
+
+      // 2. Start a slow session — PLUGIN_TIMEOUT_SLEEP_MARKER has a 100s delay
+      //    before the finish event, guaranteeing the session stays busy.
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+      })
+
+      // Wait for the slow matcher to start streaming (text appears before delay)
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'starting sleep',
+        afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        timeout: 4_000,
+      })
+
+      // 3. Queue a message via /queue while the slow session is running
+      const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{ name: 'message', type: 3, value: 'Reply with exactly: queued-behind-slow' }],
+        })
+
+      const queueAck = await th.waitForInteractionAck({
+        interactionId: queueInteractionId,
+        timeout: 4_000,
+      })
+      if (!queueAck.messageId) {
+        throw new Error('Expected /queue response message id')
+      }
+
+      const queueStatusMessage = await waitForMessageById({
+        discord: ctx.discord,
+        threadId: thread.id,
+        messageId: queueAck.messageId,
+        timeout: 4_000,
+      })
+      // The /queue message should be queued (session is busy with the 100s task)
+      expect(queueStatusMessage.content).toContain('Queued message')
+
+      // 4. Send a normal (non-queued) message — this should interrupt the slow
+      //    session and be processed immediately
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: interrupt-now',
+      })
+
+      // 5. Wait for the final state: the interrupt message should get its own
+      //    ⬥ ok reply, then the queued message should drain and get processed.
+      //    We wait for the queued message's footer as the final signal.
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 12_000,
+        afterMessageIncludes: 'queued-behind-slow',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      // 6. Capture the full interaction in an inline snapshot.
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (interrupt-tester)
+        Reply with exactly: setup-interrupt-drain
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        --- from: user (interrupt-tester)
+        PLUGIN_TIMEOUT_SLEEP_MARKER
+        --- from: assistant (TestBot)
+        ⬥ starting sleep 100
+        Queued message (position 1)
+        --- from: user (interrupt-tester)
+        Reply with exactly: interrupt-now
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        » **interrupt-tester:** Reply with exactly: queued-behind-slow
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+
+      // 7. Assert the interrupt message got its own ⬥ ok reply between the
+      //    user's interrupt message and the queue dispatch indicator.
+      const text = await th.text()
+      const lines = text.split('\n')
+
+      const interruptUserLine = lines.findIndex((line) => {
+        return line.includes('Reply with exactly: interrupt-now')
+      })
+      expect(interruptUserLine).toBeGreaterThan(-1)
+
+      const queueDispatchLine = lines.findIndex((line) => {
+        return line.includes('» **interrupt-tester:** Reply with exactly: queued-behind-slow')
+      })
+      expect(queueDispatchLine).toBeGreaterThan(-1)
+
+      const linesBetween = lines.slice(interruptUserLine + 1, queueDispatchLine)
+      const hasInterruptReply = linesBetween.some((line) => {
+        return line.includes('⬥ ok')
+      })
+      expect(hasInterruptReply).toBe(true)
+    },
+    20_000,
+  )
+})

package/src/queue-question-select-drain.e2e.test.ts

@@ -0,0 +1,327 @@
+// E2e test: queued message must drain after the user answers a pending question
+// via the Discord dropdown select menu. Reproduces a bug where answering via
+// select (not text) leaves queued messages stuck because the session continues
+// processing after the answer and may enter another blocking state.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForFooterMessage,
+} from './test-utils.js'
+import { pendingQuestionContexts } from './commands/ask-question.js'
+
+const TEXT_CHANNEL_ID = '200000000000001030'
+
+async function waitForPendingQuestion({
+  threadId,
+  timeoutMs,
+}: {
+  threadId: string
+  timeoutMs: number
+}): Promise<{ contextHash: string }> {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    const entry = [...pendingQuestionContexts.entries()].find(([, context]) => {
+      return context.thread.id === threadId
+    })
+    if (entry) {
+      return { contextHash: entry[0] }
+    }
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 100)
+    })
+  }
+  throw new Error('Timed out waiting for pending question context')
+}
+
+async function expectNoBotMessageContaining({
+  discord,
+  threadId,
+  text,
+  timeout,
+}: {
+  discord: Parameters<typeof waitForBotMessageContaining>[0]['discord']
+  threadId: string
+  text: string
+  timeout: number
+}): Promise<void> {
+  const start = Date.now()
+  while (Date.now() - start < timeout) {
+    const messages = await discord.thread(threadId).getMessages()
+    const match = messages.find((message) => {
+      return (
+        message.author.id === discord.botUserId
+        && message.content.includes(text)
+      )
+    })
+    if (match) {
+      throw new Error(
+        `Unexpected bot message containing ${JSON.stringify(text)} while it should still be queued`,
+      )
+    }
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 20)
+    })
+  }
+}
+
+describe('queue drain after question select answer', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-question-select-drain',
+    dirName: 'qa-question-select-drain',
+    username: 'question-select-tester',
+  })
+
+  test(
+    'queued message drains after answering question via dropdown select',
+    async () => {
+      // 1. Send a message that triggers the question tool
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'QUESTION_SELECT_QUEUE_MARKER',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 8_000,
+        predicate: (t) => {
+          return t.name === 'QUESTION_SELECT_QUEUE_MARKER'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      // 2. Wait for the question dropdown message to appear in Discord.
+      // Uses visible message wait instead of internal Map polling which
+      // is too timing-sensitive on CI.
+      const questionMessages = await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: 'How to proceed?',
+        timeout: 12_000,
+      })
+
+      // Get the pending question context hash from the internal map.
+      // By this point the question message is visible so the context must exist.
+      const pending = await waitForPendingQuestion({
+        threadId: thread.id,
+        timeoutMs: 8_000,
+      })
+      const questionMsg = questionMessages.find((m) => {
+        return m.content.includes('How to proceed?')
+      })!
+      expect(questionMsg).toBeTruthy()
+
+      // 3. Queue a message while question is pending
+      const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-question-drain' }],
+        })
+
+      const queueAck = await th.waitForInteractionAck({
+        interactionId: queueInteractionId,
+        timeout: 8_000,
+      })
+      if (!queueAck.messageId) {
+        throw new Error('Expected /queue response message id')
+      }
+
+      // 4. The first queued item should be handed off immediately even while
+      //    the question is still pending, so the visible dispatch indicator
+      //    appears before the user answers the dropdown.
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: '» **question-select-tester:** Reply with exactly: post-question-drain',
+        timeout: 8_000,
+      })
+
+      // 5. Answer the question via dropdown select (pick first option "Alpha")
+      const interaction = await th.user(TEST_USER_ID).selectMenu({
+        messageId: questionMsg.id,
+        customId: `ask_question:${pending.contextHash}:0`,
+        values: ['0'],
+      })
+
+      await th.waitForInteractionAck({
+        interactionId: interaction.id,
+        timeout: 8_000,
+      })
+
+      // 6. Wait for footer from the drained queued message
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 8_000,
+        afterMessageIncludes: '» **question-select-tester:**',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      const timeline = await th.text({ showInteractions: true })
+      expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (question-select-tester)
+        QUESTION_SELECT_QUEUE_MARKER
+        --- from: assistant (TestBot)
+        **Select action**
+        How to proceed?
+        ✓ _Alpha_
+        [user interaction]
+        » **question-select-tester:** Reply with exactly: post-question-drain
+        Queued message (position 1)
+        [user selects dropdown: 0]
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+      expect(timeline).toContain('QUESTION_SELECT_QUEUE_MARKER')
+      expect(timeline).toContain('How to proceed?')
+      expect(timeline).toContain('[user selects dropdown: 0]')
+      expect(timeline).toContain('» **question-select-tester:** Reply with exactly: post-question-drain')
+      expect(timeline).toContain('⬥ ok')
+      expect(timeline).toContain('*project ⋅ main ⋅')
+    },
+    20_000,
+  )
+
+  test(
+    'only the first queued message is handed off after dropdown answer',
+    async () => {
+      const marker = 'QUESTION_SELECT_QUEUE_MARKER second-test'
+
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: marker,
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 8_000,
+        predicate: (t) => {
+          return t.name === marker
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      const questionMessages = await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: 'How to proceed?',
+        timeout: 12_000,
+      })
+
+      const pending = await waitForPendingQuestion({
+        threadId: thread.id,
+        timeoutMs: 8_000,
+      })
+
+      const questionMsg = questionMessages.find((message) => {
+        return message.content.includes('How to proceed?')
+      })
+      expect(questionMsg).toBeTruthy()
+      if (!questionMsg) {
+        throw new Error('Expected question message')
+      }
+
+      const firstQueuedPrompt = 'SLOW_ABORT_MARKER run long response'
+      const secondQueuedPrompt = 'Reply with exactly: post-question-second'
+
+      const { id: firstQueueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{ name: 'message', type: 3, value: firstQueuedPrompt }],
+        })
+
+      await th.waitForInteractionAck({
+        interactionId: firstQueueInteractionId,
+        timeout: 8_000,
+      })
+
+      const { id: secondQueueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{ name: 'message', type: 3, value: secondQueuedPrompt }],
+        })
+
+      await th.waitForInteractionAck({
+        interactionId: secondQueueInteractionId,
+        timeout: 8_000,
+      })
+
+      const interaction = await th.user(TEST_USER_ID).selectMenu({
+        messageId: questionMsg.id,
+        customId: `ask_question:${pending.contextHash}:0`,
+        values: ['0'],
+      })
+
+      await th.waitForInteractionAck({
+        interactionId: interaction.id,
+        timeout: 8_000,
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: `» **question-select-tester:** ${firstQueuedPrompt}`,
+        timeout: 8_000,
+      })
+
+      await expectNoBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: `» **question-select-tester:** ${secondQueuedPrompt}`,
+        timeout: 200,
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 8_000,
+        afterMessageIncludes: `» **question-select-tester:** ${firstQueuedPrompt}`,
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: `» **question-select-tester:** ${secondQueuedPrompt}`,
+        timeout: 8_000,
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 8_000,
+        afterMessageIncludes: `» **question-select-tester:** ${secondQueuedPrompt}`,
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      const timeline = await th.text({ showInteractions: true })
+      expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (question-select-tester)
+        QUESTION_SELECT_QUEUE_MARKER second-test
+        --- from: assistant (TestBot)
+        **Select action**
+        How to proceed?
+        ✓ _Alpha_
+        [user interaction]
+        » **question-select-tester:** SLOW_ABORT_MARKER run long response
+        Queued message (position 1)
+        [user interaction]
+        Queued message (position 1)
+        [user selects dropdown: 0]
+        ⬥ slow-response-started
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        » **question-select-tester:** Reply with exactly: post-question-second
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+      expect(timeline).toContain(`» **question-select-tester:** ${firstQueuedPrompt}`)
+      expect(timeline).toContain('⬥ slow-response-started')
+      expect(timeline).toContain(`» **question-select-tester:** ${secondQueuedPrompt}`)
+      expect(timeline).toContain('⬥ ok')
+    },
+    20_000,
+  )
+})