zevairouter 1.0.154 → 1.0.155

package/src/app/api/oauth/codebuddy-cn/quota-cookie/route.js

@@ -1,28 +0,0 @@
-import { NextResponse } from "next/server";
-
-export const dynamic = "force-dynamic";
-
-/**
- * CodeBuddy CN quota-cookie probe — STUB.
- *
- * The global CodeBuddy (codebuddy.ai) quota-cookie route probes
- * /billing/meter/get-user-resource with ProductCode "p_tcaca" and a set of
- * TCACA_code_* package codes. The CN edition (www.codebuddy.cn / copilot.tencent.com)
- * uses different Tencent product/package codes that are not yet documented.
- *
- * This stub returns a "not supported" response so the UI can gracefully hide
- * or disable the quota-cookie feature for CN connections until the codes are
- * identified.
- *
- * TODO: Populate with CN product codes after identifying the Tencent CN billing
- * endpoint and package codes (likely different ProductCode + PackageCodes).
- */
-export async function POST() {
-  return NextResponse.json(
-    {
-      supported: false,
-      error: "CodeBuddy CN quota tracking is not yet supported. The Tencent CN product/package codes need to be identified before quota probing can work.",
-    },
-    { status: 501 }
-  );
-}

package/src/app/api/oauth/codex/import-token/route.js

@@ -1,96 +0,0 @@
-import { NextResponse } from "next/server";
-import { createProviderConnection } from "@/models";
-import { extractCodexAccountInfo } from "@/lib/oauth/providers";
-
-/**
- * POST /api/oauth/codex/import-token
- * Import a ChatGPT access token (created from chatgpt.com settings)
- * as a provider connection, bypassing OAuth refresh flow.
- *
- * Body: { accessToken: string, name?: string }
- */
-export async function POST(request) {
-  try {
-    const { accessToken, name } = await request.json();
-
-    if (!accessToken || typeof accessToken !== "string") {
-      return NextResponse.json(
-        { error: "Access token is required" },
-        { status: 400 }
-      );
-    }
-
-    const token = accessToken.trim();
-
-    // Extract account info from the JWT (email, workspace, plan)
-    let email = null;
-    let providerSpecificData = { authMethod: "access_token" };
-
-    // Try decoding as JWT to extract email + workspace
-    try {
-      const parts = token.split(".");
-      if (parts.length === 3) {
-        const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
-        const missingPadding = (4 - (base64.length % 4)) % 4;
-        const padded = base64 + "=".repeat(missingPadding);
-        const payload = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
-
-        // Extract from OpenAI JWT structure
-        const auth = payload["https://api.openai.com/auth"] || {};
-        const profile = payload["https://api.openai.com/profile"] || {};
-        email = profile.email || payload.email || payload.preferred_username || null;
-
-        if (auth.chatgpt_account_id) {
-          providerSpecificData.chatgptAccountId = auth.chatgpt_account_id;
-        }
-        if (auth.chatgpt_plan_type) {
-          providerSpecificData.chatgptPlanType = auth.chatgpt_plan_type;
-        }
-
-        // Store expiry info from JWT if available
-        if (payload.exp) {
-          providerSpecificData.jwtExp = payload.exp;
-        }
-      }
-    } catch {
-      // Not a JWT or malformed — still allow import as raw token
-    }
-
-    // Also try extractCodexAccountInfo via id_token-style extraction
-    // (the access token itself may contain the same claims)
-    if (!email) {
-      const info = extractCodexAccountInfo(token);
-      if (info.email) email = info.email;
-      if (info.chatgptAccountId) providerSpecificData.chatgptAccountId = info.chatgptAccountId;
-      if (info.chatgptPlanType) providerSpecificData.chatgptPlanType = info.chatgptPlanType;
-    }
-
-    const connectionName = name || email || "ChatGPT Access Token";
-
-    // Save to database as access_token authType (no refresh token)
-    const connection = await createProviderConnection({
-      provider: "codex",
-      authType: "access_token",
-      accessToken: token,
-      name: connectionName,
-      email: email,
-      providerSpecificData,
-      testStatus: "active",
-    });
-
-    return NextResponse.json({
-      success: true,
-      connection: {
-        id: connection.id,
-        provider: connection.provider,
-        email: connection.email,
-        name: connection.name,
-        workspace: providerSpecificData.chatgptAccountId || null,
-        plan: providerSpecificData.chatgptPlanType || null,
-      },
-    });
-  } catch (error) {
-    console.log("Codex access token import error:", error);
-    return NextResponse.json({ error: error.message }, { status: 500 });
-  }
-}

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

