kimaki 0.4.82 → 0.4.84

package/dist/markdown.js

@@ -263,8 +263,8 @@ export function getCompactSessionContext({ client, sessionId, includeSystemPromp
             for (const msg of recentMessages) {
                 if (msg.info.role === 'user') {
                     const textParts = (msg.parts || [])
-                        .filter((p) => p.type === 'text' && 'text' in p)
-                        .map((p) => ('text' in p ? extractNonXmlContent(p.text || '') : ''))
+                        .filter((p) => p.type === 'text')
+                        .map((p) => (p.type === 'text' ? extractNonXmlContent(p.text || '') : ''))
                         .filter(Boolean);
                     if (textParts.length > 0) {
                         lines.push(`[User]: ${textParts.join(' ').slice(0, 1000)}`);
@@ -274,8 +274,8 @@ export function getCompactSessionContext({ client, sessionId, includeSystemPromp
                 else if (msg.info.role === 'assistant') {
                     // Get assistant text parts (non-synthetic, non-empty)
                     const textParts = (msg.parts || [])
-                        .filter((p) => p.type === 'text' && 'text' in p && !p.synthetic && p.text)
-                        .map((p) => ('text' in p ? p.text : ''))
+                        .filter((p) => p.type === 'text' && !p.synthetic && p.text)
+                        .map((p) => (p.type === 'text' ? p.text : ''))
                         .filter(Boolean);
                     if (textParts.length > 0) {
                         lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`);

package/dist/markdown.test.js

@@ -100,7 +100,7 @@ beforeAll(async () => {
         const msgs = await client.session.messages({ sessionID });
         const assistantMsg = msgs.data?.find((m) => m.info.role === 'assistant');
         const hasTextParts = assistantMsg?.parts?.some((p) => {
-            return p.type === 'text' && 'text' in p && p.text && !('synthetic' in p && p.synthetic);
+            return p.type === 'text' && p.text && !p.synthetic;
         });
         if (hasTextParts) {
             // Extra wait for step-start and other parts to be flushed

package/dist/message-formatting.js

@@ -45,26 +45,65 @@ function normalizeWhitespace(text) {
     return text.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ');
 }
 /**
- * Collects and formats the last N assistant parts from session messages.
- * Used by both /resume and /fork to show recent assistant context.
+ * Collect renderable assistant parts from session messages as SessionChunks.
+ * Each non-empty formatted part becomes one chunk. Caller can batch them
+ * with batchChunksForDiscord() before sending.
+ *
+ * - skipPartIds: parts already synced (external sync). Skipped parts are
+ *   not included in the result.
+ * - limit: max parts to include (from the end). Older parts are counted
+ *   in skippedCount.
  */
-export function collectLastAssistantParts({ messages, limit = 30, }) {
-    const allAssistantParts = [];
+export function collectSessionChunks({ messages, skipPartIds, limit, }) {
+    const allChunks = [];
     for (const message of messages) {
-        if (message.info.role === 'assistant') {
-            for (const part of message.parts) {
-                const content = formatPart(part);
-                if (content.trim()) {
-                    allAssistantParts.push({ id: part.id, content: content.trimEnd() });
-                }
+        if (message.info.role !== 'assistant') {
+            continue;
+        }
+        for (const part of message.parts) {
+            if (skipPartIds?.has(part.id)) {
+                continue;
+            }
+            const content = formatPart(part);
+            if (!content.trim()) {
+                continue;
             }
+            allChunks.push({ partIds: [part.id], content: content.trimEnd() });
+        }
+    }
+    if (limit !== undefined && allChunks.length > limit) {
+        return {
+            chunks: allChunks.slice(-limit),
+            skippedCount: allChunks.length - limit,
+        };
+    }
+    return { chunks: allChunks, skippedCount: 0 };
+}
+// Merge consecutive SessionChunks into as few Discord messages as possible,
+// respecting the 2000 char limit.
+const DISCORD_BATCH_MAX_LENGTH = 2000;
+export function batchChunksForDiscord(chunks) {
+    if (chunks.length === 0) {
+        return [];
+    }
+    const batched = [];
+    let current = { partIds: [...chunks[0].partIds], content: chunks[0].content };
+    for (let i = 1; i < chunks.length; i++) {
+        const next = chunks[i];
+        const merged = current.content + '\n' + next.content;
+        if (merged.length <= DISCORD_BATCH_MAX_LENGTH) {
+            current = {
+                partIds: [...current.partIds, ...next.partIds],
+                content: merged,
+            };
+        }
+        else {
+            batched.push(current);
+            current = { partIds: [...next.partIds], content: next.content };
         }
     }
-    const partsToRender = allAssistantParts.slice(-limit);
-    const partIds = partsToRender.map((p) => p.id);
-    const content = partsToRender.map((p) => p.content).join('\n');
-    const skippedCount = allAssistantParts.length - partsToRender.length;
-    return { partIds, content, skippedCount };
+    batched.push(current);
+    return batched;
 }
 export const TEXT_MIME_TYPES = [
     'text/',

package/dist/onboarding-tutorial.js

@@ -142,7 +142,7 @@ ${backticks}bash
 PORT=$((RANDOM % 6000 + 3000))
 tmux kill-session -t game-dev 2>/dev/null
 tmux new-session -d -s game-dev -c "$PWD"
-tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel -p $PORT -- bun run server.ts" Enter
+tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel --kill -p $PORT -- bun run server.ts" Enter
 ${backticks}
 
 Wait a moment, then get the tunnel URL:

package/dist/openai-realtime.js

@@ -140,13 +140,11 @@ export async function startGenAiSession({ onAssistantAudioChunk, onAssistantStar
     }
     // Set up event handlers
     client.on('conversation.item.created', ({ item }) => {
-        if ('role' in item &&
-            item.role === 'assistant' &&
+        if (item.role === 'assistant' &&
             item.type === 'message') {
             // Check if this is the first audio content
-            const hasAudio = 'content' in item &&
-                Array.isArray(item.content) &&
-                item.content.some((c) => 'type' in c && c.type === 'audio');
+            const hasAudio = Array.isArray(item.content) &&
+                item.content.some((c) => c.type === 'audio');
             if (hasAudio && !isAssistantSpeaking && onAssistantStartSpeaking) {
                 isAssistantSpeaking = true;
                 onAssistantStartSpeaking();
@@ -155,7 +153,7 @@ export async function startGenAiSession({ onAssistantAudioChunk, onAssistantStar
     });
     client.on('conversation.updated', ({ item, delta, }) => {
         // Handle audio chunks
-        if (delta?.audio && 'role' in item && item.role === 'assistant') {
+        if (delta?.audio && item.role === 'assistant') {
             if (!isAssistantSpeaking && onAssistantStartSpeaking) {
                 isAssistantSpeaking = true;
                 onAssistantStartSpeaking();
@@ -177,13 +175,11 @@ export async function startGenAiSession({ onAssistantAudioChunk, onAssistantStar
         }
         // Handle transcriptions
         if (delta?.transcript) {
-            if ('role' in item) {
-                if (item.role === 'user') {
-                    openaiLogger.log('User transcription:', delta.transcript);
-                }
-                else if (item.role === 'assistant') {
-                    openaiLogger.log('Assistant transcription:', delta.transcript);
-                }
+            if (item.role === 'user') {
+                openaiLogger.log('User transcription:', delta.transcript);
+            }
+            else if (item.role === 'assistant') {
+                openaiLogger.log('Assistant transcription:', delta.transcript);
             }
         }
     });

package/dist/opencode.js

@@ -29,6 +29,9 @@ import { notifyError } from './sentry.js';
 import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
 import { ensureKimakiCommandShim, getPathEnvKey, getSpawnCommandAndArgs, prependPathEntry, selectResolvedCommand, } from './opencode-command.js';
 const opencodeLogger = createLogger(LogPrefix.OPENCODE);
+// Tracks directories that have been initialized, to avoid repeated log spam
+// from the external sync polling loop.
+const initializedDirectories = new Set();
 const STARTUP_STDERR_TAIL_LIMIT = 30;
 const STARTUP_STDERR_LINE_MAX_LENGTH = 120;
 const STARTUP_ERROR_REASON_MAX_LENGTH = 1500;
@@ -361,6 +364,20 @@ async function startSingleServer() {
         opencodeLogger.warn(kimakiShimDirectory.message);
     }
     const gatewayToken = store.getState().gatewayToken;
+    const vitestOpencodeEnv = (() => {
+        if (process.env.KIMAKI_VITEST !== '1') {
+            return {};
+        }
+        const root = path.join(getDataDir(), 'opencode-vitest-home');
+        return {
+            OPENCODE_TEST_HOME: root,
+            OPENCODE_CONFIG_DIR: path.join(root, '.opencode-kimaki'),
+            XDG_CONFIG_HOME: path.join(root, '.config'),
+            XDG_DATA_HOME: path.join(root, '.local', 'share'),
+            XDG_CACHE_HOME: path.join(root, '.cache'),
+            XDG_STATE_HOME: path.join(root, '.local', 'state'),
+        };
+    })();
     const serverProcess = spawn(spawnCommand, spawnArgs, {
         stdio: 'pipe',
         detached: false,
@@ -417,6 +434,7 @@ async function startSingleServer() {
             ...(process.env.KIMAKI_SENTRY_DSN && {
                 KIMAKI_SENTRY_DSN: process.env.KIMAKI_SENTRY_DSN,
             }),
+            ...vitestOpencodeEnv,
             ...(pathEnv && { [pathEnvKey]: pathEnv }),
         },
     });
@@ -475,10 +493,12 @@ async function startSingleServer() {
         singleServer = null;
         clientCache.clear();
         notifyServerLifecycle({ type: 'stopped' });
-        // Intentional kills (SIGTERM from cleanup/restart) should not trigger
-        // auto-restart. Only unexpected crashes (non-zero exit without signal)
-        // get retried.
-        if (signal === 'SIGTERM') {
+        // Intentional kills should not trigger auto-restart:
+        // - SIGTERM from our cleanup/restart code
+        // - SIGINT propagated from Ctrl+C (parent process group signal)
+        // - any exit during bot shutdown (shuttingDown flag)
+        // Only unexpected crashes (non-zero exit without signal) get retried.
+        if (signal === 'SIGTERM' || signal === 'SIGINT' || global.shuttingDown) {
             serverRetryCount = 0;
             return;
         }
@@ -586,7 +606,10 @@ export async function initializeOpencodeForDirectory(directory, _options) {
     if (server instanceof Error) {
         return server;
     }
-    opencodeLogger.log(`Using shared server on port ${server.port} for directory: ${directory}`);
+    if (!initializedDirectories.has(directory)) {
+        initializedDirectories.add(directory);
+        opencodeLogger.log(`Using shared server on port ${server.port} for directory: ${directory}`);
+    }
     return () => {
         if (!singleServer) {
             throw new ServerNotReadyError({ directory });

package/dist/queue-advanced-e2e-setup.js

@@ -299,6 +299,41 @@ export function createDeterministicMatchers() {
             ],
         },
     };
+    // Question tool for select+queue drain test: model asks a question via dropdown,
+    // user answers via select menu while a message is queued.
+    const questionSelectQueueMatcher = {
+        id: 'question-select-queue-marker',
+        priority: 107,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'QUESTION_SELECT_QUEUE_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'question-select-queue-call',
+                    toolName: 'question',
+                    input: JSON.stringify({
+                        questions: [{
+                                question: 'How to proceed?',
+                                header: 'Select action',
+                                options: [
+                                    { label: 'Alpha', description: 'Alpha option' },
+                                    { label: 'Beta', description: 'Beta option' },
+                                ],
+                            }],
+                    }),
+                },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
     // Model responds with text + tool call, then after tool result the
     // follow-up matcher responds with text. This creates two assistant messages:
     // first with finish="tool-calls" + completed, second with finish="stop".
@@ -356,6 +391,57 @@ export function createDeterministicMatchers() {
             ],
         },
     };
+    const undoFileMatcher = {
+        id: 'undo-file-marker',
+        priority: 111,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'UNDO_FILE_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'undo-file-text' },
+                { type: 'text-delta', id: 'undo-file-text', delta: 'creating undo file' },
+                { type: 'text-end', id: 'undo-file-text' },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'undo-file-bash',
+                    toolName: 'bash',
+                    input: JSON.stringify({
+                        command: 'mkdir -p tmp && printf created > tmp/undo-marker.txt',
+                        description: 'Create undo marker file',
+                    }),
+                },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
+    const undoFileFollowupMatcher = {
+        id: 'undo-file-followup',
+        priority: 112,
+        when: {
+            latestUserTextIncludes: 'UNDO_FILE_MARKER',
+            rawPromptIncludes: 'creating undo file',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'undo-file-followup' },
+                { type: 'text-delta', id: 'undo-file-followup', delta: 'undo file created' },
+                { type: 'text-end', id: 'undo-file-followup' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
     // Multi-step tool chain: model emits text + 3 parallel tool calls in one
     // response (finish="tool-calls"). All tools complete, then the follow-up
     // matcher responds with final text (finish="stop"). This creates 2 assistant
@@ -562,10 +648,13 @@ export function createDeterministicMatchers() {
         pluginTimeoutSleepMatcher,
         actionButtonClickFollowupMatcher,
         questionToolMatcher,
+        questionSelectQueueMatcher,
         permissionTypingMatcher,
         permissionTypingFollowupMatcher,
         multiToolMatcher,
         multiToolFollowupMatcher,
+        undoFileMatcher,
+        undoFileFollowupMatcher,
         multiStepChainInitMatcher,
         multiStepChainStep2Matcher,
         multiStepChainStep3Matcher,

package/dist/queue-advanced-permissions-typing.e2e.test.js

@@ -39,7 +39,7 @@ describe('queue advanced: typing around permissions', () => {
             },
         });
         const th = ctx.discord.thread(thread.id);
-        await th.waitForTypingEvent({ timeout: 1_000 });
+        await th.waitForTypingEvent({ timeout: 4_000 });
         const pending = await waitForPendingPermission({
             threadId: thread.id,
             timeoutMs: 4_000,
@@ -133,14 +133,14 @@ describe('queue advanced: typing around permissions', () => {
             discord: ctx.discord,
             threadId: thread.id,
             text: 'Permission dismissed - user sent a new message.',
-            timeout: 4_000,
+            timeout: 8_000,
         });
         await waitForBotReplyAfterUserMessage({
             discord: ctx.discord,
             threadId: thread.id,
             userId: TEST_USER_ID,
             userMessageIncludes: 'post-permission-user-message',
-            timeout: 4_000,
+            timeout: 8_000,
         });
         await waitForBotMessageContaining({
             discord: ctx.discord,
@@ -148,12 +148,12 @@ describe('queue advanced: typing around permissions', () => {
             userId: TEST_USER_ID,
             text: 'ok',
             afterUserMessageIncludes: 'post-permission-user-message',
-            timeout: 4_000,
+            timeout: 8_000,
         });
         await waitForFooterMessage({
             discord: ctx.discord,
             threadId: thread.id,
-            timeout: 4_000,
+            timeout: 8_000,
             afterMessageIncludes: 'ok',
             afterAuthorId: ctx.discord.botUserId,
         });

package/dist/queue-advanced-typing.e2e.test.js

@@ -52,14 +52,11 @@ e2eTest('queue advanced: typing lifecycle', () => {
                 && message.content.includes('⋅');
         });
         const timeline = await th.text({ showTyping: true });
-        expect(timeline).toMatchInlineSnapshot(`
-        "--- from: user (queue-advanced-tester)
-        Reply with exactly: typing-stop-normal
-        [bot typing]
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
+        expect(timeline).toContain('Reply with exactly: typing-stop-normal');
+        expect(timeline).toContain('⬥ ok');
+        expect(timeline).toContain('*project ⋅ main ⋅');
+        const typingCount = (timeline.match(/\[bot typing\]/g) || []).length;
+        expect(typingCount).toBeGreaterThanOrEqual(1);
         expect(replyIndex).toBeGreaterThanOrEqual(0);
         expect(footerIndex).toBeGreaterThan(replyIndex);
         expect(messages[footerIndex]).toBeDefined();
@@ -134,20 +131,10 @@ e2eTest('queue advanced: typing lifecycle', () => {
             afterAuthorId: TEST_USER_ID,
         });
         const timeline = await th.text({ showTyping: true });
-        expect(timeline).toMatchInlineSnapshot(`
-        "--- from: user (queue-advanced-tester)
-        Reply with exactly: typing-thread-reply-setup
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        --- from: user (queue-advanced-tester)
-        TYPING_REPULSE_MARKER
-        [bot typing]
-        --- from: assistant (TestBot)
-        ⬥ repulse-first
-        [bot typing]
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
+        expect(timeline).toContain('TYPING_REPULSE_MARKER');
+        expect(timeline).toContain('⬥ repulse-first');
+        const typingCount = (timeline.match(/\[bot typing\]/g) || []).length;
+        expect(typingCount).toBeGreaterThanOrEqual(2);
         const followupUserIndex = messages.findIndex((message) => {
             return message.author.id === TEST_USER_ID
                 && message.content.includes('TYPING_REPULSE_MARKER');

package/dist/queue-question-select-drain.e2e.test.js

@@ -0,0 +1,117 @@
+// 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: 4_000,
+            predicate: (t) => {
+                return t.name === 'QUESTION_SELECT_QUEUE_MARKER';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        // 2. Wait for the question dropdown to appear
+        const pending = await waitForPendingQuestion({
+            threadId: thread.id,
+            timeoutMs: 4_000,
+        });
+        expect(pending.contextHash).toBeTruthy();
+        // Verify dropdown message appeared
+        const questionMessages = await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'How to proceed?',
+            timeout: 4_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: 4_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: 4_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: 4_000,
+        });
+        // 6. Wait for footer from the drained queued message
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_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]
+        Queued message (position 1)
+        [user selects dropdown: 0]
+        » **question-select-tester:** Reply with exactly: post-question-drain
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+    }, 20_000);
+});