wyxrouter 0.4.71

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

@@ -0,0 +1,85 @@
+import { NextResponse } from "next/server";
+import { readFile, readdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+
+/**
+ * GET /api/oauth/kiro/auto-import
+ * Auto-detect and extract Kiro refresh token from AWS SSO cache
+ */
+export async function GET() {
+  try {
+    const cachePath = join(homedir(), ".aws/sso/cache");
+
+    // Try to read cache directory
+    let files;
+    try {
+      files = await readdir(cachePath);
+    } catch (error) {
+      return NextResponse.json({
+        found: false,
+        error: "AWS SSO cache not found. Please login to Kiro IDE first.",
+      });
+    }
+
+    // Look for kiro-auth-token.json or any .json file with refreshToken
+    let refreshToken = null;
+    let foundFile = null;
+
+    // First try kiro-auth-token.json
+    const kiroTokenFile = "kiro-auth-token.json";
+    if (files.includes(kiroTokenFile)) {
+      try {
+        const content = await readFile(join(cachePath, kiroTokenFile), "utf-8");
+        const data = JSON.parse(content);
+        if (data.refreshToken && data.refreshToken.startsWith("aorAAAAAG")) {
+          refreshToken = data.refreshToken;
+          foundFile = kiroTokenFile;
+        }
+      } catch (error) {
+        // Continue to search other files
+      }
+    }
+
+    // If not found, search all .json files
+    if (!refreshToken) {
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+
+        try {
+          const content = await readFile(join(cachePath, file), "utf-8");
+          const data = JSON.parse(content);
+
+          // Look for Kiro refresh token (starts with aorAAAAAG)
+          if (data.refreshToken && data.refreshToken.startsWith("aorAAAAAG")) {
+            refreshToken = data.refreshToken;
+            foundFile = file;
+            break;
+          }
+        } catch (error) {
+          // Skip invalid JSON files
+          continue;
+        }
+      }
+    }
+
+    if (!refreshToken) {
+      return NextResponse.json({
+        found: false,
+        error: "Kiro token not found in AWS SSO cache. Please login to Kiro IDE first.",
+      });
+    }
+
+    return NextResponse.json({
+      found: true,
+      refreshToken,
+      source: foundFile,
+    });
+  } catch (error) {
+    console.log("Kiro auto-import error:", error);
+    return NextResponse.json(
+      { found: false, error: error.message },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/oauth/kiro/bulk-import/[jobId]/cancel/route.js

@@ -0,0 +1,18 @@
+import { NextResponse } from "next/server";
+import { getKiroBulkImportManager } from "@/lib/oauth/services/kiroBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(_request, { params }) {
+  const manager = getKiroBulkImportManager();
+  const job = manager.cancelJob(params.jobId);
+
+  if (!job) {
+    return NextResponse.json({ error: "Bulk import job not found" }, { status: 404 });
+  }
+
+  return NextResponse.json({
+    success: true,
+    job,
+  });
+}

package/src/app/api/oauth/kiro/bulk-import/[jobId]/manual/[workerId]/route.js

@@ -0,0 +1,29 @@
+import { NextResponse } from "next/server";
+import { getKiroBulkImportManager } from "@/lib/oauth/services/kiroBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(_request, { params }) {
+  const manager = getKiroBulkImportManager();
+  const result = await manager.openManualSession(params.jobId, params.workerId);
+
+  if (!result) {
+    return NextResponse.json({ error: "Bulk import job not found" }, { status: 404 });
+  }
+
+  if (!result.ok) {
+    return NextResponse.json(
+      {
+        error: result.error || "Manual session not found for this worker",
+        job: result.job,
+      },
+      { status: 404 }
+    );
+  }
+
+  return NextResponse.json({
+    success: true,
+    job: result.job,
+    account: result.account,
+  });
+}

package/src/app/api/oauth/kiro/bulk-import/[jobId]/route.js

@@ -0,0 +1,22 @@
+import { NextResponse } from "next/server";
+import { buildLookupResponse, getKiroBulkImportManager } from "@/lib/oauth/services/kiroBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(_request, { params }) {
+  const manager = getKiroBulkImportManager();
+  const job = await manager.getJobWithPreview(params.jobId);
+
+  if (!job) {
+    return NextResponse.json({
+      success: false,
+      ...buildLookupResponse(null, { stale: true }),
+      error: "Bulk import job not found",
+    }, { status: 404 });
+  }
+
+  return NextResponse.json({
+    success: true,
+    ...buildLookupResponse(job),
+  });
+}

package/src/app/api/oauth/kiro/bulk-import/latest/route.js

@@ -0,0 +1,25 @@
+import { NextResponse } from "next/server";
+import { buildLookupResponse, getKiroBulkImportManager } from "@/lib/oauth/services/kiroBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request) {
+  const manager = getKiroBulkImportManager();
+  const searchParams = new URL(request.url).searchParams;
+  const scope = searchParams.get("scope");
+  const includeRecentTerminal = scope === "recent" || scope === "recoverable" || scope === "all";
+  const job = await manager.getLatestJobWithPreview({ includeRecentTerminal });
+
+  if (!job) {
+    return NextResponse.json({
+      success: false,
+      ...buildLookupResponse(null),
+      error: "Bulk import job not found",
+    }, { status: 404 });
+  }
+
+  return NextResponse.json({
+    success: true,
+    ...buildLookupResponse(job),
+  });
+}

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

