kimaki 0.11.0 → 0.13.0

package/dist/commands/model.js

@@ -11,6 +11,20 @@ import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const modelLogger = createLogger(LogPrefix.MODEL);
+function buildSafeSelectOption({ label, value, description, }) {
+    const trimmedLabel = label?.trim();
+    const trimmedValue = value?.trim();
+    const safeLabel = (trimmedLabel || trimmedValue || 'Unknown').slice(0, 100);
+    const safeValue = trimmedValue || trimmedLabel || '';
+    if (!safeLabel || !safeValue) {
+        return undefined;
+    }
+    return {
+        label: safeLabel,
+        value: safeValue,
+        description: description?.slice(0, 100),
+    };
+}
 // Store context by hash to avoid customId length limits (Discord max: 100 chars).
 // Entries are TTL'd to prevent unbounded growth when users open /model and never
 // interact with the select menu.
@@ -172,7 +186,7 @@ export async function getCurrentModelInfo({ sessionId, channelId, appId, agentPr
 export async function handleModelCommand({ interaction, appId, }) {
     modelLogger.log('[MODEL] handleModelCommand called');
     // Defer reply immediately to avoid 3-second timeout
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    await interaction.deferReply();
     modelLogger.log('[MODEL] Deferred reply');
     const channel = interaction.channel;
     if (!channel) {
@@ -307,15 +321,16 @@ export async function handleModelCommand({ interaction, appId, }) {
         const contextHash = crypto.randomBytes(8).toString('hex');
         setModelContext(contextHash, context);
         const allProviderOptions = [...availableProviders]
-            .sort((a, b) => a.name.localeCompare(b.name))
+            .sort((a, b) => (a.name || a.id || '').localeCompare(b.name || b.id || ''))
             .map((provider) => {
             const modelCount = Object.keys(provider.models || {}).length;
-            return {
-                label: provider.name.slice(0, 100),
+            return buildSafeSelectOption({
+                label: provider.name,
                 value: provider.id,
-                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
-            };
-        });
+                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`,
+            });
+        })
+            .filter((option) => !!option);
         const { options } = buildPaginatedOptions({
             allOptions: allProviderOptions,
             page: 0,
@@ -383,15 +398,16 @@ export async function handleProviderSelectMenu(interaction) {
         const { all: allProviders, connected } = providersResponse.data;
         const availableProviders = allProviders.filter((p) => connected.includes(p.id));
         const allProviderOptions = [...availableProviders]
-            .sort((a, b) => a.name.localeCompare(b.name))
+            .sort((a, b) => (a.name || a.id || '').localeCompare(b.name || b.id || ''))
             .map((p) => {
             const modelCount = Object.keys(p.models || {}).length;
-            return {
-                label: p.name.slice(0, 100),
+            return buildSafeSelectOption({
+                label: p.name,
                 value: p.id,
-                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
-            };
-        });
+                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`,
+            });
+        })
+            .filter((option) => !!option);
         const { options } = buildPaginatedOptions({ allOptions: allProviderOptions, page: providerNavPage });
         const selectMenu = new StringSelectMenuBuilder()
             .setCustomId(`model_provider:${contextHash}`)
@@ -434,10 +450,11 @@ export async function handleProviderSelectMenu(interaction) {
         const models = Object.entries(provider.models || {})
             .map(([modelId, model]) => ({
             id: modelId,
-            name: model.name,
+            name: model.name || modelId,
             releaseDate: model.release_date,
         }))
-            .sort((a, b) => a.name.localeCompare(b.name));
+            .filter((model) => model.id && model.name)
+            .sort((a, b) => (a.name || a.id || '').localeCompare(b.name || b.id || ''));
         if (models.length === 0) {
             await interaction.editReply({
                 content: `No models available for ${provider.name}`,
@@ -447,19 +464,21 @@ export async function handleProviderSelectMenu(interaction) {
         }
         // Update context with provider info and reuse the same hash
         context.providerId = selectedProviderId;
-        context.providerName = provider.name;
+        context.providerName = provider.name?.trim() || provider.id;
         context.modelPage = 0;
         setModelContext(contextHash, context);
-        const allModelOptions = models.map((model) => {
+        const allModelOptions = models
+            .map((model) => {
             const dateStr = model.releaseDate
                 ? new Date(model.releaseDate).toLocaleDateString()
                 : 'Unknown date';
-            return {
-                label: model.name.slice(0, 100),
+            return buildSafeSelectOption({
+                label: model.name,
                 value: model.id,
-                description: dateStr.slice(0, 100),
-            };
-        });
+                description: dateStr,
+            });
+        })
+            .filter((option) => !!option);
         const { options } = buildPaginatedOptions({
             allOptions: allModelOptions,
             page: 0,
@@ -527,13 +546,14 @@ export async function handleModelSelectMenu(interaction) {
             return;
         }
         const allModelOptions = Object.entries(provider.models || {})
-            .map(([modelId, model]) => ({
-            label: model.name.slice(0, 100),
+            .map(([modelId, model]) => buildSafeSelectOption({
+            label: model.name || modelId,
             value: modelId,
-            description: (model.release_date
+            description: model.release_date
                 ? new Date(model.release_date).toLocaleDateString()
-                : 'Unknown date').slice(0, 100),
+                : 'Unknown date',
         }))
+            .filter((option) => !!option)
             .sort((a, b) => a.label.localeCompare(b.label));
         const { options } = buildPaginatedOptions({ allOptions: allModelOptions, page: modelNavPage });
         const selectMenu = new StringSelectMenuBuilder()
@@ -708,7 +728,7 @@ export async function handleModelScopeSelectMenu(interaction) {
     const modelDisplay = modelId.split('/')[1] || modelId;
     const variant = context.selectedVariant ?? null;
     const variantSuffix = variant ? ` (${variant})` : '';
-    const agentTip = '\n_Tip: create [agent .md files](https://github.com/remorses/kimaki/blob/main/docs/model-switching.md) in .opencode/agent/ for one-command model switching_';
+    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/docs/model-switching) in .opencode/agent/ for one-command model switching_';
     try {
         if (selectedScope === 'session') {
             if (!context.sessionId) {

package/dist/commands/restart-opencode-server.js

@@ -46,7 +46,7 @@ export async function handleRestartOpencodeServerCommand({ command, appId, }) {
     }
     const { projectDirectory } = resolved;
     // Defer reply since restart may take a moment
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     // Dispose all runtimes for this directory/channel scope.
     // disposeRuntimesForDirectory aborts active runs, kills listeners, and
     // removes runtimes from the registry. Scoped by channelId so runtimes

package/dist/commands/undo-redo.js

@@ -58,7 +58,7 @@ export async function handleUndoCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
         await command.editReply(`Failed to undo: ${getClient.message}`);
@@ -209,7 +209,7 @@ export async function handleRedoCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
         await command.editReply(`Failed to redo: ${getClient.message}`);

package/dist/commands/unset-model.js

@@ -1,5 +1,5 @@
 // /unset-model-override command - Remove model overrides and use default instead.
-import { ChatInputCommandInteraction, ChannelType, MessageFlags, } from 'discord.js';
+import { ChatInputCommandInteraction, ChannelType, } from 'discord.js';
 import { getChannelModel, getSessionModel, getThreadSession, clearSessionModel, } from '../database.js';
 import { getDb } from '../db.js';
 import * as orm from 'drizzle-orm';
@@ -35,7 +35,7 @@ function formatModelSource(type, agentName) {
  */
 export async function handleUnsetModelCommand({ interaction, appId, }) {
     unsetModelLogger.log('[UNSET-MODEL] handleUnsetModelCommand called');
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    await interaction.deferReply();
     const channel = interaction.channel;
     if (!channel) {
         await interaction.editReply({

package/dist/commands/upgrade.js

@@ -1,13 +1,12 @@
 // /upgrade-and-restart command - Upgrade kimaki to the latest version and restart the bot.
 // Checks npm for a newer version, installs it globally, then spawns a new kimaki process.
 // The new process kills the old one on startup (kimaki's single-instance lock).
-import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getCurrentVersion, upgrade } from '../upgrade.js';
 import { spawn } from 'node:child_process';
 const logger = createLogger(LogPrefix.CLI);
 export async function handleUpgradeAndRestartCommand({ command, }) {
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     logger.log('[UPGRADE] /upgrade-and-restart triggered');
     try {
         const currentVersion = getCurrentVersion();

package/dist/commands/verbosity.js

@@ -85,7 +85,6 @@ export async function handleVerbosityCommand({ command, }) {
     await command.reply({
         content: `**Verbosity**\nCurrent: \`${currentLevel}\` (${source})`,
         components: [actionRow],
-        flags: MessageFlags.Ephemeral,
     });
 }
 /**

package/dist/commands/worktree-settings.js

@@ -37,6 +37,5 @@ export async function handleToggleWorktreesCommand({ command, }) {
         content: nextEnabled
             ? `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${channel.name}** will now automatically create git worktrees.\n\nNew setting for **#${channel.name}**: **enabled**.`
             : `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${channel.name}** will use the main project directory.\n\nNew setting for **#${channel.name}**: **disabled**.`,
-        flags: MessageFlags.Ephemeral,
     });
 }

package/dist/discord-bot.js

@@ -6,14 +6,14 @@ import { stopOpencodeServer, } from './opencode.js';
 import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
 import { resolveSessionWorkingDirectory, git, isGitRepositoryRoot } from './worktrees.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
-import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, } from './discord-utils.js';
+import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, resolveGuildMessageMember, } from './discord-utils.js';
 import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
 import YAML from 'yaml';
 import { getTextAttachments, resolveMentions, } from './message-formatting.js';
-import { extractBtwPrefix } from './btw-prefix-detection.js';
+import { extractBtwSuffix } from './btw-prefix-detection.js';
 import { isVoiceAttachment } from './voice-attachment.js';
 import { forkSessionToBtwThread } from './commands/btw.js';
-import { getChannelReferencePermissionRules, preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
+import { extractQueueSuffix, getChannelReferencePermissionRules, preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
 import { cancelPendingActionButtons } from './commands/action-buttons.js';
 import { cancelPendingQuestion, hasPendingQuestionForThread } from './commands/ask-question.js';
 import { cancelPendingFileUpload } from './commands/file-upload.js';
@@ -30,6 +30,7 @@ import { markDiscordGatewayReady, stopHranaServer } from './hrana-server.js';
 import { notifyError } from './sentry.js';
 import { flushDebouncedProcessCallbacks } from './debounced-process-flush.js';
 import { startRuntimeIdleSweeper } from './runtime-idle-sweeper.js';
+import { store } from './store.js';
 import { startExternalOpencodeSessionSync, stopExternalOpencodeSessionSync, } from './external-opencode-sync.js';
 export { initDatabase, closeDatabase, getChannelDirectory, } from './database.js';
 export { initializeOpencodeForDirectory } from './opencode.js';
@@ -144,6 +145,7 @@ export async function createDiscordClient() {
     // Read REST API URL lazily so gateway mode can set store.discordBaseUrl
     // after module import but before client creation.
     const restApiUrl = getDiscordRestApiUrl();
+    const { allowedMentions } = store.getState();
     return new Client({
         intents: [
             GatewayIntentBits.Guilds,
@@ -158,6 +160,7 @@ export async function createDiscordClient() {
             Partials.ThreadMember,
         ],
         rest: { api: restApiUrl },
+        allowedMentions: { parse: allowedMentions },
     });
 }
 export async function startDiscordBot({ token, appId, discordClient, useWorktrees, }) {
@@ -304,7 +307,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             // still need Kimaki permission so multi-agent orchestration stays opt-in.
             const isInjectedSelfBotMessage = isCliInjectedPrompt && message.author?.id === discordClient.user?.id;
             if (message.author?.bot && !isInjectedSelfBotMessage) {
-                if (!hasKimakiBotPermission(message.member)) {
+                const member = await resolveGuildMessageMember(message);
+                if (!hasKimakiBotPermission(member, message.guild)) {
                     return;
                 }
             }
@@ -343,15 +347,19 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     }
                 }
             }
-            if (!isCliInjectedPrompt && message.guild && message.member) {
-                if (hasNoKimakiRole(message.member)) {
+            if (!isCliInjectedPrompt && message.guild) {
+                const member = await resolveGuildMessageMember(message);
+                if (!member) {
+                    return;
+                }
+                if (hasNoKimakiRole(member)) {
                     await message.reply({
                         content: `You have the **no-kimaki** role which blocks bot access.\nRemove this role to use Kimaki.`,
                         flags: SILENT_MESSAGE_FLAGS,
                     });
                     return;
                 }
-                if (!hasKimakiBotPermission(message.member)) {
+                if (!hasKimakiBotPermission(member, message.guild)) {
                     await message.reply({
                         content: `You don't have permission to start sessions.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
                         flags: SILENT_MESSAGE_FLAGS,
@@ -450,18 +458,17 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         return;
                     }
                 }
-                // Raw `btw ` mirrors /btw for fast side-question forks from Discord.
-                // Keep this at ingress instead of preprocess because it must create a
-                // new thread/runtime, not just transform the current prompt.
-                // Voice-transcribed `btw` still goes through normal preprocessing.
-                const btwShortcut = projectDirectory && worktreeInfo?.status !== 'pending'
-                    ? extractBtwPrefix(message.content || '')
+                // `. btw` suffix mirrors /btw for fast side-question forks.
+                // Works like queue: just the word "btw" at the end after punctuation
+                // or newline. The whole message (minus the suffix) becomes the fork prompt.
+                const btwResult = projectDirectory && worktreeInfo?.status !== 'pending'
+                    ? extractBtwSuffix(message.content || '')
                     : null;
-                if (btwShortcut && projectDirectory) {
+                if (btwResult?.forceBtw && projectDirectory) {
                     const result = await forkSessionToBtwThread({
                         sourceThread: thread,
                         projectDirectory,
-                        prompt: btwShortcut.prompt,
+                        prompt: btwResult.prompt,
                         userId: message.author.id,
                         username: message.member?.displayName || message.author.displayName,
                         appId: currentAppId,
@@ -738,6 +745,49 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             }
         }
     });
+    // Handle user message edits to update queued messages.
+    // When a user edits a message that is still waiting in kimaki's local queue,
+    // the queue item is updated with the new content. If the edit removes the
+    // queue suffix, the item is removed from the queue.
+    discordClient.on(Events.MessageUpdate, async (_oldMessage, newMessage) => {
+        try {
+            // Fetch full message if partial (cache miss). Needed for mentions
+            // and content to be fully resolved.
+            const message = newMessage.partial
+                ? await newMessage.fetch().catch(() => null)
+                : newMessage;
+            if (!message)
+                return;
+            if (message.author.bot)
+                return;
+            if (!message.content)
+                return;
+            const channel = message.channel;
+            const isThread = [
+                ChannelType.PublicThread,
+                ChannelType.PrivateThread,
+                ChannelType.AnnouncementThread,
+            ].includes(channel.type);
+            if (!isThread)
+                return;
+            const runtime = getRuntime(channel.id);
+            if (!runtime)
+                return;
+            // Use resolveMentions to match initial preprocessing and preserve
+            // newlines (stripMentions collapses them, breaking final-line queue
+            // suffix detection).
+            const { prompt, forceQueue } = extractQueueSuffix(resolveMentions(message));
+            // If the edit removed the queue suffix, remove the item from the queue.
+            // If the suffix is still present, update the prompt.
+            const result = runtime.updateQueuedMessage(message.id, forceQueue ? prompt : '');
+            if (result.found) {
+                discordLogger.log(`[MESSAGE_EDIT] ${result.removed ? 'Removed' : 'Updated'} queued message ${message.id} in thread ${channel.id}`);
+            }
+        }
+        catch (error) {
+            discordLogger.error('Error handling message update:', error instanceof Error ? error.stack : String(error));
+        }
+    });
     // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
     // Uses JSON embed marker to pass options (start, worktree name)
     discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {

package/dist/discord-command-registration.js

@@ -395,7 +395,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDMPermission(false)
             .addStringOption((opt) => opt
             .setName('prompt')
-            .setDescription('Send a one-shot prompt with this agent without switching')
+            .setDescription('Send a prompt with this agent')
             .setRequired(false))
             .toJSON());
     }

package/dist/discord-utils.js

@@ -72,6 +72,20 @@ export function hasKimakiAdminPermission(member, guild) {
     const hasKimakiRole = hasRoleByName(member, 'kimaki', guild);
     return isOwner || isAdmin || canManageServer || hasKimakiRole;
 }
+export async function resolveGuildMessageMember(message) {
+    if (!message.guild)
+        return null;
+    if (message.member)
+        return message.member;
+    const fetchedMember = await message.guild.members
+        .fetch(message.author.id)
+        .catch((e) => new Error('Failed to fetch guild member', { cause: e }));
+    if (fetchedMember instanceof Error) {
+        discordLogger.warn(`[PERMISSION] Denying message ${message.id}: ${fetchedMember.message}`);
+        return null;
+    }
+    return fetchedMember;
+}
 function hasRoleByName(member, roleName, guild) {
     const target = roleName.toLowerCase();
     if (member instanceof GuildMember) {

package/dist/discord-utils.test.js

@@ -1,6 +1,6 @@
 import { PermissionsBitField } from 'discord.js';
 import { afterEach, describe, expect, test } from 'vitest';
-import { hasKimakiAdminPermission, hasKimakiBotPermission, splitMarkdownForDiscord } from './discord-utils.js';
+import { hasKimakiAdminPermission, hasKimakiBotPermission, resolveGuildMessageMember, splitMarkdownForDiscord, } from './discord-utils.js';
 import { store } from './store.js';
 describe('splitMarkdownForDiscord', () => {
     test('never returns chunks over the max length with code fences', () => {
@@ -198,3 +198,53 @@ describe('hasKimakiAdminPermission', () => {
         expect(hasKimakiAdminPermission(member, guild)).toBe(true);
     });
 });
+describe('resolveGuildMessageMember', () => {
+    test('uses hydrated message member without fetching', async () => {
+        const member = { id: 'member-id' };
+        const message = {
+            guild: {
+                members: {
+                    fetch() {
+                        throw new Error('should not fetch');
+                    },
+                },
+            },
+            member,
+            author: { id: 'member-id' },
+            id: 'message-id',
+        };
+        await expect(resolveGuildMessageMember(message)).resolves.toBe(member);
+    });
+    test('fetches missing guild message member', async () => {
+        const member = { id: 'member-id' };
+        const message = {
+            guild: {
+                members: {
+                    fetch(id) {
+                        expect(id).toBe('member-id');
+                        return Promise.resolve(member);
+                    },
+                },
+            },
+            member: null,
+            author: { id: 'member-id' },
+            id: 'message-id',
+        };
+        await expect(resolveGuildMessageMember(message)).resolves.toBe(member);
+    });
+    test('denies when missing guild message member cannot be fetched', async () => {
+        const message = {
+            guild: {
+                members: {
+                    fetch() {
+                        return Promise.reject(new Error('missing member'));
+                    },
+                },
+            },
+            member: null,
+            author: { id: 'member-id' },
+            id: 'message-id',
+        };
+        await expect(resolveGuildMessageMember(message)).resolves.toBe(null);
+    });
+});