zevairouter 1.0.154 → 1.0.155

package/src/shared/utils/apiKey.js

@@ -1,98 +0,0 @@
-import crypto from "crypto";
-
-const API_KEY_SECRET = process.env.API_KEY_SECRET || "endpoint-proxy-api-key-secret";
-
-/**
- * Generate 6-char random keyId
- */
-function generateKeyId() {
-  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0; i < 6; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-}
-
-/**
- * Generate CRC (8-char HMAC)
- */
-function generateCrc(machineId, keyId) {
-  return crypto
-    .createHmac("sha256", API_KEY_SECRET)
-    .update(machineId + keyId)
-    .digest("hex")
-    .slice(0, 8);
-}
-
-/**
- * Generate API key with machineId embedded
- * Format: sk-{machineId}-{keyId}-{crc8}
- * @param {string} machineId - 16-char machine ID
- * @returns {{ key: string, keyId: string }}
- */
-export function generateApiKeyWithMachine(machineId) {
-  const keyId = generateKeyId();
-  const crc = generateCrc(machineId, keyId);
-  const key = `sk-${machineId}-${keyId}-${crc}`;
-  return { key, keyId };
-}
-
-/**
- * Parse API key and extract machineId + keyId
- * Supports both formats:
- * - New: sk-{machineId}-{keyId}-{crc8}
- * - Old: sk-{random8}
- * @param {string} apiKey
- * @returns {{ machineId: string, keyId: string, isNewFormat: boolean } | null}
- */
-export function parseApiKey(apiKey) {
-  if (!apiKey || !apiKey.startsWith("sk-")) return null;
-
-  const parts = apiKey.split("-");
-  
-  // New format: sk-{machineId}-{keyId}-{crc8} = 4 parts
-  if (parts.length === 4) {
-    const [, machineId, keyId, crc] = parts;
-    
-    // Validate CRC
-    const expectedCrc = generateCrc(machineId, keyId);
-    if (crc !== expectedCrc) return null;
-    
-    return { machineId, keyId, isNewFormat: true };
-  }
-  
-  // Old format: sk-{random8} = 2 parts
-  if (parts.length === 2) {
-    return { machineId: null, keyId: parts[1], isNewFormat: false };
-  }
-  
-  return null;
-}
-
-/**
- * Verify API key CRC (only for new format)
- * @param {string} apiKey
- * @returns {boolean}
- */
-export function verifyApiKeyCrc(apiKey) {
-  const parsed = parseApiKey(apiKey);
-  if (!parsed) return false;
-  
-  // Old format doesn't have CRC, always valid if parsed
-  if (!parsed.isNewFormat) return true;
-  
-  // New format already verified in parseApiKey
-  return true;
-}
-
-/**
- * Check if API key is new format (contains machineId)
- * @param {string} apiKey
- * @returns {boolean}
- */
-export function isNewFormatKey(apiKey) {
-  const parsed = parseApiKey(apiKey);
-  return parsed?.isNewFormat === true;
-}
-

package/src/shared/utils/asyncPolling.js

@@ -1,27 +0,0 @@
-export function startAsyncPolling(task, intervalMs, options = {}) {
-  const setTimer = options.setTimer || globalThis.setTimeout;
-  const clearTimer = options.clearTimer || globalThis.clearTimeout;
-  let cancelled = false;
-  let timer = null;
-
-  const isCancelled = () => cancelled;
-  const poll = async () => {
-    timer = null;
-    if (cancelled) return;
-
-    try {
-      await task(isCancelled);
-    } catch {
-      // Polling is best-effort; schedule the next attempt after transient failures.
-    }
-
-    if (!cancelled) timer = setTimer(poll, intervalMs);
-  };
-
-  timer = setTimer(poll, intervalMs);
-  return () => {
-    cancelled = true;
-    if (timer !== null) clearTimer(timer);
-    timer = null;
-  };
-}

package/src/shared/utils/clineAuth.js

