wyxrouter 0.4.71

package/src/lib/oauth/services/codebuddyBulkImportManager.js

@@ -0,0 +1,454 @@
+import {
+  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY,
+  KIRO_BULK_IMPORT_MAX_CONCURRENCY,
+  KIRO_BULK_IMPORT_MIN_CONCURRENCY,
+  KiroBulkImportManager,
+  buildLookupResponse,
+  createFreshContext,
+  parseKiroBulkAccounts,
+} from "./kiroBulkImportManager.js";
+import {
+  runGoogleAccountAutomation,
+  handleCodeBuddyRegionPage,
+  handleProviderOnboarding,
+  handleCodeBuddyStartedAuthorization,
+  isProviderPage,
+} from "./kiroGoogleAutomation.js";
+
+const CODEBUDDY_PROVIDER_ID = "codebuddy";
+const CODEBUDDY_LABEL = "CodeBuddy";
+const CODEBUDDY_POLL_TIMEOUT_MS = 15 * 60_000;
+const CODEBUDDY_POLL_INTERVAL_MS = 5_000;
+const CODEBUDDY_MAX_TRANSIENT_POLL_ERRORS = 6;
+const CODEBUDDY_COOKIE_DOMAINS = new Set(["codebuddy.ai", "www.codebuddy.ai"]);
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function normalizeCodeBuddyAuthUrl(rawUrl, state) {
+  if (!rawUrl && !state) return rawUrl;
+  const url = rawUrl ? new URL(rawUrl) : new URL("https://www.codebuddy.ai/login");
+  const platform = url.searchParams.get("platform") || "CLI";
+  const effectiveState = state || url.searchParams.get("state");
+  const normalized = new URL("https://www.codebuddy.ai/login");
+  normalized.searchParams.set("platform", platform);
+  if (effectiveState) normalized.searchParams.set("state", effectiveState);
+  return normalized.toString();
+}
+
+async function defaultSaveCodeBuddyConnection({ tokens, email }) {
+  const { createProviderConnection } = await import("../../../models/index.js");
+  const providerSpecificData = {
+    ...(tokens.providerSpecificData || {}),
+    loginEmail: email,
+    automation: "gsuite-bulk",
+  };
+
+  if (tokens.webCookie) {
+    providerSpecificData.webCookie = tokens.webCookie;
+    providerSpecificData.webCookieCapturedAt = tokens.webCookieCapturedAt || new Date().toISOString();
+  }
+
+  const connection = await createProviderConnection({
+    provider: CODEBUDDY_PROVIDER_ID,
+    authType: "oauth",
+    ...tokens,
+    email,
+    providerSpecificData,
+    expiresAt: tokens.expiresIn
+      ? new Date(Date.now() + tokens.expiresIn * 1000).toISOString()
+      : null,
+    testStatus: "active",
+  });
+
+  return { connection };
+}
+
+async function defaultRequestDeviceCode(providerId) {
+  const { requestDeviceCode } = await import("../providers.js");
+  return requestDeviceCode(providerId);
+}
+
+async function defaultPollForToken(providerId, deviceCode) {
+  const { pollForToken } = await import("../providers.js");
+  return pollForToken(providerId, deviceCode);
+}
+
+async function captureCodeBuddyWebCookie(context) {
+  if (!context?.cookies) {
+    console.warn("[CodeBuddy] captureWebCookie: context.cookies not available");
+    return null;
+  }
+
+  try {
+    const cookies = await context.cookies(["https://www.codebuddy.ai", "https://codebuddy.ai"]);
+    console.log(`[CodeBuddy] captureWebCookie: found ${cookies.length} raw cookies from browser context`);
+
+    const usefulCookies = cookies
+      .filter((cookie) => {
+        const domain = String(cookie.domain || "").replace(/^\./, "").toLowerCase();
+        return CODEBUDDY_COOKIE_DOMAINS.has(domain)
+          || domain.endsWith(".codebuddy.ai");
+      })
+      .filter((cookie) => cookie.name && cookie.value)
+      .sort((left, right) => String(left.name).localeCompare(String(right.name)));
+
+    if (usefulCookies.length === 0) {
+      console.warn("[CodeBuddy] captureWebCookie: no useful cookies after filtering. Raw cookie names:", cookies.map(c => `${c.name}@${c.domain}`).join(", "));
+      return null;
+    }
+
+    const cookieString = usefulCookies
+      .map((cookie) => `${cookie.name}=${cookie.value}`)
+      .join("; ");
+
+    console.log(`[CodeBuddy] captureWebCookie: captured ${usefulCookies.length} cookies (${cookieString.length} chars). Names: ${usefulCookies.map(c => c.name).join(", ")}`);
+    return cookieString;
+  } catch (error) {
+    console.error("[CodeBuddy] captureWebCookie error:", error.message);
+    return null;
+  }
+}
+
+async function attachCodeBuddyWebCookie(context, tokens = {}) {
+  const webCookie = await captureCodeBuddyWebCookie(context);
+  if (!webCookie) return tokens;
+
+  return {
+    ...tokens,
+    webCookie,
+    webCookieCapturedAt: new Date().toISOString(),
+  };
+}
+
+function createCodeBuddyPollPromise({
+  deviceCode,
+  pollToken,
+  onStep,
+  timeoutMs = CODEBUDDY_POLL_TIMEOUT_MS,
+  pollIntervalMs = CODEBUDDY_POLL_INTERVAL_MS,
+  maxTransientErrors = CODEBUDDY_MAX_TRANSIENT_POLL_ERRORS,
+}) {
+  return (async () => {
+    const startedAt = Date.now();
+    let lastStepAt = 0;
+    let transientErrors = 0;
+
+    while (Date.now() - startedAt < timeoutMs) {
+      if (Date.now() - lastStepAt > pollIntervalMs - 100) {
+        onStep?.("polling_codebuddy_token", "Waiting for CodeBuddy OAuth token");
+        lastStepAt = Date.now();
+      }
+
+      const result = await pollToken(CODEBUDDY_PROVIDER_ID, deviceCode);
+      if (result.success) {
+        return {
+          tokens: result.tokens,
+        };
+      }
+
+      if (!result.pending && result.error !== "authorization_pending" && result.error !== "slow_down") {
+        if (result.error === "request_failed" && transientErrors < maxTransientErrors) {
+          transientErrors += 1;
+          onStep?.(
+            "codebuddy_poll_retry",
+            `CodeBuddy token poll failed temporarily (${transientErrors}/${maxTransientErrors}); retrying`
+          );
+          await wait(pollIntervalMs);
+          continue;
+        }
+        throw new Error(result.errorDescription || result.error || "CodeBuddy OAuth polling failed");
+      }
+
+      await wait(pollIntervalMs);
+    }
+
+    throw new Error("Timed out waiting for CodeBuddy OAuth token");
+  })();
+}
+
+const CODEBUDDY_DASHBOARD_URL = "https://www.codebuddy.ai/home";
+const CODEBUDDY_COMPLETE_REGISTER_TIMEOUT_MS = 30_000;
+const CODEBUDDY_COMPLETE_REGISTER_POLL_MS = 1_500;
+
+async function completeCodeBuddyRegistration(page, onStep) {
+  const reportStep = (step, message) => onStep?.(step, message);
+
+  try {
+    reportStep("navigating_to_dashboard", "Navigating to CodeBuddy to complete registration");
+    await page.goto(CODEBUDDY_DASHBOARD_URL, { waitUntil: "domcontentloaded", timeout: 30_000 });
+    await page.waitForTimeout(3_000);
+
+    const startedAt = Date.now();
+    let handledAnything = false;
+    let loopCount = 0;
+
+    while (Date.now() - startedAt < CODEBUDDY_COMPLETE_REGISTER_TIMEOUT_MS) {
+      loopCount += 1;
+      if (!isProviderPage(page)) break;
+
+      const handledStarted = await handleCodeBuddyStartedAuthorization(page, reportStep);
+      if (handledStarted) {
+        handledAnything = true;
+        await page.waitForTimeout(CODEBUDDY_COMPLETE_REGISTER_POLL_MS);
+        continue;
+      }
+
+      const handledRegion = await handleCodeBuddyRegionPage(page, reportStep);
+      if (handledRegion) {
+        handledAnything = true;
+        await page.waitForTimeout(CODEBUDDY_COMPLETE_REGISTER_POLL_MS);
+        continue;
+      }
+
+      const handledOnboarding = await handleProviderOnboarding(page, reportStep, CODEBUDDY_LABEL);
+      if (handledOnboarding) {
+        handledAnything = true;
+        await page.waitForTimeout(CODEBUDDY_COMPLETE_REGISTER_POLL_MS);
+        continue;
+      }
+
+      // Nothing left to handle — page is stable
+      break;
+    }
+
+    if (handledAnything) {
+      reportStep("complete_register_done", "CodeBuddy registration completed, establishing session");
+    }
+
+    // Note: CodeBuddy web console uses Keycloak auth which is separate from the
+    // CLI OAuth flow. Web session cookies for quota tracking cannot be obtained
+    // from the OAuth token alone. Users can attach a quota cookie manually via
+    // Dashboard -> Providers -> CodeBuddy -> Quota Cookie.
+  } catch (error) {
+    reportStep("complete_register_skipped", `Could not complete registration: ${error.message}`);
+  }
+}
+export class CodeBuddyBulkImportManager extends KiroBulkImportManager {
+  constructor({
+    browserLauncher,
+    googleAutomation = runGoogleAccountAutomation,
+    requestDeviceCodeFn = defaultRequestDeviceCode,
+    pollToken = defaultPollForToken,
+    saveConnection = defaultSaveCodeBuddyConnection,
+    pollIntervalMs = CODEBUDDY_POLL_INTERVAL_MS,
+  } = {}) {
+    super({
+      browserLauncher,
+      googleAutomation,
+      storageName: "codebuddy-bulk-import",
+    });
+    this.requestDeviceCode = requestDeviceCodeFn;
+    this.pollToken = pollToken;
+    this.saveConnection = saveConnection;
+    this.pollIntervalMs = pollIntervalMs;
+  }
+
+  async runManualFollowup(job, account, workerId, context, successPromise) {
+    const followupPromise = (async () => {
+      try {
+        const result = await successPromise;
+        if (job.cancelRequested) {
+          this.finalizeAccount(account, "cancelled", {
+            error: "Job cancelled",
+            step: "cancelled",
+            message: "Job cancelled while waiting for manual completion",
+          });
+          await this.persistJobSnapshot(job, { forcePreview: true });
+          return;
+        }
+
+        const manualPage = account.manualSession?.page;
+        if (manualPage) {
+          this.setAccountStep(account, "completing_registration", "Completing CodeBuddy registration");
+          await this.persistJobSnapshot(job, { forcePreview: true });
+          await completeCodeBuddyRegistration(manualPage, (step, message) => {
+            this.setAccountStep(account, step, message);
+            void this.persistJobSnapshot(job, { forcePreview: false });
+          });
+        }
+
+        this.setAccountStep(account, "saving_connection", "Saving CodeBuddy OAuth connection");
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        const tokensWithCookie = await attachCodeBuddyWebCookie(context, result.tokens);
+        const { connection } = await this.saveConnection({
+          tokens: tokensWithCookie,
+          email: account.email,
+        });
+
+        this.finalizeAccount(account, "success", {
+          connectionId: connection.id,
+          step: "connection_saved",
+          message: "CodeBuddy connection saved successfully",
+        });
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      } catch (error) {
+        if (job.cancelRequested) {
+          this.finalizeAccount(account, "cancelled", {
+            error: "Job cancelled",
+            step: "cancelled",
+            message: "Job cancelled while waiting for manual completion",
+          });
+        } else {
+          this.finalizeAccount(account, "failed_exchange", {
+            error: error.message || "Manual assist flow failed during token polling.",
+            step: "exchange_failed",
+            message: error.message || "Manual assist flow failed during token polling.",
+          });
+        }
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      } finally {
+        account.manualSession = null;
+        account.runtimeSession = null;
+        await context.close().catch(() => null);
+        job.manualFollowups.delete(followupPromise);
+        await this.persistJobSnapshot(job, { forcePreview: true });
+      }
+    })();
+
+    job.manualFollowups.add(followupPromise);
+  }
+
+  async processAccount(job, account, workerId) {
+    if (job.cancelRequested || !job.browser) {
+      this.finalizeAccount(account, "cancelled", { error: "Job cancelled" });
+      return;
+    }
+
+    const { context, page } = await createFreshContext(job.browser);
+    account.runtimeSession = { context, page };
+
+    try {
+      this.setAccountStep(account, "preparing_worker", `Worker ${workerId} is preparing a browser context`);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+
+      this.setAccountStep(account, "requesting_codebuddy_state", "Requesting CodeBuddy OAuth state");
+      const deviceData = await this.requestDeviceCode(CODEBUDDY_PROVIDER_ID);
+      const authUrl = normalizeCodeBuddyAuthUrl(deviceData.verification_uri, deviceData.device_code);
+      if (!authUrl || !deviceData.device_code) {
+        throw new Error("CodeBuddy did not return an OAuth login URL");
+      }
+
+      const successPromise = createCodeBuddyPollPromise({
+        deviceCode: deviceData.device_code,
+        pollToken: this.pollToken,
+        pollIntervalMs: this.pollIntervalMs,
+        onStep: (step, message) => {
+          this.setAccountStep(account, step, message);
+          void this.persistJobSnapshot(job, { forcePreview: false });
+        },
+      });
+
+      const automationResult = await this.googleAutomation({
+        page,
+        authUrl,
+        email: account.email,
+        password: account.password,
+        successPromise,
+        serviceLabel: CODEBUDDY_LABEL,
+        openingStep: "opening_codebuddy_oauth",
+        openingMessage: "Opening CodeBuddy OAuth page",
+        successStep: "codebuddy_token_received",
+        successMessage: "CodeBuddy OAuth token received",
+        onStep: (step, message) => {
+          this.setAccountStep(account, step, message);
+          void this.persistJobSnapshot(job, { forcePreview: false });
+        },
+      });
+
+      if (automationResult.status === "success") {
+        this.setAccountStep(account, "completing_registration", "Completing CodeBuddy registration");
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        await completeCodeBuddyRegistration(page, (step, message) => {
+          this.setAccountStep(account, step, message);
+          void this.persistJobSnapshot(job, { forcePreview: false });
+        });
+
+        this.setAccountStep(account, "saving_connection", "Saving CodeBuddy OAuth connection");
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        const tokensWithCookie = await attachCodeBuddyWebCookie(context, automationResult.tokens);
+        const { connection } = await this.saveConnection({
+          tokens: tokensWithCookie,
+          email: account.email,
+        });
+        this.finalizeAccount(account, "success", {
+          connectionId: connection.id,
+          step: "connection_saved",
+          message: "CodeBuddy connection saved successfully",
+        });
+        account.runtimeSession = null;
+        await context.close().catch(() => null);
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        return;
+      }
+
+      if (automationResult.status === "needs_manual") {
+        account.manualSession = {
+          context,
+          page,
+          opened: false,
+          openedAt: null,
+        };
+        this.setAccountStep(account, "awaiting_manual", "Waiting for manual completion in the browser session");
+        this.finalizeAccount(account, "needs_manual", {
+          error: automationResult.error,
+          step: "awaiting_manual",
+          message: automationResult.error,
+        });
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        await this.runManualFollowup(job, account, workerId, context, successPromise);
+        return;
+      }
+
+      this.finalizeAccount(account, automationResult.status || "failed", {
+        error: automationResult.error || "CodeBuddy Google automation failed.",
+        step: automationResult.status || "failed",
+        message: automationResult.error || "CodeBuddy Google automation failed.",
+      });
+      account.runtimeSession = null;
+      await context.close().catch(() => null);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+    } catch (error) {
+      if (job.cancelRequested) {
+        this.finalizeAccount(account, "cancelled", {
+          error: "Job cancelled",
+          step: "cancelled",
+          message: "Job cancelled while CodeBuddy automation was running",
+        });
+      } else {
+        this.finalizeAccount(account, "failed", {
+          error: error.message || "Unexpected CodeBuddy bulk import failure.",
+          step: "failed",
+          message: error.message || "Unexpected CodeBuddy bulk import failure.",
+        });
+      }
+      account.runtimeSession = null;
+      await context.close().catch(() => null);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+    } finally {
+      account.password = undefined;
+    }
+  }
+}
+
+function getSingletonStore() {
+  if (!globalThis.__codeBuddyBulkImportSingleton) {
+    globalThis.__codeBuddyBulkImportSingleton = {
+      manager: new CodeBuddyBulkImportManager(),
+    };
+  }
+  return globalThis.__codeBuddyBulkImportSingleton;
+}
+
+export function getCodeBuddyBulkImportManager() {
+  return getSingletonStore().manager;
+}
+
+export {
+  buildLookupResponse,
+  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY as CODEBUDDY_BULK_IMPORT_DEFAULT_CONCURRENCY,
+  KIRO_BULK_IMPORT_MAX_CONCURRENCY as CODEBUDDY_BULK_IMPORT_MAX_CONCURRENCY,
+  KIRO_BULK_IMPORT_MIN_CONCURRENCY as CODEBUDDY_BULK_IMPORT_MIN_CONCURRENCY,
+  parseKiroBulkAccounts as parseCodeBuddyBulkAccounts,
+};

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

