wyxrouter 0.4.71

package/src/app/api/v1beta/models/[...path]/route.js

@@ -0,0 +1,328 @@
+import { handleChat } from "@/sse/handlers/chat.js";
+import { initTranslators } from "open-sse/translator/index.js";
+
+let initialized = false;
+
+/**
+ * Initialize translators once
+ */
+async function ensureInitialized() {
+  if (!initialized) {
+    await initTranslators();
+    initialized = true;
+  }
+}
+
+/**
+ * Handle CORS preflight
+ */
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "*"
+    }
+  });
+}
+
+/**
+ * POST /v1beta/models/{model}:generateContent        — non-streaming
+ * POST /v1beta/models/{model}:streamGenerateContent  — streaming (SSE)
+ *
+ * Streaming intent is determined by the URL action suffix (canonical Gemini API
+ * convention), NOT by a body field. generationConfig.stream is not a real
+ * Gemini API field and Gemini CLI never sets it.
+ *
+ * The @google/genai SDK always uses :streamGenerateContent?alt=sse for chat.
+ * The upstream handleChat returns OpenAI SSE format; we transform it to
+ * Gemini SSE format on the fly via transformOpenAISSEToGeminiSSE().
+ */
+export async function POST(request, { params }) {
+  await ensureInitialized();
+
+  try {
+    const { path } = await params;
+    // path = ["provider", "model:action"] or ["model:action"]
+
+    let model;
+    let action; // ":generateContent" | ":streamGenerateContent"
+
+    if (path.length >= 2) {
+      // Format: /v1beta/models/provider/model:generateContent
+      const provider = path[0];
+      const modelAction = path[1];
+      action = modelAction.includes(":streamGenerateContent")
+        ? ":streamGenerateContent"
+        : ":generateContent";
+      const modelName = modelAction
+        .replace(":streamGenerateContent", "")
+        .replace(":generateContent", "");
+      model = provider + "/" + modelName;
+    } else {
+      // Format: /v1beta/models/model:generateContent
+      const modelAction = path[0];
+      action = modelAction.includes(":streamGenerateContent")
+        ? ":streamGenerateContent"
+        : ":generateContent";
+      model = modelAction
+        .replace(":streamGenerateContent", "")
+        .replace(":generateContent", "");
+    }
+
+    const body = await request.json();
+
+    // Streaming is determined by URL action suffix:
+    //   :streamGenerateContent => stream: true  (SSE)
+    //   :generateContent       => stream: false (plain JSON)
+    const stream = action === ":streamGenerateContent";
+
+    // Convert Gemini request format to OpenAI/internal format
+    const convertedBody = convertGeminiToInternal(body, model, stream);
+
+    // Create new request with converted body
+    const newRequest = new Request(request.url, {
+      method: "POST",
+      headers: request.headers,
+      body: JSON.stringify(convertedBody),
+    });
+
+    const response = await handleChat(newRequest);
+
+    if (stream) {
+      // Transform OpenAI SSE => Gemini SSE on the fly.
+      // The @google/genai SDK always uses :streamGenerateContent?alt=sse and
+      // expects Gemini SSE chunks (no [DONE] sentinel — stream just closes).
+      return transformOpenAISSEToGeminiSSE(response, model);
+    } else {
+      // Convert OpenAI JSON response => Gemini GenerateContentResponse
+      return await convertOpenAIResponseToGemini(response, model);
+    }
+  } catch (error) {
+    console.log("Error handling Gemini request:", error);
+    return Response.json(
+      { error: { message: error.message, code: 500 } },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * Convert Gemini request format to OpenAI/internal format.
+ *
+ * @param {object} geminiBody  - parsed Gemini request body
+ * @param {string} model       - resolved model string (e.g. "gemini-pro-high")
+ * @param {boolean} stream     - whether to stream (from URL action)
+ */
+function convertGeminiToInternal(geminiBody, model, stream) {
+  const messages = [];
+
+  // Convert system instruction
+  if (geminiBody.systemInstruction) {
+    const systemText = geminiBody.systemInstruction.parts
+      ?.map(p => p.text)
+      .join("\n") || "";
+    if (systemText) {
+      messages.push({ role: "system", content: systemText });
+    }
+  }
+
+  // Convert contents to messages
+  if (geminiBody.contents) {
+    for (const content of geminiBody.contents) {
+      const role = content.role === "model" ? "assistant" : "user";
+      const text = content.parts?.map(p => p.text).join("\n") || "";
+      messages.push({ role, content: text });
+    }
+  }
+
+  return {
+    model,
+    messages,
+    stream,
+    max_tokens: geminiBody.generationConfig?.maxOutputTokens,
+    temperature: geminiBody.generationConfig?.temperature,
+    top_p: geminiBody.generationConfig?.topP,
+  };
+}
+
+/** Map OpenAI finish_reason => Gemini finishReason */
+const FINISH_REASON_MAP = {
+  stop: "STOP",
+  length: "MAX_TOKENS",
+  tool_calls: "STOP",
+  content_filter: "SAFETY",
+};
+
+/**
+ * Transform an OpenAI SSE stream into a Gemini SSE stream.
+ *
+ * OpenAI SSE format (what handleChat returns):
+ *   data: {"choices":[{"delta":{"content":"Hi"},"finish_reason":null}]}
+ *   data: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{...}}
+ *   data: [DONE]
+ *
+ * Gemini SSE format (what @google/genai SDK expects):
+ *   data: {"candidates":[{"content":{"role":"model","parts":[{"text":"Hi"}]},"index":0}]}
+ *   data: {"candidates":[{"content":{"role":"model","parts":[{"text":""}]},"finishReason":"STOP","index":0}],"usageMetadata":{...}}
+ *   (stream closes — no [DONE])
+ */
+function transformOpenAISSEToGeminiSSE(upstreamResponse, model) {
+  if (!upstreamResponse.ok || !upstreamResponse.body) {
+    return upstreamResponse;
+  }
+
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+
+  const transformStream = new TransformStream({
+    transform(chunk, controller) {
+      const text = decoder.decode(chunk, { stream: true });
+      const lines = text.split("\n");
+
+      for (const line of lines) {
+        if (!line.startsWith("data:")) continue;
+
+        const data = line.slice(5).trim();
+
+        // Drop empty lines and the OpenAI [DONE] sentinel.
+        // Gemini SSE ends by stream close, no sentinel needed.
+        if (!data || data === "[DONE]") continue;
+
+        let parsed;
+        try {
+          parsed = JSON.parse(data);
+        } catch {
+          continue;
+        }
+
+        const choice = parsed.choices?.[0];
+        if (!choice) continue;
+
+        const delta = choice.delta || {};
+
+        const parts = [];
+        if (delta.reasoning_content) {
+          parts.push({ text: delta.reasoning_content, thought: true });
+        }
+        if (delta.content) {
+          parts.push({ text: delta.content });
+        }
+
+        // Skip pure role-only deltas with no content and no finish signal
+        if (parts.length === 0 && !choice.finish_reason) continue;
+
+        const candidate = {
+          content: {
+            role: "model",
+            parts: parts.length > 0 ? parts : [{ text: "" }],
+          },
+          index: 0,
+        };
+
+        if (choice.finish_reason) {
+          candidate.finishReason = FINISH_REASON_MAP[choice.finish_reason] || "STOP";
+        }
+
+        const geminiChunk = { candidates: [candidate] };
+
+        // Attach usage + modelVersion on the final chunk (when finish_reason is set)
+        if (choice.finish_reason && parsed.usage) {
+          geminiChunk.usageMetadata = {
+            promptTokenCount: parsed.usage.prompt_tokens || 0,
+            candidatesTokenCount: parsed.usage.completion_tokens || 0,
+            totalTokenCount: parsed.usage.total_tokens || 0,
+          };
+          const reasoningTokens =
+            parsed.usage.completion_tokens_details?.reasoning_tokens;
+          if (reasoningTokens) {
+            geminiChunk.usageMetadata.thoughtsTokenCount = reasoningTokens;
+          }
+          geminiChunk.modelVersion = parsed.model || model;
+        }
+
+        controller.enqueue(
+          encoder.encode("data: " + JSON.stringify(geminiChunk) + "\r\n\r\n")
+        );
+      }
+    },
+    // No flush() needed: Gemini SSE ends by stream close, not a sentinel
+  });
+
+  return new Response(upstreamResponse.body.pipeThrough(transformStream), {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Access-Control-Allow-Origin": "*",
+    },
+  });
+}
+
+/**
+ * Convert an OpenAI chat.completion JSON response into a Gemini
+ * GenerateContentResponse so that Gemini CLI can parse it.
+ */
+async function convertOpenAIResponseToGemini(response, model) {
+  if (!response.ok) return response;
+
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return response;
+  }
+
+  if (body.candidates) return Response.json(body, {
+    headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+  });
+
+  if (body.error) return Response.json(body, {
+    status: response.status,
+    headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+  });
+
+  const choice = body.choices?.[0];
+  if (!choice) {
+    return Response.json(body, {
+      headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+    });
+  }
+
+  const { message, finish_reason } = choice;
+
+  const parts = [];
+  if (message.reasoning_content) {
+    parts.push({ text: message.reasoning_content, thought: true });
+  }
+  parts.push({ text: message.content || "" });
+
+  const finishReason = FINISH_REASON_MAP[finish_reason] || "STOP";
+
+  const geminiResponse = {
+    candidates: [
+      {
+        content: { role: "model", parts },
+        finishReason,
+        index: 0,
+      },
+    ],
+    modelVersion: body.model || model,
+  };
+
+  if (body.usage) {
+    geminiResponse.usageMetadata = {
+      promptTokenCount: body.usage.prompt_tokens || 0,
+      candidatesTokenCount: body.usage.completion_tokens || 0,
+      totalTokenCount: body.usage.total_tokens || 0,
+    };
+    const reasoningTokens = body.usage.completion_tokens_details?.reasoning_tokens;
+    if (reasoningTokens) {
+      geminiResponse.usageMetadata.thoughtsTokenCount = reasoningTokens;
+    }
+  }
+
+  return Response.json(geminiResponse, {
+    headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+  });
+}

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

@@ -0,0 +1,44 @@
+import { PROVIDER_MODELS } from "@/shared/constants/models";
+
+/**
+ * Handle CORS preflight
+ */
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, OPTIONS",
+      "Access-Control-Allow-Headers": "*"
+    }
+  });
+}
+
+/**
+ * GET /v1beta/models - Gemini compatible models list
+ * Returns models in Gemini API format
+ */
+export async function GET() {
+  try {
+    // Collect all models from all providers
+    const models = [];
+    
+    for (const [provider, providerModels] of Object.entries(PROVIDER_MODELS)) {
+      for (const model of providerModels) {
+        models.push({
+          name: `models/${provider}/${model.id}`,
+          displayName: model.name || model.id,
+          description: `${provider} model: ${model.name || model.id}`,
+          supportedGenerationMethods: ["generateContent"],
+          inputTokenLimit: 128000,
+          outputTokenLimit: 8192,
+        });
+      }
+    }
+
+    return Response.json({ models });
+  } catch (error) {
+    console.log("Error fetching models:", error);
+    return Response.json({ error: { message: error.message } }, { status: 500 });
+  }
+}
+

