zevairouter 1.0.44 → 1.0.47

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

@@ -0,0 +1,343 @@
+/**
+ * xAI email signup / login automation for Grok CLI device-code flow.
+ * Proven with CloakBrowser (Turnstile) + tempmail.zevai.web.id OTP.
+ */
+
+import { pollTempmailXaiOtp } from "./tempmailClient.js";
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function pageText(page) {
+  return page.evaluate(() => document.body?.innerText || "").catch(() => "");
+}
+
+async function clickFirst(page, selectors, { timeout = 3_000 } = {}) {
+  for (const selector of selectors) {
+    try {
+      const loc = page.locator(selector).first();
+      if (await loc.isVisible({ timeout: 400 }).catch(() => false)) {
+        await loc.click({ timeout });
+        return selector;
+      }
+    } catch {
+      // next
+    }
+  }
+  return null;
+}
+
+async function dismissCookies(page) {
+  return clickFirst(page, [
+    "#onetrust-accept-btn-handler",
+    "#onetrust-reject-all-handler",
+    'button:has-text("Accept All Cookies")',
+    'button:has-text("Reject All")',
+  ]);
+}
+
+async function typeSlow(locator, value, delay = 35) {
+  await locator.click();
+  await locator.fill("").catch(() => null);
+  await locator.type(value, { delay });
+}
+
+/**
+ * Wait until Cloudflare Turnstile populates cf-turnstile-response (or times out).
+ */
+export async function waitForTurnstile(page, { timeoutMs = 60_000, onStep } = {}) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const val = await page.evaluate(() => {
+      const el = document.querySelector("input[name=cf-turnstile-response], [name=cf-turnstile-response]");
+      return el ? String(el.value || "") : "";
+    }).catch(() => "");
+    if (val && val.length > 20) {
+      onStep?.("turnstile_ok", `Cloudflare Turnstile solved (${val.length} chars)`);
+      return { ok: true, length: val.length };
+    }
+    // try click challenge iframe
+    try {
+      for (const frame of page.frames()) {
+        const url = frame.url() || "";
+        if (/turnstile|challenges\.cloudflare/i.test(url)) {
+          await frame.locator("input[type=checkbox], body").first().click({ timeout: 800 }).catch(() => null);
+        }
+      }
+    } catch {
+      // ignore
+    }
+    await wait(1_200);
+  }
+  onStep?.("turnstile_timeout", "Turnstile did not produce a token in time");
+  return { ok: false };
+}
+
+/**
+ * Full xAI email signup using tempmail OTP.
+ */
+export async function runXaiEmailSignup(page, {
+  email,
+  password,
+  firstName,
+  lastName,
+  pollOtp = pollTempmailXaiOtp,
+  onStep,
+} = {}) {
+  // Callers should pass random names; keep mild defaults only as last resort.
+  if (!firstName || !lastName) {
+    const { generateRandomPersonName } = await import("./tempmailClient.js");
+    const n = generateRandomPersonName();
+    firstName = firstName || n.firstName;
+    lastName = lastName || n.lastName;
+  }
+  const report = (step, message) => onStep?.(step, message);
+
+  report("opening_signup", "Opening xAI email sign-up");
+  await page.goto("https://accounts.x.ai/sign-up", { waitUntil: "domcontentloaded", timeout: 60_000 });
+  await wait(1_200);
+  await dismissCookies(page);
+
+  if (await page.getByRole("button", { name: /Sign up with email/i }).count()) {
+    await page.getByRole("button", { name: /Sign up with email/i }).click();
+    await wait(800);
+    report("signup_with_email", "Selected Sign up with email");
+  }
+
+  await page.waitForSelector("input[type=email], input[name=email]", { timeout: 15_000 });
+  await typeSlow(page.locator("input[type=email], input[name=email]").first(), email, 40);
+  await clickFirst(page, ['button:has-text("Sign up")', 'button:has-text("Sign Up")']);
+  report("submitted_email", `Submitted sign-up email ${email}`);
+  await wait(2_000);
+  await dismissCookies(page);
+
+  report("polling_otp", "Polling tempmail for xAI confirmation code");
+  const otp = await pollOtp(email, { timeoutMs: 120_000, intervalMs: 3_000 });
+  if (!otp?.code) {
+    return { status: "failed", step: "otp_timeout", error: "No xAI OTP received on tempmail inbox" };
+  }
+  report("otp_received", `OTP ${otp.code} from ${otp.subject || "tempmail"}`);
+
+  const codeInput = page.locator("input[name=code]");
+  if (await codeInput.isVisible().catch(() => false)) {
+    await typeSlow(codeInput, otp.code, 80);
+    await wait(1_200);
+  }
+
+  // Typing OTP often auto-advances; otherwise Confirm email
+  let text = await pageText(page);
+  if (!/Complete your sign up/i.test(text)) {
+    await clickFirst(page, ['button:has-text("Confirm email")']);
+    await wait(2_000);
+  }
+
+  for (let i = 0; i < 20; i++) {
+    text = await pageText(page);
+    if (/Complete your sign up/i.test(text) || await page.locator("input[name=givenName]").count()) break;
+    await wait(500);
+  }
+
+  if (!await page.locator("input[name=givenName]").first().isVisible().catch(() => false)) {
+    return { status: "failed", step: "profile_form_missing", error: "xAI profile form (givenName) not shown after OTP" };
+  }
+
+  report("filling_profile", "Filling name + password");
+  await typeSlow(page.locator("input[name=givenName]").first(), firstName, 35);
+  await typeSlow(page.locator("input[name=familyName]").first(), lastName, 35);
+  await typeSlow(page.locator("input[name=password], input[type=password]").first(), password, 35);
+
+  const turnstile = await waitForTurnstile(page, { timeoutMs: 60_000, onStep });
+  if (!turnstile.ok) {
+    return {
+      status: "needs_manual",
+      step: "turnstile",
+      error: "Cloudflare Turnstile did not solve. Use CloakBrowser headed engine or complete manually.",
+    };
+  }
+
+  await clickFirst(page, ['button:has-text("Complete sign up")']);
+  report("completing_signup", "Clicked Complete sign up");
+  await wait(4_000);
+
+  // Retry if still on form but turnstile refreshed
+  text = await pageText(page);
+  if (/Complete your sign up/i.test(text)) {
+    await waitForTurnstile(page, { timeoutMs: 20_000, onStep });
+    await clickFirst(page, ['button:has-text("Complete sign up")']);
+    await wait(4_000);
+    text = await pageText(page);
+  }
+
+  const url = page.url();
+  const ok =
+    (!/Complete your sign up|Verify your email|You must provide/i.test(text) && !/\/sign-up/i.test(url))
+    || /\/account/i.test(url)
+    || /Welcome/i.test(text);
+
+  if (!ok) {
+    return {
+      status: "failed",
+      step: "signup_incomplete",
+      error: "xAI sign-up did not complete after profile submit",
+      url,
+      text: text.slice(0, 300),
+    };
+  }
+
+  report("signup_ok", `Account ready: ${email}`);
+  return { status: "success", email, password, url };
+}
+
+/**
+ * Login with email+password (session), then authorize a Grok CLI device code.
+ */
+export async function runXaiEmailDeviceAuthorize(page, {
+  email,
+  password,
+  verificationUrl,
+  pollToken,
+  deviceCode,
+  pollOtp = pollTempmailXaiOtp,
+  onStep,
+  cancelCheck,
+} = {}) {
+  const report = (step, message) => onStep?.(step, message);
+
+  // Ensure session via sign-in if not already on account
+  const cur = page.url();
+  if (!/\/account/i.test(cur)) {
+    report("opening_signin", "Opening xAI email login");
+    await page.goto("https://accounts.x.ai/sign-in", { waitUntil: "domcontentloaded", timeout: 60_000 });
+    await wait(1_000);
+    await dismissCookies(page);
+
+    if (await page.getByRole("button", { name: /Login with email/i }).count()) {
+      await page.getByRole("button", { name: /Login with email/i }).click();
+      await wait(800);
+    }
+
+    if (await page.locator("input[type=email]").first().isVisible().catch(() => false)) {
+      await typeSlow(page.locator("input[type=email]").first(), email, 40);
+      await clickFirst(page, ['button:has-text("Next")', 'button:has-text("Continue")']);
+      await wait(1_500);
+    }
+    if (await page.locator("input[type=password]").first().isVisible().catch(() => false)) {
+      await typeSlow(page.locator("input[type=password]").first(), password, 40);
+      await waitForTurnstile(page, { timeoutMs: 45_000, onStep });
+      await clickFirst(page, ['button:has-text("Login")', 'button:has-text("Log in")']);
+      await wait(3_000);
+    }
+
+    let text = await pageText(page);
+    if (/security code|Verify your email|one time/i.test(text)) {
+      report("login_otp", "Login requires OTP — polling tempmail");
+      const otp = await pollOtp(email, { timeoutMs: 90_000 });
+      if (otp?.code) {
+        await typeSlow(page.locator("input[name=code]").first(), otp.code, 80);
+        await clickFirst(page, ['button:has-text("Confirm email")', 'button:has-text("Continue")']);
+        await wait(2_500);
+      }
+    }
+  }
+
+  report("opening_device", "Opening Grok Build device authorization");
+  await page.goto(verificationUrl, { waitUntil: "domcontentloaded", timeout: 60_000 });
+  await wait(1_200);
+  await dismissCookies(page);
+  await clickFirst(page, ['button:has-text("Continue")']);
+  await wait(2_000);
+
+  // If bounced to login again, do email login on this page
+  if (await page.getByRole("button", { name: /Login with email/i }).count()) {
+    await page.getByRole("button", { name: /Login with email/i }).click();
+    await wait(800);
+    if (await page.locator("input[type=email]").first().isVisible().catch(() => false)) {
+      await typeSlow(page.locator("input[type=email]").first(), email, 40);
+      await clickFirst(page, ['button:has-text("Next")']);
+      await wait(1_200);
+    }
+    if (await page.locator("input[type=password]").first().isVisible().catch(() => false)) {
+      await typeSlow(page.locator("input[type=password]").first(), password, 40);
+      await waitForTurnstile(page, { timeoutMs: 45_000, onStep });
+      await clickFirst(page, ['button:has-text("Login")', 'button:has-text("Log in")']);
+      await wait(3_000);
+    }
+    // re-open device after login
+    await page.goto(verificationUrl, { waitUntil: "domcontentloaded", timeout: 60_000 });
+    await wait(1_200);
+    await clickFirst(page, ['button:has-text("Continue")']);
+    await wait(2_000);
+  }
+
+  const pollPromise = (async () => {
+    const start = Date.now();
+    let interval = 5_000;
+    while (Date.now() - start < 15 * 60_000) {
+      if (cancelCheck?.()) throw new Error("Job cancelled during token polling");
+      const result = await pollToken(deviceCode);
+      if (result?.success && result.tokens) return { tokens: result.tokens };
+      if (result?.pending || result?.error === "authorization_pending") {
+        await wait(interval);
+        continue;
+      }
+      if (result?.error === "slow_down") {
+        interval = Math.min(interval + 5_000, 30_000);
+        await wait(interval);
+        continue;
+      }
+      if (result?.error && !["authorization_pending", "slow_down"].includes(result.error)) {
+        // keep polling a bit — page may still authorize
+        await wait(interval);
+        continue;
+      }
+      await wait(interval);
+    }
+    throw new Error("Timed out waiting for Grok CLI OAuth token");
+  })();
+
+  // UI authorize loop in parallel with poll
+  const uiLoop = (async () => {
+    for (let i = 0; i < 20; i++) {
+      if (cancelCheck?.()) return;
+      const text = await pageText(page);
+      if (/Device Authorized|device has been authorized|you can close/i.test(text)) {
+        report("device_authorized", "Device authorized in browser");
+        return;
+      }
+      // signed-in consent
+      if (/Authorize Grok Build|Verify your identity|Confirm your identity/i.test(text)) {
+        await clickFirst(page, [
+          'button:has-text("Allow")',
+          'button:has-text("Authorize")',
+          'button:has-text("Approve")',
+          'button:has-text("Continue")',
+          'button:has-text("Confirm")',
+        ]);
+        await wait(1_500);
+        continue;
+      }
+      if (/Redirecting/i.test(text) || /\/account/i.test(page.url())) {
+        await page.goto(verificationUrl, { waitUntil: "domcontentloaded", timeout: 60_000 });
+        await wait(1_500);
+        await clickFirst(page, ['button:has-text("Continue")']);
+        await wait(1_500);
+        continue;
+      }
+      await clickFirst(page, [
+        'button:has-text("Continue")',
+        'button:has-text("Allow")',
+        'button:has-text("Authorize")',
+      ]);
+      await wait(1_500);
+    }
+  })();
+
+  report("polling_token", "Waiting for device token after authorization");
+  const [tokenResult] = await Promise.all([
+    pollPromise,
+    uiLoop.catch(() => null),
+  ]);
+
+  return { status: "success", tokens: tokenResult.tokens };
+}

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

