vforclaude2 0.3.87

package/cloud/src/handlers/sync.js

@@ -0,0 +1,227 @@
+import * as log from "../utils/logger.js";
+import { getMachineData, saveMachineData, deleteMachineData } from "../services/storage.js";
+
+const CORS_HEADERS = {
+  "Content-Type": "application/json",
+  "Access-Control-Allow-Origin": "*"
+};
+
+// Removed: WORKER_FIELDS and WORKER_SPECIFIC_FIELDS
+// Now syncing entire provider based on updatedAt (simpler logic)
+
+export async function handleSync(request, env, ctx) {
+  const url = new URL(request.url);
+  const machineId = url.pathname.split("/")[2]; // /sync/:machineId
+
+  // Handle CORS preflight
+  if (request.method === "OPTIONS") {
+    return new Response(null, {
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "*"
+      }
+    });
+  }
+
+  if (!machineId) {
+    log.warn("SYNC", "Missing machineId in path");
+    return jsonResponse({ error: "Missing machineId" }, 400);
+  }
+
+  // Route by method
+  switch (request.method) {
+    case "GET":
+      return handleGet(machineId, env);
+    case "POST":
+      return handlePost(request, machineId, env);
+    case "DELETE":
+      return handleDelete(machineId, env);
+    default:
+      return jsonResponse({ error: "Method not allowed" }, 405);
+  }
+}
+
+/**
+ * GET /sync/:machineId - Return merged data for Web to update
+ */
+async function handleGet(machineId, env) {
+  const data = await getMachineData(machineId, env);
+
+  if (!data) {
+    log.warn("SYNC", "No data found", { machineId });
+    return jsonResponse({ error: "No data found" }, 404);
+  }
+
+  log.info("SYNC", "Data retrieved", { machineId });
+  return jsonResponse({
+    success: true,
+    data
+  });
+}
+
+/**
+ * POST /sync/:machineId - Merge Web data with Worker data
+ * providers stored by ID (supports multiple connections per provider)
+ */
+async function handlePost(request, machineId, env) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    log.warn("SYNC", "Invalid JSON body", { machineId });
+    return jsonResponse({ error: "Invalid JSON body" }, 400);
+  }
+
+  // Validate required fields
+  if (!body.providers || !Array.isArray(body.providers)) {
+    log.warn("SYNC", "Missing or invalid providers array", { machineId });
+    return jsonResponse({ error: "Missing providers array" }, 400);
+  }
+
+  const existingData = await getMachineData(machineId, env) || { providers: {}, modelAliases: {}, apiKeys: [] };
+
+  // Merge providers by ID
+  const mergedProviders = {};
+  const changes = { updated: [], fromWorker: [] };
+
+  for (const webProvider of body.providers) {
+    const providerId = webProvider.id;
+    if (!providerId) {
+      log.warn("SYNC", "Provider missing id", { provider: webProvider.provider });
+      continue;
+    }
+
+    const workerProvider = existingData.providers[providerId];
+
+    if (workerProvider) {
+      // Merge: token fields from Worker, config fields from Web
+      mergedProviders[providerId] = mergeProvider(webProvider, workerProvider, changes, providerId);
+    } else {
+      // New provider from Web
+      mergedProviders[providerId] = formatProviderData(webProvider);
+      changes.updated.push(providerId);
+    }
+  }
+
+  // Prepare final data - modelAliases, apiKeys, combos always from Web
+  const finalData = {
+    providers: mergedProviders,
+    modelAliases: body.modelAliases || existingData.modelAliases || {},
+    combos: body.combos || existingData.combos || [],
+    apiKeys: body.apiKeys || existingData.apiKeys || [],
+    updatedAt: new Date().toISOString()
+  };
+
+  // Store in D1 + invalidate cache
+  await saveMachineData(machineId, finalData, env);
+
+  log.info("SYNC", "Data synced successfully", {
+    machineId,
+    providerCount: Object.keys(mergedProviders).length,
+    changes
+  });
+
+  return jsonResponse({
+    success: true,
+    data: finalData,
+    changes
+  });
+}
+
+/**
+ * DELETE /sync/:machineId - Clear cache when Worker is disabled
+ */
+async function handleDelete(machineId, env) {
+  await deleteMachineData(machineId, env);
+
+  log.info("SYNC", "Data deleted", { machineId });
+  return jsonResponse({
+    success: true,
+    message: "Data deleted successfully"
+  });
+}
+
+/**
+ * Merge provider data: compare updatedAt to decide which source to use
+ * Simple logic: newer wins (sync entire provider)
+ */
+function mergeProvider(webProvider, workerProvider, changes, providerId) {
+  const webTime = new Date(webProvider.updatedAt || 0).getTime();
+  const workerTime = new Date(workerProvider.updatedAt || 0).getTime();
+
+  let merged;
+  
+  if (workerTime > webTime) {
+    // Cloud has newer data - use entire Cloud provider
+    merged = formatProviderData(workerProvider);
+    changes.fromWorker.push(providerId);
+  } else {
+    // Server has newer data - use entire Server provider
+    merged = formatProviderData(webProvider);
+    changes.updated.push(providerId);
+  }
+
+  // Always update timestamp
+  merged.updatedAt = new Date().toISOString();
+  return merged;
+}
+
+/**
+ * Format provider data for storage
+ */
+function formatProviderData(provider) {
+  return {
+    id: provider.id,
+    provider: provider.provider,
+    authType: provider.authType,
+    name: provider.name,
+    displayName: provider.displayName,
+    email: provider.email,
+    priority: provider.priority,
+    globalPriority: provider.globalPriority,
+    defaultModel: provider.defaultModel,
+    accessToken: provider.accessToken,
+    refreshToken: provider.refreshToken,
+    expiresAt: provider.expiresAt,
+    expiresIn: provider.expiresIn,
+    tokenType: provider.tokenType,
+    scope: provider.scope,
+    idToken: provider.idToken,
+    projectId: provider.projectId,
+    apiKey: provider.apiKey,
+    providerSpecificData: provider.providerSpecificData || {},
+    isActive: provider.isActive,
+    status: provider.status || "active",
+    lastError: provider.lastError || null,
+    lastErrorAt: provider.lastErrorAt || null,
+    errorCode: provider.errorCode || null,
+    rateLimitedUntil: provider.rateLimitedUntil || null,
+    createdAt: provider.createdAt,
+    updatedAt: provider.updatedAt || new Date().toISOString()
+  };
+}
+
+/**
+ * Update provider status (called when token refresh fails or API errors)
+ */
+export function updateProviderStatus(providers, providerId, status, error = null, errorCode = null) {
+  if (providers[providerId]) {
+    providers[providerId].status = status;
+    providers[providerId].lastError = error;
+    providers[providerId].lastErrorAt = error ? new Date().toISOString() : null;
+    providers[providerId].errorCode = errorCode;
+    providers[providerId].updatedAt = new Date().toISOString();
+  }
+  return providers;
+}
+
+/**
+ * Helper to create JSON response
+ */
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: CORS_HEADERS
+  });
+}

