ever-terminal 1.0.0

package/dist/codex/status.js

@@ -0,0 +1,16 @@
+export function codexThreadStatus(thread) {
+    const statusType = String(thread?.status?.type ?? thread?.status ?? "");
+    if (statusType === "active")
+        return "busy";
+    if (statusType === "waitingOnApproval" ||
+        statusType === "waitingOnUserInput")
+        return "awaiting";
+    if (statusType === "idle" ||
+        statusType === "completed" ||
+        statusType === "archived")
+        return "idle";
+    const turns = Array.isArray(thread?.turns) ? thread.turns : [];
+    if (turns.length === 0)
+        return "idle";
+    return turns[turns.length - 1]?.completedAt != null ? "idle" : "busy";
+}

package/dist/codex/storage.js

@@ -0,0 +1,83 @@
+import { codexThreadStatus } from "./status.js";
+import { debugLog } from "../debug.js";
+export async function listCodexSessions(client, limit, cwd) {
+    const result = await client.threadList({
+        limit,
+        ...(cwd ? { cwd } : {}),
+        archived: false,
+        sortKey: "updated_at",
+    });
+    return result.data.slice(0, 10).map((t) => ({
+        id: String(t.id ?? ""),
+        title: String(t.name ?? t.preview ?? "Codex session").slice(0, 64),
+        timestamp: new Date(Number(t.updatedAt ?? t.createdAt ?? Date.now() / 1000) * 1000).toISOString(),
+        cwd: String(t.cwd ?? ""),
+        status: codexThreadStatus(t),
+    }));
+}
+const MAX_HISTORY_ITEMS = 10;
+// Turns fetched per page. Independent of `limit`; correctness comes from the
+// pagination loop, this constant only paces it.
+const TURNS_PAGE_SIZE = 10;
+export async function getCodexSessionHistory(client, sessionId, limit) {
+    const t0 = Date.now();
+    const returnCount = Math.min(limit, MAX_HISTORY_ITEMS);
+    const messages = [];
+    let cursor = undefined;
+    let pages = 0;
+    let scannedTurns = 0;
+    let scannedItems = 0;
+    outer: while (messages.length < returnCount) {
+        const page = await client.threadTurnsList({
+            threadId: sessionId,
+            limit: TURNS_PAGE_SIZE,
+            sortDirection: "desc",
+            itemsView: "full",
+            ...(cursor ? { cursor } : {}),
+        });
+        pages++;
+        for (const turn of page.data) {
+            scannedTurns++;
+            const items = Array.isArray(turn?.items)
+                ? [...turn.items].reverse()
+                : [];
+            for (const item of items) {
+                scannedItems++;
+                if (item?.type === "userMessage") {
+                    const text = extractUserMessageText(item);
+                    if (text)
+                        messages.push({ role: "user", text });
+                }
+                else if (item?.type === "agentMessage") {
+                    const text = extractAgentMessageText(item);
+                    if (text)
+                        messages.push({ role: "assistant", text });
+                }
+                if (messages.length >= returnCount)
+                    break outer;
+            }
+        }
+        if (!page.nextCursor || page.data.length === 0)
+            break;
+        cursor = page.nextCursor;
+    }
+    const result = messages.slice(0, returnCount).reverse();
+    const tEnd = Date.now();
+    debugLog("codex-history", `sessionId=${sessionId} totalMs=${tEnd - t0} pages=${pages} scannedTurns=${scannedTurns} scannedItems=${scannedItems} extracted=${messages.length} returned=${result.length}`);
+    return result;
+}
+function extractUserMessageText(item) {
+    const content = Array.isArray(item?.content) ? item.content : [];
+    const parts = [];
+    for (const c of content) {
+        if (c?.type === "text" && typeof c?.text === "string" && c.text.trim()) {
+            parts.push(c.text.trim());
+        }
+    }
+    return parts.join("\n").trim();
+}
+function extractAgentMessageText(item) {
+    if (typeof item?.text === "string" && item.text.trim())
+        return item.text.trim();
+    return "";
+}

package/dist/codex/summarize.js

