@brianli/kimaki 0.4.72-brianli.1

package/dist/commands/permissions.js

@@ -0,0 +1,163 @@
+// Permission button handler - Shows buttons for permission requests.
+// When OpenCode asks for permission, this module renders 3 buttons:
+// Accept, Accept Always, and Deny.
+import { ButtonBuilder, ButtonStyle, ActionRowBuilder, } from 'discord.js';
+import crypto from 'node:crypto';
+import { getOpencodeClient } from '../opencode.js';
+import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.PERMISSIONS);
+function wildcardMatch({ value, pattern, }) {
+    let escapedPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    if (escapedPattern.endsWith(' .*')) {
+        escapedPattern = escapedPattern.slice(0, -3) + '( .*)?';
+    }
+    return new RegExp(`^${escapedPattern}$`, 's').test(value);
+}
+export function arePatternsCoveredBy({ patterns, coveringPatterns, }) {
+    return patterns.every((pattern) => {
+        return coveringPatterns.some((coveringPattern) => {
+            return wildcardMatch({ value: pattern, pattern: coveringPattern });
+        });
+    });
+}
+export function compactPermissionPatterns(patterns) {
+    const uniquePatterns = Array.from(new Set(patterns));
+    return uniquePatterns.filter((pattern, index) => {
+        return !uniquePatterns.some((candidate, candidateIndex) => {
+            if (candidateIndex === index) {
+                return false;
+            }
+            return wildcardMatch({ value: pattern, pattern: candidate });
+        });
+    });
+}
+// Store pending permission contexts by hash
+export const pendingPermissionContexts = new Map();
+/**
+ * Show permission buttons for a permission request.
+ * Displays 3 buttons in a row: Accept, Accept Always, Deny.
+ * Returns the message ID and context hash for tracking.
+ */
+export async function showPermissionButtons({ thread, permission, directory, permissionDirectory, subtaskLabel, }) {
+    const contextHash = crypto.randomBytes(8).toString('hex');
+    const context = {
+        permission,
+        requestIds: [permission.id],
+        directory,
+        permissionDirectory,
+        thread,
+        contextHash,
+    };
+    pendingPermissionContexts.set(contextHash, context);
+    const patternStr = compactPermissionPatterns(permission.patterns).join(', ');
+    // Build 3 buttons for permission actions
+    const acceptButton = new ButtonBuilder()
+        .setCustomId(`permission_once:${contextHash}`)
+        .setLabel('Accept')
+        .setStyle(ButtonStyle.Success);
+    const acceptAlwaysButton = new ButtonBuilder()
+        .setCustomId(`permission_always:${contextHash}`)
+        .setLabel('Accept Always')
+        .setStyle(ButtonStyle.Success);
+    const denyButton = new ButtonBuilder()
+        .setCustomId(`permission_reject:${contextHash}`)
+        .setLabel('Deny')
+        .setStyle(ButtonStyle.Secondary);
+    const actionRow = new ActionRowBuilder().addComponents(acceptButton, acceptAlwaysButton, denyButton);
+    const subtaskLine = subtaskLabel ? `**From:** \`${subtaskLabel}\`\n` : '';
+    const fullContent = `⚠️ **Permission Required**\n` +
+        subtaskLine +
+        `**Type:** \`${permission.permission}\`\n` +
+        (patternStr ? `**Pattern:** \`${patternStr}\`` : '');
+    const permissionMessage = await thread.send({
+        content: fullContent.slice(0, 1900),
+        components: [actionRow],
+        flags: NOTIFY_MESSAGE_FLAGS,
+    });
+    logger.log(`Showed permission buttons for ${permission.id}`);
+    return { messageId: permissionMessage.id, contextHash };
+}
+/**
+ * Handle button click for permission.
+ */
+export async function handlePermissionButton(interaction) {
+    const customId = interaction.customId;
+    // Extract action and hash from customId (e.g., "permission_once:abc123")
+    const [actionPart, contextHash] = customId.split(':');
+    if (!actionPart || !contextHash) {
+        return;
+    }
+    const response = actionPart.replace('permission_', '');
+    const context = pendingPermissionContexts.get(contextHash);
+    if (!context) {
+        await interaction.update({ components: [] });
+        return;
+    }
+    await interaction.deferUpdate();
+    try {
+        const permClient = getOpencodeClient(context.directory);
+        if (!permClient) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        const requestIds = context.requestIds.length > 0
+            ? context.requestIds
+            : [context.permission.id];
+        await Promise.all(requestIds.map((requestId) => {
+            return permClient.permission.reply({
+                requestID: requestId,
+                directory: context.permissionDirectory,
+                reply: response,
+            });
+        }));
+        pendingPermissionContexts.delete(contextHash);
+        // Update message: show result and remove dropdown
+        const resultText = (() => {
+            switch (response) {
+                case 'once':
+                    return '✅ Permission **accepted**';
+                case 'always':
+                    return '✅ Permission **accepted** (auto-approve similar requests)';
+                case 'reject':
+                    return '❌ Permission **rejected**';
+            }
+        })();
+        const patternStr = compactPermissionPatterns(context.permission.patterns).join(', ');
+        await interaction.editReply({
+            content: `⚠️ **Permission Required**\n` +
+                `**Type:** \`${context.permission.permission}\`\n` +
+                (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+                resultText,
+            components: [], // Remove the buttons
+        });
+        logger.log(`Permission ${context.permission.id} ${response} (${requestIds.length} request(s))`);
+    }
+    catch (error) {
+        logger.error('Error handling permission:', error);
+        await interaction.editReply({
+            content: `Failed to process permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+export function addPermissionRequestToContext({ contextHash, requestId, }) {
+    const context = pendingPermissionContexts.get(contextHash);
+    if (!context) {
+        return false;
+    }
+    if (context.requestIds.includes(requestId)) {
+        return false;
+    }
+    context.requestIds = [...context.requestIds, requestId];
+    pendingPermissionContexts.set(contextHash, context);
+    return true;
+}
+/**
+ * Clean up a pending permission context (e.g., on auto-reject).
+ */
+export function cleanupPermissionContext(contextHash) {
+    pendingPermissionContexts.delete(contextHash);
+}

package/dist/commands/queue.js

@@ -0,0 +1,217 @@
+// Queue commands - /queue, /queue-command, /clear-queue
+import { ChannelType, MessageFlags } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { resolveWorkingDirectory, sendThreadMessage, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { handleOpencodeSession, abortControllers, addToQueue, getQueueLength, clearQueue, queueOrSendMessage, } from '../session-handler.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { notifyError } from '../sentry.js';
+import { registeredUserCommands } from '../config.js';
+const logger = createLogger(LogPrefix.QUEUE);
+export async function handleQueueCommand({ command, appId, }) {
+    const message = command.options.getString('message', true);
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const result = await queueOrSendMessage({
+        thread: channel,
+        prompt: message,
+        userId: command.user.id,
+        username: command.user.displayName,
+        appId,
+    });
+    if (result.action === 'no-session') {
+        await command.reply({
+            content: 'No active session in this thread. Send a message directly instead.',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (result.action === 'no-directory') {
+        await command.reply({
+            content: 'Could not determine project directory',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (result.action === 'sent') {
+        await command.reply({
+            content: `» **${command.user.displayName}:** ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.reply({
+        content: `Message queued (position: ${result.position}). Will be sent after current response.`,
+        flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    });
+}
+export async function handleClearQueueCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const queueLength = getQueueLength(channel.id);
+    if (queueLength === 0) {
+        await command.reply({
+            content: 'No messages in queue',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    clearQueue(channel.id);
+    await command.reply({
+        content: `🗑 Cleared ${queueLength} queued message${queueLength > 1 ? 's' : ''}`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    logger.log(`[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`);
+}
+export async function handleQueueCommandCommand({ command, appId, }) {
+    const commandName = command.options.getString('command', true);
+    const args = command.options.getString('arguments') || '';
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread. Send a message directly instead.',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Validate command exists in registered user commands
+    const isKnownCommand = registeredUserCommands.some((cmd) => {
+        return cmd.name === commandName;
+    });
+    if (!isKnownCommand) {
+        await command.reply({
+            content: `Unknown command: /${commandName}. Use autocomplete to pick from available commands.`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const commandPayload = { name: commandName, arguments: args };
+    const displayText = `/${commandName}`;
+    // Check if there's an active request running
+    const existingController = abortControllers.get(sessionId);
+    const hasActiveRequest = Boolean(existingController && !existingController.signal.aborted);
+    if (existingController && existingController.signal.aborted) {
+        abortControllers.delete(sessionId);
+    }
+    if (!hasActiveRequest) {
+        const resolved = await resolveWorkingDirectory({
+            channel: channel,
+        });
+        if (!resolved) {
+            await command.reply({
+                content: 'Could not determine project directory',
+                flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `» **${command.user.displayName}:** ${displayText}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`[QUEUE] No active request, sending command immediately in thread ${channel.id}`);
+        handleOpencodeSession({
+            prompt: '',
+            thread: channel,
+            projectDirectory: resolved.projectDirectory,
+            channelId: channel.parentId || channel.id,
+            command: commandPayload,
+            appId,
+        }).catch(async (e) => {
+            logger.error(`[QUEUE] Failed to send command:`, e);
+            void notifyError(e, 'Queue: failed to send command');
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            await sendThreadMessage(channel, `Failed: ${errorMsg.slice(0, 200)}`);
+        });
+        return;
+    }
+    // Add to queue with command payload
+    const queuePosition = addToQueue({
+        threadId: channel.id,
+        message: {
+            prompt: '',
+            userId: command.user.id,
+            username: command.user.displayName,
+            queuedAt: Date.now(),
+            appId,
+            command: commandPayload,
+        },
+    });
+    await command.reply({
+        content: `Command queued (position: ${queuePosition}): ${displayText}`,
+        flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    });
+    logger.log(`[QUEUE] User ${command.user.displayName} queued command /${commandName} in thread ${channel.id}`);
+}
+export async function handleQueueCommandAutocomplete({ interaction, }) {
+    const focused = interaction.options.getFocused(true);
+    if (focused.name !== 'command') {
+        await interaction.respond([]);
+        return;
+    }
+    const query = focused.value.toLowerCase();
+    const choices = registeredUserCommands
+        .filter((cmd) => {
+        return cmd.name.toLowerCase().includes(query);
+    })
+        .slice(0, 25)
+        .map((cmd) => ({
+        name: `/${cmd.name} - ${cmd.description}`.slice(0, 100),
+        value: cmd.name.slice(0, 100),
+    }));
+    await interaction.respond(choices);
+}

package/dist/commands/remove-project.js

@@ -0,0 +1,115 @@
+// /remove-project command - Remove Discord channels for a project.
+import path from 'node:path';
+import * as errore from 'errore';
+import { findChannelsByDirectory, deleteChannelDirectoriesByDirectory, getAllTextChannelDirectories, } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { abbreviatePath } from '../utils.js';
+const logger = createLogger(LogPrefix.REMOVE_PROJECT);
+export async function handleRemoveProjectCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const directory = command.options.getString('project', true);
+    const guild = command.guild;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    try {
+        // Get channel IDs for this directory
+        const channels = await findChannelsByDirectory({ directory });
+        if (channels.length === 0) {
+            await command.editReply(`No channels found for directory: \`${directory}\``);
+            return;
+        }
+        const deletedChannels = [];
+        const failedChannels = [];
+        for (const { channel_id, channel_type } of channels) {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (channel instanceof Error) {
+                logger.error(`Failed to fetch channel ${channel_id}:`, channel);
+                failedChannels.push(`${channel_type}: ${channel_id}`);
+                continue;
+            }
+            if (channel) {
+                try {
+                    await channel.delete(`Removed by /remove-project command`);
+                    deletedChannels.push(`${channel_type}: ${channel_id}`);
+                }
+                catch (error) {
+                    logger.error(`Failed to delete channel ${channel_id}:`, error);
+                    failedChannels.push(`${channel_type}: ${channel_id}`);
+                }
+            }
+            else {
+                deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`);
+            }
+        }
+        // Remove from database
+        await deleteChannelDirectoriesByDirectory(directory);
+        const projectName = path.basename(directory);
+        let message = `Removed project **${projectName}**\n`;
+        message += `Directory: \`${directory}\`\n\n`;
+        if (deletedChannels.length > 0) {
+            message += `Deleted channels:\n${deletedChannels.map((c) => `- ${c}`).join('\n')}`;
+        }
+        if (failedChannels.length > 0) {
+            message += `\n\nFailed to delete (may be in another server):\n${failedChannels.map((c) => `- ${c}`).join('\n')}`;
+        }
+        await command.editReply(message);
+        logger.log(`Removed project ${projectName} at ${directory}`);
+    }
+    catch (error) {
+        logger.error('[REMOVE-PROJECT] Error:', error);
+        await command.editReply(`Failed to remove project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    const guild = interaction.guild;
+    if (!guild) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        // Get all directories with channels
+        const allChannels = (await findChannelsByDirectory({
+            channelType: 'text',
+        }));
+        // Filter to only channels that exist in this guild
+        const projectsInGuild = [];
+        for (const { directory, channel_id } of allChannels) {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (channel instanceof Error) {
+                // Channel not in this guild, skip
+                continue;
+            }
+            if (channel) {
+                projectsInGuild.push({ directory, channelId: channel_id });
+            }
+        }
+        const projects = projectsInGuild
+            .filter(({ directory }) => {
+            const baseName = path.basename(directory);
+            const searchText = `${baseName} ${directory}`.toLowerCase();
+            return searchText.includes(focusedValue.toLowerCase());
+        })
+            .slice(0, 25)
+            .map(({ directory }) => {
+            const name = `${path.basename(directory)} (${abbreviatePath(directory)})`;
+            return {
+                name: name.length > 100 ? name.slice(0, 99) + '...' : name,
+                value: directory,
+            };
+        });
+        await interaction.respond(projects);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+        await interaction.respond([]);
+    }
+}

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

@@ -0,0 +1,116 @@
+// /restart-opencode-server command - Restart the opencode server for the current channel.
+// Used for resolving opencode state issues, internal bugs, refreshing auth state, plugins, etc.
+// Aborts all in-progress sessions in this channel before restarting to avoid orphaned requests.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { initializeOpencodeForDirectory, restartOpencodeServer, } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { getAllThreadSessionIds, getThreadIdBySessionId } from '../database.js';
+import { abortControllers } from '../session-handler.js';
+import { SessionAbortError } from '../errors.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.OPENCODE);
+export async function handleRestartOpencodeServerCommand({ command, appId, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const isTextChannel = channel.type === ChannelType.GuildText;
+    if (!isThread && !isTextChannel) {
+        await command.reply({
+            content: 'This command can only be used in text channels or threads',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory, channelAppId } = resolved;
+    if (channelAppId && channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is not configured for this bot',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Defer reply since restart may take a moment
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    // Abort all in-progress sessions in this channel before restarting.
+    // Find sessions with active abort controllers, check if their thread belongs
+    // to this channel (thread parentId matches, or command was run in the thread itself).
+    const parentChannelId = isThread
+        ? channel.parentId
+        : channel.id;
+    const activeSessionIds = [...abortControllers.keys()];
+    let abortedCount = 0;
+    if (activeSessionIds.length > 0) {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const client = !(getClient instanceof Error) ? getClient : null;
+        for (const sessionId of activeSessionIds) {
+            const threadId = await getThreadIdBySessionId(sessionId);
+            if (!threadId) {
+                continue;
+            }
+            // Check if thread belongs to this channel: either the thread IS this channel,
+            // or the thread's parent matches the parent channel
+            const threadChannel = await errore.tryAsync(() => {
+                return command.client.channels.fetch(threadId);
+            });
+            if (threadChannel instanceof Error || !threadChannel) {
+                continue;
+            }
+            const threadParentId = 'parentId' in threadChannel ? threadChannel.parentId : null;
+            if (threadId !== channel.id && threadParentId !== parentChannelId) {
+                continue;
+            }
+            const controller = abortControllers.get(sessionId);
+            if (controller) {
+                logger.log(`[RESTART] Aborting session ${sessionId} in thread ${threadId}`);
+                controller.abort(new SessionAbortError({ reason: 'server-restart' }));
+                abortControllers.delete(sessionId);
+                abortedCount++;
+            }
+            if (client) {
+                await errore.tryAsync(() => {
+                    return client().session.abort({ sessionID: sessionId });
+                });
+            }
+        }
+    }
+    if (abortedCount > 0) {
+        logger.log(`[RESTART] Aborted ${abortedCount} active session(s) before restart`);
+    }
+    logger.log(`[RESTART] Restarting opencode server for directory: ${projectDirectory}`);
+    const result = await restartOpencodeServer(projectDirectory);
+    if (result instanceof Error) {
+        logger.error('[RESTART] Failed:', result);
+        await command.editReply({
+            content: `Failed to restart opencode server: ${result.message}`,
+        });
+        return;
+    }
+    const abortMsg = abortedCount > 0
+        ? ` (aborted ${abortedCount} active session${abortedCount > 1 ? 's' : ''})`
+        : '';
+    await command.editReply({
+        content: `Opencode server **restarted** successfully${abortMsg}`,
+    });
+    logger.log(`[RESTART] Opencode server restarted for directory: ${projectDirectory}`);
+}