ever-terminal 1.0.0

package/dist/codex/app-server.js

@@ -0,0 +1,300 @@
+import WebSocket from "ws";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { debugLog } from "../debug.js";
+import { ensureCodexAppServerStarted } from "../startup/common.js";
+const execAsync = promisify(exec);
+let codexVersionCache = null;
+async function probeCodexVersion() {
+    if (codexVersionCache !== null)
+        return codexVersionCache;
+    try {
+        const { stdout } = await execAsync("codex --version", { timeout: 3000 });
+        codexVersionCache = stdout.trim() || "0.0.0";
+    }
+    catch {
+        codexVersionCache = "0.0.0";
+    }
+    return codexVersionCache;
+}
+export class CodexAppServerClient {
+    ws = null;
+    wsUrl;
+    initialized = false;
+    nextId = 1;
+    handleNotification;
+    handleServerRequest;
+    handleClose;
+    pending = new Map();
+    initPromise = null;
+    constructor(wsUrl) {
+        this.wsUrl = wsUrl;
+    }
+    async threadList(params) {
+        const result = await this.call("thread/list", params);
+        return {
+            data: Array.isArray(result?.data) ? result.data : [],
+            nextCursor: result?.nextCursor ?? null,
+        };
+    }
+    async threadRead(threadId, includeTurns = true) {
+        const result = await this.call("thread/read", {
+            threadId,
+            includeTurns,
+        });
+        return result?.thread ?? null;
+    }
+    /** Paginated turn listing used by getCodexSessionHistory. */
+    async threadTurnsList(params) {
+        const result = await this.call("thread/turns/list", params);
+        return {
+            data: Array.isArray(result?.data) ? result.data : [],
+            nextCursor: result?.nextCursor ?? null,
+            backwardsCursor: result?.backwardsCursor ?? null,
+        };
+    }
+    async threadStart(params) {
+        const result = await this.call("thread/start", params);
+        return result?.thread ?? null;
+    }
+    async threadResume(params) {
+        const result = await this.call("thread/resume", params);
+        return result?.thread ?? null;
+    }
+    async turnStart(params) {
+        const result = await this.call("turn/start", params);
+        return result?.turn ?? null;
+    }
+    async turnInterrupt(threadId, turnId) {
+        await this.call("turn/interrupt", { threadId, turnId });
+    }
+    async threadUnsubscribe(threadId) {
+        const result = await this.call("thread/unsubscribe", { threadId });
+        return result?.status ?? "unknown";
+    }
+    async getAccount() {
+        try {
+            const result = await this.call("account/get", {});
+            return result?.account ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    respondToServerRequest(id, result) {
+        this.send({
+            jsonrpc: "2.0",
+            id,
+            result,
+        });
+    }
+    /** Connect and initialize eagerly (for receiving notifications at startup). */
+    async connect() {
+        await this.ensureInitialized();
+    }
+    async close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.initialized = false;
+        this.initPromise = null;
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new Error("Client closed"));
+        }
+        this.pending.clear();
+    }
+    send(msg) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        this.ws.send(JSON.stringify(msg));
+    }
+    async call(method, params) {
+        await this.ensureInitialized();
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error("codex app-server not connected");
+        }
+        const id = this.nextId++;
+        const req = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`RPC timeout: ${method}`));
+            }, 30000);
+            this.pending.set(id, { resolve, reject, timer });
+            this.send(req);
+        });
+    }
+    async ensureInitialized() {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN && this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.connectAndInitialize().finally(() => {
+            this.initPromise = null;
+        });
+        return this.initPromise;
+    }
+    async connectAndInitialize() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            const started = await ensureCodexAppServerStarted();
+            if (!started) {
+                throw new Error("codex app-server failed to start (see [codex] logs above)");
+            }
+            await this.connectWebSocket();
+        }
+        if (!this.initialized) {
+            await this.callRaw("initialize", {
+                clientInfo: {
+                    name: "codex",
+                    version: await probeCodexVersion(),
+                },
+                capabilities: {
+                    experimentalApi: true,
+                },
+            });
+            this.initialized = true;
+            // Send initialized notification
+            this.send({ jsonrpc: "2.0", method: "initialized" });
+        }
+    }
+    connectWebSocket() {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(this.wsUrl);
+            const connectTimeout = setTimeout(() => {
+                ws.close();
+                reject(new Error(`WebSocket connect timeout: ${this.wsUrl}`));
+            }, 10000);
+            ws.on("open", () => {
+                clearTimeout(connectTimeout);
+                this.ws = ws;
+                resolve();
+            });
+            ws.on("message", (data) => {
+                const text = typeof data === "string" ? data : data.toString();
+                // app-server may send multiple JSON-RPC messages in one frame (newline-delimited)
+                for (const line of text.split("\n")) {
+                    if (line.trim())
+                        this.handleLine(line);
+                }
+            });
+            ws.on("error", (err) => {
+                clearTimeout(connectTimeout);
+                console.error(`[codex-app-server] ws error: ${err.message}`);
+                const e = new Error(`codex app-server ws error: ${err.message}`);
+                for (const [, p] of this.pending) {
+                    clearTimeout(p.timer);
+                    p.reject(e);
+                }
+                this.pending.clear();
+                this.ws = null;
+                this.initialized = false;
+                try {
+                    this.handleClose?.(e);
+                }
+                catch { }
+                reject(e);
+            });
+            ws.on("close", () => {
+                const err = new Error("codex app-server ws closed");
+                for (const [, p] of this.pending) {
+                    clearTimeout(p.timer);
+                    p.reject(err);
+                }
+                this.pending.clear();
+                this.ws = null;
+                this.initialized = false;
+                try {
+                    this.handleClose?.(err);
+                }
+                catch { }
+            });
+        });
+    }
+    async callRaw(method, params) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error("codex app-server not connected");
+        }
+        const id = this.nextId++;
+        const req = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`RPC timeout: ${method}`));
+            }, 10000);
+            this.pending.set(id, { resolve, reject, timer });
+            this.send(req);
+        });
+    }
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        // JSON-RPC notification (no id)
+        if (msg?.id === undefined || msg?.id === null) {
+            if (typeof msg?.method === "string") {
+                debugLog("codex-app-server", `notification ${msg.method}`, toOneLineJson(msg.params ?? {}));
+                try {
+                    this.handleNotification?.(msg.method, msg.params ?? {});
+                }
+                catch { }
+            }
+            return;
+        }
+        // JSON-RPC server request (has method + id)
+        if (typeof msg?.method === "string" && msg?.id !== undefined) {
+            debugLog("codex-app-server", `server_request id=${String(msg.id)} method=${msg.method}`, toOneLineJson(msg.params ?? {}));
+            try {
+                this.handleServerRequest?.(msg.id, msg.method, msg.params ?? {});
+            }
+            catch { }
+            return;
+        }
+        // JSON-RPC response
+        const pending = this.pending.get(msg.id);
+        if (!pending)
+            return;
+        this.pending.delete(msg.id);
+        clearTimeout(pending.timer);
+        if (msg.error) {
+            const err = Object.assign(new Error(msg.error.message || "RPC error"), {
+                rpcCode: msg.error.code,
+                rpcData: msg.error.data,
+            });
+            pending.reject(err);
+            return;
+        }
+        pending.resolve(msg.result);
+    }
+}
+function toOneLineJson(value) {
+    try {
+        const raw = JSON.stringify(value);
+        if (!raw)
+            return "";
+        return raw.length > 1000
+            ? raw.slice(0, 1000) + "...(truncated)"
+            : raw;
+    }
+    catch {
+        return "";
+    }
+}