@@ -0,0 +1,144 @@
+import open from "open";
+import { OAuthService } from "./oauth.js";
+import { CODEX_CONFIG } from "../constants/oauth.js";
+import { getServerCredentials } from "../config/index.js";
+import { startLocalServer } from "../utils/server.js";
+import { generatePKCE } from "../utils/pkce.js";
+import { spinner as createSpinner } from "../utils/ui.js";
+
+/**
+ * Codex (OpenAI) OAuth Service
+ */
+export class CodexService extends OAuthService {
+  constructor() {
+    super(CODEX_CONFIG);
+  }
+
+  /**
+   * Build Codex authorization URL
+   */
+  buildCodexAuthUrl(redirectUri, state, codeChallenge) {
+    // Build URL manually to ensure space encoding as %20 instead of +
+    const params = {
+      response_type: "code",
+      client_id: CODEX_CONFIG.clientId,
+      redirect_uri: redirectUri,
+      scope: CODEX_CONFIG.scope,
+      code_challenge: codeChallenge,
+      code_challenge_method: CODEX_CONFIG.codeChallengeMethod,
+      ...CODEX_CONFIG.extraParams,
+      state: state,
+    };
+
+    const queryString = Object.entries(params)
+      .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+      .join("&");
+
+    return `${CODEX_CONFIG.authorizeUrl}?${queryString}`;
+  }
+
+  /**
+   * Save Codex tokens to server
+   */
+  async saveTokens(tokens) {
+    const { server, token, userId } = getServerCredentials();
+
+    const response = await fetch(`${server}/api/cli/providers/codex`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        "X-User-Id": userId,
+      },
+      body: JSON.stringify({
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresIn: tokens.expires_in,
+        lastRefreshAt: new Date().toISOString(),
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || "Failed to save tokens");
+    }
+
+    return await response.json();
+  }
+
+  /**
+   * Complete Codex OAuth flow
+   */
+  async connect() {
+    const spinner = createSpinner("Starting Codex OAuth...").start();
+
+    try {
+      spinner.text = "Starting local server...";
+
+      // Start local server for callback (use fixed port 1455 like real Codex CLI)
+      const fixedPort = 1455;
+      let callbackParams = null;
+      const { port, close } = await startLocalServer((params) => {
+        callbackParams = params;
+      }, fixedPort);
+
+      const redirectUri = `http://localhost:${port}/auth/callback`;
+      spinner.succeed(`Local server started on port ${port}`);
+
+      // Generate PKCE
+      const { codeVerifier, codeChallenge, state } = generatePKCE();
+
+      // Build authorization URL
+      const authUrl = this.buildCodexAuthUrl(redirectUri, state, codeChallenge);
+
+      console.log("\nOpening browser for OpenAI authentication...");
+      console.log(`If browser doesn't open, visit:\n${authUrl}\n`);
+
+      // Open browser
+      await open(authUrl);
+
+      // Wait for callback
+      spinner.start("Waiting for OpenAI authorization...");
+
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error("Authentication timeout (5 minutes)"));
+        }, 300000);
+
+        const checkInterval = setInterval(() => {
+          if (callbackParams) {
+            clearInterval(checkInterval);
+            clearTimeout(timeout);
+            resolve();
+          }
+        }, 100);
+      });
+
+      close();
+
+      if (callbackParams.error) {
+        throw new Error(callbackParams.error_description || callbackParams.error);
+      }
+
+      if (!callbackParams.code) {
+        throw new Error("No authorization code received");
+      }
+
+      spinner.start("Exchanging code for tokens...");
+
+      // Exchange code for tokens (Codex uses form-urlencoded)
+      const tokens = await this.exchangeCode(callbackParams.code, redirectUri, codeVerifier, "application/x-www-form-urlencoded");
+
+      spinner.text = "Saving tokens to server...";
+
+      // Save tokens to server
+      await this.saveTokens(tokens);
+
+      spinner.succeed("Codex connected successfully!");
+      return true;
+    } catch (error) {
+      spinner.fail(`Failed: ${error.message}`);
+      throw error;
+    }
+  }
+}