Replace repository with grok-reg-protocol-cpa project

Overwrite previous grok-keygen contents with the local registration/CPA protocol codebase (secrets and runtime data excluded).

auto_register.py

@@ -0,0 +1,777 @@
+#!/usr/bin/env python3
+"""
+自动注册脚本 v2（Cloudflare catch-all + Gmail IMAP）
+流程：生成随机别名 -> Chromium注册 -> 直接IMAP取验证码 -> 填码完成注册
+"""
+import argparse
+import email as email_lib
+import imaplib
+import json
+import os
+import random
+import re
+import string
+import sys
+import time
+from datetime import datetime, timezone
+from email.header import decode_header as _decode_header
+from email.utils import parsedate_to_datetime
+from pathlib import Path
+
+from DrissionPage import Chromium, ChromiumOptions
+
+# ---- 配置 ----
+BASE_URL = "https://accounts.x.ai"
+SIGNUP_URL = "https://accounts.x.ai/sign-up?redirect=grok-com"
+ACCOUNTS_FILE = "accounts_cli.txt"
+CPA_DIR = "cpa_auths"
+DOMAIN = "zhangyunuo.net"
+CODE_TIMEOUT = 180
+CODE_POLL = 3
+IMAP_HOST = "imap.gmail.com"
+IMAP_PORT = 993
+EXTENSION_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "turnstilePatch")
+
+CHROMIUM_SLIM_FLAGS = [
+    "--disable-gpu",
+    "--disable-software-rasterizer",
+    "--no-sandbox",
+    "--disable-dev-shm-usage",
+    "--disable-images",
+    "--mute-audio",
+    "--disable-background-networking",
+    "--no-first-run",
+]
+
+CODE_PATTERNS = [
+    re.compile(r"verification\s+code[:\s]+(\d{4,8})", re.I),
+    re.compile(r"your\s+code[:\s]+(\d{4,8})", re.I),
+    re.compile(r"confirm(?:ation)?\s+code[:\s]+(\d{4,8})", re.I),
+    re.compile(r"code[:\s]+(\d{4,8})", re.I),
+    re.compile(r"验证码[：:\\s]+(\d{4,8})"),
+]
+
+def load_env(path=".env"):
+    data = {}
+    if not os.path.exists(path):
+        return data
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" in line:
+                k, v = line.split("=", 1)
+                data[k.strip()] = v.strip().strip('"').strip("'")
+    return data
+
+def gen_alias(domain: str, length: int = 10) -> str:
+    alias = "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
+    return f"{alias}@{domain}"
+
+def gen_password(length: int = 16) -> str:
+    # Avoid form-hostile punctuation; keep strong enough for xAI signup rules.
+    lower = string.ascii_lowercase
+    upper = string.ascii_uppercase
+    digits = string.digits
+    special = "!@#$%^&*"
+    if length < 8:
+        length = 8
+    base = [
+        random.choice(lower),
+        random.choice(upper),
+        random.choice(digits),
+        random.choice(special),
+    ]
+    pool = lower + upper + digits + special
+    base += random.choices(pool, k=length - len(base))
+    random.shuffle(base)
+    return "".join(base)
+
+def decode_header(raw: str) -> str:
+    parts = _decode_header(raw or "")
+    out = []
+    for part, charset in parts:
+        if isinstance(part, bytes):
+            out.append(part.decode(charset or "utf-8", errors="replace"))
+        else:
+            out.append(part)
+    return "".join(out)
+
+def message_body(msg) -> str:
+    body = ""
+    if msg.is_multipart():
+        for part in msg.walk():
+            ct = part.get_content_type()
+            if ct == "text/plain":
+                payload = part.get_payload(decode=True)
+                if payload:
+                    body += payload.decode("utf-8", errors="replace")
+    else:
+        payload = msg.get_payload(decode=True)
+        if payload:
+            body += payload.decode("utf-8", errors="replace")
+    return body
+
+def extract_code(text: str) -> str | None:
+    for pat in CODE_PATTERNS:
+        m = pat.search(text)
+        if m:
+            return m.group(1)
+    return None
+
+def imap_login(user: str, password: str):
+    imap = imaplib.IMAP4_SSL(IMAP_HOST, IMAP_PORT, timeout=45)
+    imap.login(user, password)
+    imap.select("INBOX")
+    return imap
+
+def fetch_code(imap, target_email: str, timeout: int = CODE_TIMEOUT, poll: int = CODE_POLL) -> str | None:
+    deadline = time.time() + timeout
+    target_lower = target_email.lower().strip()
+    while time.time() < deadline:
+        try:
+            status, data = imap.search(None, "ALL")
+            if status != "OK" or not data or not data[0]:
+                time.sleep(poll)
+                continue
+            msg_ids = data[0].split()[-30:]
+            filter_ts = int((time.time() - 900) * 1000)
+            for mid in reversed(msg_ids):
+                try:
+                    _, msg_data = imap.fetch(mid, "(RFC822)")
+                except Exception:
+                    continue
+                if not msg_data or not msg_data[0] or not isinstance(msg_data[0][1], bytes):
+                    continue
+                msg = email_lib.message_from_bytes(msg_data[0][1])
+                date_str = msg.get("Date")
+                if date_str:
+                    try:
+                        dt = parsedate_to_datetime(date_str)
+                        if dt.tzinfo is None:
+                            dt = dt.replace(tzinfo=timezone.utc)
+                        if int(dt.timestamp() * 1000) < filter_ts:
+                            continue
+                    except Exception:
+                        pass
+                subject = decode_header(msg.get("Subject", ""))
+                sender = decode_header(msg.get("From", ""))
+                recipient_blob = " ".join(
+                    decode_header(msg.get(h, ""))
+                    for h in ("To", "Cc", "Delivered-To", "X-Original-To", "Original-Recipient", "Envelope-To")
+                ).lower()
+                if target_lower not in recipient_blob:
+                    continue
+                body = message_body(msg)
+                combined = f"{subject}\n{sender}\n{recipient_blob}\n{body}".lower()
+                if not any(kw in combined for kw in ["x.ai", "xai", "grok", "verification", "code", "confirm", "验证码", "确认"]):
+                    continue
+                code = extract_code(combined)
+                if code:
+                    print(f"[+] Code found for {target_email}: {code}")
+                    return code
+        except Exception as e:
+            print(f"[!] IMAP poll error: {e}")
+        time.sleep(poll)
+    return None
+
+def save_account(email: str, password: str, sso: str = ""):
+    Path(ACCOUNTS_FILE).parent.mkdir(parents=True, exist_ok=True)
+    with open(ACCOUNTS_FILE, "a") as f:
+        f.write(f"{email}----{password}----{sso}\n")
+    print(f"[+] Saved: {email}")
+
+def create_browser_options(headless: bool = False, proxy: str = "") -> ChromiumOptions:
+    opts = ChromiumOptions()
+    opts.auto_port()
+    for flag in CHROMIUM_SLIM_FLAGS:
+        opts.set_argument(flag)
+    if os.path.exists(EXTENSION_PATH):
+        opts.add_extension(EXTENSION_PATH)
+    if headless:
+        opts.headless()
+    if proxy:
+        try:
+            from urllib.parse import urlparse
+            u = urlparse(proxy if "://" in proxy else f"http://{proxy}")
+            host = u.hostname or ""
+            if host:
+                port = u.port or (443 if (u.scheme or "http") == "https" else 80)
+                scheme = u.scheme or "http"
+                opts.set_argument(f"--proxy-server={scheme}://{host}:{port}")
+        except Exception as e:
+            print(f"[!] Proxy setup failed: {e}")
+    return opts
+
+def wait_for_tab(browser: Chromium, timeout: int = 15) -> any:
+    """Wait for browser tab to be ready and return it."""
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            tab_ids = browser.tab_ids
+            if tab_ids:
+                tab = browser.get_tab(tab_ids[0])
+                if tab is not None:
+                    return tab
+        except Exception:
+            pass
+        time.sleep(0.5)
+    # Fallback
+    return browser.latest_tab
+
+def bypass_turnstile(page) -> None:
+    """Try to bypass Cloudflare Turnstile using multiple methods."""
+    try:
+        # Method 1: Check if Turnstile token already exists
+        token = page.run_js("""
+            try {
+                const byInput = String((document.querySelector('input[name="cf-turnstile-response"]') || {}).value || '').trim();
+                if (byInput) return byInput;
+                if (window.turnstile && typeof turnstile.getResponse === 'function') {
+                    return String(turnstile.getResponse() || '').trim();
+                }
+                return '';
+            } catch(e) { return ''; }
+        """)
+        if token and len(token) >= 80:
+            print(f"[+] Turnstile token already present (len={len(token)})")
+            return
+    except Exception:
+        pass
+
+    try:
+        # Method 2: Try to find and click Turnstile checkbox
+        challenge_input = page.ele("@name=cf-turnstile-response", timeout=2)
+        if challenge_input:
+            try:
+                wrapper = challenge_input.parent()
+                iframe = None
+                try:
+                    iframe = wrapper.shadow_root.ele("tag:iframe")
+                except Exception:
+                    pass
+                if iframe:
+                    try:
+                        iframe.run_js("""
+                            window.dtp = 1;
+                            function getRandomInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }
+                            let sx = getRandomInt(800, 1200);
+                            let sy = getRandomInt(400, 700);
+                            Object.defineProperty(MouseEvent.prototype, 'screenX', { value: sx });
+                            Object.defineProperty(MouseEvent.prototype, 'screenY', { value: sy });
+                        """)
+                    except Exception:
+                        pass
+                    try:
+                        body_sr = iframe.ele("tag:body").shadow_root
+                        btn = body_sr.ele("tag:input")
+                        if btn:
+                            btn.click()
+                            print("[+] Clicked Turnstile checkbox via shadow DOM")
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    try:
+        # Method 3: Click any visible Turnstile container
+        page.run_js("""
+            const nodes = Array.from(document.querySelectorAll('div,span,iframe')).filter((n) => {
+                const txt = (n.className || '') + ' ' + (n.id || '') + ' ' + (n.getAttribute?.('src') || '');
+                return String(txt).toLowerCase().includes('turnstile');
+            });
+            if (nodes.length && typeof nodes[0].click === 'function') nodes[0].click();
+        """)
+    except Exception:
+        pass
+
+def click_email_signup_button(page, timeout: int = 15) -> bool:
+    """Click the 'Sign up with email' button on the landing page."""
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        clicked = page.run_js("""
+            const candidates = Array.from(document.querySelectorAll('button, a, [role="button"]'));
+            const target = candidates.find((node) => {
+                const text = (node.innerText || node.textContent || '').replace(/\\s+/g, '');
+                const lower = text.toLowerCase();
+                return (
+                    text.includes('使用邮箱注册') ||
+                    lower.includes('signupwithemail') ||
+                    lower.includes('continuewithemail') ||
+                    lower.includes('email')
+                );
+            });
+            if (!target) return false;
+            target.click();
+            return true;
+        """)
+        if clicked:
+            print("[+] Clicked 'Sign up with email' button")
+            return True
+        time.sleep(1)
+    return False
+
+def fill_email_js(page, email: str) -> bool:
+    """Fill email input using React-compatible JS injection."""
+    deadline = time.time() + 15
+    while time.time() < deadline:
+        result = page.run_js("""
+            function isVisible(node) {
+                if (!node) return false;
+                const style = window.getComputedStyle(node);
+                if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+                const rect = node.getBoundingClientRect();
+                return rect.width > 0 && rect.height > 0;
+            }
+            const input = Array.from(document.querySelectorAll('input[data-testid="email"], input[name="email"], input[type="email"], input[autocomplete="email"]')).find((node) => isVisible(node) && !node.disabled && !node.readOnly) || null;
+            if (!input) return 'not-ready';
+            input.focus(); input.click();
+            const valueSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+            const tracker = input._valueTracker;
+            if (tracker) tracker.setValue(arguments[0]);
+            if (valueSetter) valueSetter.call(input, arguments[0]); else input.value = arguments[0];
+            input.dispatchEvent(new Event('focus', { bubbles: true }));
+            input.dispatchEvent(new InputEvent('beforeinput', { bubbles: true, data: arguments[0], inputType: 'insertText' }));
+            input.dispatchEvent(new InputEvent('input', { bubbles: true, data: arguments[0], inputType: 'insertText' }));
+            input.dispatchEvent(new Event('change', { bubbles: true }));
+            input.dispatchEvent(new Event('blur', { bubbles: true }));
+            const current = (input.value || '').trim();
+            if (current === arguments[0]) return 'filled';
+            input.value = '';
+            input.dispatchEvent(new Event('input', { bubbles: true }));
+            for (const ch of arguments[0]) {
+                input.dispatchEvent(new KeyboardEvent('keydown', { key: ch, bubbles: true }));
+                input.value += ch;
+                input.dispatchEvent(new InputEvent('input', { bubbles: true, data: ch, inputType: 'insertText' }));
+                input.dispatchEvent(new KeyboardEvent('keyup', { key: ch, bubbles: true }));
+            }
+            input.dispatchEvent(new Event('change', { bubbles: true }));
+            if ((input.value || '').trim() === arguments[0]) return 'filled';
+            return input.value;
+        """, email)
+        if result == "not-ready":
+            time.sleep(0.5)
+            continue
+        if result == "filled":
+            return True
+        time.sleep(0.5)
+    return False
+
+def click_continue_button(page) -> bool:
+    """Click continue/signup button after email is filled."""
+    clicked = page.run_js(r"""
+        function isVisible(node) {
+            if (!node) return false;
+            const style = window.getComputedStyle(node);
+            if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+            const rect = node.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        }
+        const input = Array.from(document.querySelectorAll('input[data-testid="email"], input[name="email"], input[type="email"], input[autocomplete="email"]')).find((node) => isVisible(node) && !node.disabled && !node.readOnly) || null;
+        if (!input || !(input.value || '').trim()) return false;
+        const buttons = Array.from(document.querySelectorAll('button[type="submit"], button')).filter((node) => isVisible(node) && !node.disabled && node.getAttribute('aria-disabled') !== 'true');
+        const submitButton = buttons.find((node) => {
+            const raw = (node.innerText || node.textContent || '').trim();
+            const compact = raw.replace(/\s+/g, '').toLowerCase();
+            return (
+                raw.includes('注册') ||
+                compact === 'signup' ||
+                compact.includes('signup') ||
+                compact.includes('continue') ||
+                compact.includes('next') ||
+                compact.includes('createaccount') ||
+                compact.includes('submit')
+            );
+        });
+        if (!submitButton || submitButton.disabled) return false;
+        submitButton.click();
+        return true;
+    """)
+    return bool(clicked)
+
+def gen_name() -> tuple[str, str]:
+    first = ["Alex", "Sam", "Jordan", "Taylor", "Casey", "Riley", "Morgan", "Avery", "Quinn", "Jamie"]
+    last = ["Smith", "Johnson", "Brown", "Taylor", "Anderson", "Thomas", "Jackson", "White", "Harris", "Martin"]
+    return random.choice(first), random.choice(last)
+
+
+def fill_profile_js(page, password: str, timeout: int = 120) -> dict:
+    """Fill given/family name + password and submit after Turnstile is ready."""
+    given_name, family_name = gen_name()
+    deadline = time.time() + timeout
+    form_filled = False
+    while time.time() < deadline:
+        state = page.run_js(
+            r"""
+const givenName = arguments[0];
+const familyName = arguments[1];
+const password = arguments[2];
+function isVisible(node) {
+  if (!node) return false;
+  const style = window.getComputedStyle(node);
+  if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+  const rect = node.getBoundingClientRect();
+  return rect.width > 0 && rect.height > 0;
+}
+function pick(sel) {
+  return Array.from(document.querySelectorAll(sel)).find((n) => isVisible(n) && !n.disabled && !n.readOnly) || null;
+}
+function setVal(input, value) {
+  if (!input) return false;
+  input.focus(); input.click();
+  const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+  const tracker = input._valueTracker;
+  if (tracker) tracker.setValue('');
+  if (setter) setter.call(input, value); else input.value = value;
+  input.dispatchEvent(new InputEvent('beforeinput', { bubbles: true, data: value, inputType: 'insertText' }));
+  input.dispatchEvent(new InputEvent('input', { bubbles: true, data: value, inputType: 'insertText' }));
+  input.dispatchEvent(new Event('change', { bubbles: true }));
+  input.blur();
+  return String(input.value || '').trim() === String(value || '').trim();
+}
+const givenInput = pick('input[data-testid="givenName"], input[name="givenName"], input[autocomplete="given-name"]');
+const familyInput = pick('input[data-testid="familyName"], input[name="familyName"], input[autocomplete="family-name"]');
+const passwordInput = pick('input[data-testid="password"], input[name="password"], input[type="password"], input[autocomplete="new-password"]');
+if (!givenInput || !familyInput || !passwordInput) return 'not-ready';
+const ok1 = setVal(givenInput, givenName);
+const ok2 = setVal(familyInput, familyName);
+const ok3 = setVal(passwordInput, password);
+if (!ok1 || !ok2 || !ok3) return 'fill-failed';
+const cfInput = document.querySelector('input[name="cf-turnstile-response"]');
+const cfPresent = !!cfInput || !!document.querySelector('iframe[src*="turnstile"], div.cf-turnstile, [data-sitekey]');
+if (cfPresent) {
+  const token = String((cfInput && cfInput.value) || '').trim();
+  if (token.length < 80) return 'wait-cf:' + token.length;
+}
+const buttons = Array.from(document.querySelectorAll('button[type="submit"], button')).filter((n) => isVisible(n) && !n.disabled && n.getAttribute('aria-disabled') !== 'true');
+const submitBtn = buttons.find((n) => {
+  const t = (n.innerText || n.textContent || '').replace(/\s+/g, '').toLowerCase();
+  return t.includes('完成注册') || t.includes('创建账户') || t.includes('signup') || t.includes('signup') || t.includes('createaccount') || t.includes('continue') || t.includes('confirm');
+});
+if (!submitBtn) return 'filled-no-submit';
+submitBtn.click();
+return 'submitted';
+            """,
+            given_name,
+            family_name,
+            password,
+        )
+        if state == "not-ready":
+            time.sleep(0.8)
+            continue
+        if state == "fill-failed":
+            time.sleep(0.5)
+            continue
+        if isinstance(state, str) and state.startswith("wait-cf"):
+            form_filled = True
+            bypass_turnstile(page)
+            time.sleep(1.5)
+            continue
+        if state == "filled-no-submit":
+            form_filled = True
+            time.sleep(1)
+            continue
+        if state == "submitted":
+            return {"ok": True, "given_name": given_name, "family_name": family_name, "password": password}
+        time.sleep(0.8)
+    return {"ok": False, "error": "timeout waiting profile/turnstile", "given_name": given_name, "family_name": family_name}
+
+
+def wait_for_sso(page, timeout: int = 180) -> str:
+    deadline = time.time() + timeout
+    last_click = 0.0
+    while time.time() < deadline:
+        # periodically re-click final submit if still on complete-registration page
+        now = time.time()
+        if now - last_click >= 3:
+            try:
+                page.run_js(r"""
+function isVisible(node) {
+  if (!node) return false;
+  const style = window.getComputedStyle(node);
+  if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+  const rect = node.getBoundingClientRect();
+  return rect.width > 0 && rect.height > 0;
+}
+const titleHit = !!Array.from(document.querySelectorAll('h1,h2,div,span')).find((el) => {
+  const t = (el.textContent || '').replace(/\s+/g, '');
+  return t.includes('完成注册') || t.toLowerCase().includes('complete');
+});
+if (!titleHit) return false;
+const cfInput = document.querySelector('input[name="cf-turnstile-response"]');
+if (cfInput && String(cfInput.value || '').trim().length < 80) return false;
+const buttons = Array.from(document.querySelectorAll('button[type="submit"], button')).filter((n) => isVisible(n) && !n.disabled);
+const submitBtn = buttons.find((n) => {
+  const t = (n.innerText || n.textContent || '').replace(/\s+/g, '').toLowerCase();
+  return t.includes('完成注册') || t.includes('创建账户') || t.includes('signup') || t.includes('signup') || t.includes('createaccount');
+});
+if (submitBtn) { submitBtn.click(); return true; }
+return false;
+""")
+            except Exception:
+                pass
+            last_click = now
+        try:
+            cookies = None
+            for getter in (
+                lambda: page.cookies(all_domains=True, all_info=True),
+                lambda: page.cookies(all_domains=True),
+                lambda: page.cookies(),
+            ):
+                try:
+                    cookies = getter()
+                    if cookies:
+                        break
+                except TypeError:
+                    continue
+                except Exception:
+                    continue
+            if isinstance(cookies, list):
+                for c in cookies:
+                    if not isinstance(c, dict):
+                        continue
+                    if str(c.get("name", "")).strip() == "sso" and c.get("value"):
+                        return str(c.get("value")).strip()
+        except Exception:
+            pass
+        time.sleep(1)
+    return ""
+
+
+def maybe_export_cpa(email: str, password: str, sso: str, page) -> str | None:
+    """Best-effort CPA export using project cpa_export + config.json."""
+    cfg_path = Path(__file__).resolve().parent / "config.json"
+    if not cfg_path.is_file():
+        return None
+    try:
+        cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+    if not cfg.get("cpa_export_enabled", True):
+        return None
+    try:
+        import cpa_export
+        cookies = cpa_export.export_cookies_from_page(page)
+        result = cpa_export.export_cpa_xai_for_account(
+            email,
+            password,
+            page=None,
+            cookies=cookies,
+            sso=sso,
+            config=cfg,
+            log_callback=lambda m: print(f"[cpa] {m}"),
+        )
+        if result.get("ok") and result.get("path"):
+            return str(result["path"])
+    except Exception as exc:
+        print(f"[!] CPA export exception: {exc}")
+    return None
+
+
+def do_register(alias: str, password: str, imap_user: str, imap_password: str, headless: bool = False, proxy: str = "") -> dict:
+    email = alias
+    print(f"[*] Registering: {email}")
+
+    opts = create_browser_options(headless=headless, proxy=proxy)
+    browser = None
+    imap_conn = None
+    try:
+        browser = Chromium(opts)
+        page = wait_for_tab(browser, timeout=20)
+        if page is None:
+            raise Exception("无法获取浏览器标签页")
+
+        page.get(SIGNUP_URL)
+        page.wait.doc_loaded(timeout=20)
+        time.sleep(2)
+        print(f"[+] Page loaded: {page.url}")
+
+        # 尝试绕过 Turnstile
+        bypass_turnstile(page)
+        time.sleep(1)
+
+        # 点击"使用邮箱注册"按钮
+        if not click_email_signup_button(page, timeout=10):
+            print("[!] No email signup button found, continuing anyway...")
+        time.sleep(2)
+
+        # 填写邮箱
+        if not fill_email_js(page, email):
+            raise Exception("未找到邮箱输入框或写入失败")
+        print(f"[+] Email submitted: {email}")
+        time.sleep(0.8)
+
+        # 点击继续
+        if not click_continue_button(page):
+            raise Exception("未找到注册按钮")
+        print(f"[+] Continue clicked")
+        time.sleep(3)
+
+        # 连接 IMAP 准备取验证码
+        print(f"[*] Connecting IMAP {imap_user}...")
+        imap_conn = imap_login(imap_user, imap_password)
+
+        # 等待验证码
+        print(f"[*] Waiting for code...")
+        code = fetch_code(imap_conn, email, timeout=CODE_TIMEOUT, poll=CODE_POLL)
+        if not code:
+            raise Exception(f"未收到验证码: {email}")
+
+        # 填写验证码
+        code_input = page.ele(
+            "css:input[data-input-otp='true'], input[name='code'], input[autocomplete='one-time-code']",
+            timeout=5,
+        )
+        if code_input:
+            code_input.clear()
+            code_input.input(code)
+        else:
+            boxes = page.eles("css:input[inputmode='numeric']")
+            for i, ch in enumerate(code):
+                if i < len(boxes):
+                    boxes[i].input(ch)
+                    time.sleep(0.1)
+        print(f"[+] Code filled: {code}")
+        time.sleep(0.5)
+
+        # 点击确认
+        page.run_js("""
+            const btns = Array.from(document.querySelectorAll('button'));
+            const btn = btns.find(b => {
+                const t = (b.innerText || b.textContent || '').replace(/\\s+/g, '').toLowerCase();
+                return t.includes('continue') || t.includes('confirm') || t.includes('下一步');
+            });
+            if (btn) btn.click();
+        """)
+        time.sleep(3)
+
+        # 验证码后通常进入资料页：姓名 + 密码 + Turnstile
+        print("[*] Filling profile (name/password)...")
+        profile = fill_profile_js(page, password, timeout=120)
+        if not profile.get("ok"):
+            raise Exception(f"资料填写失败: {profile.get('error') or 'unknown'}")
+        print(f"[+] Profile filled: {profile.get('given_name')} {profile.get('family_name')}")
+
+        # 等待 sso cookie（最终提交后）
+        print("[*] Waiting for sso cookie...")
+        sso_cookie = wait_for_sso(page, timeout=180)
+        current_url = page.url
+        print(f"[+] Current URL: {current_url}")
+        if not sso_cookie:
+            raise Exception("未获取到 sso cookie")
+
+        save_account(email, password, sso_cookie)
+        result = {"ok": True, "email": email, "password": password, "sso": sso_cookie, "url": current_url}
+
+        # 可选：协议优先 CPA mint
+        if os.environ.get("CPA_EXPORT", "1") not in ("0", "false", "False"):
+            try:
+                cpa_path = maybe_export_cpa(email, password, sso_cookie, page)
+                if cpa_path:
+                    result["cpa_path"] = cpa_path
+                    print(f"[+] CPA auth: {cpa_path}")
+            except Exception as cpa_exc:
+                print(f"[!] CPA export failed: {cpa_exc}")
+                result["cpa_error"] = str(cpa_exc)
+        return result
+
+    except Exception as e:
+        print(f"[-] Failed: {e}")
+        try:
+            if browser is not None:
+                tab = wait_for_tab(browser, timeout=5)
+                if tab is not None:
+                    tab.get_screenshot(path="register_error.png", full_page=False)
+                    print(f"[!] Screenshot: register_error.png")
+        except Exception:
+            pass
+        return {"ok": False, "error": str(e), "email": email}
+    finally:
+        if imap_conn:
+            try:
+                imap_conn.close()
+            except Exception:
+                pass
+            try:
+                imap_conn.logout()
+            except Exception:
+                pass
+        if browser is not None:
+            try:
+                browser.quit()
+            except Exception:
+                pass
+
+def main():
+    parser = argparse.ArgumentParser(description="Grok 自动注册（Cloudflare catch-all + Gmail IMAP）")
+    parser.add_argument("--count", type=int, default=1)
+    parser.add_argument("--threads", type=int, default=1)
+    parser.add_argument("--headless", action="store_true")
+    parser.add_argument("--proxy", default=None)
+    parser.add_argument("--domain", default=DOMAIN)
+    parser.add_argument("--imap-user", default=None)
+    parser.add_argument("--imap-password", default=None)
+    args = parser.parse_args()
+
+    env = load_env()
+    proxy = args.proxy or env.get("proxy") or env.get("cpa_proxy") or ""
+    if proxy == "http://127.0.0.1:7890":
+        proxy = ""
+    imap_user = args.imap_user or env.get("GMAIL_USER") or ""
+    imap_password = args.imap_password or env.get("GMAIL_PASSWORD") or ""
+    if not imap_user or not imap_password:
+        print("Error: IMAP credentials required via --imap-user/--imap-password or GMAIL_USER/GMAIL_PASSWORD")
+        return 1
+
+    print(f"[*] Domain: {args.domain}")
+    print(f"[*] Proxy: {proxy or 'direct'}")
+    print(f"[*] IMAP: {imap_user}")
+    print(f"[*] Count: {args.count}, Threads: {args.threads}")
+
+    tasks = []
+    for i in range(args.count):
+        tasks.append((i + 1, gen_alias(args.domain), gen_password()))
+
+    results = []
+    threads = max(1, min(int(args.threads or 1), 10))
+    if threads == 1:
+        for idx, alias, password in tasks:
+            print(f"\n=== Account {idx}/{args.count} ===")
+            res = do_register(alias, password, imap_user, imap_password, headless=args.headless, proxy=proxy or None)
+            results.append(res)
+            if idx < args.count:
+                time.sleep(3)
+    else:
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        print(f"[*] Running with {threads} threads")
+        with ThreadPoolExecutor(max_workers=threads) as ex:
+            futs = {
+                ex.submit(
+                    do_register, alias, password, imap_user, imap_password, args.headless, proxy or None
+                ): (idx, alias)
+                for idx, alias, password in tasks
+            }
+            for fut in as_completed(futs):
+                idx, alias = futs[fut]
+                try:
+                    res = fut.result()
+                except Exception as exc:
+                    res = {"ok": False, "email": alias, "error": str(exc)}
+                results.append(res)
+                status = "OK" if res.get("ok") else "FAIL"
+                print(f"[{status}] #{idx} {res.get('email')} {res.get('error', '')[:80]}")
+
+    print(f"\n=== Summary ===")
+    ok = sum(1 for r in results if r.get("ok"))
+    print(f"Success: {ok}/{len(results)}")
+    for r in results:
+        status = "OK" if r.get("ok") else "FAIL"
+        extra = r.get("cpa_path") or r.get("error", "")
+        print(f"  [{status}] {r.get('email')} - {str(extra)[:100]}")
+    return 0 if ok else 1
+
+if __name__ == "__main__":
+    raise SystemExit(main() or 0)