ever-terminal 1.0.0

package/dist/routes/core.js

@@ -0,0 +1,290 @@
+import { Router } from "express";
+import { getDefaultProvider, isProvider, parseProvider, SUPPORTED_PROVIDERS, } from "../session.js";
+import { broadcast, pushMessage, getMessages } from "./events.js";
+import { createClaudeProvider } from "../claude/provider.js";
+import { createCodexProvider } from "../codex/provider.js";
+import { CodexAppServerClient } from "../codex/app-server.js";
+import { debugLog } from "../debug.js";
+import { CODEX_APP_SERVER_PORT, ensureCodexAppServerStarted, } from "../startup/common.js";
+import { checkForUpdate, getCurrentAppVersion } from "../update.js";
+const router = Router();
+const emit = (sessionId, msg) => {
+    if (!sessionId)
+        return;
+    const id = pushMessage(sessionId, msg);
+    broadcast(sessionId, msg, id);
+};
+const STATUS_CHECK_COUNT = 10;
+function toOneLineJson(value, maxLen = 1200) {
+    try {
+        const text = JSON.stringify(value);
+        if (!text)
+            return String(value);
+        return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
+    }
+    catch {
+        return String(value);
+    }
+}
+const codexClient = new CodexAppServerClient(`ws://127.0.0.1:${CODEX_APP_SERVER_PORT}`);
+const claudeProvider = createClaudeProvider(emit);
+const codexProvider = createCodexProvider(emit, () => codexClient);
+const providerRegistry = {
+    claude: claudeProvider,
+    codex: codexProvider,
+};
+export { codexClient };
+export function getProvider(name) {
+    const resolved = name ? parseProvider(name) : getDefaultProvider();
+    const handlers = providerRegistry[resolved];
+    if (!handlers)
+        throw new Error(`No handlers registered for provider "${resolved}"`);
+    return handlers;
+}
+router.use((req, res, next) => {
+    for (const provider of [
+        req.query.provider,
+        req.body?.provider,
+    ]) {
+        if (provider !== undefined && !isProvider(provider)) {
+            res.status(400).json({
+                error: `Unsupported provider "${String(provider)}". Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}`,
+            });
+            return;
+        }
+    }
+    next();
+});
+// GET /api/sessions — list resumable sessions
+router.get("/sessions", async (req, res) => {
+    const providerName = req.query.provider;
+    const resolvedProvider = providerName
+        ? parseProvider(providerName)
+        : getDefaultProvider();
+    const cwd = req.query.cwd ||
+        (resolvedProvider === "codex" ? undefined : process.env.PROJECT_DIR);
+    const provider = getProvider(resolvedProvider);
+    const limit = Number(req.query.limit) || 10;
+    try {
+        const sessions = await provider.listSessions(limit, cwd);
+        await Promise.all(sessions.slice(0, STATUS_CHECK_COUNT).map(async (s, i) => {
+            if (s.status)
+                return;
+            sessions[i].status = await provider.getSessionStatus(s.id);
+        }));
+        res.json({ sessions });
+    }
+    catch (err) {
+        res.json({ sessions: [], error: err.message });
+    }
+});
+// GET /api/info — account, model, version, provider
+router.get("/info", async (req, res) => {
+    const providerName = req.query.provider;
+    const provider = getProvider(providerName);
+    try {
+        const info = await provider.getInfo();
+        res.json(info);
+    }
+    catch (err) {
+        res.json({
+            account: {},
+            model: "Unknown",
+            version: "Unknown",
+            error: err.message,
+        });
+    }
+});
+// GET /api/update-check — current app version and latest npm version
+router.get("/update-check", async (_req, res) => {
+    try {
+        res.json(await checkForUpdate());
+    }
+    catch (err) {
+        res.json({
+            ...getCurrentAppVersion(),
+            newestVersion: null,
+            updateAvailable: null,
+            error: err.message,
+        });
+    }
+});
+// POST /api/prompt — send a prompt to a session (create if needed)
+router.post("/prompt", async (req, res) => {
+    const { text, sessionId, provider, cwd } = req.body ?? {};
+    console.log(`[prompt] sessionId=${sessionId ?? "(none)"} (provider=${provider}) text=${(text || "").slice(0, 80)}`);
+    if (!text || typeof text !== "string") {
+        console.warn("[prompt] rejected: missing text field");
+        res.status(400).json({ error: "Missing 'text' field" });
+        return;
+    }
+    try {
+        const p = provider || getDefaultProvider();
+        const targetProvider = getProvider(p);
+        const result = await targetProvider.prompt(sessionId, text, cwd);
+        res.status(202).json({
+            ok: true,
+            sessionId: result.sessionId,
+            provider: result.provider,
+        });
+    }
+    catch (err) {
+        console.error("[prompt] failed:", err.message);
+        const statusCode = typeof err.statusCode === "number" ? err.statusCode : 500;
+        res.status(statusCode).json({ error: err.message });
+    }
+});
+// POST /api/permission-response
+router.post("/permission-response", (req, res) => {
+    const { sessionId, decision, provider } = req.body ?? {};
+    console.log(`[permission-response] sessionId=${sessionId ?? "(none)"} provider=${provider ?? "(default)"} decision=${decision ?? "deny"}`);
+    debugLog("api", "permission-response body", toOneLineJson(req.body ?? {}));
+    if (!sessionId) {
+        res.status(400).json({ error: "Missing 'sessionId'" });
+        return;
+    }
+    const targetProvider = getProvider(provider);
+    if (!targetProvider.getStatus(sessionId)) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+    }
+    targetProvider.respondPermission(sessionId, decision || "deny");
+    res.json({ ok: true });
+});
+// POST /api/question-response
+router.post("/question-response", (req, res) => {
+    const { sessionId, answer, provider } = req.body ?? {};
+    console.log(`[question-response] sessionId=${sessionId ?? "(none)"} provider=${provider ?? "(default)"} answer=${String(answer ?? "skip").slice(0, 120)}`);
+    debugLog("api", "question-response body", toOneLineJson(req.body ?? {}));
+    if (!sessionId) {
+        res.status(400).json({ error: "Missing 'sessionId'" });
+        return;
+    }
+    const targetProvider = getProvider(provider);
+    if (!targetProvider.getStatus(sessionId)) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+    }
+    targetProvider.respondQuestion(sessionId, answer || "skip");
+    res.json({ ok: true });
+});
+// POST /api/interrupt
+router.post("/interrupt", (req, res) => {
+    const { sessionId, provider } = req.body ?? {};
+    if (!sessionId) {
+        res.status(400).json({ error: "Missing 'sessionId'" });
+        return;
+    }
+    const targetProvider = getProvider(provider);
+    if (!targetProvider.getStatus(sessionId)) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+    }
+    targetProvider.interrupt(sessionId);
+    res.json({ ok: true });
+});
+// GET /api/status
+router.get("/status", (req, res) => {
+    const sessionId = req.query.sessionId;
+    const providerName = req.query.provider;
+    if (!sessionId) {
+        res.status(400).json({ error: "Missing 'sessionId'" });
+        return;
+    }
+    const status = getProvider(providerName).getStatus(sessionId);
+    if (!status) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+    }
+    res.json({
+        state: status.state,
+        sessionId,
+        provider: status.provider,
+    });
+});
+// GET /api/messages?sessionId=&after=
+router.get("/messages", (req, res) => {
+    const after = parseInt(req.query.after) || 0;
+    const sessionId = req.query.sessionId;
+    const providerName = req.query.provider;
+    if (!sessionId) {
+        res.status(400).json({ error: "Missing 'sessionId'" });
+        return;
+    }
+    const status = getProvider(providerName).getStatus(sessionId);
+    const messages = getMessages(sessionId, after);
+    res.json({
+        messages,
+        state: status?.state ?? "idle",
+        sessionId,
+        provider: status?.provider ?? providerName ?? null,
+    });
+});
+// GET /api/debug/thread/:id — raw app-server / SDK output for debugging
+router.get("/debug/thread/:id", async (req, res) => {
+    const id = req.params.id;
+    const provider = req.query.provider || getDefaultProvider();
+    try {
+        if (provider === "codex") {
+            const thread = await codexClient.threadRead(id, true);
+            res.json(thread);
+        }
+        else if (provider === "claude") {
+            const { getSessionMessages } = await import("@anthropic-ai/claude-agent-sdk");
+            const messages = await getSessionMessages(id);
+            res.json({ sessionId: id, messages });
+        }
+        else {
+            const history = await getProvider(provider).getHistory(id, 50);
+            res.json({ sessionId: id, messages: history });
+        }
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// GET /api/debug/status/:id — test status detection against real data
+router.get("/debug/status/:id", async (req, res) => {
+    const id = req.params.id;
+    const providerName = req.query.provider || getDefaultProvider();
+    const provider = getProvider(providerName);
+    try {
+        const status = await provider.getSessionStatus(id);
+        res.json({ sessionId: id, provider: providerName, status });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// GET /api/sessions/:id/history
+router.get("/sessions/:id/history", async (req, res) => {
+    const id = req.params.id;
+    const limit = Math.min(parseInt(req.query.limit) || 10, 10);
+    const providerName = req.query.provider || getDefaultProvider();
+    const provider = getProvider(providerName);
+    try {
+        const history = await provider.getHistory(id, limit);
+        res.json({ history });
+    }
+    catch (err) {
+        res.json({ history: [], error: err.message });
+    }
+});
+// GET /api/metrics — codex subscription state for monitoring
+router.get("/metrics", (_req, res) => {
+    const subscribed = codexProvider.getSubscribedSessions();
+    res.json({ codex: { subscribedSessions: subscribed } });
+});
+// POST /api/codex/ensure-app-server — wake the lazy codex app-server.
+router.post("/codex/ensure-app-server", async (_req, res) => {
+    try {
+        const started = await ensureCodexAppServerStarted();
+        res.json({ started, port: CODEX_APP_SERVER_PORT });
+    }
+    catch (err) {
+        res
+            .status(500)
+            .json({ started: false, error: err?.message ?? String(err) });
+    }
+});
+export default router;

package/dist/routes/events.js

@@ -0,0 +1,104 @@
+import { Router } from "express";
+import { writeToLogFile } from "../logger.js";
+const router = Router();
+// ── Per-session message ring buffer + SSE clients ────
+const MAX_MESSAGES_PER_SESSION = 500;
+const sessions = new Map();
+function getSession(sessionId) {
+    let s = sessions.get(sessionId);
+    if (!s) {
+        s = { messages: [], clients: new Set(), nextId: 1 };
+        sessions.set(sessionId, s);
+    }
+    return s;
+}
+export function pushMessage(sessionId, msg) {
+    const s = getSession(sessionId);
+    const id = s.nextId++;
+    s.messages.push({ id, msg });
+    if (s.messages.length > MAX_MESSAGES_PER_SESSION) {
+        s.messages.shift();
+    }
+    return id;
+}
+export function getMessages(sessionId, after) {
+    const s = sessions.get(sessionId);
+    if (!s)
+        return [];
+    return s.messages
+        .filter((m) => m.id > after)
+        .map((m) => ({ id: m.id, ...m.msg }));
+}
+export function broadcast(sessionId, msg, id) {
+    const s = sessions.get(sessionId);
+    const data = JSON.stringify(msg);
+    if (process.env.VERBOSE === "1") {
+        console.log(`[SSE-${sessionId}]: ${data}`);
+    }
+    else {
+        writeToLogFile(`[SSE-${sessionId}]: ${data}`);
+    }
+    if (!s || s.clients.size === 0)
+        return;
+    let deadCount = 0;
+    for (const res of s.clients) {
+        try {
+            res.write(`id: ${id}\ndata: ${data}\n\n`);
+        }
+        catch {
+            s.clients.delete(res);
+            deadCount++;
+        }
+    }
+    if (deadCount > 0) {
+        console.warn(`[sse] Removed ${deadCount} dead client(s) for session=${sessionId} (remaining: ${s.clients.size})`);
+    }
+}
+export function clientCount() {
+    let total = 0;
+    for (const s of sessions.values())
+        total += s.clients.size;
+    return total;
+}
+export function sessionHasClients(sessionId) {
+    const s = sessions.get(sessionId);
+    return !!s && s.clients.size > 0;
+}
+router.get("/events", (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId) {
+        res.status(400).json({ error: "Missing 'sessionId' query parameter" });
+        return;
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    res.write(":ok\n\n");
+    const s = getSession(sessionId);
+    if (req.query.needReplay === "true" && s.messages.length > 0) {
+        // Replay buffered messages for this session
+        for (const entry of s.messages) {
+            res.write(`id: ${entry.id}\ndata: ${JSON.stringify(entry.msg)}\n\n`);
+        }
+    }
+    s.clients.add(res);
+    console.log(`[sse] Client connected session=${sessionId} (session clients: ${s.clients.size}, total: ${clientCount()})`);
+    // Heartbeat every 15s
+    const heartbeat = setInterval(() => {
+        try {
+            res.write(":heartbeat\n\n");
+        }
+        catch {
+            clearInterval(heartbeat);
+            s.clients.delete(res);
+        }
+    }, 15000);
+    req.on("close", () => {
+        clearInterval(heartbeat);
+        s.clients.delete(res);
+        console.log(`[sse] Client disconnected (total: ${clientCount()})`);
+    });
+});
+export default router;

package/dist/session.js

@@ -0,0 +1,18 @@
+// ── Provider ────────────────────────────────────────────
+// cursor/opencode are experimental and hidden in 0.8.1 — re-add them here to re-enable.
+export const SUPPORTED_PROVIDERS = ["claude", "codex"];
+export function isProvider(value) {
+    return typeof value === "string" && SUPPORTED_PROVIDERS.includes(value);
+}
+export function parseProvider(value, label = "provider") {
+    if (isProvider(value))
+        return value;
+    throw new Error(`Unsupported ${label} "${String(value)}". Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}`);
+}
+/** Global default provider, read once from env. */
+export function getDefaultProvider() {
+    const env = process.env.DEFAULT_PROVIDER;
+    if (!env)
+        return "claude";
+    return parseProvider(env, "DEFAULT_PROVIDER");
+}