@@ -1,257 +0,0 @@
-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";
-
-const execFileAsync = promisify(execFile);
-
-const ACCESS_TOKEN_KEYS = ["cursorAuth/accessToken", "cursorAuth/token"];
-const MACHINE_ID_KEYS = [
-  "storage.serviceMachineId",
-  "storage.machineId",
-  "telemetry.machineId",
-];
-
-/** Get candidate db paths by platform */
-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;
-  }
-};
-
-/**
- * Extract tokens via better-sqlite3 (bundled dependency).
- * This is the preferred strategy — no external CLI required.
- */
-function extractTokensViaBetterSqlite(dbPath) {
-  // Dynamic require so the route stays importable even if native bindings fail
-  const Database = require("better-sqlite3");
-  const db = new Database(dbPath, { readonly: true, fileMustExist: true });
-
-  const query = (key) => {
-    const row = db.prepare("SELECT value FROM itemTable WHERE key=? LIMIT 1").get(key);
-    return row?.value || null;
-  };
-
-  const normalize = (value) => {
-    if (typeof value !== "string") return value;
-    try {
-      const parsed = JSON.parse(value);
-      return typeof parsed === "string" ? parsed : value;
-    } catch {
-      return value;
-    }
-  };
-
-  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; }
-  }
-
-  db.close();
-  return { accessToken, machineId };
-}
-
-/**
- * Extract tokens via sqlite3 CLI.
- * Fallback when better-sqlite3 native bindings are unavailable.
- */
-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();
-  };
-
-  // Try each key in priority order
-  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 {
-      /* try next */
-    }
-  }
-
-  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 {
-      /* try next */
-    }
-  }
-
-  return { accessToken, machineId };
-}
-
-/**
- * GET /api/oauth/cursor/auto-import
- * Auto-detect and extract Cursor tokens from local SQLite database.
- * Strategy: better-sqlite3 → sqlite3 CLI → manual fallback
- */
-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 {
-        // Try next candidate
-      }
-    }
-
-    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.`,
-      });
-    }
-
-    // On Linux, verify Cursor is actually installed (not just leftover config)
-    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 { /* not found */ }
-      }
-      if (!cursorInstalled) {
-        return NextResponse.json({
-          found: false,
-          error: "Cursor config files found but Cursor IDE does not appear to be installed. Skipping auto-import.",
-        });
-      }
-    }
-
-    // Strategy 1: better-sqlite3 (bundled — no external tools required)
-    try {
-      const tokens = extractTokensViaBetterSqlite(dbPath);
-      if (tokens.accessToken && tokens.machineId) {
-        return NextResponse.json({
-          found: true,
-          accessToken: tokens.accessToken,
-          machineId: tokens.machineId,
-        });
-      }
-    } catch {
-      // Native bindings unavailable — try CLI fallback
-    }
-
-    // Strategy 2: sqlite3 CLI
-    try {
-      const tokens = await extractTokensViaCLI(dbPath);
-      if (tokens.accessToken && tokens.machineId) {
-        return NextResponse.json({
-          found: true,
-          accessToken: tokens.accessToken,
-          machineId: tokens.machineId,
-        });
-      }
-    } catch {
-      // sqlite3 CLI not available either
-    }
-
-    // Strategy 3: ask user to paste manually
-    return NextResponse.json({ found: false, windowsManual: true, dbPath });
-  } catch (error) {
-    console.log("Cursor auto-import error:", error);
-    return NextResponse.json(
-      { found: false, error: error.message },
-      { status: 500 },
-    );
-  }
-}

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

@@ -1,100 +0,0 @@
-import { NextResponse } from "next/server";
-import { CursorService } from "@/lib/oauth/services/cursor";
-import { createProviderConnection } from "@/models";
-
-/**
- * POST /api/oauth/cursor/import
- * Import and validate access token from Cursor IDE's local SQLite database
- *
- * Request body:
- * - accessToken: string - Access token from cursorAuth/accessToken
- * - machineId: string - Machine ID from storage.serviceMachineId
- */
-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();
-
-    // Validate token by making API call
-    const tokenData = await cursorService.validateImportToken(
-      accessToken.trim(),
-      machineId.trim()
-    );
-
-    // Try to extract user info from token
-    const userInfo = cursorService.extractUserInfo(tokenData.accessToken);
-
-    // Save to database
-    const connection = await createProviderConnection({
-      provider: "cursor",
-      authType: "oauth",
-      accessToken: tokenData.accessToken,
-      refreshToken: null, // Cursor doesn't have public refresh endpoint
-      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) {
-    console.log("Cursor import token error:", error);
-    return NextResponse.json({ error: error.message }, { status: 500 });
-  }
-}
-
-/**
- * GET /api/oauth/cursor/import
- * Get instructions for importing Cursor token
- */
-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/app/api/oauth/gitlab/pat/route.js

@@ -1,62 +0,0 @@
-import { NextResponse } from "next/server";
-import { createProviderConnection } from "@/models";
-
-const GITLAB_DEFAULT_BASE = "https://gitlab.com";
-
-/**
- * POST /api/oauth/gitlab/pat
- * Authenticate GitLab Duo with a Personal Access Token (PAT)
- */
-export async function POST(request) {
-  try {
-    let body;
-    try {
-      body = await request.json();
-    } catch {
-      return NextResponse.json({ error: "Invalid request body" }, { status: 400 });
-    }
-
-    const { token, baseUrl } = body;
-    if (!token?.trim()) {
-      return NextResponse.json({ error: "Personal Access Token is required" }, { status: 400 });
-    }
-
-    const base = (baseUrl?.trim() || GITLAB_DEFAULT_BASE).replace(/\/$/, "");
-
-    // Verify token by fetching current user
-    const userRes = await fetch(`${base}/api/v4/user`, {
-      headers: { "Private-Token": token.trim(), Accept: "application/json" },
-    });
-
-    if (!userRes.ok) {
-      const err = await userRes.text();
-      return NextResponse.json({ error: `GitLab token verification failed: ${err}` }, { status: 401 });
-    }
-
-    const user = await userRes.json();
-    const email = user.email || user.public_email || "";
-
-    await createProviderConnection({
-      provider: "gitlab",
-      authType: "oauth",
-      accessToken: token.trim(),
-      refreshToken: null,
-      expiresAt: null,
-      email,
-      displayName: user.name || user.username || email,
-      testStatus: "active",
-      providerSpecificData: {
-        username: user.username || "",
-        email,
-        name: user.name || "",
-        baseUrl: base,
-        authKind: "personal_access_token",
-      },
-    });
-
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.error("GitLab PAT auth error:", error);
-    return NextResponse.json({ error: error.message }, { status: 500 });
-  }
-}

package/src/app/api/oauth/iflow/cookie/route.js

@@ -1,137 +0,0 @@
-import { NextResponse } from "next/server";
-import { createProviderConnection } from "@/models";
-
-/**
- * iFlow Cookie-Based Authentication
- * POST /api/oauth/iflow/cookie
- * Body: { cookie: "BXAuth=xxx; ..." }
- */
-export async function POST(request) {
-  try {
-    const { cookie } = await request.json();
-
-    if (!cookie || typeof cookie !== "string") {
-      return NextResponse.json({ error: "Cookie is required" }, { status: 400 });
-    }
-
-    // Normalize cookie
-    const trimmed = cookie.trim();
-    if (!trimmed.includes("BXAuth=")) {
-      return NextResponse.json({ error: "Cookie must contain BXAuth field" }, { status: 400 });
-    }
-
-    let normalizedCookie = trimmed;
-    if (!normalizedCookie.endsWith(";")) {
-      normalizedCookie += ";";
-    }
-
-    // Step 1: GET API key info to get the name
-    const getResponse = await fetch("https://platform.iflow.cn/api/openapi/apikey", {
-      method: "GET",
-      headers: {
-        "Cookie": normalizedCookie,
-        "Accept": "application/json, text/plain, */*",
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
-        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
-        "Accept-Encoding": "gzip, deflate, br",
-        "Connection": "keep-alive",
-        "Sec-Fetch-Dest": "empty",
-        "Sec-Fetch-Mode": "cors",
-        "Sec-Fetch-Site": "same-origin",
-      },
-    });
-
-    if (!getResponse.ok) {
-      const errorText = await getResponse.text();
-      return NextResponse.json(
-        { error: `Failed to fetch API key info: ${errorText}` },
-        { status: getResponse.status }
-      );
-    }
-
-    const getResult = await getResponse.json();
-    if (!getResult.success) {
-      return NextResponse.json(
-        { error: `API key fetch failed: ${getResult.message}` },
-        { status: 400 }
-      );
-    }
-
-    const keyData = getResult.data;
-    if (!keyData.name) {
-      return NextResponse.json({ error: "Missing name in API key info" }, { status: 400 });
-    }
-
-    // Step 2: POST to refresh API key
-    const postResponse = await fetch("https://platform.iflow.cn/api/openapi/apikey", {
-      method: "POST",
-      headers: {
-        "Cookie": normalizedCookie,
-        "Content-Type": "application/json",
-        "Accept": "application/json, text/plain, */*",
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
-        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
-        "Accept-Encoding": "gzip, deflate, br",
-        "Connection": "keep-alive",
-        "Origin": "https://platform.iflow.cn",
-        "Referer": "https://platform.iflow.cn/",
-      },
-      body: JSON.stringify({ name: keyData.name }),
-    });
-
-    if (!postResponse.ok) {
-      const errorText = await postResponse.text();
-      return NextResponse.json(
-        { error: `Failed to refresh API key: ${errorText}` },
-        { status: postResponse.status }
-      );
-    }
-
-    const postResult = await postResponse.json();
-    if (!postResult.success) {
-      return NextResponse.json(
-        { error: `API key refresh failed: ${postResult.message}` },
-        { status: 400 }
-      );
-    }
-
-    const refreshedKey = postResult.data;
-    if (!refreshedKey.apiKey) {
-      return NextResponse.json({ error: "Missing API key in response" }, { status: 400 });
-    }
-
-    // Extract only BXAuth from cookie
-    const bxAuthMatch = normalizedCookie.match(/BXAuth=([^;]+)/);
-    const bxAuth = bxAuthMatch ? bxAuthMatch[1] : "";
-    const cookieToSave = bxAuth ? `BXAuth=${bxAuth};` : "";
-
-    // Save to database
-    const connection = await createProviderConnection({
-      provider: "iflow",
-      authType: "cookie",
-      name: refreshedKey.name || keyData.name,
-      email: refreshedKey.name || keyData.name,
-      apiKey: refreshedKey.apiKey,
-      providerSpecificData: {
-        cookie: cookieToSave,
-        expireTime: refreshedKey.expireTime,
-      },
-      testStatus: "active",
-      isActive: true,
-    });
-
-    return NextResponse.json({
-      success: true,
-      connection: {
-        id: connection.id,
-        provider: connection.provider,
-        email: connection.email,
-        apiKey: refreshedKey.apiKey.substring(0, 10) + "...", // masked
-        expireTime: refreshedKey.expireTime,
-      },
-    });
-  } catch (error) {
-    console.error("iFlow cookie auth error:", error);
-    return NextResponse.json({ error: error.message }, { status: 500 });
-  }
-}