tide-commander 1.152.0 → 1.154.0

package/dist/src/packages/server/codex/app-server/app-server-process.js

@@ -0,0 +1,304 @@
+/**
+ * CodexAppServerProcess
+ *
+ * Manages a DETACHED, restart-surviving `codex app-server` listening on a
+ * localhost WebSocket (`--listen ws://127.0.0.1:PORT`) and speaks its
+ * "JSON-RPC lite" protocol (standard JSON-RPC 2.0 shape, `"jsonrpc":"2.0"`
+ * omitted on the wire) over that WebSocket.
+ *
+ * Why WebSocket + detached:
+ *  - `codex exec` never streams; the app-server emits `item/agentMessage/delta`
+ *    tokens (word-by-word).
+ *  - A stdio child dies with the commander. A detached process bound to a TCP
+ *    port survives commander restarts, and the app-server keeps running any
+ *    in-flight turn independently. On restart the commander reconnects the
+ *    WebSocket and `thread/resume` re-subscribes — the server even replays the
+ *    turn's remaining deltas (verified empirically).
+ *  - The raw `unix://` transport uses an undocumented framing; the `ws://`
+ *    transport uses standard WebSocket framing (the commander already depends on
+ *    `ws`) and exposes `/readyz` for health probes.
+ *
+ * One process multiplexes every Codex agent: each agent owns a `threadId`, and
+ * notifications carry that id so the runner can fan them back out.
+ */
+import { spawn } from 'child_process';
+import * as http from 'http';
+import * as net from 'net';
+import * as fs from 'fs';
+import { WebSocket } from 'ws';
+import { createLogger } from '../../utils/logger.js';
+import { loadDaemonInfo, saveDaemonInfo, clearDaemonInfo, APP_SERVER_LOG_FILE, } from './app-server-recovery-store.js';
+const log = createLogger('CodexAppServer');
+const INITIALIZE_TIMEOUT_MS = 15000;
+const READYZ_TIMEOUT_MS = 20000;
+const READYZ_POLL_MS = 250;
+export class CodexAppServerProcess {
+    opts;
+    ws = null;
+    port = null;
+    nextId = 1;
+    pending = new Map();
+    readyPromise = null;
+    stopped = false;
+    /** True when the last ensureStarted() rejoined an already-running daemon. */
+    reconnectedToExisting = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    isAlive() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN && !this.stopped;
+    }
+    /** Did the current connection rejoin a daemon that survived a prior commander? */
+    didReconnect() {
+        return this.reconnectedToExisting;
+    }
+    ensureStarted() {
+        if (this.readyPromise)
+            return this.readyPromise;
+        this.readyPromise = this.boot();
+        return this.readyPromise;
+    }
+    async boot() {
+        this.stopped = false;
+        // 1. Rejoin an already-running daemon if one is healthy.
+        const existing = loadDaemonInfo();
+        if (existing && (await this.isDaemonHealthy(existing))) {
+            log.log(`🔗 Rejoining existing app-server daemon pid=${existing.pid} port=${existing.port}`);
+            this.port = existing.port;
+            this.reconnectedToExisting = true;
+            await this.connectAndInitialize(existing.port);
+            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.waitForReadyz(port);
+        await this.connectAndInitialize(port);
+    }
+    spawnDaemon(port) {
+        const { executablePath, cwd, extraEnv } = this.opts;
+        const logFd = (() => {
+            try {
+                return fs.openSync(APP_SERVER_LOG_FILE, 'a');
+            }
+            catch {
+                return 'ignore';
+            }
+        })();
+        log.log(`🚀 Spawning detached app-server: ${executablePath} app-server --listen ws://127.0.0.1:${port}`);
+        const child = spawn(executablePath, ['app-server', '--listen', `ws://127.0.0.1:${port}`], {
+            cwd,
+            env: { ...process.env, ...extraEnv },
+            detached: true,
+            stdio: ['ignore', logFd, logFd],
+        });
+        child.unref();
+        child.on('error', (err) => log.error(`app-server spawn error: ${err.message}`));
+        return child.pid ?? -1;
+    }
+    async isDaemonHealthy(info) {
+        if (!isPidAlive(info.pid))
+            return false;
+        return probeReadyz(info.port, 1500);
+    }
+    async waitForReadyz(port) {
+        const deadline = Date.now() + READYZ_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (await probeReadyz(port, 1000))
+                return;
+            await sleep(READYZ_POLL_MS);
+        }
+        throw new Error('app-server /readyz never became healthy');
+    }
+    connectAndInitialize(port) {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+            this.ws = ws;
+            let settled = false;
+            const initTimer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    reject(new Error('app-server initialize timed out'));
+                }
+            }, INITIALIZE_TIMEOUT_MS);
+            ws.on('open', () => {
+                this.request('initialize', {
+                    clientInfo: { name: 'tide-commander', title: 'Tide Commander', version: '1.0.0' },
+                    capabilities: { experimentalApi: true },
+                })
+                    .then(() => {
+                    this.notify('initialized', {});
+                    clearTimeout(initTimer);
+                    if (!settled) {
+                        settled = true;
+                        log.log('✅ app-server WebSocket initialized');
+                        resolve();
+                    }
+                })
+                    .catch((err) => {
+                    clearTimeout(initTimer);
+                    if (!settled) {
+                        settled = true;
+                        reject(err);
+                    }
+                });
+            });
+            ws.on('message', (data) => this.handleLine(data.toString()));
+            ws.on('error', (err) => {
+                log.warn(`app-server WebSocket error: ${err.message}`);
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(initTimer);
+                    reject(err);
+                }
+            });
+            ws.on('close', () => this.handleDisconnect());
+        });
+    }
+    handleDisconnect() {
+        const wasConnected = this.ws !== null;
+        this.ws = null;
+        this.readyPromise = null;
+        for (const [, p] of this.pending)
+            p.reject(new Error('app-server connection closed'));
+        this.pending.clear();
+        if (wasConnected && !this.stopped) {
+            log.warn('app-server connection closed unexpectedly');
+            this.opts.onExit();
+        }
+    }
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            log.warn(`Non-JSON message from app-server: ${trimmed.slice(0, 200)}`);
+            return;
+        }
+        if (msg.id !== undefined && msg.method === undefined) {
+            const id = typeof msg.id === 'number' ? msg.id : Number(msg.id);
+            const pending = this.pending.get(id);
+            if (!pending)
+                return;
+            this.pending.delete(id);
+            if (msg.error)
+                pending.reject(new Error(msg.error.message || `app-server error on ${pending.method}`));
+            else
+                pending.resolve(msg.result);
+            return;
+        }
+        if (msg.method !== undefined && msg.id !== undefined) {
+            this.handleServerRequest(msg.id, msg.method);
+            return;
+        }
+        if (msg.method !== undefined) {
+            this.opts.onNotification(msg.method, msg.params || {});
+        }
+    }
+    /**
+     * Auto-answer server-initiated requests. Agents run approvalPolicy:'never' +
+     * danger-full-access, so approvals shouldn't fire — but approve rather than
+     * hang if one does.
+     */
+    handleServerRequest(id, method) {
+        if (/approval/i.test(method)) {
+            this.respond(id, { decision: 'approved' });
+            return;
+        }
+        log.warn(`Unhandled app-server request '${method}' — responding empty`);
+        this.respond(id, {});
+    }
+    respond(id, result) {
+        this.sendRaw({ id, result });
+    }
+    request(method, params) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return Promise.reject(new Error('app-server not connected'));
+        }
+        const id = this.nextId++;
+        const promise = new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject, method });
+        });
+        this.sendRaw({ id, method, params });
+        return promise;
+    }
+    notify(method, params) {
+        this.sendRaw({ method, params });
+    }
+    sendRaw(obj) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            log.warn('Cannot send to app-server: WebSocket not open');
+            return;
+        }
+        this.ws.send(JSON.stringify(obj));
+    }
+    /** Disconnect our client but LEAVE the daemon running (survives restart). */
+    disconnect() {
+        this.stopped = true;
+        if (this.ws) {
+            try {
+                this.ws.close();
+            }
+            catch { /* ignore */ }
+            this.ws = 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 probeReadyz(port, timeoutMs) {
+    return new Promise((resolve) => {
+        const req = http.get({ host: '127.0.0.1', port, path: '/readyz', timeout: timeoutMs }, (res) => {
+            res.resume();
+            resolve(res.statusCode !== undefined && res.statusCode >= 200 && res.statusCode < 500);
+        });
+        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/codex/app-server/app-server-recovery-store.js

@@ -0,0 +1,76 @@
+/**
+ * Persistence for the restart-surviving Codex app-server.
+ *
+ * Two things are persisted, in a dedicated file (never the shared
+ * running-processes.json), so a restarted commander can rejoin a still-running
+ * app-server and its in-flight turns:
+ *
+ *  1. Daemon info — the `ws://` port + pid of the detached `codex app-server`
+ *     process. On boot we probe it; if alive we reconnect instead of spawning.
+ *  2. Per-agent thread state — agentId ↔ threadId (== sessionId) + turn state, so
+ *     we can re-subscribe (thread/resume) to each agent's thread 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('CodexAppServerStore');
+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, 'codex-app-server-daemon.json');
+const AGENTS_FILE = path.join(DATA_DIR, 'codex-app-server-agents.json');
+export const APP_SERVER_LOG_FILE = path.join(DATA_DIR, 'codex-app-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 loadAppServerAgents() {
+    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 app-server agents: ${err.message}`);
+        return [];
+    }
+}
+export function saveAppServerAgents(agents) {
+    ensureDataDir();
+    try {
+        fs.writeFileSync(AGENTS_FILE, JSON.stringify(agents, null, 2), 'utf-8');
+    }
+    catch (err) {
+        log.error(`Failed to save app-server agents: ${err.message}`);
+    }
+}