vforclaude2 0.3.87

package/src/app/api/oauth/kiro/import/route.js

@@ -0,0 +1,56 @@
+import { NextResponse } from "next/server";
+import { KiroService } from "@/lib/oauth/services/kiro";
+import { createProviderConnection } from "@/models";
+
+/**
+ * POST /api/oauth/kiro/import
+ * Import and validate refresh token from Kiro IDE
+ */
+export async function POST(request) {
+  try {
+    const { refreshToken } = await request.json();
+
+    if (!refreshToken || typeof refreshToken !== "string") {
+      return NextResponse.json(
+        { error: "Refresh token is required" },
+        { status: 400 }
+      );
+    }
+
+    const kiroService = new KiroService();
+
+    // Validate and refresh token
+    const tokenData = await kiroService.validateImportToken(refreshToken.trim());
+
+    // Extract email from JWT if available
+    const email = kiroService.extractEmailFromJWT(tokenData.accessToken);
+
+    // Save to database
+    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: "imported",
+        provider: "Imported",
+      },
+      testStatus: "active",
+    });
+
+    return NextResponse.json({
+      success: true,
+      connection: {
+        id: connection.id,
+        provider: connection.provider,
+        email: connection.email,
+      },
+    });
+  } catch (error) {
+    console.log("Kiro import token error:", error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

package/src/app/api/oauth/kiro/social-authorize/route.js

@@ -0,0 +1,43 @@
+import { NextResponse } from "next/server";
+import { generatePKCE } from "@/lib/oauth/utils/pkce";
+import { KiroService } from "@/lib/oauth/services/kiro";
+
+/**
+ * GET /api/oauth/kiro/social-authorize
+ * Generate Google/GitHub social login URL for manual callback flow
+ * Uses kiro:// custom protocol as required by AWS Cognito
+ */
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const provider = searchParams.get("provider"); // "google" or "github"
+
+    if (!provider || !["google", "github"].includes(provider)) {
+      return NextResponse.json(
+        { error: "Invalid provider. Use 'google' or 'github'" },
+        { status: 400 }
+      );
+    }
+
+    // Generate PKCE for social auth
+    const { codeVerifier, codeChallenge, state } = generatePKCE();
+
+    const kiroService = new KiroService();
+    const authUrl = kiroService.buildSocialLoginUrl(
+      provider,
+      codeChallenge,
+      state
+    );
+
+    return NextResponse.json({
+      authUrl,
+      state,
+      codeVerifier,
+      codeChallenge,
+      provider,
+    });
+  } catch (error) {
+    console.log("Kiro social authorize error:", error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,67 @@
+import { NextResponse } from "next/server";
+import { KiroService } from "@/lib/oauth/services/kiro";
+import { createProviderConnection } from "@/models";
+
+/**
+ * POST /api/oauth/kiro/social-exchange
+ * Exchange authorization code for tokens (Google/GitHub social login)
+ * Callback URL will be in format: kiro://kiro.kiroAgent/authenticate-success?code=XXX&state=YYY
+ */
+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();
+
+    // Exchange code for tokens (redirect_uri handled internally)
+    const tokenData = await kiroService.exchangeSocialCode(
+      code,
+      codeVerifier
+    );
+
+    // Extract email from JWT if available
+    const email = kiroService.extractEmailFromJWT(tokenData.accessToken);
+
+    // Save to database
+    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, // "google" or "github"
+        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) {
+    console.log("Kiro social exchange error:", error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,134 @@
+import { NextResponse } from "next/server";
+import { getPricing, updatePricing, resetPricing, resetAllPricing } from "@/lib/localDb.js";
+import { getDefaultPricing } from "@/shared/constants/pricing.js";
+
+/**
+ * GET /api/pricing
+ * Get current pricing configuration (merged user + defaults)
+ */
+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 }
+    );
+  }
+}
+
+/**
+ * PATCH /api/pricing
+ * Update pricing configuration
+ * Body: { provider: { model: { input: number, output: number, cached: number, ... } } }
+ */
+export async function PATCH(request) {
+  try {
+    const body = await request.json();
+
+    // Validate body structure
+    if (typeof body !== "object" || body === null) {
+      return NextResponse.json(
+        { error: "Invalid pricing data format" },
+        { status: 400 }
+      );
+    }
+
+    // Validate pricing structure
+    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 }
+          );
+        }
+
+        // Validate pricing fields
+        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" || 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 }
+    );
+  }
+}
+
+/**
+ * DELETE /api/pricing
+ * Reset pricing to defaults
+ * Query params: ?provider=xxx&model=yyy (optional)
+ */
+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) {
+      // Reset specific model
+      await resetPricing(provider, model);
+    } else if (provider) {
+      // Reset entire provider
+      await resetPricing(provider);
+    } else {
+      // Reset all pricing
+      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 }
+    );
+  }
+}
+
+/**
+ * GET /api/pricing/defaults
+ * Get default pricing configuration
+ */
+export async function GET_DEFAULTS() {
+  try {
+    const defaultPricing = getDefaultPricing();
+    return NextResponse.json(defaultPricing);
+  } catch (error) {
+    console.error("Error fetching default pricing:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch default pricing" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,93 @@
+import { NextResponse } from "next/server";
+import { deleteProviderConnectionsByProvider, deleteProviderNode, getProviderConnections, getProviderNodeById, updateProviderConnection, updateProviderNode } from "@/models";
+
+// PUT /api/provider-nodes/[id] - Update provider node
+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 });
+    }
+
+    // Only validate apiType for OpenAI Compatible nodes
+    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();
+    
+    // Sanitize Base URL for Anthropic Compatible
+    if (node.type === "anthropic-compatible") {
+      sanitizedBaseUrl = sanitizedBaseUrl.replace(/\/$/, "");
+      if (sanitizedBaseUrl.endsWith("/messages")) {
+        sanitizedBaseUrl = sanitizedBaseUrl.slice(0, -9); // remove /messages
+      }
+    }
+
+    const updates = {
+      name: name.trim(),
+      prefix: prefix.trim(),
+      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: prefix.trim(),
+          apiType: node.type === "openai-compatible" ? apiType : undefined,
+          baseUrl: sanitizedBaseUrl,
+          nodeName: updated.name,
+        }
+      })
+    )));
+
+    return NextResponse.json({ node: updated });
+  } catch (error) {
+    console.log("Error updating provider node:", error);
+    return NextResponse.json({ error: "Failed to update provider node" }, { status: 500 });
+  }
+}
+
+// DELETE /api/provider-nodes/[id] - Delete provider node and its connections
+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/app/api/provider-nodes/route.js