@@ -0,0 +1,49 @@
+import { NextResponse } from "next/server";
+import { getKiroBulkImportManager, parseKiroBulkAccounts } from "@/lib/oauth/services/kiroBulkImportManager";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const accounts = Array.isArray(body?.accounts) ? body.accounts : [];
+    const { parsed, invalidLines } = parseKiroBulkAccounts(accounts);
+
+    if (!parsed.length) {
+      return NextResponse.json(
+        { error: "At least one account entry is required" },
+        { status: 400 }
+      );
+    }
+
+    if (invalidLines.length > 0) {
+      return NextResponse.json(
+        {
+          error: "Invalid account format. Use one account per line: gmail@example.com|password",
+          invalidLines,
+        },
+        { status: 400 }
+      );
+    }
+
+    const manager = getKiroBulkImportManager();
+    const job = await manager.startJob({
+      accounts,
+      concurrency: body?.concurrency,
+    });
+
+    return NextResponse.json({
+      success: true,
+      job,
+    });
+  } catch (error) {
+    const status = Array.isArray(error?.invalidLines) ? 400 : 500;
+    return NextResponse.json(
+      {
+        error: error?.error || error?.message || "Failed to start Kiro bulk import",
+        ...(Array.isArray(error?.invalidLines) ? { invalidLines: error.invalidLines } : {}),
+      },
+      { status }
+    );
+  }
+}

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

@@ -0,0 +1,110 @@
+import { NextResponse } from "next/server";
+import { getKiroBulkImportManager, parseKiroBulkAccounts } from "@/lib/oauth/services/kiroBulkImportManager";
+import { validateAndSaveKiroImportedToken } from "@/lib/oauth/services/kiroConnections";
+
+/**
+ * POST /api/oauth/kiro/import
+ * Import and validate Kiro credentials.
+ * Supported today:
+ * - single/bulk refresh token import
+ *
+ * Reserved for future work:
+ * - bulk account credential import (email|password)
+ */
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const mode = body?.mode === "account" ? "account" : "token";
+
+    if (mode === "account") {
+      const accounts = Array.isArray(body?.accounts) ? body.accounts : [];
+      const { parsed, invalidLines } = parseKiroBulkAccounts(accounts);
+      if (!parsed.length) {
+        return NextResponse.json(
+          { error: "At least one account entry is required" },
+          { status: 400 }
+        );
+      }
+
+      if (invalidLines.length > 0) {
+        return NextResponse.json(
+          {
+            error: "Invalid account format. Use one account per line: gmail@example.com|password",
+            invalidLines,
+          },
+          { status: 400 }
+        );
+      }
+
+      const manager = getKiroBulkImportManager();
+      const job = manager.startJob({
+        accounts,
+        concurrency: body?.concurrency,
+      });
+
+      return NextResponse.json({
+        success: true,
+        job,
+      });
+    }
+
+    const singleRefreshToken = typeof body?.refreshToken === "string"
+      ? body.refreshToken.trim()
+      : "";
+    const bulkRefreshTokens = Array.isArray(body?.refreshTokens)
+      ? body.refreshTokens.map((token) => String(token || "").trim()).filter(Boolean)
+      : [];
+    const refreshTokens = bulkRefreshTokens.length > 0
+      ? bulkRefreshTokens
+      : (singleRefreshToken ? [singleRefreshToken] : []);
+
+    if (!refreshTokens.length) {
+      return NextResponse.json(
+        { error: "Refresh token is required" },
+        { status: 400 }
+      );
+    }
+
+    const importedConnections = [];
+    const failed = [];
+
+    for (let index = 0; index < refreshTokens.length; index += 1) {
+      const refreshToken = refreshTokens[index];
+
+      try {
+        const { connection } = await validateAndSaveKiroImportedToken(refreshToken);
+        importedConnections.push(connection);
+      } catch (error) {
+        failed.push({
+          line: bulkRefreshTokens.length > 0 ? index + 1 : 1,
+          error: error.message,
+        });
+      }
+    }
+
+    if (!importedConnections.length) {
+      return NextResponse.json(
+        { error: failed[0]?.error || "Import failed", failed },
+        { status: 400 }
+      );
+    }
+
+    if (bulkRefreshTokens.length > 0) {
+      return NextResponse.json({
+        success: true,
+        imported: importedConnections.length,
+        failed: failed.length,
+        connections: importedConnections,
+        failures: failed,
+      });
+    }
+
+    return NextResponse.json({
+      success: true,
+      connection: importedConnections[0],
+    });
+  } 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,27 @@
+import { NextResponse } from "next/server";
+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 }
+      );
+    }
+
+    const kiroService = new KiroService();
+    return NextResponse.json(kiroService.createSocialAuthorization(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,41 @@
+import { NextResponse } from "next/server";
+import { exchangeAndSaveKiroSocialConnection } from "@/lib/oauth/services/kiroConnections";
+
+/**
+ * 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 { connection } = await exchangeAndSaveKiroSocialConnection({
+      code,
+      codeVerifier,
+      provider,
+    });
+
+    return NextResponse.json({
+      success: true,
+      connection,
+    });
+  } 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,101 @@
+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
+      }
+    }
+
+    // Sanitize Base URL for Custom Embedding (strip trailing slash and /embeddings)
+    if (node.type === "custom-embedding") {
+      sanitizedBaseUrl = sanitizedBaseUrl.replace(/\/$/, "");
+      if (sanitizedBaseUrl.endsWith("/embeddings")) {
+        sanitizedBaseUrl = sanitizedBaseUrl.slice(0, -"/embeddings".length);
+      }
+    }
+
+    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 });
+  }
+}