@otto-assistant/bridge 0.4.92

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 kimaki 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,152 @@
+// 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')
+}
+
+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 = (() => {
+        const entry = [...pendingQuestionContexts.entries()].find(([, context]) => {
+          return context.thread.id === thread.id
+        })
+        return entry ? { contextHash: entry[0] } : null
+      })()
+      expect(pending).toBeTruthy()
+      if (!pending) {
+        throw new Error('Expected pending question context')
+      }
+      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. 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,
+      })
+
+      // 5. Queued message should be handed off to OpenCode's own prompt queue
+      //    after the question reply, so the dispatch indicator appears without
+      //    waiting for a later natural idle.
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: '» **question-select-tester:** Reply with exactly: post-question-drain',
+        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,
+      })
+
+      // Assert key invariants instead of exact snapshot — on CI the deterministic
+      // matcher can fire a second time after the drained message (rawPromptIncludes
+      // scans full history), adding an extra question to the timeline.
+      const timeline = await th.text({ showInteractions: true })
+      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,
+  )
+})

package/src/runtime-idle-sweeper.ts

@@ -0,0 +1,76 @@
+// Runtime inactivity sweeper.
+// Periodically disposes thread runtimes that stayed idle past a timeout.
+
+import { createLogger, LogPrefix } from './logger.js'
+import {
+  disposeInactiveRuntimes,
+} from './session-handler/thread-session-runtime.js'
+
+const logger = createLogger(LogPrefix.SESSION)
+
+// 24 hours — users often return the next day to click buttons/selects,
+// so runtimes (and their in-memory context maps) must stay alive that long.
+export const DEFAULT_RUNTIME_IDLE_MS = 24 * 60 * 60 * 1000
+export const DEFAULT_SWEEP_INTERVAL_MS = 60 * 1000
+
+export function startRuntimeIdleSweeper({
+  runtimeIdleMs = DEFAULT_RUNTIME_IDLE_MS,
+  sweepIntervalMs = DEFAULT_SWEEP_INTERVAL_MS,
+}: {
+  runtimeIdleMs?: number
+  sweepIntervalMs?: number
+} = {}): () => Promise<void> {
+  let stopped = false
+  let sweeping = false
+  let sweepPromise: Promise<void> | null = null
+
+  const sweep = async (): Promise<void> => {
+    if (stopped || sweeping) {
+      return
+    }
+    sweeping = true
+
+    const currentSweepPromise = (async () => {
+      const nowMs = Date.now()
+      const disposeResult = disposeInactiveRuntimes({
+        idleMs: runtimeIdleMs,
+        nowMs,
+      })
+      if (disposeResult.disposedThreadIds.length > 0) {
+        logger.log(
+          `[IDLE SWEEP] Disposed ${disposeResult.disposedThreadIds.length} inactive runtime(s) after ${runtimeIdleMs}ms`,
+        )
+      }
+
+    })()
+
+    sweepPromise = currentSweepPromise
+    await currentSweepPromise.finally(() => {
+      sweeping = false
+      sweepPromise = null
+    })
+  }
+
+  const interval = setInterval(() => {
+    void sweep()
+  }, sweepIntervalMs)
+
+  void sweep()
+
+  logger.log(
+    `[IDLE SWEEP] Started (runtimeIdleMs=${runtimeIdleMs}, intervalMs=${sweepIntervalMs})`,
+  )
+
+  return async () => {
+    if (stopped) {
+      return
+    }
+    stopped = true
+    clearInterval(interval)
+    if (sweepPromise) {
+      await sweepPromise
+      sweepPromise = null
+    }
+    logger.log('[IDLE SWEEP] Stopped')
+  }
+}