tide-commander 1.154.0 → 1.155.0

package/dist/assets/{web-BvAQVbIF.js → web-Dj2DYQG1.js}

@@ -1 +1 @@
-import{df as a}from"./main-D5j8Ul0m.js";import{ImpactStyle as i,NotificationType as r}from"./index-CnESn83U.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};
+import{df as a}from"./main-DDwa0x9e.js";import{ImpactStyle as i,NotificationType as r}from"./index-C7t_6aP3.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};

package/dist/assets/{web-DMxl9AVF.js → web-EBdZk56y.js}

@@ -1 +1 @@
-import{df as s}from"./main-D5j8Ul0m.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};
+import{df as s}from"./main-DDwa0x9e.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};

package/dist/assets/{web-Cd0-XOkz.js → web-PXjd4vZ8.js}

@@ -1 +1 @@
-import{df as t}from"./main-D5j8Ul0m.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};
+import{df as t}from"./main-DDwa0x9e.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};

package/dist/build-info.json

@@ -1 +1 @@
-{"version":"1.154.0"}
+{"version":"1.155.0"}

package/dist/index.html

@@ -22,7 +22,7 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/icons/favicon-16x16.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/icons/apple-touch-icon.png" />
     <title>Tide Commander</title>
-    <script type="module" crossorigin src="/assets/main-D5j8Ul0m.js"></script>
+    <script type="module" crossorigin src="/assets/main-DDwa0x9e.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-react--Eh9ivFN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-Chj50gSY.js">
     <link rel="stylesheet" crossorigin href="/assets/main-BHBs2E1L.css">

package/dist/locales/en/config.json

@@ -38,6 +38,7 @@
     "tmuxMode": "Tmux Process Persistence",
     "interactiveMode": "Interactive TUI Mode (Experimental)",
     "codexAppServerMode": "Codex Streaming / app-server (Experimental)",
+    "opencodeServerMode": "OpenCode Streaming / serve (Experimental)",
     "tts": "Text-to-Speech",
     "stt": "Speech-to-Text",
     "externalEditor": "External Editor",

package/dist/src/packages/server/opencode/json-event-parser.js

