swayrouter 1.0.0

package/src/routes/api/oauth/cursor/auto-import/route.js

@@ -0,0 +1,250 @@
+import { NextResponse } from "next/server";
+import { access, constants } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const CURSOR_IMPORT_ERROR = publicError("oauth", "Unable to inspect Cursor credentials");
+
+const execFileAsync = promisify(execFile);
+
+const ACCESS_TOKEN_KEYS = ["cursorAuth/accessToken", "cursorAuth/token"];
+const MACHINE_ID_KEYS = [
+  "storage.serviceMachineId",
+  "storage.machineId",
+  "telemetry.machineId",
+];
+
+function getCandidatePaths(platform) {
+  const home = homedir();
+
+  if (platform === "darwin") {
+    return [
+      join(
+        home,
+        "Library/Application Support/Cursor/User/globalStorage/state.vscdb",
+      ),
+      join(
+        home,
+        "Library/Application Support/Cursor - Insiders/User/globalStorage/state.vscdb",
+      ),
+    ];
+  }
+
+  if (platform === "win32") {
+    const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+    const localAppData =
+      process.env.LOCALAPPDATA || join(home, "AppData", "Local");
+    return [
+      join(appData, "Cursor", "User", "globalStorage", "state.vscdb"),
+      join(
+        appData,
+        "Cursor - Insiders",
+        "User",
+        "globalStorage",
+        "state.vscdb",
+      ),
+      join(localAppData, "Cursor", "User", "globalStorage", "state.vscdb"),
+      join(
+        localAppData,
+        "Programs",
+        "Cursor",
+        "User",
+        "globalStorage",
+        "state.vscdb",
+      ),
+    ];
+  }
+
+  return [
+    join(home, ".config/Cursor/User/globalStorage/state.vscdb"),
+    join(home, ".config/cursor/User/globalStorage/state.vscdb"),
+  ];
+}
+
+const normalize = (value) => {
+  if (typeof value !== "string") return value;
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "string" ? parsed : value;
+  } catch {
+    return value;
+  }
+};
+
+function readTokenRows(db) {
+  const query = (key) => {
+    const row = db.prepare("SELECT value FROM itemTable WHERE key=? LIMIT 1").get(key);
+    return row?.value || null;
+  };
+
+  let accessToken = null;
+  for (const key of ACCESS_TOKEN_KEYS) {
+    const raw = query(key);
+    if (raw) { accessToken = normalize(raw); break; }
+  }
+
+  let machineId = null;
+  for (const key of MACHINE_ID_KEYS) {
+    const raw = query(key);
+    if (raw) { machineId = normalize(raw); break; }
+  }
+
+  return { accessToken, machineId };
+}
+
+async function extractTokensViaBunSqlite(dbPath) {
+  const { Database } = await import("bun:sqlite");
+  const db = new Database(dbPath, { readonly: true, create: false });
+
+  try {
+    return readTokenRows(db);
+  } finally {
+    db.close();
+  }
+}
+
+function extractTokensViaBetterSqlite(dbPath) {
+  const Database = require("better-sqlite3");
+  const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+
+  try {
+    return readTokenRows(db);
+  } finally {
+    db.close();
+  }
+}
+
+async function extractTokensViaCLI(dbPath) {
+  const normalize = (raw) => {
+    const value = raw.trim();
+    try {
+      const parsed = JSON.parse(value);
+      return typeof parsed === "string" ? parsed : value;
+    } catch {
+      return value;
+    }
+  };
+
+  const query = async (sql) => {
+    const { stdout } = await execFileAsync("sqlite3", [dbPath, sql], {
+      timeout: 10000,
+    });
+    return stdout.trim();
+  };
+
+  let accessToken = null;
+  for (const key of ACCESS_TOKEN_KEYS) {
+    try {
+      const raw = await query(
+        `SELECT value FROM itemTable WHERE key='${key}' LIMIT 1`,
+      );
+      if (raw) {
+        accessToken = normalize(raw);
+        break;
+      }
+    } catch {
+
+    }
+  }
+
+  let machineId = null;
+  for (const key of MACHINE_ID_KEYS) {
+    try {
+      const raw = await query(
+        `SELECT value FROM itemTable WHERE key='${key}' LIMIT 1`,
+      );
+      if (raw) {
+        machineId = normalize(raw);
+        break;
+      }
+    } catch {
+
+    }
+  }
+
+  return { accessToken, machineId };
+}
+
+export async function GET() {
+  try {
+    const platform = process.platform;
+    const candidates = getCandidatePaths(platform);
+
+    let dbPath = null;
+    for (const candidate of candidates) {
+      try {
+        await access(candidate, constants.R_OK);
+        dbPath = candidate;
+        break;
+      } catch {
+
+      }
+    }
+
+    if (!dbPath) {
+      return NextResponse.json({
+        found: false,
+        error: `Cursor database not found. Checked locations:\n${candidates.join("\n")}\n\nMake sure Cursor IDE is installed and opened at least once.`,
+      });
+    }
+
+    if (platform === "linux") {
+      let cursorInstalled = false;
+      try {
+        await execFileAsync("which", ["cursor"], { timeout: 5000 });
+        cursorInstalled = true;
+      } catch {
+        try {
+          const desktopFile = join(homedir(), ".local/share/applications/cursor.desktop");
+          await access(desktopFile, constants.R_OK);
+          cursorInstalled = true;
+        } catch {                 }
+      }
+      if (!cursorInstalled) {
+        return NextResponse.json({
+          found: false,
+          error: "Cursor config files found but Cursor IDE does not appear to be installed. Skipping auto-import.",
+        });
+      }
+    }
+
+    try {
+      const tokens = process.versions.bun
+        ? await extractTokensViaBunSqlite(dbPath)
+        : extractTokensViaBetterSqlite(dbPath);
+      if (tokens.accessToken && tokens.machineId) {
+        return NextResponse.json({
+          found: true,
+          accessToken: tokens.accessToken,
+          machineId: tokens.machineId,
+        });
+      }
+    } catch {
+
+    }
+
+    try {
+      const tokens = await extractTokensViaCLI(dbPath);
+      if (tokens.accessToken && tokens.machineId) {
+        return NextResponse.json({
+          found: true,
+          accessToken: tokens.accessToken,
+          machineId: tokens.machineId,
+        });
+      }
+    } catch {
+
+    }
+
+    return NextResponse.json({ found: false, windowsManual: true, dbPath });
+  } catch (error) {
+    logRouteError("CursorAutoImport", error);
+    return NextResponse.json(
+      { found: false, error: CURSOR_IMPORT_ERROR },
+      { status: 500 },
+    );
+  }
+}

