zevairouter 1.0.154 → 1.0.156

package/src/lib/responseCache.js

@@ -1,169 +0,0 @@
-/**
- * Response cache for identical non-streaming chat completions.
- *
- * Goal: identical request → serve the previous response without hitting the
- * provider at all. Saves cost AND latency. This is an exact-match cache
- * (byte-identical request body), not semantic similarity — semantic caching
- * needs embeddings infra which is out of scope for a self-hosted router.
- *
- * What's cached:
- *   - Non-streaming (stream: false) successful (2xx) JSON responses
- *   - Keyed by SHA-256 of (API-key tenant + canonical request body)
- *
- * What's NEVER cached (correctness first):
- *   - Streaming requests (stream: true) — SSE can't be replayed safely
- *   - Requests with tools / tool_choice (tool results are time-sensitive)
- *   - Responses with usage.estimated (we don't trust token counts)
- *   - Anything with cache-control hints from client (x-zevai-no-cache header)
- *
- * Storage: in-memory LRU (configurable max entries + TTL). Restart clears it.
- * Persistent cache is a future enhancement — in-memory covers the hot path
- * (repeated identical prompts within a session) without DB bloat.
- */
-
-import crypto from "crypto";
-
-const DEFAULT_TTL_MS = 10 * 60 * 1000; // 10 minutes
-const DEFAULT_MAX_ENTRIES = 500;
-
-class ResponseCache {
-  constructor() {
-    this.store = new Map(); // key -> { body, status, headers, storedAt, hits }
-    this.maxEntries = DEFAULT_MAX_ENTRIES;
-    this.ttlMs = DEFAULT_TTL_MS;
-    this.stats = { hits: 0, misses: 0, stores: 0, evictions: 0 };
-  }
-
-  configure({ ttlMs, maxEntries } = {}) {
-    if (Number.isFinite(ttlMs) && ttlMs > 0) this.ttlMs = ttlMs;
-    if (Number.isFinite(maxEntries) && maxEntries > 0) this.maxEntries = maxEntries;
-  }
-
-  /**
-   * Build a deterministic cache key from the request.
-   * Canonicalizes JSON (sorted keys) so key order doesn't matter.
-   */
-  buildKey(body, tenantScope = "local") {
-    try {
-      const canonical = JSON.stringify({
-        tenantScope: String(tenantScope || "local"),
-        body: sortKeysDeep(body),
-      });
-      return crypto.createHash("sha256").update(canonical).digest("hex");
-    } catch {
-      return null;
-    }
-  }
-
-  get(key) {
-    const entry = this.store.get(key);
-    if (!entry) {
-      this.stats.misses++;
-      return null;
-    }
-    const age = Date.now() - entry.storedAt;
-    if (age > this.ttlMs) {
-      this.store.delete(key);
-      this.stats.misses++;
-      return null;
-    }
-    // Refresh recency (LRU touch)
-    this.store.delete(key);
-    this.store.set(key, entry);
-    entry.hits++;
-    this.stats.hits++;
-    return entry;
-  }
-
-  set(key, value) {
-    if (!key) return;
-    // LRU eviction: delete oldest when at capacity
-    if (this.store.size >= this.maxEntries) {
-      const oldestKey = this.store.keys().next().value;
-      if (oldestKey !== undefined) {
-        this.store.delete(oldestKey);
-        this.stats.evictions++;
-      }
-    }
-    this.store.set(key, { ...value, storedAt: Date.now(), hits: 0 });
-    this.stats.stores++;
-  }
-
-  getStats() {
-    return {
-      ...this.stats,
-      entries: this.store.size,
-      hitRate: this.stats.hits + this.stats.misses > 0
-        ? (this.stats.hits / (this.stats.hits + this.stats.misses)) : 0,
-    };
-  }
-
-  clear() {
-    this.store.clear();
-    this.stats = { hits: 0, misses: 0, stores: 0, evictions: 0 };
-  }
-}
-
-// Deep-sort object keys for canonical serialization
-function sortKeysDeep(value) {
-  if (Array.isArray(value)) return value.map(sortKeysDeep);
-  if (value && typeof value === "object") {
-    return Object.keys(value).sort().reduce((acc, k) => {
-      acc[k] = sortKeysDeep(value[k]);
-      return acc;
-    }, {});
-  }
-  return value;
-}
-
-// Singleton
-export const responseCache = new ResponseCache();
-
-/**
- * Decide whether a request is cacheable at all.
- * @param {object} body - Parsed request body
- * @param {object} [headers] - Request headers (Headers instance or plain obj)
- * @returns {{cacheable: boolean, reason?: string}}
- */
-export function isCacheableRequest(body, headers) {
-  if (!body || typeof body !== "object") return { cacheable: false, reason: "no-body" };
-  if (body.stream === true) return { cacheable: false, reason: "streaming" };
-  if (Array.isArray(body.tools) && body.tools.length > 0) return { cacheable: false, reason: "tools" };
-  if (body.tool_choice) return { cacheable: false, reason: "tool_choice" };
-  if (body.temperature !== 0) return { cacheable: false, reason: "non-deterministic-temperature" };
-  if (body.top_p !== undefined && body.top_p !== 1) return { cacheable: false, reason: "non-deterministic-top-p" };
-  if (body.n !== undefined && body.n !== 1) return { cacheable: false, reason: "multiple-choices" };
-
-  // Respect client opt-out header
-  const h = headers && typeof headers.get === "function"
-    ? headers.get("x-zevai-no-cache")
-    : headers?.["x-zevai-no-cache"];
-  if (h) return { cacheable: false, reason: "client-opt-out" };
-  const cacheControl = headers && typeof headers.get === "function"
-    ? headers.get("cache-control")
-    : headers?.["cache-control"];
-  if (/\b(?:no-cache|no-store)\b/i.test(cacheControl || "")) {
-    return { cacheable: false, reason: "cache-control" };
-  }
-
-  return { cacheable: true };
-}
-
-/**
- * Decide whether a response is safe to store.
- */
-export function isCacheableResponse(responseBody, status) {
-  if (status !== 200) return false;
-  if (!responseBody || typeof responseBody !== "object") return false;
-  // Providers sometimes return failure envelopes with HTTP 200.
-  if (responseBody.error != null) return false;
-  if (Array.isArray(responseBody.errors) && responseBody.errors.length > 0) return false;
-  if (responseBody.success === false) return false;
-  const type = String(responseBody.type || "").toLowerCase();
-  const responseStatus = String(responseBody.status || "").toLowerCase();
-  if (type === "error" || type.endsWith(".failed") || responseStatus === "failed") return false;
-  if (responseBody.choices?.some((choice) => choice?.error != null)) return false;
-  // Don't cache estimated usage (token counts unreliable)
-  if (responseBody.usage?.estimated) return false;
-  return true;
-}

