@otto-assistant/otto 0.1.1 → 0.7.15

package/dist/commands/undo-redo.js

@@ -0,0 +1,305 @@
+// Undo/Redo commands - /undo, /redo
+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.UNDO_REDO);
+async function waitForSessionIdle({ client, sessionId, directory, timeoutMs = 2_000, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const statusResponse = await client.session.status({ directory });
+        const sessionStatus = statusResponse.data?.[sessionId];
+        if (!sessionStatus || sessionStatus.type === 'idle') {
+            return;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 50);
+        });
+    }
+}
+export async function handleUndoCommand({ 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 });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to undo: ${getClient.message}`);
+        return;
+    }
+    try {
+        const client = getClient();
+        // Fetch session to check existing revert state
+        const sessionResponse = await client.session.get({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (sessionResponse.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(sessionResponse.error)}`);
+            return;
+        }
+        // Abort if session is busy before reverting, matching TUI behavior
+        // (use-session-commands.tsx always aborts non-idle sessions before revert).
+        // session.status() returns a sparse map — only non-idle sessions have entries,
+        // so a missing key means idle.
+        const statusResponse = await client.session.status({
+            directory: workingDirectory,
+        });
+        const sessionStatus = statusResponse.data?.[sessionId];
+        if (sessionStatus && sessionStatus.type !== 'idle') {
+            await client.session.abort({
+                sessionID: sessionId,
+                directory: workingDirectory,
+            }).catch((error) => {
+                logger.warn(`[UNDO] abort failed for ${sessionId}`, error);
+            });
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+        }
+        const messagesResponse = await client.session.messages({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (messagesResponse.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(messagesResponse.error)}`);
+            return;
+        }
+        if (!messagesResponse.data || messagesResponse.data.length === 0) {
+            await command.editReply('No messages to undo');
+            return;
+        }
+        // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
+        // find the last user message that is before the current revert point
+        // (or the last user message if no revert is active). This matches the
+        // TUI's `findLast(userMessages(), (x) => !revert || x.id < revert)`.
+        const currentRevert = sessionResponse.data?.revert?.messageID;
+        const userMessages = messagesResponse.data.filter((m) => {
+            return m.info.role === 'user';
+        });
+        const targetUserMessage = [...userMessages].reverse().find((m) => {
+            return !currentRevert || m.info.id < currentRevert;
+        });
+        if (!targetUserMessage) {
+            await command.editReply('No messages to undo');
+            return;
+        }
+        const targetAssistantMessage = [...messagesResponse.data].reverse().find((m) => {
+            return m.info.role === 'assistant' && m.info.parentID === targetUserMessage.info.id;
+        });
+        const revertMessageId = targetAssistantMessage?.info.id || targetUserMessage.info.id;
+        // session.revert() reverts filesystem patches (file edits, writes) and
+        // marks the session with revert.messageID. Messages are NOT deleted — they
+        // get cleaned up automatically on the next promptAsync() call via
+        // SessionRevert.cleanup(). The model only sees messages before the revert
+        // point when processing the next prompt.
+        logger.log(`[UNDO] session.revert start messageId=${revertMessageId}`);
+        let response = await client.session.revert({
+            sessionID: sessionId,
+            directory: workingDirectory,
+            messageID: revertMessageId,
+        });
+        logger.log(`[UNDO] session.revert done error=${Boolean(response.error)}`);
+        if (response.error) {
+            logger.log('[UNDO] retry wait idle before revert retry');
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+            logger.log('[UNDO] retry revert start');
+            response = await client.session.revert({
+                sessionID: sessionId,
+                directory: workingDirectory,
+                messageID: revertMessageId,
+            });
+            logger.log(`[UNDO] retry revert done error=${Boolean(response.error)}`);
+            if (response.error) {
+                await command.editReply(`Failed to undo: ${JSON.stringify(response.error)}`);
+                return;
+            }
+        }
+        const diffInfo = response.data?.revert?.diff
+            ? `\n\`\`\`diff\n${response.data.revert.diff.slice(0, 1500)}\n\`\`\``
+            : '';
+        await command.editReply(`Undone - reverted last assistant message${diffInfo}`);
+        logger.log(`Session ${sessionId} reverted at message ${revertMessageId}`);
+    }
+    catch (error) {
+        logger.error('[UNDO] Error:', error);
+        await command.editReply(`Failed to undo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRedoCommand({ 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 });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to redo: ${getClient.message}`);
+        return;
+    }
+    try {
+        const client = getClient();
+        // Fetch session to check existing revert state
+        const sessionResponse = await client.session.get({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (sessionResponse.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(sessionResponse.error)}`);
+            return;
+        }
+        const revertMessageID = sessionResponse.data?.revert?.messageID;
+        if (!revertMessageID) {
+            await command.editReply('Nothing to redo - no previous undo found');
+            return;
+        }
+        // Abort if session is busy before reverting/unreverting — both enforce
+        // assertNotBusy in OpenCode and would fail with "Session is busy"
+        const redoStatusResponse = await client.session.status({
+            directory: workingDirectory,
+        });
+        const redoSessionStatus = redoStatusResponse.data?.[sessionId];
+        if (redoSessionStatus && redoSessionStatus.type !== 'idle') {
+            await client.session.abort({
+                sessionID: sessionId,
+                directory: workingDirectory,
+            }).catch((error) => {
+                logger.warn(`[REDO] abort failed for ${sessionId}`, error);
+            });
+            await waitForSessionIdle({
+                client,
+                sessionId,
+                directory: workingDirectory,
+            });
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 500);
+        });
+        // Follow the same approach as the OpenCode TUI (use-session-commands.tsx):
+        // find the next user message after the current revert point. If one exists,
+        // move the revert cursor forward to it (one step redo). If none exists,
+        // fully unrevert — we're at the end of the message history.
+        const messagesResponse = await client.session.messages({
+            sessionID: sessionId,
+            directory: workingDirectory,
+        });
+        if (messagesResponse.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(messagesResponse.error)}`);
+            return;
+        }
+        const userMessages = (messagesResponse.data ?? []).filter((m) => {
+            return m.info.role === 'user';
+        });
+        const nextMessage = userMessages.find((m) => {
+            return m.info.id > revertMessageID;
+        });
+        if (!nextMessage) {
+            // No more messages after revert point — fully unrevert
+            const response = await client.session.unrevert({
+                sessionID: sessionId,
+                directory: workingDirectory,
+            });
+            if (response.error) {
+                await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
+                return;
+            }
+            await command.editReply('Restored - session fully back to previous state');
+            logger.log(`Session ${sessionId} unrevert completed`);
+            return;
+        }
+        // Move revert cursor forward one step to the next user message
+        const response = await client.session.revert({
+            sessionID: sessionId,
+            directory: workingDirectory,
+            messageID: nextMessage.info.id,
+        });
+        if (response.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
+            return;
+        }
+        await command.editReply('Restored one step forward');
+        logger.log(`Session ${sessionId} redo: moved revert to ${nextMessage.info.id}`);
+    }
+    catch (error) {
+        logger.error('[REDO] Error:', error);
+        await command.editReply(`Failed to redo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/unset-model.js

@@ -0,0 +1,139 @@
+// /unset-model-override command - Remove model overrides and use default instead.
+import { ChatInputCommandInteraction, ChannelType, MessageFlags, } from 'discord.js';
+import { getChannelModel, getSessionModel, getThreadSession, clearSessionModel, } from '../database.js';
+import { getPrisma } from '../db.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getOttoMetadata } from '../discord-utils.js';
+import { getRuntime } from '../session-handler/thread-session-runtime.js';
+import { getCurrentModelInfo } from './model.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const unsetModelLogger = createLogger(LogPrefix.MODEL);
+function formatModelSource(type, agentName) {
+    switch (type) {
+        case 'session':
+            return 'session override';
+        case 'agent':
+            return `agent "${agentName}"`;
+        case 'channel':
+            return 'channel override';
+        case 'global':
+            return 'global default';
+        case 'opencode-config':
+        case 'opencode-recent':
+        case 'opencode-provider-default':
+            return 'opencode default';
+        default:
+            return 'none';
+    }
+}
+/**
+ * Handle the /unset-model-override slash command.
+ * In thread: clears session override if exists, otherwise channel override.
+ * In channel: clears channel override.
+ */
+export async function handleUnsetModelCommand({ interaction, appId, }) {
+    unsetModelLogger.log('[UNSET-MODEL] handleUnsetModelCommand called');
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let targetChannelId;
+    let sessionId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = await getOttoMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        targetChannelId = textChannel?.id || channel.id;
+        sessionId = await getThreadSession(thread.id);
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = await getOttoMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
+        return;
+    }
+    // Check what overrides exist
+    const [sessionPref, channelPref] = await Promise.all([
+        sessionId ? getSessionModel(sessionId) : Promise.resolve(undefined),
+        getChannelModel(targetChannelId),
+    ]);
+    let clearedType = null;
+    let clearedModel;
+    if (isThread && sessionId && sessionPref) {
+        // In thread with session override: clear session
+        await clearSessionModel(sessionId);
+        clearedType = 'session';
+        clearedModel = sessionPref.modelId;
+        unsetModelLogger.log(`[UNSET-MODEL] Cleared session model for ${sessionId}`);
+    }
+    else if (channelPref) {
+        // Clear channel override
+        const prisma = await getPrisma();
+        await prisma.channel_models.deleteMany({
+            where: { channel_id: targetChannelId },
+        });
+        clearedType = 'channel';
+        clearedModel = channelPref.modelId;
+        unsetModelLogger.log(`[UNSET-MODEL] Cleared channel model for ${targetChannelId}`);
+    }
+    else {
+        await interaction.editReply({
+            content: 'No model override to clear.',
+        });
+        return;
+    }
+    // Get the new model that will be used
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    let newModelText = 'unknown';
+    if (!(getClient instanceof Error)) {
+        const newModelInfo = await getCurrentModelInfo({
+            sessionId,
+            channelId: targetChannelId,
+            appId,
+            getClient,
+            directory: projectDirectory,
+        });
+        newModelText =
+            newModelInfo.type === 'none'
+                ? 'none'
+                : `\`${newModelInfo.model}\` (${formatModelSource(newModelInfo.type, 'agentName' in newModelInfo ? newModelInfo.agentName : undefined)})`;
+    }
+    // Check if there's a running request and abort+retry with new model (only for session changes in threads)
+    let retried = false;
+    if (isThread && clearedType === 'session' && sessionId) {
+        const runtime = getRuntime(channel.id);
+        if (runtime) {
+            retried = await runtime.retryLastUserPrompt();
+        }
+    }
+    const clearedTypeText = clearedType === 'session' ? 'Session' : 'Channel';
+    const retriedText = retried
+        ? '\n_Restarting current request with new model..._'
+        : '';
+    await interaction.editReply({
+        content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}${retriedText}`,
+    });
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,48 @@
+// /upgrade-and-restart command - Upgrade otto to the latest version and restart the bot.
+// Checks npm for a newer version, installs it globally, then spawns a new otto process.
+// Spawn `otto gateway start`; the new process evicts the old one (single-instance lock).
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { getCurrentVersion, upgrade } from '../upgrade.js';
+import { spawn } from 'node:child_process';
+const logger = createLogger(LogPrefix.CLI);
+export async function handleUpgradeAndRestartCommand({ command, }) {
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    logger.log('[UPGRADE] /upgrade-and-restart triggered');
+    try {
+        const currentVersion = getCurrentVersion();
+        const newVersion = await upgrade();
+        if (!newVersion) {
+            await command.editReply({
+                content: `Already on latest version: **v${currentVersion}**`,
+            });
+            return;
+        }
+        await command.editReply({
+            content: `Upgraded otto **v${currentVersion}** -> **v${newVersion}**. Restarting bot...`,
+        });
+        // Spawning `otto gateway start` works even if the user originally ran via npx/bunx:
+        // `npm i -g @otto-assistant/otto@latest` creates a global bin link, and
+        // npx resolves local -> global -> cache -> registry, so it prefers the
+        // global install. bunx shares the same global cache too.
+        const scriptPath = process.argv[1];
+        if (!scriptPath) {
+            throw new Error('Unable to resolve current CLI script path');
+        }
+        const child = spawn(process.execPath, [scriptPath, 'gateway', 'start'], {
+            stdio: 'ignore',
+            detached: true,
+            env: process.env,
+            shell: false,
+            windowsHide: process.platform === 'win32',
+        });
+        child.unref();
+        logger.debug('Started new background otto process');
+    }
+    catch (error) {
+        logger.error('[UPGRADE] Failed:', error);
+        await command.editReply({
+            content: `Upgrade failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}

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,
+            });
+        }
+    }
+};