zevairouter 1.0.126 → 1.0.128

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

@@ -1,564 +0,0 @@
-import {
-  KiroBulkImportManager,
-  buildLookupResponse,
-  createFreshContext,
-  parseKiroBulkAccounts,
-  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY,
-  KIRO_BULK_IMPORT_MAX_CONCURRENCY,
-  KIRO_BULK_IMPORT_MIN_CONCURRENCY,
-} from "./kiroBulkImportManager.js";
-import {
-  createTempmailMailbox,
-  generateTempmailPassword,
-  generateRandomPersonName,
-  pollTempmailXaiOtp,
-} from "./tempmailClient.js";
-import {
-  runXaiEmailSignup,
-  runXaiEmailDeviceAuthorize,
-  runXaiGoogleDeviceAuthorize,
-} from "./grokXaiEmailAutomation.js";
-
-const GROK_CLI_PROVIDER_ID = "grok-cli";
-const GROK_CLI_LABEL = "Grok CLI";
-const GROK_CLI_POLL_TIMEOUT_MS = 15 * 60_000;
-const GROK_CLI_POLL_INTERVAL_MS = 5_000;
-
-function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export function resolveVerificationUrl(deviceData) {
-  if (deviceData?.verification_uri_complete) {
-    return deviceData.verification_uri_complete;
-  }
-  const base = deviceData?.verification_uri || "https://accounts.x.ai/oauth2/device";
-  if (deviceData?.user_code) {
-    try {
-      const url = new URL(base);
-      url.searchParams.set("user_code", deviceData.user_code);
-      return url.toString();
-    } catch {
-      return `${base}${base.includes("?") ? "&" : "?"}user_code=${encodeURIComponent(deviceData.user_code)}`;
-    }
-  }
-  return base;
-}
-
-/**
- * Expand bulk lines for Grok:
- * - email:password / email|password → **Google OAuth** device auth (default, like Kiro)
- * - google:email:pass / gmail:email|pass → force Google
- * - email-login:email:pass → legacy xAI email+password (Turnstile)
- * - auto / tempmail / auto:N → tempmail register (legacy)
- * - bare number N → N tempmail accounts
- */
-export async function expandGrokBulkAccountLines(accounts = [], { createMailbox = createTempmailMailbox } = {}) {
-  const lines = Array.isArray(accounts) ? accounts : [];
-  const expanded = [];
-  const invalidLines = [];
-
-  const pushTempmail = async (count, line) => {
-    const n = Math.min(50, Math.max(1, count));
-    for (let i = 0; i < n; i++) {
-      const box = await createMailbox({ prefix: "zevai-cb", label: "grok-cli-bulk" });
-      const password = generateTempmailPassword();
-      expanded.push({
-        line,
-        email: box.address,
-        password,
-        mode: "tempmail-register",
-      });
-    }
-  };
-
-  const parseEmailPassword = (raw) => {
-    let email = "";
-    let password = "";
-    if (raw.includes("|")) {
-      const [e, ...rest] = raw.split("|");
-      email = e.trim();
-      password = rest.join("|").trim();
-    } else if (raw.includes(":")) {
-      const idx = raw.indexOf(":");
-      const before = raw.slice(0, idx).trim();
-      if (before.includes("@")) {
-        email = before;
-        password = raw.slice(idx + 1).trim();
-      }
-    }
-    return { email, password };
-  };
-
-  for (let index = 0; index < lines.length; index++) {
-    const raw = String(lines[index] || "").trim();
-    if (!raw || raw.startsWith("#")) continue;
-
-    if (/^\d{1,3}$/.test(raw)) {
-      await pushTempmail(Number(raw), index + 1);
-      continue;
-    }
-
-    const autoMatch = raw.match(/^(auto|tempmail)(?::(\d{1,3}))?$/i);
-    if (autoMatch) {
-      await pushTempmail(Number(autoMatch[2] || 1), index + 1);
-      continue;
-    }
-
-    let body = raw;
-    let mode = "google-login";
-    const googlePref = raw.match(/^(google|gmail)[:|]/i);
-    const emailPref = raw.match(/^email-login[:|]/i);
-    if (googlePref) {
-      body = raw.slice(googlePref[0].length).trim();
-      mode = "google-login";
-    } else if (emailPref) {
-      body = raw.slice(emailPref[0].length).trim();
-      mode = "email-login";
-    }
-
-    const { email, password } = parseEmailPassword(body);
-    if (!email || !password) {
-      invalidLines.push(index + 1);
-      continue;
-    }
-
-    expanded.push({
-      line: index + 1,
-      email,
-      password,
-      mode,
-    });
-  }
-
-  return { parsed: expanded, invalidLines };
-}
-
-async function defaultRequestDeviceCode() {
-  const { requestDeviceCode } = await import("../providers.js");
-  return requestDeviceCode(GROK_CLI_PROVIDER_ID);
-}
-
-async function defaultPollForToken(deviceCode) {
-  const { pollForToken } = await import("../providers.js");
-  return pollForToken(GROK_CLI_PROVIDER_ID, deviceCode);
-}
-
-async function defaultSaveGrokCliConnection({ tokens, email, automation = "tempmail-cloakbrowser" }) {
-  const { createProviderConnection } = await import("../../../models/index.js");
-  const providerSpecificData = {
-    ...(tokens.providerSpecificData || {}),
-    loginEmail: email,
-    automation,
-    authMethod: tokens.providerSpecificData?.authMethod || "device_code",
-  };
-
-  const connectionData = {
-    provider: GROK_CLI_PROVIDER_ID,
-    authType: "oauth",
-    accessToken: tokens.accessToken,
-    refreshToken: tokens.refreshToken || null,
-    email: tokens.email || email,
-    displayName: tokens.displayName || email?.split("@")[0] || null,
-    scope: tokens.scope || null,
-    providerSpecificData,
-    expiresAt: tokens.expiresIn
-      ? new Date(Date.now() + tokens.expiresIn * 1000).toISOString()
-      : null,
-    testStatus: "active",
-  };
-
-  const connection = await createProviderConnection(connectionData);
-  return { connection };
-}
-
-async function defaultBrowserLauncher(proxyUrl) {
-  const { launchBulkImportBrowser } = await import("./bulkImportBrowserEngine.js");
-  return launchBulkImportBrowser({
-    engine: "chromium",
-    proxyUrl,
-    headless: true,
-  });
-}
-
-class GrokCliBulkImportManager extends KiroBulkImportManager {
-  constructor({
-    browserLauncher = defaultBrowserLauncher,
-    saveConnection = defaultSaveGrokCliConnection,
-    requestDeviceCode = defaultRequestDeviceCode,
-    pollToken = defaultPollForToken,
-    createMailbox = createTempmailMailbox,
-    pollOtp = pollTempmailXaiOtp,
-    storageName = "grok-cli-bulk-import",
-    proxyUrl = null,
-  } = {}) {
-    super({
-      // Prefer first pool URL from the job so CloakBrowser launches with proxy+geoip
-      // (context-only proxy is not enough for fingerprint/timezone matching).
-      browserLauncher: (job) =>
-        browserLauncher(job?.proxyUrls?.[0] || proxyUrl || null, job?.engine),
-      googleAutomation: null,
-      socialExchange: null,
-      kiroServiceFactory: null,
-      storageName,
-    });
-    this.saveConnection = saveConnection;
-    this.requestDeviceCode = requestDeviceCode;
-    this.pollToken = pollToken;
-    this.createMailbox = createMailbox;
-    this.pollOtp = pollOtp;
-    this.proxyUrl = proxyUrl;
-  }
-
-  async startJob({ accounts, concurrency, engine, proxyPoolMode, proxyPoolId }) {
-    const { parsed, invalidLines } = await expandGrokBulkAccountLines(accounts, {
-      createMailbox: this.createMailbox,
-    });
-
-    if (!parsed.length) {
-      const error = invalidLines.length > 0
-        ? "Invalid format. Use: email|password (Google OAuth) / auto / auto:5 / email-login:email:pass"
-        : "At least one account entry is required (e.g. email|password or auto:3)";
-      throw Object.assign(new Error(error), {
-        error,
-        ...(invalidLines.length ? { invalidLines } : {}),
-      });
-    }
-    if (invalidLines.length > 0) {
-      throw Object.assign(new Error("Invalid account format"), {
-        error: "Invalid format. Use: auto / auto:5 / email:password",
-        invalidLines,
-      });
-    }
-
-    // Rebuild lines as email:password for parent startJob parse
-    const lineStrings = parsed.map((a) => `${a.email}:${a.password}`);
-    // Prefer cloakbrowser; cap concurrency (Turnstile is heavy)
-    const resolvedEngine = engine || "cloakbrowser";
-    const resolvedConcurrency = concurrency ?? 1;
-
-    const job = await super.startJob({
-      accounts: lineStrings,
-      concurrency: resolvedConcurrency,
-      engine: resolvedEngine,
-      proxyPoolMode,
-      proxyPoolId,
-    });
-
-    // Attach mode metadata by email
-    const live = this.jobs.get(job.jobId);
-    if (live) {
-      const modeByEmail = new Map(parsed.map((a) => [a.email.toLowerCase(), a.mode]));
-      for (const account of live.accounts) {
-        account.mode = modeByEmail.get(String(account.email || "").toLowerCase()) || "google-login";
-      }
-      // Keep passwords in account for signup path (parent may strip later)
-      for (const account of live.accounts) {
-        const src = parsed.find((p) => p.email === account.email);
-        if (src) {
-          account.password = src.password;
-          account.mode = src.mode;
-        }
-      }
-    }
-
-    return job;
-  }
-
-  async processAccount(job, account, workerId) {
-    if (job.cancelRequested || !job.browser) {
-      this.finalizeAccount(account, "cancelled", { error: "Job cancelled" });
-      return;
-    }
-
-    // CloakBrowser needs proxy+geoip on launch() for antibot. Shared job.browser may
-    // have no proxy or a different one — spawn a dedicated browser when needed.
-    let browser = job.browser;
-    let ownedBrowser = null;
-    const accountProxy = account.proxyUrl || null;
-    const sharedProxy = job.proxyUrls?.[0] || null;
-    const needsOwnBrowser =
-      job.engine === "cloakbrowser"
-      && accountProxy
-      && accountProxy !== sharedProxy;
-
-    if (needsOwnBrowser || (job.engine === "cloakbrowser" && accountProxy && !sharedProxy)) {
-      try {
-        const { launchBulkImportBrowser } = await import("./bulkImportBrowserEngine.js");
-        ownedBrowser = await launchBulkImportBrowser({
-          engine: "cloakbrowser",
-          proxyUrl: accountProxy,
-          headless: false,
-          windowSize: { width: 1280, height: 900 },
-        });
-        browser = ownedBrowser;
-        this.setAccountStep(
-          account,
-          "proxy_browser",
-          `Launched CloakBrowser with account proxy (geoip)`
-        );
-      } catch (error) {
-        this.finalizeAccount(account, "failed", {
-          error: error.message || "Failed to launch browser with proxy",
-          step: "proxy_launch_failed",
-          message: error.message || "Failed to launch browser with proxy",
-        });
-        await this.persistJobSnapshot(job, { forcePreview: true });
-        return;
-      }
-    }
-
-    // If browser already launched with this proxy, don't double-apply on context
-    const contextProxy = ownedBrowser ? null : accountProxy;
-    let context = null;
-
-    try {
-      const session = await createFreshContext(browser, contextProxy);
-      context = session.context;
-      const { page } = session;
-      account.runtimeSession = { context, page, ownedBrowser };
-      this.setAccountStep(
-        account,
-        "preparing_worker",
-        `Worker ${workerId} preparing CloakBrowser / xAI flow${accountProxy ? " (proxied)" : " (direct VPS IP — expect blocks)"}`
-      );
-      await this.persistJobSnapshot(job, { forcePreview: true });
-
-      const onStep = (step, message) => {
-        this.setAccountStep(account, step, message);
-        void this.persistJobSnapshot(job, { forcePreview: false });
-      };
-
-      const mode = account.mode || "google-login";
-
-      // 1) Register via tempmail if needed
-      if (mode === "tempmail-register") {
-        const { firstName, lastName } = generateRandomPersonName();
-        account.profileName = `${firstName} ${lastName}`;
-        this.setAccountStep(
-          account,
-          "registering_xai",
-          `Signing up as ${firstName} ${lastName} (tempmail + Turnstile)`
-        );
-        await this.persistJobSnapshot(job, { forcePreview: true });
-
-        const signup = await runXaiEmailSignup(page, {
-          email: account.email,
-          password: account.password,
-          firstName,
-          lastName,
-          pollOtp: (addr, opts) => this.pollOtp(addr, opts),
-          onStep,
-        });
-
-        if (signup.status === "needs_manual") {
-          account.manualSession = {
-            context,
-            page,
-            opened: false,
-            openedAt: null,
-            ownedBrowser,
-          };
-          this.finalizeAccount(account, "needs_manual", {
-            error: signup.error,
-            step: signup.step || "awaiting_manual",
-            message: signup.error,
-          });
-          await this.persistJobSnapshot(job, { forcePreview: true });
-          // keep session open for manual; do not close ownedBrowser here
-          ownedBrowser = null;
-          return;
-        }
-
-        if (signup.status !== "success") {
-          this.finalizeAccount(account, "failed", {
-            error: signup.error || "xAI email signup failed",
-            step: signup.step || "failed",
-            message: signup.error || "xAI email signup failed",
-          });
-          account.runtimeSession = null;
-          await context?.close().catch(() => null);
-          if (ownedBrowser) await ownedBrowser.close().catch(() => null);
-          await this.persistJobSnapshot(job, { forcePreview: true });
-          return;
-        }
-      }
-
-      // 2) Device code + authorize (Google OAuth preferred; email path for legacy)
-      this.setAccountStep(account, "requesting_device_code", "Requesting Grok CLI device code");
-      await this.persistJobSnapshot(job, { forcePreview: true });
-      const deviceData = await this.requestDeviceCode();
-      const authUrl = resolveVerificationUrl(deviceData);
-      const deviceCode = deviceData?.device_code;
-      if (!authUrl || !deviceCode) {
-        throw new Error("Grok CLI did not return a device code / verification URL");
-      }
-
-      const useGoogle = mode === "google-login" || mode === "google";
-      let auth;
-      if (useGoogle) {
-        this.setAccountStep(
-          account,
-          "google_device_auth",
-          `Authorizing Grok via Google OAuth (${account.email})`
-        );
-        await this.persistJobSnapshot(job, { forcePreview: true });
-        auth = await runXaiGoogleDeviceAuthorize(page, {
-          email: account.email,
-          password: account.password,
-          verificationUrl: authUrl,
-          deviceCode,
-          pollToken: (code) => this.pollToken(code),
-          onStep,
-          cancelCheck: () => job.cancelRequested,
-        });
-      } else {
-        auth = await runXaiEmailDeviceAuthorize(page, {
-          email: account.email,
-          password: account.password,
-          verificationUrl: authUrl,
-          deviceCode,
-          pollToken: (code) => this.pollToken(code),
-          pollOtp: (addr, opts) => this.pollOtp(addr, opts),
-          onStep,
-          cancelCheck: () => job.cancelRequested,
-        });
-      }
-
-      if (auth.status === "success" && auth.tokens) {
-        await this.finalizeSuccess(job, account, auth.tokens, mode);
-        account.runtimeSession = null;
-        await context?.close().catch(() => null);
-        if (ownedBrowser) await ownedBrowser.close().catch(() => null);
-        await this.persistJobSnapshot(job, { forcePreview: true });
-        return;
-      }
-
-      if (auth.status === "needs_manual") {
-        account.manualSession = {
-          context,
-          page,
-          opened: false,
-          openedAt: null,
-          ownedBrowser,
-        };
-        this.finalizeAccount(account, "needs_manual", {
-          error: auth.error,
-          step: "awaiting_manual",
-          message: auth.error,
-        });
-        await this.persistJobSnapshot(job, { forcePreview: true });
-        ownedBrowser = null;
-        return;
-      }
-
-      this.finalizeAccount(account, auth.status?.startsWith?.("failed") ? auth.status : "failed", {
-        error: auth.error || "Device authorization failed",
-        step: "device_failed",
-        message: auth.error || "Device authorization failed",
-      });
-      account.runtimeSession = null;
-      await context?.close().catch(() => null);
-      if (ownedBrowser) await ownedBrowser.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 Grok CLI automation was running",
-        });
-      } else {
-        this.finalizeAccount(account, error.status || "failed", {
-          error: error.message || "Unexpected Grok CLI bulk import failure.",
-          step: error.step || "failed",
-          message: error.message || "Unexpected Grok CLI bulk import failure.",
-        });
-      }
-      account.runtimeSession = null;
-      await context?.close().catch(() => null);
-      if (ownedBrowser) await ownedBrowser.close().catch(() => null);
-      await this.persistJobSnapshot(job, { forcePreview: true });
-    } finally {
-      account.password = undefined;
-      if (ownedBrowser) await ownedBrowser.close().catch(() => null);
-    }
-  }
-
-  createPollPromise(deviceCode, job, account) {
-    return (async () => {
-      const startTime = Date.now();
-      let intervalMs = GROK_CLI_POLL_INTERVAL_MS;
-      while (Date.now() - startTime < GROK_CLI_POLL_TIMEOUT_MS) {
-        if (job.cancelRequested) throw new Error("Job cancelled during token polling");
-        this.setAccountStep(account, "polling_grok_token", "Waiting for Grok CLI OAuth token");
-        void this.persistJobSnapshot(job, { forcePreview: false });
-        const result = await this.pollToken(deviceCode);
-        if (result.success && result.tokens) return { tokens: result.tokens };
-        if (result.pending || result.error === "authorization_pending") {
-          await wait(intervalMs);
-          continue;
-        }
-        if (result.error === "slow_down") {
-          intervalMs = Math.min(intervalMs + 5_000, 30_000);
-          await wait(intervalMs);
-          continue;
-        }
-        await wait(intervalMs);
-      }
-      throw new Error("Timed out waiting for Grok CLI OAuth token");
-    })();
-  }
-
-  async finalizeSuccess(job, account, tokens, mode = "google-login") {
-    this.setAccountStep(account, "saving_connection", "Saving Grok CLI connection");
-    await this.persistJobSnapshot(job, { forcePreview: true });
-
-    const automation = mode === "tempmail-register"
-      ? "tempmail-cloakbrowser"
-      : mode === "google-login" || mode === "google"
-        ? "google-oauth-device"
-        : "email-login-cloakbrowser";
-    const { connection } = await this.saveConnection({
-      tokens,
-      email: tokens.email || account.email,
-      automation,
-    });
-
-    this.finalizeAccount(account, "success", {
-      connectionId: connection.id,
-      step: "connection_saved",
-      message: "Grok CLI connection saved successfully",
-    });
-  }
-}
-
-function getSingletonStore() {
-  if (!globalThis.__grokCliBulkImportSingleton) {
-    globalThis.__grokCliBulkImportSingleton = {
-      manager: new GrokCliBulkImportManager(),
-    };
-  }
-  return globalThis.__grokCliBulkImportSingleton;
-}
-
-export function getGrokCliBulkImportManager() {
-  return getSingletonStore().manager;
-}
-
-// Back-compat re-export used by older tests
-export async function prepareXaiDeviceLogin(page, onStep) {
-  const { runXaiEmailDeviceAuthorize } = await import("./grokXaiEmailAutomation.js");
-  // minimal stub — prefer full email path
-  onStep?.("deprecated", "prepareXaiDeviceLogin is superseded by email device authorize");
-  return { ok: true, stage: "unknown" };
-}
-
-export {
-  GrokCliBulkImportManager,
-  buildLookupResponse,
-  parseKiroBulkAccounts,
-  KIRO_BULK_IMPORT_DEFAULT_CONCURRENCY,
-  KIRO_BULK_IMPORT_MAX_CONCURRENCY,
-  KIRO_BULK_IMPORT_MIN_CONCURRENCY,
-};