@gelglx/grok-builder-cli 1.0.0

package/.env.example

@@ -0,0 +1,11 @@
+# ── Grok Builder CLI ──────────────────────────────────
+# Password for Grok accounts (min 16 chars, mix cases+digits+symbols)
+PASSWORD=YourSecurePassword123!@
+
+# ── Temp Mail (CloakMail / glx.web.id) ───────────────
+MAIL_URL=https://glx.web.id
+MAIL_DOMAIN=glx.web.id
+
+# ── 9router Gateway ───────────────────────────────────
+ROUTER9_URL=http://localhost:20128
+ROUTER9_PASS=123456

package/README.md

@@ -0,0 +1,69 @@
+# 🚀 Grok Builder CLI
+
+**Auto-register Grok (x.ai) accounts — multi-threaded, with 9router integration**
+
+```bash
+npx @gelglx/grok-builder-cli
+```
+
+## Features
+
+- ✨ **Auto-register** Grok (x.ai) accounts via Playwright
+- 📧 **Temp mail** via CloakMail (glx.web.id) — no external API needed
+- 🛡️ **Turnstile bypass** — Chrome extension patches Cloudflare detection
+- 🔗 **9router OAuth** — auto-add accounts as Grok CLI providers
+- ⚡ **Multi-threaded** — parallel workers for batch registration
+- 🎨 **Beautiful CLI** — progress bars, spinners, live stats
+
+## Quick Start
+
+```bash
+# Set password (min 16 chars)
+export PASSWORD='MySecurePass123!@'
+
+# Run interactive CLI
+npx @gelglx/grok-builder-cli
+```
+
+Or install globally:
+
+```bash
+npm install -g @gelglx/grok-builder-cli
+grok-builder
+```
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PASSWORD` | *(required)* | Password for Grok accounts (min 16 chars) |
+| `MAIL_URL` | `https://glx.web.id` | Temp mail base URL |
+| `MAIL_DOMAIN` | `glx.web.id` | Temp mail domain |
+| `ROUTER9_URL` | `http://localhost:20128` | 9router gateway URL |
+| `ROUTER9_PASS` | `123456` | 9router dashboard password |
+
+## Requirements
+
+- Node.js 18+
+- Xvfb (Linux) — for headless browser display
+- Google Chrome or Chromium installed
+
+## How It Works
+
+```
+┌──────────────────────────────────────────┐
+│  1. Create temp email (glx.web.id)       │
+│  2. Open accounts.x.ai/sign-up           │
+│  3. Enter email → wait for OTP           │
+│  4. Extract code from mail inbox         │
+│  5. Fill name + password                 │
+│  6. Turnstile auto-solve                 │
+│  7. Submit → redirect to grok.com        │
+│  8. Save SSO cookies                     │
+│  9. (optional) OAuth device flow → 9R    │
+└──────────────────────────────────────────┘
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@gelglx/grok-builder-cli",
+  "version": "1.0.0",
+  "description": "Auto-register Grok (x.ai) accounts with temp mail (CloakMail/glx.web.id) and auto-integrate into 9router — multi-threaded CLI",
+  "main": "src/index.js",
+  "bin": {
+    "grok-builder": "./src/index.js"
+  },
+  "files": [
+    "src/",
+    "turnstilePatch/",
+    ".env.example",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "keywords": [
+    "grok",
+    "xai",
+    "x.ai",
+    "signup",
+    "registration",
+    "9router",
+    "temp-mail",
+    "cloakmail",
+    "playwright"
+  ],
+  "author": "gelglx",
+  "license": "MIT",
+  "dependencies": {
+    "playwright": "^1.60.0",
+    "chalk": "^5.4.0",
+    "ora": "^8.1.0",
+    "cli-progress": "^3.12.0",
+    "uuid": "^11.0.0"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+// GrokBuilderCLI — Auto-register Grok (x.ai) accounts + 9router integration
+// Multi-threaded, interactive CLI
+
+import { chromium } from 'playwright';
+import chalk from 'chalk';
+import ora from 'ora';
+import cliProgress from 'cli-progress';
+import * as readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+
+import { runOneSignup, getTurnstilePath } from './signup.js';
+import { login as loginRouter9 } from './router9.js';
+
+// ── ANSI helpers ──────────────────────────────────────────────
+const { bold, dim, green, red, yellow, cyan, magenta } = chalk;
+const BAR_W = 74;
+
+function barLine(color = cyan) {
+  console.log(color('─'.repeat(BAR_W)));
+}
+
+function header(text) {
+  console.log(`\n${cyan(` ─── [ ${text} ] `)}${cyan('─'.repeat(Math.max(0, BAR_W - text.length - 8)))}`);
+}
+
+function row(num, email, status, elapsed, extra = '') {
+  const e = (email || '—').padEnd(36).slice(0, 36);
+  const s = status.padEnd(10);
+  const t = elapsed ? dim(`${elapsed}s`) : '';
+  console.log(`  ${dim(String(num).padStart(3))} ${cyan('│')} ${e} ${s} ${t} ${extra}`);
+}
+
+// ── Interactive prompt ───────────────────────────────────────
+const rl = readline.createInterface({ input, output });
+
+async function ask(q, defaultVal) {
+  const answer = await rl.question(`${cyan('?')} ${bold(q)} ${defaultVal ? dim(`(${defaultVal}) `) : ''}`);
+  return answer.trim() || defaultVal;
+}
+
+function closePrompt() {
+  rl.close();
+}
+
+// ── Main ──────────────────────────────────────────────────────
+async function main() {
+  console.clear();
+  console.log(`\n${cyan('╔' + '═'.repeat(BAR_W - 2) + '╗')}`);
+  console.log(`${cyan('║')}  ${bold('🚀  Grok Builder CLI')}  ${dim('v1.0.0')}${' '.repeat(Math.max(0, BAR_W - 37))}${cyan('║')}`);
+  console.log(`${cyan('║')}  ${dim('Auto-register Grok (x.ai) + 9router integration')}${' '.repeat(10)}${cyan('║')}`);
+  console.log(`${cyan('╚' + '═'.repeat(BAR_W - 2) + '╝')}\n`);
+
+  // ── Config checks ───────────────────────────────────────────
+  const checks = [
+    { label: 'PASSWORD   ', ok: !!process.env.PASSWORD, msg: 'env PASSWORD set' },
+    { label: 'MAIL_URL   ', ok: true, msg: process.env.MAIL_URL || 'https://glx.web.id (default)' },
+    { label: 'ROUTER9_URL', ok: true, msg: process.env.ROUTER9_URL || 'http://localhost:20128 (default)' },
+  ];
+
+  console.log(`  ${dim('Config:')}`);
+  for (const c of checks) {
+    const icon = c.ok ? green('✓') : red('✗');
+    console.log(`    ${icon} ${dim(c.label)} ${c.msg}`);
+  }
+
+  if (!process.env.PASSWORD) {
+    console.log(`\n  ${yellow('⚠')}  ${dim('Set PASSWORD in environment or .env file')}`);
+    console.log(`  ${dim('   Example:')} PASSWORD='MySecurePass123!@' grok-builder`);
+  }
+
+  // ── Interactive questions ───────────────────────────────────
+  console.log();
+  const countStr = await ask('How many accounts to create?', '5');
+  const count = parseInt(countStr) || 5;
+
+  const threadsStr = await ask('How many parallel threads?', '2');
+  const threads = parseInt(threadsStr) || 2;
+
+  const addRouter = (await ask('Auto-add to 9router?', 'y')).toLowerCase() === 'y';
+
+  let routerOk = false;
+  if (addRouter) {
+    try {
+      await loginRouter9();
+      routerOk = true;
+      console.log(`  ${green('✓')} ${dim('9router login OK')}`);
+    } catch (err) {
+      console.log(`  ${red('✗')} ${dim(`9router login: ${err.message}`)}`);
+    }
+  }
+
+  closePrompt();
+
+  // ── Start ───────────────────────────────────────────────────
+  console.log();
+  header(`GROK BUILDER  |  ${count} accounts × ${threads} threads`);
+  barLine();
+
+  const tStart = Date.now();
+  const results = [];
+  let succeeded = 0, failed = 0;
+  let active = 0; // track concurrent
+
+  // Multi-progress bar
+  const multibar = new cliProgress.MultiBar({
+    clearOnComplete: false,
+    hideCursor: true,
+    format: `  ${cyan('│')} {bar} | {percentage}% | {value}/{total} accounts | {duration_formatted}`,
+    barCompleteChar: '■',
+    barIncompleteChar: '□',
+    barsize: 32,
+  }, cliProgress.Presets.shades_classic);
+
+  const progressBar = multibar.create(count, 0);
+
+  // ── Launch persistent browser with turnstile patch ──────────
+  const extPath = getTurnstilePath();
+  console.log(`  ${dim('Turnstile patch:')} ${extPath}\n`);
+
+  // We'll use one shared browser for all contexts
+  const browser = await chromium.launch({
+    headless: false,
+    args: [
+      '--no-sandbox',
+      '--disable-dev-shm-usage',
+      '--disable-blink-features=AutomationControlled',
+      `--disable-extensions-except=${extPath}`,
+      `--load-extension=${extPath}`,
+    ],
+  });
+
+  // ── Worker pool ─────────────────────────────────────────────
+  async function worker(taskIndex) {
+    const context = await browser.newContext({
+      viewport: { width: 1280, height: 1024 },
+      ignoreHTTPSErrors: true,
+    });
+    try {
+      const account = await runOneSignup({
+        context,
+        addToRouter: addRouter && routerOk,
+      });
+      results.push(account);
+      succeeded++;
+      const elapsed = account.elapsed || ((Date.now() - tStart) / 1000).toFixed(1);
+      row(succeeded, account.email, green('SUCCESS'), elapsed);
+    } catch (err) {
+      failed++;
+      row(count - failed + 1, '—failed—', red('FAILED'), '', dim(err.message));
+    } finally {
+      await context.close();
+      progressBar.increment();
+      active--;
+    }
+  }
+
+  // ── Queue processor ─────────────────────────────────────────
+  let idx = 0;
+  async function processQueue() {
+    while (idx < count) {
+      if (active < threads) {
+        active++;
+        const taskIdx = idx++;
+        worker(taskIdx); // fire and forget — we track via active counter
+      }
+      await sleep(100); // small tick
+    }
+    // Wait for remaining workers
+    while (active > 0) {
+      await sleep(200);
+    }
+  }
+
+  await processQueue();
+  multibar.stop();
+
+  // ── Final report ────────────────────────────────────────────
+  console.log();
+  header('SYSTEM LOGS');
+  for (const r of results) {
+    const icon = r.router9 === 'added' ? green('→9R') : r.router9 ? red(`→${r.router9}`) : dim('—');
+    console.log(`  ${green('DONE')} ${dim(`[${r.email}]`)} ${green('✓')} ${r.elapsed}s  ${icon}`);
+  }
+  barLine();
+
+  const tElapsed = ((Date.now() - tStart) / 1000).toFixed(1);
+  const rate = succeeded / (tElapsed / 60);
+  const health = count > 0 ? (succeeded / count * 100).toFixed(1) : '0';
+
+  console.log(`\n ${dim('[Summary]')}`);
+  console.log(`  ${green('✓')} ${succeeded} success  ${red('✗')} ${failed} failed  ${dim(`(${tElapsed}s, ${rate.toFixed(1)}/min)`)}`);
+  console.log(`  Health: ${health}%  |  Speed: ${rate.toFixed(1)}/m`);
+  console.log();
+
+  // ── Save results ────────────────────────────────────────────
+  const fs = await import('fs');
+  const outPath = 'grok-accounts.json';
+  fs.writeFileSync(outPath, JSON.stringify(results, null, 2));
+  console.log(`  ${dim('Saved:')} ${outPath} (${results.length} accounts)`);
+
+  await browser.close();
+  process.exit(0);
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+main().catch(err => {
+  console.error(`\n${red('FATAL:')} ${err.message}`);
+  process.exit(1);
+});

package/src/mail.js

@@ -0,0 +1,99 @@
+// glx.web.id (CloakMail) temp email client
+// API: SvelteKit __data.json + SSR page parsing
+
+import { randomBytes } from 'crypto';
+
+const MAIL_BASE = process.env.MAIL_URL || 'https://glx.web.id';
+const MAIL_DOMAIN = process.env.MAIL_DOMAIN || 'glx.web.id';
+
+function randomLocal() {
+  const chars = 'abcdefghijklmnopqrstuvwxyz';
+  let s = '';
+  for (let i = 0; i < 8; i++) s += chars[randomBytes(1)[0] % 26];
+  const num = String(Date.now()).slice(-6);
+  return s + num;
+}
+
+export async function createTempEmail() {
+  const local = randomLocal();
+  const addr = `${local}@${MAIL_DOMAIN}`;
+  const url = `${MAIL_BASE}/confirm/${encodeURIComponent(addr)}/__data.json?x-sveltekit-invalidated=01`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Mail confirm failed: ${res.status}`);
+  return addr;
+}
+
+/**
+ * Fetch emails from glx.web.id inbox using __data.json endpoint
+ * Returns array of {id, to, from, subject, text, html, receivedAt}
+ */
+export async function fetchEmails(addr) {
+  const url = `${MAIL_BASE}/inbox/${encodeURIComponent(addr)}/__data.json?x-sveltekit-invalidated=01`;
+  const res = await fetch(url, {
+    headers: { Accept: 'application/json' }
+  });
+  if (!res.ok) throw new Error(`Inbox fetch failed: ${res.status}`);
+  const json = await res.json();
+
+  // Parse SvelteKit __data.json format
+  for (const node of json.nodes || []) {
+    if (node?.type === 'data') {
+      const data = node.data;
+      // data = [address_string, emails_array, pagination_object]
+      if (Array.isArray(data)) {
+        if (data.length >= 2 && Array.isArray(data[1])) return data[1];
+        if (data.length >= 3 && Array.isArray(data[2])) return data[2];
+      }
+      // alternative: data = {address, emails, pagination}
+      if (data?.emails && Array.isArray(data.emails)) return data.emails;
+    }
+  }
+
+  // Fallback: try parsing from page data at top level
+  if (json?.data?.emails) return json.data.emails;
+  return [];
+}
+
+/**
+ * Extract OTP code from email subject/text/html
+ * Returns 6-char code (without hyphen)
+ */
+export function extractOTP(subject, text, html) {
+  const sources = [subject || '', text || '', html || ''];
+  for (const src of sources) {
+    // Pattern 1: "confirmation code: XXX-XXX"
+    let m = src.match(/confirmation code:\s*([A-Z0-9]{3}-[A-Z0-9]{3})/i);
+    if (m) return m[1].replace('-', '');
+    // Pattern 2: "code: XXX-XXX" or "code: XXXXXX"
+    m = src.match(/code:\s*([A-Z0-9]{3}-[A-Z0-9]{3})/i);
+    if (m) return m[1].replace('-', '');
+    m = src.match(/code[:\s]\s*([A-Z0-9]{6})/i);
+    if (m) return m[1];
+    // Pattern 3: inline HTML like >DQC-UR9<
+    m = src.match(/>([A-Z0-9]{3}-[A-Z0-9]{3})</);
+    if (m) return m[1].replace('-', '');
+    m = src.match(/>([A-Z0-9]{6})</);
+    if (m) return m[1];
+  }
+  return null;
+}
+
+/**
+ * Poll mailbox for OTP code (poll every 3s, timeout ms)
+ */
+export async function waitForOTP(addr, timeout = 120000) {
+  const started = Date.now();
+  while (Date.now() - started < timeout) {
+    const emails = await fetchEmails(addr);
+    for (const email of emails) {
+      const code = extractOTP(email.subject, email.text, email.html);
+      if (code) return { code, email };
+    }
+    await sleep(3000);
+  }
+  throw new Error(`OTP timeout after ${timeout / 1000}s`);
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}

