@otto-assistant/bridge 0.4.92

package/dist/commands/abort.js

@@ -0,0 +1,65 @@
+// /abort command - Abort the current OpenCode request in this thread.
+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 { getRuntime } from '../session-handler/thread-session-runtime.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.ABORT);
+export async function handleAbortCommand({ 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;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.editReply('Could not determine project directory for this channel');
+        return;
+    }
+    const { projectDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.editReply('No active session in this thread');
+        return;
+    }
+    // abortActiveRun delegates to session.abort(), run settlement stays event-driven.
+    const runtime = getRuntime(channel.id);
+    if (runtime) {
+        runtime.abortActiveRun('user-requested');
+    }
+    else {
+        // No runtime but session exists — fall back to direct API abort
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await command.editReply(`Failed to abort: ${getClient.message}`);
+            return;
+        }
+        try {
+            await getClient().session.abort({ sessionID: sessionId });
+        }
+        catch (error) {
+            logger.error('[ABORT] API abort failed:', error);
+        }
+    }
+    await command.editReply('Request **aborted**');
+    logger.log(`Session ${sessionId} aborted by user`);
+}

package/dist/commands/action-buttons.js

@@ -0,0 +1,245 @@
+// Action button tool handler - Shows Discord buttons for quick model actions.
+// Used by the kimaki_action_buttons tool to render up to 3 buttons and route
+// button clicks back into the session as a new user message.
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, MessageFlags, } from 'discord.js';
+import crypto from 'node:crypto';
+import { getThreadSession } from '../database.js';
+import { NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS, resolveWorkingDirectory, sendThreadMessage, } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+import { notifyError } from '../sentry.js';
+import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
+const logger = createLogger('ACT_BTN');
+const PENDING_TTL_MS = 24 * 60 * 60 * 1000;
+export const pendingActionButtonContexts = new Map();
+const pendingActionButtonRequests = new Map();
+const pendingActionButtonRequestWaiters = new Map();
+export function queueActionButtonsRequest(request) {
+    pendingActionButtonRequests.set(request.sessionId, request);
+    const waiter = pendingActionButtonRequestWaiters.get(request.sessionId);
+    if (!waiter) {
+        return;
+    }
+    pendingActionButtonRequestWaiters.delete(request.sessionId);
+    waiter(request);
+}
+export async function waitForQueuedActionButtonsRequest({ sessionId, timeoutMs, }) {
+    const queued = pendingActionButtonRequests.get(sessionId);
+    if (queued) {
+        pendingActionButtonRequests.delete(sessionId);
+        return queued;
+    }
+    return await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            const currentWaiter = pendingActionButtonRequestWaiters.get(sessionId);
+            if (!currentWaiter || currentWaiter !== onRequest) {
+                return;
+            }
+            pendingActionButtonRequestWaiters.delete(sessionId);
+            resolve(undefined);
+        }, timeoutMs);
+        const onRequest = (request) => {
+            clearTimeout(timeout);
+            pendingActionButtonRequests.delete(sessionId);
+            resolve(request);
+        };
+        pendingActionButtonRequestWaiters.set(sessionId, onRequest);
+    });
+}
+function toButtonStyle(color) {
+    if (color === 'blue') {
+        return ButtonStyle.Primary;
+    }
+    if (color === 'green') {
+        return ButtonStyle.Success;
+    }
+    if (color === 'red') {
+        return ButtonStyle.Danger;
+    }
+    return ButtonStyle.Secondary;
+}
+function resolveContext(context) {
+    if (context.resolved) {
+        return false;
+    }
+    context.resolved = true;
+    clearTimeout(context.timer);
+    pendingActionButtonContexts.delete(context.contextHash);
+    return true;
+}
+function updateButtonMessage({ context, status, }) {
+    if (!context.messageId) {
+        return;
+    }
+    context.thread.messages
+        .fetch(context.messageId)
+        .then((message) => {
+        return message.edit({
+            content: `**Action Required**\n${status}`,
+            components: [],
+        });
+    })
+        .catch(() => { });
+}
+async function sendClickedActionToModel({ interaction, thread, prompt, }) {
+    const resolved = await resolveWorkingDirectory({ channel: thread });
+    if (!resolved) {
+        throw new Error('Could not resolve project directory for thread');
+    }
+    const username = interaction.user.globalName || interaction.user.username;
+    // Action button clicks use opencode queue mode.
+    const runtime = getOrCreateRuntime({
+        threadId: thread.id,
+        thread,
+        projectDirectory: resolved.projectDirectory,
+        sdkDirectory: resolved.workingDirectory,
+        channelId: thread.parentId || thread.id,
+    });
+    await runtime.enqueueIncoming({
+        prompt,
+        userId: interaction.user.id,
+        username,
+        mode: 'opencode',
+    });
+}
+export async function showActionButtons({ thread, sessionId, directory, buttons, silent, }) {
+    const safeButtons = buttons
+        .slice(0, 3)
+        .map((button) => {
+        return {
+            label: button.label.trim().slice(0, 80),
+            color: button.color,
+        };
+    })
+        .filter((button) => {
+        return button.label.length > 0;
+    });
+    if (safeButtons.length === 0) {
+        throw new Error('No valid buttons to display');
+    }
+    const contextHash = crypto.randomBytes(8).toString('hex');
+    const timer = setTimeout(() => {
+        const current = pendingActionButtonContexts.get(contextHash);
+        if (!current || current.resolved) {
+            return;
+        }
+        resolveContext(current);
+        updateButtonMessage({ context: current, status: '_Expired_' });
+    }, PENDING_TTL_MS);
+    const context = {
+        sessionId,
+        directory,
+        thread,
+        buttons: safeButtons,
+        contextHash,
+        resolved: false,
+        timer,
+    };
+    pendingActionButtonContexts.set(contextHash, context);
+    const row = new ActionRowBuilder().addComponents(...safeButtons.map((button, index) => {
+        return new ButtonBuilder()
+            .setCustomId(`action_button:${contextHash}:${index}`)
+            .setLabel(button.label)
+            .setStyle(toButtonStyle(button.color));
+    }));
+    try {
+        const message = await thread.send({
+            content: '**Action Required**',
+            components: [row],
+            flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
+        });
+        context.messageId = message.id;
+        logger.log(`Showed ${safeButtons.length} action button(s) for session ${sessionId}`);
+    }
+    catch (error) {
+        clearTimeout(timer);
+        pendingActionButtonContexts.delete(contextHash);
+        throw new Error('Failed to send action buttons', { cause: error });
+    }
+}
+export async function handleActionButton(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('action_button:')) {
+        return;
+    }
+    const [, contextHash, indexPart] = customId.split(':');
+    if (!contextHash || !indexPart) {
+        await interaction.reply({
+            content: 'Invalid action button.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const context = pendingActionButtonContexts.get(contextHash);
+    if (!context || context.resolved) {
+        await interaction.reply({
+            content: 'This action is no longer available.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const buttonIndex = Number.parseInt(indexPart, 10);
+    const button = context.buttons[buttonIndex];
+    if (!button) {
+        await interaction.reply({
+            content: 'This action is no longer available.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferUpdate();
+    const claimed = resolveContext(context);
+    if (!claimed) {
+        return;
+    }
+    const thread = interaction.channel;
+    if (!thread?.isThread()) {
+        logger.warn('[ACTION] Button clicked outside thread channel');
+        await interaction.editReply({
+            content: '**Action Required**\n_This action is no longer available._',
+            components: [],
+        });
+        return;
+    }
+    const currentSessionId = await getThreadSession(thread.id);
+    if (!currentSessionId || currentSessionId !== context.sessionId) {
+        await interaction.editReply({
+            content: '**Action Required**\n_Expired due to session change._',
+            components: [],
+        });
+        return;
+    }
+    await interaction.editReply({
+        content: `**Action Required**\n_Selected: ${button.label}_`,
+        components: [],
+    });
+    const prompt = `User clicked: ${button.label}`;
+    try {
+        await sendClickedActionToModel({
+            interaction,
+            thread,
+            prompt,
+        });
+    }
+    catch (error) {
+        logger.error('[ACTION] Failed to send click to model:', error);
+        void notifyError(error, 'Action button click send to model failed');
+        await sendThreadMessage(thread, `Failed to send action click: ${error instanceof Error ? error.message : String(error)}`, { flags: NOTIFY_MESSAGE_FLAGS });
+    }
+}
+/**
+ * Dismiss pending action buttons for a thread (e.g. user sent a new message).
+ * Removes buttons from the message and cleans up context.
+ */
+export function cancelPendingActionButtons(threadId) {
+    for (const [, ctx] of pendingActionButtonContexts) {
+        if (ctx.thread.id !== threadId) {
+            continue;
+        }
+        if (!resolveContext(ctx)) {
+            continue;
+        }
+        updateButtonMessage({ context: ctx, status: '_Buttons dismissed._' });
+        return true;
+    }
+    return false;
+}

package/dist/commands/add-project.js

@@ -0,0 +1,113 @@
+// /add-project command - Create Discord channels for an existing OpenCode project.
+import fs from 'node:fs';
+import path from 'node:path';
+import { findChannelsByDirectory, getAllTextChannelDirectories, } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { createProjectChannels } from '../channel-management.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { abbreviatePath } from '../utils.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.ADD_PROJECT);
+export async function handleAddProjectCommand({ command, }) {
+    await command.deferReply();
+    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);
+        if (getClient instanceof Error) {
+            await command.editReply(getClient.message);
+            return;
+        }
+        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 existingChannels = await findChannelsByDirectory({
+            directory,
+            channelType: 'text',
+        });
+        if (existingChannels.length > 0) {
+            await command.editReply(`A channel already exists for this directory: <#${existingChannels[0].channel_id}>`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+            guild,
+            projectDirectory: directory,
+            botName: command.client.user?.username,
+        });
+        const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : '';
+        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>${voiceInfo}\n📁 Directory: \`${directory}\``);
+        logger.log(`Created channels for project ${channelName} at ${directory}`);
+    }
+    catch (error) {
+        logger.error('[ADD-PROJECT] Error:', error);
+        await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleAddProjectAutocomplete({ interaction, }) {
+    const focusedValue = interaction.options.getFocused();
+    try {
+        const currentDir = process.cwd();
+        const getClient = await initializeOpencodeForDirectory(currentDir);
+        if (getClient instanceof Error) {
+            await interaction.respond([]);
+            return;
+        }
+        const projectsResponse = await getClient().project.list({});
+        if (!projectsResponse.data) {
+            await interaction.respond([]);
+            return;
+        }
+        const existingDirs = await getAllTextChannelDirectories();
+        const existingDirSet = new Set(existingDirs);
+        const availableProjects = projectsResponse.data.filter((project) => {
+            if (existingDirSet.has(project.worktree)) {
+                return false;
+            }
+            if (path.basename(project.worktree).startsWith('opencode-test-')) {
+                return false;
+            }
+            return true;
+        });
+        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)} (${abbreviatePath(project.worktree)})`;
+            return {
+                name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+                value: project.id,
+            };
+        });
+        await interaction.respond(projects);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+        await interaction.respond([]);
+    }
+}