@amir83nasr/10router 0.1.7 → 0.1.9

package/src/app/api/usage/health/route.ts

@@ -0,0 +1,121 @@
+import { NextResponse } from "next/server";
+import { getAdapter } from "@/lib/db/driver.js";
+import { getProviderConnections } from "@/lib/db/index.js";
+import { parseJson } from "@/lib/db/helpers/jsonCol.js";
+import { summarizeProviderHealth } from "@/lib/usageHealth";
+
+const HISTORY_LIMIT = 5000;
+const DETAIL_LIMIT = 200;
+const WINDOW_MS = 24 * 60 * 60 * 1000;
+
+function extractError(data: any): string | null {
+  const r = data?.response;
+  if (!r || typeof r !== "object") return null;
+  if (typeof r.error === "string") return r.error;
+  if (r.error != null) {
+    try {
+      return JSON.stringify(r.error);
+    } catch {
+      return String(r.error);
+    }
+  }
+  return null;
+}
+
+/**
+ * GET /api/usage/health
+ * Fallback inspector: per-account success rate, p50 latency, last error,
+ * cooldown state + recent failure trace (last 24h window).
+ */
+export async function GET() {
+  try {
+    const db = await getAdapter();
+    const cutoffIso = new Date(Date.now() - WINDOW_MS).toISOString();
+
+    const historyRows = db.all(
+      `SELECT provider, connectionId, status, timestamp FROM usageHistory WHERE timestamp >= ? ORDER BY timestamp DESC LIMIT ?`,
+      [cutoffIso, HISTORY_LIMIT],
+    ) as Array<{
+      provider: string | null;
+      connectionId: string | null;
+      status: string | null;
+      timestamp: string;
+    }>;
+
+    const detailRaw = db.all(`SELECT data FROM requestDetails ORDER BY timestamp DESC LIMIT ?`, [
+      DETAIL_LIMIT,
+    ]) as Array<{ data: string }>;
+
+    const detailRows: Array<{
+      provider?: string | null;
+      connectionId?: string | null;
+      timestamp?: string;
+      status?: string | null;
+      latencyMs?: number;
+      error?: string | null;
+    }> = [];
+    for (const row of detailRaw) {
+      const data = parseJson(row.data, null) as any;
+      if (!data) continue;
+      const latencyMs =
+        typeof data?.latency?.total === "number"
+          ? data.latency.total
+          : typeof data?.data?.latency?.total === "number"
+            ? data.data.latency.total
+            : undefined;
+      detailRows.push({
+        provider: data.provider || null,
+        connectionId: data.connectionId || null,
+        timestamp: data.timestamp || "",
+        status: data.status || null,
+        latencyMs,
+        error: extractError(data),
+      });
+    }
+
+    // Attach model names to recent failures (cheap second pass over parsed rows).
+    const parsedDetails = detailRaw.map((r) => parseJson(r.data, null) as any).filter(Boolean);
+
+    const connections = await getProviderConnections();
+
+    const { providers, recentFailures } = summarizeProviderHealth({
+      historyRows: historyRows.map((r) => ({
+        provider: r.provider,
+        connectionId: r.connectionId,
+        status: r.status,
+        timestamp: r.timestamp,
+      })),
+      detailRows,
+      connections: connections.map((c: any) => ({
+        id: c.id,
+        provider: c.provider,
+        name: c.name || c.email || null,
+        rateLimitedUntil: c.rateLimitedUntil || null,
+        testStatus: c.testStatus || null,
+        lastError: c.lastError ?? null,
+      })),
+      cutoffIso,
+    });
+
+    const modelByKey = new Map<string, string>();
+    for (const d of parsedDetails) {
+      if (d?.provider && d?.connectionId && d?.timestamp && d?.model) {
+        modelByKey.set(`${d.provider}|||${d.connectionId}|||${d.timestamp}`, d.model);
+      }
+    }
+    const failuresWithModel = recentFailures.map((f) => ({
+      ...f,
+      model: modelByKey.get(`${f.provider}|||${f.connectionId}|||${f.timestamp}`) || "",
+    }));
+
+    return NextResponse.json({
+      generatedAt: new Date().toISOString(),
+      window: "24h",
+      providers,
+      recentFailures: failuresWithModel,
+    });
+  } catch (error) {
+    console.error("[API] Failed to get usage health:", error);
+    return NextResponse.json({ error: "Failed to fetch provider health" }, { status: 500 });
+  }
+}

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

