@otto-assistant/otto 0.1.1 → 0.7.15

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 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/dist/queue-question-select-drain.e2e.test.js

@@ -0,0 +1,256 @@
+// 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');
+}
+async function expectNoBotMessageContaining({ discord, threadId, text, timeout, }) {
+    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((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);
+});

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');
+    };
+}