vforclaude2 0.3.87

package/src/app/api/translator/console-logs/stream/route.js

@@ -0,0 +1,70 @@
+import { getConsoleLogs, getConsoleEmitter, initConsoleLogCapture } from "@/lib/consoleLogBuffer";
+
+export const dynamic = "force-dynamic";
+
+initConsoleLogCapture();
+
+export async function GET() {
+  const encoder = new TextEncoder();
+  const emitter = getConsoleEmitter();
+  const state = { closed: false, send: null, keepalive: null };
+
+  const stream = new ReadableStream({
+    start(controller) {
+      // Send all buffered logs immediately on connect
+      const buffered = getConsoleLogs();
+      if (buffered.length > 0) {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "init", logs: buffered })}\n\n`));
+      }
+
+      // Push new lines as they arrive
+      state.send = (line) => {
+        if (state.closed) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "line", line })}\n\n`));
+        } catch {
+          state.closed = true;
+        }
+      };
+
+      // Notify client when cleared
+      state.sendClear = () => {
+        if (state.closed) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "clear" })}\n\n`));
+        } catch {
+          state.closed = true;
+        }
+      };
+
+      emitter.on("line", state.send);
+      emitter.on("clear", state.sendClear);
+
+      // Keepalive ping every 25s
+      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);
+    },
+
+    cancel() {
+      state.closed = true;
+      emitter.off("line", state.send);
+      emitter.off("clear", state.sendClear);
+      clearInterval(state.keepalive);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+    },
+  });
+}

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

@@ -0,0 +1,45 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const file = searchParams.get("file");
+
+    if (!file) {
+      return NextResponse.json({ success: false, error: "File parameter required" }, { status: 400 });
+    }
+
+    // Security: only allow specific filenames
+    const allowedFiles = [
+      "1_req_client.json",
+      "2_req_source.json",
+      "3_req_openai.json",
+      "4_req_target.json",
+      "5_res_provider.txt",
+      "6_res_openai.txt",
+      "7_res_client.txt",
+      "7_res_client.json",
+    ];
+
+    if (!allowedFiles.includes(file)) {
+      return NextResponse.json({ success: false, error: "Invalid file name" }, { status: 400 });
+    }
+
+    const logsDir = path.join(process.cwd(), "logs", "translator");
+    const filePath = path.join(logsDir, file);
+
+    // Check if file exists
+    if (!fs.existsSync(filePath)) {
+      return NextResponse.json({ success: false, error: "File not found" }, { status: 404 });
+    }
+
+    const content = fs.readFileSync(filePath, "utf-8");
+
+    return NextResponse.json({ success: true, content });
+  } catch (error) {
+    console.error("Error loading file:", error);
+    return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,44 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+export async function POST(request) {
+  try {
+    const { file, content } = await request.json();
+
+    if (!file || content === undefined) {
+      return NextResponse.json({ success: false, error: "File and content required" }, { status: 400 });
+    }
+
+    // Security: only allow specific filenames
+    const allowedFiles = [
+      "1_req_client.json",
+      "2_req_source.json",
+      "3_req_openai.json",
+      "4_req_target.json",
+      "5_res_provider.txt",
+      "6_res_openai.txt",
+      "7_res_client.txt",
+      "7_res_client.json",
+    ];
+
+    if (!allowedFiles.includes(file)) {
+      return NextResponse.json({ success: false, error: "Invalid file name" }, { status: 400 });
+    }
+
+    const logsDir = path.join(process.cwd(), "logs", "translator");
+    
+    // Create directory if not exists
+    if (!fs.existsSync(logsDir)) {
+      fs.mkdirSync(logsDir, { recursive: true });
+    }
+
+    const filePath = path.join(logsDir, file);
+    fs.writeFileSync(filePath, content, "utf-8");
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Error saving file:", error);
+    return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,58 @@
+import { getProviderConnections } from "@/lib/localDb.js";
+import { getExecutor, refreshTokenByProvider } from "open-sse/index.js";
+
+export async function POST(request) {
+  try {
+    const { provider, model, body } = await request.json();
+
+    if (!provider || !model || !body) {
+      return Response.json({ success: false, error: "provider, model, and body required" }, { status: 400 });
+    }
+
+    const connections = await getProviderConnections({ provider });
+    const connection = connections.find(c => c.isActive !== false);
+    if (!connection) {
+      return Response.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 stream = body.stream !== false;
+
+    let { response } = await executor.execute({ model, body, stream, credentials });
+
+    // Auto-refresh token on 401/403 and retry (same as chatCore.js)
+    if (response.status === 401 || response.status === 403) {
+      const newCredentials = await refreshTokenByProvider(provider, credentials);
+      if (newCredentials?.accessToken || newCredentials?.copilotToken) {
+        Object.assign(credentials, newCredentials);
+        ({ response } = await executor.execute({ model, body, stream, credentials }));
+      }
+    }
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`[Translator] Provider error ${response.status}:`, errorText.slice(0, 500));
+      return Response.json({ success: false, error: `Provider error: ${response.status}`, details: errorText }, { status: response.status });
+    }
+
+    return new Response(response.body, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  } catch (error) {
+    console.error("[Translator] Send error:", error);
+    return Response.json({ success: false, error: error.message }, { status: 500 });
+  }
+}

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/tunnelManager";
+
+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/tunnelManager";
+
+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,12 @@
+import { NextResponse } from "next/server";
+import { getTunnelStatus } from "@/lib/tunnel/tunnelManager";
+
+export async function GET() {
+  try {
+    const status = await getTunnelStatus();
+    return NextResponse.json(status);
+  } catch (error) {
+    console.error("Tunnel status error:", error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,152 @@
+// 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";
+
+// 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) {
+  const executor = getExecutor(connection.provider);
+
+  // Build credentials object from connection
+  const credentials = {
+    accessToken: connection.accessToken,
+    refreshToken: connection.refreshToken,
+    expiresAt: connection.expiresAt || connection.tokenExpiresAt,
+    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
+  const refreshResult = await executor.refreshCredentials(credentials, console);
+
+  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;
+  }
+
+  // Update token expiry
+  if (refreshResult.expiresIn) {
+    updateData.expiresAt = new Date(Date.now() + refreshResult.expiresIn * 1000).toISOString();
+  } else if (refreshResult.expiresAt) {
+    updateData.expiresAt = refreshResult.expiresAt;
+  }
+
+  // Handle provider-specific data (copilotToken for GitHub, etc.)
+  if (refreshResult.copilotToken || refreshResult.copilotTokenExpiresAt) {
+    updateData.providerSpecificData = {
+      ...connection.providerSpecificData,
+      copilotToken: refreshResult.copilotToken,
+      copilotTokenExpiresAt: refreshResult.copilotTokenExpiresAt,
+    };
+  }
+
+  // Update database
+  await updateProviderConnection(connection.id, updateData);
+
+  // Return updated connection
+  const updatedConnection = {
+    ...connection,
+    ...updateData,
+  };
+
+  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 });
+    }
+
+    // Only OAuth connections have usage APIs
+    if (connection.authType !== "oauth") {
+      return Response.json({ message: "Usage not available for API key connections" });
+    }
+
+    // Refresh credentials if needed using executor
+    try {
+      const result = await refreshAndUpdateCredentials(connection);
+      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);
+
+    // If provider returned an auth-expired message instead of throwing,
+    // force-refresh token and retry once
+    if (isAuthExpiredMessage(usage) && connection.refreshToken) {
+      try {
+        const retryResult = await refreshAndUpdateCredentials(connection, true);
+        connection = retryResult.connection;
+        usage = await getUsageForProvider(connection);
+      } 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(["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/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(["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 });
+  }
+}