@@ -1,37 +0,0 @@
-import pkg from "../../../package.json" with { type: "json" };
-
-const APP_VERSION = pkg.version || "0.0.0";
-
-export function getClineAccessToken(token) {
-  if (typeof token !== "string") return "";
-  const trimmed = token.trim();
-  if (!trimmed) return "";
-  return trimmed.startsWith("workos:") ? trimmed : `workos:${trimmed}`;
-}
-
-export function getClineAuthorizationHeader(token) {
-  const accessToken = getClineAccessToken(token);
-  return accessToken ? `Bearer ${accessToken}` : "";
-}
-
-export function buildClineHeaders(token, extraHeaders = {}) {
-  const authorization = getClineAuthorizationHeader(token);
-  const headers = {
-    "HTTP-Referer": "https://cline.bot",
-    "X-Title": "Cline",
-    "User-Agent": `ZevaiRouter/${APP_VERSION}`,
-    "X-PLATFORM": process.platform || "unknown",
-    "X-PLATFORM-VERSION": process.version || "unknown",
-    "X-CLIENT-TYPE": "zevairouter",
-    "X-CLIENT-VERSION": APP_VERSION,
-    "X-CORE-VERSION": APP_VERSION,
-    "X-IS-MULTIROOT": "false",
-    ...extraHeaders,
-  };
-
-  if (authorization) {
-    headers.Authorization = authorization;
-  }
-
-  return headers;
-}

package/src/shared/utils/cn.js

