wyxrouter 0.4.71

package/src/app/api/combos/[id]/route.js

@@ -0,0 +1,81 @@
+import { NextResponse } from "next/server";
+import { getComboById, updateCombo, deleteCombo, getComboByName } from "@/lib/localDb";
+import { resetComboRotation } from "open-sse/services/combo.js";
+
+// Validate combo name: only a-z, A-Z, 0-9, -, _
+const VALID_NAME_REGEX = /^[a-zA-Z0-9_.\-]+$/;
+
+// GET /api/combos/[id] - Get combo by ID
+export async function GET(request, { params }) {
+  try {
+    const { id } = await params;
+    const combo = await getComboById(id);
+    
+    if (!combo) {
+      return NextResponse.json({ error: "Combo not found" }, { status: 404 });
+    }
+    
+    return NextResponse.json(combo);
+  } catch (error) {
+    console.log("Error fetching combo:", error);
+    return NextResponse.json({ error: "Failed to fetch combo" }, { status: 500 });
+  }
+}
+
+// PUT /api/combos/[id] - Update combo
+export async function PUT(request, { params }) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    
+    // Validate name format if provided
+    if (body.name) {
+      if (!VALID_NAME_REGEX.test(body.name)) {
+        return NextResponse.json({ error: "Name can only contain letters, numbers, -, _ and ." }, { status: 400 });
+      }
+      
+      // Check if name already exists (exclude current combo)
+      const existing = await getComboByName(body.name);
+      if (existing && existing.id !== id) {
+        return NextResponse.json({ error: "Combo name already exists" }, { status: 400 });
+      }
+    }
+    
+    // Capture previous name to invalidate rotation state on rename
+    const prev = await getComboById(id);
+    const combo = await updateCombo(id, body);
+    
+    if (!combo) {
+      return NextResponse.json({ error: "Combo not found" }, { status: 404 });
+    }
+
+    // Invalidate rotation state (models/strategy/name may have changed)
+    if (prev?.name) resetComboRotation(prev.name);
+    if (combo.name && combo.name !== prev?.name) resetComboRotation(combo.name);
+
+    return NextResponse.json(combo);
+  } catch (error) {
+    console.log("Error updating combo:", error);
+    return NextResponse.json({ error: "Failed to update combo" }, { status: 500 });
+  }
+}
+
+// DELETE /api/combos/[id] - Delete combo
+export async function DELETE(request, { params }) {
+  try {
+    const { id } = await params;
+    const prev = await getComboById(id);
+    const success = await deleteCombo(id);
+    
+    if (!success) {
+      return NextResponse.json({ error: "Combo not found" }, { status: 404 });
+    }
+
+    if (prev?.name) resetComboRotation(prev.name);
+    
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.log("Error deleting combo:", error);
+    return NextResponse.json({ error: "Failed to delete combo" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,48 @@
+import { NextResponse } from "next/server";
+import { getCombos, createCombo, getComboByName } from "@/lib/localDb";
+
+export const dynamic = "force-dynamic";
+
+// Validate combo name: only a-z, A-Z, 0-9, -, _
+const VALID_NAME_REGEX = /^[a-zA-Z0-9_.\-]+$/;
+
+// GET /api/combos - Get all combos
+export async function GET() {
+  try {
+    const combos = await getCombos();
+    return NextResponse.json({ combos });
+  } catch (error) {
+    console.log("Error fetching combos:", error);
+    return NextResponse.json({ error: "Failed to fetch combos" }, { status: 500 });
+  }
+}
+
+// POST /api/combos - Create new combo
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const { name, models, kind } = body;
+
+    if (!name) {
+      return NextResponse.json({ error: "Name is required" }, { status: 400 });
+    }
+
+    // Validate name format
+    if (!VALID_NAME_REGEX.test(name)) {
+      return NextResponse.json({ error: "Name can only contain letters, numbers, -, _ and ." }, { status: 400 });
+    }
+
+    // Check if name already exists
+    const existing = await getComboByName(name);
+    if (existing) {
+      return NextResponse.json({ error: "Combo name already exists" }, { status: 400 });
+    }
+
+    const combo = await createCombo({ name, models: models || [], kind: kind || null });
+
+    return NextResponse.json(combo, { status: 201 });
+  } catch (error) {
+    console.log("Error creating combo:", error);
+    return NextResponse.json({ error: "Failed to create combo" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+
+const CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, OPTIONS",
+  "Access-Control-Allow-Headers": "*",
+};
+
+export async function GET() {
+  return NextResponse.json({ ok: true }, { headers: CORS_HEADERS });
+}
+
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204, headers: CORS_HEADERS });
+}

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

@@ -0,0 +1,4 @@
+// This API route is called automatically to initialize app
+export async function GET() {
+  return new Response("Initialized", { status: 200 });
+}

package/src/app/api/keys/[id]/route.js

@@ -0,0 +1,58 @@
+import { NextResponse } from "next/server";
+import { deleteApiKey, getApiKeyById, updateApiKey } from "@/lib/localDb";
+
+// GET /api/keys/[id] - Get single key
+export async function GET(request, { params }) {
+  try {
+    const { id } = await params;
+    const key = await getApiKeyById(id);
+    if (!key) {
+      return NextResponse.json({ error: "Key not found" }, { status: 404 });
+    }
+    return NextResponse.json({ key });
+  } catch (error) {
+    console.log("Error fetching key:", error);
+    return NextResponse.json({ error: "Failed to fetch key" }, { status: 500 });
+  }
+}
+
+// PUT /api/keys/[id] - Update key
+export async function PUT(request, { params }) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    const { isActive } = body;
+
+    const existing = await getApiKeyById(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Key not found" }, { status: 404 });
+    }
+
+    const updateData = {};
+    if (isActive !== undefined) updateData.isActive = isActive;
+
+    const updated = await updateApiKey(id, updateData);
+
+    return NextResponse.json({ key: updated });
+  } catch (error) {
+    console.log("Error updating key:", error);
+    return NextResponse.json({ error: "Failed to update key" }, { status: 500 });
+  }
+}
+
+// DELETE /api/keys/[id] - Delete API key
+export async function DELETE(request, { params }) {
+  try {
+    const { id } = await params;
+
+    const deleted = await deleteApiKey(id);
+    if (!deleted) {
+      return NextResponse.json({ error: "Key not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ message: "Key deleted successfully" });
+  } catch (error) {
+    console.log("Error deleting key:", error);
+    return NextResponse.json({ error: "Failed to delete key" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,42 @@
+import { NextResponse } from "next/server";
+import { getApiKeys, createApiKey } from "@/lib/localDb";
+import { getConsistentMachineId } from "@/shared/utils/machineId";
+
+export const dynamic = "force-dynamic";
+
+// GET /api/keys - List API keys
+export async function GET() {
+  try {
+    const keys = await getApiKeys();
+    return NextResponse.json({ keys });
+  } catch (error) {
+    console.log("Error fetching keys:", error);
+    return NextResponse.json({ error: "Failed to fetch keys" }, { status: 500 });
+  }
+}
+
+// POST /api/keys - Create new API key
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const { name } = body;
+
+    if (!name) {
+      return NextResponse.json({ error: "Name is required" }, { status: 400 });
+    }
+
+    // Always get machineId from server
+    const machineId = await getConsistentMachineId();
+    const apiKey = await createApiKey(name, machineId);
+
+    return NextResponse.json({
+      key: apiKey.key,
+      name: apiKey.name,
+      id: apiKey.id,
+      machineId: apiKey.machineId,
+    }, { status: 201 });
+  } catch (error) {
+    console.log("Error creating key:", error);
+    return NextResponse.json({ error: "Failed to create key" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,30 @@
+import { cookies } from "next/headers";
+import { NextResponse } from "next/server";
+import { LOCALE_COOKIE, normalizeLocale, isSupportedLocale } from "@/i18n/config";
+
+export async function POST(request) {
+  try {
+    const { locale } = await request.json();
+    
+    if (!locale || !isSupportedLocale(locale)) {
+      return NextResponse.json(
+        { error: "Invalid locale" },
+        { status: 400 }
+      );
+    }
+
+    const normalized = normalizeLocale(locale);
+    const cookieStore = await cookies();
+    cookieStore.set(LOCALE_COOKIE, normalized, {
+      path: "/",
+      maxAge: 60 * 60 * 24 * 365, // 1 year
+    });
+
+    return NextResponse.json({ success: true, locale: normalized });
+  } catch (error) {
+    return NextResponse.json(
+      { error: "Failed to set locale" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/mcp/[plugin]/message/route.js

@@ -0,0 +1,21 @@
+import { NextResponse } from "next/server";
+import { sendToChild, findPlugin } from "@/lib/mcp/stdioSseBridge";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(request, { params }) {
+  // Cowork disabled: MCP stdio bridge spawns arbitrary processes (RCE risk).
+  return NextResponse.json({ error: "Cowork is disabled" }, { status: 403 });
+  const { plugin } = await params;
+  if (!findPlugin(plugin)) {
+    return NextResponse.json({ error: `Unknown plugin: ${plugin}` }, { status: 404 });
+  }
+  try {
+    const body = await request.json();
+    sendToChild(plugin, body);
+    return new Response(null, { status: 202 });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/src/app/api/mcp/[plugin]/sse/route.js

@@ -0,0 +1,37 @@
+import { registerSession, unregisterSession, findPlugin } from "@/lib/mcp/stdioSseBridge";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(request, { params }) {
+  // Cowork disabled: MCP stdio bridge spawns arbitrary processes (RCE risk).
+  return new Response("Cowork is disabled", { status: 403 });
+  const { plugin } = await params;
+  if (!findPlugin(plugin)) {
+    return new Response(`Unknown plugin: ${plugin}`, { status: 404 });
+  }
+
+  const encoder = new TextEncoder();
+  let sid;
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const send = (chunk) => controller.enqueue(encoder.encode(chunk));
+      sid = registerSession(plugin, send);
+      // MCP SSE handshake: tell client where to POST messages.
+      send(`event: endpoint\ndata: /api/mcp/${plugin}/message?sessionId=${sid}\n\n`);
+    },
+    cancel() {
+      if (sid) unregisterSession(plugin, sid);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}

package/src/app/api/media-providers/tts/deepgram/voices/route.js

@@ -0,0 +1,65 @@
+import { NextResponse } from "next/server";
+import { getProviderConnections } from "@/lib/localDb";
+
+const langNames = new Intl.DisplayNames(["en"], { type: "language" });
+
+/**
+ * GET /api/media-providers/tts/deepgram/voices[?lang=en]
+ * Returns { languages, byLang } grouped by language code (same shape as edge-tts/elevenlabs/inworld)
+ * Each Deepgram voice = one model (canonical_name like "aura-2-thalia-en")
+ */
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const langFilter = searchParams.get("lang");
+
+    const connections = await getProviderConnections({ provider: "deepgram", isActive: true });
+    const apiKey = connections[0]?.apiKey;
+    if (!apiKey) return NextResponse.json({ error: "No Deepgram connection found" }, { status: 400 });
+
+    const res = await fetch("https://api.deepgram.com/v1/models", {
+      headers: { "Authorization": `Token ${apiKey}` },
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return NextResponse.json({ error: `Deepgram API ${res.status}: ${text || "Failed"}` }, { status: 502 });
+    }
+    const data = await res.json();
+    const ttsModels = data.tts || [];
+
+    const byLang = {};
+    for (const m of ttsModels) {
+      // Deepgram returns `languages: ["en"]` or sometimes language inferred from canonical_name suffix
+      const langs = Array.isArray(m.languages) && m.languages.length
+        ? m.languages
+        : [m.canonical_name?.split("-").pop() || "en"];
+      for (const code of langs) {
+        if (!byLang[code]) {
+          byLang[code] = {
+            code,
+            name: (() => { try { return langNames.of(code); } catch { return code; } })(),
+            voices: [],
+          };
+        }
+        const voiceId = m.canonical_name || m.name;
+        if (!byLang[code].voices.find((x) => x.id === voiceId)) {
+          byLang[code].voices.push({
+            id: voiceId,
+            name: m.name || voiceId,
+            gender: m.metadata?.tags?.find((t) => t === "masculine" || t === "feminine") || "",
+            lang: code,
+          });
+        }
+      }
+    }
+
+    const languages = Object.values(byLang).sort((a, b) => a.name.localeCompare(b.name));
+
+    if (langFilter) {
+      return NextResponse.json({ voices: byLang[langFilter]?.voices || [] });
+    }
+    return NextResponse.json({ languages, byLang });
+  } catch (err) {
+    return NextResponse.json({ error: err.message || "Failed to fetch voices" }, { status: 502 });
+  }
+}

package/src/app/api/media-providers/tts/elevenlabs/voices/route.js

@@ -0,0 +1,71 @@
+import { NextResponse } from "next/server";
+import { getProviderConnections } from "@/lib/localDb";
+import { fetchElevenLabsVoices } from "open-sse/handlers/ttsCore.js";
+
+const langNames = new Intl.DisplayNames(["en"], { type: "language" });
+
+/**
+ * GET /api/media-providers/tts/elevenlabs/voices[?lang=en]
+ * Returns { languages, byLang } grouped by language - same format as edge-tts
+ * Uses direct DB read (no mutex) to avoid blocking on concurrent TTS requests
+ */
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const langFilter = searchParams.get("lang");
+
+    // Direct DB read - bypass auth mutex used for TTS inference
+    const connections = await getProviderConnections({ provider: "elevenlabs", isActive: true });
+    const apiKey = connections[0]?.apiKey;
+    if (!apiKey) {
+      return NextResponse.json({ error: "No ElevenLabs connection found" }, { status: 400 });
+    }
+
+    const voices = await fetchElevenLabsVoices(apiKey);
+
+    // Group by all supported languages (verified_languages + labels.language)
+    const byLang = {};
+    const addToLang = (code, voice) => {
+      if (!byLang[code]) {
+        byLang[code] = {
+          code,
+          name: (() => { try { return langNames.of(code); } catch { return code; } })(),
+          voices: [],
+        };
+      }
+      // Avoid duplicate voice in same lang
+      if (!byLang[code].voices.find((v) => v.id === voice.voice_id)) {
+        byLang[code].voices.push({
+          id: voice.voice_id,
+          name: voice.name,
+          gender: voice.labels?.gender || "",
+          lang: code,
+          // premade voices are free; professional library voices added to account may require paid plan
+          free_users_allowed: voice.category === "premade" || voice.is_owner === true
+        });
+      }
+    };
+    for (const v of voices) {
+      // Add to primary language
+      const primaryLang = v.labels?.language || "en";
+      addToLang(primaryLang, v);
+      // Add to all verified languages
+      for (const vl of v.verified_languages || []) {
+        if (vl.language && vl.language !== primaryLang) {
+          addToLang(vl.language, v);
+        }
+      }
+    }
+
+    const languages = Object.values(byLang).sort((a, b) => a.name.localeCompare(b.name));
+
+    // If lang filter requested, return only that group's voices
+    if (langFilter) {
+      return NextResponse.json({ voices: byLang[langFilter]?.voices || [] });
+    }
+
+    return NextResponse.json({ languages, byLang });
+  } catch (err) {
+    return NextResponse.json({ error: err.message || "Failed to fetch voices" }, { status: 502 });
+  }
+}

package/src/app/api/media-providers/tts/inworld/voices/route.js

@@ -0,0 +1,61 @@
+import { NextResponse } from "next/server";
+import { getProviderConnections } from "@/lib/localDb";
+
+const langNames = new Intl.DisplayNames(["en"], { type: "language" });
+
+/**
+ * GET /api/media-providers/tts/inworld/voices[?lang=en]
+ * Returns { languages, byLang } grouped by language code (same shape as edge-tts/elevenlabs)
+ */
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const langFilter = searchParams.get("lang");
+
+    const connections = await getProviderConnections({ provider: "inworld", isActive: true });
+    const apiKey = connections[0]?.apiKey;
+    if (!apiKey) return NextResponse.json({ error: "No Inworld connection found" }, { status: 400 });
+
+    const res = await fetch("https://api.inworld.ai/tts/v1/voices", {
+      headers: { "Authorization": `Basic ${apiKey}` },
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return NextResponse.json({ error: `Inworld API ${res.status}: ${text || "Failed"}` }, { status: 502 });
+    }
+    const data = await res.json();
+    const voices = data.voices || [];
+
+    const byLang = {};
+    for (const v of voices) {
+      // Each voice has `languages: ["en", "es", ...]`
+      const langs = Array.isArray(v.languages) && v.languages.length ? v.languages : ["en"];
+      for (const code of langs) {
+        if (!byLang[code]) {
+          byLang[code] = {
+            code,
+            name: (() => { try { return langNames.of(code); } catch { return code; } })(),
+            voices: [],
+          };
+        }
+        if (!byLang[code].voices.find((x) => x.id === v.voiceId)) {
+          byLang[code].voices.push({
+            id: v.voiceId,
+            name: v.displayName || v.voiceId,
+            gender: v.gender || "",
+            lang: code,
+          });
+        }
+      }
+    }
+
+    const languages = Object.values(byLang).sort((a, b) => a.name.localeCompare(b.name));
+
+    if (langFilter) {
+      return NextResponse.json({ voices: byLang[langFilter]?.voices || [] });
+    }
+    return NextResponse.json({ languages, byLang });
+  } catch (err) {
+    return NextResponse.json({ error: err.message || "Failed to fetch voices" }, { status: 502 });
+  }
+}

package/src/app/api/media-providers/tts/minimax/voices/route.js

@@ -0,0 +1,113 @@
+import { NextResponse } from "next/server";
+import { getProviderConnections } from "@/lib/localDb";
+
+const MINIMAX_VOICE_ENDPOINTS = {
+  minimax: "https://api.minimax.io/v1/get_voice",
+  "minimax-cn": "https://api.minimaxi.com/v1/get_voice",
+};
+
+const VOICE_GROUPS = [
+  { key: "system_voice", label: "System" },
+  { key: "voice_cloning", label: "Cloned" },
+  { key: "voice_generation", label: "Generated" },
+  { key: "music_generation", label: "Music" },
+];
+
+function inferLanguage(voiceId) {
+  const value = typeof voiceId === "string" ? voiceId.trim() : "";
+  if (!value.includes("_")) return "Custom";
+  return value.split("_")[0] || "Custom";
+}
+
+function addVoice(byLang, code, voice) {
+  if (!byLang[code]) byLang[code] = { code, name: code, voices: [] };
+  if (byLang[code].voices.some((v) => v.id === voice.id)) return;
+  byLang[code].voices.push(voice);
+}
+
+function normalizeMiniMaxVoices(data) {
+  const byLang = {};
+
+  for (const group of VOICE_GROUPS) {
+    const voices = Array.isArray(data?.[group.key]) ? data[group.key] : [];
+    for (const item of voices) {
+      const voiceId = item?.voice_id || item?.voiceId;
+      if (!voiceId) continue;
+
+      const voiceName = item?.voice_name || item?.voiceName || voiceId;
+      const lang = group.key === "system_voice" ? inferLanguage(voiceId) : "Custom";
+      addVoice(byLang, lang, {
+        id: voiceId,
+        name: group.key === "system_voice" ? voiceName : `${voiceName} · ${group.label}`,
+        lang,
+        category: group.key,
+      });
+    }
+  }
+
+  const languages = Object.values(byLang).sort((a, b) => {
+    if (a.code === "Custom") return 1;
+    if (b.code === "Custom") return -1;
+    return a.name.localeCompare(b.name);
+  });
+
+  for (const lang of languages) {
+    lang.voices.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  return { languages, byLang };
+}
+
+/**
+ * GET /api/media-providers/tts/minimax/voices[?provider=minimax|minimax-cn&voice_type=all]
+ * Returns { languages, byLang } grouped for the shared TTS voice picker.
+ */
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const provider = searchParams.get("provider") === "minimax-cn" ? "minimax-cn" : "minimax";
+    const voiceType = searchParams.get("voice_type") || "all";
+    const langFilter = searchParams.get("lang");
+
+    const connections = await getProviderConnections({ provider, isActive: true });
+    const apiKey = connections[0]?.apiKey;
+    if (!apiKey) {
+      return NextResponse.json({ error: `No ${provider} connection found` }, { status: 400 });
+    }
+
+    const res = await fetch(MINIMAX_VOICE_ENDPOINTS[provider], {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ voice_type: voiceType }),
+    });
+
+    const rawText = await res.text();
+    let data = {};
+    if (rawText) {
+      try { data = JSON.parse(rawText); } catch { data = {}; }
+    }
+
+    const baseResp = data.base_resp || data.baseResp || {};
+    const statusCode = Number(baseResp.status_code ?? baseResp.statusCode ?? 0);
+    const statusMessage = baseResp.status_msg || baseResp.statusMsg || data.message || "";
+
+    if (!res.ok) {
+      return NextResponse.json({ error: `MiniMax API ${res.status}: ${statusMessage || rawText || "Failed"}` }, { status: 502 });
+    }
+    if (statusCode !== 0) {
+      return NextResponse.json({ error: statusMessage || "MiniMax voice API error" }, { status: 502 });
+    }
+
+    const normalized = normalizeMiniMaxVoices(data);
+    if (langFilter) {
+      return NextResponse.json({ voices: normalized.byLang[langFilter]?.voices || [] });
+    }
+
+    return NextResponse.json(normalized);
+  } catch (err) {
+    return NextResponse.json({ error: err.message || "Failed to fetch MiniMax voices" }, { status: 502 });
+  }
+}