@@ -222,6 +222,8 @@ const MANUAL_ASSIST_MARKERS = [
   "unusual activity detected",
   "captcha",
   "try again later",
+  "browser or app may not be secure",
+  "try using a different browser",
 ];
 
 const RESTRICTED_ACCOUNT_MARKERS = [
@@ -494,10 +496,12 @@ function isGoogleAuthPage(page) {
 
 // Google bounces flagged (headless) browsers to myaccount.google.com/not-supported
 // at the OAuth consent step; from there the page often drifts to about.google.
+// Newer flows use /v3/signin/rejected with "This browser or app may not be secure".
 function isBlockedBrowserPage(page) {
   try {
     const url = new URL(page.url());
     if (url.pathname.startsWith("/not-supported")) return true;
+    if (url.pathname.includes("/signin/rejected")) return true;
     return url.hostname === "about.google" || url.hostname.endsWith(".about.google");
   } catch {
     return false;

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

@@ -0,0 +1,160 @@
+/**
+ * Client for self-hosted tempmail (tempmail.zevai.web.id).
+ * Inbox-only: create address, poll OTP. No passwords stored server-side.
+ */
+
+const DEFAULT_BASE_URL = process.env.TEMPMAIL_BASE_URL || "https://tempmail.zevai.web.id";
+const DEFAULT_DOMAIN = process.env.TEMPMAIL_EMAIL_DOMAIN || "zevai.web.id";
+const DEFAULT_UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function getTempmailConfig(overrides = {}) {
+  return {
+    baseUrl: String(overrides.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, ""),
+    domain: String(overrides.domain || DEFAULT_DOMAIN).replace(/^@/, ""),
+    userAgent: overrides.userAgent || DEFAULT_UA,
+  };
+}
+
+async function tempmailFetch(config, path, { method = "GET", body } = {}) {
+  const url = `${config.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      Accept: "application/json",
+      "User-Agent": config.userAgent,
+      ...(body ? { "Content-Type": "application/json" } : {}),
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = { raw: text };
+  }
+  if (!res.ok) {
+    const err = new Error(data?.error || `Tempmail HTTP ${res.status}`);
+    err.status = res.status;
+    err.payload = data;
+    throw err;
+  }
+  return data;
+}
+
+export function generateTempmailLocalPart(prefix = "zevai") {
+  const rand = Math.random().toString(36).slice(2, 8);
+  const ts = Date.now().toString(36).slice(-4);
+  return `${prefix}-${ts}${rand}`.toLowerCase().replace(/[^a-z0-9._+-]/g, "");
+}
+
+export function generateTempmailPassword() {
+  const core = Math.random().toString(36).slice(2, 10);
+  return `Zv!${core}Aa1`;
+}
+
+const FIRST_NAMES = [
+  "James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph",
+  "Thomas", "Charles", "Christopher", "Daniel", "Matthew", "Anthony", "Mark",
+  "Steven", "Paul", "Andrew", "Joshua", "Kenneth", "Kevin", "Brian", "George",
+  "Timothy", "Ronald", "Edward", "Jason", "Jeffrey", "Ryan", "Jacob",
+  "Mary", "Patricia", "Jennifer", "Linda", "Barbara", "Elizabeth", "Susan",
+  "Jessica", "Sarah", "Karen", "Lisa", "Nancy", "Betty", "Margaret", "Sandra",
+  "Ashley", "Dorothy", "Kimberly", "Emily", "Donna", "Michelle", "Carol",
+  "Amanda", "Melissa", "Deborah", "Stephanie", "Rebecca", "Sharon", "Laura",
+  "Emma", "Olivia", "Ava", "Sophia", "Isabella", "Mia", "Charlotte", "Amelia",
+  "Noah", "Liam", "Oliver", "Elijah", "Lucas", "Mason", "Logan", "Ethan",
+];
+
+const LAST_NAMES = [
+  "Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis",
+  "Rodriguez", "Martinez", "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson",
+  "Thomas", "Taylor", "Moore", "Jackson", "Martin", "Lee", "Perez", "Thompson",
+  "White", "Harris", "Sanchez", "Clark", "Ramirez", "Lewis", "Robinson",
+  "Walker", "Young", "Allen", "King", "Wright", "Scott", "Torres", "Nguyen",
+  "Hill", "Flores", "Green", "Adams", "Nelson", "Baker", "Hall", "Rivera",
+  "Campbell", "Mitchell", "Carter", "Roberts", "Turner", "Phillips", "Parker",
+  "Evans", "Edwards", "Collins", "Stewart", "Morris", "Murphy", "Cook",
+];
+
+function pick(list) {
+  return list[Math.floor(Math.random() * list.length)];
+}
+
+/** Random human-looking first/last name for xAI signup profile. */
+export function generateRandomPersonName() {
+  return {
+    firstName: pick(FIRST_NAMES),
+    lastName: pick(LAST_NAMES),
+  };
+}
+
+export async function registerTempmailAddress(address, { label = null, ...cfg } = {}) {
+  const config = getTempmailConfig(cfg);
+  return tempmailFetch(config, "/api/addresses", {
+    method: "POST",
+    body: { address, label: label || "grok-cli-bulk" },
+  });
+}
+
+export async function createTempmailMailbox({ prefix = "zevai-cb", label = "grok-cli-bulk", ...cfg } = {}) {
+  const config = getTempmailConfig(cfg);
+  const local = generateTempmailLocalPart(prefix);
+  const address = `${local}@${config.domain}`;
+  await registerTempmailAddress(address, { label, ...config });
+  return { address, domain: config.domain };
+}
+
+export async function listTempmailInbox(address, cfg = {}) {
+  const config = getTempmailConfig(cfg);
+  const enc = encodeURIComponent(address);
+  const data = await tempmailFetch(config, `/api/inbox/${enc}`);
+  return Array.isArray(data) ? data : [];
+}
+
+/**
+ * Poll inbox for xAI OTP. Subject format: "ABC-123 xAI confirmation code"
+ */
+export async function pollTempmailXaiOtp(
+  address,
+  {
+    timeoutMs = 120_000,
+    intervalMs = 3_000,
+    seenIds = null,
+    ...cfg
+  } = {}
+) {
+  const seen = seenIds || new Set();
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const mails = await listTempmailInbox(address, cfg);
+    const sorted = [...mails].sort((a, b) => (b.received_at || 0) - (a.received_at || 0));
+    for (const mail of sorted) {
+      const id = mail.id || `${mail.subject}-${mail.received_at}`;
+      if (seen.has(id)) continue;
+      const subject = mail.subject || "";
+      const match = subject.match(/([A-Z0-9]{2,5}-[A-Z0-9]{2,5})\s+xAI confirmation code/i);
+      if (match) {
+        seen.add(id);
+        return {
+          code: match[1],
+          subject,
+          id: mail.id || null,
+          mail,
+        };
+      }
+    }
+    await wait(intervalMs);
+  }
+  return null;
+}
+
+export {
+  DEFAULT_BASE_URL as TEMPMAIL_DEFAULT_BASE_URL,
+  DEFAULT_DOMAIN as TEMPMAIL_DEFAULT_DOMAIN,
+};

package/src/shared/components/BulkAccountAutomationModal.js

@@ -16,6 +16,7 @@ const DEFAULT_ENGINE = "chromium";
 const ENGINE_OPTIONS = [
   { value: "chromium", label: "Chromium (default, fast)" },
   { value: "camoufox", label: "Camoufox (stealth Firefox, slower)" },
+  { value: "cloakbrowser", label: "CloakBrowser (Turnstile / xAI email)" },
 ];
 
 function formatStepLabel(value) {
@@ -68,6 +69,8 @@ export default function BulkAccountAutomationModal({
   provider,
   title,
   serviceName,
+  defaultEngine = DEFAULT_ENGINE,
+  accountsPlaceholder,
 }) {
   const storageKey = `${provider}-bulk-import-active-job`;
   const draftKey = `${provider}-bulk-import-accounts-draft`;
@@ -89,7 +92,7 @@ export default function BulkAccountAutomationModal({
   }, [draftKey]);
   const [concurrency, setConcurrency] = useState(String(DEFAULT_CONCURRENCY));
   const [autoConcurrency, setAutoConcurrency] = useState(true);
-  const [engine, setEngine] = useState(DEFAULT_ENGINE);
+  const [engine, setEngine] = useState(defaultEngine || DEFAULT_ENGINE);
   const [proxyPoolSelection, setProxyPoolSelection] = useState("");
   const [proxyPools, setProxyPools] = useState([]);
   const [activeJob, setActiveJob] = useState(null);
@@ -148,7 +151,7 @@ export default function BulkAccountAutomationModal({
     setBulkText("");
     setConcurrency(String(DEFAULT_CONCURRENCY));
     setAutoConcurrency(true);
-    setEngine(DEFAULT_ENGINE);
+    setEngine(defaultEngine || DEFAULT_ENGINE);
     setProxyPoolSelection("");
     setActiveJob(null);
     setError(null);
@@ -157,7 +160,11 @@ export default function BulkAccountAutomationModal({
     if (typeof window !== "undefined") {
       window.localStorage.removeItem(storageKey);
     }
-  }, [storageKey]);
+  }, [storageKey, defaultEngine]);
+
+  useEffect(() => {
+    setEngine(defaultEngine || DEFAULT_ENGINE);
+  }, [defaultEngine, provider]);
 
   useEffect(() => {
     if (!isOpen) return;
@@ -344,7 +351,7 @@ export default function BulkAccountAutomationModal({
               <textarea
                 value={bulkText}
                 onChange={(event) => setBulkText(event.target.value)}
-                placeholder={"gmail1@example.com|password1\ngmail2@example.com|password2"}
+                placeholder={accountsPlaceholder || "gmail1@example.com|password1\ngmail2@example.com|password2"}
                 className="min-h-[180px] w-full resize-y rounded-lg border border-border bg-background px-3 py-2 font-mono text-sm focus:outline-none focus:ring-1 focus:ring-primary"
               />
               <p className="mt-1 text-xs text-text-muted">
@@ -642,4 +649,6 @@ BulkAccountAutomationModal.propTypes = {
   provider: PropTypes.string.isRequired,
   title: PropTypes.string.isRequired,
   serviceName: PropTypes.string.isRequired,
+  defaultEngine: PropTypes.string,
+  accountsPlaceholder: PropTypes.string,
 };