package/src/router9.js

@@ -0,0 +1,118 @@
+// 9router OAuth Device Flow integration
+import { randomBytes } from 'crypto';
+
+const ROUTER9_URL = process.env.ROUTER9_URL || 'http://localhost:20128';
+const ROUTER9_PASS = process.env.ROUTER9_PASS || '123456';
+
+let _authToken = null;
+
+async function api(method, path, body) {
+  const headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
+  const opts = { method, headers };
+  if (_authToken) headers.Cookie = `auth_token=${_authToken}`;
+  if (body) opts.body = JSON.stringify(body);
+
+  const res = await fetch(`${ROUTER9_URL}${path}`, opts);
+
+  // Handle Set-Cookie for auth
+  const setCookie = res.headers.get('set-cookie');
+  if (setCookie) {
+    const m = setCookie.match(/auth_token=([^;]+)/);
+    if (m) _authToken = m[1];
+  }
+  return res.json();
+}
+
+export async function login() {
+  const r = await api('POST', '/api/auth/login', { password: ROUTER9_PASS });
+  if (!r.success) throw new Error(`9router login failed: ${r.error || 'unknown'}`);
+  return true;
+}
+
+export async function requestDeviceCode() {
+  const r = await api('GET', '/api/oauth/grok-cli/device-code');
+  if (r.error) throw new Error(`Device code failed: ${r.error}`);
+  return r;
+}
+
+export async function pollDevice(deviceCode, codeVerifier) {
+  const r = await api('POST', '/api/oauth/grok-cli/poll', {
+    deviceCode,
+    codeVerifier
+  });
+  return r;
+}
+
+export async function listGrokProviders() {
+  const r = await api('GET', '/api/providers');
+  const conns = r.connections || [];
+  return conns.filter(c => c.provider === 'grok-cli');
+}
+
+/**
+ * Complete OAuth device flow via browser context (Playwright page)
+ * Returns {success, connection} after polling
+ */
+export async function doDeviceFlow(page, cookies, { deviceCode, codeVerifier, userCode, verificationUriComplete }) {
+  // Inject SSO cookies
+  if (cookies && cookies.length > 0) {
+    const pwCookies = cookies.map(c => ({
+      ...c,
+      sameSite: ['Strict', 'Lax', 'None'].includes(c.sameSite) ? c.sameSite : 'Lax'
+    }));
+    try { await page.context().clearCookies(); } catch {}
+    await page.context().addCookies(pwCookies);
+  }
+
+  // Open verification URL
+  await page.goto(verificationUriComplete, { waitUntil: 'domcontentloaded', timeout: 45000 });
+  await sleep(3000);
+
+  // Check if SSO expired (login page shown)
+  const hasLoginInput = await page.evaluate(
+    () => !!document.querySelector('input[type=email], input[type=password]')
+  );
+  if (hasLoginInput) {
+    throw new Error('SSO expired — login required');
+  }
+
+  // Click "Continue" button
+  try {
+    await page.getByRole('button', { name: /continue/i, exact: false }).click({ timeout: 5000 });
+    await sleep(2500);
+  } catch {
+    // May already be on consent page
+  }
+
+  // Click "Allow" / "Allow All" on consent page
+  try {
+    await page.getByRole('button', { name: /^Allow$/i, exact: true }).click({ timeout: 8000 });
+  } catch {
+    try {
+      await page.getByRole('button', { name: /Allow All/i, exact: true }).click({ timeout: 3000 });
+    } catch {
+      try {
+        await page.getByRole('button', { name: /allow/i, exact: false }).click({ timeout: 3000 });
+      } catch {
+        throw new Error('Allow button not found on consent page');
+      }
+    }
+  }
+
+  await sleep(3000);
+
+  // Poll until success (max 60 tries = 5 min)
+  for (let i = 0; i < 60; i++) {
+    const res = await pollDevice(deviceCode, codeVerifier);
+    if (res.success) return res;
+    if (res.pending !== true) {
+      throw new Error(`Poll error: ${res.error || 'unknown'}`);
+    }
+    await sleep(5000);
+  }
+  throw new Error('Poll timeout after 5 minutes');
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}

