wyxrouter 0.4.71

package/src/shared/utils/connectionStatus.js

@@ -0,0 +1,162 @@
+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();
+}
+
+function hasActiveModelLock(connection = {}) {
+  return Object.entries(connection).some(([key, value]) => (
+    key.startsWith("modelLock_") && hasActiveDate(value)
+  ));
+}
+
+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/index.js

@@ -0,0 +1,40 @@
+// 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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,66 @@
+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 = '9r-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/providerModelsFetcher.js

@@ -0,0 +1,30 @@
+// 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/sse/handlers/chat.js

@@ -0,0 +1,261 @@
+import "open-sse/index.js";
+
+import {
+  getProviderCredentials,
+  markAccountUnavailable,
+  clearAccountError,
+  extractApiKey,
+  isValidApiKey,
+} from "../services/auth.js";
+import { cacheClaudeHeaders } from "open-sse/utils/claudeHeaderCache.js";
+import { getSettings } from "@/lib/localDb";
+import { getModelInfo, getComboModels } from "../services/model.js";
+import { handleChatCore } from "open-sse/handlers/chatCore.js";
+import { errorResponse, unavailableResponse } from "open-sse/utils/error.js";
+import { handleComboChat } from "open-sse/services/combo.js";
+import { handleBypassRequest } from "open-sse/utils/bypassHandler.js";
+import { HTTP_STATUS } from "open-sse/config/runtimeConfig.js";
+import { detectFormatByEndpoint } from "open-sse/translator/formats.js";
+import * as log from "../utils/logger.js";
+import { updateProviderCredentials, checkAndRefreshToken } from "../services/tokenRefresh.js";
+import { getProjectIdForConnection } from "open-sse/services/projectId.js";
+import { getCodexConnectionLabel, resolveCodexGatewayConnection } from "../services/codexGateway.js";
+
+/**
+ * Handle chat completion request
+ * Supports: OpenAI, Claude, Gemini, OpenAI Responses API formats
+ * Format detection and translation handled by translator
+ */
+export async function handleChat(request, clientRawRequest = null) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    log.warn("CHAT", "Invalid JSON body");
+    return errorResponse(HTTP_STATUS.BAD_REQUEST, "Invalid JSON body");
+  }
+
+  // Build clientRawRequest for logging (if not provided)
+  if (!clientRawRequest) {
+    const url = new URL(request.url);
+    clientRawRequest = {
+      endpoint: url.pathname,
+      body,
+      headers: Object.fromEntries(request.headers.entries())
+    };
+  }
+  cacheClaudeHeaders(clientRawRequest.headers);
+
+  // Log request endpoint and model
+  const url = new URL(request.url);
+  const modelStr = body.model;
+
+  // Count messages (support both messages[] and input[] formats)
+  const msgCount = body.messages?.length || body.input?.length || 0;
+  const toolCount = body.tools?.length || 0;
+  const effort = body.reasoning_effort || body.reasoning?.effort || null;
+  log.request("POST", `${url.pathname} | ${modelStr} | ${msgCount} msgs${toolCount ? ` | ${toolCount} tools` : ""}${effort ? ` | effort=${effort}` : ""}`);
+
+  // Log API key (masked)
+  const authHeader = request.headers.get("Authorization");
+  const apiKey = extractApiKey(request);
+  if (authHeader && apiKey) {
+    const masked = log.maskKey(apiKey);
+    log.debug("AUTH", `API Key: ${masked}`);
+  } else {
+    log.debug("AUTH", "No API key provided (local mode)");
+  }
+
+  // Enforce API key if enabled in settings
+  const settings = await getSettings();
+  if (settings.requireApiKey) {
+    if (!apiKey) {
+      log.warn("AUTH", "Missing API key (requireApiKey=true)");
+      return errorResponse(HTTP_STATUS.UNAUTHORIZED, "Missing API key");
+    }
+    const valid = await isValidApiKey(apiKey);
+    if (!valid) {
+      log.warn("AUTH", "Invalid API key (requireApiKey=true)");
+      return errorResponse(HTTP_STATUS.UNAUTHORIZED, "Invalid API key");
+    }
+  }
+
+  if (!modelStr) {
+    log.warn("CHAT", "Missing model");
+    return errorResponse(HTTP_STATUS.BAD_REQUEST, "Missing model");
+  }
+
+  // Bypass naming/warmup requests before combo rotation to avoid wasting rotation slots
+  const userAgent = request?.headers?.get("user-agent") || "";
+  const bypassResponse = handleBypassRequest(body, modelStr, userAgent, !!settings.ccFilterNaming);
+  if (bypassResponse) return bypassResponse.response || bypassResponse;
+
+  // Check if model is a combo (has multiple models with fallback)
+  const comboModels = await getComboModels(modelStr);
+  if (comboModels) {
+    // Check for combo-specific strategy first, fallback to global
+    const comboStrategies = settings.comboStrategies || {};
+    const comboSpecificStrategy = comboStrategies[modelStr]?.fallbackStrategy;
+    const comboStrategy = comboSpecificStrategy || settings.comboStrategy || "fallback";
+    
+    const comboStickyLimit = settings.comboStickyRoundRobinLimit;
+    log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models (strategy: ${comboStrategy}, sticky: ${comboStickyLimit})`);
+    return handleComboChat({
+      body,
+      models: comboModels,
+      handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+      log,
+      comboName: modelStr,
+      comboStrategy,
+      comboStickyLimit
+    });
+  }
+
+  // Single model request
+  return handleSingleModelChat(body, modelStr, clientRawRequest, request, apiKey);
+}
+
+/**
+ * Handle single model chat request
+ */
+async function handleSingleModelChat(body, modelStr, clientRawRequest = null, request = null, apiKey = null) {
+  const modelInfo = await getModelInfo(modelStr);
+
+  // If provider is null, this might be a combo name - check and handle
+  if (!modelInfo.provider) {
+    const comboModels = await getComboModels(modelStr);
+    if (comboModels) {
+      const chatSettings = await getSettings();
+      // Check for combo-specific strategy first, fallback to global
+      const comboStrategies = chatSettings.comboStrategies || {};
+      const comboSpecificStrategy = comboStrategies[modelStr]?.fallbackStrategy;
+      const comboStrategy = comboSpecificStrategy || chatSettings.comboStrategy || "fallback";
+      
+      const comboStickyLimit = chatSettings.comboStickyRoundRobinLimit;
+      log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models (strategy: ${comboStrategy}, sticky: ${comboStickyLimit})`);
+      return handleComboChat({
+        body,
+        models: comboModels,
+        handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+        log,
+        comboName: modelStr,
+        comboStrategy,
+        comboStickyLimit
+      });
+    }
+    log.warn("CHAT", "Invalid model format", { model: modelStr });
+    return errorResponse(HTTP_STATUS.BAD_REQUEST, "Invalid model format");
+  }
+
+  const { provider, model } = modelInfo;
+  const gateway = modelInfo.gateway || null;
+
+  // Log model routing (alias → actual model)
+  if (modelStr !== `${provider}/${model}`) {
+    log.info("ROUTING", `${modelStr} → ${provider}/${model}`);
+  } else {
+    log.info("ROUTING", `Provider: ${provider}, Model: ${model}`);
+  }
+
+  // Extract userAgent from request
+  const userAgent = request?.headers?.get("user-agent") || "";
+
+  // Try with available accounts (fallback on errors)
+  const excludeConnectionIds = new Set();
+  let lastError = null;
+  let lastStatus = null;
+  const credentialOptions = {};
+
+  if (gateway && provider === "codex" && (gateway.mode === "original" || gateway.mode === "account")) {
+    const pinnedConnection = await resolveCodexGatewayConnection(gateway);
+    if (!pinnedConnection) {
+      const ref = gateway.mode === "account" ? `account "${gateway.accountRef}"` : "original Codex account";
+      log.warn("AUTH", `Codex gateway could not resolve ${ref}`);
+      return errorResponse(HTTP_STATUS.NOT_FOUND, `Codex gateway could not resolve ${ref}`);
+    }
+    credentialOptions.preferredConnectionId = pinnedConnection.id;
+    credentialOptions.strictPreferred = !!gateway.strictAccount;
+    log.info("ROUTING", `Codex gateway ${gateway.mode} pinned to ${getCodexConnectionLabel(pinnedConnection)}`);
+  }
+
+  while (true) {
+    const credentials = await getProviderCredentials(provider, excludeConnectionIds, model, credentialOptions);
+
+    // All accounts unavailable
+    if (!credentials || credentials.allRateLimited) {
+      if (credentials?.allRateLimited) {
+        const errorMsg = lastError || credentials.lastError || "Unavailable";
+        const status = lastStatus || Number(credentials.lastErrorCode) || HTTP_STATUS.SERVICE_UNAVAILABLE;
+        log.warn("CHAT", `[${provider}/${model}] ${errorMsg} (${credentials.retryAfterHuman})`);
+        return unavailableResponse(status, `[${provider}/${model}] ${errorMsg}`, credentials.retryAfter, credentials.retryAfterHuman);
+      }
+      if (excludeConnectionIds.size === 0) {
+        log.warn("AUTH", `No active credentials for provider: ${provider}`);
+        return errorResponse(HTTP_STATUS.NOT_FOUND, `No active credentials for provider: ${provider}`);
+      }
+      log.warn("CHAT", "No more accounts available", { provider });
+      return errorResponse(lastStatus || HTTP_STATUS.SERVICE_UNAVAILABLE, lastError || "All accounts unavailable");
+    }
+
+    // Log account selection
+    log.info("AUTH", `\x1b[32mUsing ${provider} account: ${credentials.connectionName}\x1b[0m`);
+
+    const refreshedCredentials = await checkAndRefreshToken(provider, credentials);
+
+    // Ensure real project ID is available for providers that need it (P0 fix: cold miss)
+    if ((provider === "antigravity" || provider === "gemini-cli") && !refreshedCredentials.projectId) {
+      const pid = await getProjectIdForConnection(credentials.connectionId, refreshedCredentials.accessToken);
+      if (pid) {
+        refreshedCredentials.projectId = pid;
+        // Persist to DB in background so subsequent requests have it immediately
+        updateProviderCredentials(credentials.connectionId, { projectId: pid }).catch(() => { });
+      }
+    }
+
+    // Use shared chatCore
+    const chatSettings = await getSettings();
+    const providerThinking = (chatSettings.providerThinking || {})[provider] || null;
+    const result = await handleChatCore({
+      body: { ...body, model: `${provider}/${model}` },
+      modelInfo: { provider, model },
+      credentials: refreshedCredentials,
+      log,
+      clientRawRequest,
+      connectionId: credentials.connectionId,
+      userAgent,
+      apiKey,
+      ccFilterNaming: !!chatSettings.ccFilterNaming,
+      rtkEnabled: !!chatSettings.rtkEnabled,
+      cavemanEnabled: !!chatSettings.cavemanEnabled,
+      cavemanLevel: chatSettings.cavemanLevel || "full",
+      providerThinking,
+      // Detect source format by endpoint + body
+      sourceFormatOverride: request?.url ? detectFormatByEndpoint(new URL(request.url).pathname, body) : null,
+      onCredentialsRefreshed: async (newCreds) => {
+        await updateProviderCredentials(credentials.connectionId, {
+          ...newCreds,
+          existingProviderSpecificData: credentials.providerSpecificData,
+          testStatus: "active"
+        });
+      },
+      onRequestSuccess: async () => {
+        await clearAccountError(credentials.connectionId, credentials, model);
+      }
+    });
+
+    if (result.success) return result.response;
+
+    // Mark account unavailable (auto-calculates cooldown with exponential backoff, or precise resetsAtMs)
+    const { shouldFallback } = await markAccountUnavailable(credentials.connectionId, result.status, result.error, provider, model, result.resetsAtMs);
+
+    if (shouldFallback) {
+      log.warn("AUTH", `Account ${credentials.connectionName} unavailable (${result.status}), trying fallback`);
+      excludeConnectionIds.add(credentials.connectionId);
+      lastError = result.error;
+      lastStatus = result.status;
+      continue;
+    }
+
+    return result.response;
+  }
+}