@otto-assistant/bridge 0.4.92

package/dist/commands/user-command.js

@@ -0,0 +1,155 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { getChannelDirectory, getThreadSession } from '../database.js';
+import { store } from '../store.js';
+import fs from 'node:fs';
+const userCommandLogger = createLogger(LogPrefix.USER_CMD);
+const DISCORD_MESSAGE_LIMIT = 2000;
+const DISCORD_THREAD_NAME_LIMIT = 100;
+export const handleUserCommand = async ({ command, appId, }) => {
+    const discordCommandName = command.commandName;
+    // Look up the original OpenCode command name from the mapping populated at registration.
+    // The sanitized Discord name is lossy (e.g. foo:bar → foo-bar), so resolving from
+    // the exact registered slash command name avoids collisions.
+    const registered = store.getState().registeredUserCommands.find((c) => c.discordCommandName === discordCommandName);
+    const fallbackBase = discordCommandName.replace(/-(cmd|skill|mcp-prompt)$/, '');
+    const commandName = registered?.name || fallbackBase;
+    const args = command.options.getString('arguments') || '';
+    const commandInvocation = args ? `/${commandName} ${args}` : `/${commandName}`;
+    const threadOpeningMessage = commandInvocation.length <= DISCORD_MESSAGE_LIMIT
+        ? commandInvocation
+        : `${commandInvocation.slice(0, DISCORD_MESSAGE_LIMIT - 14)}... truncated`;
+    userCommandLogger.log(`Executing /${commandName} (from /${discordCommandName}) argsLength=${args.length}`);
+    const channel = command.channel;
+    userCommandLogger.log(`Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`);
+    const isThread = channel &&
+        [
+            ChannelType.PublicThread,
+            ChannelType.PrivateThread,
+            ChannelType.AnnouncementThread,
+        ].includes(channel.type);
+    const isTextChannel = channel?.type === ChannelType.GuildText;
+    if (!channel || (!isTextChannel && !isThread)) {
+        await command.reply({
+            content: 'This command can only be used in text channels or threads',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    let projectDirectory;
+    let textChannel = null;
+    let thread = null;
+    if (isThread) {
+        // Running in an existing thread - get project directory from parent channel
+        thread = channel;
+        textChannel = thread.parent;
+        // Verify this thread has an existing session
+        const sessionId = await getThreadSession(thread.id);
+        if (!sessionId) {
+            await command.reply({
+                content: 'This thread does not have an active session. Use this command in a project channel to create a new thread.',
+                flags: MessageFlags.Ephemeral,
+            });
+            return;
+        }
+        if (textChannel) {
+            const channelConfig = await getChannelDirectory(textChannel.id);
+            projectDirectory = channelConfig?.directory;
+        }
+    }
+    else {
+        // Running in a text channel - will create a new thread
+        textChannel = channel;
+        const channelConfig = await getChannelDirectory(textChannel.id);
+        projectDirectory = channelConfig?.directory;
+    }
+    if (!projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    if (!fs.existsSync(projectDirectory)) {
+        await command.reply({
+            content: `Directory does not exist: ${projectDirectory}`,
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await command.deferReply();
+    try {
+        // Use the dedicated session.command API instead of formatting as text prompt
+        const commandPayload = { name: commandName, arguments: args };
+        if (isThread && thread) {
+            // Running in existing thread - just send the command
+            await command.editReply(`Running ${commandInvocation}...`);
+            const runtime = getOrCreateRuntime({
+                threadId: thread.id,
+                thread,
+                projectDirectory,
+                sdkDirectory: projectDirectory,
+                channelId: textChannel?.id,
+                appId,
+            });
+            await runtime.enqueueIncoming({
+                prompt: '',
+                userId: command.user.id,
+                username: command.user.displayName,
+                command: commandPayload,
+                appId,
+                mode: 'local-queue',
+            });
+        }
+        else if (textChannel) {
+            // Running in text channel - create a new thread
+            const starterMessage = await textChannel.send({
+                content: threadOpeningMessage,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            const newThread = await starterMessage.startThread({
+                name: commandInvocation.slice(0, DISCORD_THREAD_NAME_LIMIT),
+                autoArchiveDuration: 1440,
+                reason: `OpenCode command: ${commandName}`,
+            });
+            // Add user to thread so it appears in their sidebar
+            await newThread.members.add(command.user.id);
+            await command.editReply(`Started /${commandName} in ${newThread.toString()}`);
+            const runtime = getOrCreateRuntime({
+                threadId: newThread.id,
+                thread: newThread,
+                projectDirectory,
+                sdkDirectory: projectDirectory,
+                channelId: textChannel.id,
+                appId,
+            });
+            await runtime.enqueueIncoming({
+                prompt: '',
+                userId: command.user.id,
+                username: command.user.displayName,
+                command: commandPayload,
+                appId,
+                mode: 'local-queue',
+            });
+        }
+    }
+    catch (error) {
+        userCommandLogger.error(`Error executing /${commandName}:`, error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (command.deferred) {
+            await command.editReply({
+                content: `Failed to execute /${commandName}: ${errorMessage}`,
+            });
+        }
+        else {
+            await command.reply({
+                content: `Failed to execute /${commandName}: ${errorMessage}`,
+                flags: MessageFlags.Ephemeral,
+            });
+        }
+    }
+};

package/dist/commands/verbosity.js

@@ -0,0 +1,125 @@
+// /verbosity command.
+// Shows a dropdown to set output verbosity level for sessions in a channel.
+// 'text_and_essential_tools' (default): shows text and essential tools (edits, custom MCP tools)
+// 'tools_and_text': shows all output including tool executions
+// 'text_only': only shows text responses
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, MessageFlags, ChannelType, } from 'discord.js';
+import { getChannelVerbosity, setChannelVerbosity, } from '../database.js';
+import { getPrisma } from '../db.js';
+import { store } from '../store.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const verbosityLogger = createLogger(LogPrefix.VERBOSITY);
+const VERBOSITY_OPTIONS = [
+    {
+        value: 'tools_and_text',
+        label: 'Tools and text',
+        description: 'All output including tool executions and status messages',
+    },
+    {
+        value: 'text_and_essential_tools',
+        label: 'Text and essential tools',
+        description: 'Text + essential tools (edits, custom MCP). Hides read/search.',
+    },
+    {
+        value: 'text_only',
+        label: 'Text only',
+        description: 'Only text responses. Hides all tools and status messages.',
+    },
+];
+function resolveChannelId(channel) {
+    if (!channel) {
+        return null;
+    }
+    if (channel.type === ChannelType.GuildText) {
+        return channel.id;
+    }
+    if (channel.type === ChannelType.PublicThread ||
+        channel.type === ChannelType.PrivateThread ||
+        channel.type === ChannelType.AnnouncementThread) {
+        return channel.parentId || channel.id;
+    }
+    return channel.id;
+}
+/**
+ * Check if there is a per-channel verbosity override in the DB.
+ * Returns the override value if it exists, null otherwise.
+ */
+async function getChannelVerbosityOverride(channelId) {
+    const prisma = await getPrisma();
+    const row = await prisma.channel_verbosity.findUnique({
+        where: { channel_id: channelId },
+    });
+    if (row?.verbosity) {
+        return row.verbosity;
+    }
+    return null;
+}
+/**
+ * Handle the /verbosity slash command.
+ * Shows a dropdown with the current verbosity level and available options.
+ */
+export async function handleVerbosityCommand({ command, }) {
+    verbosityLogger.log('[VERBOSITY] Command called');
+    const channelId = resolveChannelId(command.channel);
+    if (!channelId) {
+        await command.reply({
+            content: 'Could not determine channel.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const override = await getChannelVerbosityOverride(channelId);
+    const currentLevel = override || store.getState().defaultVerbosity;
+    const source = override ? 'channel override' : 'global default';
+    const options = VERBOSITY_OPTIONS.map((opt) => ({
+        label: opt.label,
+        value: opt.value,
+        description: opt.description,
+        default: opt.value === currentLevel,
+    }));
+    const selectMenu = new StringSelectMenuBuilder()
+        .setCustomId(`verbosity_select:${channelId}`)
+        .setPlaceholder('Select verbosity level')
+        .addOptions(options);
+    const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+    await command.reply({
+        content: `**Verbosity**\nCurrent: \`${currentLevel}\` (${source})`,
+        components: [actionRow],
+        flags: MessageFlags.Ephemeral,
+    });
+}
+/**
+ * Handle the verbosity select menu interaction.
+ * Sets the selected verbosity level for the channel.
+ */
+export async function handleVerbositySelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('verbosity_select:')) {
+        return;
+    }
+    await interaction.deferUpdate();
+    const channelId = customId.replace('verbosity_select:', '');
+    const level = interaction.values[0];
+    if (!level) {
+        await interaction.editReply({
+            content: 'No level selected.',
+            components: [],
+        });
+        return;
+    }
+    const currentLevel = await getChannelVerbosity(channelId);
+    if (currentLevel === level) {
+        await interaction.editReply({
+            content: `Verbosity is already \`${level}\` for this channel.`,
+            components: [],
+        });
+        return;
+    }
+    await setChannelVerbosity(channelId, level);
+    verbosityLogger.log(`[VERBOSITY] Set channel ${channelId} to ${level}`);
+    const description = VERBOSITY_OPTIONS.find((o) => o.value === level)?.description || '';
+    await interaction.editReply({
+        content: `Verbosity set to \`${level}\` for this channel.\n${description}\nApplies immediately, including active sessions.`,
+        components: [],
+    });
+}

package/dist/commands/worktree-settings.js

@@ -0,0 +1,43 @@
+// /toggle-worktrees command.
+// Allows per-channel opt-in for automatic worktree creation,
+// as an alternative to the global --use-worktrees CLI flag.
+import { ChatInputCommandInteraction, MessageFlags, ChannelType, } from 'discord.js';
+import { getChannelWorktreesEnabled, setChannelWorktreesEnabled, } from '../database.js';
+import { getKimakiMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE);
+/**
+ * Handle the /toggle-worktrees slash command.
+ * Toggles automatic worktree creation for new sessions in this channel.
+ */
+export async function handleToggleWorktreesCommand({ command, }) {
+    worktreeSettingsLogger.log('[TOGGLE_WORKTREES] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = await getKimakiMetadata(textChannel);
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const wasEnabled = await getChannelWorktreesEnabled(textChannel.id);
+    const nextEnabled = !wasEnabled;
+    await setChannelWorktreesEnabled(textChannel.id, nextEnabled);
+    const nextLabel = nextEnabled ? 'enabled' : 'disabled';
+    worktreeSettingsLogger.log(`[TOGGLE_WORKTREES] ${nextLabel.toUpperCase()} for channel ${textChannel.id}`);
+    await command.reply({
+        content: nextEnabled
+            ? `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will now automatically create git worktrees.\n\nNew setting for **#${textChannel.name}**: **enabled**.`
+            : `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will use the main project directory.\n\nNew setting for **#${textChannel.name}**: **disabled**.`,
+        flags: MessageFlags.Ephemeral,
+    });
+}