remote-opencode 1.0.8 → 1.0.10

package/dist/src/commands/opencode.js

@@ -1,11 +1,8 @@
-import { SlashCommandBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, MessageFlags, EmbedBuilder } from 'discord.js';
+import { SlashCommandBuilder, MessageFlags } from 'discord.js';
 import * as dataStore from '../services/dataStore.js';
-import * as sessionManager from '../services/sessionManager.js';
-import * as serveManager from '../services/serveManager.js';
-import * as worktreeManager from '../services/worktreeManager.js';
-import { SSEClient } from '../services/sseClient.js';
 import { getOrCreateThread } from '../utils/threadHelper.js';
-import { formatOutput } from '../utils/messageFormatter.js';
+import { runPrompt } from '../services/executionService.js';
+import { isBusy } from '../services/queueManager.js';
 function getParentChannelId(interaction) {
     const channel = interaction.channel;
     if (channel?.isThread()) {
@@ -49,50 +46,14 @@ export const opencode = {
             return;
         }
         const threadId = thread.id;
-        // Auto-create worktree if enabled and this is a new thread (not isInThread)
-        let worktreeMapping = dataStore.getWorktreeMapping(threadId);
-        if (!worktreeMapping && !isInThread) {
-            const projectAlias = dataStore.getChannelBinding(channelId);
-            if (projectAlias && dataStore.getProjectAutoWorktree(projectAlias)) {
-                try {
-                    const branchName = worktreeManager.sanitizeBranchName(`auto/${threadId.slice(0, 8)}-${Date.now()}`);
-                    const worktreePath = await worktreeManager.createWorktree(projectPath, branchName);
-                    const newMapping = {
-                        threadId,
-                        branchName,
-                        worktreePath,
-                        projectPath,
-                        description: prompt.slice(0, 50) + (prompt.length > 50 ? '...' : ''),
-                        createdAt: Date.now()
-                    };
-                    dataStore.setWorktreeMapping(newMapping);
-                    worktreeMapping = newMapping;
-                    const embed = new EmbedBuilder()
-                        .setTitle(`🌳 Auto-Worktree: ${branchName}`)
-                        .setDescription('Automatically created for this session')
-                        .addFields({ name: 'Branch', value: branchName, inline: true }, { name: 'Path', value: worktreePath, inline: true })
-                        .setColor(0x2ecc71);
-                    const worktreeButtons = new ActionRowBuilder()
-                        .addComponents(new ButtonBuilder()
-                        .setCustomId(`delete_${threadId}`)
-                        .setLabel('Delete')
-                        .setStyle(ButtonStyle.Danger), new ButtonBuilder()
-                        .setCustomId(`pr_${threadId}`)
-                        .setLabel('Create PR')
-                        .setStyle(ButtonStyle.Primary));
-                    await thread.send({ embeds: [embed], components: [worktreeButtons] });
-                }
-                catch (error) {
-                    console.error('Auto-worktree creation failed:', error);
-                    // Continue with main project path (graceful degradation)
-                }
-            }
-        }
-        const effectivePath = worktreeMapping?.worktreePath ?? projectPath;
-        const existingClient = sessionManager.getSseClient(threadId);
-        if (existingClient && existingClient.isConnected()) {
+        if (isBusy(threadId)) {
+            dataStore.addToQueue(threadId, {
+                prompt,
+                userId: interaction.user.id,
+                timestamp: Date.now()
+            });
             await interaction.reply({
-                content: '⚠️ Already running. Wait for completion or press [Interrupt].',
+                content: '📥 Prompt added to queue.',
                 flags: MessageFlags.Ephemeral
             });
             return;
@@ -100,128 +61,6 @@ export const opencode = {
         await interaction.reply({
             content: `📌 **Prompt**: ${prompt}`
         });
-        const buttons = new ActionRowBuilder()
-            .addComponents(new ButtonBuilder()
-            .setCustomId(`interrupt_${threadId}`)
-            .setLabel('⏸️ Interrupt')
-            .setStyle(ButtonStyle.Secondary));
-        let streamMessage;
-        try {
-            streamMessage = await thread.send({
-                content: '🚀 Starting OpenCode server...',
-                components: [buttons]
-            });
-        }
-        catch {
-            await interaction.editReply({
-                content: `📌 **Prompt**: ${prompt}\n\n❌ Cannot send message to thread.`
-            });
-            return;
-        }
-        let port;
-        let sessionId;
-        let updateInterval = null;
-        let accumulatedText = '';
-        let lastContent = '';
-        let tick = 0;
-        const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-        const updateStreamMessage = async (content, components) => {
-            try {
-                await streamMessage.edit({ content, components });
-            }
-            catch {
-            }
-        };
-        try {
-            port = await serveManager.spawnServe(effectivePath);
-            await updateStreamMessage('⏳ Waiting for OpenCode server...', [buttons]);
-            await serveManager.waitForReady(port);
-            const existingSession = sessionManager.getSessionForThread(threadId);
-            if (existingSession && existingSession.projectPath === effectivePath) {
-                const isValid = await sessionManager.validateSession(port, existingSession.sessionId);
-                if (isValid) {
-                    sessionId = existingSession.sessionId;
-                    sessionManager.updateSessionLastUsed(threadId);
-                }
-                else {
-                    sessionId = await sessionManager.createSession(port);
-                    sessionManager.setSessionForThread(threadId, sessionId, effectivePath, port);
-                }
-            }
-            else {
-                sessionId = await sessionManager.createSession(port);
-                sessionManager.setSessionForThread(threadId, sessionId, effectivePath, port);
-            }
-            const sseClient = new SSEClient();
-            sseClient.connect(`http://localhost:${port}`);
-            sessionManager.setSseClient(threadId, sseClient);
-            sseClient.onPartUpdated((part) => {
-                accumulatedText = part.text;
-            });
-            sseClient.onSessionIdle(() => {
-                if (updateInterval) {
-                    clearInterval(updateInterval);
-                    updateInterval = null;
-                }
-                (async () => {
-                    try {
-                        const formatted = formatOutput(accumulatedText);
-                        const disabledButtons = new ActionRowBuilder()
-                            .addComponents(new ButtonBuilder()
-                            .setCustomId(`interrupt_${threadId}`)
-                            .setLabel('⏸️ Interrupt')
-                            .setStyle(ButtonStyle.Secondary)
-                            .setDisabled(true));
-                        await updateStreamMessage(`\`\`\`\n${formatted}\n\`\`\``, [disabledButtons]);
-                        await thread.send({ content: '✅ Done' });
-                        sseClient.disconnect();
-                        sessionManager.clearSseClient(threadId);
-                    }
-                    catch {
-                    }
-                })();
-            });
-            sseClient.onError((error) => {
-                if (updateInterval) {
-                    clearInterval(updateInterval);
-                    updateInterval = null;
-                }
-                (async () => {
-                    try {
-                        await updateStreamMessage(`❌ Connection error: ${error.message}`, []);
-                    }
-                    catch {
-                    }
-                })();
-            });
-            updateInterval = setInterval(async () => {
-                tick++;
-                try {
-                    const formatted = formatOutput(accumulatedText);
-                    const spinnerChar = spinner[tick % spinner.length];
-                    const newContent = formatted || 'Processing...';
-                    if (newContent !== lastContent || tick % 2 === 0) {
-                        lastContent = newContent;
-                        await updateStreamMessage(`${spinnerChar} **Running...**\n\`\`\`\n${newContent}\n\`\`\``, [buttons]);
-                    }
-                }
-                catch {
-                }
-            }, 1000);
-            await updateStreamMessage('📝 Sending prompt...', [buttons]);
-            await sessionManager.sendPrompt(port, sessionId, prompt);
-        }
-        catch (error) {
-            if (updateInterval) {
-                clearInterval(updateInterval);
-            }
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            await updateStreamMessage(`❌ OpenCode execution failed: ${errorMessage}`, []);
-            const client = sessionManager.getSseClient(threadId);
-            if (client) {
-                client.disconnect();
-                sessionManager.clearSseClient(threadId);
-            }
-        }
+        await runPrompt(thread, threadId, prompt, channelId);
     }
 };

package/dist/src/commands/queue.js

@@ -0,0 +1,85 @@
+import { SlashCommandBuilder, MessageFlags } from 'discord.js';
+import * as dataStore from '../services/dataStore.js';
+import { processNextInQueue } from '../services/queueManager.js';
+export const queue = {
+    data: new SlashCommandBuilder()
+        .setName('queue')
+        .setDescription('Manage the job queue for this thread')
+        .addSubcommand(sub => sub.setName('list')
+        .setDescription('List all pending prompts in the queue'))
+        .addSubcommand(sub => sub.setName('clear')
+        .setDescription('Clear all pending prompts in the queue'))
+        .addSubcommand(sub => sub.setName('pause')
+        .setDescription('Pause the queue (current job will finish)'))
+        .addSubcommand(sub => sub.setName('resume')
+        .setDescription('Resume the queue and start next task if idle'))
+        .addSubcommand(sub => sub.setName('settings')
+        .setDescription('Configure queue behavior')
+        .addBooleanOption(opt => opt.setName('continue_on_failure')
+        .setDescription('Whether to continue to next task if current one fails'))
+        .addBooleanOption(opt => opt.setName('fresh_context')
+        .setDescription('Whether to clear AI conversation context between tasks'))),
+    async execute(interaction) {
+        const thread = interaction.channel;
+        if (!thread?.isThread()) {
+            await interaction.reply({
+                content: '❌ This command can only be used in a thread.',
+                flags: MessageFlags.Ephemeral
+            });
+            return;
+        }
+        const threadId = thread.id;
+        const subcommand = interaction.options.getSubcommand();
+        if (subcommand === 'list') {
+            const q = dataStore.getQueue(threadId);
+            if (q.length === 0) {
+                await interaction.reply({ content: '📭 The queue is empty.', flags: MessageFlags.Ephemeral });
+                return;
+            }
+            const list = q.map((m, i) => `${i + 1}. ${m.prompt.slice(0, 100)}${m.prompt.length > 100 ? '...' : ''}`).join('\n');
+            const settings = dataStore.getQueueSettings(threadId);
+            const status = settings.paused ? '⏸️ Paused' : '▶️ Running';
+            await interaction.reply({
+                content: `📋 **Queue Status**: ${status}\n\n**Pending Tasks**:\n${list}`,
+                flags: MessageFlags.Ephemeral
+            });
+        }
+        else if (subcommand === 'clear') {
+            dataStore.clearQueue(threadId);
+            await interaction.reply({ content: '🗑️ Queue cleared.', flags: MessageFlags.Ephemeral });
+        }
+        else if (subcommand === 'pause') {
+            dataStore.updateQueueSettings(threadId, { paused: true });
+            await interaction.reply({ content: '⏸️ Queue paused. Current job will finish, but next one won\'t start automatically.', flags: MessageFlags.Ephemeral });
+        }
+        else if (subcommand === 'resume') {
+            dataStore.updateQueueSettings(threadId, { paused: false });
+            await interaction.reply({ content: '▶️ Queue resumed.', flags: MessageFlags.Ephemeral });
+            // Try to trigger next if idle
+            const parentChannelId = thread.parentId;
+            if (parentChannelId) {
+                const sseClient = (await import('../services/sessionManager.js')).getSseClient(threadId);
+                if (!sseClient || !sseClient.isConnected()) {
+                    await processNextInQueue(thread, threadId, parentChannelId);
+                }
+            }
+        }
+        else if (subcommand === 'settings') {
+            const continueOnFailure = interaction.options.getBoolean('continue_on_failure');
+            const freshContext = interaction.options.getBoolean('fresh_context');
+            const updates = {};
+            if (continueOnFailure !== null)
+                updates.continueOnFailure = continueOnFailure;
+            if (freshContext !== null)
+                updates.freshContext = freshContext;
+            if (Object.keys(updates).length > 0) {
+                dataStore.updateQueueSettings(threadId, updates);
+            }
+            const settings = dataStore.getQueueSettings(threadId);
+            await interaction.reply({
+                content: `⚙️ **Queue Settings Updated**:\n- Continue on failure: \`${settings.continueOnFailure}\`\n- Fresh context: \`${settings.freshContext}\``,
+                flags: MessageFlags.Ephemeral
+            });
+        }
+    }
+};

package/dist/src/commands/setports.js

@@ -0,0 +1,33 @@
+import { SlashCommandBuilder } from 'discord.js';
+import { setPortConfig } from '../services/configStore.js';
+export const setports = {
+    data: new SlashCommandBuilder()
+        .setName('setports')
+        .setDescription('Configure the port range for OpenCode server instances')
+        .addIntegerOption(option => option.setName('min')
+        .setDescription('Minimum port number')
+        .setRequired(true))
+        .addIntegerOption(option => option.setName('max')
+        .setDescription('Maximum port number')
+        .setRequired(true)),
+    async execute(interaction) {
+        const min = interaction.options.getInteger('min', true);
+        const max = interaction.options.getInteger('max', true);
+        if (min >= max) {
+            await interaction.reply({
+                content: '❌ Minimum port must be less than maximum port.',
+                ephemeral: true
+            });
+            return;
+        }
+        if (min < 1024 || max > 65535) {
+            await interaction.reply({
+                content: '❌ Ports must be between 1024 and 65535.',
+                ephemeral: true
+            });
+            return;
+        }
+        setPortConfig({ min, max });
+        await interaction.reply(`✅ Port range updated: ${min}-${max}`);
+    }
+};

package/dist/src/handlers/buttonHandler.js

@@ -1,3 +1,4 @@
+import { MessageFlags } from 'discord.js';
 import * as sessionManager from '../services/sessionManager.js';
 import * as serveManager from '../services/serveManager.js';
 import * as dataStore from '../services/dataStore.js';
@@ -8,7 +9,7 @@ export async function handleButton(interaction) {
     if (!threadId) {
         await interaction.reply({
             content: '❌ Invalid button.',
-            ephemeral: true
+            flags: MessageFlags.Ephemeral
         });
         return;
     }
@@ -24,7 +25,7 @@ export async function handleButton(interaction) {
     else {
         await interaction.reply({
             content: '❌ Unknown action.',
-            ephemeral: true
+            flags: MessageFlags.Ephemeral
         });
     }
 }
@@ -33,19 +34,22 @@ async function handleInterrupt(interaction, threadId) {
     if (!session) {
         await interaction.reply({
             content: '⚠️ Session not found.',
-            ephemeral: true
+            flags: MessageFlags.Ephemeral
         });
         return;
     }
-    const port = serveManager.getPort(session.projectPath);
+    const channel = interaction.channel;
+    const parentChannelId = channel?.isThread() ? channel.parentId : channel?.id;
+    const preferredModel = parentChannelId ? dataStore.getChannelModel(parentChannelId) : undefined;
+    const port = serveManager.getPort(session.projectPath, preferredModel);
     if (!port) {
         await interaction.reply({
             content: '⚠️ Server is not running.',
-            ephemeral: true
+            flags: MessageFlags.Ephemeral
         });
         return;
     }
-    await interaction.deferReply({ ephemeral: true });
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
     const success = await sessionManager.abortSession(port, session.sessionId);
     if (success) {
         await interaction.editReply({ content: '⏸️ Interrupt request sent.' });
@@ -57,10 +61,10 @@ async function handleInterrupt(interaction, threadId) {
 async function handleWorktreeDelete(interaction, threadId) {
     const mapping = dataStore.getWorktreeMapping(threadId);
     if (!mapping) {
-        await interaction.reply({ content: '⚠️ Worktree mapping not found.', ephemeral: true });
+        await interaction.reply({ content: '⚠️ Worktree mapping not found.', flags: MessageFlags.Ephemeral });
         return;
     }
-    await interaction.deferReply({ ephemeral: true });
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
     try {
         if (worktreeManager.worktreeExists(mapping.worktreePath)) {
             await worktreeManager.removeWorktree(mapping.worktreePath, false);
@@ -79,13 +83,16 @@ async function handleWorktreeDelete(interaction, threadId) {
 async function handleWorktreePR(interaction, threadId) {
     const mapping = dataStore.getWorktreeMapping(threadId);
     if (!mapping) {
-        await interaction.reply({ content: '⚠️ Worktree mapping not found.', ephemeral: true });
+        await interaction.reply({ content: '⚠️ Worktree mapping not found.', flags: MessageFlags.Ephemeral });
         return;
     }
-    await interaction.deferReply({ ephemeral: true });
+    const channel = interaction.channel;
+    const parentChannelId = channel?.isThread() ? channel.parentId : channel?.id;
+    const preferredModel = parentChannelId ? dataStore.getChannelModel(parentChannelId) : undefined;
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
     try {
-        const port = await serveManager.spawnServe(mapping.worktreePath);
-        await serveManager.waitForReady(port);
+        const port = await serveManager.spawnServe(mapping.worktreePath, preferredModel);
+        await serveManager.waitForReady(port, 30000, mapping.worktreePath, preferredModel);
         let sessionId;
         const existingSession = sessionManager.getSessionForThread(threadId);
         if (existingSession) {
@@ -97,7 +104,7 @@ async function handleWorktreePR(interaction, threadId) {
         }
         sessionManager.setSessionForThread(threadId, sessionId, mapping.worktreePath, port);
         const prPrompt = `Create a pull request for the current branch. Include a clear title and description summarizing all changes.`;
-        await sessionManager.sendPrompt(port, sessionId, prPrompt);
+        await sessionManager.sendPrompt(port, sessionId, prPrompt, preferredModel);
         await interaction.editReply({ content: '🚀 PR creation started! Check the thread for progress.' });
     }
     catch (error) {

package/dist/src/handlers/interactionHandler.js

@@ -1,8 +1,14 @@
+import { MessageFlags } from 'discord.js';
 import { commands } from '../commands/index.js';
 import { handleButton } from './buttonHandler.js';
 export async function handleInteraction(interaction) {
     if (interaction.isButton()) {
-        await handleButton(interaction);
+        try {
+            await handleButton(interaction);
+        }
+        catch (error) {
+            console.error('Error handling button:', error);
+        }
         return;
     }
     if (!interaction.isChatInputCommand())
@@ -15,12 +21,18 @@ export async function handleInteraction(interaction) {
         await command.execute(interaction);
     }
     catch (error) {
+        console.error(`Error executing command ${interaction.commandName}:`, error);
         const content = '❌ An error occurred while executing the command.';
-        if (interaction.replied || interaction.deferred) {
-            await interaction.followUp({ content, ephemeral: true });
+        try {
+            if (interaction.replied || interaction.deferred) {
+                await interaction.followUp({ content, flags: MessageFlags.Ephemeral });
+            }
+            else {
+                await interaction.reply({ content, flags: MessageFlags.Ephemeral });
+            }
         }
-        else {
-            await interaction.reply({ content, ephemeral: true });
+        catch (replyError) {
+            console.error('Failed to send error response to user:', replyError);
         }
     }
 }

package/dist/src/handlers/messageHandler.js

@@ -1,10 +1,6 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder } from 'discord.js';
 import * as dataStore from '../services/dataStore.js';
-import * as sessionManager from '../services/sessionManager.js';
-import * as serveManager from '../services/serveManager.js';
-import * as worktreeManager from '../services/worktreeManager.js';
-import { SSEClient } from '../services/sseClient.js';
-import { formatOutput } from '../utils/messageFormatter.js';
+import { runPrompt } from '../services/executionService.js';
+import { isBusy } from '../services/queueManager.js';
 export async function handleMessageCreate(message) {
     if (message.author.bot)
         return;
@@ -19,178 +15,17 @@ export async function handleMessageCreate(message) {
     const parentChannelId = channel.parentId;
     if (!parentChannelId)
         return;
-    const projectPath = dataStore.getChannelProjectPath(parentChannelId);
-    if (!projectPath) {
-        await message.reply('❌ No project bound to parent channel. Disable passthrough and use `/use` first.');
-        return;
-    }
-    let worktreeMapping = dataStore.getWorktreeMapping(threadId);
-    // Auto-create worktree if enabled and no mapping exists for this thread
-    if (!worktreeMapping) {
-        const projectAlias = dataStore.getChannelBinding(parentChannelId);
-        if (projectAlias && dataStore.getProjectAutoWorktree(projectAlias)) {
-            try {
-                const branchName = worktreeManager.sanitizeBranchName(`auto/${threadId.slice(0, 8)}-${Date.now()}`);
-                const worktreePath = await worktreeManager.createWorktree(projectPath, branchName);
-                const prompt = message.content.trim();
-                const newMapping = {
-                    threadId,
-                    branchName,
-                    worktreePath,
-                    projectPath,
-                    description: prompt.slice(0, 50) + (prompt.length > 50 ? '...' : ''),
-                    createdAt: Date.now()
-                };
-                dataStore.setWorktreeMapping(newMapping);
-                worktreeMapping = newMapping;
-                const embed = new EmbedBuilder()
-                    .setTitle(`🌳 Auto-Worktree: ${branchName}`)
-                    .setDescription('Automatically created for this session')
-                    .addFields({ name: 'Branch', value: branchName, inline: true }, { name: 'Path', value: worktreePath, inline: true })
-                    .setColor(0x2ecc71);
-                const worktreeButtons = new ActionRowBuilder()
-                    .addComponents(new ButtonBuilder()
-                    .setCustomId(`delete_${threadId}`)
-                    .setLabel('Delete')
-                    .setStyle(ButtonStyle.Danger), new ButtonBuilder()
-                    .setCustomId(`pr_${threadId}`)
-                    .setLabel('Create PR')
-                    .setStyle(ButtonStyle.Primary));
-                await channel.send({ embeds: [embed], components: [worktreeButtons] });
-            }
-            catch (error) {
-                console.error('Auto-worktree creation failed:', error);
-                // Continue with main project path (graceful degradation)
-            }
-        }
-    }
-    const effectivePath = worktreeMapping?.worktreePath ?? projectPath;
-    const existingClient = sessionManager.getSseClient(threadId);
-    if (existingClient && existingClient.isConnected()) {
-        await message.react('⏳');
-        return;
-    }
     const prompt = message.content.trim();
     if (!prompt)
         return;
-    const buttons = new ActionRowBuilder()
-        .addComponents(new ButtonBuilder()
-        .setCustomId(`interrupt_${threadId}`)
-        .setLabel('⏸️ Interrupt')
-        .setStyle(ButtonStyle.Secondary));
-    let streamMessage;
-    try {
-        streamMessage = await channel.send({
-            content: `📌 **Prompt**: ${prompt}\n\n🚀 Starting OpenCode server...`,
-            components: [buttons]
+    if (isBusy(threadId)) {
+        dataStore.addToQueue(threadId, {
+            prompt,
+            userId: message.author.id,
+            timestamp: Date.now()
         });
-    }
-    catch {
+        await message.react('📥');
         return;
     }
-    let port;
-    let sessionId;
-    let updateInterval = null;
-    let accumulatedText = '';
-    let lastContent = '';
-    let tick = 0;
-    const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    const updateStreamMessage = async (content, components) => {
-        try {
-            await streamMessage.edit({ content, components });
-        }
-        catch {
-        }
-    };
-    try {
-        port = await serveManager.spawnServe(effectivePath);
-        await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n⏳ Waiting for OpenCode server...`, [buttons]);
-        await serveManager.waitForReady(port);
-        const existingSession = sessionManager.getSessionForThread(threadId);
-        if (existingSession && existingSession.projectPath === effectivePath) {
-            const isValid = await sessionManager.validateSession(port, existingSession.sessionId);
-            if (isValid) {
-                sessionId = existingSession.sessionId;
-                sessionManager.updateSessionLastUsed(threadId);
-            }
-            else {
-                sessionId = await sessionManager.createSession(port);
-                sessionManager.setSessionForThread(threadId, sessionId, effectivePath, port);
-            }
-        }
-        else {
-            sessionId = await sessionManager.createSession(port);
-            sessionManager.setSessionForThread(threadId, sessionId, effectivePath, port);
-        }
-        const sseClient = new SSEClient();
-        sseClient.connect(`http://localhost:${port}`);
-        sessionManager.setSseClient(threadId, sseClient);
-        sseClient.onPartUpdated((part) => {
-            accumulatedText = part.text;
-        });
-        sseClient.onSessionIdle(() => {
-            if (updateInterval) {
-                clearInterval(updateInterval);
-                updateInterval = null;
-            }
-            (async () => {
-                try {
-                    const formatted = formatOutput(accumulatedText);
-                    const disabledButtons = new ActionRowBuilder()
-                        .addComponents(new ButtonBuilder()
-                        .setCustomId(`interrupt_${threadId}`)
-                        .setLabel('⏸️ Interrupt')
-                        .setStyle(ButtonStyle.Secondary)
-                        .setDisabled(true));
-                    await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n\`\`\`\n${formatted}\n\`\`\``, [disabledButtons]);
-                    await channel.send({ content: '✅ Done' });
-                    sseClient.disconnect();
-                    sessionManager.clearSseClient(threadId);
-                }
-                catch {
-                }
-            })();
-        });
-        sseClient.onError((error) => {
-            if (updateInterval) {
-                clearInterval(updateInterval);
-                updateInterval = null;
-            }
-            (async () => {
-                try {
-                    await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n❌ Connection error: ${error.message}`, []);
-                }
-                catch {
-                }
-            })();
-        });
-        updateInterval = setInterval(async () => {
-            tick++;
-            try {
-                const formatted = formatOutput(accumulatedText);
-                const spinnerChar = spinner[tick % spinner.length];
-                const newContent = formatted || 'Processing...';
-                if (newContent !== lastContent || tick % 2 === 0) {
-                    lastContent = newContent;
-                    await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n${spinnerChar} **Running...**\n\`\`\`\n${newContent}\n\`\`\``, [buttons]);
-                }
-            }
-            catch {
-            }
-        }, 1000);
-        await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n📝 Sending prompt...`, [buttons]);
-        await sessionManager.sendPrompt(port, sessionId, prompt);
-    }
-    catch (error) {
-        if (updateInterval) {
-            clearInterval(updateInterval);
-        }
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        await updateStreamMessage(`📌 **Prompt**: ${prompt}\n\n❌ OpenCode execution failed: ${errorMessage}`, []);
-        const client = sessionManager.getSseClient(threadId);
-        if (client) {
-            client.disconnect();
-            sessionManager.clearSseClient(threadId);
-        }
-    }
+    await runPrompt(channel, threadId, prompt, parentChannelId);
 }

package/dist/src/services/configStore.js

@@ -36,6 +36,14 @@ export function setBotConfig(bot) {
     config.bot = bot;
     saveConfig(config);
 }
+export function getPortConfig() {
+    return loadConfig().ports;
+}
+export function setPortConfig(ports) {
+    const config = loadConfig();
+    config.ports = ports;
+    saveConfig(config);
+}
 export function hasBotConfig() {
     const bot = getBotConfig();
     return !!(bot?.discordToken && bot?.clientId && bot?.guildId);