swayrouter 1.0.0

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

@@ -0,0 +1,73 @@
+import { NextResponse } from "next/server";
+import { getComboById, updateCombo, deleteCombo, getComboByName } from "@/lib/localDb";
+import { resetComboRotation } from "open-sse/services/combo.js";
+
+const VALID_NAME_REGEX = /^[a-zA-Z0-9_.\-]+$/;
+
+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 });
+  }
+}
+
+export async function PUT(request, { params }) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+
+    if (body.name) {
+      if (!VALID_NAME_REGEX.test(body.name)) {
+        return NextResponse.json({ error: "Name can only contain letters, numbers, -, _ and ." }, { status: 400 });
+      }
+
+      const existing = await getComboByName(body.name);
+      if (existing && existing.id !== id) {
+        return NextResponse.json({ error: "Combo name already exists" }, { status: 400 });
+      }
+    }
+
+    const prev = await getComboById(id);
+    const combo = await updateCombo(id, body);
+
+    if (!combo) {
+      return NextResponse.json({ error: "Combo not found" }, { status: 404 });
+    }
+
+    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 });
+  }
+}
+
+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/routes/api/combos/route.js

@@ -0,0 +1,43 @@
+import { NextResponse } from "next/server";
+import { getCombos, createCombo, getComboByName } from "@/lib/localDb";
+
+export const dynamic = "force-dynamic";
+
+const VALID_NAME_REGEX = /^[a-zA-Z0-9_.\-]+$/;
+
+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 });
+  }
+}
+
+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 });
+    }
+
+    if (!VALID_NAME_REGEX.test(name)) {
+      return NextResponse.json({ error: "Name can only contain letters, numbers, -, _ and ." }, { status: 400 });
+    }
+
+    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/routes/api/health/live/route.js

@@ -0,0 +1,7 @@
+import { NextResponse } from "next/server";
+
+const HEADERS = { "Cache-Control": "no-store" };
+
+export function GET() {
+  return NextResponse.json({ ok: true, status: "live" }, { headers: HEADERS });
+}

package/src/routes/api/health/ready/route.js

@@ -0,0 +1,19 @@
+import { NextResponse } from "next/server";
+import { getAdapter } from "@/lib/db/driver.js";
+import { getLifecycleSnapshot } from "@/lifecycle/appLifecycle";
+
+const HEADERS = { "Cache-Control": "no-store" };
+
+export async function GET() {
+  const lifecycle = getLifecycleSnapshot();
+  if (lifecycle.state !== "ready") {
+    return NextResponse.json({ ok: false, status: "not_ready" }, { status: 503, headers: HEADERS });
+  }
+  try {
+    const db = await getAdapter();
+    db.get("SELECT 1 AS ok");
+    return NextResponse.json({ ok: true, status: "ready" }, { headers: HEADERS });
+  } catch {
+    return NextResponse.json({ ok: false, status: "not_ready" }, { status: 503, headers: HEADERS });
+  }
+}

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

@@ -0,0 +1,17 @@
+import { NextResponse } from "next/server";
+
+const CORS_HEADERS = {
+  "Cache-Control": "no-store",
+
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Api-Key",
+};
+
+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/routes/api/inflight/stream/route.js

