wyxrouter 0.4.71

package/src/app/api/translator/translate/route.js

@@ -0,0 +1,90 @@
+import { NextResponse } from "next/server";
+import { detectFormat, getTargetFormat } from "open-sse/services/provider.js";
+import { translateRequest } from "open-sse/translator/index.js";
+import { FORMATS } from "open-sse/translator/formats.js";
+import { parseModel } from "open-sse/services/model.js";
+import { getProviderConnections } from "@/lib/localDb.js";
+import { getExecutor } from "open-sse/executors/index.js";
+
+export async function POST(request) {
+  try {
+    const { step, body } = await request.json();
+
+    if (!step || !body) {
+      return NextResponse.json({ success: false, error: "Step and body required" }, { status: 400 });
+    }
+
+    switch (step) {
+      case 1: {
+        // Detect provider + formats from 1_req_client.json
+        const clientBody = body.body || body;
+        const { provider, model } = parseModel(clientBody.model);
+        const sourceFormat = detectFormat(clientBody);
+        const targetFormat = getTargetFormat(provider);
+        return NextResponse.json({ success: true, result: { provider, model, sourceFormat, targetFormat } });
+      }
+
+      case 2: {
+        // source → OpenAI intermediate (mirrors 3_req_openai.json)
+        // Translate source→openai only (half of the pipeline)
+        const clientBody = body.body || body;
+        const { provider, model } = parseModel(clientBody.model);
+        const sourceFormat = detectFormat(clientBody);
+        const stream = clientBody.stream !== false;
+
+        // translateRequest(source, OPENAI) = only the first half
+        const result = translateRequest(sourceFormat, FORMATS.OPENAI, model, clientBody, stream, null, provider);
+        delete result._toolNameMap;
+
+        return NextResponse.json({ success: true, result: { body: result } });
+      }
+
+      case 3: {
+        // OpenAI intermediate → target + build URL/headers (mirrors 4_req_target.json)
+        const openaiBody = body.body || body;
+        const provider = body.provider;
+        const model = body.model;
+
+        if (!provider || !model) {
+          return NextResponse.json({ success: false, error: "provider and model required" }, { status: 400 });
+        }
+
+        const targetFormat = getTargetFormat(provider);
+        const stream = openaiBody.stream !== false;
+
+        // translateRequest(OPENAI, target) = second half of pipeline
+        const translated = translateRequest(FORMATS.OPENAI, targetFormat, model, openaiBody, stream, null, provider);
+        delete translated._toolNameMap;
+
+        // Build URL + headers via executor (same as chatCore → executor.execute)
+        const connections = await getProviderConnections({ provider });
+        const connection = connections.find(c => c.isActive !== false);
+        if (!connection) {
+          return NextResponse.json({ success: false, error: `No active connection for provider: ${provider}` }, { status: 400 });
+        }
+
+        const credentials = {
+          apiKey: connection.apiKey,
+          accessToken: connection.accessToken,
+          refreshToken: connection.refreshToken,
+          copilotToken: connection.copilotToken,
+          projectId: connection.projectId,
+          providerSpecificData: connection.providerSpecificData
+        };
+
+        const executor = getExecutor(provider);
+        const url = executor.buildUrl(model, stream, 0, credentials);
+        const headers = executor.buildHeaders(credentials, stream);
+        const finalBody = executor.transformRequest(model, translated, stream, credentials);
+
+        return NextResponse.json({ success: true, result: { url, headers, body: finalBody } });
+      }
+
+      default:
+        return NextResponse.json({ success: false, error: "Invalid step (1-3)" }, { status: 400 });
+    }
+  } catch (error) {
+    console.error("Error in translator:", error);
+    return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/tunnel/disable/route.js

@@ -0,0 +1,12 @@
+import { NextResponse } from "next/server";
+import { disableTunnel } from "@/lib/tunnel";
+
+export async function POST() {
+  try {
+    const result = await disableTunnel();
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error("Tunnel disable error:", error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/tunnel/enable/route.js

@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { enableTunnel } from "@/lib/tunnel";
+
+const DNS_WARMUP_DELAY_MS = 8000;
+
+export async function POST() {
+  try {
+    const result = await enableTunnel();
+    // Wait for DNS warmup to propagate at Cloudflare edge after tunnel registered
+    await new Promise((r) => setTimeout(r, DNS_WARMUP_DELAY_MS));
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error("Tunnel enable error:", error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/tunnel/status/route.js

@@ -0,0 +1,13 @@
+import { NextResponse } from "next/server";
+import { getTunnelStatus, getTailscaleStatus, getDownloadStatus } from "@/lib/tunnel";
+
+export async function GET() {
+  try {
+    const [tunnel, tailscale] = await Promise.all([getTunnelStatus(), getTailscaleStatus()]);
+    const download = getDownloadStatus();
+    return NextResponse.json({ tunnel, tailscale, download });
+  } catch (error) {
+    console.error("Tunnel status error:", error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/tunnel/tailscale-check/route.js

@@ -0,0 +1,50 @@
+import os from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { NextResponse } from "next/server";
+import { isTailscaleInstalled, isTailscaleLoggedIn, TAILSCALE_SOCKET } from "@/lib/tunnel";
+import { getCachedPassword, loadEncryptedPassword } from "@/mitm/manager";
+
+const execAsync = promisify(exec);
+const EXTENDED_PATH = `/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:${process.env.PATH || ""}`;
+const PROBE_TIMEOUT_MS = 1500;
+
+async function hasBrew() {
+  try {
+    await execAsync("which brew", { windowsHide: true, env: { ...process.env, PATH: EXTENDED_PATH }, timeout: PROBE_TIMEOUT_MS });
+    return true;
+  } catch { return false; }
+}
+
+async function isDaemonRunning() {
+  try {
+    await execAsync(`tailscale --socket ${TAILSCALE_SOCKET} status --json`, {
+      windowsHide: true,
+      env: { ...process.env, PATH: EXTENDED_PATH },
+      timeout: PROBE_TIMEOUT_MS
+    });
+    return true;
+  } catch {
+    try {
+      await execAsync("pgrep -x tailscaled", { windowsHide: true, timeout: PROBE_TIMEOUT_MS });
+      return true;
+    } catch { return false; }
+  }
+}
+
+export async function GET() {
+  try {
+    const installed = isTailscaleInstalled();
+    const platform = os.platform();
+    // Run independent probes in parallel — none blocks the event loop
+    const [brewAvailable, daemonRunning] = await Promise.all([
+      platform === "darwin" ? hasBrew() : Promise.resolve(false),
+      installed ? isDaemonRunning() : Promise.resolve(false),
+    ]);
+    const loggedIn = daemonRunning ? isTailscaleLoggedIn() : false;
+    const hasCachedPassword = !!(getCachedPassword() || await loadEncryptedPassword());
+    return NextResponse.json({ installed, loggedIn, platform, brewAvailable, daemonRunning, hasCachedPassword });
+  } catch (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/tunnel/tailscale-disable/route.js

@@ -0,0 +1,12 @@
+import { NextResponse } from "next/server";
+import { disableTailscale } from "@/lib/tunnel";
+
+export async function POST() {
+  try {
+    const result = await disableTailscale();
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error("Tailscale disable error:", error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/tunnel/tailscale-enable/route.js

@@ -0,0 +1,12 @@
+import { NextResponse } from "next/server";
+import { enableTailscale } from "@/lib/tunnel";
+
+export async function POST() {
+  try {
+    const result = await enableTailscale();
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error("Tailscale enable error:", error.message);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/tunnel/tailscale-install/route.js

@@ -0,0 +1,72 @@
+"use server";
+
+import os from "os";
+import { execSync } from "child_process";
+import { installTailscale, loadState, generateShortId } from "@/lib/tunnel";
+import { getCachedPassword, loadEncryptedPassword, initDbHooks } from "@/mitm/manager";
+import { getSettings, updateSettings } from "@/lib/localDb";
+
+initDbHooks(getSettings, updateSettings);
+
+const EXTENDED_PATH = `/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:${process.env.PATH || ""}`;
+
+function hasBrew() {
+  try { execSync("which brew", { stdio: "ignore", windowsHide: true, env: { ...process.env, PATH: EXTENDED_PATH } }); return true; } catch { return false; }
+}
+
+export async function POST(request) {
+  const body = await request.json().catch(() => ({}));
+  const platform = os.platform();
+  const isWindows = platform === "win32";
+  const isBrew = platform === "darwin" && hasBrew();
+  const needsPassword = !isWindows && !isBrew;
+
+  const sudoPassword = body.sudoPassword || getCachedPassword() || await loadEncryptedPassword() || "";
+
+  if (needsPassword && !sudoPassword.trim()) {
+    return new Response(JSON.stringify({ error: "Sudo password is required" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  const shortId = loadState()?.shortId || generateShortId();
+
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      let closed = false;
+      const send = (event, data) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+        } catch {
+          closed = true;
+        }
+      };
+
+      try {
+        const result = await installTailscale(sudoPassword, shortId, (msg) => {
+          send("progress", { message: msg });
+        });
+        send("done", { success: true, authUrl: result?.authUrl || null });
+      } catch (error) {
+        console.error("Tailscale install error:", error);
+        const msg = error.message?.includes("incorrect password") || error.message?.includes("Sorry")
+          ? "Wrong sudo password"
+          : error.message;
+        send("error", { error: msg });
+      } finally {
+        if (!closed) { try { controller.close(); } catch {} }
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+    },
+  });
+}

package/src/app/api/usage/[connectionId]/route.js

@@ -0,0 +1,188 @@
+// Ensure proxyFetch is loaded to patch globalThis.fetch
+import "open-sse/index.js";
+
+import { getProviderConnectionById, updateProviderConnection } from "@/lib/localDb";
+import { getUsageForProvider } from "open-sse/services/usage.js";
+import { getExecutor } from "open-sse/executors/index.js";
+import { resolveConnectionProxyConfig } from "@/lib/network/connectionProxy";
+import { USAGE_APIKEY_PROVIDERS } from "@/shared/constants/providers";
+
+// Detect auth-expired messages returned by usage providers instead of throwing
+const AUTH_EXPIRED_PATTERNS = ["expired", "authentication", "unauthorized", "401", "re-authorize"];
+function isAuthExpiredMessage(usage) {
+  if (!usage?.message) return false;
+  const msg = usage.message.toLowerCase();
+  return AUTH_EXPIRED_PATTERNS.some((p) => msg.includes(p));
+}
+
+/**
+ * Refresh credentials using executor and update database
+ * @param {boolean} force - Skip needsRefresh check and always attempt refresh
+ * @returns Promise<{ connection, refreshed: boolean }>
+ */
+async function refreshAndUpdateCredentials(connection, force = false, proxyOptions = null) {
+  const executor = getExecutor(connection.provider);
+
+  // Build credentials object from connection
+  const credentials = {
+    accessToken: connection.accessToken,
+    refreshToken: connection.refreshToken,
+    idToken: connection.idToken,
+    expiresAt: connection.expiresAt || connection.tokenExpiresAt,
+    lastRefreshAt: connection.lastRefreshAt,
+    connectionId: connection.id,
+    providerSpecificData: connection.providerSpecificData,
+    // For GitHub
+    copilotToken: connection.providerSpecificData?.copilotToken,
+    copilotTokenExpiresAt: connection.providerSpecificData?.copilotTokenExpiresAt,
+  };
+
+  // Check if refresh is needed (skip when force=true)
+  const needsRefresh = force || executor.needsRefresh(credentials);
+
+  if (!needsRefresh) {
+    return { connection, refreshed: false };
+  }
+
+  // Use executor's refreshCredentials method (with optional proxy)
+  const refreshResult = await executor.refreshCredentials(credentials, console, proxyOptions);
+
+  if (!refreshResult) {
+    // Refresh failed but we still have an accessToken — try with existing token
+    if (connection.accessToken) {
+      return { connection, refreshed: false };
+    }
+    throw new Error("Failed to refresh credentials. Please re-authorize the connection.");
+  }
+
+  // Build update object
+  const now = new Date().toISOString();
+  const updateData = {
+    updatedAt: now,
+  };
+
+  // Update accessToken if present
+  if (refreshResult.accessToken) {
+    updateData.accessToken = refreshResult.accessToken;
+  }
+
+  // Update refreshToken if present
+  if (refreshResult.refreshToken) {
+    updateData.refreshToken = refreshResult.refreshToken;
+  }
+
+  if (refreshResult.idToken) {
+    updateData.idToken = refreshResult.idToken;
+  }
+
+  if (refreshResult.lastRefreshAt) {
+    updateData.lastRefreshAt = refreshResult.lastRefreshAt;
+  }
+
+  // Update token expiry
+  if (refreshResult.expiresIn) {
+    updateData.expiresAt = new Date(Date.now() + refreshResult.expiresIn * 1000).toISOString();
+    updateData.expiresIn = refreshResult.expiresIn;
+  } else if (refreshResult.expiresAt) {
+    updateData.expiresAt = refreshResult.expiresAt;
+  }
+
+  // Handle provider-specific data (copilotToken for GitHub, etc.)
+  const providerSpecificUpdates = {
+    ...(refreshResult.providerSpecificData || {}),
+    ...(refreshResult.copilotToken ? { copilotToken: refreshResult.copilotToken } : {}),
+    ...(refreshResult.copilotTokenExpiresAt ? { copilotTokenExpiresAt: refreshResult.copilotTokenExpiresAt } : {}),
+  };
+  if (Object.keys(providerSpecificUpdates).length > 0) {
+    updateData.providerSpecificData = {
+      ...(connection.providerSpecificData || {}),
+      ...providerSpecificUpdates,
+    };
+  }
+
+  // Update database
+  await updateProviderConnection(connection.id, updateData);
+
+  // Return updated connection
+  const updatedConnection = {
+    ...connection,
+    ...updateData,
+    providerSpecificData: updateData.providerSpecificData || connection.providerSpecificData,
+  };
+
+  return {
+    connection: updatedConnection,
+    refreshed: true,
+  };
+}
+
+/**
+ * GET /api/usage/[connectionId] - Get usage data for a specific connection
+ */
+export async function GET(request, { params }) {
+  let connection;
+  try {
+    const { connectionId } = await params;
+
+
+    // Get connection from database
+    connection = await getProviderConnectionById(connectionId);
+    if (!connection) {
+      return Response.json({ error: "Connection not found" }, { status: 404 });
+    }
+
+    // Allow OAuth connections, plus whitelisted apikey providers (glm/minimax/...)
+    const isOAuth = connection.authType === "oauth";
+    const isApikeyEligible =
+      connection.authType === "apikey" &&
+      USAGE_APIKEY_PROVIDERS.includes(connection.provider);
+
+    if (!isOAuth && !isApikeyEligible) {
+      return Response.json({ message: "Usage not available for this connection" });
+    }
+
+    // Resolve connection proxy config; force strictProxy=false so quota/refresh fall back to direct on failure
+    const proxyConfig = await resolveConnectionProxyConfig(connection.providerSpecificData);
+    const proxyOptions = {
+      connectionProxyEnabled: proxyConfig.connectionProxyEnabled === true,
+      connectionProxyUrl: proxyConfig.connectionProxyUrl || "",
+      connectionNoProxy: proxyConfig.connectionNoProxy || "",
+      vercelRelayUrl: proxyConfig.vercelRelayUrl || "",
+      strictProxy: false,
+    };
+
+    // Refresh credentials only for OAuth connections (apikey has no token refresh)
+    if (isOAuth) {
+      try {
+        const result = await refreshAndUpdateCredentials(connection, false, proxyOptions);
+        connection = result.connection;
+      } catch (refreshError) {
+        console.error("[Usage API] Credential refresh failed:", refreshError);
+        return Response.json({
+          error: `Credential refresh failed: ${refreshError.message}`
+        }, { status: 401 });
+      }
+    }
+
+    // Fetch usage from provider API
+    let usage = await getUsageForProvider(connection, proxyOptions);
+
+    // If provider returned an auth-expired message instead of throwing,
+    // force-refresh token and retry once (OAuth only)
+    if (isOAuth && isAuthExpiredMessage(usage) && connection.refreshToken) {
+      try {
+        const retryResult = await refreshAndUpdateCredentials(connection, true, proxyOptions);
+        connection = retryResult.connection;
+        usage = await getUsageForProvider(connection, proxyOptions);
+      } catch (retryError) {
+        console.warn(`[Usage] ${connection.provider}: force refresh failed: ${retryError.message}`);
+      }
+    }
+
+    return Response.json(usage);
+  } catch (error) {
+    const provider = connection?.provider ?? "unknown";
+    console.warn(`[Usage] ${provider}: ${error.message}`);
+    return Response.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/usage/chart/route.js

@@ -0,0 +1,21 @@
+import { NextResponse } from "next/server";
+import { getChartData } from "@/lib/usageDb";
+
+const VALID_PERIODS = new Set(["today", "24h", "7d", "30d", "60d"]);
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const period = searchParams.get("period") || "7d";
+
+    if (!VALID_PERIODS.has(period)) {
+      return NextResponse.json({ error: "Invalid period" }, { status: 400 });
+    }
+
+    const data = await getChartData(period);
+    return NextResponse.json(data);
+  } catch (error) {
+    console.error("[API] Failed to get chart data:", error);
+    return NextResponse.json({ error: "Failed to fetch chart data" }, { status: 500 });
+  }
+}

package/src/app/api/usage/history/route.js

@@ -0,0 +1,12 @@
+import { NextResponse } from "next/server";
+import { getUsageStats } from "@/lib/usageDb";
+
+export async function GET() {
+  try {
+    const stats = await getUsageStats();
+    return NextResponse.json(stats);
+  } catch (error) {
+    console.error("Error fetching usage stats:", error);
+    return NextResponse.json({ error: "Failed to fetch usage stats" }, { status: 500 });
+  }
+}

package/src/app/api/usage/logs/route.js

@@ -0,0 +1,12 @@
+import { NextResponse } from "next/server";
+import { getRecentLogs } from "@/lib/usageDb";
+
+export async function GET() {
+  try {
+    const logs = await getRecentLogs(200);
+    return NextResponse.json(logs);
+  } catch (error) {
+    console.error("Error fetching logs:", error);
+    return NextResponse.json({ error: "Failed to fetch logs" }, { status: 500 });
+  }
+}

package/src/app/api/usage/providers/route.js

@@ -0,0 +1,42 @@
+import { NextResponse } from "next/server";
+import { getRequestDetails } from "@/lib/requestDetailsDb";
+import { getProviderNodes } from "@/lib/localDb";
+import { AI_PROVIDERS, getProviderByAlias } from "@/shared/constants/providers";
+
+/**
+ * GET /api/usage/providers
+ * Returns list of unique providers from request details
+ */
+export async function GET() {
+  try {
+    const { details } = await getRequestDetails({ pageSize: 9999 });
+
+    // Extract unique providers
+    const providerIds = [...new Set(details.map(r => r.provider).filter(Boolean))].sort();
+
+    const providerNodes = await getProviderNodes();
+    const nodeMap = {};
+    for (const node of providerNodes) {
+      nodeMap[node.id] = node.name;
+    }
+
+    const providers = providerIds.map(providerId => {
+      let name = providerId;
+      if (nodeMap[providerId]) {
+        name = nodeMap[providerId];
+      } else {
+        const providerConfig = getProviderByAlias(providerId) || AI_PROVIDERS[providerId];
+        if (providerConfig?.name) name = providerConfig.name;
+      }
+      return { id: providerId, name };
+    });
+
+    return NextResponse.json({ providers });
+  } catch (error) {
+    console.error("[API] Failed to get providers:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch providers" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/usage/request-details/route.js

@@ -0,0 +1,57 @@
+import { NextResponse } from "next/server";
+import { getRequestDetails } from "@/lib/usageDb";
+
+/**
+ * GET /api/usage/request-details
+ * Query parameters: page, pageSize (1-100), provider, model, connectionId, status, startDate, endDate
+ */
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    
+    const page = parseInt(searchParams.get("page")) || 1;
+    const pageSize = parseInt(searchParams.get("pageSize")) || 20;
+    const provider = searchParams.get("provider");
+    const model = searchParams.get("model");
+    const connectionId = searchParams.get("connectionId");
+    const status = searchParams.get("status");
+    const startDate = searchParams.get("startDate");
+    const endDate = searchParams.get("endDate");
+    
+    if (page < 1) {
+      return NextResponse.json(
+        { error: "Page must be >= 1" },
+        { status: 400 }
+      );
+    }
+    
+    if (pageSize < 1 || pageSize > 100) {
+      return NextResponse.json(
+        { error: "PageSize must be between 1 and 100" },
+        { status: 400 }
+      );
+    }
+    
+    const filter = {
+      page,
+      pageSize
+    };
+    
+    if (provider) filter.provider = provider;
+    if (model) filter.model = model;
+    if (connectionId) filter.connectionId = connectionId;
+    if (status) filter.status = status;
+    if (startDate) filter.startDate = startDate;
+    if (endDate) filter.endDate = endDate;
+    
+    const result = await getRequestDetails(filter);
+    
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error("[API] Failed to get request details:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch request details" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/usage/request-logs/route.js

@@ -0,0 +1,13 @@
+import { NextResponse } from "next/server";
+import { getRecentLogs } from "@/lib/usageDb";
+
+export async function GET() {
+  try {
+    const logs = await getRecentLogs(200);
+    return NextResponse.json(logs);
+  } catch (error) {
+    console.error("[API ERROR] /api/usage/logs failed:", error);
+    console.error("[API ERROR] Stack:", error?.stack);
+    return NextResponse.json({ error: "Failed to fetch logs" }, { status: 500 });
+  }
+}

package/src/app/api/usage/stats/route.js

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { getUsageStats } from "@/lib/usageDb";
+
+const VALID_PERIODS = new Set(["today", "24h", "7d", "30d", "60d", "all"]);
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const period = searchParams.get("period") || "7d";
+
+    if (!VALID_PERIODS.has(period)) {
+      return NextResponse.json({ error: "Invalid period" }, { status: 400 });
+    }
+
+    const stats = await getUsageStats(period);
+    return NextResponse.json(stats);
+  } catch (error) {
+    console.error("[API] Failed to get usage stats:", error);
+    return NextResponse.json({ error: "Failed to fetch usage stats" }, { status: 500 });
+  }
+}