dev-sessions 0.1.0

package/dist/backends/codex-appserver.js

@@ -0,0 +1,839 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAppServerBackend = void 0;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_net_1 = require("node:net");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const ws_1 = __importDefault(require("ws"));
+const DEFAULT_MODEL = 'gpt-5.3-codex';
+const DEFAULT_TIMEOUT_MS = 300_000;
+const REQUEST_TIMEOUT_MS = 60_000;
+const STARTUP_TIMEOUT_MS = 15_000;
+const PORT_POLL_INTERVAL_MS = 100;
+const CLOSE_TIMEOUT_MS = 500;
+const STATE_FILE_VERSION = 1;
+const RESUME_NOT_FOUND_PATTERN = /no rollout found|thread not found/i;
+const APP_SERVER_URL_PATTERN = /ws:\/\/127\.0\.0\.1:(\d+)/i;
+function defaultSpawnCodexDaemon(args, options) {
+    return (0, node_child_process_1.spawn)('codex', args, options);
+}
+function getDaemonStateFilePath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), '.dev-sessions', 'codex-appserver.json');
+}
+function getDaemonLogFilePath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), '.dev-sessions', 'codex-appserver.log');
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function waitForPortOpen(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        try {
+            await new Promise((resolve, reject) => {
+                const socket = (0, node_net_1.createConnection)({
+                    host: '127.0.0.1',
+                    port
+                });
+                socket.once('connect', () => {
+                    socket.destroy();
+                    resolve();
+                });
+                socket.once('error', (error) => {
+                    socket.destroy();
+                    reject(error);
+                });
+            });
+            return;
+        }
+        catch {
+            await sleep(PORT_POLL_INTERVAL_MS);
+        }
+    }
+    throw new Error(`Timed out waiting for Codex app-server to listen on port ${port}`);
+}
+class DefaultCodexAppServerDaemonManager {
+    stateFilePath;
+    logFilePath;
+    spawnDaemonProcess;
+    constructor(stateFilePath = getDaemonStateFilePath(), logFilePath = getDaemonLogFilePath(), spawnDaemonProcess = defaultSpawnCodexDaemon) {
+        this.stateFilePath = stateFilePath;
+        this.logFilePath = logFilePath;
+        this.spawnDaemonProcess = spawnDaemonProcess;
+    }
+    async ensureServer() {
+        const existing = await this.getServer();
+        if (existing) {
+            return existing;
+        }
+        return this.startServer();
+    }
+    async getServer() {
+        const state = await this.readState();
+        if (!state) {
+            return undefined;
+        }
+        if (!isProcessRunning(state.pid)) {
+            await this.deleteStateFile();
+            return undefined;
+        }
+        return {
+            pid: state.pid,
+            port: state.port,
+            url: state.url
+        };
+    }
+    async isServerRunning(pid, _port) {
+        if (typeof pid === 'number') {
+            return isProcessRunning(pid);
+        }
+        return (await this.getServer()) !== undefined;
+    }
+    async resetServer(server) {
+        const target = server ?? (await this.getServer());
+        if (!target) {
+            return;
+        }
+        try {
+            process.kill(target.pid, 'SIGTERM');
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH') {
+                throw error;
+            }
+        }
+        await this.deleteStateFile();
+    }
+    async stopServer() {
+        await this.resetServer();
+    }
+    async startServer() {
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(this.stateFilePath), { recursive: true });
+        const logHandle = await (0, promises_1.open)(this.logFilePath, 'w');
+        let child;
+        try {
+            child = this.spawnDaemonProcess(['app-server', '--listen', 'ws://127.0.0.1:0'], {
+                detached: true,
+                stdio: ['ignore', logHandle.fd, logHandle.fd]
+            });
+        }
+        finally {
+            await logHandle.close();
+        }
+        if (!child.pid || !Number.isInteger(child.pid)) {
+            throw new Error('Failed to start Codex app-server (missing PID)');
+        }
+        child.unref();
+        const port = await this.waitForListeningPort(child.pid);
+        await waitForPortOpen(port, STARTUP_TIMEOUT_MS);
+        const info = {
+            pid: child.pid,
+            port,
+            url: `ws://127.0.0.1:${port}`
+        };
+        await this.writeState(info);
+        return info;
+    }
+    async waitForListeningPort(pid) {
+        const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+        while (Date.now() <= deadline) {
+            const logContents = await this.readLog();
+            const match = logContents.match(APP_SERVER_URL_PATTERN);
+            if (match) {
+                const port = Number.parseInt(match[1], 10);
+                if (Number.isInteger(port) && port > 0) {
+                    return port;
+                }
+            }
+            if (!isProcessRunning(pid)) {
+                throw new Error(`Codex app-server exited during startup. Log output:\n${logContents.trim()}`);
+            }
+            await sleep(PORT_POLL_INTERVAL_MS);
+        }
+        const finalLog = await this.readLog();
+        throw new Error(`Timed out waiting for Codex app-server startup. Log output:\n${finalLog.trim()}`);
+    }
+    async readLog() {
+        try {
+            return await (0, promises_1.readFile)(this.logFilePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return '';
+            }
+            throw error;
+        }
+    }
+    async readState() {
+        try {
+            const raw = await (0, promises_1.readFile)(this.stateFilePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed.version !== STATE_FILE_VERSION ||
+                !Number.isInteger(parsed.pid) ||
+                !Number.isInteger(parsed.port) ||
+                typeof parsed.url !== 'string') {
+                return undefined;
+            }
+            return {
+                version: STATE_FILE_VERSION,
+                pid: parsed.pid,
+                port: parsed.port,
+                url: parsed.url,
+                startedAt: typeof parsed.startedAt === 'string' ? parsed.startedAt : new Date().toISOString()
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    async writeState(info) {
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(this.stateFilePath), { recursive: true });
+        const tmpPath = `${this.stateFilePath}.tmp`;
+        const payload = {
+            version: STATE_FILE_VERSION,
+            pid: info.pid,
+            port: info.port,
+            url: info.url,
+            startedAt: new Date().toISOString()
+        };
+        await (0, promises_1.writeFile)(tmpPath, JSON.stringify(payload, null, 2), 'utf8');
+        await (0, promises_1.rename)(tmpPath, this.stateFilePath);
+    }
+    async deleteStateFile() {
+        await (0, promises_1.rm)(this.stateFilePath, { force: true });
+    }
+}
+class CodexWebSocketRpcClient {
+    url;
+    ws;
+    connectPromise;
+    nextRequestId = 1;
+    stdoutBuffer = '';
+    pendingRequests = new Map();
+    waiters = [];
+    currentText = '';
+    turnStatus;
+    turnError;
+    closed = false;
+    closing = false;
+    constructor(url) {
+        this.url = url;
+    }
+    get currentTurnText() {
+        return this.currentText;
+    }
+    get lastTurnStatus() {
+        return this.turnStatus;
+    }
+    get lastTurnError() {
+        return this.turnError;
+    }
+    async connectAndInitialize() {
+        if (!this.connectPromise) {
+            this.connectPromise = this.connect();
+        }
+        await this.connectPromise;
+        await this.request('initialize', {
+            clientInfo: {
+                name: 'dev-sessions',
+                title: 'dev-sessions',
+                version: '0.1.0'
+            },
+            capabilities: {
+                experimentalApi: true
+            }
+        });
+        this.notify('initialized', {});
+    }
+    async request(method, params) {
+        if (this.closed) {
+            throw new Error(this.turnError ?? 'Codex app-server connection is closed');
+        }
+        const ws = this.ws;
+        if (!ws || ws.readyState !== ws_1.default.OPEN) {
+            throw new Error('Codex app-server connection is not open');
+        }
+        const id = this.nextRequestId;
+        this.nextRequestId += 1;
+        return new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                const pending = this.pendingRequests.get(id);
+                if (!pending) {
+                    return;
+                }
+                this.pendingRequests.delete(id);
+                pending.reject(new Error(`${method} timed out after ${REQUEST_TIMEOUT_MS}ms`));
+            }, REQUEST_TIMEOUT_MS);
+            this.pendingRequests.set(id, {
+                method,
+                resolve,
+                reject,
+                timeoutHandle
+            });
+            try {
+                ws.send(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+            }
+            catch (error) {
+                this.pendingRequests.delete(id);
+                clearTimeout(timeoutHandle);
+                reject(error);
+            }
+        });
+    }
+    async waitForTurnCompletion(timeoutMs) {
+        if (this.turnStatus) {
+            return {
+                completed: true,
+                timedOut: false,
+                elapsedMs: 0,
+                status: this.turnStatus,
+                errorMessage: this.turnError
+            };
+        }
+        const safeTimeout = Math.max(1, timeoutMs);
+        return new Promise((resolve) => {
+            const startTime = Date.now();
+            const timeoutHandle = setTimeout(() => {
+                this.waiters = this.waiters.filter((waiter) => waiter.timeoutHandle !== timeoutHandle);
+                this.turnStatus = 'interrupted';
+                this.turnError = 'Timed out waiting for Codex turn completion';
+                resolve({
+                    completed: false,
+                    timedOut: true,
+                    elapsedMs: Date.now() - startTime,
+                    status: 'interrupted',
+                    errorMessage: this.turnError
+                });
+            }, safeTimeout);
+            this.waiters.push({
+                startTime,
+                timeoutHandle,
+                resolve
+            });
+        });
+    }
+    async close() {
+        const ws = this.ws;
+        if (!ws || this.closed) {
+            return;
+        }
+        this.closing = true;
+        await new Promise((resolve) => {
+            const finish = () => {
+                resolve();
+            };
+            const timeoutHandle = setTimeout(() => {
+                try {
+                    ws.terminate();
+                }
+                catch {
+                    // no-op
+                }
+                finish();
+            }, CLOSE_TIMEOUT_MS);
+            ws.once('close', () => {
+                clearTimeout(timeoutHandle);
+                finish();
+            });
+            try {
+                if (ws.readyState === ws_1.default.CONNECTING) {
+                    ws.terminate();
+                    clearTimeout(timeoutHandle);
+                    finish();
+                    return;
+                }
+                ws.close();
+            }
+            catch {
+                clearTimeout(timeoutHandle);
+                finish();
+            }
+        });
+    }
+    async connect() {
+        await new Promise((resolve, reject) => {
+            const ws = new ws_1.default(this.url, {
+                perMessageDeflate: false,
+                handshakeTimeout: REQUEST_TIMEOUT_MS
+            });
+            this.ws = ws;
+            const onOpen = () => {
+                cleanup();
+                this.attachSocketHandlers(ws);
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onClose = (code, reason) => {
+                cleanup();
+                const details = reason.toString().trim();
+                const suffix = details.length > 0 ? `: ${details}` : '';
+                reject(new Error(`Codex app-server websocket closed during connect (${code})${suffix}`));
+            };
+            const cleanup = () => {
+                ws.off('open', onOpen);
+                ws.off('error', onError);
+                ws.off('close', onClose);
+            };
+            ws.once('open', onOpen);
+            ws.once('error', onError);
+            ws.once('close', onClose);
+        });
+    }
+    attachSocketHandlers(ws) {
+        ws.on('message', (data) => {
+            const text = typeof data === 'string' ? data : data.toString();
+            this.handleMessageFrame(text);
+        });
+        ws.on('error', (error) => {
+            this.failConnection(`Codex app-server websocket error: ${error.message}`);
+        });
+        ws.on('close', (code, reason) => {
+            if (this.closing) {
+                this.closed = true;
+                return;
+            }
+            const details = reason.toString().trim();
+            const suffix = details.length > 0 ? `: ${details}` : '';
+            this.failConnection(`Codex app-server websocket closed (${code})${suffix}`);
+        });
+    }
+    handleMessageFrame(frame) {
+        if (!frame.includes('\n') && this.stdoutBuffer.length === 0) {
+            this.handleMaybeJsonLine(frame);
+            return;
+        }
+        this.stdoutBuffer += frame;
+        const lines = this.stdoutBuffer.split('\n');
+        this.stdoutBuffer = lines.pop() ?? '';
+        for (const line of lines) {
+            this.handleMaybeJsonLine(line);
+        }
+        if (this.stdoutBuffer.trim().length > 0) {
+            const pendingBuffer = this.stdoutBuffer;
+            this.stdoutBuffer = '';
+            this.handleMaybeJsonLine(pendingBuffer);
+        }
+    }
+    handleMaybeJsonLine(rawLine) {
+        const trimmed = rawLine.trim();
+        if (trimmed.length === 0) {
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(trimmed);
+        }
+        catch {
+            // If parsing fails, keep buffering behavior for newline-delimited mode.
+            if (!rawLine.includes('\n')) {
+                this.stdoutBuffer = rawLine;
+            }
+            return;
+        }
+        this.handleRpcMessage(payload);
+    }
+    handleRpcMessage(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return;
+        }
+        if ('id' in payload && typeof payload.id === 'number') {
+            this.handleRpcResponse(payload);
+            return;
+        }
+        if ('method' in payload && typeof payload.method === 'string') {
+            this.handleNotification(payload);
+        }
+    }
+    handleRpcResponse(response) {
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+            return;
+        }
+        this.pendingRequests.delete(response.id);
+        clearTimeout(pending.timeoutHandle);
+        if (response.error) {
+            const message = response.error.message ?? 'Unknown JSON-RPC error';
+            pending.reject(new Error(`${pending.method} failed: ${message}`));
+            return;
+        }
+        pending.resolve(response.result);
+    }
+    handleNotification(notification) {
+        if (notification.method === 'item/agentMessage/delta') {
+            const deltaText = extractDeltaText(notification.params);
+            if (deltaText.length > 0) {
+                this.currentText += deltaText;
+            }
+            return;
+        }
+        if (notification.method !== 'turn/completed') {
+            return;
+        }
+        const turn = notification.params?.turn;
+        const status = extractTurnStatus(turn);
+        if (!status) {
+            return;
+        }
+        this.turnStatus = status;
+        this.turnError = extractTurnError(turn);
+        this.resolveWaiters({
+            completed: true,
+            timedOut: false,
+            elapsedMs: 0,
+            status,
+            errorMessage: this.turnError
+        });
+    }
+    resolveWaiters(baseResult) {
+        const waiters = this.waiters.splice(0, this.waiters.length);
+        const now = Date.now();
+        for (const waiter of waiters) {
+            clearTimeout(waiter.timeoutHandle);
+            waiter.resolve({
+                ...baseResult,
+                elapsedMs: now - waiter.startTime
+            });
+        }
+    }
+    failConnection(message) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.turnStatus = this.turnStatus ?? 'failed';
+        this.turnError = this.turnError ?? message;
+        const pendingRequests = [...this.pendingRequests.values()];
+        this.pendingRequests.clear();
+        for (const pending of pendingRequests) {
+            clearTimeout(pending.timeoutHandle);
+            pending.reject(new Error(message));
+        }
+        this.resolveWaiters({
+            completed: true,
+            timedOut: false,
+            elapsedMs: 0,
+            status: this.turnStatus,
+            errorMessage: this.turnError
+        });
+    }
+    notify(method, params) {
+        const ws = this.ws;
+        if (!ws || ws.readyState !== ws_1.default.OPEN) {
+            return;
+        }
+        ws.send(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`);
+    }
+}
+function extractThreadId(result) {
+    const threadId = result?.thread?.id;
+    if (typeof threadId !== 'string' || threadId.trim().length === 0) {
+        throw new Error('thread/start did not return a thread ID');
+    }
+    return threadId;
+}
+function extractDeltaText(params) {
+    if (!params || typeof params !== 'object') {
+        return '';
+    }
+    const asRecord = params;
+    const directText = asRecord.text;
+    if (typeof directText === 'string') {
+        return directText;
+    }
+    const delta = asRecord.delta;
+    if (typeof delta === 'string') {
+        return delta;
+    }
+    if (delta && typeof delta === 'object' && typeof delta.text === 'string') {
+        return delta.text;
+    }
+    const item = asRecord.item;
+    if (item && typeof item === 'object') {
+        const nestedDelta = item.delta;
+        if (nestedDelta &&
+            typeof nestedDelta === 'object' &&
+            typeof nestedDelta.text === 'string') {
+            return nestedDelta.text;
+        }
+    }
+    return '';
+}
+function extractTurnStatus(turn) {
+    if (!turn || typeof turn !== 'object') {
+        return undefined;
+    }
+    const status = turn.status;
+    if (status === 'completed' || status === 'failed' || status === 'interrupted') {
+        return status;
+    }
+    return undefined;
+}
+function extractTurnError(turn) {
+    if (!turn || typeof turn !== 'object') {
+        return undefined;
+    }
+    const error = turn.error;
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const message = error.message;
+    if (typeof message === 'string' && message.length > 0) {
+        return message;
+    }
+    return undefined;
+}
+class CodexAppServerBackend {
+    sessionState = new Map();
+    daemonManager;
+    clientFactory;
+    constructor(dependencies = {}) {
+        this.daemonManager = dependencies.daemonManager ?? new DefaultCodexAppServerDaemonManager();
+        this.clientFactory = dependencies.clientFactory ?? ((url) => new CodexWebSocketRpcClient(url));
+    }
+    async createSession(championId, workspacePath, model = DEFAULT_MODEL) {
+        const { server, result } = await this.withConnectedClient(async (client) => {
+            const threadResult = await client.request('thread/start', {
+                model,
+                cwd: workspacePath,
+                approvalPolicy: 'never',
+                sandbox: 'danger-full-access',
+                ephemeral: false,
+                persistExtendedHistory: true,
+                experimentalRawEvents: false
+            });
+            return extractThreadId(threadResult);
+        });
+        this.ensureSessionState(championId);
+        return {
+            threadId: result,
+            model,
+            appServerPid: server.pid,
+            appServerPort: server.port
+        };
+    }
+    async sendMessage(championId, threadId, message, options) {
+        if (!options || options.workspacePath.trim().length === 0) {
+            throw new Error('Codex workspace path is required to send a message');
+        }
+        const timeoutMs = Math.max(1, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        const model = options.model ?? DEFAULT_MODEL;
+        const state = this.ensureSessionState(championId);
+        const { server, result } = await this.withConnectedClient(async (client) => {
+            let activeThreadId = threadId.trim();
+            if (activeThreadId.length > 0) {
+                try {
+                    await client.request('thread/resume', {
+                        threadId: activeThreadId,
+                        cwd: options.workspacePath,
+                        model,
+                        approvalPolicy: 'never',
+                        sandbox: 'danger-full-access',
+                        persistExtendedHistory: true
+                    });
+                }
+                catch (error) {
+                    if (!this.isResumeNotFoundError(error)) {
+                        throw error;
+                    }
+                    activeThreadId = '';
+                }
+            }
+            if (activeThreadId.length === 0) {
+                const threadResult = await client.request('thread/start', {
+                    model,
+                    cwd: options.workspacePath,
+                    approvalPolicy: 'never',
+                    sandbox: 'danger-full-access',
+                    ephemeral: false,
+                    persistExtendedHistory: true,
+                    experimentalRawEvents: false
+                });
+                activeThreadId = extractThreadId(threadResult);
+            }
+            await client.request('turn/start', {
+                threadId: activeThreadId,
+                input: [{ type: 'text', text: message }]
+            });
+            const waitResult = await client.waitForTurnCompletion(timeoutMs);
+            return {
+                threadId: activeThreadId,
+                waitResult,
+                assistantMessage: client.currentTurnText
+            };
+        });
+        state.lastTurnStatus = result.waitResult.status;
+        state.lastTurnError = result.waitResult.errorMessage;
+        if (result.assistantMessage.length > 0) {
+            state.assistantHistory.push(result.assistantMessage);
+        }
+        return {
+            ...result.waitResult,
+            threadId: result.threadId,
+            assistantMessage: result.assistantMessage,
+            appServerPid: server.pid,
+            appServerPort: server.port
+        };
+    }
+    async waitForTurn(championId, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const state = this.sessionState.get(championId);
+        if (!state || !state.lastTurnStatus) {
+            return {
+                completed: true,
+                timedOut: false,
+                elapsedMs: 0,
+                status: 'completed'
+            };
+        }
+        if (state.lastTurnStatus === 'interrupted') {
+            return {
+                completed: false,
+                timedOut: true,
+                elapsedMs: Math.max(1, timeoutMs),
+                status: 'interrupted',
+                errorMessage: state.lastTurnError
+            };
+        }
+        return {
+            completed: true,
+            timedOut: false,
+            elapsedMs: 0,
+            status: state.lastTurnStatus,
+            errorMessage: state.lastTurnError
+        };
+    }
+    getLastAssistantMessages(championId, count) {
+        const state = this.ensureSessionState(championId);
+        const safeCount = Math.max(1, count);
+        return state.assistantHistory.slice(-safeCount);
+    }
+    getSessionStatus(championId) {
+        const state = this.ensureSessionState(championId);
+        if (state.lastTurnStatus === 'failed') {
+            const suffix = state.lastTurnError ? `: ${state.lastTurnError}` : '';
+            throw new Error(`Codex turn failed${suffix}`);
+        }
+        if (state.lastTurnStatus === 'interrupted') {
+            return 'working';
+        }
+        return 'idle';
+    }
+    async killSession(championId, pid, threadId, port) {
+        this.sessionState.delete(championId);
+        if (!threadId || typeof port !== 'number') {
+            return;
+        }
+        const activeServer = await this.daemonManager.getServer();
+        if (!activeServer) {
+            return;
+        }
+        if (typeof pid === 'number' && activeServer.pid !== pid) {
+            return;
+        }
+        if (activeServer.port !== port) {
+            return;
+        }
+        try {
+            await this.withConnectedClientToServer(activeServer, async (client) => {
+                await client.request('thread/archive', {
+                    threadId
+                });
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error &&
+                /not found|no rollout found|unknown thread|websocket|ECONNREFUSED|socket hang up|connection is not open/i
+                    .test(error.message))) {
+                throw error;
+            }
+        }
+    }
+    async stopAppServer() {
+        await this.daemonManager.stopServer();
+    }
+    async sessionExists(_championId, pid, port) {
+        return this.daemonManager.isServerRunning(pid, port);
+    }
+    ensureSessionState(championId) {
+        const existing = this.sessionState.get(championId);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            assistantHistory: []
+        };
+        this.sessionState.set(championId, created);
+        return created;
+    }
+    async withConnectedClient(fn) {
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            const server = await this.daemonManager.ensureServer();
+            try {
+                const result = await this.withConnectedClientToServer(server, fn);
+                return {
+                    server,
+                    result
+                };
+            }
+            catch (error) {
+                if (attempt === 0 && this.shouldResetDaemonAfterConnectionFailure(error)) {
+                    await this.daemonManager.resetServer(server);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error('Unreachable');
+    }
+    async withConnectedClientToServer(server, fn) {
+        const client = this.clientFactory(server.url);
+        try {
+            await client.connectAndInitialize();
+            return await fn(client);
+        }
+        finally {
+            await client.close().catch(() => {
+                // Ignore close errors; the primary operation result/error is more useful.
+            });
+        }
+    }
+    shouldResetDaemonAfterConnectionFailure(error) {
+        if (!(error instanceof Error)) {
+            return false;
+        }
+        return /websocket|ECONNREFUSED|EPIPE|socket hang up|closed during connect|connection is not open/i
+            .test(error.message);
+    }
+    isResumeNotFoundError(error) {
+        if (!(error instanceof Error)) {
+            return false;
+        }
+        return RESUME_NOT_FOUND_PATTERN.test(error.message);
+    }
+}
+exports.CodexAppServerBackend = CodexAppServerBackend;
+//# sourceMappingURL=codex-appserver.js.map