swayrouter 1.0.0

package/src/routes/api/oauth/kiro/social-exchange/route.js

@@ -0,0 +1,62 @@
+import { NextResponse } from "next/server";
+import { KiroService } from "@/lib/oauth/services/kiro";
+import { createProviderConnection } from "@/models";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const OAUTH_ERROR = publicError("oauth", "Social sign-in failed");
+
+export async function POST(request) {
+  try {
+    const { code, codeVerifier, provider } = await request.json();
+
+    if (!code || !codeVerifier) {
+      return NextResponse.json(
+        { error: "Missing required fields" },
+        { status: 400 }
+      );
+    }
+
+    if (!provider || !["google", "github"].includes(provider)) {
+      return NextResponse.json(
+        { error: "Invalid provider" },
+        { status: 400 }
+      );
+    }
+
+    const kiroService = new KiroService();
+
+    const tokenData = await kiroService.exchangeSocialCode(
+      code,
+      codeVerifier
+    );
+
+    const email = kiroService.extractEmailFromJWT(tokenData.accessToken);
+
+    const connection = await createProviderConnection({
+      provider: "kiro",
+      authType: "oauth",
+      accessToken: tokenData.accessToken,
+      refreshToken: tokenData.refreshToken,
+      expiresAt: new Date(Date.now() + tokenData.expiresIn * 1000).toISOString(),
+      email: email || null,
+      providerSpecificData: {
+        profileArn: tokenData.profileArn,
+        authMethod: provider,
+        provider: provider.charAt(0).toUpperCase() + provider.slice(1),
+      },
+      testStatus: "active",
+    });
+
+    return NextResponse.json({
+      success: true,
+      connection: {
+        id: connection.id,
+        provider: connection.provider,
+        email: connection.email,
+      },
+    });
+  } catch (error) {
+    logRouteError("OAuth][KiroSocialExchange", error);
+    return NextResponse.json({ error: OAUTH_ERROR }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,96 @@
+import { NextResponse } from "next/server";
+import { getPricing, updatePricing, resetPricing, resetAllPricing } from "@/lib/localDb.js";
+
+export async function GET() {
+  try {
+    const pricing = await getPricing();
+    return NextResponse.json(pricing);
+  } catch (error) {
+    console.error("Error fetching pricing:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch pricing" },
+      { status: 500 },
+    );
+  }
+}
+
+export async function PATCH(request) {
+  try {
+    const body = await request.json();
+
+    if (typeof body !== "object" || body === null) {
+      return NextResponse.json(
+        { error: "Invalid pricing data format" },
+        { status: 400 },
+      );
+    }
+
+    for (const [provider, models] of Object.entries(body)) {
+      if (typeof models !== "object" || models === null) {
+        return NextResponse.json(
+          { error: `Invalid pricing for provider: ${provider}` },
+          { status: 400 },
+        );
+      }
+
+      for (const [model, pricing] of Object.entries(models)) {
+        if (typeof pricing !== "object" || pricing === null) {
+          return NextResponse.json(
+            { error: `Invalid pricing for model: ${provider}/${model}` },
+            { status: 400 },
+          );
+        }
+
+        const validFields = ["input", "output", "cached", "reasoning", "cache_creation"];
+        for (const [key, value] of Object.entries(pricing)) {
+          if (!validFields.includes(key)) {
+            return NextResponse.json(
+              { error: `Invalid pricing field: ${key} for ${provider}/${model}` },
+              { status: 400 },
+            );
+          }
+          if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
+            return NextResponse.json(
+              { error: `Invalid pricing value for ${key} in ${provider}/${model}: must be non-negative number` },
+              { status: 400 },
+            );
+          }
+        }
+      }
+    }
+
+    const updatedPricing = await updatePricing(body);
+    return NextResponse.json(updatedPricing);
+  } catch (error) {
+    console.error("Error updating pricing:", error);
+    return NextResponse.json(
+      { error: "Failed to update pricing" },
+      { status: 500 },
+    );
+  }
+}
+
+export async function DELETE(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const provider = searchParams.get("provider");
+    const model = searchParams.get("model");
+
+    if (provider && model) {
+      await resetPricing(provider, model);
+    } else if (provider) {
+      await resetPricing(provider);
+    } else {
+      await resetAllPricing();
+    }
+
+    const pricing = await getPricing();
+    return NextResponse.json(pricing);
+  } catch (error) {
+    console.error("Error resetting pricing:", error);
+    return NextResponse.json(
+      { error: "Failed to reset pricing" },
+      { status: 500 },
+    );
+  }
+}

package/src/routes/api/provider-nodes/[id]/route.js