@@ -55,7 +55,9 @@ export class OpencodeJsonEventParser {
         if (!event || typeof event !== 'object' || !event.type) {
             return [];
         }
-        log.log(`parseEvent: type=${event.type}, sessionID=${event.sessionID || 'none'}`);
+        // debug-level: in `opencode serve` mode this fires once per token delta, so
+        // keep it out of the default log stream to avoid per-token log spam.
+        log.debug(`parseEvent: type=${event.type}, sessionID=${event.sessionID || 'none'}`);
         switch (event.type) {
             case 'step_start':
                 return this.parseStepStart(event);

package/dist/src/packages/server/opencode/server/opencode-server-event-adapter.js

@@ -0,0 +1,127 @@
+/**
+ * OpencodeServerEventAdapter
+ *
+ * Translates `opencode serve` SSE events into Tide StandardEvents, one adapter
+ * per agent. Text/reasoning streaming and turn-end finalization are delegated to
+ * the existing OpencodeJsonEventParser (its `message.part.delta` /
+ * `message.part.updated` handling already matches the server's `properties`
+ * shape exactly), so the streaming behaviour is identical to the exec path.
+ *
+ * The adapter only adds what the server surfaces differently from `opencode run`:
+ *  - tool parts (`part.type === 'tool'`) → tool_start (once) + tool_result (on
+ *    completion), since the server streams them as message.part.updated rather
+ *    than the `tool_use` events the parser expects;
+ *  - `session.idle` → a synthetic `step_finish` fed through the parser so its
+ *    stream-finalization + step_complete/resultText logic is reused verbatim;
+ *  - assistant token/cost capture from `message.updated`, injected into that
+ *    synthetic step_finish for context tracking.
+ */
+import { OpencodeJsonEventParser } from '../json-event-parser.js';
+const TOOL_NAME_MAP = {
+    bash: 'Bash', read: 'Read', write: 'Write', edit: 'Edit', glob: 'Glob', grep: 'Grep',
+    task: 'Task', agent: 'Agent', skill: 'Skill', webfetch: 'WebFetch', websearch: 'WebSearch',
+    todowrite: 'TodoWrite', notebookedit: 'NotebookEdit', askuserquestion: 'AskUserQuestion',
+};
+function normalizeToolName(raw) {
+    return TOOL_NAME_MAP[raw.toLowerCase()] || raw;
+}
+export class OpencodeServerEventAdapter {
+    parser = new OpencodeJsonEventParser();
+    toolStarted = new Set();
+    toolInputSent = new Set();
+    toolDone = new Set();
+    lastTokens;
+    lastCost;
+    handle(event) {
+        const type = event.type;
+        if (!type)
+            return [];
+        const props = event.properties || {};
+        switch (type) {
+            case 'message.part.delta':
+                return this.parser.parseEvent(event);
+            case 'message.part.updated': {
+                const part = props.part || undefined;
+                const out = [];
+                // Text/reasoning parts stream through the shared parser (tool parts have
+                // no `text`, so the parser safely ignores them).
+                out.push(...this.parser.parseEvent(event));
+                if (part?.type === 'tool')
+                    out.push(...this.handleToolPart(part));
+                return out;
+            }
+            case 'message.updated': {
+                const info = props.info;
+                if (info?.role === 'assistant') {
+                    if (info.tokens)
+                        this.lastTokens = info.tokens;
+                    if (typeof info.cost === 'number')
+                        this.lastCost = info.cost;
+                }
+                return [];
+            }
+            case 'session.idle':
+                return this.finalizeTurn();
+            case 'session.error': {
+                const err = props.error;
+                const errorMessage = err?.message || err?.data?.message || 'OpenCode session error';
+                return [{ type: 'error', errorMessage }];
+            }
+            default:
+                return [];
+        }
+    }
+    handleToolPart(part) {
+        const callId = part.callID || part.id;
+        if (!callId)
+            return [];
+        const toolName = normalizeToolName(part.tool || 'unknown');
+        const status = part.state?.status;
+        const input = part.state?.input;
+        const hasInput = !!input && Object.keys(input).length > 0;
+        const events = [];
+        if (!this.toolStarted.has(callId)) {
+            this.toolStarted.add(callId);
+            if (hasInput)
+                this.toolInputSent.add(callId);
+            events.push({ type: 'tool_start', toolName, toolInput: input, uuid: callId, toolUseId: callId });
+        }
+        else if (!this.toolInputSent.has(callId) && hasInput) {
+            // Input arrived after the first (pending) update — refresh the same row.
+            this.toolInputSent.add(callId);
+            events.push({ type: 'tool_start', toolName, toolInput: input, uuid: callId, toolUseId: callId });
+        }
+        if ((status === 'completed' || status === 'error') && !this.toolDone.has(callId)) {
+            this.toolDone.add(callId);
+            events.push({ type: 'tool_result', toolName, toolOutput: part.state?.output || '', uuid: callId, toolUseId: callId });
+        }
+        return events;
+    }
+    finalizeTurn() {
+        // Feed a synthetic step_finish so the parser finalizes any open streaming
+        // rows and emits usage_snapshot + step_complete (with resultText from the
+        // assistant text it accumulated). Reset per-turn tool tracking after.
+        const syntheticStepFinish = {
+            type: 'step_finish',
+            part: {
+                reason: 'stop',
+                cost: this.lastCost,
+                tokens: this.lastTokens
+                    ? {
+                        input: this.lastTokens.input || 0,
+                        output: this.lastTokens.output || 0,
+                        reasoning: this.lastTokens.reasoning || 0,
+                        cache: { read: this.lastTokens.cache?.read || 0, write: this.lastTokens.cache?.write || 0 },
+                    }
+                    : undefined,
+            },
+        };
+        const events = this.parser.parseEvent(syntheticStepFinish);
+        this.toolStarted.clear();
+        this.toolInputSent.clear();
+        this.toolDone.clear();
+        this.lastTokens = undefined;
+        this.lastCost = undefined;
+        return events;
+    }
+}

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}`);
+    }
+}