tide-commander 1.153.0 → 1.155.0

package/dist/src/packages/server/opencode/server/opencode-server-process.js

@@ -0,0 +1,285 @@
+/**
+ * OpencodeServerProcess
+ *
+ * Manages a DETACHED, restart-surviving `opencode serve` HTTP server and speaks
+ * its API: one SSE stream (`GET /event`) carries every session's events
+ * (word-by-word `message.part.delta`), and prompts/sessions/aborts go over plain
+ * HTTP. One server multiplexes every OpenCode agent — each agent owns a
+ * `sessionID`, and every event carries `properties.sessionID` so the runner can
+ * fan them back out.
+ *
+ * Why detached + HTTP/SSE (vs `opencode run` per turn): `opencode run --format
+ * json` emits one full assistant message (no token deltas), and a child process
+ * dies with the commander. A detached server bound to a localhost port survives
+ * commander restarts and keeps running any in-flight turn; on restart the runner
+ * reconnects the SSE stream and OpenCode's persisted sessions resume seamlessly.
+ */
+import { spawn } from 'child_process';
+import * as http from 'http';
+import * as net from 'net';
+import * as fs from 'fs';
+import { createLogger } from '../../utils/logger.js';
+import { loadDaemonInfo, saveDaemonInfo, clearDaemonInfo, OPENCODE_SERVER_LOG_FILE, } from './opencode-server-recovery-store.js';
+const log = createLogger('OpencodeServer');
+const HEALTH_TIMEOUT_MS = 25000;
+const HEALTH_POLL_MS = 300;
+const SSE_RECONNECT_MS = 1000;
+export class OpencodeServerProcess {
+    opts;
+    port = null;
+    sseReq = null;
+    stopped = false;
+    connected = false;
+    reconnectedToExisting = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    isAlive() {
+        return this.connected && !this.stopped;
+    }
+    didReconnect() {
+        return this.reconnectedToExisting;
+    }
+    get baseUrl() {
+        return `http://127.0.0.1:${this.port}`;
+    }
+    async ensureStarted() {
+        if (this.connected)
+            return;
+        this.stopped = false;
+        // 1. Rejoin an already-running daemon if healthy.
+        const existing = loadDaemonInfo();
+        if (existing && isPidAlive(existing.pid) && (await probeHealth(existing.port, 1500))) {
+            log.log(`🔗 Rejoining existing opencode server pid=${existing.pid} port=${existing.port}`);
+            this.port = existing.port;
+            this.reconnectedToExisting = true;
+            this.openSse();
+            this.connected = true;
+            return;
+        }
+        // 2. Spawn a fresh detached daemon.
+        this.reconnectedToExisting = false;
+        const port = await findFreePort();
+        const pid = this.spawnDaemon(port);
+        saveDaemonInfo({ port, pid, startedAt: Date.now() });
+        this.port = port;
+        await this.waitForHealth(port);
+        this.openSse();
+        this.connected = true;
+    }
+    spawnDaemon(port) {
+        const { executablePath, cwd, extraEnv } = this.opts;
+        const logFd = (() => {
+            try {
+                return fs.openSync(OPENCODE_SERVER_LOG_FILE, 'a');
+            }
+            catch {
+                return 'ignore';
+            }
+        })();
+        log.log(`🚀 Spawning detached opencode server: ${executablePath} serve --port ${port}`);
+        const child = spawn(executablePath, ['serve', '--port', String(port), '--hostname', '127.0.0.1'], {
+            cwd,
+            env: { ...process.env, ...extraEnv },
+            detached: true,
+            stdio: ['ignore', logFd, logFd],
+        });
+        child.unref();
+        child.on('error', (err) => log.error(`opencode serve spawn error: ${err.message}`));
+        return child.pid ?? -1;
+    }
+    async waitForHealth(port) {
+        const deadline = Date.now() + HEALTH_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (await probeHealth(port, 1000))
+                return;
+            await sleep(HEALTH_POLL_MS);
+        }
+        throw new Error('opencode server /api/health never became healthy');
+    }
+    /** Open the single global SSE stream and parse `data:` frames. */
+    openSse() {
+        if (this.stopped)
+            return;
+        const req = http.get(`${this.baseUrl}/event`, { headers: { Accept: 'text/event-stream' } }, (res) => {
+            res.setEncoding('utf8');
+            let buffer = '';
+            res.on('data', (chunk) => {
+                buffer += chunk;
+                // SSE frames are separated by a blank line.
+                let idx;
+                while ((idx = buffer.indexOf('\n\n')) >= 0) {
+                    const frame = buffer.slice(0, idx);
+                    buffer = buffer.slice(idx + 2);
+                    this.handleFrame(frame);
+                }
+            });
+            res.on('end', () => this.handleSseClosed());
+        });
+        this.sseReq = req;
+        req.on('error', (err) => {
+            log.warn(`SSE connection error: ${err.message}`);
+            this.handleSseClosed();
+        });
+    }
+    handleFrame(frame) {
+        // A frame is one or more lines; take the `data:` payload(s).
+        const dataLines = frame
+            .split('\n')
+            .filter((l) => l.startsWith('data:'))
+            .map((l) => l.slice(5).trim());
+        if (dataLines.length === 0)
+            return;
+        const payload = dataLines.join('\n');
+        if (!payload)
+            return;
+        let evt;
+        try {
+            evt = JSON.parse(payload);
+        }
+        catch {
+            return;
+        }
+        this.opts.onEvent(evt);
+    }
+    handleSseClosed() {
+        this.sseReq = null;
+        if (this.stopped)
+            return;
+        // Try to re-establish once; if the server is truly gone, give up and notify.
+        log.warn('SSE stream closed; attempting to reconnect');
+        setTimeout(async () => {
+            if (this.stopped || !this.port)
+                return;
+            if (await probeHealth(this.port, 1500)) {
+                this.openSse();
+            }
+            else {
+                this.connected = false;
+                this.opts.onDisconnect();
+            }
+        }, SSE_RECONNECT_MS);
+    }
+    // ---- HTTP helpers --------------------------------------------------------
+    async httpJson(method, path, body) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: body !== undefined ? { 'Content-Type': 'application/json' } : undefined,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            throw new Error(`${method} ${path} → ${res.status} ${res.statusText}`);
+        }
+        const text = await res.text();
+        return text ? JSON.parse(text) : null;
+    }
+    /** Create a session (optionally scoped to a working directory). */
+    async createSession(directory) {
+        const body = {};
+        if (directory)
+            body.location = { directory };
+        const resp = await this.httpJson('POST', '/api/session', body);
+        const id = resp?.data?.id ?? resp?.id;
+        if (!id)
+            throw new Error('opencode session create returned no id');
+        return id;
+    }
+    /** Send a prompt to a session. Fire-and-forget: streaming arrives via SSE. */
+    sendPrompt(sessionId, text, model) {
+        const body = { parts: [{ type: 'text', text }] };
+        if (model)
+            body.model = model;
+        return this.httpJson('POST', `/session/${sessionId}/message`, body).then(() => undefined);
+    }
+    async abort(sessionId) {
+        try {
+            await this.httpJson('POST', `/session/${sessionId}/abort`, {});
+        }
+        catch { /* best-effort */ }
+    }
+    /** Session IDs currently generating (busy), used to detect turns still in flight. */
+    async activeSessionIds() {
+        try {
+            const resp = await this.httpJson('GET', '/api/session/active');
+            const list = (resp?.data ?? resp);
+            const ids = new Set();
+            if (Array.isArray(list)) {
+                for (const item of list) {
+                    if (typeof item === 'string')
+                        ids.add(item);
+                    else if (item?.id)
+                        ids.add(item.id);
+                    else if (item?.sessionID)
+                        ids.add(item.sessionID);
+                }
+            }
+            return ids;
+        }
+        catch {
+            return new Set();
+        }
+    }
+    /** Disconnect our client but LEAVE the daemon running (survives restart). */
+    disconnect() {
+        this.stopped = true;
+        this.connected = false;
+        if (this.sseReq) {
+            try {
+                this.sseReq.destroy();
+            }
+            catch { /* ignore */ }
+            this.sseReq = null;
+        }
+    }
+    /** Disconnect AND kill the daemon (used on explicit full shutdown). */
+    killDaemon() {
+        this.disconnect();
+        const info = loadDaemonInfo();
+        if (info && isPidAlive(info.pid)) {
+            try {
+                process.kill(info.pid, 'SIGTERM');
+            }
+            catch { /* ignore */ }
+        }
+        clearDaemonInfo();
+    }
+}
+function isPidAlive(pid) {
+    if (!pid || pid < 1)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function probeHealth(port, timeoutMs) {
+    return new Promise((resolve) => {
+        const req = http.get({ host: '127.0.0.1', port, path: '/api/health', timeout: timeoutMs }, (res) => {
+            res.resume();
+            resolve(res.statusCode === 200);
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.unref();
+        srv.on('error', reject);
+        srv.listen(0, '127.0.0.1', () => {
+            const addr = srv.address();
+            const port = typeof addr === 'object' && addr ? addr.port : 0;
+            srv.close(() => (port ? resolve(port) : reject(new Error('could not allocate a free port'))));
+        });
+    });
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/src/packages/server/opencode/server/opencode-server-recovery-store.js

@@ -0,0 +1,73 @@
+/**
+ * Persistence for the restart-surviving OpenCode `serve` daemon.
+ *
+ * Mirrors the Codex app-server recovery store. Persists, in a dedicated file:
+ *  1. Daemon info — the HTTP port + pid of the detached `opencode serve` process,
+ *     so a restarted commander probes it and reconnects instead of respawning.
+ *  2. Per-agent session state — agentId ↔ OpenCode sessionID + turn state, so we
+ *     can re-attach the SSE stream and finalize any turn that was mid-flight
+ *     during the restart.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createLogger } from '../../utils/logger.js';
+const log = createLogger('OpencodeServerStore');
+const DATA_DIR = path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'), 'tide-commander');
+const DAEMON_FILE = path.join(DATA_DIR, 'opencode-server-daemon.json');
+const AGENTS_FILE = path.join(DATA_DIR, 'opencode-server-agents.json');
+export const OPENCODE_SERVER_LOG_FILE = path.join(DATA_DIR, 'opencode-server.log');
+function ensureDataDir() {
+    if (!fs.existsSync(DATA_DIR))
+        fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+export function loadDaemonInfo() {
+    try {
+        if (!fs.existsSync(DAEMON_FILE))
+            return null;
+        const data = JSON.parse(fs.readFileSync(DAEMON_FILE, 'utf-8'));
+        if (typeof data.port === 'number' && typeof data.pid === 'number')
+            return data;
+    }
+    catch (err) {
+        log.warn(`Failed to load daemon info: ${err.message}`);
+    }
+    return null;
+}
+export function saveDaemonInfo(info) {
+    ensureDataDir();
+    try {
+        fs.writeFileSync(DAEMON_FILE, JSON.stringify(info, null, 2), 'utf-8');
+    }
+    catch (err) {
+        log.error(`Failed to save daemon info: ${err.message}`);
+    }
+}
+export function clearDaemonInfo() {
+    try {
+        if (fs.existsSync(DAEMON_FILE))
+            fs.unlinkSync(DAEMON_FILE);
+    }
+    catch { /* ignore */ }
+}
+export function loadOpencodeAgents() {
+    try {
+        if (!fs.existsSync(AGENTS_FILE))
+            return [];
+        const data = JSON.parse(fs.readFileSync(AGENTS_FILE, 'utf-8'));
+        return Array.isArray(data) ? data : [];
+    }
+    catch (err) {
+        log.warn(`Failed to load opencode agents: ${err.message}`);
+        return [];
+    }
+}
+export function saveOpencodeAgents(agents) {
+    ensureDataDir();
+    try {
+        fs.writeFileSync(AGENTS_FILE, JSON.stringify(agents, null, 2), 'utf-8');
+    }
+    catch (err) {
+        log.error(`Failed to save opencode agents: ${err.message}`);
+    }
+}