vforclaude2 0.3.87

package/src/shared/utils/api.js

@@ -0,0 +1,93 @@
+/**
+ * API utility functions for making HTTP requests
+ */
+
+const DEFAULT_HEADERS = {
+  "Content-Type": "application/json",
+};
+
+/**
+ * Make a GET request
+ * @param {string} url - API endpoint
+ * @param {object} options - Fetch options
+ * @returns {Promise<object>}
+ */
+export async function get(url, options = {}) {
+  const response = await fetch(url, {
+    method: "GET",
+    headers: { ...DEFAULT_HEADERS, ...options.headers },
+    ...options,
+  });
+  return handleResponse(response);
+}
+
+/**
+ * Make a POST request
+ * @param {string} url - API endpoint
+ * @param {object} data - Request body
+ * @param {object} options - Fetch options
+ * @returns {Promise<object>}
+ */
+export async function post(url, data, options = {}) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { ...DEFAULT_HEADERS, ...options.headers },
+    body: JSON.stringify(data),
+    ...options,
+  });
+  return handleResponse(response);
+}
+
+/**
+ * Make a PUT request
+ * @param {string} url - API endpoint
+ * @param {object} data - Request body
+ * @param {object} options - Fetch options
+ * @returns {Promise<object>}
+ */
+export async function put(url, data, options = {}) {
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: { ...DEFAULT_HEADERS, ...options.headers },
+    body: JSON.stringify(data),
+    ...options,
+  });
+  return handleResponse(response);
+}
+
+/**
+ * Make a DELETE request
+ * @param {string} url - API endpoint
+ * @param {object} options - Fetch options
+ * @returns {Promise<object>}
+ */
+export async function del(url, options = {}) {
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: { ...DEFAULT_HEADERS, ...options.headers },
+    ...options,
+  });
+  return handleResponse(response);
+}
+
+/**
+ * Handle API response
+ * @param {Response} response - Fetch response
+ * @returns {Promise<object>}
+ */
+async function handleResponse(response) {
+  const data = await response.json();
+
+  if (!response.ok) {
+    const error = new Error(data.error || "An error occurred");
+    error.status = response.status;
+    error.data = data;
+    throw error;
+  }
+
+  return data;
+}
+
+const api = { get, post, put, del };
+export default api;
+

package/src/shared/utils/apiKey.js

@@ -0,0 +1,98 @@
+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/clineAuth.js

@@ -0,0 +1,37 @@
+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": `9Router/${APP_VERSION}`,
+    "X-PLATFORM": process.platform || "unknown",
+    "X-PLATFORM-VERSION": process.version || "unknown",
+    "X-CLIENT-TYPE": "9router",
+    "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/cloud.js

@@ -0,0 +1,40 @@
+import { getMachineId } from "@/shared/utils/machine";
+
+// Function to get cloud URL with machine ID
+export function getCloudUrl(machineId) {
+  // Get from environment or default to localhost:8787
+  const cloudUrl = process.env.NEXT_PUBLIC_CLOUD_URL || "http://localhost:8787";
+  return `${cloudUrl}/${machineId}/v1/chat/completions`;
+}
+
+// Function to call cloud with machine ID
+export async function callCloudWithMachineId(request) {
+  const machineId = await getMachineId();
+  if (!machineId) {
+    throw new Error("Could not get machine ID");
+  }
+
+  const cloudUrl = getCloudUrl(machineId);
+  
+  // Get the original request body and headers
+  const body = await request.json();
+  const headers = new Headers(request.headers);
+  
+  // Remove authorization header since cloud won't need it (uses machineId instead)
+  headers.delete("authorization");
+  
+  // Call the cloud with machine ID
+  const response = await fetch(cloudUrl, {
+    method: "POST",
+    headers: headers,
+    body: JSON.stringify(body)
+  });
+  
+  return response;
+}
+
+// Function to periodically sync provider data to cloud (now a no-op)
+export function startProviderSync(cloudUrl, intervalMs = 900000) { // Default 15 minutes
+  console.log("Frontend sync is disabled. Use backend sync instead.");
+  return null;
+}

package/src/shared/utils/cn.js

@@ -0,0 +1,11 @@
+// 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/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,18 @@
+import { getConsistentMachineId } from './machineId';
+
+// Get machine ID using node-machine-id with salt
+export async function getMachineId() {
+  return await getConsistentMachineId();
+}
+
+// Keep sync functions for backward compatibility but make them no-ops
+// (Frontend sync is disabled - use backend sync instead)
+export async function syncProviderDataToCloud(cloudUrl) {
+  console.log("Frontend sync is disabled. Use backend sync instead.");
+  return Promise.resolve(true);
+}
+
+export async function getProvidersNeedingRefresh() {
+  console.log("Frontend sync is disabled. Use backend sync instead.");
+  return Promise.resolve([]);
+}