package/src/routes/api/oauth/cursor/import/route.js

@@ -0,0 +1,86 @@
+import { NextResponse } from "next/server";
+import { CursorService } from "@/lib/oauth/services/cursor";
+import { createProviderConnection } from "@/models";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+export async function POST(request) {
+  try {
+    const { accessToken, machineId } = await request.json();
+
+    if (!accessToken || typeof accessToken !== "string") {
+      return NextResponse.json(
+        { error: "Access token is required" },
+        { status: 400 }
+      );
+    }
+
+    if (!machineId || typeof machineId !== "string") {
+      return NextResponse.json(
+        { error: "Machine ID is required" },
+        { status: 400 }
+      );
+    }
+
+    const cursorService = new CursorService();
+
+    const tokenData = await cursorService.validateImportToken(
+      accessToken.trim(),
+      machineId.trim()
+    );
+
+    const userInfo = cursorService.extractUserInfo(tokenData.accessToken);
+
+    const connection = await createProviderConnection({
+      provider: "cursor",
+      authType: "oauth",
+      accessToken: tokenData.accessToken,
+      refreshToken: null,
+      expiresAt: new Date(Date.now() + tokenData.expiresIn * 1000).toISOString(),
+      email: userInfo?.email || null,
+      providerSpecificData: {
+        machineId: tokenData.machineId,
+        authMethod: "imported",
+        provider: "Imported",
+        userId: userInfo?.userId,
+      },
+      testStatus: "active",
+    });
+
+    return NextResponse.json({
+      success: true,
+      connection: {
+        id: connection.id,
+        provider: connection.provider,
+        email: connection.email,
+      },
+    });
+  } catch (error) {
+    logRouteError("OAuth][CursorImport", error);
+    return NextResponse.json({ error: publicError("oauth", "Cursor token import failed") }, { status: 500 });
+  }
+}
+
+export async function GET() {
+  const cursorService = new CursorService();
+  const instructions = cursorService.getTokenStorageInstructions();
+
+  return NextResponse.json({
+    provider: "cursor",
+    method: "import_token",
+    instructions,
+    requiredFields: [
+      {
+        name: "accessToken",
+        label: "Access Token",
+        description: "From cursorAuth/accessToken in state.vscdb",
+        type: "textarea",
+      },
+      {
+        name: "machineId",
+        label: "Machine ID",
+        description: "From storage.serviceMachineId in state.vscdb",
+        type: "text",
+      },
+    ],
+  });
+}

