zevairouter 1.0.154 → 1.0.155

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

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

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

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

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

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

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

@@ -1,40 +0,0 @@
-// Ensure proxyFetch is loaded to patch globalThis.fetch
-import "open-sse/index.js";
-
-import { getQuotaSnapshot } from "@/lib/localDb";
-import { resolveUsageForConnection } from "@/lib/usage/quotaService";
-
-// Serve cached quota when it's fresher than this; otherwise fetch live.
-const CACHE_FRESH_MS = 60 * 1000;
-
-/**
- * GET /api/usage/[connectionId] - Get usage data for a specific connection.
- *
- * Reads the server-side quota cache first (instant); only hits the upstream API
- * when the cache is stale or `?refresh=1` is passed. Live fetches also write the
- * cache so routing + dashboard stay in sync.
- */
-export async function GET(request, { params }) {
-  let connectionId;
-  try {
-    ({ connectionId } = await params);
-    const url = new URL(request.url);
-    const force = url.searchParams.get("refresh") === "1";
-
-    if (!force) {
-      const snap = await getQuotaSnapshot(connectionId);
-      if (snap?.usage && Date.now() - new Date(snap.fetchedAt).getTime() < CACHE_FRESH_MS) {
-        return Response.json({ ...snap.usage, cached: true, fetchedAt: snap.fetchedAt });
-      }
-    }
-
-    const usage = await resolveUsageForConnection(connectionId, { writeCache: true, force });
-    if (usage?.notFound) {
-      return Response.json({ error: "Connection not found" }, { status: 404 });
-    }
-    return Response.json(usage);
-  } catch (error) {
-    console.warn(`[Usage] ${connectionId || "unknown"}: ${error.message}`);
-    return Response.json({ error: error.message }, { status: 500 });
-  }
-}

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

@@ -1,126 +0,0 @@
-import { NextResponse } from "next/server";
-import { getAllQuotaSnapshots } from "@/lib/db/repos/quotaCacheRepo";
-import { getProviderConnections } from "@/lib/localDb";
-import { refreshQuotaConnections } from "@/lib/usage/quotaRefresh";
-
-/**
- * GET /api/usage/aggregate?provider=antigravity
- *
- * Returns aggregated quota data across ALL connections of a provider, reading
- * from the server-side quotaCache (populated by the background refresh loop).
- * This avoids the client having to fetch quota per-connection for every account
- * just to build an aggregate card.
- *
- * Response shape matches what the client's parseQuotaData expects:
- *   { plan, quotas: { [modelKey]: { used, total, resetAt, remainingPercentage, displayName } }, accountCount, activeCount, deadCount }
- */
-export async function GET(request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const provider = searchParams.get("provider");
-    const force = searchParams.get("refresh") === "1";
-
-    if (!provider) {
-      return NextResponse.json({ error: "provider query param required" }, { status: 400 });
-    }
-
-    // Get all connections for this provider to know the full count
-    const allConnections = await getProviderConnections({ provider });
-    const activeConnections = allConnections.filter((c) => c.isActive ?? true);
-
-    if (force) {
-      await refreshQuotaConnections(activeConnections, { force: true });
-    }
-
-    // Get all cached quota snapshots for this provider
-    const snapshots = await getAllQuotaSnapshots(provider);
-
-    // Build a set of active connection IDs for filtering
-    const activeIds = new Set(activeConnections.map((c) => c.id));
-
-    // Aggregate quotas across all snapshots (only active connections)
-    const aggregated = {};
-    let accountsWithQuota = 0;
-    let deadCount = 0;
-
-    for (const snap of snapshots) {
-      // Only aggregate active connections
-      if (!activeIds.has(snap.connectionId)) continue;
-
-      const usage = snap.usage;
-      if (!usage) continue;
-
-      if (usage.accountDead) {
-        deadCount++;
-        continue;
-      }
-
-      const quotas = usage.quotas;
-      if (!quotas || typeof quotas !== "object" || Object.keys(quotas).length === 0) continue;
-
-      accountsWithQuota++;
-
-      for (const [modelKey, quota] of Object.entries(quotas)) {
-        if (!aggregated[modelKey]) {
-          aggregated[modelKey] = {
-            used: 0,
-            total: 0,
-            resetAt: null,
-            displayName: quota.displayName || modelKey,
-            remainingPercentage: null, // Will compute after summing
-            unlimited: false,
-            _pctSum: 0,
-            _pctCount: 0,
-          };
-        }
-
-        aggregated[modelKey].used += Number(quota.used) || 0;
-        aggregated[modelKey].total += Number(quota.total) || 0;
-        if (quota.unlimited === true) aggregated[modelKey].unlimited = true;
-        if (quota.remainingPercentage != null && Number.isFinite(Number(quota.remainingPercentage))) {
-          aggregated[modelKey]._pctSum += Number(quota.remainingPercentage);
-          aggregated[modelKey]._pctCount += 1;
-        }
-
-        // Use the earliest resetAt across all accounts
-        if (quota.resetAt) {
-          if (!aggregated[modelKey].resetAt ||
-              new Date(quota.resetAt).getTime() < new Date(aggregated[modelKey].resetAt).getTime()) {
-            aggregated[modelKey].resetAt = quota.resetAt;
-          }
-        }
-      }
-    }
-
-    // Compute remaining percentage from aggregated used/total
-    for (const quota of Object.values(aggregated)) {
-      if (quota.unlimited) {
-        // Grok Code / included pools have total:0 — do NOT collapse to 0%.
-        quota.remainingPercentage = 100;
-        quota.total = 0;
-      } else if (quota.total > 0) {
-        quota.remainingPercentage = ((quota.total - quota.used) / quota.total) * 100;
-      } else if (quota._pctCount > 0) {
-        quota.remainingPercentage = quota._pctSum / quota._pctCount;
-      } else {
-        quota.remainingPercentage = 0;
-      }
-      delete quota._pctSum;
-      delete quota._pctCount;
-    }
-
-    return NextResponse.json({
-      plan: provider.charAt(0).toUpperCase() + provider.slice(1),
-      quotas: aggregated,
-      accountCount: activeConnections.length,
-      accountsWithQuota,
-      deadCount,
-    });
-  } catch (error) {
-    console.error("[API] Failed to aggregate usage:", error);
-    return NextResponse.json(
-      { error: "Failed to aggregate usage" },
-      { status: 500 }
-    );
-  }
-}

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

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

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

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

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

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

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