package/src/lib/safeFetch.js

@@ -1,167 +0,0 @@
-import dns from "node:dns/promises";
-import net from "node:net";
-import { Agent, fetch as undiciFetch } from "undici";
-
-export function isPrivateAddress(address) {
-  const normalized = address.toLowerCase().replace(/^::ffff:/, "");
-  if (net.isIPv4(normalized)) {
-    const [a, b, c] = normalized.split(".").map(Number);
-    return a === 0 || a === 10 || a === 127 ||
-      (a === 100 && b >= 64 && b <= 127) ||
-      (a === 169 && b === 254) ||
-      (a === 172 && b >= 16 && b <= 31) ||
-      (a === 192 && (b === 0 || b === 168 || (b === 88 && c === 99))) ||
-      (a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100))) ||
-      (a === 203 && b === 0 && c === 113) || a >= 224;
-  }
-  const [first, second = "0"] = normalized.split(":");
-  const firstHextet = Number.parseInt(first, 16);
-  const secondHextet = Number.parseInt(second, 16);
-  return normalized === "::" || normalized === "::1" || firstHextet < 0x2000 || firstHextet > 0x3fff ||
-    (firstHextet === 0x2001 && (secondHextet <= 0x1ff || secondHextet === 0xdb8)) ||
-    firstHextet === 0x2002 || firstHextet === 0x3fff;
-}
-
-export async function readJsonResponse(response, maxBytes) {
-  const declaredLength = Number(response.headers.get("content-length"));
-  if (declaredLength > maxBytes) {
-    await response.body?.cancel?.();
-    throw new Error("Response body is too large");
-  }
-
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of response.body) {
-    size += chunk.byteLength;
-    if (size > maxBytes) throw new Error("Response body is too large");
-    chunks.push(chunk);
-  }
-  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-}
-
-function abortError(signal) {
-  if (signal?.reason) return signal.reason;
-  return Object.assign(new Error("The operation was aborted"), { name: "AbortError" });
-}
-
-async function lookupWithSignal(hostname, signal) {
-  if (!signal) return dns.lookup(hostname, { all: true });
-  if (signal.aborted) throw abortError(signal);
-
-  const lookup = dns.lookup(hostname, { all: true });
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = (error, addresses) => {
-      if (settled) return;
-      settled = true;
-      signal.removeEventListener("abort", onAbort);
-      if (error) reject(error);
-      else resolve(addresses);
-    };
-    const onAbort = () => finish(abortError(signal));
-    signal.addEventListener("abort", onAbort, { once: true });
-    lookup.then(
-      (addresses) => finish(null, addresses),
-      (error) => finish(error),
-    );
-  });
-}
-
-function wrapResponseBody(response, dispatcher, signal) {
-  if (!response.body?.getReader) return null;
-
-  const reader = response.body.getReader();
-  let closePromise = null;
-  let released = false;
-  const releaseReader = () => {
-    if (released) return;
-    released = true;
-    reader.releaseLock();
-  };
-  const closeDispatcher = () => {
-    signal?.removeEventListener("abort", onAbort);
-    closePromise ||= Promise.resolve(dispatcher.close()).catch(() => {});
-    return closePromise;
-  };
-  const onAbort = () => {
-    void closeDispatcher();
-  };
-
-  if (signal?.aborted) onAbort();
-  else signal?.addEventListener("abort", onAbort, { once: true });
-
-  const body = new ReadableStream({
-    async pull(controller) {
-      try {
-        const { done, value } = await reader.read();
-        if (!done) {
-          controller.enqueue(value);
-          return;
-        }
-        releaseReader();
-        await closeDispatcher();
-        controller.close();
-      } catch (error) {
-        releaseReader();
-        await closeDispatcher();
-        controller.error(error);
-      }
-    },
-    async cancel(reason) {
-      try {
-        await reader.cancel(reason);
-      } finally {
-        releaseReader();
-        await closeDispatcher();
-      }
-    },
-  });
-
-  const wrapped = new Response(body, {
-    headers: response.headers,
-    status: response.status,
-    statusText: response.statusText,
-  });
-  for (const key of ["url", "redirected", "type"]) {
-    Object.defineProperty(wrapped, key, { configurable: true, value: response[key] });
-  }
-  return wrapped;
-}
-
-export async function safeFetch(rawUrl, options = {}, { expectedOrigin, httpsOnly = false } = {}) {
-  const url = new URL(rawUrl);
-  const allowedProtocols = httpsOnly ? ["https:"] : ["http:", "https:"];
-  if (!allowedProtocols.includes(url.protocol) || url.username || url.password ||
-      (expectedOrigin && url.origin !== expectedOrigin)) {
-    throw new Error("URL is not an allowed public HTTP endpoint");
-  }
-
-  const addresses = await lookupWithSignal(url.hostname, options.signal);
-  if (!addresses.length || addresses.some(({ address }) => isPrivateAddress(address))) {
-    throw new Error("URL must resolve only to public addresses");
-  }
-
-  let next = 0;
-  const dispatcher = new Agent({
-    connect: {
-      lookup(_hostname, lookupOptions, callback) {
-        const candidates = addresses.filter(({ family }) => !lookupOptions.family || family === lookupOptions.family);
-        const pool = candidates.length ? candidates : addresses;
-        if (lookupOptions.all) return callback(null, pool);
-        const selected = pool[next++ % pool.length];
-        callback(null, selected.address, selected.family);
-      },
-    },
-  });
-
-  try {
-    const response = await undiciFetch(url, { ...options, redirect: "error", dispatcher });
-    const wrapped = wrapResponseBody(response, dispatcher, options.signal);
-    if (wrapped) return wrapped;
-    await dispatcher.close();
-    return response;
-  } catch (error) {
-    await dispatcher.close();
-    throw error;
-  }
-}