package/src/signup.js

@@ -0,0 +1,165 @@
+// x.ai signup flow — Playwright automation
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createTempEmail, waitForOTP } from './mail.js';
+import * as r9 from './router9.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TS_EXT = path.resolve(__dirname, '..', 'turnstilePatch');
+const SIGNUP_URL = 'https://accounts.x.ai/sign-up?redirect=grok-com';
+
+const PASSWORD = process.env.PASSWORD || 'GrokBuilder2024!Secure';
+
+/**
+ * Run one signup flow + optional 9router addition
+ * @param {object} opts
+ * @param {import('playwright').BrowserContext} opts.context
+ * @param {boolean} opts.addToRouter
+ * @returns {Promise<object>} account data
+ */
+export async function runOneSignup({ context, addToRouter = false }) {
+  const page = await context.newPage();
+  const startTime = Date.now();
+
+  try {
+    // Set extra headers
+    await page.setExtraHTTPHeaders({
+      'sec-ch-ua': '"Chromium";v="128", "Google Chrome";v="128", "Not-A.Brand";v="99"',
+      'sec-ch-ua-mobile': '?0',
+      'sec-ch-ua-platform': '"Linux"',
+      'accept-language': 'en-US,en;q=0.9',
+    });
+
+    // Step 1: Open x.ai signup
+    await page.goto(SIGNUP_URL, { waitUntil: 'domcontentloaded', timeout: 45000 });
+    await sleep(3000);
+    try { await page.getByRole('button', { name: /Accept All Cookies/i }).click({ timeout: 3000 }); } catch {}
+    await sleep(500);
+
+    // Step 2: Click "Sign up with email"
+    await page.getByText('Sign up with email').click({ timeout: 8000 });
+    await page.waitForSelector('input[type=email]', { timeout: 8000 });
+
+    // Step 3: Create temp email
+    const addr = await createTempEmail();
+    await page.locator('input[type=email]').fill(addr);
+    await page.locator('input[type=email]').press('Enter');
+
+    // Wait for code input to appear
+    try {
+      await page.waitForSelector('input[name=code]', { timeout: 20000 });
+    } catch {
+      try {
+        await page.getByRole('button', { name: /Sign up/i }).click({ timeout: 3000 });
+        await page.waitForSelector('input[name=code]', { timeout: 15000 });
+      } catch {
+        throw new Error('Could not reach OTP input');
+      }
+    }
+
+    // Step 4: Wait for OTP
+    const { code } = await waitForOTP(addr, 120000);
+
+    // Step 5: Submit OTP
+    await page.locator('input[name=code]').first().fill(code, { timeout: 15000 });
+    await sleep(500);
+    await page.keyboard.press('Enter');
+    await page.waitForSelector('input[name=givenName]', { timeout: 20000 });
+
+    // Step 6: Fill name & password
+    const local = addr.split('@')[0];
+    const parts = local.split(/[._\-]/);
+    const givenName = parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
+    const familyName = (parts[1] || 'Xyz').charAt(0).toUpperCase() + (parts[1] || 'Xyz').slice(1);
+
+    await page.locator('input[name=givenName]').fill(givenName);
+    await page.locator('input[name=familyName]').fill(familyName);
+    await page.locator('input[name=password]').fill(PASSWORD);
+
+    // Step 7: Solve turnstile & submit
+    let tok = '';
+    for (let i = 0; i < 40; i++) {
+      tok = await page.evaluate(
+        () => document.querySelector('input[name=cf-turnstile-response]')?.value || ''
+      );
+      if (tok) break;
+      await sleep(1000);
+    }
+    if (!tok) throw new Error('Turnstile timeout 40s');
+
+    await page.getByRole('button', { name: /Complete sign up/i }).click();
+    await sleep(1000);
+
+    // Step 8: Wait for redirect to grok.com
+    let redirected = false;
+    for (let i = 0; i < 30; i++) {
+      await sleep(2000);
+      try {
+        const url = page.url();
+        if (url.includes('grok.com')) { redirected = true; break; }
+      } catch {}
+    }
+
+    if (!redirected) {
+      // Check if we have SSO cookies anyway
+      const cookies = await page.context().cookies();
+      const sso = cookies.filter(c => c.name?.toLowerCase().includes('sso'));
+      if (sso.length === 0) throw new Error(`No redirect to grok.com (last URL: ${page.url()})`);
+    }
+
+    // Step 9: Save credentials
+    const allCookies = await page.context().cookies();
+    const accountData = {
+      email: addr,
+      password: PASSWORD,
+      code,
+      sso_cookies: allCookies,
+      final_url: page.url(),
+      timestamp: Math.floor(Date.now() / 1000),
+      elapsed: ((Date.now() - startTime) / 1000).toFixed(1),
+    };
+
+    // Step 10: Add to 9router if requested
+    if (addToRouter) {
+      try {
+        await addToRouter9(page, accountData);
+        accountData.router9 = 'added';
+      } catch (err) {
+        accountData.router9 = `failed: ${err.message}`;
+      }
+    }
+
+    return accountData;
+  } finally {
+    await page.close();
+  }
+}
+
+async function addToRouter9(page, account) {
+  // Check if already exists
+  const existing = await r9.listGrokProviders();
+  if (existing.some(c => c.email === account.email)) {
+    throw new Error('Already exists in 9router');
+  }
+
+  const dc = await r9.requestDeviceCode();
+  const result = await r9.doDeviceFlow(page, account.sso_cookies, {
+    deviceCode: dc.device_code,
+    codeVerifier: dc.codeVerifier,
+    userCode: dc.user_code,
+    verificationUriComplete: dc.verification_uri_complete
+  });
+
+  return result;
+}
+
+/**
+ * Get turnstile patch extension path
+ */
+export function getTurnstilePath() {
+  return TS_EXT;
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}

package/turnstilePatch/manifest.json

@@ -0,0 +1,18 @@
+{
+    "manifest_version": 3,
+    "name": "Turnstile Patcher",
+    "version": "2.1",
+    "content_scripts": [
+        {
+            "js": [
+                "./script.js"
+            ],
+            "matches": [
+                "<all_urls>"
+            ],
+            "run_at": "document_start",
+            "all_frames": true,
+            "world": "MAIN"
+        }
+    ]
+}

package/turnstilePatch/script.js

@@ -0,0 +1,12 @@
+function getRandomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+// old method wouldn't work on 4k screens
+
+let screenX = getRandomInt(800, 1200);
+let screenY = getRandomInt(400, 600);
+
+Object.defineProperty(MouseEvent.prototype, 'screenX', { value: screenX });
+
+Object.defineProperty(MouseEvent.prototype, 'screenY', { value: screenY });