package/cloud/src/handlers/verify.js

@@ -0,0 +1,60 @@
+import { parseApiKey, extractBearerToken } from "../utils/apiKey.js";
+import { getMachineData } from "../services/storage.js";
+
+/**
+ * Verify API key endpoint
+ * @param {Request} request
+ * @param {Object} env
+ * @param {string|null} machineIdOverride - machineId from URL (old format) or null (new format)
+ */
+export async function handleVerify(request, env, machineIdOverride = null) {
+  const apiKey = extractBearerToken(request);
+  if (!apiKey) {
+    return jsonResponse({ error: "Missing or invalid Authorization header" }, 401);
+  }
+
+  // Determine machineId: from URL (old) or from API key (new)
+  let machineId = machineIdOverride;
+  
+  if (!machineId) {
+    const parsed = await parseApiKey(apiKey);
+    if (!parsed) {
+      return jsonResponse({ error: "Invalid API key format" }, 401);
+    }
+    
+    if (!parsed.isNewFormat || !parsed.machineId) {
+      return jsonResponse({ error: "API key does not contain machineId" }, 400);
+    }
+    
+    machineId = parsed.machineId;
+  }
+
+  const data = await getMachineData(machineId, env);
+  
+  if (!data) {
+    return jsonResponse({ error: "Machine not found" }, 404);
+  }
+
+  const isValid = data.apiKeys?.some(k => k.key === apiKey) || false;
+  
+  if (!isValid) {
+    return jsonResponse({ error: "Invalid API key" }, 401);
+  }
+
+  return jsonResponse({ 
+    valid: true,
+    machineId,
+    providersCount: Object.keys(data.providers || {}).length
+  });
+}
+
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+