@@ -0,0 +1,69 @@
+import { truncate } from "../summary-format.js";
+export function mapCodexItemTypeToToolName(type) {
+    switch (type) {
+        case "commandExecution":
+            return "Shell";
+        case "fileChange":
+            return "FileEdit";
+        case "mcpToolCall":
+            return "Mcp";
+        case "dynamicToolCall":
+            return "Tool";
+        case "webSearch":
+            return "WebSearch";
+        case "imageView":
+            return "ImageView";
+        case "imageGeneration":
+            return "ImageGeneration";
+        case "collabAgentToolCall":
+            return "Agent";
+        default:
+            return String(type ?? "Tool");
+    }
+}
+export function summarizeCodexItem(item) {
+    const type = String(item?.type ?? "tool");
+    if (type === "commandExecution") {
+        const cmd = String(item?.command ?? "").trim();
+        return cmd ? `Shell ${truncate(cmd, 50)}` : "Shell command";
+    }
+    if (type === "fileChange") {
+        const changes = Array.isArray(item?.changes) ? item.changes.length : 0;
+        return changes > 0 ? `FileEdit (${changes} files)` : "FileEdit";
+    }
+    if (type === "webSearch") {
+        const q = String(item?.query ?? "").trim();
+        return q ? `Search "${truncate(q, 40)}"` : "Web search";
+    }
+    return mapCodexItemTypeToToolName(type);
+}
+export function summarizeCodexRequest(params, method) {
+    if (method.includes("commandExecution") ||
+        method === "execCommandApproval") {
+        const cmd = typeof params?.command === "string"
+            ? params.command
+            : Array.isArray(params?.command)
+                ? params.command.join(" ")
+                : "";
+        return cmd ? `Shell ${truncate(cmd, 50)}` : "Run command";
+    }
+    if (method.includes("fileChange") || method === "applyPatchApproval") {
+        return "Apply file changes";
+    }
+    if (method.includes("permissions")) {
+        return "Request additional permissions";
+    }
+    return method;
+}
+export function mapCodexRequestMethodToToolName(method) {
+    if (method.includes("commandExecution") ||
+        method === "execCommandApproval")
+        return "Shell";
+    if (method.includes("fileChange") || method === "applyPatchApproval")
+        return "FileEdit";
+    if (method.includes("permissions"))
+        return "Config";
+    if (method.includes("mcp"))
+        return "Mcp";
+    return "Tool";
+}

package/dist/debug.js

@@ -0,0 +1,9 @@
+import { writeToLogFile } from "./logger.js";
+export function debugLog(tag, ...args) {
+    if (process.env.VERBOSE === "1") {
+        console.log(`[${tag}]`, ...args);
+    }
+    else {
+        writeToLogFile(`[${tag}]`, ...args);
+    }
+}

package/dist/expose/providers/bore.js

@@ -0,0 +1,14 @@
+const provider = {
+    name: "bore",
+    program: "bore",
+    buildArgs(port) {
+        return ["local", String(port), "--to", "bore.pub"];
+    },
+    parseUrl(output) {
+        const match = output.match(/\blistening at\s+bore\.pub:(\d+)\b/i);
+        if (!match)
+            return undefined;
+        return "http://bore.pub:" + match[1];
+    },
+};
+export default provider;

package/dist/expose/providers/ngrok.js

