remote-opencode 1.0.8 → 1.1.1

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

package/dist/src/services/dataStore.js

@@ -52,17 +52,34 @@ export function removeProject(alias) {
     saveData(data);
     return true;
 }
-export function setChannelBinding(channelId, projectAlias) {
+export function setChannelBinding(channelId, projectAlias, model) {
     const data = loadData();
     const existing = data.bindings.findIndex(b => b.channelId === channelId);
     if (existing >= 0) {
         data.bindings[existing].projectAlias = projectAlias;
+        if (model !== undefined) {
+            data.bindings[existing].model = model;
+        }
     }
     else {
-        data.bindings.push({ channelId, projectAlias });
+        data.bindings.push({ channelId, projectAlias, model });
     }
     saveData(data);
 }
+export function setChannelModel(channelId, model) {
+    const data = loadData();
+    const existing = data.bindings.findIndex(b => b.channelId === channelId);
+    if (existing >= 0) {
+        data.bindings[existing].model = model;
+        saveData(data);
+        return true;
+    }
+    return false;
+}
+export function getChannelModel(channelId) {
+    const binding = loadData().bindings.find(b => b.channelId === channelId);
+    return binding?.model;
+}
 export function getChannelBinding(channelId) {
     const binding = loadData().bindings.find(b => b.channelId === channelId);
     return binding?.projectAlias;
@@ -206,3 +223,50 @@ export function getProjectAutoWorktree(alias) {
     const project = getProject(alias);
     return project?.autoWorktree ?? false;
 }
+// Queue Management
+export function getQueue(threadId) {
+    const data = loadData();
+    return data.queues?.[threadId] ?? [];
+}
+export function addToQueue(threadId, message) {
+    const data = loadData();
+    if (!data.queues)
+        data.queues = {};
+    if (!data.queues[threadId])
+        data.queues[threadId] = [];
+    data.queues[threadId].push(message);
+    saveData(data);
+}
+export function popFromQueue(threadId) {
+    const data = loadData();
+    if (!data.queues?.[threadId] || data.queues[threadId].length === 0)
+        return undefined;
+    const message = data.queues[threadId].shift();
+    saveData(data);
+    return message;
+}
+export function clearQueue(threadId) {
+    const data = loadData();
+    if (data.queues?.[threadId]) {
+        delete data.queues[threadId];
+        saveData(data);
+    }
+}
+export function getQueueSettings(threadId) {
+    const data = loadData();
+    return data.queueSettings?.[threadId] ?? {
+        paused: false,
+        continueOnFailure: false,
+        freshContext: true
+    };
+}
+export function updateQueueSettings(threadId, settings) {
+    const data = loadData();
+    if (!data.queueSettings)
+        data.queueSettings = {};
+    data.queueSettings[threadId] = {
+        ...getQueueSettings(threadId),
+        ...settings
+    };
+    saveData(data);
+}

package/dist/src/services/executionService.js

@@ -0,0 +1,204 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder } from 'discord.js';
+import * as dataStore from './dataStore.js';
+import * as sessionManager from './sessionManager.js';
+import * as serveManager from './serveManager.js';
+import * as worktreeManager from './worktreeManager.js';
+import { SSEClient } from './sseClient.js';
+import { formatOutput, buildContextHeader } from '../utils/messageFormatter.js';
+import { processNextInQueue } from './queueManager.js';
+export async function runPrompt(channel, threadId, prompt, parentChannelId) {
+    const projectPath = dataStore.getChannelProjectPath(parentChannelId);
+    if (!projectPath) {
+        await channel.send('❌ No project bound to parent channel.');
+        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 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);
+            }
+        }
+    }
+    const effectivePath = worktreeMapping?.worktreePath ?? projectPath;
+    const preferredModel = dataStore.getChannelModel(parentChannelId);
+    const modelDisplay = preferredModel ? `${preferredModel}` : 'default';
+    const branchName = worktreeMapping?.branchName ?? await worktreeManager.getCurrentBranch(effectivePath) ?? 'main';
+    const contextHeader = buildContextHeader(branchName, modelDisplay);
+    const buttons = new ActionRowBuilder()
+        .addComponents(new ButtonBuilder()
+        .setCustomId(`interrupt_${threadId}`)
+        .setLabel('⏸️ Interrupt')
+        .setStyle(ButtonStyle.Secondary));
+    let streamMessage;
+    try {
+        streamMessage = await channel.send({
+            content: `${contextHeader}\n📌 **Prompt**: ${prompt}\n\n🚀 Starting OpenCode server...`,
+            components: [buttons]
+        });
+    }
+    catch {
+        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, preferredModel);
+        await updateStreamMessage(`${contextHeader}\n📌 **Prompt**: ${prompt}\n\n⏳ Waiting for OpenCode server...`, [buttons]);
+        await serveManager.waitForReady(port, 30000, effectivePath, preferredModel);
+        const settings = dataStore.getQueueSettings(threadId);
+        // If fresh context is enabled, we always clear the session before starting
+        if (settings.freshContext) {
+            sessionManager.clearSessionForThread(threadId);
+        }
+        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://127.0.0.1:${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(`${contextHeader}\n📌 **Prompt**: ${prompt}\n\n\`\`\`\n${formatted}\n\`\`\``, [disabledButtons]);
+                    await channel.send({ content: '✅ Done' });
+                    sseClient.disconnect();
+                    sessionManager.clearSseClient(threadId);
+                    // Trigger next in queue
+                    await processNextInQueue(channel, threadId, parentChannelId);
+                }
+                catch (error) {
+                    console.error('Error in onSessionIdle:', error);
+                }
+            })();
+        });
+        sseClient.onError((error) => {
+            if (updateInterval) {
+                clearInterval(updateInterval);
+                updateInterval = null;
+            }
+            (async () => {
+                try {
+                    await updateStreamMessage(`${contextHeader}\n📌 **Prompt**: ${prompt}\n\n❌ Connection error: ${error.message}`, []);
+                    sseClient.disconnect();
+                    sessionManager.clearSseClient(threadId);
+                    const settings = dataStore.getQueueSettings(threadId);
+                    if (settings.continueOnFailure) {
+                        await processNextInQueue(channel, threadId, parentChannelId);
+                    }
+                    else {
+                        dataStore.clearQueue(threadId);
+                        await channel.send('❌ Execution failed. Queue cleared. Use `/queue settings` to change this behavior.');
+                    }
+                }
+                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(`${contextHeader}\n📌 **Prompt**: ${prompt}\n\n${spinnerChar} **Running...**\n\`\`\`\n${newContent}\n\`\`\``, [buttons]);
+                }
+            }
+            catch {
+            }
+        }, 1000);
+        await updateStreamMessage(`${contextHeader}\n📌 **Prompt**: ${prompt}\n\n📝 Sending prompt...`, [buttons]);
+        await sessionManager.sendPrompt(port, sessionId, prompt, preferredModel);
+    }
+    catch (error) {
+        if (updateInterval) {
+            clearInterval(updateInterval);
+        }
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        await updateStreamMessage(`${contextHeader}\n📌 **Prompt**: ${prompt}\n\n❌ OpenCode execution failed: ${errorMessage}`, []);
+        const client = sessionManager.getSseClient(threadId);
+        if (client) {
+            client.disconnect();
+            sessionManager.clearSseClient(threadId);
+        }
+        const settings = dataStore.getQueueSettings(threadId);
+        if (settings.continueOnFailure) {
+            await processNextInQueue(channel, threadId, parentChannelId);
+        }
+        else {
+            dataStore.clearQueue(threadId);
+            await channel.send('❌ Execution failed. Queue cleared.');
+        }
+    }
+}

package/dist/src/services/queueManager.js

@@ -0,0 +1,20 @@
+import * as dataStore from './dataStore.js';
+import { runPrompt } from './executionService.js';
+import * as sessionManager from './sessionManager.js';
+export async function processNextInQueue(channel, threadId, parentChannelId) {
+    const settings = dataStore.getQueueSettings(threadId);
+    if (settings.paused)
+        return;
+    const next = dataStore.popFromQueue(threadId);
+    if (!next)
+        return;
+    // Visual indication that we are starting the next one
+    if ('send' in channel) {
+        await channel.send(`🔄 **Queue**: Starting next task...\n> ${next.prompt}`);
+    }
+    await runPrompt(channel, threadId, next.prompt, parentChannelId);
+}
+export function isBusy(threadId) {
+    const sseClient = sessionManager.getSseClient(threadId);
+    return !!(sseClient && sseClient.isConnected());
+}