@@ -0,0 +1,106 @@
+import { NextResponse } from "next/server";
+import { deleteProviderConnectionsByProvider, deleteProviderNode, getProviderConnections, getProviderNodeById, updateProviderConnection, updateProviderNode } from "@/models";
+
+function normalizePrefix(value) {
+  return String(value || "").trim().toLowerCase().replace(/\s+/g, "-");
+}
+
+export async function PUT(request, { params }) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+    const { name, prefix, apiType, baseUrl } = body;
+    const node = await getProviderNodeById(id);
+
+    if (!node) {
+      return NextResponse.json({ error: "Provider node not found" }, { status: 404 });
+    }
+
+    if (!name?.trim()) {
+      return NextResponse.json({ error: "Name is required" }, { status: 400 });
+    }
+
+    if (!prefix?.trim()) {
+      return NextResponse.json({ error: "Prefix is required" }, { status: 400 });
+    }
+
+    if (node.type === "openai-compatible" && (!apiType || !["chat", "responses"].includes(apiType))) {
+      return NextResponse.json({ error: "Invalid OpenAI compatible API type" }, { status: 400 });
+    }
+
+    if (!baseUrl?.trim()) {
+      return NextResponse.json({ error: "Base URL is required" }, { status: 400 });
+    }
+
+    let sanitizedBaseUrl = baseUrl.trim();
+
+    if (node.type === "anthropic-compatible") {
+      sanitizedBaseUrl = sanitizedBaseUrl.replace(/\/$/, "");
+      if (sanitizedBaseUrl.endsWith("/messages")) {
+        sanitizedBaseUrl = sanitizedBaseUrl.slice(0, -9);
+      }
+    }
+
+    if (node.type === "custom-embedding") {
+      sanitizedBaseUrl = sanitizedBaseUrl.replace(/\/$/, "");
+      if (sanitizedBaseUrl.endsWith("/embeddings")) {
+        sanitizedBaseUrl = sanitizedBaseUrl.slice(0, -"/embeddings".length);
+      }
+    }
+
+    const updates = {
+      name: name.trim(),
+      prefix: normalizePrefix(prefix),
+      baseUrl: sanitizedBaseUrl,
+    };
+
+    if (node.type === "openai-compatible") {
+      updates.apiType = apiType;
+    }
+
+    const updated = await updateProviderNode(id, updates);
+
+    const connections = await getProviderConnections({ provider: id });
+    await Promise.all(connections.map((connection) => (
+      updateProviderConnection(connection.id, {
+        providerSpecificData: {
+          ...(connection.providerSpecificData || {}),
+          prefix: normalizePrefix(prefix),
+          apiType: node.type === "openai-compatible" ? apiType : undefined,
+          baseUrl: sanitizedBaseUrl,
+          nodeName: updated.name,
+        }
+      })
+    )));
+
+    return NextResponse.json({ node: updated });
+  } catch (error) {
+    if (error?.code === "DUPLICATE_PROVIDER_NODE") {
+      return NextResponse.json(
+        { error: error.message, code: error.code, field: error.field },
+        { status: 409 }
+      );
+    }
+    console.log("Error updating provider node:", error);
+    return NextResponse.json({ error: "Failed to update provider node" }, { status: 500 });
+  }
+}
+
+export async function DELETE(request, { params }) {
+  try {
+    const { id } = await params;
+    const node = await getProviderNodeById(id);
+
+    if (!node) {
+      return NextResponse.json({ error: "Provider node not found" }, { status: 404 });
+    }
+
+    await deleteProviderConnectionsByProvider(id);
+    await deleteProviderNode(id);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.log("Error deleting provider node:", error);
+    return NextResponse.json({ error: "Failed to delete provider node" }, { status: 500 });
+  }
+}

package/src/routes/api/provider-nodes/route.js