package/src/app/api/version/route.js

@@ -0,0 +1,45 @@
+import https from "https";
+import pkg from "../../../../package.json" with { type: "json" };
+
+const NPM_PACKAGE_NAME = "9router";
+
+// Fetch latest version from npm registry
+function fetchLatestVersion() {
+  return new Promise((resolve) => {
+    const req = https.get(
+      `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`,
+      { timeout: 4000 },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(data).version || null);
+          } catch {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => { req.destroy(); resolve(null); });
+  });
+}
+
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] > pb[i]) return 1;
+    if (pa[i] < pb[i]) return -1;
+  }
+  return 0;
+}
+
+export async function GET() {
+  const latestVersion = await fetchLatestVersion();
+  const currentVersion = pkg.version;
+  const hasUpdate = latestVersion ? compareVersions(latestVersion, currentVersion) > 0 : false;
+
+  return Response.json({ currentVersion, latestVersion, hasUpdate });
+}

package/src/app/api/version/shutdown/route.js

@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+import { killAppProcesses } from "@/lib/appUpdater";
+
+// Shutdown app to release file locks for manual update
+export async function POST() {
+  try {
+    await killAppProcesses();
+  } catch { /* best effort */ }
+
+  const response = NextResponse.json({ success: true, message: "Shutting down for manual update..." });
+
+  setTimeout(() => process.exit(0), 500);
+
+  return response;
+}

