zevairouter 1.0.48 → 1.0.50

package/src/lib/terminal/sessionManager.js

@@ -0,0 +1,428 @@
+/**
+ * In-process web shell sessions for the dashboard Terminal page.
+ *
+ * Spawn order:
+ *  1. node-pty (real PTY) when the native module works
+ *  2. Python PTY bridge (reliable on macOS/Linux when node-pty fails)
+ *  3. Piped shell fallback (line-oriented; client does local echo)
+ *
+ * Security: API routes must stay behind LOCAL_ONLY + dashboard auth.
+ */
+
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+
+const MAX_SESSIONS = 4;
+const IDLE_MS = 30 * 60 * 1000;
+const MAX_OUTPUT_BUFFER = 256 * 1024;
+
+const g = globalThis.__zevaiTerminal ??= {
+  sessions: new Map(),
+};
+
+function defaultShell() {
+  if (process.platform === "win32") {
+    return process.env.COMSPEC || "powershell.exe";
+  }
+  return process.env.SHELL || "/bin/bash";
+}
+
+function loadNodePty() {
+  try {
+    return require("node-pty");
+  } catch {
+    return null;
+  }
+}
+
+function resolveBridgeScript() {
+  const candidates = [
+    // Source tree / symlink install
+    path.join(path.dirname(fileURLToPath(import.meta.url)), "ptyBridge.py"),
+    // Standalone Next build layouts
+    path.join(process.cwd(), "src/lib/terminal/ptyBridge.py"),
+    path.join(process.cwd(), "zevairouter/src/lib/terminal/ptyBridge.py"),
+  ];
+  for (const p of candidates) {
+    try {
+      if (fs.existsSync(p)) return p;
+    } catch { /* ignore */ }
+  }
+  return null;
+}
+
+function findPython() {
+  const candidates = ["python3", "python", "/usr/bin/python3", "/opt/homebrew/bin/python3"];
+  for (const cmd of candidates) {
+    try {
+      // cheap existence check for absolute paths
+      if (cmd.startsWith("/") && !fs.existsSync(cmd)) continue;
+      return cmd;
+    } catch { /* ignore */ }
+  }
+  return null;
+}
+
+function pushOutput(session, chunk) {
+  if (!chunk) return;
+  const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+  session.buffer += text;
+  if (session.buffer.length > MAX_OUTPUT_BUFFER) {
+    session.buffer = session.buffer.slice(-MAX_OUTPUT_BUFFER);
+  }
+  session.emitter.emit("data", text);
+  touch(session);
+}
+
+function touch(session) {
+  session.lastActive = Date.now();
+}
+
+function destroySession(id, reason = "closed") {
+  const session = g.sessions.get(id);
+  if (!session) return false;
+
+  try {
+    clearTimeout(session.idleTimer);
+  } catch { /* ignore */ }
+
+  try {
+    if (session.kind === "pty" && session.pty) {
+      try { session.pty.kill(); } catch { /* ignore */ }
+    } else if (session.child && !session.child.killed) {
+      try { session.child.stdin?.end?.(); } catch { /* ignore */ }
+      session.child.kill("SIGTERM");
+      setTimeout(() => {
+        try {
+          if (!session.child.killed) session.child.kill("SIGKILL");
+        } catch { /* ignore */ }
+      }, 1500).unref?.();
+    }
+  } catch { /* ignore */ }
+
+  session.alive = false;
+  session.emitter.emit("exit", { reason, code: session.exitCode });
+  session.emitter.removeAllListeners();
+  g.sessions.delete(id);
+  return true;
+}
+
+function armIdleTimer(session) {
+  try {
+    clearTimeout(session.idleTimer);
+  } catch { /* ignore */ }
+  session.idleTimer = setTimeout(() => {
+    destroySession(session.id, "idle");
+  }, IDLE_MS);
+  session.idleTimer.unref?.();
+}
+
+function makeSessionBase(id, cols, rows, mode) {
+  const emitter = new EventEmitter();
+  emitter.setMaxListeners(20);
+  return {
+    id,
+    emitter,
+    buffer: "",
+    createdAt: Date.now(),
+    lastActive: Date.now(),
+    shell: path.basename(defaultShell()),
+    mode,
+    cols,
+    rows,
+    alive: true,
+    exitCode: null,
+    idleTimer: null,
+    kind: mode === "pipe" ? "pipe" : "pty",
+    pty: null,
+    child: null,
+  };
+}
+
+function attachChildIO(session, child) {
+  session.child = child;
+  child.stdout?.on("data", (chunk) => pushOutput(session, chunk));
+  child.stderr?.on("data", (chunk) => {
+    // bridge control noise only — don't spam terminal unless it's the pipe shell
+    if (session.mode === "pipe") pushOutput(session, chunk);
+  });
+  child.on("error", (error) => {
+    pushOutput(session, `\r\n[terminal] spawn error: ${error.message}\r\n`);
+  });
+  child.on("exit", (code, signal) => {
+    session.exitCode = code;
+    session.alive = false;
+    pushOutput(
+      session,
+      `\r\n[terminal] process exited${code != null ? ` (code ${code})` : ""}${signal ? ` signal ${signal}` : ""}\r\n`
+    );
+    session.emitter.emit("exit", { reason: "process-exit", code, signal });
+    setTimeout(() => destroySession(session.id, "process-exit"), 2000).unref?.();
+  });
+}
+
+function spawnWithNodePty(cols, rows) {
+  const pty = loadNodePty();
+  if (!pty) return null;
+
+  const shell = defaultShell();
+  const cwd = os.homedir();
+  const env = {
+    ...process.env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    FORCE_COLOR: "1",
+  };
+
+  try {
+    const term = pty.spawn(
+      shell,
+      process.platform === "win32" ? [] : ["-il"],
+      {
+        name: "xterm-256color",
+        cols: cols || 120,
+        rows: rows || 40,
+        cwd,
+        env,
+      }
+    );
+    return { term, mode: "pty", cwd };
+  } catch {
+    // node-pty is optional; python bridge / pipe handle the common case.
+    return null;
+  }
+}
+
+function spawnWithPythonBridge(cols, rows) {
+  if (process.platform === "win32") return null;
+  const script = resolveBridgeScript();
+  const python = findPython();
+  if (!script || !python) return null;
+
+  try {
+    const child = spawn(python, ["-u", script, String(cols || 120), String(rows || 40)], {
+      cwd: os.homedir(),
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor",
+        FORCE_COLOR: "1",
+        PYTHONUNBUFFERED: "1",
+        SHELL: defaultShell(),
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    return { child, mode: "pty-python", cwd: os.homedir() };
+  } catch (error) {
+    console.warn("[terminal] python PTY bridge failed:", error?.message || error);
+    return null;
+  }
+}
+
+function spawnWithPipe(cols, rows) {
+  const shell = defaultShell();
+  const cwd = os.homedir();
+  const env = {
+    ...process.env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    COLUMNS: String(cols || 120),
+    LINES: String(rows || 40),
+    FORCE_COLOR: "1",
+  };
+
+  const isWin = process.platform === "win32";
+  const isPs = isWin && /powershell/i.test(shell);
+  const child = spawn(shell, isWin ? (isPs ? ["-NoLogo"] : []) : ["-i"], {
+    cwd,
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  return { child, mode: "pipe", cwd };
+}
+
+function writeWelcome(session, cwd) {
+  pushOutput(
+    session,
+    `\r\n\x1b[38;2;229;106;74mZevaiRouter\x1b[0m web shell · ${session.shell} · ${session.mode}\r\n` +
+      `Host: ${os.hostname()} · cwd: ${cwd}\r\n` +
+      (session.mode === "pipe"
+        ? `\x1b[33mLine mode\x1b[0m (no PTY) — type a command and press Enter.\r\n`
+        : `Interactive PTY session. `) +
+      `Type \x1b[1mexit\x1b[0m to close.\r\n\r\n`
+  );
+}
+
+export function listTerminalSessions() {
+  return Array.from(g.sessions.values()).map((s) => ({
+    id: s.id,
+    createdAt: s.createdAt,
+    lastActive: s.lastActive,
+    shell: s.shell,
+    mode: s.mode,
+    cols: s.cols,
+    rows: s.rows,
+    alive: s.alive,
+  }));
+}
+
+export function getTerminalSession(id) {
+  return g.sessions.get(id) || null;
+}
+
+export function createTerminalSession({ cols = 120, rows = 40 } = {}) {
+  for (const [id, s] of g.sessions) {
+    if (!s.alive) destroySession(id, "cleanup");
+  }
+
+  if (g.sessions.size >= MAX_SESSIONS) {
+    const oldest = Array.from(g.sessions.values()).sort((a, b) => a.lastActive - b.lastActive)[0];
+    if (oldest) destroySession(oldest.id, "evicted");
+  }
+
+  if (g.sessions.size >= MAX_SESSIONS) {
+    const err = new Error(`Too many terminal sessions (max ${MAX_SESSIONS})`);
+    err.code = "MAX_SESSIONS";
+    throw err;
+  }
+
+  const id = randomUUID();
+
+  // 1) node-pty
+  const ptySpawn = spawnWithNodePty(cols, rows);
+  if (ptySpawn) {
+    const session = makeSessionBase(id, cols, rows, ptySpawn.mode);
+    session.pty = ptySpawn.term;
+    session.kind = "pty";
+    ptySpawn.term.onData((data) => pushOutput(session, data));
+    ptySpawn.term.onExit(({ exitCode, signal }) => {
+      session.exitCode = exitCode;
+      session.alive = false;
+      pushOutput(
+        session,
+        `\r\n[terminal] process exited${exitCode != null ? ` (code ${exitCode})` : ""}${signal ? ` signal ${signal}` : ""}\r\n`
+      );
+      session.emitter.emit("exit", { reason: "process-exit", code: exitCode, signal });
+      setTimeout(() => destroySession(id, "process-exit"), 2000).unref?.();
+    });
+    writeWelcome(session, ptySpawn.cwd);
+    g.sessions.set(id, session);
+    armIdleTimer(session);
+    return { id, shell: session.shell, mode: session.mode, cols, rows };
+  }
+
+  // 2) Python PTY bridge
+  const pySpawn = spawnWithPythonBridge(cols, rows);
+  if (pySpawn) {
+    const session = makeSessionBase(id, cols, rows, pySpawn.mode);
+    session.kind = "pty";
+    attachChildIO(session, pySpawn.child);
+    // Don't write welcome before bridge prompt — only a short header
+    pushOutput(
+      session,
+      `\r\n\x1b[38;2;229;106;74mZevaiRouter\x1b[0m web shell · ${session.shell} · ${session.mode}\r\n` +
+        `Host: ${os.hostname()} · cwd: ${pySpawn.cwd}\r\n\r\n`
+    );
+    g.sessions.set(id, session);
+    armIdleTimer(session);
+    return { id, shell: session.shell, mode: session.mode, cols, rows };
+  }
+
+  // 3) Piped shell
+  const pipeSpawn = spawnWithPipe(cols, rows);
+  const session = makeSessionBase(id, cols, rows, pipeSpawn.mode);
+  session.kind = "pipe";
+  attachChildIO(session, pipeSpawn.child);
+  writeWelcome(session, pipeSpawn.cwd);
+  g.sessions.set(id, session);
+  armIdleTimer(session);
+  return { id, shell: session.shell, mode: session.mode, cols, rows };
+}
+
+export function writeTerminalInput(id, data) {
+  const session = g.sessions.get(id);
+  if (!session?.alive) {
+    return { ok: false, error: "Session not found or dead" };
+  }
+  let payload = typeof data === "string" ? data : String(data ?? "");
+  if (!payload) return { ok: true };
+
+  // xterm sends \r for Enter; most non-PTY shells want \n
+  if (session.mode === "pipe") {
+    payload = payload.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  }
+
+  try {
+    if (session.kind === "pty" && session.pty) {
+      session.pty.write(payload);
+    } else if (session.child?.stdin) {
+      const ok = session.child.stdin.write(payload);
+      if (!ok) {
+        // wait for drain briefly
+        session.child.stdin.once("drain", () => {});
+      }
+    } else {
+      return { ok: false, error: "Session not found or dead" };
+    }
+    touch(session);
+    armIdleTimer(session);
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: error.message || "write failed" };
+  }
+}
+
+export function resizeTerminalSession(id, cols, rows) {
+  const session = g.sessions.get(id);
+  if (!session?.alive) return { ok: false, error: "Session not found or dead" };
+  const c = Math.max(20, Math.min(500, Number(cols) || session.cols));
+  const r = Math.max(5, Math.min(200, Number(rows) || session.rows));
+  session.cols = c;
+  session.rows = r;
+
+  try {
+    if (session.kind === "pty" && session.pty?.resize) {
+      session.pty.resize(c, r);
+    } else if (session.mode === "pty-python" && session.child?.stdin) {
+      // Custom resize escape handled by ptyBridge.py
+      session.child.stdin.write(`\x1b]9999;${c};${r}\x07`);
+    }
+  } catch { /* ignore */ }
+
+  touch(session);
+  armIdleTimer(session);
+  return { ok: true, cols: c, rows: r };
+}
+
+export function killTerminalSession(id) {
+  return destroySession(id, "client-kill");
+}
+
+export function subscribeTerminalOutput(id, { onData, onExit }) {
+  const session = g.sessions.get(id);
+  if (!session) return () => {};
+
+  const dataHandler = (text) => onData?.(text);
+  const exitHandler = (info) => onExit?.(info);
+
+  session.emitter.on("data", dataHandler);
+  session.emitter.on("exit", exitHandler);
+  touch(session);
+  armIdleTimer(session);
+
+  return () => {
+    session.emitter.off("data", dataHandler);
+    session.emitter.off("exit", exitHandler);
+  };
+}

package/src/shared/components/BulkAccountAutomationModal.js

@@ -50,26 +50,14 @@ AccountStatusBadge.propTypes = {
   status: PropTypes.string,
 };
 
-function grokAuthHeaders(accessKey) {
-  const headers = {};
-  if (accessKey) headers["x-grok-automation-key"] = accessKey;
-  return headers;
-}
-
-async function fetchJob(provider, jobId, accessKey) {
-  const res = await fetch(`/api/oauth/${provider}/bulk-import/${jobId}`, {
-    cache: "no-store",
-    headers: grokAuthHeaders(accessKey),
-  });
+async function fetchJob(provider, jobId) {
+  const res = await fetch(`/api/oauth/${provider}/bulk-import/${jobId}`, { cache: "no-store" });
   const data = await res.json();
   return { res, data };
 }
 
-async function fetchLatestJob(provider, scope = "recoverable", accessKey) {
-  const res = await fetch(`/api/oauth/${provider}/bulk-import/latest?scope=${encodeURIComponent(scope)}`, {
-    cache: "no-store",
-    headers: grokAuthHeaders(accessKey),
-  });
+async function fetchLatestJob(provider, scope = "recoverable") {
+  const res = await fetch(`/api/oauth/${provider}/bulk-import/latest?scope=${encodeURIComponent(scope)}`, { cache: "no-store" });
   const data = await res.json();
   return { res, data };
 }
@@ -83,7 +71,6 @@ export default function BulkAccountAutomationModal({
   serviceName,
   defaultEngine = DEFAULT_ENGINE,
   accountsPlaceholder,
-  accessKey = "",
 }) {
   const storageKey = `${provider}-bulk-import-active-job`;
   const draftKey = `${provider}-bulk-import-accounts-draft`;
@@ -191,7 +178,7 @@ export default function BulkAccountAutomationModal({
           ? window.localStorage.getItem(storageKey)
           : null;
         if (storedJobId) {
-          const { res, data } = await fetchJob(provider, storedJobId, accessKey);
+          const { res, data } = await fetchJob(provider, storedJobId);
           if (!cancelled && res.ok && data?.job && data.recoverable) {
             setActiveJob(data.job);
             setJobRestoreNotice("Restored the active bulk login job.");
@@ -199,7 +186,7 @@ export default function BulkAccountAutomationModal({
           }
         }
 
-        const latest = await fetchLatestJob(provider, "recoverable", accessKey);
+        const latest = await fetchLatestJob(provider, "recoverable");
         if (!cancelled && latest.res.ok && latest.data?.job) {
           setActiveJob(latest.data.job);
           setJobRestoreNotice("Restored the latest recoverable bulk login job.");
@@ -216,14 +203,14 @@ export default function BulkAccountAutomationModal({
     return () => {
       cancelled = true;
     };
-  }, [isOpen, provider, storageKey, accessKey]);
+  }, [isOpen, provider, storageKey]);
 
   useEffect(() => {
     if (!isOpen || !activeJob?.jobId || finishedJob) return undefined;
 
     const interval = window.setInterval(async () => {
       try {
-        const { res, data } = await fetchJob(provider, activeJob.jobId, accessKey);
+        const { res, data } = await fetchJob(provider, activeJob.jobId);
         if (res.ok && data?.job) {
           setActiveJob(data.job);
           if (typeof window !== "undefined") {
@@ -240,7 +227,7 @@ export default function BulkAccountAutomationModal({
     }, 2000);
 
     return () => window.clearInterval(interval);
-  }, [activeJob?.jobId, finishedJob, isOpen, onSuccess, provider, storageKey, accessKey]);
+  }, [activeJob?.jobId, finishedJob, isOpen, onSuccess, provider, storageKey]);
 
   const handleStartBulk = async () => {
     const lines = bulkText
@@ -270,10 +257,7 @@ export default function BulkAccountAutomationModal({
 
       const res = await fetch(`/api/oauth/${provider}/bulk-import`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...grokAuthHeaders(accessKey),
-        },
+        headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
           accounts: lines,
           concurrency: autoConcurrency
@@ -314,7 +298,6 @@ export default function BulkAccountAutomationModal({
     try {
       const res = await fetch(`/api/oauth/${provider}/bulk-import/${activeJob.jobId}/cancel`, {
         method: "POST",
-        headers: grokAuthHeaders(accessKey),
       });
       const data = await res.json();
       if (!res.ok) throw new Error(data.error || "Failed to cancel job");
@@ -330,7 +313,6 @@ export default function BulkAccountAutomationModal({
     try {
       const res = await fetch(`/api/oauth/${provider}/bulk-import/${activeJob.jobId}/manual/${workerId}`, {
         method: "POST",
-        headers: grokAuthHeaders(accessKey),
       });
       const data = await res.json();
       if (!res.ok) throw new Error(data.error || "Failed to open manual session");
@@ -669,5 +651,4 @@ BulkAccountAutomationModal.propTypes = {
   serviceName: PropTypes.string.isRequired,
   defaultEngine: PropTypes.string,
   accountsPlaceholder: PropTypes.string,
-  accessKey: PropTypes.string,
 };

package/src/shared/components/Header.js

@@ -115,9 +115,44 @@ const getPageInfo = (pathname) => {
     return {
       title: "CLI Tools",
       description: "Configure CLI tools",
+      icon: "handyman",
+      breadcrumbs: [],
+    };
+  if (pathname.includes("/terminal"))
+    return {
+      title: "Terminal",
+      description: "Localhost web shell on this machine",
       icon: "terminal",
       breadcrumbs: [],
     };
+  if (pathname.includes("/automation"))
+    return {
+      title: "Automation",
+      description: "Bulk account and workflow automation",
+      icon: "automation",
+      breadcrumbs: [],
+    };
+  if (pathname.includes("/token-saver"))
+    return {
+      title: "Token Saver",
+      description: "Reduce prompt tokens before they hit providers",
+      icon: "savings",
+      breadcrumbs: [],
+    };
+  if (pathname.includes("/context"))
+    return {
+      title: "Context Inject",
+      description: "Inject shared context into routed requests",
+      icon: "psychology",
+      breadcrumbs: [],
+    };
+  if (pathname.includes("/pxpipe"))
+    return {
+      title: "PxPipe",
+      description: "Proxy pipeline status and controls",
+      icon: "cable",
+      breadcrumbs: [],
+    };
   if (pathname.includes("/proxy-pools"))
     return {
       title: "Proxy Pools",
@@ -160,6 +195,13 @@ const getPageInfo = (pathname) => {
       icon: "monitor",
       breadcrumbs: [],
     };
+  if (pathname.includes("/playground") || pathname.includes("/basic-chat"))
+    return {
+      title: "Playground",
+      description: "Chat with any connected model through ZevaiRouter",
+      icon: "forum",
+      breadcrumbs: [],
+    };
   if (pathname === "/dashboard")
     return {
       title: "Endpoint",