@@ -0,0 +1,110 @@
+import { NextResponse } from "next/server";
+import { createProviderNode, getProviderNodes } from "@/models";
+import { OPENAI_COMPATIBLE_PREFIX, ANTHROPIC_COMPATIBLE_PREFIX, CUSTOM_EMBEDDING_PREFIX } from "@/shared/constants/providers";
+import { generateId } from "@/shared/utils";
+
+export const dynamic = "force-dynamic";
+
+const OPENAI_COMPATIBLE_DEFAULTS = {
+  baseUrl: "https://api.openai.com/v1",
+};
+
+const ANTHROPIC_COMPATIBLE_DEFAULTS = {
+  baseUrl: "https://api.anthropic.com/v1",
+};
+
+const CUSTOM_EMBEDDING_DEFAULTS = {
+  baseUrl: "https://api.openai.com/v1",
+};
+
+function normalizePrefix(value) {
+  return String(value || "").trim().toLowerCase().replace(/\s+/g, "-");
+}
+
+export async function GET() {
+  try {
+    const nodes = await getProviderNodes();
+    return NextResponse.json({ nodes });
+  } catch (error) {
+    console.log("Error fetching provider nodes:", error);
+    return NextResponse.json({ error: "Failed to fetch provider nodes" }, { status: 500 });
+  }
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const { name, prefix, apiType, baseUrl, type } = body;
+
+    if (!name?.trim()) {
+      return NextResponse.json({ error: "Name is required" }, { status: 400 });
+    }
+
+    if (!prefix?.trim()) {
+      return NextResponse.json({ error: "Prefix is required" }, { status: 400 });
+    }
+
+    const nodeType = type || "openai-compatible";
+
+    if (nodeType === "openai-compatible") {
+      if (!apiType || !["chat", "responses"].includes(apiType)) {
+        return NextResponse.json({ error: "Invalid OpenAI compatible API type" }, { status: 400 });
+      }
+
+      const node = await createProviderNode({
+        id: `${OPENAI_COMPATIBLE_PREFIX}${apiType}-${generateId()}`,
+        type: "openai-compatible",
+        prefix: normalizePrefix(prefix),
+        apiType,
+        baseUrl: (baseUrl || OPENAI_COMPATIBLE_DEFAULTS.baseUrl).trim(),
+        name: name.trim(),
+      });
+      return NextResponse.json({ node }, { status: 201 });
+    }
+
+    if (nodeType === "custom-embedding") {
+
+      let sanitizedBaseUrl = (baseUrl || CUSTOM_EMBEDDING_DEFAULTS.baseUrl).trim().replace(/\/$/, "");
+      if (sanitizedBaseUrl.endsWith("/embeddings")) {
+        sanitizedBaseUrl = sanitizedBaseUrl.slice(0, -"/embeddings".length);
+      }
+
+      const node = await createProviderNode({
+        id: `${CUSTOM_EMBEDDING_PREFIX}${generateId()}`,
+        type: "custom-embedding",
+        prefix: normalizePrefix(prefix),
+        baseUrl: sanitizedBaseUrl,
+        name: name.trim(),
+      });
+      return NextResponse.json({ node }, { status: 201 });
+    }
+
+    if (nodeType === "anthropic-compatible") {
+
+      let sanitizedBaseUrl = (baseUrl || ANTHROPIC_COMPATIBLE_DEFAULTS.baseUrl).trim().replace(/\/$/, "");
+      if (sanitizedBaseUrl.endsWith("/messages")) {
+        sanitizedBaseUrl = sanitizedBaseUrl.slice(0, -9);
+      }
+
+      const node = await createProviderNode({
+        id: `${ANTHROPIC_COMPATIBLE_PREFIX}${generateId()}`,
+        type: "anthropic-compatible",
+        prefix: normalizePrefix(prefix),
+        baseUrl: sanitizedBaseUrl,
+        name: name.trim(),
+      });
+      return NextResponse.json({ node }, { status: 201 });
+    }
+
+    return NextResponse.json({ error: "Invalid provider node type" }, { status: 400 });
+  } catch (error) {
+    if (error?.code === "DUPLICATE_PROVIDER_NODE") {
+      return NextResponse.json(
+        { error: error.message, code: error.code, field: error.field },
+        { status: 409 }
+      );
+    }
+    console.log("Error creating provider node:", error);
+    return NextResponse.json({ error: "Failed to create provider node" }, { status: 500 });
+  }
+}

package/src/routes/api/provider-nodes/validate/route.js