@@ -1,11 +0,0 @@
-// Utility function to merge class names
-// Handles conditional classes and removes duplicates
-
-export function cn(...classes) {
-  return classes
-    .filter(Boolean)
-    .join(" ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-

package/src/shared/utils/codexCliConfig.js

@@ -1,44 +0,0 @@
-/**
- * Helpers for writing ~/.codex/config.toml through the ZevaiRouter dashboard.
- * Keeps bare model ids from falling into alias/openai traps.
- */
-
-/** Default model written for fresh Codex CLI setup */
-export const CODEX_CLI_DEFAULT_MODEL = "cx/gpt-5.6-sol";
-
-/**
- * Normalize model ids written into ~/.codex/config.toml so bare names like
- * `gpt-5.6-sol` always route through the Codex provider (`cx/...`) instead of
- * alias resolution → openai fallback (or stale aliases mapping to gpt-5.5).
- *
- * @param {string} model
- * @returns {string}
- */
-export function normalizeCodexCliModel(model) {
-  const value = String(model || "").trim();
-  if (!value) return CODEX_CLI_DEFAULT_MODEL;
-
-  // Gateway / multi-account aliases keep their own scheme
-  if (
-    value === "auto-codex" ||
-    value.startsWith("router/") ||
-    value.startsWith("original/") ||
-    value.startsWith("account/") ||
-    value.startsWith("codex-account/")
-  ) {
-    return value;
-  }
-
-  // codex/foo → cx/foo
-  if (value.startsWith("codex/")) return `cx/${value.slice(6)}`;
-
-  // Already provider-prefixed (cx/..., openai/..., combo, etc.)
-  if (value.includes("/")) return value;
-
-  // Bare ChatGPT/Codex model ids — always pin to Codex OAuth pool
-  if (value.startsWith("gpt-") || /^o[134]/i.test(value)) {
-    return `cx/${value}`;
-  }
-
-  return value;
-}

package/src/shared/utils/connectionStatus.js

@@ -1,168 +0,0 @@
-export const CONNECTION_STATUS_KEYS = {
-  active: "active",
-  disabled: "disabled",
-  connection_error: "connection_error",
-  auth_error: "auth_error",
-  quota_exhausted: "quota_exhausted",
-  rate_limited: "rate_limited",
-  banned: "banned",
-  cooldown: "cooldown",
-  unknown: "unknown",
-};
-
-export const CONNECTION_STATUS_FILTERS = [
-  { id: "all", label: "All" },
-  { id: "active", label: "Active", keys: ["active"] },
-  {
-    id: "errors",
-    label: "Errors",
-    keys: ["connection_error", "auth_error", "quota_exhausted", "rate_limited", "banned", "cooldown", "unknown"],
-  },
-  { id: "connection", label: "Connection", keys: ["connection_error"] },
-  { id: "auth", label: "Auth", keys: ["auth_error"] },
-  { id: "limit", label: "Limit", keys: ["rate_limited", "cooldown"] },
-  { id: "exhausted", label: "Exhausted", keys: ["quota_exhausted"] },
-  { id: "banned", label: "Banned", keys: ["banned"] },
-  { id: "disabled", label: "Disabled", keys: ["disabled"] },
-];
-
-const STATUS_META = {
-  active: { label: "active", severity: "success", terminal: false },
-  disabled: { label: "disabled", severity: "default", terminal: false },
-  connection_error: { label: "connection error", severity: "error", terminal: false },
-  auth_error: { label: "auth error", severity: "error", terminal: true },
-  quota_exhausted: { label: "exhausted", severity: "error", terminal: true },
-  rate_limited: { label: "rate limited", severity: "warning", terminal: false },
-  banned: { label: "banned", severity: "error", terminal: true },
-  cooldown: { label: "cooldown", severity: "warning", terminal: false },
-  unknown: { label: "unknown", severity: "default", terminal: false },
-};
-
-function normalizeText(value) {
-  if (!value) return "";
-  if (typeof value === "string") return value.toLowerCase();
-  try {
-    return JSON.stringify(value).toLowerCase();
-  } catch {
-    return String(value).toLowerCase();
-  }
-}
-
-function hasActiveDate(value) {
-  if (!value) return false;
-  const timestamp = new Date(value).getTime();
-  return Number.isFinite(timestamp) && timestamp > Date.now();
-}
-
-export function getEarliestActiveModelLockUntil(connection = {}, now = Date.now()) {
-  const timestamps = Object.entries(connection)
-    .filter(([key]) => key.startsWith("modelLock_"))
-    .map(([, value]) => new Date(value).getTime())
-    .filter((timestamp) => Number.isFinite(timestamp) && timestamp > now);
-  return timestamps.length > 0 ? new Date(Math.min(...timestamps)).toISOString() : null;
-}
-
-function hasActiveModelLock(connection = {}) {
-  return getEarliestActiveModelLockUntil(connection) !== null;
-}
-
-function withMeta(key, reason = "") {
-  const meta = STATUS_META[key] || STATUS_META.unknown;
-  return { key, ...meta, reason };
-}
-
-export function classifyConnectionStatus(connection = {}) {
-  if (connection.isActive === false) {
-    return withMeta("disabled", "Connection is disabled");
-  }
-
-  if (hasActiveModelLock(connection)) {
-    return withMeta("cooldown", "Model cooldown is active");
-  }
-
-  if (hasActiveDate(connection.rateLimitedUntil)) {
-    return withMeta("rate_limited", "Rate limit cooldown is active");
-  }
-
-  const status = normalizeText(connection.testStatus || connection.status);
-  const errorType = normalizeText(connection.lastErrorType || connection.errorType);
-  const errorCode = normalizeText(connection.errorCode || connection.statusCode);
-  const errorText = normalizeText(connection.lastError || connection.error);
-  const combined = `${status} ${errorType} ${errorCode} ${errorText}`.trim();
-
-  if (!combined || ["active", "success", "ok"].includes(status)) {
-    return withMeta("active", "");
-  }
-
-  if (combined.includes("ban") || combined.includes("suspend") || combined.includes("restricted")) {
-    return withMeta("banned", connection.lastError || "Account appears restricted");
-  }
-
-  if (
-    combined.includes("exhaust") ||
-    combined.includes("quota exceeded") ||
-    combined.includes("insufficient_quota") ||
-    combined.includes("payment required") ||
-    errorCode === "402"
-  ) {
-    return withMeta("quota_exhausted", connection.lastError || "Quota exhausted");
-  }
-
-  if (
-    errorType.includes("rate_limited") ||
-    combined.includes("rate limit") ||
-    combined.includes("too many requests") ||
-    errorCode === "429"
-  ) {
-    return withMeta("rate_limited", connection.lastError || "Rate limited");
-  }
-
-  if (
-    errorType.includes("auth") ||
-    errorType.includes("token") ||
-    combined.includes("unauthorized") ||
-    combined.includes("invalid api key") ||
-    combined.includes("token invalid") ||
-    combined.includes("token expired") ||
-    combined.includes("revoked") ||
-    errorCode === "401" ||
-    errorCode === "403"
-  ) {
-    return withMeta("auth_error", connection.lastError || "Authentication failed");
-  }
-
-  if (
-    errorType.includes("network") ||
-    combined.includes("network") ||
-    combined.includes("timeout") ||
-    combined.includes("fetch failed") ||
-    combined.includes("econn") ||
-    combined.includes("dns") ||
-    combined.includes("proxy")
-  ) {
-    return withMeta("connection_error", connection.lastError || "Connection failed");
-  }
-
-  if (["error", "expired", "unavailable", "failed"].includes(status)) {
-    return withMeta("connection_error", connection.lastError || connection.testStatus || "Connection failed");
-  }
-
-  return withMeta("unknown", connection.lastError || connection.testStatus || "");
-}
-
-export function filterConnectionByStatus(connection, filterId) {
-  if (!filterId || filterId === "all") return true;
-  const filter = CONNECTION_STATUS_FILTERS.find((item) => item.id === filterId);
-  if (!filter) return true;
-  return filter.keys.includes(classifyConnectionStatus(connection).key);
-}
-
-export function isTerminalConnectionStatus(connection) {
-  return classifyConnectionStatus(connection).terminal === true;
-}
-
-export function getStatusBadgeVariant(classifiedStatus) {
-  if (classifiedStatus?.severity === "success") return "success";
-  if (classifiedStatus?.severity === "error") return "error";
-  return "default";
-}

package/src/shared/utils/dashboardMedia.js

@@ -1,19 +0,0 @@
-const MEDIA_OPERATION_BY_PUBLIC_PATH = Object.freeze({
-  "/v1/embeddings": "embeddings",
-  "/v1/images/generations": "images",
-  "/v1/audio/speech": "speech",
-  "/v1/audio/transcriptions": "transcriptions",
-  "/v1/search": "search",
-  "/v1/web/fetch": "fetch",
-});
-
-export function getDashboardMediaEndpoint(publicPath) {
-  if (typeof publicPath !== "string") return null;
-
-  const queryIndex = publicPath.indexOf("?");
-  const pathname = queryIndex === -1 ? publicPath : publicPath.slice(0, queryIndex);
-  const query = queryIndex === -1 ? "" : publicPath.slice(queryIndex);
-  const operation = MEDIA_OPERATION_BY_PUBLIC_PATH[pathname];
-
-  return operation ? `/api/dashboard/media/${operation}${query}` : null;
-}

package/src/shared/utils/index.js

@@ -1,40 +0,0 @@
-// Shared Utils - Export all
-export { cn } from "./cn";
-export * as api from "./api";
-
-import { v4 as uuidv4 } from "uuid";
-
-/**
- * Generate unique ID (UUID v4)
- * @returns {string} UUID v4 string
- */
-export const generateId = uuidv4;
-
-/**
- * Extract error code from error message (401, 429, 503...)
- * @param {string} lastError - Error message
- * @returns {string|null} Error code or null
- */
-export function getErrorCode(lastError) {
-  if (!lastError) return null;
-  const match = lastError.match(/\b([45]\d{2})\b/);
-  return match ? match[1] : "ERR";
-}
-
-/**
- * Get relative time string (e.g. "5 min ago")
- * @param {string} isoDate - ISO date string
- * @returns {string} Relative time
- */
-export function getRelativeTime(isoDate) {
-  if (!isoDate) return "";
-  const diff = Date.now() - new Date(isoDate).getTime();
-  const mins = Math.floor(diff / 60000);
-  if (mins < 1) return "just now";
-  if (mins < 60) return `${mins}m ago`;
-  const hours = Math.floor(mins / 60);
-  if (hours < 24) return `${hours}h ago`;
-  const days = Math.floor(hours / 24);
-  return `${days}d ago`;
-}
-

package/src/shared/utils/machine.js

@@ -1,6 +0,0 @@
-import { getConsistentMachineId } from "./machineId";
-
-// Get machine ID using node-machine-id with salt
-export async function getMachineId() {
-  return await getConsistentMachineId();
-}

package/src/shared/utils/machineId.js

@@ -1,66 +0,0 @@
-import { machineIdSync } from 'node-machine-id';
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { DATA_DIR } from '@/lib/dataDir';
-
-const MACHINE_ID_FILE = path.join(DATA_DIR, 'machine-id');
-const AUTH_DIR = path.join(DATA_DIR, 'auth');
-const CLI_SECRET_FILE = path.join(AUTH_DIR, 'cli-secret');
-const CLI_AUTH_SALT = 'zevai-cli-auth';
-let cachedRawId = null;
-let cachedCliSecret = null;
-
-// Persist raw machine ID to file → guarantees CLI/server/middleware see same value
-// even when machineIdSync fails or returns inconsistent values across runtimes.
-function loadRawMachineId() {
-  if (cachedRawId) return cachedRawId;
-  try {
-    cachedRawId = fs.readFileSync(MACHINE_ID_FILE, 'utf8').trim();
-    if (cachedRawId) return cachedRawId;
-  } catch {}
-  try {
-    cachedRawId = machineIdSync();
-  } catch {
-    cachedRawId = crypto.randomUUID();
-  }
-  try {
-    fs.mkdirSync(DATA_DIR, { recursive: true });
-    fs.writeFileSync(MACHINE_ID_FILE, cachedRawId, { mode: 0o600 });
-  } catch {}
-  return cachedRawId;
-}
-
-// Random secret persisted on first run → unpredictable CLI token even when machineId leaks.
-function loadCliSecret() {
-  if (cachedCliSecret) return cachedCliSecret;
-  try {
-    cachedCliSecret = fs.readFileSync(CLI_SECRET_FILE, 'utf8').trim();
-    if (cachedCliSecret) return cachedCliSecret;
-  } catch {}
-  cachedCliSecret = crypto.randomBytes(32).toString('hex');
-  try {
-    fs.mkdirSync(AUTH_DIR, { recursive: true });
-    fs.writeFileSync(CLI_SECRET_FILE, cachedCliSecret, { mode: 0o600 });
-  } catch {}
-  return cachedCliSecret;
-}
-
-export async function getConsistentMachineId(salt = null) {
-  const saltValue = salt || process.env.MACHINE_ID_SALT || 'endpoint-proxy-salt';
-  const raw = loadRawMachineId();
-  const extra = saltValue === CLI_AUTH_SALT ? loadCliSecret() : '';
-  return crypto.createHash('sha256').update(raw + saltValue + extra).digest('hex').substring(0, 16);
-}
-
-export async function getRawMachineId() {
-  return loadRawMachineId();
-}
-
-/**
- * Check if we're running in browser or server environment
- * @returns {boolean} True if in browser, false if in server
- */
-export function isBrowser() {
-  return typeof window !== 'undefined';
-}

package/src/shared/utils/modelLockTimer.js

@@ -1,32 +0,0 @@
-import { getEarliestActiveModelLockUntil } from "./connectionStatus";
-
-const MAX_TIMEOUT_MS = 2_147_483_647;
-
-export function scheduleModelLockRefresh(modelLocks, onChange, options = {}) {
-  const now = options.now || Date.now;
-  const setTimer = options.setTimer || globalThis.setTimeout;
-  const clearTimer = options.clearTimer || globalThis.clearTimeout;
-  let stopped = false;
-  let timer = null;
-
-  const refresh = () => {
-    timer = null;
-    if (stopped) return;
-
-    const checkedAt = now();
-    const until = getEarliestActiveModelLockUntil(modelLocks, checkedAt);
-    onChange(until);
-    if (!until) return;
-
-    // Wake just after the boundary, then move to the next active lock if one exists.
-    const delay = Math.max(1, new Date(until).getTime() - checkedAt + 1);
-    timer = setTimer(refresh, Math.min(delay, MAX_TIMEOUT_MS));
-  };
-
-  timer = setTimer(refresh, 0);
-  return () => {
-    stopped = true;
-    if (timer !== null) clearTimer(timer);
-    timer = null;
-  };
-}

package/src/shared/utils/providerModelsFetcher.js

@@ -1,30 +0,0 @@
-// Fetch and cache suggested models for providers that expose a public models API
-// Fetches via backend proxy to avoid CORS issues
-
-const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
-const cache = new Map(); // key: fetcher.url → { data, expiresAt }
-
-/**
- * Fetch suggested models for a provider using its modelsFetcher config.
- * Results are cached in-memory for CACHE_TTL_MS.
- * @param {{ url: string, type: string }} fetcher
- * @returns {Promise<Array<{ id: string, name: string, contextLength?: number }>>}
- */
-export async function fetchSuggestedModels(fetcher) {
-  if (!fetcher?.url || !fetcher?.type) return [];
-
-  const cached = cache.get(fetcher.url);
-  if (cached && Date.now() < cached.expiresAt) return cached.data;
-
-  try {
-    const params = new URLSearchParams({ url: fetcher.url, type: fetcher.type });
-    const res = await fetch(`/api/providers/suggested-models?${params}`);
-    if (!res.ok) return [];
-    const json = await res.json();
-    const data = json.data ?? [];
-    cache.set(fetcher.url, { data, expiresAt: Date.now() + CACHE_TTL_MS });
-    return data;
-  } catch {
-    return [];
-  }
-}

package/src/shared/utils/usageStats.js

@@ -1,10 +0,0 @@
-export function getAccountPendingCount(account = {}, pendingByAccount = {}) {
-  const connectionPending = pendingByAccount[account.connectionId];
-  if (!connectionPending) return 0;
-
-  const providerId = account.providerId || account.provider;
-  const modelKey = providerId
-    ? `${account.rawModel} (${providerId})`
-    : account.rawModel;
-  return connectionPending[modelKey] || 0;
-}