zevairouter 1.0.44 → 1.0.46

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

@@ -0,0 +1,449 @@
+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,
+  pollTempmailXaiOtp,
+} from "./tempmailClient.js";
+import {
+  runXaiEmailSignup,
+  runXaiEmailDeviceAuthorize,
+} 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:
+ * - auto / tempmail / auto:N / tempmail:N  → generate N tempmail mailboxes + random passwords
+ * - email:password / email|password → existing login
+ * - bare number N → N auto accounts
+ */
+export async function expandGrokBulkAccountLines(accounts = [], { createMailbox = createTempmailMailbox } = {}) {
+  const lines = Array.isArray(accounts) ? accounts : [];
+  const expanded = [];
+  const invalidLines = [];
+
+  for (let index = 0; index < lines.length; index++) {
+    const raw = String(lines[index] || "").trim();
+    if (!raw || raw.startsWith("#")) continue;
+
+    // bare count: "5"
+    if (/^\d{1,3}$/.test(raw)) {
+      const n = Math.min(50, Math.max(1, Number(raw)));
+      for (let i = 0; i < n; i++) {
+        const box = await createMailbox({ prefix: "zevai-cb", label: "grok-cli-bulk" });
+        const password = generateTempmailPassword();
+        expanded.push({
+          line: index + 1,
+          email: box.address,
+          password,
+          mode: "tempmail-register",
+        });
+      }
+      continue;
+    }
+
+    // auto / tempmail / auto:3
+    const autoMatch = raw.match(/^(auto|tempmail)(?::(\d{1,3}))?$/i);
+    if (autoMatch) {
+      const n = Math.min(50, Math.max(1, Number(autoMatch[2] || 1)));
+      for (let i = 0; i < n; i++) {
+        const box = await createMailbox({ prefix: "zevai-cb", label: "grok-cli-bulk" });
+        const password = generateTempmailPassword();
+        expanded.push({
+          line: index + 1,
+          email: box.address,
+          password,
+          mode: "tempmail-register",
+        });
+      }
+      continue;
+    }
+
+    // standard email:password or email|password
+    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();
+      }
+    }
+
+    if (!email || !password) {
+      invalidLines.push(index + 1);
+      continue;
+    }
+
+    // Existing credentials → login only (no signup). Tempmail domain still works for login.
+    expanded.push({
+      line: index + 1,
+      email,
+      password,
+      mode: "email-login",
+    });
+  }
+
+  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, engine) {
+  const { launchBulkImportBrowser, normalizeBulkImportEngine } = await import("./bulkImportBrowserEngine.js");
+  const resolved = normalizeBulkImportEngine(engine || "cloakbrowser");
+  // CloakBrowser defaults headed (Turnstile); other engines keep headless default
+  const headless = resolved === "cloakbrowser" ? false : true;
+  return launchBulkImportBrowser({
+    engine: resolved,
+    proxyUrl,
+    headless,
+    windowSize: resolved === "cloakbrowser" ? { width: 1280, height: 900 } : null,
+  });
+}
+
+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({
+      browserLauncher: (job) => browserLauncher(proxyUrl, 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: auto / auto:5 / email:password (or email|password)"
+        : "At least one account entry is required (e.g. auto 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()) || "email-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;
+    }
+
+    const { context, page } = await createFreshContext(job.browser, account.proxyUrl);
+    account.runtimeSession = { context, page };
+
+    try {
+      this.setAccountStep(account, "preparing_worker", `Worker ${workerId} preparing CloakBrowser / xAI flow`);
+      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 || "email-login";
+
+      // 1) Register via tempmail if needed
+      if (mode === "tempmail-register") {
+        this.setAccountStep(account, "registering_xai", "Signing up on xAI with tempmail + Turnstile");
+        await this.persistJobSnapshot(job, { forcePreview: true });
+
+        const signup = await runXaiEmailSignup(page, {
+          email: account.email,
+          password: account.password,
+          firstName: "Zevai",
+          lastName: "Bulk",
+          pollOtp: (addr, opts) => this.pollOtp(addr, opts),
+          onStep,
+        });
+
+        if (signup.status === "needs_manual") {
+          account.manualSession = { context, page, opened: false, openedAt: null };
+          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; no token poll yet
+          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);
+          await this.persistJobSnapshot(job, { forcePreview: true });
+          return;
+        }
+      }
+
+      // 2) Device code + authorize with email session
+      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 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);
+        await this.persistJobSnapshot(job, { forcePreview: true });
+        return;
+      }
+
+      this.finalizeAccount(account, "failed", {
+        error: auth.error || "Device authorization failed",
+        step: "device_failed",
+        message: auth.error || "Device authorization 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 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);
+      await this.persistJobSnapshot(job, { forcePreview: true });
+    } finally {
+      account.password = undefined;
+    }
+  }
+
+  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 = "email-login") {
+    this.setAccountStep(account, "saving_connection", "Saving Grok CLI connection");
+    await this.persistJobSnapshot(job, { forcePreview: true });
+
+    const automation = mode === "tempmail-register" ? "tempmail-cloakbrowser" : "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,
+};