package/dist/codex/memory.js

@@ -0,0 +1,61 @@
+const threadMeta = new Map();
+const threadMessages = new Map();
+export function recordThreadMeta(id, cwd, title) {
+    if (!id)
+        return;
+    const prev = threadMeta.get(id);
+    threadMeta.set(id, {
+        id,
+        cwd: cwd || prev?.cwd || "",
+        title: (title || prev?.title || "Codex session").slice(0, 64),
+        updatedAt: Date.now(),
+    });
+}
+export function appendThreadMessage(id, role, text) {
+    if (!id || !text.trim())
+        return;
+    const arr = threadMessages.get(id) ?? [];
+    arr.push({ role, text: text.trim(), ts: Date.now() });
+    if (arr.length > 80)
+        arr.splice(0, arr.length - 80);
+    threadMessages.set(id, arr);
+    const meta = threadMeta.get(id);
+    if (meta) {
+        meta.updatedAt = Date.now();
+    }
+}
+export function listInMemorySessions(cwd) {
+    return Array.from(threadMeta.values())
+        .filter((m) => !cwd || m.cwd === cwd)
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, 10)
+        .map((m) => ({
+        id: m.id,
+        title: m.title || "Codex session",
+        timestamp: new Date(m.updatedAt).toISOString(),
+        cwd: m.cwd || "",
+    }));
+}
+export function getInMemoryHistory(threadId, limit) {
+    const rows = threadMessages.get(threadId) ?? [];
+    if (rows.length === 0)
+        return [];
+    const rounds = [];
+    let cur = [];
+    for (const m of rows) {
+        if (m.role === "user") {
+            if (cur.length > 0)
+                rounds.push(cur);
+            cur = [{ role: "user", text: m.text }];
+        }
+        else {
+            cur.push({ role: "assistant", text: m.text });
+        }
+    }
+    if (cur.length > 0)
+        rounds.push(cur);
+    return rounds
+        .slice(-limit)
+        .flat()
+        .map((m) => ({ role: m.role, text: m.text.slice(0, 800) }));
+}