package/src/routes/api/oauth/kiro/api-key/route.js

@@ -0,0 +1,60 @@
+import { NextResponse } from "next/server";
+import { KiroService } from "@/lib/oauth/services/kiro";
+import { createProviderConnection } from "@/models";
+import { logRouteError } from "@/lib/errors/publicError";
+
+export async function POST(request) {
+  try {
+    const { apiKey, region, name, autoName } = await request.json();
+
+    if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
+      return NextResponse.json(
+        { error: "API key is required" },
+        { status: 400 }
+      );
+    }
+
+    const kiroService = new KiroService();
+
+    const credential = await kiroService.validateApiKey(
+      apiKey,
+      region || "us-east-1"
+    );
+
+    const email = kiroService.extractEmailFromJWT(credential.accessToken);
+
+    const connection = await createProviderConnection({
+      provider: "kiro",
+      authType: "api_key",
+      name: typeof name === "string" && name.trim() ? name.trim() : undefined,
+      autoName: autoName === true || !(typeof name === "string" && name.trim()),
+      accessToken: credential.accessToken,
+      refreshToken: null,
+      expiresAt: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString(),
+      email: email || null,
+      providerSpecificData: {
+        ...(credential.profileArn ? { profileArn: credential.profileArn } : {}),
+        region: credential.region,
+        authMethod: "api_key",
+        provider: "API Key",
+      },
+      testStatus: "active",
+    });
+
+    return NextResponse.json({
+      success: true,
+      connection: {
+        id: connection.id,
+        provider: connection.provider,
+        email: connection.email,
+      },
+    });
+  } catch (error) {
+    logRouteError("OAuth][KiroApiKey", error);
+
+    return NextResponse.json(
+      { error: "API key validation failed" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,120 @@
+import { NextResponse } from "next/server";
+import { readFile, readdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { logRouteError } from "@/lib/errors/publicError";
+
+export async function GET() {
+  try {
+    const cachePath = join(homedir(), ".aws/sso/cache");
+
+    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.",
+      });
+    }
+
+    let refreshToken = null;
+    let foundFile = null;
+    let tokenData = null;
+
+    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;
+          tokenData = data;
+        }
+      } catch (error) {
+
+      }
+    }
+
+    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);
+          if (data.refreshToken && data.refreshToken.startsWith("aorAAAAAG")) {
+            refreshToken = data.refreshToken;
+            foundFile = file;
+            tokenData = data;
+            break;
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+
+    if (!refreshToken) {
+      return NextResponse.json({
+        found: false,
+        error: "Kiro token not found in AWS SSO cache. Please login to Kiro IDE first.",
+      });
+    }
+
+    let clientId = null;
+    let clientSecret = null;
+    const region = tokenData?.region || null;
+    const authMethod = tokenData?.authMethod || null;
+
+    if (tokenData?.clientIdHash) {
+      const clientFile = `${tokenData.clientIdHash}.json`;
+      try {
+        const clientContent = await readFile(join(cachePath, clientFile), "utf-8");
+        const clientData = JSON.parse(clientContent);
+        if (clientData.clientId && clientData.clientSecret) {
+          clientId = clientData.clientId;
+          clientSecret = clientData.clientSecret;
+        }
+      } catch (error) {
+
+      }
+    }
+
+    let profileArn = null;
+    const kiroProfilePaths = [
+      join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "Kiro", "User", "globalStorage", "kiro.kiroagent", "profile.json"),
+      join(homedir(), ".config", "Kiro", "User", "globalStorage", "kiro.kiroagent", "profile.json"),
+    ];
+    for (const profilePath of kiroProfilePaths) {
+      try {
+        const profileContent = await readFile(profilePath, "utf-8");
+        const profileData = JSON.parse(profileContent);
+        if (profileData.arn) {
+
+          profileArn = profileData.arn.replace(/arn:aws:codewhisperer:[^:]+:/, "arn:aws:codewhisperer:us-east-1:");
+          break;
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+
+    return NextResponse.json({
+      found: true,
+      refreshToken,
+      source: foundFile,
+      clientId,
+      clientSecret,
+      region,
+      authMethod,
+      profileArn,
+    });
+  } catch (error) {
+    logRouteError("OAuth][KiroAutoImport", error);
+    return NextResponse.json(
+      { found: false, error: "Unable to inspect Kiro credentials" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,72 @@
+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", "Kiro token import failed");
+
+export async function POST(request) {
+  try {
+    const {
+      refreshToken,
+      clientId,
+      clientSecret,
+      region,
+      authMethod,
+      profileArn,
+      name,
+      autoName,
+    } = await request.json();
+
+    if (!refreshToken || typeof refreshToken !== "string") {
+      return NextResponse.json(
+        { error: "Refresh token is required" },
+        { status: 400 }
+      );
+    }
+
+    const kiroService = new KiroService();
+    const isIdc = !!(clientId && clientSecret);
+
+    const providerSpecificData = isIdc
+      ? { clientId, clientSecret, region: region || "us-east-1", authMethod: "idc" }
+      : {};
+
+    const tokenData = await kiroService.refreshToken(refreshToken.trim(), providerSpecificData);
+
+    const email = kiroService.extractEmailFromJWT(tokenData.accessToken);
+    const resolvedAuthMethod = isIdc ? "idc" : "imported";
+    const providerLabel = isIdc ? "Enterprise" : "Imported";
+    const resolvedProfileArn = profileArn || tokenData.profileArn || null;
+
+    const connection = await createProviderConnection({
+      provider: "kiro",
+      authType: "oauth",
+      name: typeof name === "string" && name.trim() ? name.trim() : undefined,
+      autoName: autoName === true || !(typeof name === "string" && name.trim()),
+      accessToken: tokenData.accessToken,
+      refreshToken: tokenData.refreshToken || refreshToken.trim(),
+      expiresAt: new Date(Date.now() + (tokenData.expiresIn || 3600) * 1000).toISOString(),
+      email: email || null,
+      providerSpecificData: {
+        profileArn: resolvedProfileArn,
+        authMethod: resolvedAuthMethod,
+        provider: providerLabel,
+        ...(isIdc ? { clientId, clientSecret, region: region || "us-east-1" } : {}),
+      },
+      testStatus: "active",
+    });
+
+    return NextResponse.json({
+      success: true,
+      connection: {
+        id: connection.id,
+        provider: connection.provider,
+        email: connection.email,
+      },
+    });
+  } catch (error) {
+    logRouteError("OAuth][KiroImport", error);
+    return NextResponse.json({ error: OAUTH_ERROR }, { status: 500 });
+  }
+}

package/src/routes/api/oauth/kiro/import-cli-proxy/route.js

@@ -0,0 +1,42 @@
+import { NextResponse } from "next/server";
+import { createProviderConnection } from "@/models";
+import { normalizeKiroExternalIdpAuth } from "@/lib/oauth/kiroExternalIdp";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const OAUTH_ERROR = publicError("oauth", "CLIProxyAPI import failed");
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const rawAuth = body?.cliProxyAuth ?? body?.auth ?? body?.json ?? body;
+    const tokenData = normalizeKiroExternalIdpAuth(rawAuth);
+
+    const connection = await createProviderConnection({
+      provider: "kiro",
+      authType: "oauth",
+      name: typeof body?.name === "string" && body.name.trim() ? body.name.trim() : undefined,
+      autoName: body?.autoName === true || !(typeof body?.name === "string" && body.name.trim()),
+      accessToken: tokenData.accessToken,
+      refreshToken: tokenData.refreshToken,
+      expiresAt: tokenData.expiresAt,
+      email: tokenData.email || null,
+      providerSpecificData: tokenData.providerSpecificData,
+      testStatus: "active",
+    });
+
+    return NextResponse.json({
+      success: true,
+      connection: {
+        id: connection.id,
+        provider: connection.provider,
+        email: connection.email,
+      },
+    });
+  } catch (error) {
+    logRouteError("OAuth][KiroCliProxyImport", error);
+    return NextResponse.json(
+      { error: OAUTH_ERROR },
+      { status: 400 }
+    );
+  }
+}

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

@@ -0,0 +1,40 @@
+import { NextResponse } from "next/server";
+import { generatePKCE } from "@/lib/oauth/utils/pkce";
+import { KiroService } from "@/lib/oauth/services/kiro";
+import { logRouteError, publicError } from "@/lib/errors/publicError";
+
+const OAUTH_ERROR = publicError("oauth", "Unable to start social sign-in");
+
+export async function GET(request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const provider = searchParams.get("provider");
+
+    if (!provider || !["google", "github"].includes(provider)) {
+      return NextResponse.json(
+        { error: "Invalid provider. Use 'google' or 'github'" },
+        { status: 400 }
+      );
+    }
+
+    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) {
+    logRouteError("OAuth][KiroSocialAuthorize", error);
+    return NextResponse.json({ error: OAUTH_ERROR }, { status: 500 });
+  }
+}