ever-terminal 1.0.0

package/dist/startup/common.js

@@ -0,0 +1,318 @@
+import { networkInterfaces } from "node:os";
+import { createServer } from "node:net";
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import qrcodeTerminal from "qrcode-terminal";
+import { getDefaultProvider } from "../session.js";
+import { spawnShim } from "../util/spawn-shim.js";
+export const CODEX_APP_SERVER_PORT = parseInt(process.env.CODEX_APP_SERVER_PORT || "8765", 10);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, "../../package.json"), "utf8"));
+export function getLanAddress() {
+    const nets = networkInterfaces();
+    for (const ifaces of Object.values(nets)) {
+        for (const iface of ifaces ?? []) {
+            if (iface.family === "IPv4" && !iface.internal)
+                return iface.address;
+        }
+    }
+}
+function getTailscaleIp() {
+    try {
+        const out = execSync("tailscale ip -4", {
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 3000,
+        })
+            .toString()
+            .trim();
+        const first = out.split("\n")[0]?.trim();
+        return first || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getInterfaceIp(name) {
+    const ifaces = networkInterfaces()[name];
+    if (!ifaces)
+        return undefined;
+    for (const iface of ifaces) {
+        if (iface.family === "IPv4")
+            return iface.address;
+    }
+    return undefined;
+}
+/** Resolve host based on EVER_HOST_MODE / EVER_HOST_INTERFACE; exits on failure. */
+export function resolveHost() {
+    const mode = process.env.EVER_HOST_MODE;
+    if (mode === "tailscale") {
+        const ip = getTailscaleIp();
+        if (!ip) {
+            console.error("error: failed to get Tailscale IPv4 address (is `tailscale` installed and running?)");
+            process.exit(1);
+        }
+        return { label: "Tailscale", address: ip };
+    }
+    if (mode === "interface") {
+        const name = process.env.EVER_HOST_INTERFACE ?? "";
+        if (!name) {
+            console.error("error: --interface requires a name");
+            process.exit(1);
+        }
+        const ip = getInterfaceIp(name);
+        if (!ip) {
+            console.error(`error: failed to get IPv4 address for interface "${name}"`);
+            process.exit(1);
+        }
+        return { label: name, address: ip };
+    }
+    return { label: "LAN", address: getLanAddress() ?? "" };
+}
+export function truncPath(p, max) {
+    if (p.length <= max)
+        return p;
+    return "..." + p.slice(-(max - 3));
+}
+function detectColorLevel() {
+    const { TERM, COLORTERM } = process.env;
+    if (!process.stdout.isTTY)
+        return "none";
+    if (TERM === "dumb")
+        return "none";
+    if (COLORTERM === "truecolor" || COLORTERM === "24bit")
+        return "truecolor";
+    if (TERM && /-256(color)?$/i.test(TERM))
+        return "ansi256";
+    if (TERM && /color|xterm|screen|vt100|ansi|cygwin|linux/i.test(TERM))
+        return "basic";
+    return "none";
+}
+function wrapQrColors(code, level) {
+    let bg;
+    let fg;
+    switch (level) {
+        case "truecolor":
+            bg = "\x1b[48;2;0;0;0m";
+            fg = "\x1b[38;2;255;255;255m";
+            break;
+        case "ansi256":
+            bg = "\x1b[48;5;16m";
+            fg = "\x1b[38;5;231m";
+            break;
+        case "basic":
+            bg = "\x1b[40m";
+            fg = "\x1b[37m";
+            break;
+        case "none":
+            return code;
+    }
+    const reset = "\x1b[0m";
+    const lines = code.split("\n");
+    while (lines.length && lines[0].trim() === "")
+        lines.shift();
+    while (lines.length && lines[lines.length - 1].trim() === "")
+        lines.pop();
+    return lines
+        .map((line, i) => {
+        const prefix = i === 0 && /^▄+$/.test(line) ? fg : `${bg}${fg}`;
+        return `${prefix}${line}${reset}`;
+    })
+        .join("\n");
+}
+/** Write directly to stdout, bypassing the timestamp-patched console.log.
+ *  Use this for visual output (banners, QR codes) that must not be prefixed. */
+export function rawLog(msg = "") {
+    process.stdout.write(msg + "\n");
+}
+export function printQRCode(str, afterCb) {
+    const level = detectColorLevel();
+    qrcodeTerminal.generate(str, { small: true }, (code) => {
+        rawLog(wrapQrColors(code, level));
+        if (afterCb)
+            afterCb();
+    });
+}
+let codexAppServerProcess = null;
+function isPortTakenError(text) {
+    return /\bEADDRINUSE\b|address already in use|addrinuse/i.test(text);
+}
+function canBindLocalPort(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        let settled = false;
+        const done = (available) => {
+            if (settled)
+                return;
+            settled = true;
+            server.close(() => resolve(available));
+        };
+        server.once("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                resolve(false);
+                return;
+            }
+            console.error(`[codex] WARN: Failed to bind-check port ${port}: ${err.message}`);
+            resolve(false);
+        });
+        server.once("listening", () => done(true));
+        server.listen(port, "127.0.0.1");
+    });
+}
+export async function startCodexAppServer() {
+    const listenUrl = `ws://127.0.0.1:${CODEX_APP_SERVER_PORT}`;
+    if (!(await canBindLocalPort(CODEX_APP_SERVER_PORT))) {
+        console.error(`[codex] ERROR: Port ${CODEX_APP_SERVER_PORT} appears to be in use. Set CODEX_APP_SERVER_PORT to another port and restart.`);
+        console.error(`[codex] ERROR: Codex app-server was not started.`);
+        console.error(`[codex] NOTE: This is harmless if you only intend to use Claude (or providers other than Codex).`);
+        return false;
+    }
+    return new Promise((resolve) => {
+        let resolved = false;
+        let started = false;
+        const done = () => {
+            if (!resolved) {
+                resolved = true;
+                resolve(started);
+            }
+        };
+        let stderrText = "";
+        let printedPortHint = false;
+        const printPortHint = (text) => {
+            if (printedPortHint || !isPortTakenError(text))
+                return;
+            printedPortHint = true;
+            console.error(`[codex] ERROR: Port ${CODEX_APP_SERVER_PORT} appears to be in use. Set CODEX_APP_SERVER_PORT to another port and restart.`);
+        };
+        let child;
+        try {
+            child = spawnShim("codex", ["app-server", "--listen", listenUrl], {
+                env: process.env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (err) {
+            console.error(`[codex] ERROR: Failed to spawn codex app-server: ${err.message}`);
+            console.error(`[codex] ERROR: Codex provider will not work in this environment.`);
+            console.error(`[codex] NOTE: This is harmless if you only intend to use Claude (or providers other than Codex).`);
+            done();
+            return;
+        }
+        child.on("error", (err) => {
+            console.error(`[codex] ERROR: Failed to start codex app-server: ${err.message}`);
+            printPortHint(err.message);
+            console.error(`[codex] ERROR: Codex provider will not work in this environment.`);
+            console.error(`[codex] NOTE: This is harmless if you only intend to use Claude (or providers other than Codex).`);
+            codexAppServerProcess = null;
+            done();
+        });
+        child.on("close", (code) => {
+            if (code !== null && code !== 0) {
+                console.error(`[codex] ERROR: codex app-server exited with code ${code}`);
+                printPortHint(stderrText);
+                console.error(`[codex] NOTE: This is harmless if you only intend to use Claude (or providers other than Codex).`);
+            }
+            codexAppServerProcess = null;
+            done();
+        });
+        child.stderr?.on("data", (data) => {
+            const text = data.toString().trim();
+            if (text) {
+                stderrText += `${text}\n`;
+                console.log(`[codex-app-server] ${text}`);
+                printPortHint(text);
+                if (text.includes("listening on:")) {
+                    started = true;
+                    done();
+                }
+            }
+        });
+        child.stdout?.on("data", (data) => {
+            const text = data.toString().trim();
+            if (text)
+                console.log(`[codex-app-server] ${text}`);
+        });
+        codexAppServerProcess = child;
+        console.log(`[codex] app-server starting on ${listenUrl}`);
+        // Fallback timeout in case we miss the ready signal
+        setTimeout(done, 5000);
+    });
+}
+export function stopCodexAppServer() {
+    if (codexAppServerProcess) {
+        codexAppServerProcess.kill();
+        codexAppServerProcess = null;
+    }
+}
+/**
+ * Spawn the codex app-server on first call (and re-spawn if it died). Concurrent
+ * callers share the same in-flight promise; on any settlement the cached promise
+ * is cleared so the next API call can retry.
+ */
+let codexAppServerStartPromise = null;
+export function ensureCodexAppServerStarted() {
+    if (codexAppServerProcess &&
+        codexAppServerProcess.exitCode === null &&
+        codexAppServerProcess.signalCode === null) {
+        return Promise.resolve(true);
+    }
+    if (codexAppServerStartPromise)
+        return codexAppServerStartPromise;
+    codexAppServerStartPromise = startCodexAppServer().finally(() => {
+        codexAppServerStartPromise = null;
+    });
+    return codexAppServerStartPromise;
+}
+export function buildClientQuery(token) {
+    const defaultProvider = getDefaultProvider();
+    const name = process.env.EVER_TERMINAL_NAME ?? "";
+    const params = new URLSearchParams({ token, defaultProvider });
+    if (name)
+        params.set("name", name);
+    return params;
+}
+export function printServerBanner(port, token, cwd, printQr) {
+    const host = resolveHost();
+    const name = process.env.EVER_TERMINAL_NAME ?? "";
+    const labelWidth = Math.max("Local".length, "Token".length, "Name".length, "CWD".length, host.label.length);
+    const pad = (s) => s.padEnd(labelWidth);
+    const logo = [
+        "██  ████████",
+        "████        ",
+        "██  ████████",
+        "████        ",
+        "██  ████████",
+    ];
+    const info = [
+        `Ever Terminal v${pkg.version}`,
+        name ? `${pad("Name")}:  ${name}` : "",
+        `${pad("Local")}:  http://localhost:${port}`,
+        host.address
+            ? `${pad(host.label)}:  http://${host.address}:${port}`
+            : "",
+        `${pad("Token")}:  ${token.slice(0, 8)}...${token.slice(-4)}`,
+        `${pad("CWD")}:  ${truncPath(cwd, 40)}`,
+        "",
+        "",
+    ];
+    const gap = "     ";
+    rawLog("");
+    for (let i = 0; i < Math.max(logo.length, info.length); i++) {
+        const logoLine = (logo[i] ?? "").padEnd(12);
+        rawLog(`  ${logoLine}${gap}${info[i] ?? ""}`);
+    }
+    rawLog("");
+    rawLog("  Made by Even Realities · Connect your terminal to G2 glasses");
+    rawLog("  " + "─".repeat(61));
+    rawLog("");
+    rawLog(`  Full token: ${token}`);
+    rawLog("");
+    const params = buildClientQuery(token);
+    const address = host.address || "localhost";
+    const url = `http://${address}:${port}?${params.toString()}`;
+    if (printQr && host.address) {
+        rawLog(url);
+        printQRCode(url, () => rawLog(""));
+    }
+}

package/dist/startup/instance.js

@@ -0,0 +1,89 @@
+import { homedir } from "node:os";
+import { mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+export const INSTANCE_DIR = join(homedir(), ".ever-terminal", "instances");
+function instanceFilePath(pid) {
+    return join(INSTANCE_DIR, `${pid}.json`);
+}
+export function writeInstancePidfile(info) {
+    mkdirSync(INSTANCE_DIR, { recursive: true });
+    const full = {
+        pid: process.pid,
+        platform: process.platform,
+        startedAt: Date.now(),
+        ...info,
+    };
+    const path = instanceFilePath(process.pid);
+    writeFileSync(path, JSON.stringify(full, null, 2), { mode: 0o600 });
+    return path;
+}
+export function removeInstancePidfile() {
+    try {
+        unlinkSync(instanceFilePath(process.pid));
+    }
+    catch {
+        // already gone — fine
+    }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err?.code === "EPERM";
+    }
+}
+/** List live instances; silently prunes stale pidfiles. */
+export function listLiveInstances() {
+    let entries;
+    try {
+        entries = readdirSync(INSTANCE_DIR);
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const live = [];
+    for (const name of entries) {
+        if (!name.endsWith(".json"))
+            continue;
+        const path = join(INSTANCE_DIR, name);
+        let info;
+        try {
+            info = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch {
+            try {
+                unlinkSync(path);
+            }
+            catch { }
+            continue;
+        }
+        if (typeof info.pid !== "number" || !isPidAlive(info.pid)) {
+            try {
+                unlinkSync(path);
+            }
+            catch { }
+            continue;
+        }
+        live.push(info);
+    }
+    // Newest first — handy for "most recent" fallbacks and stable display.
+    live.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
+    return live;
+}
+/** Best-effort age string (e.g. "3m", "2h"). */
+export function formatInstanceAge(startedAt) {
+    const secs = Math.max(0, Math.floor((Date.now() - startedAt) / 1000));
+    if (secs < 60)
+        return `${secs}s`;
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return `${mins}m`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
+}

package/dist/summary-format.js

@@ -0,0 +1,17 @@
+export function fileName(filePath) {
+    if (!filePath)
+        return "file";
+    const parts = filePath.split(/[\\/]/);
+    return parts[parts.length - 1] || filePath;
+}
+export function truncate(value, max) {
+    const text = oneLine(value);
+    if (!text)
+        return "";
+    return text.length > max ? text.slice(0, max) + "..." : text;
+}
+export function oneLine(value) {
+    if (value === null || value === undefined)
+        return "";
+    return String(value).replace(/\s+/g, " ").trim();
+}

package/dist/types.js

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

package/dist/update.js

@@ -0,0 +1,56 @@
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf8"));
+const NPM_REGISTRY_URL = "https://registry.npmjs.org";
+const FETCH_TIMEOUT_MS = 5000;
+function isNewerVersion(candidate, current) {
+    const candidateParts = candidate.split(".").map(Number);
+    const currentParts = current.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (candidateParts[i] !== currentParts[i])
+            return candidateParts[i] > currentParts[i];
+    }
+    return false;
+}
+async function fetchNewestVersion(packageName) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const url = `${NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
+        const response = await fetch(url, {
+            headers: { Accept: "application/vnd.npm.install-v1+json" },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`npm registry returned ${response.status}`);
+        }
+        const body = (await response.json());
+        const latest = body["dist-tags"]?.latest;
+        if (typeof latest !== "string" || latest.length === 0) {
+            throw new Error("npm registry response did not include dist-tags.latest");
+        }
+        return latest;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function checkForUpdate() {
+    const newestVersion = await fetchNewestVersion(pkg.name);
+    return {
+        packageName: pkg.name,
+        currentVersion: pkg.version,
+        newestVersion,
+        updateAvailable: isNewerVersion(newestVersion, pkg.version),
+        checkedAt: new Date().toISOString(),
+    };
+}
+export function getCurrentAppVersion() {
+    return {
+        packageName: pkg.name,
+        currentVersion: pkg.version,
+        checkedAt: new Date().toISOString(),
+    };
+}

package/dist/util/spawn-shim.js

@@ -0,0 +1,25 @@
+import { spawn, spawnSync, } from "node:child_process";
+// Cross-platform spawn that resolves PATHEXT-style shims (`foo.cmd`, `foo.bat`,
+// extensionless npm shims, etc.) on Windows by routing through `cmd.exe /c`.
+// POSIX uses `execvp`, which already searches PATH — no shell wrapper needed.
+//
+// Avoids `shell: true` + array args (DEP0190 in Node 22+, removed in Node 24),
+// while still letting Windows resolve PATHEXT correctly. Args here are passed
+// through Node's per-arg quoting (safer than shell-string concatenation).
+function windowsShimArgs(file, args) {
+    return { file: process.env.ComSpec || "cmd.exe", args: ["/c", file, ...args] };
+}
+export function spawnShim(file, args = [], opts = {}) {
+    if (process.platform === "win32") {
+        const w = windowsShimArgs(file, args);
+        return spawn(w.file, w.args, opts);
+    }
+    return spawn(file, args, opts);
+}
+export function spawnSyncShim(file, args = [], opts = {}) {
+    if (process.platform === "win32") {
+        const w = windowsShimArgs(file, args);
+        return spawnSync(w.file, w.args, opts);
+    }
+    return spawnSync(file, args, opts);
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "ever-terminal",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Ever Terminal — AI Coding CLI on Smart Glasses & Flutter App",
+  "license": "MIT",
+  "packageManager": "pnpm@10.33.3",
+  "keywords": [
+    "cli",
+    "claude-code",
+    "codex",
+    "ai-coding",
+    "smart-glasses",
+    "even-realities",
+    "terminal"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "ever-terminal": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "!dist/index-evenhub.js",
+    "!dist/routes/audio.js",
+    "!dist/asr.js",
+    "!dist/at-file.js",
+    "!dist/startup/evenhub.js"
+  ],
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "dev": "tsx watch src/index.ts",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build:evenhub": "rm -rf dist public && tsc -p tsconfig.build.json && pnpm run copy-frontend",
+    "build:bundle": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.mjs --packages=external",
+    "start:prod": "node dist/index.mjs",
+    "copy-frontend": "node -e \"const fs=require('fs');fs.cpSync('../frontend/dist','public',{recursive:true})\"",
+    "prepack": "pnpm run build",
+    "pack:evenhub": "V=$(node -p \"require('./package.json').version\") && pnpm run build:evenhub && node -e \"const fs=require('fs');const p=JSON.parse(fs.readFileSync('package.json','utf8'));p.files=['dist/','public/'];fs.writeFileSync('package.json',JSON.stringify(p,null,2)+'\\n');\" && pnpm pack --ignore-scripts && git checkout package.json && mv ever-terminal-$V.tgz ever-terminal-evenhub-$V.tgz",
+    "lint": "oxlint src",
+    "test": "node --import tsx --test \"src/**/*.test.ts\"",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.195",
+    "@bomb.sh/tab": "^0.0.17",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "qrcode-terminal": "^0.12.0",
+    "ws": "^8.21.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/github": "^11.0.1",
+    "@semantic-release/npm": "^12.0.1",
+    "@semantic-release/release-notes-generator": "^14.0.3",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.0.1",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/ws": "^8.18.1",
+    "@types/yargs": "^17.0.35",
+    "esbuild": "^0.28.1",
+    "oxlint": "^1.71.0",
+    "semantic-release": "^24.2.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}