@otto-assistant/bridge 0.4.92

package/dist/queue-interrupt-drain.e2e.test.js

@@ -0,0 +1,135 @@
+// 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/dist/queue-question-select-drain.e2e.test.js

@@ -0,0 +1,120 @@
+// 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, }) {
+    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((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/dist/runtime-idle-sweeper.js

@@ -0,0 +1,52 @@
+// 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, } = {}) {
+    let stopped = false;
+    let sweeping = false;
+    let sweepPromise = null;
+    const sweep = async () => {
+        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');
+    };
+}