@@ -2,84 +2,90 @@ import { getUsageStats, statsEmitter, getActiveRequests } from "@/lib/usageDb";
 
 export const dynamic = "force-dynamic";
 
+// ── SHARED STATS CACHE ───────────────────────────────────────────────────
+// Every open dashboard tab holds one of these streams, and statsEmitter fires
+// on every saved request. Recomputing getUsageStats() (two full table reads +
+// a 100-row scan + the whole daily-summary fold) once per client per event
+// made server CPU scale with tabs × request rate. One cache + one in-flight
+// recompute, shared by every subscriber in this process, makes N tabs cost the
+// same as one. Module scope persists across requests in the Node server.
+//
+// Only the active/recent overlay is pushed downstream (that is all the client
+// merges), so the heavy snapshot is read for its cached fields alone.
+let cache = null;
+let inflight = null;
+
+// Concurrent bursts collapse onto a single getUsageStats() call.
+function refreshStats() {
+  if (!inflight) {
+    inflight = Promise.resolve()
+      .then(() => getUsageStats("all"))
+      .then((stats) => {
+        cache = stats;
+        return stats;
+      })
+      .catch(() => cache) // keep serving the last good snapshot
+      .finally(() => {
+        inflight = null;
+      });
+  }
+  return inflight;
+}
+
+// Fresh active/recent overlay, primed by the shared snapshot. Null before the
+// first compute so callers can skip a duplicate push.
+async function overlay() {
+  if (!cache) await refreshStats();
+  if (!cache) return null;
+  return getActiveRequests();
+}
+
+// ── STREAM ───────────────────────────────────────────────────────────────
 export async function GET() {
   const encoder = new TextEncoder();
-  const state = {
-    closed: false,
-    keepalive: null,
-    send: null,
-    sendPending: null,
-    cachedStats: null,
+  let closed = false;
+  let keepalive = null;
+  let controller = null;
+
+  const write = (chunk) => {
+    if (closed) return;
+    try {
+      controller.enqueue(encoder.encode(chunk));
+    } catch {
+      teardown();
+    }
   };
 
-  const stream = new ReadableStream({
-    async start(controller) {
-      // Full stats refresh (heavy) + immediate lightweight push
-      state.send = async () => {
-        if (state.closed) return;
-        try {
-          // Push lightweight update immediately so UI reflects changes fast
-          if (state.cachedStats) {
-            const { activeRequests, recentRequests, errorProvider } = await getActiveRequests();
-            const quickStats = {
-              ...state.cachedStats,
-              activeRequests,
-              recentRequests,
-              errorProvider,
-            };
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(quickStats)}\n\n`));
-          }
-          // Then do full recalc and update cache
-          const stats = await getUsageStats();
-          state.cachedStats = stats;
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(stats)}\n\n`));
-        } catch {
-          state.closed = true;
-          statsEmitter.off("update", state.send);
-          statsEmitter.off("pending", state.sendPending);
-          clearInterval(state.keepalive);
-        }
-      };
+  const sendEvent = (payload) => write(`data: ${JSON.stringify(payload)}\n\n`);
 
-      // Lightweight push: only refresh activeRequests + recentRequests on pending changes
-      state.sendPending = async () => {
-        if (state.closed || !state.cachedStats) return;
-        try {
-          const { activeRequests, recentRequests, errorProvider } = await getActiveRequests();
-          const stats = { ...state.cachedStats, activeRequests, recentRequests, errorProvider };
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(stats)}\n\n`));
-        } catch {
-          state.closed = true;
-          statsEmitter.off("update", state.send);
-          statsEmitter.off("pending", state.sendPending);
-          clearInterval(state.keepalive);
-        }
-      };
+  const send = async () => {
+    if (closed) return;
+    const stats = await overlay();
+    if (stats && !closed) sendEvent(stats);
+  };
 
-      await state.send();
+  // Cheap path: only the active/recent overlay moved.
+  const sendPending = send;
 
-      statsEmitter.on("update", state.send);
-      statsEmitter.on("pending", state.sendPending);
+  const teardown = () => {
+    if (closed) return;
+    closed = true;
+    statsEmitter.off("update", send);
+    statsEmitter.off("pending", sendPending);
+    clearInterval(keepalive);
+  };
 
-      state.keepalive = setInterval(() => {
-        if (state.closed) {
-          clearInterval(state.keepalive);
-          return;
-        }
-        try {
-          controller.enqueue(encoder.encode(": ping\n\n"));
-        } catch {
-          state.closed = true;
-          clearInterval(state.keepalive);
-        }
-      }, 25000);
+  const stream = new ReadableStream({
+    async start(c) {
+      controller = c;
+      await send();
+      if (closed) return;
+      statsEmitter.on("update", send);
+      statsEmitter.on("pending", sendPending);
+      keepalive = setInterval(() => write(": ping\n\n"), 25000);
     },
-
     cancel() {
-      state.closed = true;
-      statsEmitter.off("update", state.send);
-      statsEmitter.off("pending", state.sendPending);
-      clearInterval(state.keepalive);
+      teardown();
     },
   });
 

package/src/app/api/v1/models/route.js

@@ -108,10 +108,22 @@ const LIVE_MODEL_RESOLVERS = {
     return result?.models?.length ? { models: result.models } : null;
   },
   zed: async (conn) => {
-    const result = await resolveZedModels({
-      accessToken: conn.accessToken,
-      providerSpecificData: conn.providerSpecificData || {},
-    });
+    const proxy = await resolveConnectionProxyConfig(conn.providerSpecificData || {});
+    const result = await resolveZedModels(
+      {
+        accessToken: conn.accessToken,
+        providerSpecificData: conn.providerSpecificData || {},
+      },
+      {
+        proxyOptions: {
+          connectionProxyEnabled: proxy.connectionProxyEnabled === true,
+          connectionProxyUrl: proxy.connectionProxyUrl || "",
+          connectionNoProxy: proxy.connectionNoProxy || "",
+          vercelRelayUrl: proxy.vercelRelayUrl || "",
+          strictProxy: proxy.strictProxy === true,
+        },
+      },
+    );
     if (!result?.models?.length) return null;
     return {
       models: result.models
@@ -182,10 +194,12 @@ async function fetchCompatibleModelIds(connection) {
   if (isOpenAICompatibleProvider(connection.provider)) {
     headers.Authorization = `Bearer ${connection.apiKey}`;
   } else if (isAnthropicCompatibleProvider(connection.provider)) {
+    // Anthropic's model list lives at the API root, not under /messages.
+    // `-"/messages".length` matters: a bare -9 eats the "m" of "models".
     if (url.endsWith("/messages/models")) {
-      url = url.slice(0, -9);
+      url = url.slice(0, -"/messages".length);
     } else if (url.endsWith("/messages")) {
-      url = `${url.slice(0, -9)}/models`;
+      url = `${url.slice(0, -"/messages".length)}/models`;
     }
     headers["x-api-key"] = connection.apiKey;
     headers["anthropic-version"] = "2023-06-01";

package/src/lib/db/adapters/betterSqliteAdapter.js

@@ -1,10 +1,21 @@
-import Database from "better-sqlite3";
+import { createRequire } from "node:module";
 import { PRAGMA_SQL } from "../schema.js";
 
 // Periodic checkpoint to keep WAL file small (avoid huge -wal/-shm growth)
 const CHECKPOINT_INTERVAL_MS = 60 * 1000;
 
+function loadBetterSqlite3() {
+  // Lazy require (NOT a static import) so Next.js webpack/Turbopack never
+  // tries to resolve or bundle it at build time: the package is an optional
+  // manual install, absent from dependencies. Specifier is computed to defeat
+  // static analysis; missing package → throws → driver.js falls through to
+  // node:sqlite / sql.js.
+  const pkg = ["better", "sqlite3"].join("-");
+  return createRequire(import.meta.url)(pkg);
+}
+
 export function createBetterSqliteAdapter(filePath) {
+  const Database = loadBetterSqlite3();
   const db = new Database(filePath);
   db.exec(PRAGMA_SQL);
   // Schema is created/synced by migrate.js after adapter init

package/src/lib/db/driver.js

@@ -17,6 +17,9 @@ async function tryBunSqlite() {
 }
 
 async function tryBetterSqlite() {
+  // Optional manual install only — NOT shipped (avoids native build +
+  // npm install-script warnings on `npm i -g`). If present it is used as a
+  // fast path on Node < 24; otherwise node:sqlite / sql.js cover all runtimes.
   // Skip on Bun — better-sqlite3 native bindings unsupported
   if (process.versions.bun) return null;
   // Skip on Node >= 24: the native addon SIGSEGVs on load there, which is a
@@ -60,7 +63,7 @@ async function initAdapter() {
   ensureDirs();
   // Order per runtime:
   //   Bun:  bun:sqlite → sql.js
-  //   Node: better-sqlite3 → node:sqlite (≥22.5) → sql.js
+  //   Node: better-sqlite3 (manual opt-in only) → node:sqlite (≥22.5) → sql.js
   let adapter = await tryBunSqlite();
   if (!adapter) adapter = await tryBetterSqlite();
   if (!adapter) adapter = await tryNodeSqlite();

package/src/lib/db/index.js

@@ -1,11 +1,13 @@
 // Public API barrel — all DB functions
 import { getAdapter } from "./driver.js";
 import { stringifyJson, parseJson } from "./helpers/jsonCol.js";
+import { invalidateSettingsCache } from "./repos/settingsRepo.js";
 
 // Settings
 export {
   getSettings,
   updateSettings,
+  invalidateSettingsCache,
   isCloudEnabled,
   getCloudUrl,
   exportSettings,
@@ -303,6 +305,7 @@ export async function importDb(payload) {
     }
   });
 
+  invalidateSettingsCache(); // writes here bypass updateSettings
   return await exportDb();
 }
 

package/src/lib/db/repos/settingsRepo.js

@@ -62,10 +62,23 @@ const DEFAULT_SETTINGS = {
   pxpipeTimeoutMs: 15000,
 };
 
+// Settings are read ~3× per chat request (chat.js twice, auth.ts once) and
+// re-merge ~40 defaults each time. Same short-TTL pattern as
+// requestDetailsRepo's CONFIG_CACHE_TTL_MS; writes refresh it immediately.
+const SETTINGS_CACHE_TTL_MS = 2000;
+
+let cachedSettings = null;
+let cachedSettingsTs = 0;
+
 async function readRaw() {
+  if (cachedSettings && Date.now() - cachedSettingsTs < SETTINGS_CACHE_TTL_MS) {
+    return cachedSettings;
+  }
   const db = await getAdapter();
   const row = db.get(`SELECT data FROM settings WHERE id = 1`);
-  return row ? parseJson(row.data, {}) : {};
+  cachedSettings = row ? parseJson(row.data, {}) : {};
+  cachedSettingsTs = Date.now();
+  return cachedSettings;
 }
 
 // Merge raw settings with defaults; backward-compat for missing keys
@@ -92,6 +105,12 @@ export async function getSettings() {
   return mergeWithDefaults(raw);
 }
 
+// For writers that bypass updateSettings (bulk restore in db/index.js).
+export function invalidateSettingsCache() {
+  cachedSettings = null;
+  cachedSettingsTs = 0;
+}
+
 // Atomic read-merge-write inside transaction (prevents losing concurrent updates)
 export async function updateSettings(updates) {
   const db = await getAdapter();
@@ -105,6 +124,8 @@ export async function updateSettings(updates) {
       [stringifyJson(next)],
     );
   });
+  cachedSettings = next;
+  cachedSettingsTs = Date.now();
   return mergeWithDefaults(next);
 }
 

package/src/lib/oauth/services/xai.js

@@ -202,10 +202,6 @@ export class XaiService extends OAuthService {
 
       spinner.start("Waiting for xAI authorization...");
       await new Promise((resolve, reject) => {
-        const timeout = setTimeout(
-          () => reject(new Error("Authentication timeout (5 minutes)")),
-          300000,
-        );
         const iv = setInterval(() => {
           if (callbackParams) {
             clearInterval(iv);
@@ -213,6 +209,10 @@ export class XaiService extends OAuthService {
             resolve();
           }
         }, 100);
+        const timeout = setTimeout(() => {
+          clearInterval(iv); // else the 100ms poll spins forever after reject
+          reject(new Error("Authentication timeout (5 minutes)"));
+        }, 300000);
       });
       close();
 

package/src/lib/usageHealth.ts

@@ -0,0 +1,219 @@
+export interface HealthHistoryRow {
+  provider?: string | null;
+  connectionId?: string | null;
+  status?: string | null;
+  timestamp?: string;
+}
+
+export interface HealthDetailRow {
+  provider?: string | null;
+  connectionId?: string | null;
+  timestamp?: string;
+  status?: string | null;
+  latencyMs?: number;
+  error?: string | null;
+}
+
+export interface HealthConnection {
+  id: string;
+  provider: string;
+  name?: string | null;
+  rateLimitedUntil?: string | null;
+  testStatus?: string | null;
+  lastError?: unknown;
+}
+
+export type HealthStatus = "healthy" | "degraded" | "down" | "cooldown" | "idle";
+
+export interface ProviderHealthEntry {
+  provider: string;
+  connectionId: string;
+  connectionName: string;
+  requests: number;
+  errors: number;
+  detailErrors: number;
+  successRate: number | null;
+  p50LatencyMs: number | null;
+  lastError: string | null;
+  lastErrorAt: string | null;
+  cooldownUntil: string | null;
+  status: HealthStatus;
+}
+
+export interface RecentFailure {
+  timestamp: string;
+  provider: string;
+  model: string;
+  connectionId: string | null;
+  connectionName: string | null;
+  status: string;
+  latencyMs: number | null;
+  error: string | null;
+}
+
+function isOkStatus(status: unknown): boolean {
+  if (!status) return true;
+  const s = String(status).toLowerCase();
+  return s === "ok" || s === "success";
+}
+
+function percentile(sorted: number[], p: number): number | null {
+  if (!sorted.length) return null;
+  const idx = Math.min(sorted.length - 1, Math.floor(p * sorted.length));
+  return sorted[idx];
+}
+
+function shortError(value: unknown, max = 220): string | null {
+  if (value == null) return null;
+  const s = typeof value === "string" ? value : JSON.stringify(value);
+  const clean = s.replace(/\s+/g, " ").trim();
+  if (!clean) return null;
+  return clean.length > max ? `${clean.slice(0, max)}…` : clean;
+}
+
+export function summarizeProviderHealth(input: {
+  historyRows: HealthHistoryRow[];
+  detailRows: HealthDetailRow[];
+  connections: HealthConnection[];
+  cutoffIso: string;
+}): { providers: ProviderHealthEntry[]; recentFailures: RecentFailure[] } {
+  const cutoffMs = new Date(input.cutoffIso).getTime();
+  const connById = new Map<string, HealthConnection>();
+  for (const c of input.connections) connById.set(c.id, c);
+
+  type Acc = {
+    provider: string;
+    connectionId: string;
+    requests: number;
+    errors: number;
+    detailErrors: number;
+    latencies: number[];
+    lastError: string | null;
+    lastErrorAt: string | null;
+  };
+  const accs = new Map<string, Acc>();
+  const accKey = (provider: string, connectionId: string) => `${provider}|||${connectionId}`;
+
+  const ensure = (provider: string, connectionId: string): Acc => {
+    const key = accKey(provider, connectionId);
+    let a = accs.get(key);
+    if (!a) {
+      a = {
+        provider,
+        connectionId,
+        requests: 0,
+        errors: 0,
+        detailErrors: 0,
+        latencies: [],
+        lastError: null,
+        lastErrorAt: null,
+      };
+      accs.set(key, a);
+    }
+    return a;
+  };
+
+  for (const r of input.historyRows) {
+    if (!r.provider || !r.connectionId) continue;
+    const ts = r.timestamp ? new Date(r.timestamp).getTime() : 0;
+    if (Number.isFinite(cutoffMs) && ts < cutoffMs) continue;
+    const a = ensure(r.provider, r.connectionId);
+    a.requests += 1;
+    if (!isOkStatus(r.status)) a.errors += 1;
+  }
+
+  const failures: RecentFailure[] = [];
+  for (const d of input.detailRows) {
+    if (!d.provider) continue;
+    const connId = d.connectionId || "unknown";
+    const ts = d.timestamp || "";
+    const tsMs = ts ? new Date(ts).getTime() : 0;
+    const inWindow = !Number.isFinite(cutoffMs) || tsMs >= cutoffMs;
+    if (inWindow && d.connectionId) {
+      const a = ensure(d.provider, d.connectionId);
+      if (typeof d.latencyMs === "number" && d.latencyMs >= 0) a.latencies.push(d.latencyMs);
+      if (!isOkStatus(d.status)) {
+        a.detailErrors += 1;
+        const err = shortError(d.error);
+        if (err && (!a.lastErrorAt || ts > a.lastErrorAt)) {
+          a.lastError = err;
+          a.lastErrorAt = ts;
+        }
+      } else if (typeof d.latencyMs === "number" && d.latencyMs >= 0 && !a.lastErrorAt) {
+        // keep lastErrorAt empty on pure success; nothing to do
+      }
+    }
+    if (!isOkStatus(d.status)) {
+      const conn = d.connectionId ? connById.get(d.connectionId) : undefined;
+      failures.push({
+        timestamp: ts,
+        provider: d.provider,
+        model: "",
+        connectionId: d.connectionId || null,
+        connectionName: conn?.name || null,
+        status: String(d.status || "error"),
+        latencyMs: typeof d.latencyMs === "number" ? d.latencyMs : null,
+        error: shortError(d.error),
+      });
+    }
+    void connId;
+  }
+
+  // Seed accounts that have connections but zero traffic so the UI shows idle/cooldown rows.
+  for (const c of input.connections) {
+    ensure(c.provider, c.id);
+  }
+
+  const now = Date.now();
+  const providers: ProviderHealthEntry[] = [...accs.values()].map((a) => {
+    const conn = connById.get(a.connectionId);
+    const cooldownUntil = conn?.rateLimitedUntil || null;
+    const cooldownActive = !!cooldownUntil && new Date(cooldownUntil).getTime() > now;
+    a.latencies.sort((x, y) => x - y);
+    const total = a.requests + a.detailErrors;
+    const failed = a.errors + a.detailErrors;
+    const successRate =
+      a.requests > 0 ? (a.requests - a.errors) / a.requests : total > 0 ? 0 : null;
+    let status: HealthStatus;
+    if (cooldownActive) status = "cooldown";
+    else if (total === 0) status = "idle";
+    else if (a.requests === 0 || (successRate !== null && successRate < 0.5)) status = "down";
+    else if (failed > 0) status = "degraded";
+    else status = "healthy";
+    // Surface connection-level lastError when no detail error was captured.
+    let lastError = a.lastError;
+    let lastErrorAt = a.lastErrorAt;
+    if (!lastError && conn?.lastError) {
+      lastError = shortError(conn.lastError);
+    }
+    return {
+      provider: a.provider,
+      connectionId: a.connectionId,
+      connectionName: conn?.name || `${a.connectionId.slice(0, 8)}…`,
+      requests: a.requests,
+      errors: a.errors,
+      detailErrors: a.detailErrors,
+      successRate,
+      p50LatencyMs: percentile(a.latencies, 0.5),
+      lastError,
+      lastErrorAt,
+      cooldownUntil: cooldownActive ? cooldownUntil : null,
+      status,
+    };
+  });
+
+  providers.sort((x, y) => {
+    const rank: Record<HealthStatus, number> = {
+      down: 0,
+      cooldown: 1,
+      degraded: 2,
+      healthy: 3,
+      idle: 4,
+    };
+    if (rank[x.status] !== rank[y.status]) return rank[x.status] - rank[y.status];
+    return y.requests + y.detailErrors - (x.requests + x.detailErrors);
+  });
+
+  failures.sort((a, b) => (a.timestamp < b.timestamp ? 1 : -1));
+  return { providers, recentFailures: failures.slice(0, 20) };
+}