package/src/shared/utils/machineId.js

@@ -0,0 +1,60 @@
+/**
+ * Get consistent machine ID using node-machine-id with salt
+ * This ensures the same physical machine gets the same ID across runs
+ * 
+ * @param {string} salt - Optional salt to use (defaults to environment variable)
+ * @returns {Promise<string>} Machine ID (16-character base32)
+ */
+export async function getConsistentMachineId(salt = null) {
+  // For server-side, use node-machine-id with salt
+  const saltValue = salt || process.env.MACHINE_ID_SALT || 'endpoint-proxy-salt';
+  try {
+    const pkg = await import('node-machine-id');
+    const getMachineId = pkg.machineIdSync || pkg.default?.machineIdSync;
+    const rawMachineId = getMachineId();
+    // Create consistent ID using salt
+    const crypto = await import('crypto');
+    const hashedMachineId = crypto.createHash('sha256').update(rawMachineId + saltValue).digest('hex');
+    // Return only first 16 characters for brevity
+    return hashedMachineId.substring(0, 16);
+  } catch (error) {
+    console.log('Error getting machine ID:', error);
+    // Fallback to random ID if node-machine-id fails
+    return crypto.randomUUID ? crypto.randomUUID() : 
+      'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        const r = Math.random() * 16 | 0;
+        const v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+      });
+  }
+}
+
+/**
+ * Get raw machine ID without hashing (for debugging purposes)
+ * @returns {Promise<string>} Raw machine ID
+ */
+export async function getRawMachineId() {
+  // For server-side, use raw node-machine-id
+  try {
+    const pkg = await import('node-machine-id');
+    const getMachineId = pkg.machineIdSync || pkg.default?.machineIdSync;
+    return getMachineId();
+  } catch (error) {
+    console.log('Error getting raw machine ID:', error);
+    // Fallback to random ID if node-machine-id fails
+    return crypto.randomUUID ? crypto.randomUUID() : 
+      'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        const r = Math.random() * 16 | 0;
+        const v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+      });
+  }
+}
+
+/**
+ * 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/sse/handlers/chat.js

@@ -0,0 +1,215 @@
+import "open-sse/index.js";
+
+import {
+  getProviderCredentials,
+  markAccountUnavailable,
+  clearAccountError,
+  extractApiKey,
+  isValidApiKey,
+} from "../services/auth.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 { 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";
+
+/**
+ * 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())
+    };
+  }
+
+  // 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");
+  }
+
+  // Check if model is a combo (has multiple models with fallback)
+  const comboModels = await getComboModels(modelStr);
+  if (comboModels) {
+    log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models`);
+    return handleComboChat({
+      body,
+      models: comboModels,
+      handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+      log
+    });
+  }
+
+  // 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) {
+      log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models`);
+      return handleComboChat({
+        body,
+        models: comboModels,
+        handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest, request, apiKey),
+        log
+      });
+    }
+    log.warn("CHAT", "Invalid model format", { model: modelStr });
+    return errorResponse(HTTP_STATUS.BAD_REQUEST, "Invalid model format");
+  }
+
+  const { provider, model } = modelInfo;
+
+  // 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;
+
+  while (true) {
+    const credentials = await getProviderCredentials(provider, excludeConnectionIds, model);
+
+    // 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.error("AUTH", `No credentials for provider: ${provider}`);
+        return errorResponse(HTTP_STATUS.BAD_REQUEST, `No 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 result = await handleChatCore({
+      body: { ...body, model: `${provider}/${model}` },
+      modelInfo: { provider, model },
+      credentials: refreshedCredentials,
+      log,
+      clientRawRequest,
+      connectionId: credentials.connectionId,
+      userAgent,
+      apiKey,
+      ccFilterNaming: !!chatSettings.ccFilterNaming,
+      // Detect source format by endpoint + body
+      sourceFormatOverride: request?.url ? detectFormatByEndpoint(new URL(request.url).pathname, body) : null,
+      onCredentialsRefreshed: async (newCreds) => {
+        await updateProviderCredentials(credentials.connectionId, {
+          accessToken: newCreds.accessToken,
+          refreshToken: newCreds.refreshToken,
+          providerSpecificData: newCreds.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)
+    const { shouldFallback } = await markAccountUnavailable(credentials.connectionId, result.status, result.error, provider, model);
+
+    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;
+  }
+}