@@ -0,0 +1,24 @@
+import { createInflightStream } from "@/utils/inflight";
+
+export async function GET(request) {
+  const { stream, status, cleanup } = createInflightStream();
+
+  if (status === 429 || !stream) {
+    return new Response(
+      JSON.stringify({ error: "Too many SSE connections", maxClients: 10 }),
+      { status: 429, headers: { "Content-Type": "application/json" } }
+    );
+  }
+
+  request.signal?.addEventListener("abort", () => cleanup());
+
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      "Connection": "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}

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

@@ -0,0 +1,3 @@
+export async function GET() {
+  return new Response("Initialized", { status: 200 });
+}

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

@@ -0,0 +1,71 @@
+import { NextResponse } from "next/server";
+import { deleteApiKey, getApiKeyById, getApiKeySecretById, rotateApiKey, updateApiKey } from "@/lib/localDb";
+
+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 });
+    }
+    const secret = await getApiKeySecretById(id);
+    return NextResponse.json({ key: secret ? { ...key, key: secret } : key });
+  } catch (error) {
+    console.log("Error fetching key:", error);
+    return NextResponse.json({ error: "Failed to fetch key" }, { status: 500 });
+  }
+}
+
+export async function PUT(request, { params }) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    const { isActive, rotate } = body;
+
+    if (isActive !== undefined && typeof isActive !== "boolean") {
+      return NextResponse.json({ error: "isActive must be a boolean" }, { status: 400 });
+    }
+    if (rotate !== undefined && typeof rotate !== "boolean") {
+      return NextResponse.json({ error: "rotate must be a boolean" }, { status: 400 });
+    }
+
+    const existing = await getApiKeyById(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Key not found" }, { status: 404 });
+    }
+
+    if (rotate === true) {
+      const rotated = await rotateApiKey(id);
+      return NextResponse.json({ key: rotated, message: "API key rotated. Replace the old secret in your clients." });
+    }
+
+    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 });
+  }
+}
+
+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);
+    if (error?.code === "DEFAULT_API_KEY") {
+      return NextResponse.json({ error: error.message }, { status: 409 });
+    }
+    return NextResponse.json({ error: "Failed to delete key" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import { getApiKeys, createApiKey } from "@/lib/localDb";
+import { getConsistentMachineId } from "@/shared/utils/machineId";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  try {
+    const keys = await getApiKeys();
+    const includeRevoked = new URL(request.url).searchParams.get("includeRevoked") === "1";
+    return NextResponse.json({ keys: includeRevoked ? keys : keys.filter((key) => key.isActive !== false) });
+  } catch (error) {
+    console.log("Error fetching keys:", error);
+    return NextResponse.json({ error: "Failed to fetch keys" }, { status: 500 });
+  }
+}
+
+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 });
+    }
+
+    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,
+      isDefault: apiKey.isDefault === true,
+    }, { status: 201 });
+  } catch (error) {
+    console.log("Error creating key:", error);
+    return NextResponse.json({ error: "Failed to create key" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,19 @@
+import { searchLogs } from "@/lib/usageDb.js";
+
+export async function GET(request) {
+  const url = new URL(request.url);
+  const qp = url.searchParams;
+
+  const result = await searchLogs({
+    page:     qp.get("page")     || 1,
+    limit:    qp.get("limit")    || 50,
+    provider: qp.get("provider") || undefined,
+    model:    qp.get("model")    || undefined,
+    status:   qp.get("status")   || undefined,
+    q:        qp.get("q")        || undefined,
+  });
+
+  return new Response(JSON.stringify(result), {
+    headers: { "Content-Type": "application/json" },
+  });
+}

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

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { sendToChild, findPlugin } from "@/lib/mcp/stdioSseBridge";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const MCP_MESSAGE_ERROR = publicError("provider", "MCP message failed");
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(request, { params }) {
+  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) {
+    logRouteError("McpMessage", e);
+    return NextResponse.json({ error: MCP_MESSAGE_ERROR }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,35 @@
+import { registerSession, unregisterSession, findPlugin } from "@/lib/mcp/stdioSseBridge";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(request, { params }) {
+  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);
+
+      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/routes/api/models/availability/route.js

@@ -0,0 +1,104 @@
+import { NextResponse } from "next/server";
+import {
+  getProviderConnectionsForRouting,
+  updateProviderConnection,
+} from "@/lib/localDb";
+
+const MODEL_LOCK_PREFIX = "modelLock_";
+
+function getActiveModelLocks(connection) {
+  const now = Date.now();
+  return Object.entries(connection)
+    .filter(([key, value]) => key.startsWith(MODEL_LOCK_PREFIX) && value)
+    .map(([key, value]) => ({
+      key,
+      model: key.slice(MODEL_LOCK_PREFIX.length) || "__all",
+      until: value,
+      active: new Date(value).getTime() > now,
+    }))
+    .filter((lock) => lock.active);
+}
+
+export async function GET() {
+  try {
+
+    const connections = await getProviderConnectionsForRouting({ isActive: true });
+    const models = [];
+
+    for (const connection of connections) {
+      const locks = getActiveModelLocks(connection);
+      for (const lock of locks) {
+        models.push({
+          provider: connection.provider,
+          model: lock.model,
+          status: "cooldown",
+          until: lock.until,
+          connectionId: connection.id,
+          connectionName: connection.name || connection.email || connection.id,
+          lastError: connection.lastError || null,
+        });
+      }
+
+      if (locks.length === 0 && connection.testStatus === "unavailable") {
+        models.push({
+          provider: connection.provider,
+          model: "__all",
+          status: "unavailable",
+          connectionId: connection.id,
+          connectionName: connection.name || connection.email || connection.id,
+          lastError: connection.lastError || null,
+        });
+      }
+    }
+
+    return NextResponse.json({
+      models,
+      unavailableCount: models.length,
+    });
+  } catch (error) {
+    console.error("[API] Failed to get model availability:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch model availability" },
+      { status: 500 },
+    );
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { action, provider, model } = await request.json();
+
+    if (action !== "clearCooldown" || !provider || !model) {
+      return NextResponse.json({ error: "Invalid request" }, { status: 400 });
+    }
+
+    const connections = await getProviderConnectionsForRouting({ provider });
+    const lockKey = `${MODEL_LOCK_PREFIX}${model}`;
+
+    await Promise.all(
+      connections
+        .filter((connection) => connection[lockKey])
+        .map((connection) =>
+          updateProviderConnection(connection.id, {
+            [lockKey]: null,
+            ...(connection.testStatus === "unavailable"
+              ? {
+                  testStatus: "active",
+                  lastError: null,
+                  lastErrorAt: null,
+                  backoffLevel: 0,
+                }
+              : {}),
+          }),
+        ),
+    );
+
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    console.error("[API] Failed to clear model cooldown:", error);
+    return NextResponse.json(
+      { error: "Failed to clear cooldown" },
+      { status: 500 },
+    );
+  }
+}

package/src/routes/api/models/custom/route.js

@@ -0,0 +1,58 @@
+import { NextResponse } from "next/server";
+import { getCustomModels, addCustomModel, deleteCustomModel } from "@/models";
+import { getCapabilitiesForModel } from "open-sse/providers/capabilities.js";
+import { getThinkingLevels } from "open-sse/providers/thinkingLevels.js";
+import { resolveProviderId } from "@/shared/constants/providers";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  try {
+    const models = await getCustomModels();
+    return NextResponse.json({
+      models: models.map((model) => {
+        const provider = resolveProviderId(model.providerAlias);
+        const capabilities = getCapabilitiesForModel(provider, model.id, model.capabilities || null);
+        return {
+          ...model,
+          capabilities,
+          thinkingLevels: getThinkingLevels(provider, model.id, model.capabilities || null),
+        };
+      }),
+    });
+  } catch (error) {
+    console.log("Error fetching custom models:", error);
+    return NextResponse.json({ error: "Failed to fetch custom models" }, { status: 500 });
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { providerAlias, id, type, name, capabilities } = await request.json();
+    if (!providerAlias || !id) {
+      return NextResponse.json({ error: "providerAlias and id required" }, { status: 400 });
+    }
+    const added = await addCustomModel({ providerAlias, id, type: type || "llm", name, capabilities });
+    return NextResponse.json({ success: true, added });
+  } catch (error) {
+    console.log("Error adding custom model:", error);
+    return NextResponse.json({ error: "Failed to add custom model" }, { status: 500 });
+  }
+}
+
+export async function DELETE(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const providerAlias = searchParams.get("providerAlias");
+    const id = searchParams.get("id");
+    const type = searchParams.get("type") || "llm";
+    if (!providerAlias || !id) {
+      return NextResponse.json({ error: "providerAlias and id required" }, { status: 400 });
+    }
+    await deleteCustomModel({ providerAlias, id, type });
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.log("Error deleting custom model:", error);
+    return NextResponse.json({ error: "Failed to delete custom model" }, { status: 500 });
+  }
+}

package/src/routes/api/models/disabled/route.js

@@ -0,0 +1,47 @@
+import { NextResponse } from "next/server";
+import { getDisabledModels, disableModels, enableModels } from "@/lib/disabledModelsDb";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const providerAlias = searchParams.get("providerAlias");
+    const all = await getDisabledModels();
+    if (providerAlias) return NextResponse.json({ ids: all[providerAlias] || [] });
+    return NextResponse.json({ disabled: all });
+  } catch (error) {
+    console.log("Error fetching disabled models:", error);
+    return NextResponse.json({ error: "Failed to fetch disabled models" }, { status: 500 });
+  }
+}
+
+export async function POST(request) {
+  try {
+    const { providerAlias, ids } = await request.json();
+    if (!providerAlias || !Array.isArray(ids)) {
+      return NextResponse.json({ error: "providerAlias and ids[] required" }, { status: 400 });
+    }
+    await disableModels(providerAlias, ids);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.log("Error disabling models:", error);
+    return NextResponse.json({ error: "Failed to disable models" }, { status: 500 });
+  }
+}
+
+export async function DELETE(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const providerAlias = searchParams.get("providerAlias");
+    const id = searchParams.get("id");
+    if (!providerAlias) {
+      return NextResponse.json({ error: "providerAlias required" }, { status: 400 });
+    }
+    await enableModels(providerAlias, id ? [id] : []);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.log("Error enabling models:", error);
+    return NextResponse.json({ error: "Failed to enable models" }, { status: 500 });
+  }
+}