@@ -1,23 +0,0 @@
-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 });
-  }
-}

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

@@ -1,142 +0,0 @@
-import { getUsageStats, statsEmitter, getActiveRequests } from "@/lib/usageDb";
-
-export const dynamic = "force-dynamic";
-
-export async function GET(request) {
-  const encoder = new TextEncoder();
-  const state = {
-    cachedStats: null,
-    closed: false,
-    drainScheduled: false,
-    draining: false,
-    fullRequested: false,
-    keepalive: null,
-    pendingRequested: false,
-    send: null,
-    sendPending: null,
-  };
-
-  let cleanup = () => {};
-
-  const stream = new ReadableStream({
-    start(controller) {
-      const enqueue = (payload) => {
-        if (state.closed) return false;
-        try {
-          controller.enqueue(encoder.encode(payload));
-          return true;
-        } catch {
-          cleanup();
-          return false;
-        }
-      };
-
-      cleanup = () => {
-        if (state.closed) return;
-        state.closed = true;
-        statsEmitter.off("update", state.send);
-        statsEmitter.off("pending", state.sendPending);
-        if (state.keepalive !== null) {
-          clearInterval(state.keepalive);
-          state.keepalive = null;
-        }
-        request?.signal?.removeEventListener("abort", cleanup);
-      };
-
-      const sendPendingStats = async () => {
-        if (!state.cachedStats || state.closed) return;
-        const { activeRequests, recentRequests, errorProvider } = await getActiveRequests();
-        if (state.closed) return;
-        enqueue(`data: ${JSON.stringify({
-          ...state.cachedStats,
-          activeRequests,
-          recentRequests,
-          errorProvider,
-        })}\n\n`);
-      };
-
-      function scheduleDrain() {
-        if (state.closed || state.draining || state.drainScheduled) return;
-        state.drainScheduled = true;
-        queueMicrotask(() => {
-          state.drainScheduled = false;
-          void drain();
-        });
-      }
-
-      async function drain() {
-        if (state.draining || state.closed) return;
-        state.draining = true;
-
-        try {
-          while (!state.closed && (state.fullRequested || state.pendingRequested)) {
-            const fullRefresh = state.fullRequested;
-            state.fullRequested = false;
-            state.pendingRequested = false;
-
-            if (!fullRefresh) {
-              await sendPendingStats();
-              continue;
-            }
-
-            // Keep the UI responsive from cached totals while the heavier aggregate refresh runs.
-            await sendPendingStats();
-            if (state.closed) break;
-
-            const stats = await getUsageStats();
-            if (state.closed) break;
-            state.cachedStats = stats;
-            enqueue(`data: ${JSON.stringify(stats)}\n\n`);
-          }
-        } catch (error) {
-          cleanup();
-          try { controller.error(error); } catch {}
-        } finally {
-          state.draining = false;
-          if (!state.closed && (state.fullRequested || state.pendingRequested)) {
-            scheduleDrain();
-          }
-        }
-      }
-
-      state.send = () => {
-        if (state.closed) return;
-        state.fullRequested = true;
-        scheduleDrain();
-      };
-      state.sendPending = () => {
-        if (state.closed) return;
-        state.pendingRequested = true;
-        scheduleDrain();
-      };
-
-      statsEmitter.on("update", state.send);
-      statsEmitter.on("pending", state.sendPending);
-      request?.signal?.addEventListener("abort", cleanup, { once: true });
-
-      if (request?.signal?.aborted) {
-        cleanup();
-        return;
-      }
-
-      state.keepalive = setInterval(() => {
-        enqueue(": ping\n\n");
-      }, 25000);
-      state.keepalive.unref?.();
-
-      state.send();
-    },
-
-    cancel() {
-      cleanup();
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    },
-  });
-}