swayrouter 1.0.0

package/src/routes/api/usage/[connectionId]/codex-reset-credits/route.js

@@ -0,0 +1,169 @@
+import "open-sse/index.js";
+
+import { getProviderConnectionById } from "@/lib/localDb";
+import { consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits } from "open-sse/services/usage.js";
+import { resolveConnectionProxyConfig } from "@/lib/network/connectionProxy";
+import { refreshAndUpdateCredentials } from "../route.js";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const USAGE_ERROR = publicError("provider", "Unable to reset Codex credits");
+
+const AUTH_EXPIRED_PATTERNS = ["expired", "authentication", "unauthorized", "401", "re-authorize"];
+
+function isAuthExpiredResult(result) {
+  const values = [result?.message, result?.code, result?.raw?.detail, result?.raw?.error]
+    .filter(Boolean)
+    .map((value) => String(value).toLowerCase());
+  return values.some((value) => AUTH_EXPIRED_PATTERNS.some((pattern) => value.includes(pattern)));
+}
+
+function isAuthExpiredError(error) {
+  return isAuthExpiredResult({ message: error?.message });
+}
+
+function getResponseForConsumeResult(result, redeemRequestId) {
+  if (result.ok) {
+    return Response.json({
+      code: "reset",
+      reset: true,
+      windows_reset: result.windowsReset,
+      redeemRequestId,
+    });
+  }
+
+  if (result.noCredit) {
+    return Response.json({
+      code: "no_credit",
+      reset: false,
+      windows_reset: result.windowsReset,
+      message: "No Codex reset credits available.",
+    }, { status: 409 });
+  }
+
+  return Response.json({
+    code: "request_failed",
+    reset: false,
+    windows_reset: result.windowsReset,
+    message: "Codex reset credit request failed.",
+  }, { status: result.status >= 400 && result.status < 500 ? result.status : 502 });
+}
+
+async function getCodexConnection(connectionId) {
+  const connection = await getProviderConnectionById(connectionId);
+  if (!connection) {
+    return { response: Response.json({ error: "Connection not found" }, { status: 404 }) };
+  }
+
+  if (connection.provider !== "codex") {
+    return { response: Response.json({ error: "Codex reset credits are only available for Codex connections." }, { status: 400 }) };
+  }
+
+  const isOAuth = connection.authType === "oauth";
+  const isAccessToken = connection.authType === "access_token";
+  if (!isOAuth && !isAccessToken) {
+    return { response: Response.json({ error: "Codex reset credits require an OAuth or access-token connection." }, { status: 400 }) };
+  }
+
+  const proxyConfig = await resolveConnectionProxyConfig(connection.providerSpecificData);
+  const proxyOptions = {
+    connectionProxyEnabled: proxyConfig.connectionProxyEnabled === true,
+    connectionProxyUrl: proxyConfig.connectionProxyUrl || "",
+    connectionNoProxy: proxyConfig.connectionNoProxy || "",
+    relayUrl: proxyConfig.relayUrl || "",
+    relayToken: proxyConfig.relayToken || "",
+    vercelRelayUrl: proxyConfig.vercelRelayUrl || "",
+    strictProxy: false,
+  };
+
+  return { connection, isOAuth, proxyOptions };
+}
+
+async function refreshCodexConnection(connection, proxyOptions) {
+  try {
+    const result = await refreshAndUpdateCredentials(connection, false, proxyOptions);
+    return { connection: result.connection };
+  } catch (refreshError) {
+    logRouteError("Usage][CodexReset][Refresh", refreshError);
+    return { response: Response.json({ error: "Credential refresh failed" }, { status: 401 }) };
+  }
+}
+
+export async function GET(_request, { params }) {
+  let connection;
+  try {
+    const { connectionId } = await params;
+    const resolved = await getCodexConnection(connectionId);
+    if (resolved.response) return resolved.response;
+    ({ connection } = resolved);
+    const { isOAuth, proxyOptions } = resolved;
+
+    if (isOAuth) {
+      const refreshed = await refreshCodexConnection(connection, proxyOptions);
+      if (refreshed.response) return refreshed.response;
+      connection = refreshed.connection;
+    }
+
+    let result;
+    try {
+      result = await getCodexRateLimitResetCredits(connection.accessToken, proxyOptions, connection.providerSpecificData);
+    } catch (fetchError) {
+      if (!isOAuth || !connection.refreshToken || !isAuthExpiredError(fetchError)) throw fetchError;
+      const retryResult = await refreshAndUpdateCredentials(connection, true, proxyOptions);
+      connection = retryResult.connection;
+      result = await getCodexRateLimitResetCredits(connection.accessToken, proxyOptions, connection.providerSpecificData);
+    }
+
+    return Response.json({
+      availableCount: Number.isFinite(Number(result?.availableCount))
+        ? Math.max(0, Number(result.availableCount))
+        : 0,
+      credits: Array.isArray(result?.credits)
+        ? result.credits.map((credit) => ({
+            status: typeof credit?.status === "string" ? credit.status : "unknown",
+            grantedAt: typeof credit?.grantedAt === "string" ? credit.grantedAt : null,
+            expiresAt: typeof credit?.expiresAt === "string" ? credit.expiresAt : null,
+          }))
+        : [],
+    });
+  } catch (error) {
+    const provider = connection?.provider ?? "unknown";
+    logRouteError(`Usage][CodexReset][${provider}`, error);
+    return Response.json({ error: USAGE_ERROR }, { status: 500 });
+  }
+}
+
+export async function POST(request, { params }) {
+  let connection;
+  try {
+    const { connectionId } = await params;
+    const resolved = await getCodexConnection(connectionId);
+    if (resolved.response) return resolved.response;
+    ({ connection } = resolved);
+    const { isOAuth, proxyOptions } = resolved;
+
+    if (isOAuth) {
+      const refreshed = await refreshCodexConnection(connection, proxyOptions);
+      if (refreshed.response) return refreshed.response;
+      connection = refreshed.connection;
+    }
+
+    const redeemRequestId = crypto.randomUUID();
+    let consumeResult = await consumeCodexRateLimitResetCredit(connection.accessToken, redeemRequestId, proxyOptions);
+
+    if (isOAuth && isAuthExpiredResult(consumeResult) && connection.refreshToken) {
+      try {
+        const retryResult = await refreshAndUpdateCredentials(connection, true, proxyOptions);
+        connection = retryResult.connection;
+        consumeResult = await consumeCodexRateLimitResetCredit(connection.accessToken, redeemRequestId, proxyOptions);
+      } catch (retryError) {
+        console.warn(`[Codex Reset Credits] force refresh failed: ${retryError.message}`);
+      }
+    }
+
+    return getResponseForConsumeResult(consumeResult, redeemRequestId);
+  } catch (error) {
+    const provider = connection?.provider ?? "unknown";
+    logRouteError(`Usage][CodexReset][${provider}`, error);
+    return Response.json({ error: USAGE_ERROR }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,222 @@
+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";
+import { logRouteError } from "@/lib/errors/publicError";
+
+const USAGE_ERROR = "Provider usage request failed";
+
+const USAGE_MESSAGE_PATTERNS = [
+  /^Usage API not implemented for [a-z0-9-]+$/i,
+  /^[A-Za-z0-9 ()+.-]+ connected\.(?: .*)?$/,
+  /^[A-Za-z0-9 ()+.-]+ access token or API key not available\.$/,
+  /^[A-Za-z0-9 ()+.-]+ API key not available\..*$/,
+  /^[A-Za-z0-9 ()+.-]+ authentication expired\..*$/,
+  /^[A-Za-z0-9 ()+.-]+ credential invalid or expired\.$/,
+  /^[A-Za-z0-9 ()+.-]+ usage request failed\.$/,
+];
+
+function isSafeUsageMessage(value) {
+  return typeof value === "string" && USAGE_MESSAGE_PATTERNS.some((pattern) => pattern.test(value));
+}
+
+function sanitizeQuota(quota) {
+  if (!quota || typeof quota !== "object" || Array.isArray(quota)) return null;
+  const safe = {};
+  for (const key of ["used", "total", "remaining", "remainingPercentage"]) {
+    if (Number.isFinite(Number(quota[key]))) safe[key] = Number(quota[key]);
+  }
+  if (typeof quota.resetAt === "string") safe.resetAt = quota.resetAt;
+  if (quota.unlimited === true) safe.unlimited = true;
+  if (typeof quota.recurring === "boolean") safe.recurring = quota.recurring;
+  if (typeof quota.unit === "string" && quota.unit.length <= 32) safe.unit = quota.unit;
+  return safe;
+}
+
+function sanitizeUsage(usage) {
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) {
+    return { message: USAGE_ERROR };
+  }
+  const safe = {};
+  if (typeof usage.plan === "string" && usage.plan.length <= 100) safe.plan = usage.plan;
+  if (typeof usage.message === "string" && isSafeUsageMessage(usage.message)) safe.message = usage.message;
+  if (typeof usage.limitReached === "boolean") safe.limitReached = usage.limitReached;
+  if (typeof usage.reviewLimitReached === "boolean") safe.reviewLimitReached = usage.reviewLimitReached;
+  if (usage.resetCredits && typeof usage.resetCredits === "object" && !Array.isArray(usage.resetCredits)) {
+    safe.resetCredits = {
+      availableCount: Number.isFinite(Number(usage.resetCredits.availableCount))
+        ? Math.max(0, Number(usage.resetCredits.availableCount))
+        : 0,
+    };
+  }
+  if (usage.quotas && typeof usage.quotas === "object" && !Array.isArray(usage.quotas)) {
+    const quotas = {};
+    for (const [name, quota] of Object.entries(usage.quotas)) {
+      if (typeof name !== "string" || name.length > 100) continue;
+      const sanitized = sanitizeQuota(quota);
+      if (sanitized) quotas[name] = sanitized;
+    }
+    if (Object.keys(quotas).length > 0) safe.quotas = quotas;
+  }
+  if (Object.keys(safe).length === 0) safe.message = USAGE_ERROR;
+  return safe;
+}
+
+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));
+}
+
+export async function refreshAndUpdateCredentials(connection, force = false, proxyOptions = null) {
+  const executor = getExecutor(connection.provider);
+
+  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,
+
+    copilotToken: connection.providerSpecificData?.copilotToken,
+    copilotTokenExpiresAt: connection.providerSpecificData?.copilotTokenExpiresAt,
+  };
+
+  const needsRefresh = force || executor.needsRefresh(credentials);
+
+  if (!needsRefresh) {
+    return { connection, refreshed: false };
+  }
+
+  const refreshResult = await executor.refreshCredentials(credentials, console, proxyOptions);
+
+  if (!refreshResult) {
+
+    if (connection.accessToken) {
+      return { connection, refreshed: false };
+    }
+    throw new Error("Failed to refresh credentials. Please re-authorize the connection.");
+  }
+
+  const now = new Date().toISOString();
+  const updateData = {
+    updatedAt: now,
+  };
+
+  if (refreshResult.accessToken) {
+    updateData.accessToken = refreshResult.accessToken;
+  }
+
+  if (refreshResult.refreshToken) {
+    updateData.refreshToken = refreshResult.refreshToken;
+  }
+
+  if (refreshResult.idToken) {
+    updateData.idToken = refreshResult.idToken;
+  }
+
+  if (refreshResult.lastRefreshAt) {
+    updateData.lastRefreshAt = refreshResult.lastRefreshAt;
+  }
+
+  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;
+  }
+
+  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,
+    };
+  }
+
+  await updateProviderConnection(connection.id, updateData);
+
+  const updatedConnection = {
+    ...connection,
+    ...updateData,
+    providerSpecificData: updateData.providerSpecificData || connection.providerSpecificData,
+  };
+
+  return {
+    connection: updatedConnection,
+    refreshed: true,
+  };
+}
+
+export async function GET(request, { params }) {
+  let connection;
+  try {
+    const { connectionId } = await params;
+
+    connection = await getProviderConnectionById(connectionId);
+    if (!connection) {
+      return Response.json({ error: "Connection not found" }, { status: 404 });
+    }
+
+    const isOAuth = connection.authType === "oauth";
+    const isApikeyAuth =
+      connection.authType === "apikey" || connection.authType === "api_key";
+    const isApikeyEligible =
+      isApikeyAuth && USAGE_APIKEY_PROVIDERS.includes(connection.provider);
+
+    if (!isOAuth && !isApikeyEligible) {
+      return Response.json({ message: "Usage not available for this connection" });
+    }
+
+    const proxyConfig = await resolveConnectionProxyConfig(connection.providerSpecificData);
+    const proxyOptions = {
+      connectionProxyEnabled: proxyConfig.connectionProxyEnabled === true,
+      connectionProxyUrl: proxyConfig.connectionProxyUrl || "",
+      connectionNoProxy: proxyConfig.connectionNoProxy || "",
+      relayUrl: proxyConfig.relayUrl || "",
+      relayToken: proxyConfig.relayToken || "",
+      vercelRelayUrl: proxyConfig.vercelRelayUrl || "",
+      strictProxy: false,
+    };
+
+    if (isOAuth) {
+      try {
+        const result = await refreshAndUpdateCredentials(connection, false, proxyOptions);
+        connection = result.connection;
+      } catch (refreshError) {
+        logRouteError("Usage][Refresh", refreshError);
+        return Response.json({
+          error: "Credential refresh failed"
+        }, { status: 401 });
+      }
+    }
+
+    let usage = await getUsageForProvider(connection, proxyOptions);
+
+    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(sanitizeUsage(usage));
+  } catch (error) {
+    const provider = connection?.provider ?? "unknown";
+    logRouteError(`Usage][${provider}`, error);
+    return Response.json({ error: USAGE_ERROR }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,27 @@
+import { NextResponse } from "next/server";
+import { getChartData } from "@/lib/usageDb";
+
+const VALID_PERIODS = new Set(["today", "24h", "7d", "30d", "60d", "90d", "180d", "365d", "year", "all"]);
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const period = searchParams.get("period") || "7d";
+    const granularity = searchParams.get("granularity") || "day";
+    const requestedDays = Number(searchParams.get("days"));
+    const days = Number.isInteger(requestedDays) && requestedDays > 0 ? requestedDays : undefined;
+
+    if (!VALID_PERIODS.has(period)) {
+      return NextResponse.json({ error: "Invalid period" }, { status: 400 });
+    }
+    if (granularity !== "day" && granularity !== "hour") {
+      return NextResponse.json({ error: "Invalid granularity" }, { status: 400 });
+    }
+
+    const data = await getChartData(period, { granularity, days });
+    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/routes/api/usage/history/route.js

@@ -0,0 +1,94 @@
+import { NextResponse } from "next/server";
+import { clearUsageHistory, getUsageHistory } from "@/lib/usageDb";
+
+const VALID_RANGES = new Set(["today", "24h", "7d", "14d", "30d", "60d", "90d", "1y", "all"]);
+const RANGE_DAYS = { "7d": 7, "14d": 14, "30d": 30, "60d": 60, "90d": 90 };
+
+function getRangeStart(range) {
+  if (range === "all") return null;
+  if (range === "24h") return new Date(Date.now() - 24 * 60 * 60 * 1000);
+  if (range === "1y") {
+    const start = new Date();
+    start.setHours(0, 0, 0, 0);
+    start.setDate(start.getDate() - 364);
+    return start;
+  }
+
+  const days = RANGE_DAYS[range];
+  if (!days) {
+    const start = new Date();
+    start.setHours(0, 0, 0, 0);
+    return start;
+  }
+
+  const start = new Date();
+  start.setHours(0, 0, 0, 0);
+  start.setDate(start.getDate() - (days - 1));
+  return start;
+}
+
+function parseBoundedInt(value, fallback, min, max) {
+  if (value == null || value === "") return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < min || parsed > max) return null;
+  return parsed;
+}
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const limit = parseBoundedInt(searchParams.get("limit"), 50, 1, 500);
+    if (limit === null) {
+      return NextResponse.json({ error: "limit must be an integer between 1 and 500" }, { status: 400 });
+    }
+
+    const range = searchParams.get("range") || "all";
+    if (!VALID_RANGES.has(range)) {
+      return NextResponse.json({ error: "Invalid range" }, { status: 400 });
+    }
+
+    const rawStartDate = searchParams.get("startDate");
+    let startDate = getRangeStart(range);
+    if (rawStartDate) {
+      const explicitStart = new Date(rawStartDate);
+      if (Number.isNaN(explicitStart.getTime())) {
+        return NextResponse.json({ error: "Invalid startDate" }, { status: 400 });
+      }
+      startDate = explicitStart;
+    }
+
+    const usage = await getUsageHistory({
+      limit,
+      provider: searchParams.get("provider") || undefined,
+      model: searchParams.get("model") || undefined,
+      apiKeyId: searchParams.get("apiKeyId") || undefined,
+      startDate: startDate?.toISOString(),
+    });
+
+    return NextResponse.json({ usage, range, limit });
+  } catch (error) {
+    console.error("Error fetching usage history:", error);
+    return NextResponse.json({ error: "Failed to fetch usage history" }, { status: 500 });
+  }
+}
+
+export async function DELETE(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const range = searchParams.get("range") || "all";
+    if (!VALID_RANGES.has(range)) {
+      return NextResponse.json({ error: "Invalid range" }, { status: 400 });
+    }
+
+    const startDate = getRangeStart(range);
+    const deleted = await clearUsageHistory({
+      startDate: startDate?.toISOString(),
+    });
+    return NextResponse.json({ ok: true, range, deleted });
+  } catch (error) {
+    console.error("Error clearing usage history:", error);
+    return NextResponse.json({ error: "Failed to clear usage history" }, { status: 500 });
+  }
+}

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

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

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

