remote-opencode 1.0.8 → 1.0.10

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,202 @@
+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 } 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 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... (Model: ${modelDisplay})`,
+            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(`📌 **Prompt**: ${prompt}\n\n⏳ Waiting for OpenCode server... (Model: ${modelDisplay})`, [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(`📌 **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(`📌 **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(`📌 **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, preferredModel);
+    }
+    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);
+        }
+        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());
+}

package/dist/src/services/serveManager.js

@@ -1,7 +1,8 @@
 import { spawn } from 'node:child_process';
 import { Server } from 'node:net';
-const PORT_MIN = 14097;
-const PORT_MAX = 14200;
+import { getPortConfig } from './configStore.js';
+const DEFAULT_PORT_MIN = 14097;
+const DEFAULT_PORT_MAX = 14200;
 const instances = new Map();
 function isPortAvailable(port) {
     return new Promise((resolve) => {
@@ -14,21 +15,45 @@ function isPortAvailable(port) {
                 resolve(true);
             });
         });
-        server.listen(port);
+        // Bind to 127.0.0.1 explicitly to match opencode serve's default binding
+        server.listen(port, '127.0.0.1');
     });
 }
+async function isOrphanedServerRunning(port) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/session`, {
+            signal: AbortSignal.timeout(1000),
+        });
+        // If we get any response, there's already a server running
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function findAvailablePort() {
-    for (let port = PORT_MIN; port <= PORT_MAX; port++) {
-        const usedPorts = new Set(Array.from(instances.values()).map(i => i.port));
-        if (!usedPorts.has(port) && await isPortAvailable(port)) {
+    const config = getPortConfig();
+    const min = config?.min ?? DEFAULT_PORT_MIN;
+    const max = config?.max ?? DEFAULT_PORT_MAX;
+    for (let port = min; port <= max; port++) {
+        const usedPorts = new Set(Array.from(instances.values()).filter(i => !i.exited).map(i => i.port));
+        if (usedPorts.has(port)) {
+            continue;
+        }
+        // Check if there's an orphaned opencode server on this port
+        if (await isOrphanedServerRunning(port)) {
+            continue;
+        }
+        // Check if we can bind to this port
+        if (await isPortAvailable(port)) {
             return port;
         }
     }
-    throw new Error(`No available ports in range ${PORT_MIN}-${PORT_MAX}`);
+    throw new Error(`No available ports in range ${min}-${max}`);
 }
 async function isServerResponding(port) {
     try {
-        const response = await fetch(`http://localhost:${port}/session`, {
+        const response = await fetch(`http://127.0.0.1:${port}/session`, {
             signal: AbortSignal.timeout(2000),
         });
         return response.ok;
@@ -37,58 +62,110 @@ async function isServerResponding(port) {
         return false;
     }
 }
