@otto-assistant/bridge 0.4.92

package/dist/interaction-handler.js

@@ -0,0 +1,397 @@
+// Discord slash command and interaction handler.
+// Processes all slash commands (/session, /resume, /fork, /model, /abort, etc.)
+// and manages autocomplete, select menu interactions for the bot.
+import { Events, MessageFlags, } from 'discord.js';
+import { handleSessionCommand, handleSessionAutocomplete, } from './commands/session.js';
+import { handleNewWorktreeCommand, handleNewWorktreeAutocomplete, } from './commands/new-worktree.js';
+import { handleMergeWorktreeCommand, handleMergeWorktreeAutocomplete, } from './commands/merge-worktree.js';
+import { handleToggleWorktreesCommand } from './commands/worktree-settings.js';
+import { handleWorktreesCommand } from './commands/worktrees.js';
+import { handleTasksCommand } from './commands/tasks.js';
+import { handleResumeCommand, handleResumeAutocomplete, } from './commands/resume.js';
+import { handleAddProjectCommand, handleAddProjectAutocomplete, } from './commands/add-project.js';
+import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
+import { handleCreateNewProjectCommand } from './commands/create-new-project.js';
+import { handlePermissionButton } from './commands/permissions.js';
+import { handleAbortCommand } from './commands/abort.js';
+import { handleCompactCommand } from './commands/compact.js';
+import { handleShareCommand } from './commands/share.js';
+import { handleDiffCommand } from './commands/diff.js';
+import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
+import { handleBtwCommand } from './commands/btw.js';
+import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, handleModelScopeSelectMenu, } from './commands/model.js';
+import { handleUnsetModelCommand } from './commands/unset-model.js';
+import { handleLoginCommand, handleLoginSelect, handleLoginTextButton, handleLoginTextModalSubmit, handleLoginApiKeyButton, handleOAuthCodeButton, handleOAuthCodeModalSubmit, handleApiKeyModalSubmit, } from './commands/login.js';
+import { handleTranscriptionApiKeyButton, handleTranscriptionApiKeyCommand, handleTranscriptionApiKeyModalSubmit, } from './commands/gemini-apikey.js';
+import { handleAgentCommand, handleAgentSelectMenu, handleQuickAgentCommand, } from './commands/agent.js';
+import { handleAskQuestionSelectMenu } from './commands/ask-question.js';
+import { handleFileUploadButton, handleFileUploadModalSubmit, } from './commands/file-upload.js';
+import { handleActionButton } from './commands/action-buttons.js';
+import { handleHtmlActionButton } from './html-actions.js';
+import { handleQueueCommand, handleClearQueueCommand, handleQueueCommandCommand, handleQueueCommandAutocomplete, } from './commands/queue.js';
+import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js';
+import { handleUserCommand } from './commands/user-command.js';
+import { handleVerbosityCommand, handleVerbositySelectMenu, } from './commands/verbosity.js';
+import { handleRestartOpencodeServerCommand } from './commands/restart-opencode-server.js';
+import { handleRunCommand } from './commands/run-command.js';
+import { handleContextUsageCommand } from './commands/context-usage.js';
+import { handleSessionIdCommand } from './commands/session-id.js';
+import { handleUpgradeAndRestartCommand } from './commands/upgrade.js';
+import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js';
+import { handleScreenshareCommand, handleScreenshareStopCommand, } from './commands/screenshare.js';
+import { handleModelVariantSelectMenu } from './commands/model.js';
+import { handleModelVariantCommand, handleVariantQuickSelectMenu, handleVariantScopeSelectMenu, } from './commands/model-variant.js';
+import { hasKimakiBotPermission } from './discord-utils.js';
+import { createLogger, LogPrefix } from './logger.js';
+import { notifyError } from './sentry.js';
+const interactionLogger = createLogger(LogPrefix.INTERACTION);
+export function registerInteractionHandler({ discordClient, appId, }) {
+    interactionLogger.log('[REGISTER] Interaction handler registered');
+    discordClient.on(Events.InteractionCreate, async (interaction) => {
+        try {
+            interactionLogger.log(`[INTERACTION] Received: ${interaction.type} - ${interaction.isChatInputCommand()
+                ? interaction.commandName
+                : interaction.isAutocomplete()
+                    ? `autocomplete:${interaction.commandName}`
+                    : 'other'}`);
+            if (interaction.isAutocomplete()) {
+                switch (interaction.commandName) {
+                    case 'new-session':
+                        await handleSessionAutocomplete({ interaction, appId });
+                        return;
+                    case 'resume':
+                        await handleResumeAutocomplete({ interaction, appId });
+                        return;
+                    case 'add-project':
+                        await handleAddProjectAutocomplete({ interaction, appId });
+                        return;
+                    case 'remove-project':
+                        await handleRemoveProjectAutocomplete({ interaction, appId });
+                        return;
+                    case 'queue-command':
+                        await handleQueueCommandAutocomplete({ interaction, appId });
+                        return;
+                    case 'new-worktree':
+                        await handleNewWorktreeAutocomplete({ interaction, appId });
+                        return;
+                    case 'merge-worktree':
+                        await handleMergeWorktreeAutocomplete({ interaction, appId });
+                        return;
+                    default:
+                        await interaction.respond([]);
+                        return;
+                }
+            }
+            if (interaction.isChatInputCommand()) {
+                interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`);
+                if (!hasKimakiBotPermission(interaction.member, interaction.guild)) {
+                    await interaction.reply({
+                        content: `You don't have permission to use this command.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
+                        flags: MessageFlags.Ephemeral,
+                    });
+                    return;
+                }
+                switch (interaction.commandName) {
+                    case 'new-session':
+                        await handleSessionCommand({ command: interaction, appId });
+                        return;
+                    case 'new-worktree':
+                        await handleNewWorktreeCommand({ command: interaction, appId });
+                        return;
+                    case 'merge-worktree':
+                        await handleMergeWorktreeCommand({ command: interaction, appId });
+                        return;
+                    case 'toggle-worktrees':
+                        await handleToggleWorktreesCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'worktrees':
+                        await handleWorktreesCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'tasks':
+                        await handleTasksCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'resume':
+                        await handleResumeCommand({ command: interaction, appId });
+                        return;
+                    case 'add-project':
+                        await handleAddProjectCommand({ command: interaction, appId });
+                        return;
+                    case 'remove-project':
+                        await handleRemoveProjectCommand({ command: interaction, appId });
+                        return;
+                    case 'create-new-project':
+                        await handleCreateNewProjectCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'abort':
+                        await handleAbortCommand({ command: interaction, appId });
+                        return;
+                    case 'compact':
+                        await handleCompactCommand({ command: interaction, appId });
+                        return;
+                    case 'share':
+                        await handleShareCommand({ command: interaction, appId });
+                        return;
+                    case 'diff':
+                        await handleDiffCommand({ command: interaction, appId });
+                        return;
+                    case 'fork':
+                        await handleForkCommand(interaction);
+                        return;
+                    case 'btw':
+                        await handleBtwCommand({ command: interaction, appId });
+                        return;
+                    case 'model':
+                        await handleModelCommand({ interaction, appId });
+                        return;
+                    case 'model-variant':
+                        await handleModelVariantCommand({ interaction, appId });
+                        return;
+                    case 'unset-model-override':
+                        await handleUnsetModelCommand({ interaction, appId });
+                        return;
+                    case 'login':
+                        await handleLoginCommand({ interaction, appId });
+                        return;
+                    case 'agent':
+                        await handleAgentCommand({ interaction, appId });
+                        return;
+                    case 'queue':
+                        await handleQueueCommand({ command: interaction, appId });
+                        return;
+                    case 'clear-queue':
+                        await handleClearQueueCommand({ command: interaction, appId });
+                        return;
+                    case 'queue-command':
+                        await handleQueueCommandCommand({ command: interaction, appId });
+                        return;
+                    case 'undo':
+                        await handleUndoCommand({ command: interaction, appId });
+                        return;
+                    case 'redo':
+                        await handleRedoCommand({ command: interaction, appId });
+                        return;
+                    case 'verbosity':
+                        await handleVerbosityCommand({ command: interaction, appId });
+                        return;
+                    case 'restart-opencode-server':
+                        await handleRestartOpencodeServerCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'run-shell-command':
+                        await handleRunCommand({ command: interaction, appId });
+                        return;
+                    case 'context-usage':
+                        await handleContextUsageCommand({ command: interaction, appId });
+                        return;
+                    case 'session-id':
+                        await handleSessionIdCommand({ command: interaction, appId });
+                        return;
+                    case 'upgrade-and-restart':
+                        await handleUpgradeAndRestartCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                    case 'transcription-key':
+                        await handleTranscriptionApiKeyCommand({
+                            interaction,
+                            appId,
+                        });
+                        return;
+                    case 'mcp':
+                        await handleMcpCommand({ command: interaction, appId });
+                        return;
+                    case 'screenshare':
+                        await handleScreenshareCommand({ command: interaction, appId });
+                        return;
+                    case 'screenshare-stop':
+                        await handleScreenshareStopCommand({
+                            command: interaction,
+                            appId,
+                        });
+                        return;
+                }
+                // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
+                if (interaction.commandName.endsWith('-agent') &&
+                    interaction.commandName !== 'agent') {
+                    await handleQuickAgentCommand({ command: interaction, appId });
+                    return;
+                }
+                // Handle user-defined commands (ending with -cmd, -skill, or -mcp-prompt suffix)
+                if (interaction.commandName.endsWith('-cmd') ||
+                    interaction.commandName.endsWith('-skill') ||
+                    interaction.commandName.endsWith('-mcp-prompt')) {
+                    await handleUserCommand({ command: interaction, appId });
+                    return;
+                }
+                return;
+            }
+            if (interaction.isButton()) {
+                if (!hasKimakiBotPermission(interaction.member, interaction.guild)) {
+                    await interaction.reply({
+                        content: `You don't have permission to use this.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
+                        flags: MessageFlags.Ephemeral,
+                    });
+                    return;
+                }
+                const customId = interaction.customId;
+                if (customId.startsWith('transcription_apikey:')) {
+                    await handleTranscriptionApiKeyButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('permission_once:') ||
+                    customId.startsWith('permission_always:') ||
+                    customId.startsWith('permission_reject:')) {
+                    await handlePermissionButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('file_upload_btn:')) {
+                    await handleFileUploadButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('login_text_btn:')) {
+                    await handleLoginTextButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('login_apikey_btn:')) {
+                    await handleLoginApiKeyButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('login_oauth_code_btn:')) {
+                    await handleOAuthCodeButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('action_button:')) {
+                    await handleActionButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('html_action:')) {
+                    await handleHtmlActionButton(interaction);
+                    return;
+                }
+                return;
+            }
+            if (interaction.isStringSelectMenu()) {
+                if (!hasKimakiBotPermission(interaction.member, interaction.guild)) {
+                    await interaction.reply({
+                        content: `You don't have permission to use this.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
+                        flags: MessageFlags.Ephemeral,
+                    });
+                    return;
+                }
+                const customId = interaction.customId;
+                if (customId.startsWith('fork_select:')) {
+                    await handleForkSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('model_provider:')) {
+                    await handleProviderSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('model_select:')) {
+                    await handleModelSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('model_scope:')) {
+                    await handleModelScopeSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('model_variant:')) {
+                    await handleModelVariantSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('variant_quick:')) {
+                    await handleVariantQuickSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('variant_scope:')) {
+                    await handleVariantScopeSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('agent_select:')) {
+                    await handleAgentSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('verbosity_select:')) {
+                    await handleVerbositySelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('ask_question:')) {
+                    await handleAskQuestionSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('mcp_toggle:')) {
+                    await handleMcpSelectMenu(interaction);
+                    return;
+                }
+                if (customId.startsWith('login_select:')) {
+                    await handleLoginSelect(interaction);
+                    return;
+                }
+                return;
+            }
+            if (interaction.isModalSubmit()) {
+                if (!hasKimakiBotPermission(interaction.member, interaction.guild)) {
+                    await interaction.reply({
+                        content: `You don't have permission to use this.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
+                        flags: MessageFlags.Ephemeral,
+                    });
+                    return;
+                }
+                const customId = interaction.customId;
+                if (customId.startsWith('login_apikey:')) {
+                    await handleApiKeyModalSubmit(interaction);
+                    return;
+                }
+                if (customId.startsWith('login_text:')) {
+                    await handleLoginTextModalSubmit(interaction);
+                    return;
+                }
+                if (customId.startsWith('login_oauth_code:')) {
+                    await handleOAuthCodeModalSubmit(interaction);
+                    return;
+                }
+                if (customId.startsWith('transcription_apikey_modal:')) {
+                    await handleTranscriptionApiKeyModalSubmit(interaction);
+                    return;
+                }
+                if (customId.startsWith('file_upload_modal:')) {
+                    await handleFileUploadModalSubmit(interaction);
+                    return;
+                }
+                return;
+            }
+        }
+        catch (error) {
+            interactionLogger.error('[INTERACTION] Error handling interaction:', error);
+            void notifyError(error, 'Interaction handler error');
+            try {
+                if (interaction.isRepliable() &&
+                    !interaction.replied &&
+                    !interaction.deferred) {
+                    await interaction.reply({
+                        content: 'An error occurred processing this command.',
+                        flags: MessageFlags.Ephemeral,
+                    });
+                }
+            }
+            catch (replyError) {
+                interactionLogger.error('[INTERACTION] Failed to send error reply:', replyError);
+            }
+        }
+    });
+}

package/dist/ipc-polling.js

@@ -0,0 +1,252 @@
+// IPC polling bridge between the opencode plugin and the Discord bot.
+// The plugin inserts rows into ipc_requests (via Prisma). This module polls
+// that table, claims pending rows atomically, and dispatches them by type.
+// Replaces the old HTTP lock-server approach with DB-based IPC.
+import * as errore from 'errore';
+import { createTaggedError } from 'errore';
+import { claimPendingIpcRequests, completeIpcRequest, cancelAllPendingIpcRequests, cancelStaleProcessingRequests, } from './database.js';
+import { showFileUploadButton } from './commands/file-upload.js';
+import { queueActionButtonsRequest } from './commands/action-buttons.js';
+import { createLogger, LogPrefix } from './logger.js';
+import { notifyError } from './sentry.js';
+const ipcLogger = createLogger(LogPrefix.IPC);
+// ── Tagged errors ────────────────────────────────────────────────────────
+class IpcDispatchError extends createTaggedError({
+    name: 'IpcDispatchError',
+    message: 'IPC dispatch failed for request $requestId: $reason',
+}) {
+}
+// ── Button parsing ───────────────────────────────────────────────────────
+const VALID_COLORS = new Set([
+    'white',
+    'blue',
+    'green',
+    'red',
+]);
+function parseButtons(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const results = [];
+    for (const value of raw) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const label = (typeof value.label === 'string' ? value.label : '')
+            .trim()
+            .slice(0, 80);
+        if (!label)
+            continue;
+        const color = typeof value.color === 'string' &&
+            VALID_COLORS.has(value.color)
+            ? value.color
+            : undefined;
+        results.push({ label, color });
+        if (results.length >= 3)
+            break;
+    }
+    return results;
+}
+async function dispatchRequest({ req, discordClient, }) {
+    switch (req.type) {
+        case 'file_upload': {
+            const parsed = errore.try({
+                try: () => JSON.parse(req.payload),
+                catch: (e) => new IpcDispatchError({
+                    requestId: req.id,
+                    reason: 'Invalid payload JSON',
+                    cause: e,
+                }),
+            });
+            if (parsed instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: parsed.message }),
+                });
+                return parsed;
+            }
+            const thread = await discordClient.channels
+                .fetch(req.thread_id)
+                .catch((e) => new IpcDispatchError({
+                requestId: req.id,
+                reason: 'Thread fetch failed',
+                cause: e,
+            }));
+            if (thread instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: 'Thread not found' }),
+                });
+                return thread;
+            }
+            if (!thread?.isThread()) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: 'Thread not found' }),
+                });
+                return new IpcDispatchError({
+                    requestId: req.id,
+                    reason: 'Channel is not a thread',
+                });
+            }
+            // Fire-and-forget: showFileUploadButton waits for user interaction
+            // (button click + modal + file download) which can take minutes.
+            // Don't block the dispatch loop — complete the IPC request asynchronously.
+            showFileUploadButton({
+                thread,
+                sessionId: req.session_id,
+                directory: parsed.directory || '',
+                prompt: parsed.prompt || 'Please upload files',
+                maxFiles: Math.min(10, Math.max(1, parsed.maxFiles || 5)),
+            })
+                .then((filePaths) => {
+                return completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ filePaths }),
+                });
+            })
+                .catch((e) => {
+                ipcLogger.error('[IPC] File upload error:', e instanceof Error ? e.message : String(e));
+                return completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({
+                        error: e instanceof Error ? e.message : 'File upload failed',
+                    }),
+                });
+            })
+                .catch((e) => {
+                void notifyError(e, 'IPC file upload completion update failed');
+            });
+            return;
+        }
+        case 'action_buttons': {
+            const parsed = errore.try({
+                try: () => JSON.parse(req.payload),
+                catch: (e) => new IpcDispatchError({
+                    requestId: req.id,
+                    reason: 'Invalid payload JSON',
+                    cause: e,
+                }),
+            });
+            if (parsed instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: parsed.message }),
+                });
+                return parsed;
+            }
+            const buttons = parseButtons(parsed.buttons);
+            if (buttons.length === 0) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: 'No valid buttons' }),
+                });
+                return;
+            }
+            const thread = await discordClient.channels
+                .fetch(req.thread_id)
+                .catch((e) => new IpcDispatchError({
+                requestId: req.id,
+                reason: 'Thread fetch failed',
+                cause: e,
+            }));
+            if (thread instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: 'Thread not found' }),
+                });
+                return thread;
+            }
+            if (!thread?.isThread()) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: 'Thread not found' }),
+                });
+                return new IpcDispatchError({
+                    requestId: req.id,
+                    reason: 'Channel is not a thread',
+                });
+            }
+            queueActionButtonsRequest({
+                sessionId: req.session_id,
+                threadId: req.thread_id,
+                directory: parsed.directory || '',
+                buttons,
+            });
+            await completeIpcRequest({
+                id: req.id,
+                response: JSON.stringify({ ok: true }),
+            });
+            return;
+        }
+        default: {
+            await completeIpcRequest({
+                id: req.id,
+                response: JSON.stringify({ error: `Unknown IPC type: ${req.type}` }),
+            });
+            return;
+        }
+    }
+}
+// ── Polling lifecycle ────────────────────────────────────────────────────
+let pollingInterval = null;
+// Cancel requests stuck in 'processing' longer than 24 hours. Users often
+// come back the next day to click permission/question/file-upload buttons,
+// so we keep IPC rows alive for a full day. Checked every 30 seconds.
+const STALE_TTL_MS = 24 * 60 * 60 * 1000;
+const STALE_CHECK_INTERVAL_MS = 30 * 1000;
+let lastStaleCheck = 0;
+/**
+ * Start polling the ipc_requests table for pending requests from the plugin.
+ * Claims rows atomically (pending -> processing) to prevent duplicate dispatch.
+ * Uses an in-flight guard to prevent overlapping poll ticks.
+ */
+export async function startIpcPolling({ discordClient, }) {
+    // Clean up stale requests from previous runs before first poll tick
+    await cancelAllPendingIpcRequests().catch((e) => {
+        ipcLogger.warn('Failed to cancel stale IPC requests:', e.message);
+        void notifyError(e, 'Failed to cancel stale IPC requests');
+    });
+    let polling = false;
+    pollingInterval = setInterval(async () => {
+        if (polling)
+            return;
+        polling = true;
+        // Periodically sweep requests stuck in 'processing' past the TTL
+        const now = Date.now();
+        if (now - lastStaleCheck > STALE_CHECK_INTERVAL_MS) {
+            lastStaleCheck = now;
+            await cancelStaleProcessingRequests({ ttlMs: STALE_TTL_MS }).catch((e) => {
+                ipcLogger.warn('Stale sweep failed:', e.message);
+                void notifyError(e, 'IPC stale sweep failed');
+            });
+        }
+        const claimed = await claimPendingIpcRequests().catch((e) => new IpcDispatchError({
+            requestId: 'poll',
+            reason: 'Claim failed',
+            cause: e,
+        }));
+        if (claimed instanceof Error) {
+            ipcLogger.error('IPC claim failed:', claimed.message);
+            void notifyError(claimed, 'IPC claim failed');
+            polling = false;
+            return;
+        }
+        for (const req of claimed) {
+            const result = await dispatchRequest({ req, discordClient }).catch((e) => new IpcDispatchError({
+                requestId: req.id,
+                reason: 'Dispatch threw',
+                cause: e,
+            }));
+            if (result instanceof Error) {
+                ipcLogger.error(`IPC dispatch error for ${req.type}:`, result.message);
+                void notifyError(result, `IPC dispatch error for ${req.type}`);
+            }
+        }
+        polling = false;
+    }, 200);
+}
+export function stopIpcPolling() {
+    if (!pollingInterval)
+        return;
+    clearInterval(pollingInterval);
+    pollingInterval = null;
+}