@brianli/kimaki 0.4.72-brianli.1

package/dist/commands/resume.js

@@ -0,0 +1,159 @@
+// /resume command - Resume an existing OpenCode session.
+import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
+import fs from 'node:fs';
+import { getChannelDirectory, setThreadSession, setPartMessagesBatch, getAllThreadSessionIds, } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { sendThreadMessage, resolveTextChannel } from '../discord-utils.js';
+import { collectLastAssistantParts } from '../message-formatting.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.RESUME);
+export async function handleResumeCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const sessionId = command.options.getString('session', true);
+    const channel = command.channel;
+    const isThread = channel &&
+        [
+            ChannelType.PublicThread,
+            ChannelType.PrivateThread,
+            ChannelType.AnnouncementThread,
+        ].includes(channel.type);
+    if (isThread) {
+        await command.editReply('This command can only be used in project channels, not threads');
+        return;
+    }
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels');
+        return;
+    }
+    const textChannel = channel;
+    const channelConfig = await getChannelDirectory(textChannel.id);
+    const projectDirectory = channelConfig?.directory;
+    const channelAppId = channelConfig?.appId || undefined;
+    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);
+        if (getClient instanceof Error) {
+            await command.editReply(getClient.message);
+            return;
+        }
+        const sessionResponse = await getClient().session.get({
+            sessionID: 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}`,
+        });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
+        await setThreadSession(thread.id, sessionId);
+        logger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`);
+        const messagesResponse = await getClient().session.messages({
+            sessionID: 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...*`);
+        try {
+            const { partIds, content, skippedCount } = collectLastAssistantParts({
+                messages,
+            });
+            if (skippedCount > 0) {
+                await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
+            }
+            if (content.trim()) {
+                const discordMessage = await sendThreadMessage(thread, content);
+                // Store part-message mappings atomically
+                await setPartMessagesBatch(partIds.map((partId) => ({
+                    partId,
+                    messageId: discordMessage.id,
+                    threadId: thread.id,
+                })));
+            }
+            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 (sendError) {
+            logger.error('[RESUME] Error sending messages to thread:', sendError);
+            await sendThreadMessage(thread, `Failed to load message history, but session is connected. You can still send new messages.`);
+        }
+    }
+    catch (error) {
+        logger.error('[RESUME] Error:', error);
+        await command.editReply(`Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleResumeAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    let projectDirectory;
+    if (interaction.channel) {
+        const textChannel = await resolveTextChannel(interaction.channel);
+        if (textChannel) {
+            const channelConfig = await getChannelDirectory(textChannel.id);
+            if (channelConfig?.appId && channelConfig.appId !== appId) {
+                await interaction.respond([]);
+                return;
+            }
+            projectDirectory = channelConfig?.directory;
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await interaction.respond([]);
+            return;
+        }
+        const sessionsResponse = await getClient().session.list();
+        if (!sessionsResponse.data) {
+            await interaction.respond([]);
+            return;
+        }
+        const existingSessionIds = new Set(await getAllThreadSessionIds());
+        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) {
+        logger.error('[AUTOCOMPLETE] Error fetching sessions:', error);
+        await interaction.respond([]);
+    }
+}

package/dist/commands/run-command.js

@@ -0,0 +1,79 @@
+// /run-shell-command command - Run an arbitrary shell command in the project directory.
+// Resolves the project directory from the channel and executes the command with it as cwd.
+// Also used by the ! prefix shortcut in discord messages (e.g. "!ls -la").
+// Messages starting with ! are intercepted before session handling and routed here.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { execAsync } from '../worktree-utils.js';
+import { stripAnsi } from '../utils.js';
+const logger = createLogger(LogPrefix.INTERACTION);
+const MAX_OUTPUT_CHARS = 1900;
+export async function runShellCommand({ command, directory, }) {
+    try {
+        const { stdout, stderr } = await execAsync(command, { cwd: directory });
+        const output = stripAnsi([stdout, stderr].filter(Boolean).join('\n').trim());
+        const header = `\`${command}\` exited with 0`;
+        if (!output) {
+            return header;
+        }
+        return formatOutput(output, header);
+    }
+    catch (error) {
+        const execError = error;
+        const output = stripAnsi([execError.stdout, execError.stderr].filter(Boolean).join('\n').trim());
+        const exitCode = execError.code ?? 1;
+        logger.error(`[RUN-COMMAND] Command "${command}" exited with ${exitCode}:`, error);
+        const header = `\`${command}\` exited with ${exitCode}`;
+        return formatOutput(output || execError.message || 'Unknown error', header);
+    }
+}
+export async function handleRunCommand({ 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);
+    const isTextChannel = channel.type === ChannelType.GuildText;
+    if (!isThread && !isTextChannel) {
+        await command.reply({
+            content: 'This command can only be used in a text channel or thread.',
+            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 input = command.options.getString('command', true);
+    await command.deferReply();
+    const result = await runShellCommand({
+        command: input,
+        directory: resolved.workingDirectory,
+    });
+    await command.editReply({ content: result });
+}
+function formatOutput(output, header) {
+    // Reserve space for header + newline + code block delimiters (```\n...\n```)
+    const overhead = header.length + 1 + 3 + 1 + 1 + 3; // header\n```\n...\n```
+    const maxContent = MAX_OUTPUT_CHARS - overhead;
+    const truncated = output.length > maxContent
+        ? output.slice(0, maxContent - 14) + '\n... truncated'
+        : output;
+    return `${header}\n\`\`\`\n${truncated}\n\`\`\``;
+}

package/dist/commands/session-id.js

@@ -0,0 +1,78 @@
+// /session-id command - Show current session ID and an opencode attach command.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { getOpencodeServerPort, initializeOpencodeForDirectory, } from '../opencode.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.SESSION);
+function shellQuote(value) {
+    if (!value) {
+        return "''";
+    }
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+export async function handleSessionIdCommand({ 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 with an active session',
+            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, workingDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    let port = getOpencodeServerPort(projectDirectory);
+    if (!port) {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await command.editReply({
+                content: `Session ID: \`${sessionId}\`\nFailed to resolve OpenCode server port: ${getClient.message}`,
+            });
+            return;
+        }
+        port = getOpencodeServerPort(projectDirectory);
+    }
+    if (!port) {
+        await command.editReply({
+            content: `Session ID: \`${sessionId}\`\nCould not determine OpenCode server port`,
+        });
+        return;
+    }
+    const attachUrl = `http://127.0.0.1:${port}`;
+    const attachCommand = `opencode attach ${attachUrl} --session ${sessionId} --dir ${shellQuote(workingDirectory)}`;
+    await command.editReply({
+        content: `**Session ID:** \`${sessionId}\`\n**Attach command:**\n\`\`\`bash\n${attachCommand}\n\`\`\``,
+    });
+    logger.log(`Session ID shown for thread ${channel.id}: ${sessionId}`);
+}

package/dist/commands/session.js

@@ -0,0 +1,192 @@
+// /new-session command - Start a new OpenCode session.
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getChannelDirectory } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.SESSION);
+export async function handleSessionCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const prompt = command.options.getString('prompt', true);
+    const filesString = command.options.getString('files') || '';
+    const agent = command.options.getString('agent') || undefined;
+    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;
+    const channelConfig = await getChannelDirectory(textChannel.id);
+    const projectDirectory = channelConfig?.directory;
+    const channelAppId = channelConfig?.appId || undefined;
+    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);
+        if (getClient instanceof Error) {
+            await command.editReply(getClient.message);
+            return;
+        }
+        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}${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',
+        });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
+        await command.editReply(`Created new session in ${thread.toString()}`);
+        await handleOpencodeSession({
+            prompt: fullPrompt,
+            thread,
+            projectDirectory,
+            channelId: textChannel.id,
+            agent,
+            appId,
+        });
+    }
+    catch (error) {
+        logger.error('[SESSION] Error:', error);
+        await command.editReply(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+async function handleAgentAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    let projectDirectory;
+    if (interaction.channel &&
+        interaction.channel.type === ChannelType.GuildText) {
+        const channelConfig = await getChannelDirectory(interaction.channel.id);
+        if (channelConfig) {
+            if (channelConfig.appId && channelConfig.appId !== appId) {
+                await interaction.respond([]);
+                return;
+            }
+            projectDirectory = channelConfig.directory;
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await interaction.respond([]);
+            return;
+        }
+        const agentsResponse = await getClient().app.agents({
+            directory: projectDirectory,
+        });
+        if (!agentsResponse.data || agentsResponse.data.length === 0) {
+            await interaction.respond([]);
+            return;
+        }
+        const agents = agentsResponse.data
+            .filter((a) => {
+            const hidden = a.hidden;
+            return (a.mode === 'primary' || a.mode === 'all') && !hidden;
+        })
+            .filter((a) => a.name.toLowerCase().includes(focusedValue.toLowerCase()))
+            .slice(0, 25);
+        const choices = agents.map((agent) => ({
+            name: agent.name.slice(0, 100),
+            value: agent.name,
+        }));
+        await interaction.respond(choices);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching agents:', error);
+        await interaction.respond([]);
+    }
+}
+export async function handleSessionAutocomplete({ interaction, appId, }) {
+    const focusedOption = interaction.options.getFocused(true);
+    if (focusedOption.name === 'agent') {
+        await handleAgentAutocomplete({ interaction, appId });
+        return;
+    }
+    if (focusedOption.name !== 'files') {
+        return;
+    }
+    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 &&
+        interaction.channel.type === ChannelType.GuildText) {
+        const channelConfig = await getChannelDirectory(interaction.channel.id);
+        if (channelConfig) {
+            if (channelConfig.appId && channelConfig.appId !== appId) {
+                await interaction.respond([]);
+                return;
+            }
+            projectDirectory = channelConfig.directory;
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await interaction.respond([]);
+            return;
+        }
+        const response = await getClient().find.files({
+            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) {
+        logger.error('[AUTOCOMPLETE] Error fetching files:', error);
+        await interaction.respond([]);
+    }
+}

package/dist/commands/share.js

@@ -0,0 +1,80 @@
+// /share command - Share the current session as a public URL.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.SHARE);
+export async function handleShareCommand({ 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 with an active session',
+            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 } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to share session: ${getClient.message}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        const response = await getClient().session.share({
+            sessionID: sessionId,
+        });
+        if (!response.data?.share?.url) {
+            await command.reply({
+                content: 'Failed to generate share URL',
+                flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `🔗 **Session shared:** ${response.data.share.url}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`Session ${sessionId} shared: ${response.data.share.url}`);
+    }
+    catch (error) {
+        logger.error('[SHARE] Error:', error);
+        await command.reply({
+            content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/types.js

@@ -0,0 +1,2 @@
+// Shared types for command handlers.
+export {};