package/src/lib/systemSpecs.js

@@ -1,167 +0,0 @@
-import os from "os";
-
-/**
- * System specification detection utilities for auto-tuning bulk-import worker
- * concurrency. Each Playwright Chromium worker typically
- * consumes ~1.5-2GB RAM and 1 CPU core under load, so the defaults below stay
- * conservative to avoid swapping or thermal throttling.
- *
- * Hard limits (intentionally aligned with bulk-import managers):
- *   MIN = 1, MAX = 8
- */
-
-const BYTES_PER_GB = 1024 * 1024 * 1024;
-
-// Memory budget per worker. 4 GB per worker leaves headroom for the OS,
-// the Next.js runtime, and the spawned browser plus its OAuth tabs.
-const RAM_GB_PER_WORKER = 4;
-
-// CPU budget per worker. We use half the logical cores so background tasks
-// (OS, Next.js, browser helper processes) keep room to breathe.
-const CPU_DIVISOR = 2;
-
-const SAFE_MIN_WORKERS = 1;
-const SAFE_MAX_WORKERS = 8;
-const FALLBACK_WORKERS = 4;
-
-function safeFloor(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.floor(value));
-}
-
-function clamp(value, min, max) {
-  return Math.min(max, Math.max(min, value));
-}
-
-/**
- * Returns raw machine specs used for worker sizing. All values are best-effort
- * and may be 0/empty when the host blocks the underlying os APIs.
- */
-export function getSystemSpecs() {
-  let cpus = [];
-  try {
-    cpus = os.cpus() || [];
-  } catch {
-    cpus = [];
-  }
-
-  let totalMemBytes = 0;
-  let freeMemBytes = 0;
-  try {
-    totalMemBytes = os.totalmem();
-  } catch {
-    totalMemBytes = 0;
-  }
-  try {
-    freeMemBytes = os.freemem();
-  } catch {
-    freeMemBytes = 0;
-  }
-
-  const cpuCount = Array.isArray(cpus) ? cpus.length : 0;
-  const cpuModel = cpus[0]?.model ? String(cpus[0].model).trim() : null;
-  const totalMemGb = totalMemBytes / BYTES_PER_GB;
-  const freeMemGb = freeMemBytes / BYTES_PER_GB;
-
-  let platform = "unknown";
-  let arch = "unknown";
-  try {
-    platform = os.platform();
-  } catch {
-    /* noop */
-  }
-  try {
-    arch = os.arch();
-  } catch {
-    /* noop */
-  }
-
-  return {
-    cpuCount,
-    cpuModel,
-    totalMemBytes,
-    totalMemGb,
-    freeMemBytes,
-    freeMemGb,
-    platform,
-    arch,
-  };
-}
-
-/**
- * Calculates the recommended bulk-import worker count for the current host
- * using a hybrid formula:
- *
- *     workers = min( floor(cpuCount / 2), floor(totalRamGb / 4) )
- *     clamped to [1, 8]
- *
- * The CPU side keeps the machine responsive; the RAM side prevents Playwright
- * from triggering swap. Whichever resource is scarcer wins. When detection
- * fails entirely we fall back to the historical default of 4.
- *
- * Returns an object so callers can also surface the decision factors in the UI.
- */
-export function getRecommendedWorkerCount(specs = null) {
-  const resolved = specs || getSystemSpecs();
-  const { cpuCount, totalMemGb } = resolved;
-
-  const ramBudget = safeFloor(totalMemGb / RAM_GB_PER_WORKER);
-  const cpuBudget = safeFloor(cpuCount / CPU_DIVISOR);
-
-  let limitedBy = "fallback";
-  let raw = 0;
-
-  if (ramBudget > 0 && cpuBudget > 0) {
-    raw = Math.min(ramBudget, cpuBudget);
-    limitedBy = ramBudget <= cpuBudget ? "ram" : "cpu";
-  } else if (ramBudget > 0) {
-    raw = ramBudget;
-    limitedBy = "ram";
-  } else if (cpuBudget > 0) {
-    raw = cpuBudget;
-    limitedBy = "cpu";
-  } else {
-    raw = FALLBACK_WORKERS;
-    limitedBy = "fallback";
-  }
-
-  const recommended = clamp(raw || FALLBACK_WORKERS, SAFE_MIN_WORKERS, SAFE_MAX_WORKERS);
-
-  return {
-    recommended,
-    limitedBy, // "cpu" | "ram" | "fallback"
-    ramBudget,
-    cpuBudget,
-    minWorkers: SAFE_MIN_WORKERS,
-    maxWorkers: SAFE_MAX_WORKERS,
-    ramGbPerWorker: RAM_GB_PER_WORKER,
-    cpuDivisor: CPU_DIVISOR,
-    specs: resolved,
-  };
-}
-
-/**
- * Convenience helper - returns just the integer recommendation. Used by the
- * bulk-import managers when concurrency = "auto".
- */
-export function getOptimalWorkerCount() {
-  return getRecommendedWorkerCount().recommended;
-}
-
-/**
- * Returns true when the supplied value (string or number) requests
- * auto-detection. We accept "auto", "Auto", "AUTO" plus boolean true.
- */
-export function isAutoConcurrencyValue(value) {
-  if (value === true) return true;
-  if (typeof value !== "string") return false;
-  return value.trim().toLowerCase() === "auto";
-}
-
-export const SYSTEM_SPECS_CONSTANTS = Object.freeze({
-  RAM_GB_PER_WORKER,
-  CPU_DIVISOR,
-  SAFE_MIN_WORKERS,
-  SAFE_MAX_WORKERS,
-  FALLBACK_WORKERS,
-});

