@otto-assistant/bridge 0.4.92

package/dist/commands/new-worktree.js

@@ -0,0 +1,366 @@
+// Worktree management command: /new-worktree
+// Uses OpenCode SDK v2 to create worktrees with kimaki- prefix
+// Creates thread immediately, then worktree in background so user can type
+import { ChannelType, REST, } from 'discord.js';
+import fs from 'node:fs';
+import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, } from '../database.js';
+import { SILENT_MESSAGE_FLAGS, reactToThread, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { notifyError } from '../sentry.js';
+import { createWorktreeWithSubmodules, execAsync, listBranchesByLastCommit, validateBranchRef, } from '../worktrees.js';
+import { WORKTREE_PREFIX } from './merge-worktree.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.WORKTREE);
+/** Status message shown while a worktree is being created. */
+export function worktreeCreatingMessage(worktreeName) {
+    return `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`;
+}
+class WorktreeError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'WorktreeError';
+    }
+}
+/**
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
+ * "My Feature" → "opencode/kimaki-my-feature"
+ * Returns empty string if no valid name can be extracted.
+ */
+export function formatWorktreeName(name) {
+    const formatted = name
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+    if (!formatted) {
+        return '';
+    }
+    return `opencode/kimaki-${formatted}`;
+}
+/**
+ * Derive worktree name from thread name.
+ * Handles existing "⬦ worktree: opencode/kimaki-name" format or uses thread name directly.
+ */
+function deriveWorktreeNameFromThread(threadName) {
+    // Handle existing "⬦ worktree: opencode/kimaki-name" format
+    const worktreeMatch = threadName.match(/worktree:\s*(.+)$/i);
+    const extractedName = worktreeMatch?.[1]?.trim();
+    if (extractedName) {
+        // If already has opencode/kimaki- prefix, return as is
+        if (extractedName.startsWith('opencode/kimaki-')) {
+            return extractedName;
+        }
+        return formatWorktreeName(extractedName);
+    }
+    // Use thread name directly
+    return formatWorktreeName(threadName);
+}
+/**
+ * Get project directory from database.
+ */
+async function getProjectDirectoryFromChannel(channel) {
+    const channelConfig = await getChannelDirectory(channel.id);
+    if (!channelConfig) {
+        return new WorktreeError('This channel is not configured with a project directory');
+    }
+    if (!fs.existsSync(channelConfig.directory)) {
+        return new WorktreeError(`Directory does not exist: ${channelConfig.directory}`);
+    }
+    return channelConfig.directory;
+}
+/**
+ * Create worktree and update the status message when done.
+ * Handles the full lifecycle: pending DB entry, git creation, DB ready/error,
+ * tree emoji reaction, and editing the status message.
+ *
+ * starterMessage is optional — if omitted, status edits are skipped (creation
+ * still proceeds). This keeps worktree creation independent of Discord message
+ * delivery, so a transient send failure never silently skips the worktree.
+ *
+ * Returns the worktree directory on success, or an Error on failure.
+ * Never throws — all internal errors are caught and returned as Error values.
+ */
+export async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, baseBranch, rest, }) {
+    return errore.tryAsync({
+        try: async () => {
+            logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`);
+            await createPendingWorktree({
+                threadId: thread.id,
+                worktreeName,
+                projectDirectory,
+            });
+            // Serialize status message edits so onProgress can't overwrite the
+            // final success/error edit even if Discord's API is slow.
+            let editChain = Promise.resolve();
+            const editStatus = (content) => {
+                editChain = editChain
+                    .then(async () => {
+                    await starterMessage?.edit(content);
+                })
+                    .catch(() => { });
+            };
+            const worktreeResult = await createWorktreeWithSubmodules({
+                directory: projectDirectory,
+                name: worktreeName,
+                baseBranch,
+                onProgress: (phase) => {
+                    editStatus(`🌳 **Worktree: ${worktreeName}**\n${phase}`);
+                },
+            });
+            if (worktreeResult instanceof Error) {
+                const errorMsg = worktreeResult.message;
+                logger.error('[WORKTREE] Creation failed:', worktreeResult);
+                await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
+                editStatus(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
+                await editChain;
+                return worktreeResult;
+            }
+            // Success - update database and edit starter message
+            await setWorktreeReady({
+                threadId: thread.id,
+                worktreeDirectory: worktreeResult.directory,
+            });
+            // React with tree emoji to mark as worktree thread
+            await reactToThread({
+                rest,
+                threadId: thread.id,
+                channelId: thread.parentId || undefined,
+                emoji: '🌳',
+            });
+            editStatus(`🌳 **Worktree: ${worktreeName}**\n` +
+                `📁 \`${worktreeResult.directory}\`\n` +
+                `🌿 Branch: \`${worktreeResult.branch}\``);
+            await editChain;
+            return worktreeResult.directory;
+        },
+        catch: (e) => {
+            logger.error('[WORKTREE] Unexpected error in createWorktreeInBackground:', e);
+            return new Error(`Worktree creation failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+        },
+    });
+}
+async function findExistingWorktreePath({ projectDirectory, worktreeName, }) {
+    const listResult = await errore.tryAsync({
+        try: () => execAsync('git worktree list --porcelain', { cwd: projectDirectory }),
+        catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+    });
+    if (errore.isError(listResult)) {
+        return listResult;
+    }
+    const lines = listResult.stdout.split('\n');
+    let currentPath = '';
+    const branchRef = `refs/heads/${worktreeName}`;
+    for (const line of lines) {
+        if (line.startsWith('worktree ')) {
+            currentPath = line.slice('worktree '.length);
+            continue;
+        }
+        if (line.startsWith('branch ') &&
+            line.slice('branch '.length) === branchRef) {
+            return currentPath || undefined;
+        }
+    }
+    return undefined;
+}
+export async function handleNewWorktreeCommand({ command, }) {
+    await command.deferReply();
+    const channel = command.channel;
+    if (!channel) {
+        await command.editReply('Cannot determine channel');
+        return;
+    }
+    const isThread = channel.type === ChannelType.PublicThread ||
+        channel.type === ChannelType.PrivateThread;
+    // Handle command in existing thread - attach worktree to this thread
+    if (isThread) {
+        await handleWorktreeInThread({
+            command,
+            thread: channel,
+        });
+        return;
+    }
+    // Handle command in text channel - create new thread with worktree (existing behavior)
+    if (channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels or threads');
+        return;
+    }
+    const rawName = command.options.getString('name');
+    const rawBaseBranch = command.options.getString('base-branch') || undefined;
+    if (!rawName) {
+        await command.editReply('Name is required when creating a worktree from a text channel. Use `/new-worktree name:my-feature`');
+        return;
+    }
+    const worktreeName = formatWorktreeName(rawName);
+    if (!worktreeName) {
+        await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.');
+        return;
+    }
+    const textChannel = channel;
+    const projectDirectory = await getProjectDirectoryFromChannel(textChannel);
+    if (errore.isError(projectDirectory)) {
+        await command.editReply(projectDirectory.message);
+        return;
+    }
+    let baseBranch = rawBaseBranch;
+    if (baseBranch) {
+        const validated = await validateBranchRef({
+            directory: projectDirectory,
+            ref: baseBranch,
+        });
+        if (validated instanceof Error) {
+            await command.editReply(`Invalid base branch: \`${baseBranch}\``);
+            return;
+        }
+        baseBranch = validated;
+    }
+    const existingWorktree = await findExistingWorktreePath({
+        projectDirectory,
+        worktreeName,
+    });
+    if (errore.isError(existingWorktree)) {
+        await command.editReply(existingWorktree.message);
+        return;
+    }
+    if (existingWorktree) {
+        await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktree}\``);
+        return;
+    }
+    // Create thread immediately so user can start typing
+    const result = await errore.tryAsync({
+        try: async () => {
+            const starterMessage = await textChannel.send({
+                content: worktreeCreatingMessage(worktreeName),
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            const thread = await starterMessage.startThread({
+                name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`,
+                autoArchiveDuration: 1440,
+                reason: 'Worktree session',
+            });
+            // Add user to thread so it appears in their sidebar
+            await thread.members.add(command.user.id);
+            return { thread, starterMessage };
+        },
+        catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
+    });
+    if (errore.isError(result)) {
+        logger.error('[NEW-WORKTREE] Error:', result.cause);
+        await command.editReply(result.message);
+        return;
+    }
+    const { thread, starterMessage } = result;
+    await command.editReply(`Creating worktree in ${thread.toString()}`);
+    // Create worktree in background (don't await)
+    createWorktreeInBackground({
+        thread,
+        starterMessage,
+        worktreeName,
+        projectDirectory,
+        baseBranch,
+        rest: command.client.rest,
+    }).catch((e) => {
+        logger.error('[NEW-WORKTREE] Background error:', e);
+        void notifyError(e, 'Background worktree creation failed');
+    });
+}
+/**
+ * Handle /new-worktree when called inside an existing thread.
+ * Attaches a worktree to the current thread, using thread name if no name provided.
+ */
+async function handleWorktreeInThread({ command, thread, }) {
+    // Error if thread already has a worktree
+    if (await getThreadWorktree(thread.id)) {
+        await command.editReply('This thread already has a worktree attached.');
+        return;
+    }
+    // Get worktree name from parameter or derive from thread name
+    const rawName = command.options.getString('name');
+    const rawBaseBranch = command.options.getString('base-branch') || undefined;
+    const worktreeName = rawName
+        ? formatWorktreeName(rawName)
+        : deriveWorktreeNameFromThread(thread.name);
+    if (!worktreeName) {
+        await command.editReply('Invalid worktree name. Please provide a name or rename the thread.');
+        return;
+    }
+    // Get parent channel for project directory
+    const parent = thread.parent;
+    if (!parent || parent.type !== ChannelType.GuildText) {
+        await command.editReply('Cannot determine parent channel');
+        return;
+    }
+    const projectDirectory = await getProjectDirectoryFromChannel(parent);
+    if (errore.isError(projectDirectory)) {
+        await command.editReply(projectDirectory.message);
+        return;
+    }
+    let baseBranch = rawBaseBranch;
+    if (baseBranch) {
+        const validated = await validateBranchRef({
+            directory: projectDirectory,
+            ref: baseBranch,
+        });
+        if (validated instanceof Error) {
+            await command.editReply(`Invalid base branch: \`${baseBranch}\``);
+            return;
+        }
+        baseBranch = validated;
+    }
+    const existingWorktreePath = await findExistingWorktreePath({
+        projectDirectory,
+        worktreeName,
+    });
+    if (errore.isError(existingWorktreePath)) {
+        await command.editReply(existingWorktreePath.message);
+        return;
+    }
+    if (existingWorktreePath) {
+        await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
+        return;
+    }
+    // Send status message in thread
+    const statusMessage = await thread.send({
+        content: worktreeCreatingMessage(worktreeName),
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`);
+    createWorktreeInBackground({
+        thread,
+        starterMessage: statusMessage,
+        worktreeName,
+        projectDirectory,
+        baseBranch,
+        rest: command.client.rest,
+    }).catch((e) => {
+        logger.error('[NEW-WORKTREE] Background error:', e);
+        void notifyError(e, 'Background worktree creation failed (in-thread)');
+    });
+}
+/**
+ * Autocomplete handler for /new-worktree base-branch option.
+ * Lists local + remote branches sorted by most recent commit date.
+ */
+export async function handleNewWorktreeAutocomplete({ interaction, }) {
+    try {
+        const focusedValue = interaction.options.getFocused();
+        // interaction.channel can be null when the channel isn't cached
+        // (common with gateway-proxy). Use channelId which is always available
+        // from the raw interaction payload.
+        const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
+        if (!projectDirectory) {
+            await interaction.respond([]);
+            return;
+        }
+        const branches = await listBranchesByLastCommit({
+            directory: projectDirectory,
+            query: focusedValue,
+        });
+        await interaction.respond(branches.map((name) => {
+            return { name, value: name };
+        }));
+    }
+    catch (e) {
+        logger.error('[NEW-WORKTREE] Autocomplete error:', e);
+        await interaction.respond([]).catch(() => { });
+    }
+}

package/dist/commands/paginated-select.js

@@ -0,0 +1,57 @@
+/**
+ * Reusable paginated select menu helpers for Discord StringSelectMenuBuilder.
+ * Discord caps select menus at 25 options. This module slices a full options
+ * list into pages of PAGE_SIZE real items and appends "← Previous page" /
+ * "Next page →" sentinel options so the user can navigate. Handlers detect
+ * sentinel values via parsePaginationValue() and re-render the same select
+ * with the new page — reusing the same customId, no new interaction handlers.
+ */
+const NAV_PREFIX = '__page_nav:';
+/** 23 real items per page, leaving room for up to 2 nav sentinels (prev + next). */
+const PAGE_SIZE = 23;
+/**
+ * Build the options array for a single page, with prev/next nav sentinels.
+ * If allOptions fits in 25 items, returns them all with no nav items.
+ */
+export function buildPaginatedOptions({ allOptions, page, }) {
+    // No pagination needed — everything fits in one Discord select
+    if (allOptions.length <= 25) {
+        return { options: allOptions, totalPages: 1 };
+    }
+    const totalPages = Math.ceil(allOptions.length / PAGE_SIZE);
+    const safePage = Math.max(0, Math.min(page, totalPages - 1));
+    const start = safePage * PAGE_SIZE;
+    const slice = allOptions.slice(start, start + PAGE_SIZE);
+    const result = [];
+    if (safePage > 0) {
+        result.push({
+            label: `← Previous page (${safePage}/${totalPages})`,
+            value: `${NAV_PREFIX}${safePage - 1}`,
+            description: 'Go to previous page',
+        });
+    }
+    result.push(...slice);
+    if (safePage < totalPages - 1) {
+        result.push({
+            label: `Next page → (${safePage + 2}/${totalPages})`,
+            value: `${NAV_PREFIX}${safePage + 1}`,
+            description: 'Go to next page',
+        });
+    }
+    return { options: result, totalPages };
+}
+/**
+ * Check if a selected value is a pagination nav sentinel.
+ * Returns the target page number if so, undefined otherwise.
+ */
+export function parsePaginationValue(value) {
+    if (!value.startsWith(NAV_PREFIX)) {
+        return undefined;
+    }
+    const pageStr = value.slice(NAV_PREFIX.length);
+    const page = Number(pageStr);
+    if (Number.isNaN(page)) {
+        return undefined;
+    }
+    return page;
+}

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