swayrouter 1.0.0

package/src/lib/oauth/providerHelpers.js

@@ -0,0 +1,90 @@
+const BASE64_BLOCK_SIZE = 4;
+
+function decodeBase64Json(segment) {
+  const normalized = segment.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = (BASE64_BLOCK_SIZE - (normalized.length % BASE64_BLOCK_SIZE)) % BASE64_BLOCK_SIZE;
+  return JSON.parse(Buffer.from(`${normalized}${"=".repeat(padding)}`, "base64").toString("utf8"));
+}
+
+function validateXaiOAuthEndpoint(rawUrl, field) {
+  const value = String(rawUrl || "").trim();
+  if (!value) throw new Error(`xai discovery ${field} is empty`);
+  let parsed;
+  try { parsed = new URL(value); } catch (err) {
+    throw new Error(`xai discovery ${field} is invalid: ${err.message}`);
+  }
+  if (parsed.protocol !== "https:") throw new Error(`xai discovery ${field} must use https: ${value}`);
+  const host = parsed.hostname.toLowerCase().trim();
+  if (host !== "x.ai" && !host.endsWith(".x.ai")) {
+    throw new Error(`xai discovery ${field} host ${host} is not on x.ai`);
+  }
+  return value;
+}
+
+function decodeXaiIdTokenEmail(idToken) {
+  if (!idToken || typeof idToken !== "string") return undefined;
+  const parts = idToken.split(".");
+  if (parts.length !== 3) return undefined;
+  try {
+    const payload = decodeBase64Json(parts[1]);
+    return payload.email || payload.preferred_username || payload.sub || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function decodeJwtPayload(jwt) {
+  try {
+    if (!jwt || typeof jwt !== "string") return null;
+    const parts = jwt.split(".");
+    if (parts.length !== 3) return null;
+    return decodeBase64Json(parts[1]);
+  } catch {
+    return null;
+  }
+}
+
+function extractEmailFromAccessToken(accessToken) {
+  const payload = decodeJwtPayload(accessToken);
+  if (!payload) return undefined;
+  return payload.email || payload.preferred_username || payload.sub || undefined;
+}
+
+export async function fetchKiroProfileArn(accessToken) {
+  if (!accessToken) return null;
+  try {
+    const response = await fetch("https://codewhisperer.us-east-1.amazonaws.com/ListAvailableProfiles", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${accessToken}`,
+      },
+      body: JSON.stringify({ maxResults: 10 }),
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.profiles?.find((p) => p.arn?.trim())?.arn?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export function extractCodexAccountInfo(idToken) {
+  const payload = decodeJwtPayload(idToken);
+  if (!payload) return {};
+  const chatgpt = payload["https://api.openai.com/auth"] || {};
+  return {
+    email: payload.email,
+    chatgptAccountId: chatgpt.chatgpt_account_id || payload.account_id,
+    chatgptPlanType: chatgpt.chatgpt_plan_type || payload.plan_type,
+  };
+}
+
+export {
+  BASE64_BLOCK_SIZE,
+  validateXaiOAuthEndpoint,
+  decodeXaiIdTokenEmail,
+  decodeJwtPayload,
+  extractEmailFromAccessToken,
+};

package/src/lib/oauth/providers/_shared.js

@@ -0,0 +1,12 @@
+export function extractJsonPath(root, paths) {
+  for (const path of paths) {
+    let cur = root;
+    for (const key of path) {
+      if (cur == null || typeof cur !== "object") { cur = undefined; break; }
+      cur = cur[key];
+    }
+    if (typeof cur === "string" && cur.trim()) return cur.trim();
+    if (typeof cur === "number") return String(cur);
+  }
+  return null;
+}

package/src/lib/oauth/providers/antigravity.js

@@ -0,0 +1,126 @@
+import { ANTIGRAVITY_CONFIG, getOAuthClientMetadata } from "../constants/oauth.js";
+
+const antigravity = {
+  config: ANTIGRAVITY_CONFIG,
+  flowType: "authorization_code",
+  buildAuthUrl: (config, redirectUri, state) => {
+    if (!config.clientId || !config.clientSecret) {
+      throw new Error("Antigravity OAuth client is not configured");
+    }
+
+    const params = new URLSearchParams({
+      client_id: config.clientId,
+      response_type: "code",
+      redirect_uri: redirectUri,
+      scope: config.scopes.join(" "),
+      state: state,
+      access_type: "offline",
+      prompt: "consent",
+    });
+    return `${config.authorizeUrl}?${params.toString()}`;
+  },
+  exchangeToken: async (config, code, redirectUri) => {
+    if (!config.clientId || !config.clientSecret) {
+      throw new Error("Antigravity OAuth client is not configured");
+    }
+
+    const body = new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      code: code,
+      redirect_uri: redirectUri,
+    });
+
+    const response = await fetch(config.tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+      },
+      body,
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Token exchange failed: ${error}`);
+    }
+
+    return await response.json();
+  },
+  postExchange: async (tokens) => {
+    const loadHeaders = {
+      "Authorization": `Bearer ${tokens.access_token}`,
+      "Content-Type": "application/json",
+      "User-Agent": ANTIGRAVITY_CONFIG.loadCodeAssistUserAgent,
+      "x-request-source": "local",
+    };
+    const metadata = getOAuthClientMetadata();
+
+    const userInfoRes = await fetch(`${ANTIGRAVITY_CONFIG.userInfoUrl}?alt=json`, {
+      headers: {
+        Authorization: `Bearer ${tokens.access_token}`,
+        "x-request-source": "local",
+      },
+    });
+    const userInfo = userInfoRes.ok ? await userInfoRes.json() : {};
+
+    let projectId = "";
+    let tierId = "legacy-tier";
+    try {
+      const loadRes = await fetch(ANTIGRAVITY_CONFIG.loadCodeAssistEndpoint, {
+        method: "POST",
+        headers: loadHeaders,
+        body: JSON.stringify({ metadata }),
+      });
+      if (loadRes.ok) {
+        const data = await loadRes.json();
+        projectId = data.cloudaicompanionProject?.id || data.cloudaicompanionProject || "";
+        if (Array.isArray(data.allowedTiers)) {
+          for (const tier of data.allowedTiers) {
+            if (tier.isDefault && tier.id) {
+              tierId = tier.id.trim();
+              break;
+            }
+          }
+        }
+      }
+    } catch (e) {
+      console.log("Failed to load code assist:", e);
+    }
+
+    if (projectId) {
+      const doOnboard = async () => {
+        for (let i = 0; i < 10; i++) {
+          try {
+            const onboardRes = await fetch(ANTIGRAVITY_CONFIG.onboardUserEndpoint, {
+              method: "POST",
+              headers: loadHeaders,
+              body: JSON.stringify({ tierId, metadata }),
+            });
+            if (onboardRes.ok) {
+              const result = await onboardRes.json();
+              if (result.done === true) break;
+            }
+          } catch (e) {
+            break;
+          }
+          await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+      };
+      doOnboard().catch(() => {});
+    }
+
+    return { userInfo, projectId };
+  },
+  mapTokens: (tokens, extra) => ({
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiresIn: tokens.expires_in,
+    scope: tokens.scope,
+    email: extra?.userInfo?.email,
+    projectId: extra?.projectId,
+  }),
+};
+
+export default antigravity;

package/src/lib/oauth/providers/claude.js

@@ -0,0 +1,60 @@
+import { CLAUDE_CONFIG } from "../constants/oauth.js";
+
+const claude = {
+  config: CLAUDE_CONFIG,
+  flowType: "authorization_code_pkce",
+  buildAuthUrl: (config, redirectUri, state, codeChallenge) => {
+    const params = new URLSearchParams({
+      code: "true",
+      client_id: config.clientId,
+      response_type: "code",
+      redirect_uri: redirectUri,
+      scope: config.scopes.join(" "),
+      code_challenge: codeChallenge,
+      code_challenge_method: config.codeChallengeMethod,
+      state: state,
+    });
+    return `${config.authorizeUrl}?${params.toString()}`;
+  },
+  exchangeToken: async (config, code, redirectUri, codeVerifier, state) => {
+
+    let authCode = code;
+    let codeState = "";
+    if (authCode.includes("#")) {
+      const parts = authCode.split("#");
+      authCode = parts[0];
+      codeState = parts[1] || "";
+    }
+
+    const response = await fetch(config.tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: JSON.stringify({
+        code: authCode,
+        state: codeState || state,
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        redirect_uri: redirectUri,
+        code_verifier: codeVerifier,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Token exchange failed: ${error}`);
+    }
+
+    return await response.json();
+  },
+  mapTokens: (tokens) => ({
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiresIn: tokens.expires_in,
+    scope: tokens.scope,
+  }),
+};
+
+export default claude;

package/src/lib/oauth/providers/cline.js

@@ -0,0 +1,62 @@
+import { CLINE_CONFIG } from "../constants/oauth.js";
+
+const cline = {
+  config: CLINE_CONFIG,
+  flowType: "authorization_code",
+  buildAuthUrl: (config, redirectUri) => {
+    const params = new URLSearchParams({
+      client_type: "extension",
+      callback_url: redirectUri,
+      redirect_uri: redirectUri,
+    });
+    return `${config.authorizeUrl}?${params.toString()}`;
+  },
+  exchangeToken: async (config, code, redirectUri) => {
+    try {
+
+      let base64 = code;
+      const padding = 4 - (base64.length % 4);
+      if (padding !== 4) base64 += "=".repeat(padding);
+      const decoded = Buffer.from(base64, "base64").toString("utf-8");
+      const lastBrace = decoded.lastIndexOf("}");
+      if (lastBrace === -1) throw new Error("No JSON found in decoded code");
+      const tokenData = JSON.parse(decoded.substring(0, lastBrace + 1));
+      return {
+        access_token: tokenData.accessToken,
+        refresh_token: tokenData.refreshToken,
+        email: tokenData.email,
+        firstName: tokenData.firstName,
+        lastName: tokenData.lastName,
+        expires_at: tokenData.expiresAt,
+      };
+    } catch (e) {
+      const response = await fetch(config.tokenExchangeUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({ grant_type: "authorization_code", code, client_type: "extension", redirect_uri: redirectUri }),
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Cline token exchange failed: ${error}`);
+      }
+      const data = await response.json();
+      return {
+        access_token: data.data?.accessToken || data.accessToken,
+        refresh_token: data.data?.refreshToken || data.refreshToken,
+        email: data.data?.userInfo?.email || "",
+        expires_at: data.data?.expiresAt || data.expiresAt,
+      };
+    }
+  },
+  mapTokens: (tokens) => ({
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiresIn: tokens.expires_at
+      ? Math.floor((new Date(tokens.expires_at).getTime() - Date.now()) / 1000)
+      : 3600,
+    email: tokens.email,
+    providerSpecificData: { firstName: tokens.firstName, lastName: tokens.lastName },
+  }),
+};
+
+export default cline;

package/src/lib/oauth/providers/clinepass.js

@@ -0,0 +1,62 @@
+import { CLINEPASS_CONFIG } from "../constants/oauth.js";
+
+const clinepass = {
+  config: CLINEPASS_CONFIG,
+  flowType: "authorization_code",
+  buildAuthUrl: (config, redirectUri) => {
+    const params = new URLSearchParams({
+      client_type: "extension",
+      callback_url: redirectUri,
+      redirect_uri: redirectUri,
+    });
+    return `${config.authorizeUrl}?${params.toString()}`;
+  },
+  exchangeToken: async (config, code, redirectUri) => {
+    try {
+
+      let base64 = code;
+      const padding = 4 - (base64.length % 4);
+      if (padding !== 4) base64 += "=".repeat(padding);
+      const decoded = Buffer.from(base64, "base64").toString("utf-8");
+      const lastBrace = decoded.lastIndexOf("}");
+      if (lastBrace === -1) throw new Error("No JSON found in decoded code");
+      const tokenData = JSON.parse(decoded.substring(0, lastBrace + 1));
+      return {
+        access_token: tokenData.accessToken,
+        refresh_token: tokenData.refreshToken,
+        email: tokenData.email,
+        firstName: tokenData.firstName,
+        lastName: tokenData.lastName,
+        expires_at: tokenData.expiresAt,
+      };
+    } catch (e) {
+      const response = await fetch(config.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({ grant_type: "authorization_code", code, client_type: "extension", redirect_uri: redirectUri }),
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`ClinePass token exchange failed: ${error}`);
+      }
+      const data = await response.json();
+      return {
+        access_token: data.data?.accessToken || data.accessToken,
+        refresh_token: data.data?.refreshToken || data.refreshToken,
+        email: data.data?.userInfo?.email || "",
+        expires_at: data.data?.expiresAt || data.expiresAt,
+      };
+    }
+  },
+  mapTokens: (tokens) => ({
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiresIn: tokens.expires_at
+      ? Math.floor((new Date(tokens.expires_at).getTime() - Date.now()) / 1000)
+      : 3600,
+    email: tokens.email,
+    providerSpecificData: { firstName: tokens.firstName, lastName: tokens.lastName },
+  }),
+};
+
+export default clinepass;

package/src/lib/oauth/providers/codebuddy-cn.js

@@ -0,0 +1,75 @@
+import { CODEBUDDY_CONFIG } from "../constants/oauth.js";
+
+const codebuddyCn = {
+  config: CODEBUDDY_CONFIG,
+  flowType: "device_code",
+  requestDeviceCode: async (config) => {
+    const response = await fetch(`${config.stateUrl}?platform=${config.platform}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "User-Agent": config.userAgent,
+        "X-Requested-With": "XMLHttpRequest",
+        "X-Domain": "copilot.tencent.com",
+        "X-No-Authorization": "true",
+        "X-No-User-Id": "true",
+        "X-Product": "SaaS",
+      },
+      body: "{}",
+    });
+    if (!response.ok) throw new Error(`CodeBuddy state request failed: ${await response.text()}`);
+    const data = await response.json();
+    if (data.code !== 0 || !data.data?.state || !data.data?.authUrl) {
+      throw new Error(`CodeBuddy state error: ${data.msg || "missing state/authUrl"}`);
+    }
+    return {
+      device_code: data.data.state,
+      verification_uri: data.data.authUrl,
+      user_code: "",
+      interval: config.pollInterval / 1000,
+      _isCodeBuddy: true,
+    };
+  },
+  pollToken: async (config, deviceCode) => {
+
+    const response = await fetch(`${config.tokenUrl}?state=${encodeURIComponent(deviceCode)}`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "User-Agent": config.userAgent,
+        "X-Requested-With": "XMLHttpRequest",
+        "X-Domain": "copilot.tencent.com",
+        "X-No-Authorization": "true",
+        "X-No-User-Id": "true",
+        "X-No-Enterprise-Id": "true",
+        "X-No-Department-Info": "true",
+        "X-Product": "SaaS",
+      },
+    });
+    if (!response.ok) return { ok: false, data: { error: "request_failed" } };
+    const data = await response.json();
+
+    if (data.code === 0 && data.data?.accessToken) {
+      return {
+        ok: true,
+        data: {
+          access_token: data.data.accessToken,
+          refresh_token: data.data.refreshToken || "",
+          token_type: data.data.tokenType || "Bearer",
+          expires_in: data.data.expiresIn,
+        },
+      };
+    }
+    if (data.code === 11217) return { ok: true, data: { error: "authorization_pending" } };
+    return { ok: false, data: { error: data.msg || "unknown_error" } };
+  },
+  mapTokens: (tokens) => ({
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiresIn: tokens.expires_in || 86400,
+    providerSpecificData: {},
+  }),
+};
+
+export default codebuddyCn;

package/src/lib/oauth/providers/codebuddy-intl.js

@@ -0,0 +1,73 @@
+import { CODEBUDDY_INTL_CONFIG } from "../constants/oauth.js";
+
+const codebuddyIntl = {
+  config: CODEBUDDY_INTL_CONFIG,
+  flowType: "device_code",
+  requestDeviceCode: async (config) => {
+    const response = await fetch(`${config.stateUrl}?platform=${config.platform}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "User-Agent": config.userAgent,
+        "X-Requested-With": "XMLHttpRequest",
+        "X-Domain": "www.codebuddy.ai",
+        "X-No-Authorization": "true",
+        "X-No-User-Id": "true",
+        "X-Product": "SaaS",
+      },
+      body: "{}",
+    });
+    if (!response.ok) throw new Error(`CodeBuddy Intl state request failed: ${await response.text()}`);
+    const data = await response.json();
+    if (data.code !== 0 || !data.data?.state || !data.data?.authUrl) {
+      throw new Error(`CodeBuddy Intl state error: ${data.msg || "missing state/authUrl"}`);
+    }
+    return {
+      device_code: data.data.state,
+      verification_uri: data.data.authUrl,
+      user_code: "",
+      interval: config.pollInterval / 1000,
+      _isCodeBuddy: true,
+    };
+  },
+  pollToken: async (config, deviceCode) => {
+    const response = await fetch(`${config.tokenUrl}?state=${encodeURIComponent(deviceCode)}`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "User-Agent": config.userAgent,
+        "X-Requested-With": "XMLHttpRequest",
+        "X-Domain": "www.codebuddy.ai",
+        "X-No-Authorization": "true",
+        "X-No-User-Id": "true",
+        "X-No-Enterprise-Id": "true",
+        "X-No-Department-Info": "true",
+        "X-Product": "SaaS",
+      },
+    });
+    if (!response.ok) return { ok: false, data: { error: "request_failed" } };
+    const data = await response.json();
+    if (data.code === 0 && data.data?.accessToken) {
+      return {
+        ok: true,
+        data: {
+          access_token: data.data.accessToken,
+          refresh_token: data.data.refreshToken || "",
+          token_type: data.data.tokenType || "Bearer",
+          expires_in: data.data.expiresIn,
+        },
+      };
+    }
+    if (data.code === 11217) return { ok: true, data: { error: "authorization_pending" } };
+    return { ok: false, data: { error: data.msg || "unknown_error" } };
+  },
+  mapTokens: (tokens) => ({
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    expiresIn: tokens.expires_in || 86400,
+    providerSpecificData: {},
+  }),
+};
+
+export default codebuddyIntl;