@@ -0,0 +1,83 @@
+import { NextResponse } from "next/server";
+import { createProviderNode, getProviderNodes } from "@/models";
+import { OPENAI_COMPATIBLE_PREFIX, ANTHROPIC_COMPATIBLE_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",
+};
+
+// GET /api/provider-nodes - List all provider nodes
+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 });
+  }
+}
+
+// POST /api/provider-nodes - Create provider node
+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 });
+    }
+
+    // Determine type
+    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: prefix.trim(),
+        apiType,
+        baseUrl: (baseUrl || OPENAI_COMPATIBLE_DEFAULTS.baseUrl).trim(),
+        name: name.trim(),
+      });
+      return NextResponse.json({ node }, { status: 201 });
+    }
+
+    if (nodeType === "anthropic-compatible") {
+      // Sanitize Base URL: remove trailing slash, and remove trailing /messages if user added it
+      // This prevents double-appending /messages at runtime
+      let sanitizedBaseUrl = (baseUrl || ANTHROPIC_COMPATIBLE_DEFAULTS.baseUrl).trim().replace(/\/$/, "");
+      if (sanitizedBaseUrl.endsWith("/messages")) {
+        sanitizedBaseUrl = sanitizedBaseUrl.slice(0, -9); // remove /messages
+      }
+
+      const node = await createProviderNode({
+        id: `${ANTHROPIC_COMPATIBLE_PREFIX}${generateId()}`,
+        type: "anthropic-compatible",
+        prefix: prefix.trim(),
+        baseUrl: sanitizedBaseUrl,
+        name: name.trim(),
+      });
+      return NextResponse.json({ node }, { status: 201 });
+    }
+
+    return NextResponse.json({ error: "Invalid provider node type" }, { status: 400 });
+  } catch (error) {
+    console.log("Error creating provider node:", error);
+    return NextResponse.json({ error: "Failed to create provider node" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,171 @@
+import { NextResponse } from "next/server";
+
+// Fetch with timeout wrapper
+const fetchWithTimeout = (url, options, timeout = 10000) => {
+  return Promise.race([
+    fetch(url, options),
+    new Promise((_, reject) => 
+      setTimeout(() => reject(new Error("Request timeout")), timeout)
+    )
+  ]);
+};
+
+// Validate URL format
+const isValidUrl = (url) => {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// Parse error details for user-friendly messages
+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";
+};
+
+// Get status-specific error message for /models endpoint
+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})`;
+};
+
+// Get status-specific error message for /chat/completions endpoint
+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})`;
+};
+
+// POST /api/provider-nodes/validate - Validate API key against base URL
+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 });
+    }
+
+    // Validate URL format
+    if (!isValidUrl(baseUrl)) {
+      return NextResponse.json({ error: "Invalid URL format" }, { status: 400 });
+    }
+
+    // Anthropic Compatible Validation
+    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 });
+
+      // Auth errors - no point trying chat fallback
+      if (res.status === 401 || res.status === 403) {
+        return NextResponse.json({ valid: false, error: "API key unauthorized" });
+      }
+
+      // Fallback: try chat/completions if modelId provided
+      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) });
+    }
+
+    // OpenAI Compatible Validation (Default)
+    const modelsUrl = `${baseUrl.replace(/\/$/, "")}/models`;
+    const res = await fetchWithTimeout(modelsUrl, {
+      headers: { "Authorization": `Bearer ${apiKey}` },
+    });
+
+    if (res.ok) return NextResponse.json({ valid: true });
+
+    // Auth errors - no point trying chat fallback
+    if (res.status === 401 || res.status === 403) {
+      return NextResponse.json({ valid: false, error: "API key unauthorized" });
+    }
+
+    // Fallback: try chat/completions if modelId provided
+    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 });
+  }
+}