@@ -0,0 +1,35 @@
+const provider = {
+    name: "ngrok",
+    program: "ngrok",
+    buildArgs(port) {
+        return ["http", String(port), "--log=stdout", "--log-format=json"];
+    },
+    parseUrl(output) {
+        for (const line of output.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let event;
+            try {
+                event = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (!event || typeof event !== "object")
+                continue;
+            const record = event;
+            if (!("addr" in record))
+                continue;
+            const url = record.url;
+            if (typeof url !== "string")
+                continue;
+            if (!/^https?:\/\/[^/]+\.ngrok[^/]*/.test(url))
+                continue;
+            return url;
+        }
+        return undefined;
+    },
+    failureHint: "ngrok requires a free account and authtoken. Sign up at https://dashboard.ngrok.com/signup, then run: ngrok config add-authtoken <YOUR_TOKEN>",
+};
+export default provider;

package/dist/expose/providers/pinggy.js

@@ -0,0 +1,22 @@
+const provider = {
+    name: "pinggy",
+    program: "ssh",
+    buildArgs(port) {
+        return [
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-p",
+            "443",
+            "-R0:localhost:" + String(port),
+            "a.pinggy.io",
+        ];
+    },
+    parseUrl(output) {
+        const httpsMatch = output.match(/https:\/\/[^\s]+\.pinggy(?:-free)?\.link/);
+        if (httpsMatch)
+            return httpsMatch[0];
+        const httpMatch = output.match(/http:\/\/[^\s]+\.pinggy(?:-free)?\.link/);
+        return httpMatch?.[0];
+    },
+};
+export default provider;

package/dist/expose/registry.js

@@ -0,0 +1,22 @@
+import bore from "./providers/bore.js";
+import ngrok from "./providers/ngrok.js";
+import pinggy from "./providers/pinggy.js";
+const providers = [pinggy, bore, ngrok];
+function ensureValidExposeProviders(list) {
+    for (const provider of list) {
+        if (!/^[A-Za-z][A-Za-z0-9]*$/.test(provider.name)) {
+            console.error(`[expose] invalid provider name "${provider.name}". Provider names must start with a letter and then contain only letters or digits.`);
+            process.exit(1);
+        }
+    }
+}
+ensureValidExposeProviders(providers);
+export function getExposeProviders() {
+    return providers.slice();
+}
+export function getExposeProviderNames() {
+    return providers.map((provider) => provider.name);
+}
+export function getExposeProvider(name) {
+    return providers.find((provider) => provider.name === name);
+}

package/dist/expose/run.js

@@ -0,0 +1,75 @@
+import { getExposeProvider } from "./registry.js";
+import { buildClientQuery, printQRCode, rawLog } from "../startup/common.js";
+import { spawnShim } from "../util/spawn-shim.js";
+function getSelectedExposeProviderName() {
+    return process.env.EVER_TERMINAL_EXPOSE_PROVIDER;
+}
+function getProviderProgramPathEnvName(provider) {
+    return provider.name.toUpperCase() + "_PROGRAM_PATH";
+}
+function getProviderProgram(provider) {
+    return process.env[getProviderProgramPathEnvName(provider)] || provider.program;
+}
+function attachCleanup(child) {
+    const cleanup = () => {
+        if (!child.killed)
+            child.kill();
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => {
+        cleanup();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+    });
+}
+export function startExposeProvider(port, token) {
+    const providerName = getSelectedExposeProviderName();
+    if (!providerName)
+        return;
+    const provider = getExposeProvider(providerName);
+    if (!provider) {
+        console.error(`error: unknown expose provider "${providerName}"`);
+        process.exit(1);
+    }
+    const program = getProviderProgram(provider);
+    const programPathEnvName = getProviderProgramPathEnvName(provider);
+    const child = spawnShim(program, provider.buildArgs(port), {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let foundUrl = false;
+    let buffer = "";
+    const handleOutput = (chunk) => {
+        buffer += chunk.toString();
+        const parsedUrl = provider.parseUrl(buffer);
+        if (!parsedUrl || foundUrl)
+            return;
+        foundUrl = true;
+        const fullUrl = `${parsedUrl}?${buildClientQuery(token).toString()}`;
+        rawLog("");
+        rawLog(`  Public expose (${provider.name}):  ${parsedUrl}`);
+        rawLog("");
+        rawLog(`  ${fullUrl}`);
+        printQRCode(fullUrl, () => rawLog(""));
+    };
+    rawLog(`  Starting quick public expose via ${provider.name}...`);
+    child.stdout.on("data", handleOutput);
+    child.stderr.on("data", handleOutput);
+    child.on("error", (err) => {
+        console.error(`  Failed to start ${provider.name}: ${err.message}`);
+        console.error(`  Checked program: ${program}`);
+        console.error(`  Override with ${programPathEnvName}=... if needed.`);
+        if (provider.failureHint)
+            console.error(`  Hint: ${provider.failureHint}`);
+    });
+    child.on("exit", (code) => {
+        if (code !== null && code !== 0 && !foundUrl) {
+            console.error(`  ${provider.name} exited with code ${code}`);
+            if (provider.failureHint)
+                console.error(`  Hint: ${provider.failureHint}`);
+        }
+    });
+    attachCleanup(child);
+}

package/dist/expose/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,78 @@
+import { randomBytes } from "node:crypto";
+import express from "express";
+import cors from "cors";
+import eventsRouter from "./routes/events.js";
+import coreRouter from "./routes/core.js";
+import { CODEX_APP_SERVER_PORT, printServerBanner, stopCodexAppServer, } from "./startup/common.js";
+import { removeInstancePidfile, writeInstancePidfile, } from "./startup/instance.js";
+import { startExposeProvider } from "./expose/run.js";
+import { installTimestampLogging } from "./logger.js";
+// ── Config ─────────────────────────────────────────────
+const PORT = parseInt(process.env.PORT ?? "3456", 10);
+const TOKEN = process.env.BRIDGE_TOKEN ?? randomBytes(16).toString("hex");
+// ── App ────────────────────────────────────────────────
+const app = express();
+app.use(cors());
+app.use((req, res, next) => {
+    const startedAt = process.hrtime.bigint();
+    res.on("finish", () => {
+        const durationMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000;
+        console.log(`[${req.ip}] ${res.statusCode} ${req.method} ${req.originalUrl} ${durationMs.toFixed(1)}ms`);
+    });
+    next();
+});
+app.use(express.json({ limit: "10mb" }));
+// ── Auth middleware ────────────────────────────────────
+function auth(req, res, next) {
+    const header = req.headers.authorization;
+    const queryToken = req.query.token;
+    const provided = header?.startsWith("Bearer ")
+        ? header.slice(7)
+        : queryToken;
+    if (provided !== TOKEN) {
+        console.warn(`[auth] 401 ${req.method} ${req.url} (ip=${req.ip})`);
+        res.status(401).json({ error: "Unauthorized" });
+        return;
+    }
+    next();
+}
+// ── Routes ─────────────────────────────────────────────
+app.use("/api", auth, eventsRouter);
+app.use("/api", auth, coreRouter);
+// ── Start ──────────────────────────────────────────────
+app.listen(PORT, "0.0.0.0", () => {
+    printServerBanner(PORT, TOKEN, process.env.PROJECT_DIR || process.cwd(), true);
+    try {
+        writeInstancePidfile({
+            port: PORT,
+            token: TOKEN,
+            cwd: process.env.PROJECT_DIR || process.cwd(),
+            codexAppServerPort: CODEX_APP_SERVER_PORT,
+        });
+    }
+    catch (err) {
+        console.error(`[server] WARN: failed to write instance pidfile: ${err?.message}`);
+    }
+    startExposeProvider(PORT, TOKEN);
+    installTimestampLogging();
+});
+// ── Process-level error handlers ──────────────────────
+process.on("uncaughtException", (err) => {
+    console.error(`[server] UNCAUGHT EXCEPTION: ${err.message}\n${err.stack}`);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error(`[server] UNHANDLED REJECTION: ${reason}`);
+});
+function shutdown() {
+    stopCodexAppServer();
+    removeInstancePidfile();
+}
+process.on("exit", shutdown);
+process.on("SIGINT", () => {
+    shutdown();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    shutdown();
+    process.exit(0);
+});

package/dist/logger.js

@@ -0,0 +1,44 @@
+import { createWriteStream } from "node:fs";
+import { format } from "node:util";
+const methods = ["log", "info", "warn", "error", "debug"];
+let installed = false;
+let fileStream = null;
+function ts() {
+    return new Date().toLocaleString("sv");
+}
+function getLogFilePath() {
+    const i = process.argv.indexOf("--log-file");
+    return i >= 0 ? process.argv[i + 1] : undefined;
+}
+/** Write directly to log file only (bypass console). Used by debugLog to
+ *  always capture verbose output in the log file regardless of VERBOSE flag. */
+export function writeToLogFile(...args) {
+    if (fileStream)
+        fileStream.write(format(`[${ts()}]`, ...args) + "\n");
+}
+/** Monkey-patch console.* to prepend an ISO timestamp. If --log-file is on
+ *  argv, also tee every line to that file. */
+export function installTimestampLogging() {
+    if (installed)
+        return;
+    installed = true;
+    const logFile = getLogFilePath();
+    if (logFile) {
+        try {
+            fileStream = createWriteStream(logFile, { flags: "a" });
+            console.log(`[server] Logging to ${logFile}`);
+        }
+        catch (err) {
+            console.error(`error: failed to open log file ${logFile}: ${err.message}`);
+        }
+    }
+    for (const m of methods) {
+        const orig = console[m].bind(console);
+        console[m] = (...args) => {
+            const stamp = `[${ts()}]`;
+            orig(stamp, ...args);
+            if (fileStream)
+                fileStream.write(format(stamp, ...args) + "\n");
+        };
+    }
+}