kimaki 0.4.75 → 0.4.76

package/dist/cli.js

@@ -192,10 +192,11 @@ function exitNonInteractiveSetup() {
 }
 // Emit a structured JSON line on stdout for non-TTY consumers (cloud sandboxes, CI).
 // Each line is a self-contained JSON object with a "type" field for easy parsing.
-// Consumers can detect these by reading stdout line-by-line and JSON.parse-ing lines
-// that start with '{'.
+// Lines are prefixed with "data: " and terminated with "\n\n" (SSE format) so consumers
+// can use the eventsource-parser npm package to robustly extract JSON events from noisy
+// process output (other log lines, warnings, etc. are ignored by the parser).
 function emitJsonEvent(event) {
-    process.stdout.write(JSON.stringify(event) + '\n');
+    process.stdout.write(`data: ${JSON.stringify(event)}\n\n`);
 }
 async function resolveGatewayInstallCredentials() {
     if (!KIMAKI_GATEWAY_APP_ID) {
@@ -958,6 +959,42 @@ function showReadyMessage({ kimakiChannels, createdChannels, }) {
     }
     note('Leave this process running to keep the bot active.\n\nIf you close this process or restart your machine, run `npx kimaki` again to start the bot.', '⚠️  Keep Running');
 }
+/**
+ * Create the default kimaki channel in each guild and send a welcome message.
+ * Idempotent: skips guilds that already have the channel.
+ * Extracted so both the interactive and headless startup paths share the same logic.
+ */
+async function ensureDefaultChannelsWithWelcome({ guilds, discordClient, appId, isGatewayMode, installerDiscordUserId, }) {
+    const created = [];
+    for (const guild of guilds) {
+        try {
+            const result = await createDefaultKimakiChannel({
+                guild,
+                botName: discordClient.user?.username,
+                appId,
+                isGatewayMode,
+            });
+            if (result) {
+                created.push({
+                    name: result.channelName,
+                    id: result.textChannelId,
+                    guildId: guild.id,
+                });
+                // Send welcome message to the newly created default channel.
+                // Mention the installer so they get a notification.
+                const mentionUserId = installerDiscordUserId || guild.ownerId;
+                await sendWelcomeMessage({
+                    channel: result.textChannel,
+                    mentionUserId,
+                });
+            }
+        }
+        catch (error) {
+            cliLogger.warn(`Failed to create default kimaki channel in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return created;
+}
 /**
  * Background initialization for quick start mode.
  * Starts OpenCode server and registers slash commands without blocking bot startup.
@@ -1454,7 +1491,8 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
         cliLogger.log('Starting Discord bot...');
         await startDiscordBot({ token, appId, discordClient, useWorktrees });
         cliLogger.log('Discord bot is running!');
-        // Background channel sync + role reconciliation — never blocks ready state.
+        // Background channel sync + role reconciliation + default channel creation.
+        // Never blocks ready state.
         void (async () => {
             try {
                 const backgroundChannels = await collectKimakiChannels({
@@ -1467,6 +1505,15 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
             catch (error) {
                 cliLogger.warn('Background channel sync failed:', error instanceof Error ? error.message : String(error));
             }
+            // Create default kimaki channel + welcome message in each guild.
+            // Runs after channel sync so existing channels are detected correctly.
+            await ensureDefaultChannelsWithWelcome({
+                guilds,
+                discordClient,
+                appId,
+                isGatewayMode,
+                installerDiscordUserId,
+            });
         })();
         // Background: OpenCode init + slash command registration (non-blocking)
         void backgroundInit({
@@ -1609,33 +1656,14 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
         }
         // Create default kimaki channel for general-purpose tasks.
         // Runs for every guild the bot is in, idempotent (skips if already exists).
-        for (const guild of guilds) {
-            try {
-                const result = await createDefaultKimakiChannel({
-                    guild,
-                    botName: discordClient.user?.username,
-                    appId,
-                    isGatewayMode,
-                });
-                if (result) {
-                    createdChannels.push({
-                        name: result.channelName,
-                        id: result.textChannelId,
-                        guildId: guild.id,
-                    });
-                    // Send welcome message to the newly created default channel.
-                    // Mention the installer so they get a notification.
-                    const mentionUserId = installerDiscordUserId || guild.ownerId;
-                    await sendWelcomeMessage({
-                        channel: result.textChannel,
-                        mentionUserId,
-                    });
-                }
-            }
-            catch (error) {
-                cliLogger.warn(`Failed to create default kimaki channel in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
+        const defaultChannelResults = await ensureDefaultChannelsWithWelcome({
+            guilds,
+            discordClient,
+            appId,
+            isGatewayMode,
+            installerDiscordUserId,
+        });
+        createdChannels.push(...defaultChannelResults);
         // Log available user commands
         const registrableCommands = allUserCommands.filter((cmd) => !SKIP_USER_COMMANDS.includes(cmd.name));
         if (registrableCommands.length > 0) {

package/dist/commands/ask-question.js

@@ -29,27 +29,28 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
         contextHash,
     };
     pendingQuestionContexts.set(contextHash, context);
-    // Auto-answer on TTL expiry so the OpenCode session doesn't hang forever
-    // waiting for a question reply that will never come.
+    // On TTL expiry: hide the dropdown UI and abort the session so OpenCode
+    // unblocks. We intentionally do NOT call question.reply() — sending 'Other'
+    // made the model think the user chose an option when they didn't.
     setTimeout(async () => {
         const ctx = pendingQuestionContexts.get(contextHash);
         if (!ctx) {
             return;
         }
+        // Delete context first so the dropdown becomes inert immediately.
+        // Without this, a user clicking during the abort() await would still
+        // be accepted by handleAskQuestionSelectMenu, then abort() would
+        // kill that valid run.
+        pendingQuestionContexts.delete(contextHash);
+        // Abort the session so OpenCode isn't stuck waiting for a reply
         const client = getOpencodeClient(ctx.directory);
         if (client) {
-            const answers = ctx.questions.map((_, i) => {
-                return ctx.answers[i] || ['Other'];
-            });
-            await client.question.reply({
-                requestID: ctx.requestId,
-                directory: ctx.directory,
-                answers,
+            await client.session.abort({
+                sessionID: ctx.sessionId,
             }).catch((error) => {
-                logger.error('Failed to auto-answer expired question:', error);
+                logger.error('Failed to abort session after question expiry:', error);
             });
         }
-        pendingQuestionContexts.delete(contextHash);
     }, QUESTION_CONTEXT_TTL_MS).unref();
     // Send one message per question with its dropdown directly underneath
     for (let i = 0; i < input.questions.length; i++) {
@@ -206,6 +207,11 @@ export function parseAskUserQuestionTool(part) {
 /**
  * Cancel a pending question for a thread (e.g., when user sends a new message).
  * Sends the user's message as the answer to OpenCode so the model sees their actual response.
+ *
+ * Returns 'replied' if the question was answered successfully (caller should NOT
+ * enqueue the user message as a new prompt — it was consumed as the answer).
+ * Returns 'reply-failed' if reply failed (context kept pending so TTL can retry).
+ * Returns 'no-pending' if no question was pending for this thread.
  */
 export async function cancelPendingQuestion(threadId, userMessage) {
     // Find pending question for this thread
@@ -219,17 +225,22 @@ export async function cancelPendingQuestion(threadId, userMessage) {
         }
     }
     if (!contextHash || !context) {
-        return false;
+        return 'no-pending';
+    }
+    // undefined means teardown/cleanup — just remove context, don't reply.
+    // The session is already being torn down. Empty string '' is a valid
+    // user message (attachment-only, voice, etc.) and must still go through.
+    if (userMessage === undefined) {
+        pendingQuestionContexts.delete(contextHash);
+        return 'no-pending';
     }
     try {
         const client = getOpencodeClient(context.directory);
         if (!client) {
             throw new Error('OpenCode server not found for directory');
         }
-        // Use user's message as answer if provided, otherwise mark as "Other"
-        const customAnswer = userMessage || 'Other';
         const answers = context.questions.map((_, i) => {
-            return context.answers[i] || [customAnswer];
+            return context.answers[i] || [userMessage];
         });
         await client.question.reply({
             requestID: context.requestId,
@@ -240,8 +251,10 @@ export async function cancelPendingQuestion(threadId, userMessage) {
     }
     catch (error) {
         logger.error('Failed to answer question:', error);
+        // Keep context pending so TTL can still fire.
+        // Caller should not consume the user message since reply failed.
+        return 'reply-failed';
     }
-    // Clean up regardless of whether the API call succeeded
     pendingQuestionContexts.delete(contextHash);
-    return true;
+    return 'replied';
 }

package/dist/discord-bot.js

@@ -166,10 +166,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 const channels = await getChannelsWithDescriptions(guild);
                 const kimakiChannels = channels.filter((ch) => ch.kimakiDirectory);
                 if (kimakiChannels.length > 0) {
-                    discordLogger.log(`  Found ${kimakiChannels.length} channel(s) for this bot:`);
-                    for (const channel of kimakiChannels) {
-                        discordLogger.log(`  - #${channel.name}: ${channel.kimakiDirectory}`);
-                    }
+                    discordLogger.log(`  Found ${kimakiChannels.length} channel(s) for this bot`);
                     continue;
                 }
                 discordLogger.log('  No channels for this bot');
@@ -333,11 +330,18 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             if (isThread) {
                 const thread = channel;
                 discordLogger.log(`Message in thread ${thread.name} (${thread.id})`);
+                // Cancel interactive UI when a real user sends a message.
+                // If a question was pending and answered with the user's text,
+                // early-return: the message was consumed as the question answer
+                // and must NOT also be sent as a new prompt (causes abort loops).
                 if (!message.author.bot && !isCliInjectedPrompt) {
                     cancelPendingActionButtons(thread.id);
                     cancelHtmlActionsForThread(thread.id);
-                    void cancelPendingQuestion(thread.id, message.content);
+                    const questionResult = await cancelPendingQuestion(thread.id, message.content);
                     void cancelPendingFileUpload(thread.id);
+                    if (questionResult === 'replied') {
+                        return;
+                    }
                 }
                 const parent = thread.parent;
                 let projectDirectory;

package/dist/eventsource-parser.test.js

@@ -0,0 +1,327 @@
+// Experiment: test if eventsource-parser can extract `data:` lines from noisy process output
+import { describe, expect, test } from 'vitest';
+import { createParser } from 'eventsource-parser';
+function parseSSEFromChunks(chunks) {
+    const events = [];
+    const parser = createParser({
+        onEvent(event) {
+            events.push(event);
+        },
+    });
+    for (const chunk of chunks) {
+        parser.feed(chunk);
+    }
+    return events;
+}
+describe('eventsource-parser with noisy process output', () => {
+    test('extracts data: json lines from garbage output', () => {
+        const chunks = [
+            'Starting server on port 3000...\n',
+            '[INFO] Loading configuration\n',
+            'WARNING: deprecated API usage detected\n',
+            'data: {"type":"start","id":1}\n\n',
+            'Compiling 42 modules...\n',
+            '✓ Built in 1.2s\n',
+            '[DEBUG] cache miss for key abc123\n',
+            'data: {"type":"progress","percent":50}\n\n',
+            'error: ENOENT /tmp/missing.txt (non-fatal, skipping)\n',
+            '  at Object.openSync (node:fs:601:3)\n',
+            '  at readFileSync (node:fs:469:35)\n',
+            'data: {"type":"result","payload":{"name":"test","value":42}}\n\n',
+            'Shutting down gracefully...\n',
+            '[METRIC] requests=1024 latency_p99=12ms\n',
+            'data: {"type":"end","id":4}\n\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        const parsed = events.map((e) => {
+            return JSON.parse(e.data);
+        });
+        expect(parsed).toMatchInlineSnapshot(`
+			[
+			  {
+			    "id": 1,
+			    "type": "start",
+			  },
+			  {
+			    "percent": 50,
+			    "type": "progress",
+			  },
+			  {
+			    "payload": {
+			      "name": "test",
+			      "value": 42,
+			    },
+			    "type": "result",
+			  },
+			  {
+			    "id": 4,
+			    "type": "end",
+			  },
+			]
+		`);
+    });
+    test('handles data: lines split across chunks', () => {
+        const chunks = [
+            'some garbage\n',
+            'dat',
+            'a: {"split":true}\n\n',
+            'more garbage\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        const parsed = events.map((e) => {
+            return JSON.parse(e.data);
+        });
+        expect(parsed).toMatchInlineSnapshot(`
+			[
+			  {
+			    "split": true,
+			  },
+			]
+		`);
+    });
+    test('handles multi-line data fields', () => {
+        const chunks = [
+            '[LOG] something\n',
+            'data: {"line":1}\n',
+            'data: {"line":2}\n\n',
+            'noise\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        // multi-line data gets joined with newlines per SSE spec
+        expect(events.map((e) => {
+            return e.data;
+        })).toMatchInlineSnapshot(`
+			[
+			  "{"line":1}
+			{"line":2}",
+			]
+		`);
+    });
+    test('ignores lines that look like data but are not SSE format', () => {
+        const chunks = [
+            'database: connection established\n',
+            'data: {"real":"event"}\n\n',
+            'datadir: /var/lib/app\n',
+            'data:no-space-after-colon\n\n',
+            '  data: indented-data-line\n\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        expect(events.map((e) => {
+            return e.data;
+        })).toMatchInlineSnapshot(`
+			[
+			  "{"real":"event"}",
+			  "no-space-after-colon",
+			]
+		`);
+    });
+    test('data: in middle of a line', () => {
+        const chunks = [
+            'some prefix data: {"mid":true}\n\n',
+            'the output is data: not this\n\n',
+            'data: {"real":"event"}\n\n',
+            'foo=bar data: {"also":"mid"} more stuff\n\n',
+            '[2024-01-01] data: {"log":"entry"}\n\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        expect(events.map((e) => {
+            return e.data;
+        })).toMatchInlineSnapshot(`
+			[
+			  "{"real":"event"}",
+			]
+		`);
+    });
+    test('raw json without data: prefix', () => {
+        const chunks = [
+            '{"bare":"json"}\n\n',
+            'data: {"real":"event"}\n\n',
+            'some text {"embedded":"json"} more text\n\n',
+            '{"start":"of line"} trailing\n\n',
+            '  {"indented":"json"}\n\n',
+            '[{"array":"json"},{"second":"obj"}]\n\n',
+            'data: {"second":"real"}\n\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        expect(events.map((e) => {
+            return e.data;
+        })).toMatchInlineSnapshot(`
+			[
+			  "{"real":"event"}",
+			  "{"second":"real"}",
+			]
+		`);
+    });
+    test('other SSE fields from process noise pollute event metadata', () => {
+        const chunks = [
+            // process outputs that happen to match SSE field names
+            'id: proc-12345\n',
+            'event: error\n',
+            'retry: 5000\n',
+            ': this is a comment\n',
+            'data: {"real":"payload"}\n\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        // check if the garbage id:/event: lines leaked into the real event
+        expect(events.map((e) => {
+            return { data: e.data, id: e.id, event: e.event };
+        })).toMatchInlineSnapshot(`
+			[
+			  {
+			    "data": "{"real":"payload"}",
+			    "event": "error",
+			    "id": "proc-12345",
+			  },
+			]
+		`);
+    });
+    test('event: between two data events only affects the next one', () => {
+        const chunks = [
+            'data: {"first":"clean"}\n\n',
+            'event: contaminated\n',
+            'data: {"second":"dirty?"}\n\n',
+            'data: {"third":"clean again?"}\n\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        expect(events.map((e) => {
+            return { data: e.data, event: e.event };
+        })).toMatchInlineSnapshot(`
+			[
+			  {
+			    "data": "{"first":"clean"}",
+			    "event": undefined,
+			  },
+			  {
+			    "data": "{"second":"dirty?"}",
+			    "event": "contaminated",
+			  },
+			  {
+			    "data": "{"third":"clean again?"}",
+			    "event": undefined,
+			  },
+			]
+		`);
+    });
+    test('id: from noise persists across events', () => {
+        const chunks = [
+            'data: {"before":"id"}\n\n',
+            'id: noise-id-999\n',
+            'data: {"after":"id"}\n\n',
+            'data: {"later":"event"}\n\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        expect(events.map((e) => {
+            return { data: e.data, id: e.id };
+        })).toMatchInlineSnapshot(`
+			[
+			  {
+			    "data": "{"before":"id"}",
+			    "id": undefined,
+			  },
+			  {
+			    "data": "{"after":"id"}",
+			    "id": "noise-id-999",
+			  },
+			  {
+			    "data": "{"later":"event"}",
+			    "id": undefined,
+			  },
+			]
+		`);
+    });
+    test('realistic process output with dangerous prefixes', () => {
+        const chunks = [
+            'event loop blocked for 200ms\n',
+            'id: user-abc logged in\n',
+            'retry after 3 attempts\n',
+            'data: {"safe":"event"}\n\n',
+            'identifier: session-xyz\n',
+            'eventually consistent\n',
+            'retrying connection...\n',
+            'data: {"second":"event"}\n\n',
+        ];
+        const events = parseSSEFromChunks(chunks);
+        expect(events.map((e) => {
+            return { data: e.data, id: e.id, event: e.event };
+        })).toMatchInlineSnapshot(`
+			[
+			  {
+			    "data": "{"safe":"event"}",
+			    "event": undefined,
+			    "id": "user-abc logged in",
+			  },
+			  {
+			    "data": "{"second":"event"}",
+			    "event": undefined,
+			    "id": undefined,
+			  },
+			]
+		`);
+    });
+    test('works with rapid interleaved garbage and data', () => {
+        const garbage = [
+            '0x7fff5fbff8c0',
+            'Segfault at 0xDEADBEEF (just kidding)',
+            '█████████░░░░ 65%',
+            '🔥 hot reload triggered',
+            'npm warn deprecated lodash@3.0.0',
+        ];
+        const jsonPayloads = Array.from({ length: 10 }, (_, i) => {
+            return { seq: i, ts: 1000 + i };
+        });
+        const chunks = jsonPayloads.flatMap((payload, i) => {
+            return [
+                `${garbage[i % garbage.length]}\n`,
+                `data: ${JSON.stringify(payload)}\n\n`,
+            ];
+        });
+        const events = parseSSEFromChunks(chunks);
+        const parsed = events.map((e) => {
+            return JSON.parse(e.data);
+        });
+        expect(parsed).toMatchInlineSnapshot(`
+			[
+			  {
+			    "seq": 0,
+			    "ts": 1000,
+			  },
+			  {
+			    "seq": 1,
+			    "ts": 1001,
+			  },
+			  {
+			    "seq": 2,
+			    "ts": 1002,
+			  },
+			  {
+			    "seq": 3,
+			    "ts": 1003,
+			  },
+			  {
+			    "seq": 4,
+			    "ts": 1004,
+			  },
+			  {
+			    "seq": 5,
+			    "ts": 1005,
+			  },
+			  {
+			    "seq": 6,
+			    "ts": 1006,
+			  },
+			  {
+			    "seq": 7,
+			    "ts": 1007,
+			  },
+			  {
+			    "seq": 8,
+			    "ts": 1008,
+			  },
+			  {
+			    "seq": 9,
+			    "ts": 1009,
+			  },
+			]
+		`);
+    });
+});

package/dist/message-preprocessing.js

@@ -16,10 +16,12 @@ import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
 const logger = createLogger(LogPrefix.SESSION);
 const voiceLogger = createLogger(LogPrefix.VOICE);
-// Matches ". queue" at the end of a message (case-insensitive, ignoring trailing whitespace).
+// Matches punctuation + "queue" at the end of a message (case-insensitive).
+// Supports any common punctuation before "queue" (. ! ? , ; :) and an optional
+// trailing period: ". queue", "! queue", ". queue.", "!queue." etc.
 // When present the suffix is stripped and the message is routed through
 // kimaki's local queue (same as /queue command).
-const QUEUE_SUFFIX_RE = /\.\s*queue\s*$/i;
+const QUEUE_SUFFIX_RE = /[.!?,;:]\s*queue\.?\s*$/i;
 function extractQueueSuffix(prompt) {
     if (!QUEUE_SUFFIX_RE.test(prompt)) {
         return { prompt, forceQueue: false };

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

@@ -265,11 +265,46 @@ export function createDeterministicMatchers() {
             ],
         },
     };
+    // Question tool: model asks a question, user answers via text, model follows up
+    const questionToolMatcher = {
+        id: 'question-text-answer-marker',
+        priority: 106,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'QUESTION_TEXT_ANSWER_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'question-text-answer-call',
+                    toolName: 'question',
+                    input: JSON.stringify({
+                        questions: [{
+                                question: 'Which option do you prefer?',
+                                header: 'Pick one',
+                                options: [
+                                    { label: 'Alpha', description: 'Alpha option' },
+                                    { label: 'Beta', description: 'Beta option' },
+                                ],
+                            }],
+                    }),
+                },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
     return [
         slowAbortMatcher,
         typingRepulseMatcher,
         pluginTimeoutSleepMatcher,
         actionButtonClickFollowupMatcher,
+        questionToolMatcher,
         permissionTypingMatcher,
         permissionTypingFollowupMatcher,
         raceFinalReplyMatcher,