package/src/lib/terminal/ptyBridge.py

@@ -1,163 +0,0 @@
-#!/usr/bin/env python3
-"""
-Minimal PTY bridge for ZevaiRouter web terminal.
-
-stdin  -> PTY master (keystrokes)
-stdout <- PTY master (shell output), raw binary
-stderr  = control / errors (utf-8 text lines)
-
-Optional control on a side channel is not needed: resize arrives as
-OSC-like escape on stdin:  \\x1b]9999;<cols>;<rows>\\x07
-"""
-from __future__ import annotations
-
-import errno
-import fcntl
-import os
-import select
-import signal
-import struct
-import sys
-import termios
-
-
-def set_winsize(fd: int, rows: int, cols: int) -> None:
-    try:
-        packed = struct.pack("HHHH", max(5, rows), max(20, cols), 0, 0)
-        fcntl.ioctl(fd, termios.TIOCSWINSZ, packed)
-    except Exception:
-        pass
-
-
-def main() -> int:
-    cols = int(sys.argv[1]) if len(sys.argv) > 1 else 120
-    rows = int(sys.argv[2]) if len(sys.argv) > 2 else 40
-    shell = os.environ.get("SHELL") or ("/bin/bash" if os.path.exists("/bin/bash") else "/bin/sh")
-    cwd = os.path.expanduser("~")
-
-    pid, master = pty_fork = _fork_pty()
-    if pid == 0:
-        # child
-        try:
-            os.chdir(cwd)
-        except Exception:
-            pass
-        os.environ.setdefault("TERM", "xterm-256color")
-        os.environ.setdefault("COLORTERM", "truecolor")
-        os.environ.setdefault("FORCE_COLOR", "1")
-        try:
-            os.execv(shell, [shell, "-il"])
-        except Exception:
-            os.execv("/bin/sh", ["/bin/sh", "-i"])
-        return 1
-
-    set_winsize(master, rows, cols)
-
-    # Non-blocking master + stdin
-    for fd in (master, sys.stdin.fileno()):
-        fl = fcntl.fcntl(fd, fcntl.F_GETFL)
-        fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
-
-    # Binary stdout
-    stdout = sys.stdout.buffer
-    stdin = sys.stdin.buffer
-
-    resize_buf = b""
-
-    def handle_resize_escape(chunk: bytes) -> bytes:
-        """Strip and apply embedded resize escapes, return remaining bytes."""
-        nonlocal resize_buf
-        data = resize_buf + chunk
-        out = bytearray()
-        i = 0
-        while i < len(data):
-            # ESC ] 9999 ; cols ; rows BEL
-            if data[i] == 0x1B and data[i : i + 6] == b"\x1b]9999;":
-                end = data.find(b"\x07", i + 6)
-                if end < 0:
-                    resize_buf = data[i:]
-                    return bytes(out)
-                payload = data[i + 6 : end].decode("ascii", "ignore")
-                try:
-                    c_s, r_s = payload.split(";", 1)
-                    set_winsize(master, int(r_s), int(c_s))
-                except Exception:
-                    pass
-                i = end + 1
-                resize_buf = b""
-                continue
-            out.append(data[i])
-            i += 1
-        resize_buf = b""
-        return bytes(out)
-
-    alive = True
-
-    def on_chld(signum, frame):  # noqa: ARG001
-        nonlocal alive
-        alive = False
-
-    signal.signal(signal.SIGCHLD, on_chld)
-
-    try:
-        while alive:
-            try:
-                r, _, _ = select.select([master, sys.stdin.fileno()], [], [], 0.25)
-            except InterruptedError:
-                continue
-
-            if master in r:
-                try:
-                    data = os.read(master, 8192)
-                except OSError as e:
-                    if e.errno in (errno.EIO, errno.EAGAIN, errno.EWOULDBLOCK):
-                        data = b""
-                    else:
-                        break
-                if not data:
-                    # EIO often means child exited
-                    if not alive:
-                        break
-                else:
-                    stdout.write(data)
-                    stdout.flush()
-
-            if sys.stdin.fileno() in r:
-                try:
-                    data = stdin.read(8192)
-                except Exception:
-                    data = b""
-                if data is None:
-                    data = b""
-                if data == b"" and not alive:
-                    break
-                if data:
-                    cleaned = handle_resize_escape(data)
-                    if cleaned:
-                        try:
-                            os.write(master, cleaned)
-                        except OSError:
-                            break
-    finally:
-        try:
-            os.close(master)
-        except Exception:
-            pass
-        try:
-            os.waitpid(pid, 0)
-        except Exception:
-            pass
-    return 0
-
-
-def _fork_pty():
-    import pty
-
-    return pty.fork()
-
-
-if __name__ == "__main__":
-    try:
-        raise SystemExit(main())
-    except KeyboardInterrupt:
-        raise SystemExit(0)