@@ -0,0 +1,197 @@
+import { NextResponse } from "next/server";
+import { assertPublicUrlAtDispatch } from "@/shared/utils/ssrfGuard.js";
+import { isLocalRequest } from "@/dashboardGuard";
+
+const fetchWithTimeout = (url, options, timeout = 10000) => {
+  return Promise.race([
+    fetch(url, options),
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error("Request timeout")), timeout)
+    )
+  ]);
+};
+
+const isValidUrl = (url) => {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const getErrorMessage = (error) => {
+  if (error.cause?.code === "ECONNREFUSED") return "Connection refused - provider node offline or unreachable";
+  if (error.cause?.code === "ENOTFOUND") return "DNS lookup failed - invalid domain or network issue";
+  if (error.cause?.code === "ETIMEDOUT") return "Connection timeout - provider node too slow";
+  if (error.message.includes("timeout")) return "Request timeout (>10s) - provider node not responding";
+  if (error.cause?.code === "CERT_HAS_EXPIRED") return "SSL certificate expired";
+  if (error.cause?.code === "UNABLE_TO_VERIFY_LEAF_SIGNATURE") return "SSL certificate verification failed";
+  if (error.cause?.code) return `Network error: ${error.cause.code}`;
+  return "Network connection failed - check URL and network connectivity";
+};
+
+const getModelsErrorMessage = (status) => {
+  if (status === 401 || status === 403) return "API key unauthorized";
+  if (status === 404) return "/models endpoint not found - try chat validation with model ID";
+  if (status >= 500) return "Server error - try again later";
+  return `Unexpected response (${status})`;
+};
+
+const getChatErrorMessage = (status) => {
+  if (status === 401 || status === 403) return "API key unauthorized";
+  if (status === 400) return "Invalid model or bad request";
+  if (status === 404) return "Chat endpoint not found";
+  if (status >= 500) return "Server error - try again later";
+  return `Chat request failed (${status})`;
+};
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const { baseUrl, apiKey, type, modelId } = body;
+
+    if (!baseUrl || !apiKey) {
+      return NextResponse.json({ error: "Base URL and API key required" }, { status: 400 });
+    }
+
+    if (!isValidUrl(baseUrl)) {
+      return NextResponse.json({ error: "Invalid URL format" }, { status: 400 });
+    }
+
+    if (!isLocalRequest(request)) {
+      try {
+        await assertPublicUrlAtDispatch(baseUrl, { label: "provider base URL" });
+      } catch {
+        return NextResponse.json({ error: "URL not allowed" }, { status: 400 });
+      }
+    }
+
+    if (type === "custom-embedding") {
+      const normalizedBase = baseUrl.trim().replace(/\/$/, "");
+      if (!modelId?.trim()) {
+        return NextResponse.json({ valid: false, error: "Model ID required for embedding validation" });
+      }
+      const embedRes = await fetchWithTimeout(`${normalizedBase}/embeddings`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ model: modelId.trim(), input: "ping" })
+      });
+      if (embedRes.ok) {
+        const data = await embedRes.json().catch(() => null);
+        const dims = Array.isArray(data?.data?.[0]?.embedding) ? data.data[0].embedding.length : null;
+        return NextResponse.json({ valid: true, method: "embeddings", dimensions: dims });
+      }
+      if (embedRes.status === 401 || embedRes.status === 403) {
+        return NextResponse.json({ valid: false, error: "API key unauthorized" });
+      }
+      await embedRes.text().catch(() => "");
+      return NextResponse.json({
+        valid: false,
+        error: `Embeddings request failed (${embedRes.status})`,
+        method: "embeddings"
+      });
+    }
+
+    if (type === "anthropic-compatible") {
+      let normalizedBase = baseUrl.trim().replace(/\/$/, "");
+      if (normalizedBase.endsWith("/messages")) {
+        normalizedBase = normalizedBase.slice(0, -9);
+      }
+
+      const modelsUrl = `${normalizedBase}/models`;
+      const res = await fetchWithTimeout(modelsUrl, {
+        method: "GET",
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          "Authorization": `Bearer ${apiKey}`
+        }
+      });
+
+      if (res.ok) return NextResponse.json({ valid: true });
+
+      if (res.status === 401 || res.status === 403) {
+        return NextResponse.json({ valid: false, error: "API key unauthorized" });
+      }
+
+      if (modelId) {
+        const chatRes = await fetchWithTimeout(`${normalizedBase}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify({
+            model: modelId,
+            messages: [{ role: "user", content: "ping" }],
+            max_tokens: 1
+          })
+        });
+        if (chatRes.ok) {
+          return NextResponse.json({ valid: true, method: "chat" });
+        }
+        return NextResponse.json({
+          valid: false,
+          error: getChatErrorMessage(chatRes.status),
+          method: "chat"
+        });
+      }
+
+      return NextResponse.json({ valid: false, error: getModelsErrorMessage(res.status) });
+    }
+
+    const modelsUrl = `${baseUrl.replace(/\/$/, "")}/models`;
+    const res = await fetchWithTimeout(modelsUrl, {
+      headers: { "Authorization": `Bearer ${apiKey}` },
+    });
+
+    if (res.ok) return NextResponse.json({ valid: true });
+
+    if (res.status === 401 || res.status === 403) {
+      return NextResponse.json({ valid: false, error: "API key unauthorized" });
+    }
+
+    if (modelId) {
+      const chatRes = await fetchWithTimeout(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: modelId,
+          messages: [{ role: "user", content: "ping" }],
+          max_tokens: 1
+        })
+      });
+      if (chatRes.ok) {
+        return NextResponse.json({ valid: true, method: "chat" });
+      }
+      return NextResponse.json({
+        valid: false,
+        error: getChatErrorMessage(chatRes.status),
+        method: "chat"
+      });
+    }
+
+    return NextResponse.json({ valid: false, error: getModelsErrorMessage(res.status) });
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    console.error("Error validating provider node:", {
+      message: error.message,
+      cause: error.cause,
+      code: error.cause?.code,
+      userMessage: errorMessage
+    });
+    return NextResponse.json({
+      valid: false,
+      error: errorMessage
+    }, { status: 500 });
+  }
+}