kimaki 0.4.22 → 0.4.24

package/dist/interaction-handler.js

@@ -0,0 +1,750 @@
+import { ChannelType, Events, ThreadAutoArchiveDuration, } from 'discord.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { getDatabase } from './database.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
+import { sendThreadMessage, resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
+import { handleForkCommand, handleForkSelectMenu } from './fork.js';
+import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, } from './model-command.js';
+import { formatPart } from './message-formatting.js';
+import { createProjectChannels } from './channel-management.js';
+import { handleOpencodeSession, parseSlashCommand, abortControllers, pendingPermissions, } from './session-handler.js';
+import { extractTagsArrays } from './xml.js';
+import { createLogger } from './logger.js';
+const discordLogger = createLogger('DISCORD');
+const interactionLogger = createLogger('INTERACTION');
+export function registerInteractionHandler({ discordClient, appId, }) {
+    interactionLogger.log('[REGISTER] Interaction handler registered');
+    discordClient.on(Events.InteractionCreate, async (interaction) => {
+        try {
+            interactionLogger.log(`[INTERACTION] Received: ${interaction.type} - ${interaction.isChatInputCommand() ? interaction.commandName : interaction.isAutocomplete() ? `autocomplete:${interaction.commandName}` : 'other'}`);
+            if (interaction.isAutocomplete()) {
+                if (interaction.commandName === 'resume') {
+                    const focusedValue = interaction.options.getFocused();
+                    let projectDirectory;
+                    if (interaction.channel) {
+                        const textChannel = await resolveTextChannel(interaction.channel);
+                        if (textChannel) {
+                            const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
+                            if (channelAppId && channelAppId !== appId) {
+                                await interaction.respond([]);
+                                return;
+                            }
+                            projectDirectory = directory;
+                        }
+                    }
+                    if (!projectDirectory) {
+                        await interaction.respond([]);
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        const sessionsResponse = await getClient().session.list();
+                        if (!sessionsResponse.data) {
+                            await interaction.respond([]);
+                            return;
+                        }
+                        const existingSessionIds = new Set(getDatabase()
+                            .prepare('SELECT session_id FROM thread_sessions')
+                            .all().map((row) => row.session_id));
+                        const sessions = sessionsResponse.data
+                            .filter((session) => !existingSessionIds.has(session.id))
+                            .filter((session) => session.title
+                            .toLowerCase()
+                            .includes(focusedValue.toLowerCase()))
+                            .slice(0, 25)
+                            .map((session) => {
+                            const dateStr = new Date(session.time.updated).toLocaleString();
+                            const suffix = ` (${dateStr})`;
+                            const maxTitleLength = 100 - suffix.length;
+                            let title = session.title;
+                            if (title.length > maxTitleLength) {
+                                title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…';
+                            }
+                            return {
+                                name: `${title}${suffix}`,
+                                value: session.id,
+                            };
+                        });
+                        await interaction.respond(sessions);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[AUTOCOMPLETE] Error fetching sessions:', error);
+                        await interaction.respond([]);
+                    }
+                }
+                else if (interaction.commandName === 'session') {
+                    const focusedOption = interaction.options.getFocused(true);
+                    if (focusedOption.name === 'files') {
+                        const focusedValue = focusedOption.value;
+                        const parts = focusedValue.split(',');
+                        const previousFiles = parts
+                            .slice(0, -1)
+                            .map((f) => f.trim())
+                            .filter((f) => f);
+                        const currentQuery = (parts[parts.length - 1] || '').trim();
+                        let projectDirectory;
+                        if (interaction.channel) {
+                            const textChannel = await resolveTextChannel(interaction.channel);
+                            if (textChannel) {
+                                const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
+                                if (channelAppId && channelAppId !== appId) {
+                                    await interaction.respond([]);
+                                    return;
+                                }
+                                projectDirectory = directory;
+                            }
+                        }
+                        if (!projectDirectory) {
+                            await interaction.respond([]);
+                            return;
+                        }
+                        try {
+                            const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                            const response = await getClient().find.files({
+                                query: {
+                                    query: currentQuery || '',
+                                },
+                            });
+                            const files = response.data || [];
+                            const prefix = previousFiles.length > 0
+                                ? previousFiles.join(', ') + ', '
+                                : '';
+                            const choices = files
+                                .map((file) => {
+                                const fullValue = prefix + file;
+                                const allFiles = [...previousFiles, file];
+                                const allBasenames = allFiles.map((f) => f.split('/').pop() || f);
+                                let displayName = allBasenames.join(', ');
+                                if (displayName.length > 100) {
+                                    displayName = '…' + displayName.slice(-97);
+                                }
+                                return {
+                                    name: displayName,
+                                    value: fullValue,
+                                };
+                            })
+                                .filter((choice) => choice.value.length <= 100)
+                                .slice(0, 25);
+                            await interaction.respond(choices);
+                        }
+                        catch (error) {
+                            interactionLogger.error('[AUTOCOMPLETE] Error fetching files:', error);
+                            await interaction.respond([]);
+                        }
+                    }
+                }
+                else if (interaction.commandName === 'add-project') {
+                    const focusedValue = interaction.options.getFocused();
+                    try {
+                        const currentDir = process.cwd();
+                        const getClient = await initializeOpencodeForDirectory(currentDir);
+                        const projectsResponse = await getClient().project.list({});
+                        if (!projectsResponse.data) {
+                            await interaction.respond([]);
+                            return;
+                        }
+                        const db = getDatabase();
+                        const existingDirs = db
+                            .prepare('SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?')
+                            .all('text');
+                        const existingDirSet = new Set(existingDirs.map((row) => row.directory));
+                        const availableProjects = projectsResponse.data.filter((project) => !existingDirSet.has(project.worktree));
+                        const projects = availableProjects
+                            .filter((project) => {
+                            const baseName = path.basename(project.worktree);
+                            const searchText = `${baseName} ${project.worktree}`.toLowerCase();
+                            return searchText.includes(focusedValue.toLowerCase());
+                        })
+                            .sort((a, b) => {
+                            const aTime = a.time.initialized || a.time.created;
+                            const bTime = b.time.initialized || b.time.created;
+                            return bTime - aTime;
+                        })
+                            .slice(0, 25)
+                            .map((project) => {
+                            const name = `${path.basename(project.worktree)} (${project.worktree})`;
+                            return {
+                                name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+                                value: project.id,
+                            };
+                        });
+                        await interaction.respond(projects);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+                        await interaction.respond([]);
+                    }
+                }
+            }
+            if (interaction.isChatInputCommand()) {
+                const command = interaction;
+                interactionLogger.log(`[COMMAND] Processing: ${command.commandName}`);
+                if (command.commandName === 'session') {
+                    await command.deferReply({ ephemeral: false });
+                    const prompt = command.options.getString('prompt', true);
+                    const filesString = command.options.getString('files') || '';
+                    const channel = command.channel;
+                    if (!channel || channel.type !== ChannelType.GuildText) {
+                        await command.editReply('This command can only be used in text channels');
+                        return;
+                    }
+                    const textChannel = channel;
+                    let projectDirectory;
+                    let channelAppId;
+                    if (textChannel.topic) {
+                        const extracted = extractTagsArrays({
+                            xml: textChannel.topic,
+                            tags: ['kimaki.directory', 'kimaki.app'],
+                        });
+                        projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+                        channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                    }
+                    if (channelAppId && channelAppId !== appId) {
+                        await command.editReply('This channel is not configured for this bot');
+                        return;
+                    }
+                    if (!projectDirectory) {
+                        await command.editReply('This channel is not configured with a project directory');
+                        return;
+                    }
+                    if (!fs.existsSync(projectDirectory)) {
+                        await command.editReply(`Directory does not exist: ${projectDirectory}`);
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        const files = filesString
+                            .split(',')
+                            .map((f) => f.trim())
+                            .filter((f) => f);
+                        let fullPrompt = prompt;
+                        if (files.length > 0) {
+                            fullPrompt = `${prompt}\n\n@${files.join(' @')}`;
+                        }
+                        const starterMessage = await textChannel.send({
+                            content: `🚀 **Starting OpenCode session**\n📝 ${prompt.slice(0, 200)}${prompt.length > 200 ? '…' : ''}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        const thread = await starterMessage.startThread({
+                            name: prompt.slice(0, 100),
+                            autoArchiveDuration: 1440,
+                            reason: 'OpenCode session',
+                        });
+                        await command.editReply(`Created new session in ${thread.toString()}`);
+                        const parsedCommand = parseSlashCommand(fullPrompt);
+                        await handleOpencodeSession({
+                            prompt: fullPrompt,
+                            thread,
+                            projectDirectory,
+                            parsedCommand,
+                            channelId: textChannel.id,
+                        });
+                    }
+                    catch (error) {
+                        interactionLogger.error('[SESSION] Error:', error);
+                        await command.editReply(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                else if (command.commandName === 'resume') {
+                    await command.deferReply({ ephemeral: false });
+                    const sessionId = command.options.getString('session', true);
+                    const channel = command.channel;
+                    if (!channel || channel.type !== ChannelType.GuildText) {
+                        await command.editReply('This command can only be used in text channels');
+                        return;
+                    }
+                    const textChannel = channel;
+                    let projectDirectory;
+                    let channelAppId;
+                    if (textChannel.topic) {
+                        const extracted = extractTagsArrays({
+                            xml: textChannel.topic,
+                            tags: ['kimaki.directory', 'kimaki.app'],
+                        });
+                        projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+                        channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                    }
+                    if (channelAppId && channelAppId !== appId) {
+                        await command.editReply('This channel is not configured for this bot');
+                        return;
+                    }
+                    if (!projectDirectory) {
+                        await command.editReply('This channel is not configured with a project directory');
+                        return;
+                    }
+                    if (!fs.existsSync(projectDirectory)) {
+                        await command.editReply(`Directory does not exist: ${projectDirectory}`);
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        const sessionResponse = await getClient().session.get({
+                            path: { id: sessionId },
+                        });
+                        if (!sessionResponse.data) {
+                            await command.editReply('Session not found');
+                            return;
+                        }
+                        const sessionTitle = sessionResponse.data.title;
+                        const thread = await textChannel.threads.create({
+                            name: `Resume: ${sessionTitle}`.slice(0, 100),
+                            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+                            reason: `Resuming session ${sessionId}`,
+                        });
+                        getDatabase()
+                            .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+                            .run(thread.id, sessionId);
+                        interactionLogger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`);
+                        const messagesResponse = await getClient().session.messages({
+                            path: { id: sessionId },
+                        });
+                        if (!messagesResponse.data) {
+                            throw new Error('Failed to fetch session messages');
+                        }
+                        const messages = messagesResponse.data;
+                        await command.editReply(`Resumed session "${sessionTitle}" in ${thread.toString()}`);
+                        await sendThreadMessage(thread, `📂 **Resumed session:** ${sessionTitle}\n📅 **Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`);
+                        const allAssistantParts = [];
+                        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 });
+                                    }
+                                }
+                            }
+                        }
+                        const partsToRender = allAssistantParts.slice(-30);
+                        const skippedCount = allAssistantParts.length - partsToRender.length;
+                        if (skippedCount > 0) {
+                            await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
+                        }
+                        if (partsToRender.length > 0) {
+                            const combinedContent = partsToRender
+                                .map((p) => p.content)
+                                .join('\n');
+                            const discordMessage = await sendThreadMessage(thread, combinedContent);
+                            const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
+                            const transaction = getDatabase().transaction((parts) => {
+                                for (const part of parts) {
+                                    stmt.run(part.id, discordMessage.id, thread.id);
+                                }
+                            });
+                            transaction(partsToRender);
+                        }
+                        const messageCount = messages.length;
+                        await sendThreadMessage(thread, `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[RESUME] Error:', error);
+                        await command.editReply(`Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                else if (command.commandName === 'add-project') {
+                    await command.deferReply({ ephemeral: false });
+                    const projectId = 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 {
+                        const currentDir = process.cwd();
+                        const getClient = await initializeOpencodeForDirectory(currentDir);
+                        const projectsResponse = await getClient().project.list({});
+                        if (!projectsResponse.data) {
+                            await command.editReply('Failed to fetch projects');
+                            return;
+                        }
+                        const project = projectsResponse.data.find((p) => p.id === projectId);
+                        if (!project) {
+                            await command.editReply('Project not found');
+                            return;
+                        }
+                        const directory = project.worktree;
+                        if (!fs.existsSync(directory)) {
+                            await command.editReply(`Directory does not exist: ${directory}`);
+                            return;
+                        }
+                        const db = getDatabase();
+                        const existingChannel = db
+                            .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+                            .get(directory, 'text');
+                        if (existingChannel) {
+                            await command.editReply(`A channel already exists for this directory: <#${existingChannel.channel_id}>`);
+                            return;
+                        }
+                        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+                            guild,
+                            projectDirectory: directory,
+                            appId,
+                        });
+                        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``);
+                        discordLogger.log(`Created channels for project ${channelName} at ${directory}`);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[ADD-PROJECT] Error:', error);
+                        await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                else if (command.commandName === 'create-new-project') {
+                    await command.deferReply({ ephemeral: false });
+                    const projectName = command.options.getString('name', true);
+                    const guild = command.guild;
+                    const channel = command.channel;
+                    if (!guild) {
+                        await command.editReply('This command can only be used in a guild');
+                        return;
+                    }
+                    if (!channel || channel.type !== ChannelType.GuildText) {
+                        await command.editReply('This command can only be used in a text channel');
+                        return;
+                    }
+                    const sanitizedName = projectName
+                        .toLowerCase()
+                        .replace(/[^a-z0-9-]/g, '-')
+                        .replace(/-+/g, '-')
+                        .replace(/^-|-$/g, '')
+                        .slice(0, 100);
+                    if (!sanitizedName) {
+                        await command.editReply('Invalid project name');
+                        return;
+                    }
+                    const kimakiDir = path.join(os.homedir(), 'kimaki');
+                    const projectDirectory = path.join(kimakiDir, sanitizedName);
+                    try {
+                        if (!fs.existsSync(kimakiDir)) {
+                            fs.mkdirSync(kimakiDir, { recursive: true });
+                            discordLogger.log(`Created kimaki directory: ${kimakiDir}`);
+                        }
+                        if (fs.existsSync(projectDirectory)) {
+                            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+                            return;
+                        }
+                        fs.mkdirSync(projectDirectory, { recursive: true });
+                        discordLogger.log(`Created project directory: ${projectDirectory}`);
+                        const { execSync } = await import('node:child_process');
+                        execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+                        discordLogger.log(`Initialized git in: ${projectDirectory}`);
+                        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+                            guild,
+                            projectDirectory,
+                            appId,
+                        });
+                        const textChannel = await guild.channels.fetch(textChannelId);
+                        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`);
+                        const starterMessage = await textChannel.send({
+                            content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        const thread = await starterMessage.startThread({
+                            name: `Init: ${sanitizedName}`,
+                            autoArchiveDuration: 1440,
+                            reason: 'New project session',
+                        });
+                        await handleOpencodeSession({
+                            prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
+                            thread,
+                            projectDirectory,
+                            channelId: textChannel.id,
+                        });
+                        discordLogger.log(`Created new project ${channelName} at ${projectDirectory}`);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[ADD-NEW-PROJECT] Error:', error);
+                        await command.editReply(`Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                else if (command.commandName === 'accept' ||
+                    command.commandName === 'accept-always') {
+                    const scope = command.commandName === 'accept-always' ? 'always' : 'once';
+                    const channel = command.channel;
+                    if (!channel) {
+                        await command.reply({
+                            content: 'This command can only be used in a channel',
+                            ephemeral: true,
+                            flags: 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',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    const pending = pendingPermissions.get(channel.id);
+                    if (!pending) {
+                        await command.reply({
+                            content: 'No pending permission request in this thread',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(pending.directory);
+                        await getClient().postSessionIdPermissionsPermissionId({
+                            path: {
+                                id: pending.permission.sessionID,
+                                permissionID: pending.permission.id,
+                            },
+                            body: {
+                                response: scope,
+                            },
+                        });
+                        pendingPermissions.delete(channel.id);
+                        const msg = scope === 'always'
+                            ? `✅ Permission **accepted** (auto-approve similar requests)`
+                            : `✅ Permission **accepted**`;
+                        await command.reply({ content: msg, flags: SILENT_MESSAGE_FLAGS });
+                        discordLogger.log(`Permission ${pending.permission.id} accepted with scope: ${scope}`);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[ACCEPT] Error:', error);
+                        await command.reply({
+                            content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                    }
+                }
+                else if (command.commandName === 'reject') {
+                    const channel = command.channel;
+                    if (!channel) {
+                        await command.reply({
+                            content: 'This command can only be used in a channel',
+                            ephemeral: true,
+                            flags: 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',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    const pending = pendingPermissions.get(channel.id);
+                    if (!pending) {
+                        await command.reply({
+                            content: 'No pending permission request in this thread',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(pending.directory);
+                        await getClient().postSessionIdPermissionsPermissionId({
+                            path: {
+                                id: pending.permission.sessionID,
+                                permissionID: pending.permission.id,
+                            },
+                            body: {
+                                response: 'reject',
+                            },
+                        });
+                        pendingPermissions.delete(channel.id);
+                        await command.reply({ content: `❌ Permission **rejected**`, flags: SILENT_MESSAGE_FLAGS });
+                        discordLogger.log(`Permission ${pending.permission.id} rejected`);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[REJECT] Error:', error);
+                        await command.reply({
+                            content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                    }
+                }
+                else if (command.commandName === 'abort') {
+                    const channel = command.channel;
+                    if (!channel) {
+                        await command.reply({
+                            content: 'This command can only be used in a channel',
+                            ephemeral: true,
+                            flags: 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',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    const textChannel = await resolveTextChannel(channel);
+                    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+                    if (!directory) {
+                        await command.reply({
+                            content: 'Could not determine project directory for this channel',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    const row = getDatabase()
+                        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+                        .get(channel.id);
+                    if (!row?.session_id) {
+                        await command.reply({
+                            content: 'No active session in this thread',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    const sessionId = row.session_id;
+                    try {
+                        const existingController = abortControllers.get(sessionId);
+                        if (existingController) {
+                            existingController.abort(new Error('User requested abort'));
+                            abortControllers.delete(sessionId);
+                        }
+                        const getClient = await initializeOpencodeForDirectory(directory);
+                        await getClient().session.abort({
+                            path: { id: sessionId },
+                        });
+                        await command.reply({ content: `🛑 Request **aborted**`, flags: SILENT_MESSAGE_FLAGS });
+                        discordLogger.log(`Session ${sessionId} aborted by user`);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[ABORT] Error:', error);
+                        await command.reply({
+                            content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                    }
+                }
+                else if (command.commandName === 'share') {
+                    const channel = command.channel;
+                    if (!channel) {
+                        await command.reply({
+                            content: 'This command can only be used in a channel',
+                            ephemeral: true,
+                            flags: 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',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    const textChannel = await resolveTextChannel(channel);
+                    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+                    if (!directory) {
+                        await command.reply({
+                            content: 'Could not determine project directory for this channel',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    const row = getDatabase()
+                        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+                        .get(channel.id);
+                    if (!row?.session_id) {
+                        await command.reply({
+                            content: 'No active session in this thread',
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    const sessionId = row.session_id;
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(directory);
+                        const response = await getClient().session.share({
+                            path: { id: sessionId },
+                        });
+                        if (!response.data?.share?.url) {
+                            await command.reply({
+                                content: 'Failed to generate share URL',
+                                ephemeral: true,
+                                flags: SILENT_MESSAGE_FLAGS,
+                            });
+                            return;
+                        }
+                        await command.reply({ content: `🔗 **Session shared:** ${response.data.share.url}`, flags: SILENT_MESSAGE_FLAGS });
+                        discordLogger.log(`Session ${sessionId} shared: ${response.data.share.url}`);
+                    }
+                    catch (error) {
+                        interactionLogger.error('[SHARE] Error:', error);
+                        await command.reply({
+                            content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                    }
+                }
+                else if (command.commandName === 'fork') {
+                    await handleForkCommand(command);
+                }
+                else if (command.commandName === 'model') {
+                    await handleModelCommand({ interaction: command, appId });
+                }
+            }
+            if (interaction.isStringSelectMenu()) {
+                if (interaction.customId.startsWith('fork_select:')) {
+                    await handleForkSelectMenu(interaction);
+                }
+                else if (interaction.customId.startsWith('model_provider:')) {
+                    await handleProviderSelectMenu(interaction);
+                }
+                else if (interaction.customId.startsWith('model_select:')) {
+                    await handleModelSelectMenu(interaction);
+                }
+            }
+        }
+        catch (error) {
+            interactionLogger.error('[INTERACTION] Error handling interaction:', error);
+            // Try to respond to the interaction if possible
+            try {
+                if (interaction.isRepliable() && !interaction.replied && !interaction.deferred) {
+                    await interaction.reply({
+                        content: 'An error occurred processing this command.',
+                        ephemeral: true,
+                    });
+                }
+            }
+            catch (replyError) {
+                interactionLogger.error('[INTERACTION] Failed to send error reply:', replyError);
+            }
+        }
+    });
+}