remote-opencode 1.0.8 → 1.1.1

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/dist/src/services/worktreeManager.js

@@ -67,6 +67,15 @@ export async function removeWorktree(worktreePath, deleteBranch) {
         throw new Error(`Failed to remove worktree: ${error.message}`);
     }
 }
+export async function getCurrentBranch(cwd) {
+    try {
+        const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
 export function worktreeExists(worktreePath) {
     return existsSync(worktreePath);
 }

package/dist/src/utils/messageFormatter.js

@@ -54,6 +54,9 @@ export function parseOpenCodeOutput(buffer) {
     }
     return result;
 }
+export function buildContextHeader(branchName, modelName) {
+    return `🌿 \`${branchName}\` · 🤖 \`${modelName}\``;
+}
 export function formatOutput(buffer, maxLength = 1900) {
     const parsed = parseOpenCodeOutput(buffer);
     if (!parsed.trim()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-opencode",
-  "version": "1.0.8",
+  "version": "1.1.1",
   "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",
@@ -42,6 +42,7 @@
     "eventsource": "^4.1.0",
     "node-pty": "^1.1.0",
     "open": "^10.1.0",
+    "opencode-antigravity-auth": "^1.4.6",
     "picocolors": "^1.1.1",
     "update-notifier": "^7.3.1"
   },