package/src/app/api/version/update/route.js

@@ -0,0 +1,21 @@
+import { NextResponse } from "next/server";
+import { killAppProcesses, spawnUpdaterAndExit } from "@/lib/appUpdater";
+
+export async function POST() {
+  if (process.env.NODE_ENV !== "production") {
+    return NextResponse.json(
+      { success: false, message: "Update is only available in production build (9router CLI)" },
+      { status: 403 }
+    );
+  }
+
+  try {
+    // Kill sibling processes (cloudflared, MITM, stray next-server) to release file locks on Windows
+    await killAppProcesses();
+  } catch { /* best effort */ }
+
+  // Schedule detached updater then exit current server process
+  spawnUpdaterAndExit();
+
+  return NextResponse.json({ success: true, message: "Updater started. This app will exit shortly." });
+}

package/src/app/callback/page.js

@@ -0,0 +1,148 @@
+"use client";
+
+import { Suspense, useEffect, useState } from "react";
+import { useSearchParams } from "next/navigation";
+
+/**
+ * OAuth Callback Page Content
+ */
+function CallbackContent() {
+  const searchParams = useSearchParams();
+  const [status, setStatus] = useState("processing");
+
+  useEffect(() => {
+    const code = searchParams.get("code");
+    const state = searchParams.get("state");
+    const error = searchParams.get("error");
+    const errorDescription = searchParams.get("error_description");
+
+    const callbackData = {
+      code,
+      state,
+      error,
+      errorDescription,
+      fullUrl: window.location.href,
+    };
+
+    let relayed = false;
+
+    // Trusted origins that may receive this callback. The OAuth code/state
+    // must only be relayed to the dashboard window we expect to be the opener
+    // (same origin) or the Codex helper that listens on a fixed loopback port.
+    // Any other origin is treated as hostile (drive-by attacker that opened
+    // the popup against the well-known redirect_uri to phish the code).
+    const expectedOrigins = [
+      window.location.origin, // Same origin (for most providers)
+      "http://localhost:1455", // Codex specific port
+    ];
+
+    // Method 1: postMessage to opener (popup mode)
+    // Send once per expected origin. The browser delivers the message only
+    // when the opener's origin matches the targetOrigin we pass — using "*"
+    // here would leak the code/state to any opener (e.g. an attacker page
+    // that opened this URL in a popup), so iterate over the allowlist.
+    if (window.opener) {
+      for (const origin of expectedOrigins) {
+        try {
+          window.opener.postMessage({ type: "oauth_callback", data: callbackData }, origin);
+          relayed = true;
+        } catch (e) {
+          console.log("postMessage failed:", e);
+        }
+      }
+    }
+
+    // Method 2: BroadcastChannel (same origin tabs)
+    try {
+      const channel = new BroadcastChannel("oauth_callback");
+      channel.postMessage(callbackData);
+      channel.close();
+      relayed = true;
+    } catch (e) {
+      console.log("BroadcastChannel failed:", e);
+    }
+
+    // Method 3: localStorage event (fallback)
+    try {
+      localStorage.setItem("oauth_callback", JSON.stringify({ ...callbackData, timestamp: Date.now() }));
+      relayed = true;
+    } catch (e) {
+      console.log("localStorage failed:", e);
+    }
+
+    if (!(code || error)) {
+      setTimeout(() => setStatus("manual"), 0);
+      return;
+    }
+
+    setStatus("success");
+    setTimeout(() => {
+      window.close();
+      setTimeout(() => setStatus("done"), 500);
+    }, 1500);
+  }, [searchParams]);
+
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-bg">
+      <div className="text-center p-8 max-w-md">
+        {status === "processing" && (
+          <>
+            <div className="size-16 mx-auto mb-4 rounded-full bg-primary/10 flex items-center justify-center">
+              <span className="material-symbols-outlined text-3xl text-primary animate-spin">progress_activity</span>
+            </div>
+            <h1 className="text-xl font-semibold mb-2">Processing...</h1>
+            <p className="text-text-muted">Please wait while we complete the authorization.</p>
+          </>
+        )}
+
+        {(status === "success" || status === "done") && (
+          <>
+            <div className="size-16 mx-auto mb-4 rounded-full bg-green-100 dark:bg-green-900/30 flex items-center justify-center">
+              <span className="material-symbols-outlined text-3xl text-green-600">check_circle</span>
+            </div>
+            <h1 className="text-xl font-semibold mb-2">Authorization Successful!</h1>
+            <p className="text-text-muted">
+              {status === "success" ? "This window will close automatically..." : "You can close this tab now."}
+            </p>
+          </>
+        )}
+
+        {status === "manual" && (
+          <>
+            <div className="size-16 mx-auto mb-4 rounded-full bg-yellow-100 dark:bg-yellow-900/30 flex items-center justify-center">
+              <span className="material-symbols-outlined text-3xl text-yellow-600">info</span>
+            </div>
+            <h1 className="text-xl font-semibold mb-2">Copy This URL</h1>
+            <p className="text-text-muted mb-4">
+              Please copy the URL from the address bar and paste it in the application.
+            </p>
+            <div className="bg-surface border border-border rounded-lg p-3 text-left">
+              <code className="text-xs break-all">{typeof window !== "undefined" ? window.location.href : ""}</code>
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+/**
+ * OAuth Callback Page
+ * Receives callback from OAuth providers and sends data back via multiple methods
+ */
+export default function CallbackPage() {
+  return (
+    <Suspense fallback={
+      <div className="min-h-screen flex items-center justify-center bg-bg">
+        <div className="text-center p-8">
+          <div className="size-16 mx-auto mb-4 rounded-full bg-primary/10 flex items-center justify-center">
+            <span className="material-symbols-outlined text-3xl text-primary animate-spin">progress_activity</span>
+          </div>
+          <p className="text-text-muted">Loading...</p>
+        </div>
+      </div>
+    }>
+      <CallbackContent />
+    </Suspense>
+  );
+}