@otto-assistant/otto 0.1.1 → 0.7.15

package/dist/commands/permissions.js

@@ -0,0 +1,274 @@
+// Permission button handler - Shows buttons for permission requests.
+// When OpenCode asks for permission, this module renders 3 buttons:
+// Accept, Accept Always, and Deny.
+import { ButtonBuilder, ButtonStyle, ActionRowBuilder, MessageFlags, } from 'discord.js';
+import crypto from 'node:crypto';
+import { getOpencodeClient } from '../opencode.js';
+import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.PERMISSIONS);
+function wildcardMatch({ value, pattern, }) {
+    let escapedPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    if (escapedPattern.endsWith(' .*')) {
+        escapedPattern = escapedPattern.slice(0, -3) + '( .*)?';
+    }
+    return new RegExp(`^${escapedPattern}$`, 's').test(value);
+}
+export function arePatternsCoveredBy({ patterns, coveringPatterns, }) {
+    return patterns.every((pattern) => {
+        return coveringPatterns.some((coveringPattern) => {
+            return wildcardMatch({ value: pattern, pattern: coveringPattern });
+        });
+    });
+}
+export function compactPermissionPatterns(patterns) {
+    const uniquePatterns = Array.from(new Set(patterns));
+    return uniquePatterns.filter((pattern, index) => {
+        return !uniquePatterns.some((candidate, candidateIndex) => {
+            if (candidateIndex === index) {
+                return false;
+            }
+            return wildcardMatch({ value: pattern, pattern: candidate });
+        });
+    });
+}
+// Store pending permission contexts by hash.
+// TTL prevents unbounded growth if user never clicks a permission button.
+const PERMISSION_CONTEXT_TTL_MS = 10 * 60 * 1000;
+export const pendingPermissionContexts = new Map();
+// Atomic take: removes context from Map and returns it. Only the first caller
+// (TTL expiry or button click) wins, preventing duplicate permission replies.
+function takePendingPermissionContext(contextHash) {
+    const ctx = pendingPermissionContexts.get(contextHash);
+    if (!ctx) {
+        return undefined;
+    }
+    pendingPermissionContexts.delete(contextHash);
+    return ctx;
+}
+/**
+ * Show permission buttons for a permission request.
+ * Displays 3 buttons in a row: Accept, Accept Always, Deny.
+ * Returns the message ID and context hash for tracking.
+ */
+export async function showPermissionButtons({ thread, permission, directory, permissionDirectory, subtaskLabel, }) {
+    const contextHash = crypto.randomBytes(8).toString('hex');
+    const context = {
+        permission,
+        requestIds: [permission.id],
+        directory,
+        permissionDirectory,
+        thread,
+        contextHash,
+    };
+    pendingPermissionContexts.set(contextHash, context);
+    // Auto-reject on TTL expiry so the OpenCode session doesn't hang forever
+    // waiting for a permission reply that will never come. Uses atomic take
+    // so only one of TTL-expiry or button-click can win.
+    setTimeout(async () => {
+        const ctx = takePendingPermissionContext(contextHash);
+        if (!ctx) {
+            return;
+        }
+        const client = getOpencodeClient(ctx.directory);
+        if (client) {
+            const requestIds = ctx.requestIds.length > 0
+                ? ctx.requestIds
+                : [ctx.permission.id];
+            await Promise.all(requestIds.map((requestId) => {
+                return client.permission.reply({
+                    requestID: requestId,
+                    directory: ctx.permissionDirectory,
+                    reply: 'reject',
+                });
+            })).catch((error) => {
+                logger.error('Failed to auto-reject expired permission:', error);
+            });
+        }
+    }, PERMISSION_CONTEXT_TTL_MS).unref();
+    const patternStr = compactPermissionPatterns(permission.patterns).join(', ');
+    // Build 3 buttons for permission actions
+    const acceptButton = new ButtonBuilder()
+        .setCustomId(`permission_once:${contextHash}`)
+        .setLabel('Accept')
+        .setStyle(ButtonStyle.Success);
+    const acceptAlwaysButton = new ButtonBuilder()
+        .setCustomId(`permission_always:${contextHash}`)
+        .setLabel('Accept Always')
+        .setStyle(ButtonStyle.Success);
+    const denyButton = new ButtonBuilder()
+        .setCustomId(`permission_reject:${contextHash}`)
+        .setLabel('Deny')
+        .setStyle(ButtonStyle.Secondary);
+    const actionRow = new ActionRowBuilder().addComponents(acceptButton, acceptAlwaysButton, denyButton);
+    const subtaskLine = subtaskLabel ? `**From:** \`${subtaskLabel}\`\n` : '';
+    const externalDirLine = permission.permission === 'external_directory'
+        ? `Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)\n`
+        : '';
+    const fullContent = `⚠️ **Permission Required**\n` +
+        subtaskLine +
+        `**Type:** \`${permission.permission}\`\n` +
+        externalDirLine +
+        (patternStr ? `**Pattern:** \`${patternStr}\`` : '');
+    const permissionMessage = await thread.send({
+        content: fullContent.slice(0, 1900),
+        components: [actionRow],
+        flags: NOTIFY_MESSAGE_FLAGS | MessageFlags.SuppressEmbeds,
+    });
+    context.messageId = permissionMessage.id;
+    logger.log(`Showed permission buttons for ${permission.id}`);
+    return { messageId: permissionMessage.id, contextHash };
+}
+function updatePermissionMessage({ context, status, }) {
+    if (!context.messageId) {
+        return;
+    }
+    context.thread.messages
+        .fetch(context.messageId)
+        .then((message) => {
+        const patternStr = compactPermissionPatterns(context.permission.patterns).join(', ');
+        const externalDirLine = context.permission.permission === 'external_directory'
+            ? 'Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)\n'
+            : '';
+        return message.edit({
+            content: `⚠️ **Permission Required**\n` +
+                `**Type:** \`${context.permission.permission}\`\n` +
+                externalDirLine +
+                (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+                status,
+            components: [],
+        });
+    })
+        .catch((error) => {
+        logger.error('Failed to update permission message:', error);
+    });
+}
+export async function cancelPendingPermission(threadId) {
+    const contexts = Array.from(pendingPermissionContexts.values()).filter((context) => {
+        return context.thread.id === threadId;
+    });
+    if (contexts.length === 0) {
+        return false;
+    }
+    let cancelledCount = 0;
+    for (const context of contexts) {
+        const pendingContext = takePendingPermissionContext(context.contextHash);
+        if (!pendingContext) {
+            continue;
+        }
+        const client = getOpencodeClient(pendingContext.directory);
+        if (!client) {
+            pendingPermissionContexts.set(pendingContext.contextHash, pendingContext);
+            logger.error('Failed to dismiss pending permission: OpenCode server not found');
+            continue;
+        }
+        const requestIds = pendingContext.requestIds.length > 0
+            ? pendingContext.requestIds
+            : [pendingContext.permission.id];
+        const result = await Promise.all(requestIds.map((requestId) => {
+            return client.permission.reply({
+                requestID: requestId,
+                directory: pendingContext.permissionDirectory,
+                reply: 'reject',
+            });
+        })).then(() => {
+            return 'ok';
+        }).catch((error) => {
+            pendingPermissionContexts.set(pendingContext.contextHash, pendingContext);
+            logger.error('Failed to dismiss pending permission:', error);
+            return 'error';
+        });
+        if (result === 'error') {
+            continue;
+        }
+        updatePermissionMessage({
+            context: pendingContext,
+            status: '_Permission dismissed - user sent a new message._',
+        });
+        cancelledCount++;
+    }
+    if (cancelledCount > 0) {
+        logger.log(`Dismissed ${cancelledCount} pending permission request(s) for thread ${threadId}`);
+    }
+    return cancelledCount > 0;
+}
+/**
+ * Handle button click for permission.
+ */
+export async function handlePermissionButton(interaction) {
+    const customId = interaction.customId;
+    // Extract action and hash from customId (e.g., "permission_once:abc123")
+    const [actionPart, contextHash] = customId.split(':');
+    if (!actionPart || !contextHash) {
+        return;
+    }
+    const response = actionPart.replace('permission_', '');
+    // Atomic take: if TTL already expired and auto-rejected, context is gone.
+    const context = takePendingPermissionContext(contextHash);
+    if (!context) {
+        await interaction.update({ components: [] });
+        return;
+    }
+    await interaction.deferUpdate();
+    try {
+        const permClient = getOpencodeClient(context.directory);
+        if (!permClient) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        const requestIds = context.requestIds.length > 0
+            ? context.requestIds
+            : [context.permission.id];
+        await Promise.all(requestIds.map((requestId) => {
+            return permClient.permission.reply({
+                requestID: requestId,
+                directory: context.permissionDirectory,
+                reply: response,
+            });
+        }));
+        // Context already removed by takePendingPermissionContext above.
+        // Update message: show result and remove dropdown
+        const resultText = (() => {
+            switch (response) {
+                case 'once':
+                    return '✅ Permission **accepted**';
+                case 'always':
+                    return '✅ Permission **accepted** (auto-approve similar requests)';
+                case 'reject':
+                    return '❌ Permission **rejected**';
+            }
+        })();
+        updatePermissionMessage({
+            context,
+            status: resultText,
+        });
+        logger.log(`Permission ${context.permission.id} ${response} (${requestIds.length} request(s))`);
+    }
+    catch (error) {
+        logger.error('Error handling permission:', error);
+        await interaction.editReply({
+            content: `Failed to process permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+export function addPermissionRequestToContext({ contextHash, requestId, }) {
+    const context = pendingPermissionContexts.get(contextHash);
+    if (!context) {
+        return false;
+    }
+    if (context.requestIds.includes(requestId)) {
+        return false;
+    }
+    context.requestIds = [...context.requestIds, requestId];
+    pendingPermissionContexts.set(contextHash, context);
+    return true;
+}
+/**
+ * Clean up a pending permission context (e.g., on auto-reject).
+ */
+export function cleanupPermissionContext(contextHash) {
+    pendingPermissionContexts.delete(contextHash);
+}

package/dist/commands/queue.js

@@ -0,0 +1,223 @@
+// Queue commands - /queue, /queue-command, /clear-queue
+import { ChannelType, MessageFlags } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { resolveWorkingDirectory, sendThreadMessage, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { getRuntime, getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { notifyError } from '../sentry.js';
+import { store } from '../store.js';
+const logger = createLogger(LogPrefix.QUEUE);
+export async function handleQueueCommand({ command, appId, }) {
+    const message = command.options.getString('message', true);
+    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 thread = channel;
+    const sessionId = await getThreadSession(thread.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread. Send a message directly instead.',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({ channel: thread });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const runtime = getOrCreateRuntime({
+        threadId: thread.id,
+        thread,
+        projectDirectory: resolved.projectDirectory,
+        sdkDirectory: resolved.workingDirectory,
+        channelId: thread.parentId || thread.id,
+        appId,
+    });
+    // /queue explicitly uses otto local queue mode.
+    const enqueueResult = await runtime.enqueueIncoming({
+        prompt: message,
+        userId: command.user.id,
+        username: command.user.displayName,
+        appId,
+        mode: 'local-queue',
+    });
+    const responseText = enqueueResult.queued
+        ? `Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`
+        : `» **${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`;
+    await command.reply({
+        content: responseText,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+}
+export async function handleClearQueueCommand({ command, }) {
+    const channel = command.channel;
+    const position = command.options.getInteger('position') ?? undefined;
+    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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const runtime = getRuntime(channel.id);
+    const queueLength = runtime?.getQueueLength() ?? 0;
+    if (queueLength === 0) {
+        await command.reply({
+            content: 'No messages in queue',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (position !== undefined) {
+        const removed = runtime?.removeQueuePosition(position);
+        if (!removed) {
+            await command.reply({
+                content: `No queued message at position ${position}`,
+                flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `Cleared queued message at position ${position}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`);
+        return;
+    }
+    runtime?.clearQueue();
+    await command.reply({
+        content: `Cleared ${queueLength} queued message${queueLength > 1 ? 's' : ''}`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    logger.log(`[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`);
+}
+export async function handleQueueCommandCommand({ command, appId, }) {
+    const commandName = command.options.getString('command', true);
+    const args = command.options.getString('arguments') || '';
+    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 sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread. Send a message directly instead.',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Validate command exists in registered user commands
+    const isKnownCommand = store.getState().registeredUserCommands.some((cmd) => {
+        return cmd.name === commandName;
+    });
+    if (!isKnownCommand) {
+        await command.reply({
+            content: `Unknown command: /${commandName}. Use autocomplete to pick from available commands.`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const commandPayload = { name: commandName, arguments: args };
+    const displayText = `/${commandName}`;
+    const thread = channel;
+    const resolved = await resolveWorkingDirectory({ channel: thread });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const runtime = getOrCreateRuntime({
+        threadId: thread.id,
+        thread,
+        projectDirectory: resolved.projectDirectory,
+        sdkDirectory: resolved.workingDirectory,
+        channelId: thread.parentId || thread.id,
+        appId,
+    });
+    // /queue-command explicitly uses otto local queue mode.
+    const enqueueResult = await runtime.enqueueIncoming({
+        prompt: '',
+        userId: command.user.id,
+        username: command.user.displayName,
+        appId,
+        command: commandPayload,
+        mode: 'local-queue',
+    });
+    const responseText = enqueueResult.queued
+        ? `Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`
+        : `» **${command.user.displayName}:** ${displayText}`;
+    await command.reply({
+        content: responseText,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    logger.log(`[QUEUE] User ${command.user.displayName} queued command /${commandName} in thread ${channel.id}`);
+}
+export async function handleQueueCommandAutocomplete({ interaction, }) {
+    const focused = interaction.options.getFocused(true);
+    if (focused.name !== 'command') {
+        await interaction.respond([]);
+        return;
+    }
+    const query = focused.value.toLowerCase();
+    const choices = store.getState().registeredUserCommands
+        .filter((cmd) => {
+        return cmd.name.toLowerCase().includes(query);
+    })
+        .slice(0, 25)
+        .map((cmd) => ({
+        name: `/${cmd.name} [${cmd.source === 'skill' ? 'skill' : cmd.source === 'mcp' ? 'mcp' : 'cmd'}] - ${cmd.description}`.slice(0, 100),
+        value: cmd.name.slice(0, 100),
+    }));
+    await interaction.respond(choices);
+}

package/dist/commands/remove-project.js

@@ -0,0 +1,115 @@
+// /remove-project command - Remove Discord channels for a project.
+import path from 'node:path';
+import * as errore from 'errore';
+import { findChannelsByDirectory, deleteChannelDirectoriesByDirectory, getAllTextChannelDirectories, } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { abbreviatePath } from '../utils.js';
+const logger = createLogger(LogPrefix.REMOVE_PROJECT);
+export async function handleRemoveProjectCommand({ command, appId, }) {
+    await command.deferReply();
+    const directory = 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 {
+        // Get channel IDs for this directory
+        const channels = await findChannelsByDirectory({ directory });
+        if (channels.length === 0) {
+            await command.editReply(`No channels found for directory: \`${directory}\``);
+            return;
+        }
+        const deletedChannels = [];
+        const failedChannels = [];
+        for (const { channel_id, channel_type } of channels) {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (channel instanceof Error) {
+                logger.error(`Failed to fetch channel ${channel_id}:`, channel);
+                failedChannels.push(`${channel_type}: ${channel_id}`);
+                continue;
+            }
+            if (channel) {
+                try {
+                    await channel.delete(`Removed by /remove-project command`);
+                    deletedChannels.push(`${channel_type}: ${channel_id}`);
+                }
+                catch (error) {
+                    logger.error(`Failed to delete channel ${channel_id}:`, error);
+                    failedChannels.push(`${channel_type}: ${channel_id}`);
+                }
+            }
+            else {
+                deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`);
+            }
+        }
+        // Remove from database
+        await deleteChannelDirectoriesByDirectory(directory);
+        const projectName = path.basename(directory);
+        let message = `Removed project **${projectName}**\n`;
+        message += `Directory: \`${directory}\`\n\n`;
+        if (deletedChannels.length > 0) {
+            message += `Deleted channels:\n${deletedChannels.map((c) => `- ${c}`).join('\n')}`;
+        }
+        if (failedChannels.length > 0) {
+            message += `\n\nFailed to delete (may be in another server):\n${failedChannels.map((c) => `- ${c}`).join('\n')}`;
+        }
+        await command.editReply(message);
+        logger.log(`Removed project ${projectName} at ${directory}`);
+    }
+    catch (error) {
+        logger.error('[REMOVE-PROJECT] Error:', error);
+        await command.editReply(`Failed to remove project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    const guild = interaction.guild;
+    if (!guild) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        // Get all directories with channels
+        const allChannels = (await findChannelsByDirectory({
+            channelType: 'text',
+        }));
+        // Filter to only channels that exist in this guild
+        const projectsInGuild = [];
+        for (const { directory, channel_id } of allChannels) {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (channel instanceof Error) {
+                // Channel not in this guild, skip
+                continue;
+            }
+            if (channel) {
+                projectsInGuild.push({ directory, channelId: channel_id });
+            }
+        }
+        const projects = projectsInGuild
+            .filter(({ directory }) => {
+            const baseName = path.basename(directory);
+            const searchText = `${baseName} ${directory}`.toLowerCase();
+            return searchText.includes(focusedValue.toLowerCase());
+        })
+            .slice(0, 25)
+            .map(({ directory }) => {
+            const name = `${path.basename(directory)} (${abbreviatePath(directory)})`;
+            return {
+                name: name.length > 100 ? name.slice(0, 99) + '...' : name,
+                value: directory,
+            };
+        });
+        await interaction.respond(projects);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+        await interaction.respond([]);
+    }
+}