package/src/routes/api/models/route.js

@@ -0,0 +1,64 @@
+import { NextResponse } from "next/server";
+import { getDisabledModels } from "@/lib/disabledModelsDb";
+import { AI_MODELS } from "@/shared/constants/config";
+import { getProviderAlias, resolveProviderId } from "@/shared/constants/providers";
+import { getCapabilitiesForModel } from "open-sse/providers/capabilities.js";
+import { getThinkingLevels } from "open-sse/providers/thinkingLevels.js";
+
+function publicModelId(provider, model) {
+  const value = String(model || "").trim();
+  if (provider === "clinepass" || provider === "cline-pass") {
+    return value.replace(/^(?:clinepass|cline-pass)\//, "");
+  }
+  return value;
+}
+
+export async function GET() {
+  try {
+    const disabled = await getDisabledModels();
+
+    const models = AI_MODELS
+      .filter((m) => {
+        const alias = getProviderAlias(m.provider) || m.provider;
+        const list = disabled[alias] || disabled[m.provider] || [];
+        return !list.includes(m.model);
+      })
+      .map((m) => {
+        const publicModel = publicModelId(m.provider, m.model);
+        const fullModel = `${m.provider}/${publicModel}`;
+        const providerAlias = getProviderAlias(m.provider) || m.provider;
+        const routedModel = `${providerAlias}/${publicModel}`;
+        const providerId = resolveProviderId(m.provider);
+        const c = getCapabilitiesForModel(providerId, m.model);
+        const thinkingLevels = getThinkingLevels(providerId, m.model);
+        return {
+          ...m,
+          fullModel,
+          routedModel,
+          name: m.name || publicModel,
+          thinkingLevels,
+          caps: {
+            vision: c.vision,
+            pdf: c.pdf,
+            audioInput: c.audioInput,
+            videoInput: c.videoInput,
+            imageOutput: c.imageOutput,
+            audioOutput: c.audioOutput,
+            search: c.search,
+            tools: c.tools,
+            reasoning: c.reasoning,
+            thinkingFormat: c.thinkingFormat,
+            thinkingCanDisable: c.thinkingCanDisable,
+            thinkingRange: c.thinkingRange,
+            contextWindow: c.contextWindow,
+            maxOutput: c.maxOutput,
+          },
+        };
+      });
+
+    return NextResponse.json({ models });
+  } catch (error) {
+    console.log("Error fetching models:", error);
+    return NextResponse.json({ error: "Failed to fetch models" }, { status: 500 });
+  }
+}