package/cloud/src/index.js

@@ -0,0 +1,233 @@
+import { initTranslators } from "open-sse/translator/index.js";
+import { ollamaModels } from "open-sse/config/ollamaModels.js";
+import { transformToOllama } from "open-sse/utils/ollamaTransform.js";
+import * as log from "./utils/logger.js";
+
+// Static imports for handlers (avoid dynamic import CPU cost)
+import { handleCleanup } from "./handlers/cleanup.js";
+import { handleCacheClear } from "./handlers/cache.js";
+import { handleSync } from "./handlers/sync.js";
+import { handleChat } from "./handlers/chat.js";
+import { handleVerify } from "./handlers/verify.js";
+import { handleTestClaude } from "./handlers/testClaude.js";
+import { handleForward } from "./handlers/forward.js";
+import { handleForwardRaw } from "./handlers/forwardRaw.js";
+import { handleEmbeddings } from "./handlers/embeddings.js";
+import { createLandingPageResponse } from "./services/landingPage.js";
+
+// Initialize translators at module load (static imports)
+initTranslators();
+
+// Helper to add CORS headers to response
+function addCorsHeaders(response) {
+  const newHeaders = new Headers(response.headers);
+  newHeaders.set("Access-Control-Allow-Origin", "*");
+  newHeaders.set("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+  newHeaders.set("Access-Control-Allow-Headers", "*");
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: newHeaders
+  });
+}
+
+const worker = {
+  async scheduled(event, env, ctx) {
+    const result = await handleCleanup(env);
+    log.info("SCHEDULED", "Cleanup completed", result);
+  },
+
+  async fetch(request, env, ctx) {
+    const startTime = Date.now();
+    const url = new URL(request.url);
+    let path = url.pathname;
+
+    // Normalize /v1/v1/* → /v1/*
+    if (path.startsWith("/v1/v1/")) {
+      path = path.replace("/v1/v1/", "/v1/");
+    } else if (path === "/v1/v1") {
+      path = "/v1";
+    }
+
+    log.request(request.method, path);
+
+    // CORS preflight
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+          "Access-Control-Allow-Headers": "*"
+        }
+      });
+    }
+
+    try {
+      // Routes
+      
+      // Landing page
+      if (path === "/" && request.method === "GET") {
+        const response = createLandingPageResponse();
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      if (path === "/health" && request.method === "GET") {
+        log.response(200, Date.now() - startTime);
+        return new Response(JSON.stringify({ status: "ok" }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+
+      // Ollama compatible - list models
+      if (path === "/api/tags" && request.method === "GET") {
+        log.response(200, Date.now() - startTime);
+        return new Response(JSON.stringify(ollamaModels), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+
+      if (path === "/cache/clear" && request.method === "POST") {
+        const response = await handleCacheClear(request, env);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      // Sync provider data by machineId (GET, POST, DELETE)
+      if (path.startsWith("/sync/") && ["GET", "POST", "DELETE"].includes(request.method)) {
+        const response = await handleSync(request, env, ctx);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      // ========== NEW FORMAT: /v1/... (machineId in API key) ==========
+      
+      // New format: /v1/chat/completions
+      if (path === "/v1/chat/completions" && request.method === "POST") {
+        const response = await handleChat(request, env, ctx, null);
+        log.response(response.status, Date.now() - startTime);
+        return addCorsHeaders(response);
+      }
+
+      // New format: /v1/messages (Claude format)
+      if (path === "/v1/messages" && request.method === "POST") {
+        const response = await handleChat(request, env, ctx, null);
+        log.response(response.status, Date.now() - startTime);
+        return addCorsHeaders(response);
+      }
+
+      // New format: /v1/embeddings
+      if (path === "/v1/embeddings" && request.method === "POST") {
+        const response = await handleEmbeddings(request, env, ctx, null);
+        log.response(response.status, Date.now() - startTime);
+        return addCorsHeaders(response);
+      }
+
+      // New format: /v1/responses (OpenAI Responses API - Codex CLI)
+      if (path === "/v1/responses" && request.method === "POST") {
+        const response = await handleChat(request, env, ctx, null);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      // New format: /v1/verify
+      if (path === "/v1/verify" && request.method === "GET") {
+        const response = await handleVerify(request, env, null);
+        log.response(response.status, Date.now() - startTime);
+        return addCorsHeaders(response);
+      }
+
+      // New format: /v1/api/chat (Ollama format)
+      if (path === "/v1/api/chat" && request.method === "POST") {
+        const clonedReq = request.clone();
+        const body = await clonedReq.json();
+        const response = await handleChat(request, env, ctx, null);
+        const ollamaResponse = transformToOllama(response, body.model || "llama3.2");
+        log.response(200, Date.now() - startTime);
+        return ollamaResponse;
+      }
+
+      // ========== OLD FORMAT: /{machineId}/v1/... ==========
+
+      // Machine ID based chat endpoint
+      if (path.match(/^\/[^\/]+\/v1\/chat\/completions$/) && request.method === "POST") {
+        const machineId = path.split("/")[1];
+        const response = await handleChat(request, env, ctx, machineId);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      // Machine ID based embeddings endpoint
+      if (path.match(/^\/[^\/]+\/v1\/embeddings$/) && request.method === "POST") {
+        const machineId = path.split("/")[1];
+        const response = await handleEmbeddings(request, env, ctx, machineId);
+        log.response(response.status, Date.now() - startTime);
+        return addCorsHeaders(response);
+      }
+
+      // Machine ID based messages endpoint (Claude format)
+      if (path.match(/^\/[^\/]+\/v1\/messages$/) && request.method === "POST") {
+        const machineId = path.split("/")[1];
+        const response = await handleChat(request, env, ctx, machineId);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      // Machine ID based api/chat endpoint (Ollama format)
+      if (path.match(/^\/[^\/]+\/v1\/api\/chat$/) && request.method === "POST") {
+        const machineId = path.split("/")[1];
+        const clonedReq = request.clone();
+        const body = await clonedReq.json();
+        const response = await handleChat(request, env, ctx, machineId);
+        const ollamaResponse = transformToOllama(response, body.model || "llama3.2");
+        log.response(200, Date.now() - startTime);
+        return ollamaResponse;
+      }
+
+      // Machine ID based verify endpoint
+      if (path.match(/^\/[^\/]+\/v1\/verify$/) && request.method === "GET") {
+        const machineId = path.split("/")[1];
+        const response = await handleVerify(request, env, machineId);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      // Test Claude - forward to Anthropic API
+      if (path === "/testClaude" && request.method === "POST") {
+        const response = await handleTestClaude(request);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      // Forward request to any endpoint
+      if (path === "/forward" && request.method === "POST") {
+        const response = await handleForward(request);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      // Forward request via raw TCP socket (bypasses CF auto headers)
+      if (path === "/forward-raw" && request.method === "POST") {
+        const response = await handleForwardRaw(request);
+        log.response(response.status, Date.now() - startTime);
+        return response;
+      }
+
+      log.warn("ROUTER", "Not found", { path });
+      return new Response(JSON.stringify({ error: "Not Found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" }
+      });
+
+    } catch (error) {
+      log.error("ROUTER", error.message, { stack: error.stack });
+      return new Response(JSON.stringify({ error: error.message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+};
+
+export default worker;
+

package/cloud/src/services/landingPage.js

@@ -0,0 +1,27 @@
+/**
+ * Landing Page Service
+ * Simple health check page for self-hosted worker
+ */
+
+/**
+ * Create landing page response
+ * @returns {Response} HTML response
+ */
+export function createLandingPageResponse() {
+  const html = `<!DOCTYPE html>
+<html><head><title>9Router Worker</title></head>
+<body style="font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#0a0a0a;color:#fff">
+<div style="text-align:center">
+<h1>9Router Worker</h1>
+<p style="color:#888">Worker is running. Configure this URL in your 9Router dashboard.</p>
+</div>
+</body></html>`;
+
+  return new Response(html, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "public, max-age=3600"
+    }
+  });
+}

package/cloud/src/services/storage.js

@@ -0,0 +1,88 @@
+import * as log from "../utils/logger.js";
+
+// Request-scoped cache for getMachineData (avoids multiple D1 queries per request)
+const requestCache = new Map();
+const CACHE_TTL_MS = 5000;
+
+/**
+ * Get machine data from D1 (with request-scope caching)
+ * @param {string} machineId
+ * @param {Object} env
+ * @returns {Promise<Object|null>}
+ */
+export async function getMachineData(machineId, env) {
+  const cached = requestCache.get(machineId);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    return cached.data;
+  }
+
+  const row = await env.DB.prepare("SELECT data FROM machines WHERE machineId = ?")
+    .bind(machineId)
+    .first();
+  
+  if (!row) {
+    log.debug("STORAGE", `Not found: ${machineId}`);
+    return null;
+  }
+  
+  const data = JSON.parse(row.data);
+  requestCache.set(machineId, { data, timestamp: Date.now() });
+  log.debug("STORAGE", `Retrieved: ${machineId}`);
+  return data;
+}
+
+/**
+ * Save machine data to D1
+ * @param {string} machineId
+ * @param {Object} data
+ * @param {Object} env
+ */
+export async function saveMachineData(machineId, data, env) {
+  const now = new Date().toISOString();
+  data.updatedAt = now;
+  
+  // Upsert to D1
+  await env.DB.prepare(`
+    INSERT INTO machines (machineId, data, updatedAt) 
+    VALUES (?, ?, ?)
+    ON CONFLICT(machineId) DO UPDATE SET data = ?, updatedAt = ?
+  `)
+    .bind(machineId, JSON.stringify(data), now, JSON.stringify(data), now)
+    .run();
+  
+  // Update cache after save
+  requestCache.set(machineId, { data, timestamp: Date.now() });
+  log.debug("STORAGE", `Saved: ${machineId}`);
+}
+
+/**
+ * Delete machine data from D1
+ * @param {string} machineId
+ * @param {Object} env
+ */
+export async function deleteMachineData(machineId, env) {
+  await env.DB.prepare("DELETE FROM machines WHERE machineId = ?")
+    .bind(machineId)
+    .run();
+  
+  // Clear cache after delete
+  requestCache.delete(machineId);
+  log.debug("STORAGE", `Deleted: ${machineId}`);
+}
+
+/**
+ * Update specific fields in machine data (for token refresh, rate limit, etc.)
+ * @param {string} machineId
+ * @param {string} connectionId
+ * @param {Object} updates
+ * @param {Object} env
+ */
+export async function updateMachineProvider(machineId, connectionId, updates, env) {
+  const data = await getMachineData(machineId, env);
+  if (!data?.providers?.[connectionId]) return;
+  
+  Object.assign(data.providers[connectionId], updates);
+  data.providers[connectionId].updatedAt = new Date().toISOString();
+  
+  await saveMachineData(machineId, data, env);
+}

package/cloud/src/services/tokenRefresh.js

@@ -0,0 +1,11 @@
+// Re-export from open-sse with worker logger
+import * as log from "../utils/logger.js";
+import {
+  TOKEN_EXPIRY_BUFFER_MS as BUFFER_MS,
+  refreshTokenByProvider as _refreshTokenByProvider
+} from "open-sse/services/tokenRefresh.js";
+
+export const TOKEN_EXPIRY_BUFFER_MS = BUFFER_MS;
+
+export const refreshTokenByProvider = (provider, credentials) => 
+  _refreshTokenByProvider(provider, credentials, log);

package/cloud/src/stubs/usageDb.js

@@ -0,0 +1,8 @@
+// Stub for cloud worker - no-op async functions
+export async function saveRequestUsage() {}
+export function trackPendingRequest() {}
+export async function appendRequestLog() {}
+export async function getUsageDb() { return { data: { history: [] } }; }
+export async function getUsageHistory() { return []; }
+export async function getUsageStats() { return {}; }
+export async function getRecentLogs() { return []; }