@@ -0,0 +1,36 @@
+import { NextResponse } from "next/server";
+import { getDistinctProviders } from "@/lib/requestDetailsDb";
+import { getProviderNodes } from "@/lib/localDb";
+import { AI_PROVIDERS, getProviderByAlias } from "@/shared/constants/providers";
+
+export async function GET() {
+  try {
+
+    const providerIds = await getDistinctProviders();
+
+    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/routes/api/usage/request-details/route.js

@@ -0,0 +1,61 @@
+import { NextResponse } from "next/server";
+import { getRequestDetails, getUsageHistoryPage } from "@/lib/usageDb";
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+
+    const pageRaw = parseInt(searchParams.get("page"));
+    const page = Number.isNaN(pageRaw) ? 1 : pageRaw;
+    const pageSizeRaw = parseInt(searchParams.get("pageSize"));
+    const pageSize = Number.isNaN(pageSizeRaw) ? 20 : pageSizeRaw;
+    const provider = searchParams.get("provider");
+    const model = searchParams.get("model");
+    const connectionId = searchParams.get("connectionId");
+    const status = searchParams.get("status");
+    const query = searchParams.get("q");
+    const sortDir = searchParams.get("sortDir") === "asc" ? "asc" : "desc";
+    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 (query) filter.query = query;
+    filter.sortDir = sortDir;
+    if (startDate) filter.startDate = startDate;
+    if (endDate) filter.endDate = endDate;
+
+    const result = searchParams.get("source") === "usage"
+      ? await getUsageHistoryPage(filter)
+      : 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/routes/api/usage/request-logs/route.js

@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+import { getRecentLogs } from "@/lib/usageDb";
+
+const LOG_LIMIT = 200;
+
+export async function GET() {
+  try {
+    const logs = await getRecentLogs(LOG_LIMIT);
+    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/routes/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", "90d", "365d", "year", "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 });
+  }
+}