package/src/lib/oauth/providers/codex.js

@@ -0,0 +1,72 @@
+import { CODEX_CONFIG } from "../constants/oauth.js";
+import { extractCodexAccountInfo, extractEmailFromAccessToken } from "../providerHelpers.js";
+
+function encodeAuthParams(params) {
+  return Object.entries(params)
+    .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+    .join("&");
+}
+
+const codex = {
+  config: CODEX_CONFIG,
+  flowType: "authorization_code_pkce",
+  fixedPort: CODEX_CONFIG.fixedPort,
+  callbackPath: CODEX_CONFIG.callbackPath,
+  buildAuthUrl: (config, redirectUri, state, codeChallenge) => {
+    const params = {
+      response_type: "code",
+      client_id: config.clientId,
+      redirect_uri: redirectUri,
+      scope: config.scope,
+      code_challenge: codeChallenge,
+      code_challenge_method: config.codeChallengeMethod,
+      ...config.extraParams,
+      state: state,
+    };
+    return `${config.authorizeUrl}?${encodeAuthParams(params)}`;
+  },
+  exchangeToken: async (config, code, redirectUri, codeVerifier) => {
+    const response = await fetch(config.tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+      },
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        client_id: config.clientId,
+        code: code,
+        redirect_uri: redirectUri,
+        code_verifier: codeVerifier,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Token exchange failed: ${error}`);
+    }
+
+    return await response.json();
+  },
+  mapTokens: (tokens) => {
+    const info = extractCodexAccountInfo(tokens.id_token);
+    const mapped = {
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token,
+      idToken: tokens.id_token,
+      expiresIn: tokens.expires_in,
+      lastRefreshAt: new Date().toISOString(),
+    };
+    const email = info.email || extractEmailFromAccessToken(tokens.access_token);
+    if (email) mapped.email = email;
+    if (info.chatgptAccountId || info.chatgptPlanType) {
+      mapped.providerSpecificData = {
+        chatgptAccountId: info.chatgptAccountId,
+        chatgptPlanType: info.chatgptPlanType,
+      };
+    }
+    return mapped;
+  },
+};
+
+export default codex;

package/src/lib/oauth/providers/cursor.js

@@ -0,0 +1,18 @@
+import { CURSOR_CONFIG } from "../constants/oauth.js";
+
+const cursor = {
+  config: CURSOR_CONFIG,
+  flowType: "import_token",
+
+  mapTokens: (tokens) => ({
+    accessToken: tokens.accessToken,
+    refreshToken: null,
+    expiresIn: tokens.expiresIn || 86400,
+    providerSpecificData: {
+      machineId: tokens.machineId,
+      authMethod: "imported",
+    },
+  }),
+};
+
+export default cursor;