-function cleanupInstance(projectPath) {
-    instances.delete(projectPath);
+function cleanupInstance(key) {
+    instances.delete(key);
 }
-export async function spawnServe(projectPath) {
-    const existing = instances.get(projectPath);
-    if (existing) {
+export async function spawnServe(projectPath, model) {
+    const key = model ? `${projectPath}:${model}` : projectPath;
+    const existing = instances.get(key);
+    if (existing && !existing.exited) {
         return existing.port;
     }
+    // Clean up any exited instance before spawning a new one
+    if (existing?.exited) {
+        cleanupInstance(key);
+    }
     const port = await findAvailablePort();
-    const child = spawn('opencode', ['serve', '--port', port.toString()], {
+    // Note: opencode serve doesn't support --model flag
+    // Model selection must happen at session/prompt level, not server startup
+    const args = ['serve', '--port', port.toString()];
+    console.log(`[opencode] Spawning: opencode ${args.join(' ')}`);
+    console.log(`[opencode] Working directory: ${projectPath}`);
+    const child = spawn('opencode', args, {
         cwd: projectPath,
         env: { ...process.env },
         stdio: ['inherit', 'pipe', 'pipe'],
+        shell: true,
     });
-    child.stdout?.on('data', () => { });
-    child.stderr?.on('data', () => { });
     const instance = {
         port,
         process: child,
         startTime: Date.now(),
+        exited: false,
     };
-    instances.set(projectPath, instance);
-    child.on('exit', async () => {
-        const inst = instances.get(projectPath);
+    instances.set(key, instance);
+    let stderrBuffer = '';
+    let stdoutBuffer = '';
+    child.stdout?.on('data', (data) => {
+        const text = data.toString();
+        stdoutBuffer += text;
+        if (stdoutBuffer.length > 2000) {
+            stdoutBuffer = stdoutBuffer.slice(-2000);
+        }
+        console.log(`[opencode stdout] ${text.trim()}`);
+    });
+    child.stderr?.on('data', (data) => {
+        const text = data.toString();
+        stderrBuffer += text;
+        if (stderrBuffer.length > 2000) {
+            stderrBuffer = stderrBuffer.slice(-2000);
+        }
+        console.error(`[opencode stderr] ${text.trim()}`);
+    });
+    child.on('exit', (code) => {
+        const inst = instances.get(key);
         if (inst) {
-            const stillRunning = await isServerResponding(inst.port);
-            if (!stillRunning) {
-                cleanupInstance(projectPath);
+            inst.exited = true;
+            inst.exitCode = code;
+            if (code !== 0 && code !== null) {
+                // Combine stdout and stderr for error message
+                const combinedOutput = (stderrBuffer.trim() || stdoutBuffer.trim());
+                inst.exitError = combinedOutput || `Process exited with code ${code}`;
+                console.error(`[opencode] Process exited with code ${code}`);
+                if (combinedOutput) {
+                    console.error(`[opencode] Output: ${combinedOutput}`);
+                }
             }
         }
     });
-    child.on('error', () => {
-        cleanupInstance(projectPath);
+    child.on('error', (error) => {
+        console.error(`[opencode] Spawn error: ${error.message}`);
+        const inst = instances.get(key);
+        if (inst) {
+            inst.exited = true;
+            inst.exitError = error.message || 'Failed to spawn opencode process';
+        }
     });
     return port;
 }
-export function getPort(projectPath) {
-    return instances.get(projectPath)?.port;
+export function getPort(projectPath, model) {
+    const key = model ? `${projectPath}:${model}` : projectPath;
+    return instances.get(key)?.port;
 }
-export function stopServe(projectPath) {
-    const instance = instances.get(projectPath);
+export function stopServe(projectPath, model) {
+    const key = model ? `${projectPath}:${model}` : projectPath;
+    const instance = instances.get(key);
     if (!instance) {
         return false;
     }
     instance.process.kill();
-    cleanupInstance(projectPath);
+    cleanupInstance(key);
     return true;
 }
-export async function waitForReady(port, timeout = 10000) {
+export async function waitForReady(port, timeout = 30000, projectPath, model) {
     const start = Date.now();
-    const url = `http://localhost:${port}/session`;
+    const url = `http://127.0.0.1:${port}/session`;
+    const key = projectPath ? (model ? `${projectPath}:${model}` : projectPath) : null;
     while (Date.now() - start < timeout) {
+        // Check if the process has exited early
+        if (key) {
+            const instance = instances.get(key);
+            if (instance?.exited) {
+                const errorMsg = instance.exitError || `opencode serve exited with code ${instance.exitCode}`;
+                cleanupInstance(key);
+                throw new Error(`opencode serve failed to start: ${errorMsg}`);
+            }
+        }
         try {
             const response = await fetch(url);
             if (response.ok) {
@@ -97,19 +174,39 @@ export async function waitForReady(port, timeout = 10000) {
         }
         catch {
         }
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    // Final check - did the process exit?
+    if (key) {
+        const instance = instances.get(key);
+        if (instance?.exited) {
+            const errorMsg = instance.exitError || `opencode serve exited with code ${instance.exitCode}`;
+            cleanupInstance(key);
+            throw new Error(`opencode serve failed to start: ${errorMsg}`);
+        }
     }
-    throw new Error(`Service at port ${port} failed to become ready within ${timeout}ms`);
+    throw new Error(`Service at port ${port} failed to become ready within ${timeout}ms. Check if 'opencode serve' is working correctly.`);
 }
 export function stopAll() {
-    for (const [projectPath, instance] of instances) {
+    for (const [key, instance] of instances) {
         instance.process.kill();
-        cleanupInstance(projectPath);
+        cleanupInstance(key);
     }
 }
 export function getAllInstances() {
-    return Array.from(instances.entries()).map(([projectPath, instance]) => ({
-        projectPath,
+    return Array.from(instances.entries()).map(([key, instance]) => ({
+        key,
         port: instance.port,
     }));
 }
+export function getInstanceState(projectPath, model) {
+    const key = model ? `${projectPath}:${model}` : projectPath;
+    const instance = instances.get(key);
+    if (!instance)
+        return undefined;
+    return {
+        exited: instance.exited ?? false,
+        exitCode: instance.exitCode,
+        exitError: instance.exitError,
+    };
+}

package/dist/src/services/sessionManager.js

@@ -1,7 +1,7 @@
 import * as dataStore from './dataStore.js';
 const threadSseClients = new Map();
 export async function createSession(port) {
-    const url = `http://localhost:${port}/session`;
+    const url = `http://127.0.0.1:${port}/session`;
     const response = await fetch(url, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -16,14 +16,31 @@ export async function createSession(port) {
     }
     return data.id;
 }
-export async function sendPrompt(port, sessionId, text) {
-    const url = `http://localhost:${port}/session/${sessionId}/prompt_async`;
+function parseModelString(model) {
+    const slashIndex = model.indexOf('/');
+    if (slashIndex === -1) {
+        return null;
+    }
+    return {
+        providerID: model.slice(0, slashIndex),
+        modelID: model.slice(slashIndex + 1),
+    };
+}
+export async function sendPrompt(port, sessionId, text, model) {
+    const url = `http://127.0.0.1:${port}/session/${sessionId}/prompt_async`;
+    const body = {
+        parts: [{ type: 'text', text }],
+    };
+    if (model) {
+        const parsedModel = parseModelString(model);
+        if (parsedModel) {
+            body.model = parsedModel;
+        }
+    }
     const response = await fetch(url, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            parts: [{ type: 'text', text }],
-        }),
+        body: JSON.stringify(body),
     });
     if (!response.ok) {
         throw new Error(`Failed to send prompt: ${response.status} ${response.statusText}`);
@@ -31,7 +48,7 @@ export async function sendPrompt(port, sessionId, text) {
 }
 export async function validateSession(port, sessionId) {
     try {
-        const url = `http://localhost:${port}/session/${sessionId}`;
+        const url = `http://127.0.0.1:${port}/session/${sessionId}`;
         const response = await fetch(url, {
             method: 'GET',
             headers: { 'Content-Type': 'application/json' },
@@ -44,7 +61,7 @@ export async function validateSession(port, sessionId) {
 }
 export async function listSessions(port) {
     try {
-        const url = `http://localhost:${port}/session`;
+        const url = `http://127.0.0.1:${port}/session`;
         const response = await fetch(url, {
             method: 'GET',
             headers: { 'Content-Type': 'application/json' },
@@ -64,7 +81,7 @@ export async function listSessions(port) {
 }
 export async function abortSession(port, sessionId) {
     try {
-        const url = `http://localhost:${port}/session/${sessionId}/abort`;
+        const url = `http://127.0.0.1:${port}/session/${sessionId}/abort`;
         const response = await fetch(url, {
             method: 'POST',
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-opencode",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Discord bot for remote OpenCode CLI access",
   "main": "dist/src/index.js",
   "bin": {
@@ -15,7 +15,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "start": "node dist/src/cli.js",
+    "start": "node --no-deprecation dist/src/cli.js start",
     "dev": "node --loader ts-node/esm src/cli.ts",
     "deploy-commands": "npm run build && node dist/src/cli.js deploy",
     "test": "vitest",