Add registration runner UI

Co-Authored-By: Codex <noreply@openai.com>

api/accounts.py

@@ -327,4 +327,3 @@ def create_router() -> APIRouter:
         return {"import_job": server.get("import_job")}
 
     return router
-

api/app.py

@@ -8,7 +8,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
-from api import accounts, ai, system
+from api import accounts, ai, register, system
 from api.support import resolve_web_asset, start_limited_account_watcher
 from services.config import config
 
@@ -37,6 +37,7 @@ def create_app() -> FastAPI:
     )
     app.include_router(ai.create_router())
     app.include_router(accounts.create_router())
+    app.include_router(register.create_router())
     app.include_router(system.create_router(app_version))
     if config.images_dir.exists():
         app.mount("/images", StaticFiles(directory=str(config.images_dir)), name="images")

api/register.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import asyncio
+import json
+
+from fastapi import APIRouter, Header
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from api.support import require_admin
+from services.register_service import register_service
+
+
+class RegisterConfigRequest(BaseModel):
+    mail: dict | None = None
+    proxy: str | None = None
+    total: int | None = None
+    threads: int | None = None
+    mode: str | None = None
+    target_quota: int | None = None
+    target_available: int | None = None
+    check_interval: int | None = None
+
+
+def create_router() -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/api/register")
+    async def get_register_config(authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        return {"register": register_service.get()}
+
+    @router.post("/api/register")
+    async def update_register_config(body: RegisterConfigRequest, authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        return {"register": register_service.update(body.model_dump(exclude_none=True))}
+
+    @router.post("/api/register/start")
+    async def start_register(authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        return {"register": register_service.start()}
+
+    @router.post("/api/register/stop")
+    async def stop_register(authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        return {"register": register_service.stop()}
+
+    @router.post("/api/register/reset")
+    async def reset_register(authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        return {"register": register_service.reset()}
+
+    @router.get("/api/register/events")
+    async def register_events(token: str = ""):
+        require_admin(f"Bearer {token}")
+
+        async def stream():
+            last = ""
+            while True:
+                payload = json.dumps(register_service.get(), ensure_ascii=False)
+                if payload != last:
+                    last = payload
+                    yield f"data: {payload}\n\n"
+                await asyncio.sleep(0.5)
+
+        return StreamingResponse(stream(), media_type="text/event-stream")
+
+    return router

config.json

@@ -2,7 +2,7 @@
   "auth-key": "chatgpt2api",
   "refresh_account_interval_minute": 60,
   "image_retention_days": 15,
-  "auto_remove_invalid_accounts": false,
+  "auto_remove_invalid_accounts": true,
   "log_levels": [
     "debug",
     "error",

services/register/mail_provider.py

@@ -0,0 +1,414 @@
+from __future__ import annotations
+
+import random
+import re
+import string
+import time
+from datetime import datetime, timezone
+from email import message_from_string, policy
+from email.utils import parsedate_to_datetime
+from threading import Lock
+from typing import Any, Callable, TypeVar
+
+import requests
+from curl_cffi import requests as curl_requests
+
+
+ResultT = TypeVar("ResultT")
+domain_lock = Lock()
+provider_lock = Lock()
+domain_index = 0
+provider_index = 0
+
+
+def _config(mail_config: dict) -> dict:
+    return {
+        "request_timeout": float(mail_config.get("request_timeout") or 15),
+        "wait_timeout": float(mail_config.get("wait_timeout") or 30),
+        "wait_interval": float(mail_config.get("wait_interval") or 3),
+        "user_agent": str(mail_config.get("user_agent") or "Mozilla/5.0"),
+    }
+
+
+def _random_mailbox_name() -> str:
+    return f"{''.join(random.choices(string.ascii_lowercase, k=5))}{''.join(random.choices(string.digits, k=random.randint(1, 3)))}{''.join(random.choices(string.ascii_lowercase, k=random.randint(1, 3)))}"
+
+
+def _random_subdomain_label() -> str:
+    return "".join(random.choices(string.ascii_lowercase + string.digits, k=random.randint(4, 10)))
+
+
+def _next_domain(domains: list[str]) -> str:
+    global domain_index
+    domains = [str(item).strip() for item in domains if str(item).strip()]
+    if not domains:
+        raise RuntimeError("mail.domain 不能为空")
+    if len(domains) == 1:
+        return domains[0]
+    with domain_lock:
+        value = domains[domain_index % len(domains)]
+        domain_index = (domain_index + 1) % len(domains)
+        return value
+
+
+def _parse_received_at(value: Any) -> datetime | None:
+    if isinstance(value, (int, float)):
+        try:
+            return datetime.fromtimestamp(float(value), tz=timezone.utc)
+        except Exception:
+            return None
+    text = str(value or "").strip()
+    if not text:
+        return None
+    try:
+        date = datetime.fromisoformat(text[:-1] + "+00:00" if text.endswith("Z") else text)
+        return date if date.tzinfo else date.replace(tzinfo=timezone.utc)
+    except Exception:
+        pass
+    try:
+        date = parsedate_to_datetime(text)
+        return date if date.tzinfo else date.replace(tzinfo=timezone.utc)
+    except Exception:
+        return None
+
+
+def _extract_content(data: dict[str, Any]) -> tuple[str, str]:
+    text_content = str(data.get("text_content") or data.get("text") or data.get("body") or data.get("content") or "")
+    html_content = str(data.get("html_content") or data.get("html") or data.get("html_body") or data.get("body_html") or "")
+    if text_content or html_content:
+        return text_content, html_content
+    raw = data.get("raw")
+    if not isinstance(raw, str) or not raw.strip():
+        return "", ""
+    try:
+        parsed = message_from_string(raw, policy=policy.default)
+    except Exception:
+        return raw, ""
+    plain: list[str] = []
+    html: list[str] = []
+    for part in parsed.walk() if parsed.is_multipart() else [parsed]:
+        if part.get_content_maintype() == "multipart":
+            continue
+        try:
+            payload = part.get_content()
+        except Exception:
+            payload = ""
+        if not payload:
+            continue
+        if part.get_content_type() == "text/html":
+            html.append(str(payload))
+        else:
+            plain.append(str(payload))
+    return "\n".join(plain).strip(), "\n".join(html).strip()
+
+
+def _extract_text_candidates(value: Any) -> list[str]:
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, dict):
+        out: list[str] = []
+        for key in ("address", "email", "name", "value"):
+            if value.get(key):
+                out.extend(_extract_text_candidates(value.get(key)))
+        return out
+    if isinstance(value, list):
+        out: list[str] = []
+        for item in value:
+            out.extend(_extract_text_candidates(item))
+        return out
+    return []
+
+
+def _message_matches_email(data: dict[str, Any], email: str) -> bool:
+    target = str(email or "").strip().lower()
+    candidates: list[str] = []
+    for key in ("to", "mailTo", "receiver", "receivers", "address", "email", "envelope_to"):
+        if key in data:
+            candidates.extend(_extract_text_candidates(data.get(key)))
+    return not target or not candidates or any(target in str(item).strip().lower() for item in candidates if str(item).strip())
+
+
+def _extract_code(message: dict[str, Any]) -> str | None:
+    content = f"{message.get('subject', '')}\n{message.get('text_content', '')}\n{message.get('html_content', '')}".strip()
+    if not content:
+        return None
+    match = re.search(r"background-color:\s*#F3F3F3[^>]*>[\s\S]*?(\d{6})[\s\S]*?</p>", content, re.I)
+    if match:
+        return match.group(1)
+    match = re.search(r"(?:Verification code|code is|代码为|验证码)[:\s]*(\d{6})", content, re.I)
+    if match and match.group(1) != "177010":
+        return match.group(1)
+    for code in re.findall(r">\s*(\d{6})\s*<|(?<![#&])\b(\d{6})\b", content):
+        value = code[0] or code[1]
+        if value and value != "177010":
+            return value
+    return None
+
+
+class BaseMailProvider:
+    name = "unknown"
+
+    def __init__(self, conf: dict, provider_ref: str = ""):
+        self.conf = conf
+        self.provider_ref = provider_ref
+
+    def wait_for(self, mailbox: dict[str, Any], on_message: Callable[[dict[str, Any]], ResultT | None]) -> ResultT | None:
+        deadline = time.monotonic() + self.conf["wait_timeout"]
+        while time.monotonic() < deadline:
+            message = self.fetch_latest_message(mailbox)
+            if message:
+                result = on_message(message)
+                if result is not None:
+                    return result
+            time.sleep(max(0.2, self.conf["wait_interval"]))
+        return None
+
+    def wait_for_code(self, mailbox: dict[str, Any]) -> str | None:
+        return self.wait_for(mailbox, _extract_code)
+
+    def close(self) -> None:
+        pass
+
+
+class CloudflareTempMailProvider(BaseMailProvider):
+    name = "cloudflare_temp_email"
+
+    def __init__(self, entry: dict, conf: dict):
+        super().__init__(conf, str(entry.get("provider_ref") or ""))
+        self.api_base = str(entry["api_base"]).rstrip("/")
+        self.admin_password = str(entry["admin_password"]).strip()
+        self.domain = entry.get("domain") or []
+        self.session = curl_requests.Session(impersonate="chrome")
+
+    def _request(self, method: str, path: str, headers: dict | None = None, params: dict | None = None, payload: dict | None = None, expected: tuple[int, ...] = (200,)):
+        resp = self.session.request(method.upper(), f"{self.api_base}{path}", headers={"Content-Type": "application/json", "User-Agent": self.conf["user_agent"], **(headers or {})}, params=params, json=payload, timeout=self.conf["request_timeout"], verify=False)
+        if resp.status_code not in expected:
+            raise RuntimeError(f"CloudflareTempMail 请求失败: {method} {path}, HTTP {resp.status_code}, body={resp.text[:300]}")
+        return {} if resp.status_code == 204 else resp.json()
+
+    def create_mailbox(self, username: str | None = None) -> dict[str, Any]:
+        data = self._request("POST", "/admin/new_address", headers={"x-admin-auth": self.admin_password}, payload={"enablePrefix": True, "name": username or _random_mailbox_name(), "domain": _next_domain(self.domain)})
+        address = str(data.get("address") or "").strip()
+        token = str(data.get("jwt") or "").strip()
+        if not address or not token:
+            raise RuntimeError("CloudflareTempMail 缺少 address 或 jwt")
+        return {"provider": self.name, "provider_ref": self.provider_ref, "address": address, "token": token}
+
+    def fetch_latest_message(self, mailbox: dict[str, Any]) -> dict[str, Any] | None:
+        data = self._request("GET", "/api/mails", headers={"Authorization": f"Bearer {mailbox['token']}"}, params={"limit": 10, "offset": 0})
+        raw = list(data.get("results") or []) if isinstance(data, dict) else data if isinstance(data, list) else []
+        messages = [item for item in raw if isinstance(item, dict) and _message_matches_email(item, str(mailbox.get("address") or ""))]
+        if not messages:
+            return None
+        item = messages[0]
+        text_content, html_content = _extract_content(item)
+        sender = item.get("from") or item.get("sender") or ""
+        if isinstance(sender, dict):
+            sender = sender.get("address") or sender.get("email") or sender.get("name") or ""
+        return {"provider": self.name, "mailbox": mailbox["address"], "message_id": str(item.get("id") or item.get("_id") or ""), "subject": str(item.get("subject") or ""), "sender": str(sender), "text_content": text_content, "html_content": html_content, "received_at": _parse_received_at(item.get("createdAt") or item.get("created_at") or item.get("receivedAt") or item.get("date") or item.get("timestamp")), "raw": item}
+
+    def close(self) -> None:
+        self.session.close()
+
+
+class TempMailLolProvider(BaseMailProvider):
+    name = "tempmail_lol"
+
+    def __init__(self, entry: dict, conf: dict):
+        super().__init__(conf, str(entry.get("provider_ref") or ""))
+        self.api_key = str(entry.get("api_key") or "").strip()
+        self.domain = [str(item).strip() for item in (entry.get("domain") or []) if str(item).strip()]
+        self.session = requests.Session()
+        self.session.trust_env = False
+        self.session.headers.update({"User-Agent": conf["user_agent"], "Accept": "application/json", "Content-Type": "application/json"})
+        if self.api_key:
+            self.session.headers["Authorization"] = f"Bearer {self.api_key}"
+
+    @staticmethod
+    def _resolve_domain(domain: str) -> tuple[str, bool]:
+        text = str(domain or "").strip().lower()
+        if text.startswith("*.") and len(text) > 2:
+            return f"{_random_subdomain_label()}.{text[2:]}", True
+        return text, False
+
+    def _request(self, method: str, path: str, params: dict | None = None, payload: dict | None = None, expected: tuple[int, ...] = (200,)):
+        resp = self.session.request(method.upper(), f"https://api.tempmail.lol/v2{path}", params=params, json=payload, timeout=self.conf["request_timeout"], verify=False)
+        if resp.status_code not in expected:
+            raise RuntimeError(f"TempMail.lol 请求失败: {method} {path}, HTTP {resp.status_code}, body={resp.text[:300]}")
+        data = resp.json()
+        if not isinstance(data, dict):
+            raise RuntimeError(f"TempMail.lol {method} {path} 返回结构不是对象")
+        return data
+
+    def create_mailbox(self, username: str | None = None) -> dict[str, Any]:
+        payload: dict[str, Any] = {}
+        if self.domain:
+            domain, force_random_prefix = self._resolve_domain(random.choice(self.domain))
+            payload["domain"] = domain
+            if force_random_prefix:
+                payload["prefix"] = _random_mailbox_name()
+        if username and "prefix" not in payload:
+            payload["prefix"] = username
+        data = self._request("POST", "/inbox/create", payload=payload, expected=(200, 201))
+        address = str(data.get("address") or "").strip()
+        token = str(data.get("token") or "").strip()
+        if not address or not token:
+            raise RuntimeError("TempMail.lol 缺少 address 或 token")
+        return {"provider": self.name, "provider_ref": self.provider_ref, "address": address, "token": token}
+
+    def fetch_latest_message(self, mailbox: dict[str, Any]) -> dict[str, Any] | None:
+        data = self._request("GET", "/inbox", params={"token": mailbox["token"]})
+        items = data.get("emails") or data.get("messages") or []
+        messages = [item for item in items if isinstance(item, dict)] if isinstance(items, list) else []
+        if not messages:
+            return None
+        item = max(messages, key=lambda value: ((_parse_received_at(value.get("created_at") or value.get("createdAt") or value.get("date") or value.get("received_at") or value.get("timestamp")) or datetime.fromtimestamp(0, tz=timezone.utc)).timestamp(), str(value.get("id") or value.get("token") or "")))
+        text_content, html_content = _extract_content(item)
+        return {"provider": self.name, "mailbox": mailbox["address"], "message_id": str(item.get("id") or item.get("token") or ""), "subject": str(item.get("subject") or ""), "sender": str(item.get("from") or item.get("from_address") or ""), "text_content": text_content, "html_content": html_content, "received_at": _parse_received_at(item.get("created_at") or item.get("createdAt") or item.get("date") or item.get("received_at") or item.get("timestamp")), "raw": item}
+
+    def close(self) -> None:
+        self.session.close()
+
+
+class DuckMailProvider(BaseMailProvider):
+    name = "duckmail"
+
+    def __init__(self, entry: dict, conf: dict):
+        super().__init__(conf, str(entry.get("provider_ref") or ""))
+        self.api_key = str(entry["api_key"]).strip()
+        self.default_domain = str(entry.get("default_domain") or "duckmail.sbs").strip() or "duckmail.sbs"
+        self.session = requests.Session()
+        self.session.trust_env = False
+        self.session.headers.update({"User-Agent": conf["user_agent"], "Accept": "application/json", "Content-Type": "application/json"})
+
+    def _request(self, method: str, path: str, token: str = "", use_api_key: bool = False, params: dict | None = None, payload: dict | None = None, expected: tuple[int, ...] = (200, 201, 204)):
+        headers = {"Authorization": f"Bearer {self.api_key if use_api_key else token}"} if use_api_key or token else {}
+        resp = self.session.request(method.upper(), f"https://api.duckmail.sbs{path}", headers=headers, params=params, json=payload, timeout=self.conf["request_timeout"], verify=False)
+        if resp.status_code not in expected:
+            raise RuntimeError(f"DuckMail 请求失败: {method} {path}, HTTP {resp.status_code}, body={resp.text[:300]}")
+        return {} if resp.status_code == 204 else resp.json()
+
+    @staticmethod
+    def _items(data):
+        return data if isinstance(data, list) else data.get("hydra:member") or data.get("member") or data.get("data") or []
+
+    def create_mailbox(self, username: str | None = None) -> dict[str, Any]:
+        domains = self._items(self._request("GET", "/domains", use_api_key=True))
+        domain = random.choice(domains).get("domain") if domains else self.default_domain
+        password = "".join(random.choices(string.ascii_letters + string.digits, k=12))
+        address = f"{username or _random_mailbox_name()}@{domain}"
+        payload = {"address": address, "password": password}
+        account = self._request("POST", "/accounts", use_api_key=True, payload=payload)
+        token_data = self._request("POST", "/token", use_api_key=True, payload=payload)
+        return {"provider": self.name, "provider_ref": self.provider_ref, "address": address, "token": str(token_data.get("token") or ""), "password": password, "account_id": str(account.get("id") or "")}
+
+    def fetch_latest_message(self, mailbox: dict[str, Any]) -> dict[str, Any] | None:
+        data = self._request("GET", "/messages", token=str(mailbox.get("token") or ""), params={"page": 1})
+        items = self._items(data)
+        if not items:
+            return None
+        item = items[0]
+        message_id = str(item.get("id") or item.get("@id") or "").replace("/messages/", "")
+        if message_id:
+            item = self._request("GET", f"/messages/{message_id}", token=str(mailbox.get("token") or ""))
+        sender = item.get("from") or ""
+        if isinstance(sender, dict):
+            sender = sender.get("address") or sender.get("name") or ""
+        html_content = item.get("html") or ""
+        if isinstance(html_content, list):
+            html_content = "".join(str(value) for value in html_content)
+        return {"provider": self.name, "mailbox": mailbox["address"], "message_id": message_id, "subject": str(item.get("subject") or ""), "sender": str(sender), "text_content": str(item.get("text") or item.get("text_content") or ""), "html_content": str(html_content), "received_at": _parse_received_at(item.get("createdAt") or item.get("created_at") or item.get("receivedAt") or item.get("date")), "raw": item}
+
+    def close(self) -> None:
+        self.session.close()
+
+
+class GptMailProvider(BaseMailProvider):
+    name = "gptmail"
+
+    def __init__(self, entry: dict, conf: dict):
+        super().__init__(conf, str(entry.get("provider_ref") or ""))
+        self.api_key = str(entry["api_key"]).strip()
+        self.default_domain = str(entry.get("default_domain") or "").strip()
+        self.session = requests.Session()
+        self.session.trust_env = False
+        self.session.headers.update({"User-Agent": conf["user_agent"], "Accept": "application/json", "Content-Type": "application/json", "X-API-Key": self.api_key})
+
+    def _request(self, method: str, path: str, params: dict | None = None, payload: dict | None = None):
+        query = dict(params or {})
+        resp = self.session.request(method.upper(), f"https://mail.chatgpt.org.uk{path}", params=query, json=payload, timeout=self.conf["request_timeout"], verify=False)
+        if resp.status_code != 200:
+            raise RuntimeError(f"GPTMail 请求失败: {method} {path}, HTTP {resp.status_code}, body={resp.text[:300]}")
+        data = resp.json()
+        return data["data"] if isinstance(data, dict) and "data" in data else data
+
+    def create_mailbox(self, username: str | None = None) -> dict[str, Any]:
+        payload = {key: value for key, value in {"prefix": username, "domain": self.default_domain}.items() if value}
+        data = self._request("POST" if payload else "GET", "/api/generate-email", payload=payload or None)
+        return {"provider": self.name, "provider_ref": self.provider_ref, "address": str(data["email"])}
+
+    def fetch_latest_message(self, mailbox: dict[str, Any]) -> dict[str, Any] | None:
+        data = self._request("GET", "/api/emails", params={"email": mailbox["address"]})
+        emails = data if isinstance(data, list) else data.get("emails") or []
+        if not emails:
+            return None
+        item = max(emails, key=lambda value: (float(value.get("timestamp") or 0), str(value.get("id") or "")))
+        if item.get("id"):
+            item = self._request("GET", f"/api/email/{item['id']}")
+        return {"provider": self.name, "mailbox": mailbox["address"], "message_id": str(item.get("id") or ""), "subject": str(item.get("subject") or ""), "sender": str(item.get("from_address") or ""), "text_content": str(item.get("content") or ""), "html_content": str(item.get("html_content") or ""), "received_at": _parse_received_at(item.get("timestamp") or item.get("created_at")), "raw": item}
+
+    def close(self) -> None:
+        self.session.close()
+
+
+def _entries(mail_config: dict) -> list[dict]:
+    return [{**item, "provider_ref": f"{item['type']}#{index + 1}"} for index, item in enumerate(mail_config["providers"])]
+
+
+def _enabled_entries(mail_config: dict) -> list[dict]:
+    items = [item for item in _entries(mail_config) if item.get("enable")]
+    if not items:
+        raise RuntimeError("mail.providers 没有启用的 provider")
+    return items
+
+
+def _next_entry(mail_config: dict) -> dict:
+    global provider_index
+    items = _enabled_entries(mail_config)
+    if len(items) == 1:
+        return dict(items[0])
+    with provider_lock:
+        value = dict(items[provider_index % len(items)])
+        provider_index = (provider_index + 1) % len(items)
+        return value
+
+
+def _create_provider(mail_config: dict, provider: str = "", provider_ref: str = "") -> BaseMailProvider:
+    entry = next((dict(item) for item in _entries(mail_config) if provider_ref and item["provider_ref"] == provider_ref), None)
+    entry = entry or next((dict(item) for item in _enabled_entries(mail_config) if provider and item["type"] == provider), None) or _next_entry(mail_config)
+    conf = _config(mail_config)
+    if entry["type"] == "cloudflare_temp_email":
+        return CloudflareTempMailProvider(entry, conf)
+    if entry["type"] == "tempmail_lol":
+        return TempMailLolProvider(entry, conf)
+    if entry["type"] == "duckmail":
+        return DuckMailProvider(entry, conf)
+    if entry["type"] == "gptmail":
+        return GptMailProvider(entry, conf)
+    raise RuntimeError(f"不支持的 mail.provider: {entry['type']}")
+
+
+def create_mailbox(mail_config: dict, username: str | None = None) -> dict:
+    provider = _create_provider(mail_config)
+    try:
+        return provider.create_mailbox(username)
+    finally:
+        provider.close()
+
+
+def wait_for_code(mail_config: dict, mailbox: dict) -> str | None:
+    provider = _create_provider(mail_config, str(mailbox.get("provider") or ""), str(mailbox.get("provider_ref") or ""))
+    try:
+        return provider.wait_for_code(mailbox)
+    finally:
+        provider.close()

services/register/openai_register.py

@@ -0,0 +1,608 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import random
+import secrets
+import string
+import threading
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from urllib.parse import parse_qs, urlencode, urlparse
+
+import requests
+import urllib3
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from services.account_service import account_service
+from services.register import mail_provider
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+base_dir = Path(__file__).resolve().parent
+config = {
+    "mail": {
+        "request_timeout": 15,
+        "wait_timeout": 30,
+        "wait_interval": 3,
+        "providers": [],
+    },
+    "proxy": "",
+    "total": 20000,
+    "threads": 64,
+}
+register_config_file = base_dir.parents[1] / "data" / "register.json"
+try:
+    saved_config = json.loads(register_config_file.read_text(encoding="utf-8"))
+    config.update({key: saved_config[key] for key in ("mail", "proxy", "total", "threads") if key in saved_config})
+except Exception:
+    pass
+
+auth_base = "https://auth.openai.com"
+platform_base = "https://platform.openai.com"
+platform_oauth_client_id = "app_2SKx67EdpoN0G6j64rFvigXD"
+platform_oauth_redirect_uri = f"{platform_base}/auth/callback"
+platform_oauth_audience = "https://api.openai.com/v1"
+platform_auth0_client = "eyJuYW1lIjoiYXV0aDAtc3BhLWpzIiwidmVyc2lvbiI6IjEuMjEuMCJ9"
+user_agent = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/145.0.0.0 Safari/537.36"
+)
+sec_ch_ua = '"Google Chrome";v="145", "Not?A_Brand";v="8", "Chromium";v="145"'
+sec_ch_ua_full_version_list = '"Chromium";v="145.0.0.0", "Not:A-Brand";v="99.0.0.0", "Google Chrome";v="145.0.0.0"'
+default_timeout = 30
+print_lock = threading.Lock()
+stats_lock = threading.Lock()
+stats = {"done": 0, "success": 0, "fail": 0, "start_time": 0.0}
+register_log_sink = None
+
+common_headers = {
+    "accept": "application/json",
+    "accept-language": "en-US,en;q=0.9",
+    "content-type": "application/json",
+    "origin": auth_base,
+    "priority": "u=1, i",
+    "user-agent": user_agent,
+    "sec-ch-ua": sec_ch_ua,
+    "sec-ch-ua-arch": '"x86_64"',
+    "sec-ch-ua-bitness": '"64"',
+    "sec-ch-ua-full-version-list": sec_ch_ua_full_version_list,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-model": '""',
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-ch-ua-platform-version": '"10.0.0"',
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+}
+
+navigate_headers = {
+    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+    "accept-language": "en-US,en;q=0.9",
+    "user-agent": user_agent,
+    "sec-ch-ua": sec_ch_ua,
+    "sec-ch-ua-arch": '"x86_64"',
+    "sec-ch-ua-bitness": '"64"',
+    "sec-ch-ua-full-version-list": sec_ch_ua_full_version_list,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-model": '""',
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-ch-ua-platform-version": '"10.0.0"',
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "same-origin",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+}
+
+
+def log(text: str, color: str = "") -> None:
+    colors = {"red": "\033[31m", "green": "\033[32m", "yellow": "\033[33m"}
+    if register_log_sink:
+        try:
+            register_log_sink(text, color)
+        except Exception:
+            pass
+    with print_lock:
+        prefix = colors.get(color, "")
+        suffix = "\033[0m" if prefix else ""
+        print(f"{prefix}{datetime.now().strftime('%H:%M:%S')} {text}{suffix}")
+
+
+def step(index: int, text: str, color: str = "") -> None:
+    log(f"[任务{index}] {text}", color)
+
+
+def _make_trace_headers() -> dict[str, str]:
+    trace_id = str(random.getrandbits(64))
+    parent_id = str(random.getrandbits(64))
+    return {
+        "traceparent": f"00-{uuid.uuid4().hex}-{format(int(parent_id), '016x')}-01",
+        "tracestate": "dd=s:1;o:rum",
+        "x-datadog-origin": "rum",
+        "x-datadog-parent-id": parent_id,
+        "x-datadog-sampling-priority": "1",
+        "x-datadog-trace-id": trace_id,
+    }
+
+
+def _generate_pkce() -> tuple[str, str]:
+    code_verifier = base64.urlsafe_b64encode(secrets.token_bytes(64)).rstrip(b"=").decode("ascii")
+    code_challenge = base64.urlsafe_b64encode(hashlib.sha256(code_verifier.encode("ascii")).digest()).rstrip(b"=").decode("ascii")
+    return code_verifier, code_challenge
+
+
+def _random_password(length: int = 16) -> str:
+    chars = string.ascii_letters + string.digits + "!@#$%"
+    value = list(
+        secrets.choice(string.ascii_uppercase)
+        + secrets.choice(string.ascii_lowercase)
+        + secrets.choice(string.digits)
+        + secrets.choice("!@#$%")
+        + "".join(secrets.choice(chars) for _ in range(max(0, length - 4)))
+    )
+    random.shuffle(value)
+    return "".join(value)
+
+
+def _random_name() -> tuple[str, str]:
+    return random.choice(["James", "Robert", "John", "Michael", "David", "Mary", "Emma", "Olivia"]), random.choice(
+        ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller"]
+    )
+
+
+def _random_birthdate() -> str:
+    return f"{random.randint(1996, 2006):04d}-{random.randint(1, 12):02d}-{random.randint(1, 28):02d}"
+
+
+def _response_json(resp) -> dict:
+    try:
+        data = resp.json()
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _decode_jwt_payload(token: str) -> dict:
+    try:
+        payload = token.split(".")[1]
+        padding = 4 - len(payload) % 4
+        if padding != 4:
+            payload += "=" * padding
+        return json.loads(base64.urlsafe_b64decode(payload))
+    except Exception:
+        return {}
+
+
+def create_mailbox(username: str | None = None) -> dict:
+    return mail_provider.create_mailbox(config["mail"], username)
+
+
+def wait_for_code(mailbox: dict) -> str | None:
+    return mail_provider.wait_for_code(config["mail"], mailbox)
+
+
+class SentinelTokenGenerator:
+    MAX_ATTEMPTS = 500000
+    ERROR_PREFIX = "wQ8Lk5FbGpA2NcR9dShT6gYjU7VxZ4D"
+
+    def __init__(self, device_id: str, ua: str):
+        self.device_id = device_id
+        self.user_agent = ua
+        self.sid = str(uuid.uuid4())
+
+    @staticmethod
+    def _fnv1a_32(text: str) -> str:
+        h = 2166136261
+        for ch in text:
+            h ^= ord(ch)
+            h = (h * 16777619) & 0xFFFFFFFF
+        h ^= h >> 16
+        h = (h * 2246822507) & 0xFFFFFFFF
+        h ^= h >> 13
+        h = (h * 3266489909) & 0xFFFFFFFF
+        h ^= h >> 16
+        return format(h & 0xFFFFFFFF, "08x")
+
+    def _get_config(self) -> list:
+        perf_now = random.uniform(1000, 50000)
+        return [
+            "1920x1080",
+            time.strftime("%a %b %d %Y %H:%M:%S GMT+0000 (Coordinated Universal Time)", time.gmtime()),
+            4294705152,
+            random.random(),
+            self.user_agent,
+            "https://sentinel.openai.com/sentinel/20260124ceb8/sdk.js",
+            None,
+            None,
+            "en-US",
+            random.random(),
+            random.choice(["vendorSub-undefined", "plugins-undefined", "mimeTypes-undefined", "hardwareConcurrency-undefined"]),
+            random.choice(["location", "implementation", "URL", "documentURI", "compatMode"]),
+            random.choice(["Object", "Function", "Array", "Number", "parseFloat", "undefined"]),
+            perf_now,
+            self.sid,
+            "",
+            random.choice([4, 8, 12, 16]),
+            time.time() * 1000 - perf_now,
+        ]
+
+    @staticmethod
+    def _b64(data) -> str:
+        return base64.b64encode(json.dumps(data, separators=(",", ":"), ensure_ascii=False).encode("utf-8")).decode("ascii")
+
+    def generate_requirements_token(self) -> str:
+        data = self._get_config()
+        data[3] = 1
+        data[9] = round(random.uniform(5, 50))
+        return "gAAAAAC" + self._b64(data)
+
+    def generate_token(self, seed: str, difficulty: str) -> str:
+        start = time.time()
+        data = self._get_config()
+        difficulty = str(difficulty or "0")
+        for i in range(self.MAX_ATTEMPTS):
+            data[3] = i
+            data[9] = round((time.time() - start) * 1000)
+            payload = self._b64(data)
+            if self._fnv1a_32(seed + payload)[: len(difficulty)] <= difficulty:
+                return "gAAAAAB" + payload + "~S"
+        return "gAAAAAB" + self.ERROR_PREFIX + self._b64(str(None))
+
+
+def build_sentinel_token(session: requests.Session, device_id: str, flow: str) -> str:
+    generator = SentinelTokenGenerator(device_id, user_agent)
+    resp = session.post(
+        "https://sentinel.openai.com/backend-api/sentinel/req",
+        data=json.dumps({"p": generator.generate_requirements_token(), "id": device_id, "flow": flow}),
+        headers={
+            "Content-Type": "text/plain;charset=UTF-8",
+            "Referer": "https://sentinel.openai.com/backend-api/sentinel/frame.html",
+            "Origin": "https://sentinel.openai.com",
+            "User-Agent": user_agent,
+            "sec-ch-ua": sec_ch_ua,
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+        },
+        timeout=20,
+        verify=False,
+    )
+    data = _response_json(resp)
+    token = str(data.get("token") or "").strip()
+    if resp.status_code != 200 or not token:
+        raise RuntimeError(f"sentinel_req_failed_{resp.status_code}")
+    pow_data = data.get("proofofwork") or {}
+    p_value = (
+        generator.generate_token(str(pow_data.get("seed") or ""), str(pow_data.get("difficulty") or "0"))
+        if pow_data.get("required") and pow_data.get("seed")
+        else generator.generate_requirements_token()
+    )
+    return json.dumps({"p": p_value, "t": "", "c": token, "id": device_id, "flow": flow}, separators=(",", ":"))
+
+
+def create_session(proxy: str = "") -> requests.Session:
+    session = requests.Session()
+    retry = Retry(total=2, connect=2, read=2, backoff_factor=0.5, status_forcelist=(429, 500, 502, 503, 504))
+    adapter = HTTPAdapter(max_retries=retry, pool_connections=50, pool_maxsize=50)
+    session.mount("http://", adapter)
+    session.mount("https://", adapter)
+    session.verify = False
+    if proxy:
+        session.proxies.update({"http": proxy, "https": proxy})
+    return session
+
+
+def request_with_local_retry(session: requests.Session, method: str, url: str, retry_attempts: int = 3, **kwargs):
+    last_error = ""
+    for _ in range(max(1, retry_attempts)):
+        try:
+            return session.request(method.upper(), url, timeout=default_timeout, **kwargs), ""
+        except Exception as error:
+            last_error = str(error)
+            time.sleep(1)
+    return None, last_error
+
+
+def validate_otp(session: requests.Session, device_id: str, code: str):
+    headers = dict(common_headers)
+    headers["referer"] = f"{auth_base}/email-verification"
+    headers["oai-device-id"] = device_id
+    headers.update(_make_trace_headers())
+    resp, error = request_with_local_retry(session, "post", f"{auth_base}/api/accounts/email-otp/validate", json={"code": code}, headers=headers, verify=False)
+    if resp is not None and resp.status_code == 200:
+        return resp, ""
+    headers["openai-sentinel-token"] = build_sentinel_token(session, device_id, "authorize_continue")
+    resp, error = request_with_local_retry(session, "post", f"{auth_base}/api/accounts/email-otp/validate", json={"code": code}, headers=headers, verify=False)
+    return resp, error
+
+
+def extract_oauth_callback_params_from_url(url: str) -> dict[str, str] | None:
+    if not url:
+        return None
+    try:
+        params = parse_qs(urlparse(url).query)
+    except Exception:
+        return None
+    code = str((params.get("code") or [""])[0]).strip()
+    if not code:
+        return None
+    return {"code": code, "state": str((params.get("state") or [""])[0]).strip(), "scope": str((params.get("scope") or [""])[0]).strip()}
+
+
+def extract_oauth_callback_params_from_consent_session(session: requests.Session, consent_url: str, device_id: str) -> dict[str, str] | None:
+    if consent_url.startswith("/"):
+        consent_url = f"{auth_base}{consent_url}"
+    current_url = consent_url
+    for _ in range(10):
+        response = session.get(current_url, headers=navigate_headers, verify=False, timeout=30, allow_redirects=False)
+        callback_params = extract_oauth_callback_params_from_url(str(response.url)) or extract_oauth_callback_params_from_url(str(response.headers.get("Location") or "").strip())
+        if callback_params:
+            return callback_params
+        location = str(response.headers.get("Location") or "").strip()
+        if response.status_code not in (301, 302, 303, 307, 308) or not location:
+            break
+        current_url = f"{auth_base}{location}" if location.startswith("/") else location
+    raw = session.cookies.get("oai-client-auth-session", domain=".auth.openai.com") or session.cookies.get("oai-client-auth-session")
+    if not raw:
+        return None
+    try:
+        first_part = raw.split(".")[0]
+        padding = 4 - len(first_part) % 4
+        if padding != 4:
+            first_part += "=" * padding
+        payload = json.loads(base64.urlsafe_b64decode(first_part))
+        workspace_id = payload["workspaces"][0]["id"]
+    except Exception:
+        return None
+    headers = dict(common_headers)
+    headers["referer"] = consent_url
+    headers["oai-device-id"] = device_id
+    headers.update(_make_trace_headers())
+    ws_resp = session.post(f"{auth_base}/api/accounts/workspace/select", json={"workspace_id": workspace_id}, headers=headers, verify=False, timeout=30, allow_redirects=False)
+    callback_params = extract_oauth_callback_params_from_url(str(ws_resp.headers.get("Location") or "").strip())
+    if callback_params:
+        return callback_params
+    ws_data = _response_json(ws_resp)
+    orgs = ((ws_data.get("data") or {}).get("orgs") or []) if isinstance(ws_data, dict) else []
+    if not orgs:
+        return None
+    org_id = str((orgs[0] or {}).get("id") or "").strip()
+    project_id = str(((orgs[0] or {}).get("projects") or [{}])[0].get("id") or "").strip()
+    if not org_id:
+        return None
+    org_headers = dict(common_headers)
+    org_headers["referer"] = str(ws_data.get("continue_url") or consent_url)
+    org_headers["oai-device-id"] = device_id
+    org_headers.update(_make_trace_headers())
+    body = {"org_id": org_id}
+    if project_id:
+        body["project_id"] = project_id
+    org_resp = session.post(f"{auth_base}/api/accounts/organization/select", json=body, headers=org_headers, verify=False, timeout=30, allow_redirects=False)
+    return extract_oauth_callback_params_from_url(str(org_resp.headers.get("Location") or "").strip())
+
+
+def exchange_platform_tokens(session: requests.Session, device_id: str, code_verifier: str, consent_url: str) -> dict | None:
+    callback_params = extract_oauth_callback_params_from_consent_session(session, consent_url, device_id)
+    if not callback_params:
+        return None
+    code = str(callback_params.get("code") or "").strip()
+    if not code:
+        return None
+    resp = create_session(config["proxy"]).post(
+        f"{auth_base}/oauth/token",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        data={
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": platform_oauth_redirect_uri,
+            "client_id": platform_oauth_client_id,
+            "code_verifier": code_verifier,
+        },
+        verify=False,
+        timeout=60,
+    )
+    data = _response_json(resp)
+    if resp.status_code != 200 or not data.get("access_token") or not data.get("refresh_token") or not data.get("id_token"):
+        return None
+    payload = _decode_jwt_payload(str(data.get("id_token") or "")) or _decode_jwt_payload(str(data.get("access_token") or ""))
+    return {
+        "email": str(payload.get("email") or "").strip(),
+        "access_token": str(data.get("access_token") or "").strip(),
+        "refresh_token": str(data.get("refresh_token") or "").strip(),
+        "id_token": str(data.get("id_token") or "").strip(),
+    }
+
+
+class PlatformRegistrar:
+    def __init__(self, proxy: str = "") -> None:
+        self.session = create_session(proxy)
+        self.device_id = str(uuid.uuid4())
+
+    def close(self) -> None:
+        self.session.close()
+
+    def _navigate_headers(self, referer: str = "") -> dict[str, str]:
+        headers = dict(navigate_headers)
+        if referer:
+            headers["referer"] = referer
+        return headers
+
+    def _json_headers(self, referer: str) -> dict[str, str]:
+        headers = dict(common_headers)
+        headers["referer"] = referer
+        headers["oai-device-id"] = self.device_id
+        headers.update(_make_trace_headers())
+        return headers
+
+    def _platform_authorize(self, email: str, index: int) -> None:
+        step(index, "开始 platform authorize")
+        self.session.cookies.set("oai-did", self.device_id, domain=".auth.openai.com")
+        self.session.cookies.set("oai-did", self.device_id, domain="auth.openai.com")
+        _, code_challenge = _generate_pkce()
+        params = {
+            "issuer": auth_base,
+            "client_id": platform_oauth_client_id,
+            "audience": platform_oauth_audience,
+            "redirect_uri": platform_oauth_redirect_uri,
+            "device_id": self.device_id,
+            "screen_hint": "login_or_signup",
+            "max_age": "0",
+            "login_hint": email,
+            "scope": "openid profile email offline_access",
+            "response_type": "code",
+            "response_mode": "query",
+            "state": secrets.token_urlsafe(32),
+            "nonce": secrets.token_urlsafe(32),
+            "code_challenge": code_challenge,
+            "code_challenge_method": "S256",
+            "auth0Client": platform_auth0_client,
+        }
+        resp, error = request_with_local_retry(self.session, "get", f"{auth_base}/api/accounts/authorize?{urlencode(params)}", headers=self._navigate_headers(f"{platform_base}/"), allow_redirects=True, verify=False)
+        if resp is None or resp.status_code != 200:
+            raise RuntimeError(error or f"platform_authorize_http_{getattr(resp, 'status_code', 'unknown')}")
+        step(index, "platform authorize 完成")
+
+    def _register_user(self, email: str, password: str, index: int) -> None:
+        step(index, "开始提交注册密码")
+        headers = self._json_headers(f"{auth_base}/create-account/password")
+        headers["openai-sentinel-token"] = build_sentinel_token(self.session, self.device_id, "username_password_create")
+        resp, error = request_with_local_retry(self.session, "post", f"{auth_base}/api/accounts/user/register", json={"username": email, "password": password}, headers=headers, verify=False)
+        if resp is None or resp.status_code != 200:
+            raise RuntimeError(error or f"user_register_http_{getattr(resp, 'status_code', 'unknown')}")
+        step(index, "提交注册密码完成")
+
+    def _send_otp(self, index: int) -> None:
+        step(index, "开始发送验证码")
+        resp, error = request_with_local_retry(self.session, "get", f"{auth_base}/api/accounts/email-otp/send", headers=self._navigate_headers(f"{auth_base}/create-account/password"), allow_redirects=True, verify=False)
+        if resp is None or resp.status_code not in (200, 302):
+            raise RuntimeError(error or f"send_otp_http_{getattr(resp, 'status_code', 'unknown')}")
+        step(index, "发送验证码完成")
+
+    def _validate_otp(self, code: str, index: int) -> None:
+        step(index, f"开始校验验证码 {code}")
+        resp, error = validate_otp(self.session, self.device_id, code)
+        if resp is None or resp.status_code != 200:
+            raise RuntimeError(error or f"validate_otp_http_{getattr(resp, 'status_code', 'unknown')}")
+        step(index, "验证码校验完成")
+
+    def _create_account(self, name: str, birthdate: str, index: int) -> None:
+        step(index, "开始创建账号资料")
+        headers = self._json_headers(f"{auth_base}/about-you")
+        headers["openai-sentinel-token"] = build_sentinel_token(self.session, self.device_id, "oauth_create_account")
+        resp, error = request_with_local_retry(self.session, "post", f"{auth_base}/api/accounts/create_account", json={"name": name, "birthdate": birthdate}, headers=headers, verify=False)
+        if resp is None or resp.status_code not in (200, 302):
+            raise RuntimeError(error or f"create_account_http_{getattr(resp, 'status_code', 'unknown')}")
+        step(index, "创建账号资料完成")
+
+    def _login_and_exchange_tokens(self, email: str, password: str, mailbox: dict, index: int) -> dict:
+        step(index, "开始独立登录换 token")
+        code_verifier, code_challenge = _generate_pkce()
+        params = {
+            "issuer": auth_base,
+            "client_id": platform_oauth_client_id,
+            "audience": platform_oauth_audience,
+            "redirect_uri": platform_oauth_redirect_uri,
+            "device_id": self.device_id,
+            "screen_hint": "login_or_signup",
+            "max_age": "0",
+            "login_hint": email,
+            "scope": "openid profile email offline_access",
+            "response_type": "code",
+            "response_mode": "query",
+            "state": secrets.token_urlsafe(32),
+            "nonce": secrets.token_urlsafe(32),
+            "code_challenge": code_challenge,
+            "code_challenge_method": "S256",
+            "auth0Client": platform_auth0_client,
+        }
+        resp, error = request_with_local_retry(self.session, "get", f"{auth_base}/api/accounts/authorize?{urlencode(params)}", headers=self._navigate_headers(f"{platform_base}/"), allow_redirects=True, verify=False)
+        if resp is None:
+            raise RuntimeError(error or "platform_login_authorize_failed")
+        step(index, "登录 authorize 完成")
+        headers = self._json_headers(f"{auth_base}/log-in/password")
+        headers["openai-sentinel-token"] = build_sentinel_token(self.session, self.device_id, "password_verify")
+        resp, error = request_with_local_retry(self.session, "post", f"{auth_base}/api/accounts/password/verify", json={"password": password}, headers=headers, allow_redirects=False, verify=False)
+        if resp is None or resp.status_code != 200:
+            raise RuntimeError(error or f"password_verify_http_{getattr(resp, 'status_code', 'unknown')}")
+        step(index, "密码校验完成")
+        payload = _response_json(resp)
+        continue_url = str(payload.get("continue_url") or "").strip()
+        page_type = str(((payload.get("page") or {}).get("type")) or "")
+        if page_type == "email_otp_verification" or "email-verification" in continue_url or "email-otp" in continue_url:
+            step(index, "独立登录需要邮箱验证码")
+            code = wait_for_code(mailbox)
+            if not code:
+                raise RuntimeError("独立登录等待验证码超时")
+            resp, reason = validate_otp(self.session, self.device_id, code)
+            if resp is None or resp.status_code != 200:
+                raise RuntimeError(reason or "独立登录验证码校验失败")
+            otp_payload = _response_json(resp)
+            continue_url = str(otp_payload.get("continue_url") or continue_url).strip()
+            step(index, "独立登录验证码校验完成")
+        if not continue_url:
+            continue_url = f"{auth_base}/sign-in-with-chatgpt/codex/consent"
+        tokens = exchange_platform_tokens(self.session, self.device_id, code_verifier, continue_url)
+        if not tokens:
+            raise RuntimeError("token换取失败")
+        step(index, "token 换取完成")
+        return tokens
+
+    def register(self, index: int) -> dict:
+        step(index, "开始创建邮箱")
+        mailbox = create_mailbox()
+        email = str(mailbox.get("address") or "").strip()
+        if not email:
+            raise RuntimeError("邮箱服务未返回 address")
+        step(index, f"邮箱创建完成: {email}")
+        password = _random_password()
+        first_name, last_name = _random_name()
+        self._platform_authorize(email, index)
+        self._register_user(email, password, index)
+        self._send_otp(index)
+        step(index, "开始等待注册验证码")
+        code = wait_for_code(mailbox)
+        if not code:
+            raise RuntimeError("等待注册验证码超时")
+        step(index, f"收到注册验证码: {code}")
+        self._validate_otp(code, index)
+        self._create_account(f"{first_name} {last_name}", _random_birthdate(), index)
+        tokens = self._login_and_exchange_tokens(email, password, mailbox, index)
+        return {
+            "email": email,
+            "password": password,
+            "access_token": str(tokens.get("access_token") or "").strip(),
+            "refresh_token": str(tokens.get("refresh_token") or "").strip(),
+            "id_token": str(tokens.get("id_token") or "").strip(),
+            "created_at": datetime.now(timezone.utc).isoformat(),
+        }
+
+
+def worker(index: int) -> dict:
+    start = time.time()
+    registrar = PlatformRegistrar(config["proxy"])
+    try:
+        step(index, "任务启动")
+        result = registrar.register(index)
+        cost = time.time() - start
+        access_token = str(result["access_token"])
+        account_service.add_accounts([access_token])
+        account_service.refresh_accounts([access_token])
+        with stats_lock:
+            stats["done"] += 1
+            stats["success"] += 1
+            avg = (time.time() - stats["start_time"]) / stats["success"]
+        log(f'{result["email"]} 注册成功，本次耗时{cost:.1f}s，全局平均每个号注册耗时{avg:.1f}s', "green")
+        return {"ok": True, "index": index, "result": result}
+    except Exception as e:
+        cost = time.time() - start
+        with stats_lock:
+            stats["done"] += 1
+            stats["fail"] += 1
+        log(f"任务{index} 注册失败，本次耗时{cost:.1f}s，原因: {e}", "red")
+        return {"ok": False, "index": index, "error": str(e)}
+    finally:
+        registrar.close()

services/register_service.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import json
+import threading
+import time
+import uuid
+from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
+from datetime import datetime, timezone
+from pathlib import Path
+
+from services.account_service import account_service
+from services.config import DATA_DIR
+from services.register import openai_register
+
+
+REGISTER_FILE = DATA_DIR / "register.json"
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _default_config() -> dict:
+    return {**openai_register.config, "mode": "total", "target_quota": 100, "target_available": 10, "check_interval": 5, "enabled": False, "stats": {"success": 0, "fail": 0, "done": 0, "running": 0, "threads": openai_register.config["threads"], "elapsed_seconds": 0, "avg_seconds": 0, "success_rate": 0, "current_quota": 0, "current_available": 0}}
+
+
+def _normalize(raw: dict) -> dict:
+    cfg = _default_config()
+    cfg.update({k: v for k, v in raw.items() if k not in {"stats", "logs"}})
+    cfg["total"] = max(1, int(cfg.get("total") or 1))
+    cfg["threads"] = max(1, int(cfg.get("threads") or 1))
+    cfg["mode"] = str(cfg.get("mode") or "total").strip() if str(cfg.get("mode") or "total").strip() in {"total", "quota", "available"} else "total"
+    cfg["target_quota"] = max(1, int(cfg.get("target_quota") or 1))
+    cfg["target_available"] = max(1, int(cfg.get("target_available") or 1))
+    cfg["check_interval"] = max(1, int(cfg.get("check_interval") or 5))
+    cfg["proxy"] = str(cfg.get("proxy") or "").strip()
+    cfg["enabled"] = bool(cfg.get("enabled"))
+    stats = {**_default_config()["stats"], **(raw.get("stats") if isinstance(raw.get("stats"), dict) else {}),
+             "threads": cfg["threads"]}
+    cfg["stats"] = stats
+    return cfg
+
+
+class RegisterService:
+    def __init__(self, store_file: Path):
+        self._store_file = store_file
+        self._lock = threading.RLock()
+        self._runner: threading.Thread | None = None
+        self._logs: list[dict] = []
+        openai_register.register_log_sink = self._append_log
+        self._config = self._load()
+        if self._config["enabled"]:
+            self.start()
+
+    def _load(self) -> dict:
+        try:
+            return _normalize(json.loads(self._store_file.read_text(encoding="utf-8")))
+        except Exception:
+            return _normalize({})
+
+    def _save(self) -> None:
+        self._store_file.parent.mkdir(parents=True, exist_ok=True)
+        self._store_file.write_text(json.dumps(self._config, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+    def get(self) -> dict:
+        with self._lock:
+            return json.loads(json.dumps({**self._config, "logs": self._logs[-300:]}, ensure_ascii=False))
+
+    def update(self, updates: dict) -> dict:
+        with self._lock:
+            self._config = _normalize({**self._config, **updates})
+            openai_register.config.update({k: self._config[k] for k in ("mail", "proxy", "total", "threads")})
+            self._save()
+            return self.get()
+
+    def start(self) -> dict:
+        with self._lock:
+            if self._runner and self._runner.is_alive():
+                self._config["enabled"] = True
+                self._save()
+                return self.get()
+            self._config["enabled"] = True
+            self._logs = []
+            metrics = self._pool_metrics()
+            self._config["stats"] = {"job_id": uuid.uuid4().hex, "success": 0, "fail": 0, "done": 0, "running": 0, "threads": self._config["threads"], **metrics, "started_at": _now(), "updated_at": _now()}
+            openai_register.config.update({k: self._config[k] for k in ("mail", "proxy", "total", "threads")})
+            with openai_register.stats_lock:
+                openai_register.stats.update({"done": 0, "success": 0, "fail": 0, "start_time": time.time()})
+            self._save()
+            self._runner = threading.Thread(target=self._run, daemon=True, name="openai-register")
+            self._runner.start()
+            self._append_log(f"注册任务启动，模式={self._config['mode']}，线程数={self._config['threads']}", "yellow")
+            return self.get()
+
+    def stop(self) -> dict:
+        with self._lock:
+            self._config["enabled"] = False
+            self._config["stats"]["updated_at"] = _now()
+            self._save()
+            self._append_log("已请求停止注册任务，正在等待当前运行任务结束", "yellow")
+            return self.get()
+
+    def reset(self) -> dict:
+        with self._lock:
+            self._logs = []
+            self._config["stats"] = {"success": 0, "fail": 0, "done": 0, "running": 0, "threads": self._config["threads"], "elapsed_seconds": 0, "avg_seconds": 0, "success_rate": 0, **self._pool_metrics(), "updated_at": _now()}
+            with openai_register.stats_lock:
+                openai_register.stats.update({"done": 0, "success": 0, "fail": 0, "start_time": 0.0})
+            self._save()
+            return self.get()
+
+    def _append_log(self, text: str, color: str = "") -> None:
+        with self._lock:
+            self._logs.append({"time": _now(), "text": str(text), "level": str(color or "info")})
+            self._logs = self._logs[-300:]
+
+    def _pool_metrics(self) -> dict:
+        items = account_service.list_accounts()
+        normal = [item for item in items if item.get("status") == "正常"]
+        return {
+            "current_quota": sum(int(item.get("quota") or 0) for item in normal if not item.get("imageQuotaUnknown")),
+            "current_available": len(normal),
+        }
+
+    def _target_reached(self, cfg: dict, submitted: int) -> bool:
+        mode = str(cfg.get("mode") or "total")
+        metrics = self._pool_metrics()
+        self._bump(**metrics)
+        if mode == "quota":
+            reached = metrics["current_quota"] >= int(cfg.get("target_quota") or 1)
+            self._append_log(f"检查号池：当前正常账号={metrics['current_available']}，当前剩余额度={metrics['current_quota']}，目标额度={cfg.get('target_quota')}，{'跳过注册' if reached else '继续注册'}", "yellow")
+            return reached
+        if mode == "available":
+            reached = metrics["current_available"] >= int(cfg.get("target_available") or 1)
+            self._append_log(f"检查号池：当前正常账号={metrics['current_available']}，目标账号={cfg.get('target_available')}，当前剩余额度={metrics['current_quota']}，{'跳过注册' if reached else '继续注册'}", "yellow")
+            return reached
+        return submitted >= int(cfg.get("total") or 1)
+
+    def _bump(self, **updates) -> None:
+        with self._lock:
+            self._config["stats"].update(updates)
+            stats = self._config["stats"]
+            started_at = str(stats.get("started_at") or "")
+            if started_at:
+                try:
+                    elapsed = max(0.0, (datetime.now(timezone.utc) - datetime.fromisoformat(started_at)).total_seconds())
+                except Exception:
+                    elapsed = 0.0
+                done = int(stats.get("done") or 0)
+                success = int(stats.get("success") or 0)
+                fail = int(stats.get("fail") or 0)
+                stats["elapsed_seconds"] = round(elapsed, 1)
+                stats["avg_seconds"] = round(elapsed / success, 1) if success else 0
+                stats["success_rate"] = round(success * 100 / max(1, success + fail), 1)
+            self._config["stats"]["updated_at"] = _now()
+            self._save()
+
+    def _run(self) -> None:
+        cfg = self.get()
+        threads = int(cfg["threads"])
+        submitted, done, success, fail = 0, 0, 0, 0
+        with ThreadPoolExecutor(max_workers=threads) as executor:
+            futures = set()
+            while True:
+                while self.get()["enabled"] and not self._target_reached(cfg, submitted) and len(futures) < threads:
+                    submitted += 1
+                    futures.add(executor.submit(openai_register.worker, submitted))
+                self._bump(running=len(futures), done=done, success=success, fail=fail)
+                if not futures and (not self.get()["enabled"] or str(cfg.get("mode") or "total") == "total"):
+                    break
+                if not futures:
+                    time.sleep(max(1, int(cfg.get("check_interval") or 5)))
+                    continue
+                finished, futures = wait(futures, return_when=FIRST_COMPLETED)
+                for future in finished:
+                    done += 1
+                    try:
+                        result = future.result()
+                        success += 1 if result.get("ok") else 0
+                        fail += 0 if result.get("ok") else 1
+                    except Exception:
+                        fail += 1
+        self._bump(running=0, done=done, success=success, fail=fail, finished_at=_now())
+        with self._lock:
+            self._config["enabled"] = False
+            self._save()
+        self._append_log(f"注册任务结束，成功{success}，失败{fail}", "yellow")
+
+
+register_service = RegisterService(REGISTER_FILE)

web/src/app/register/components/register-card.tsx

@@ -0,0 +1,287 @@
+"use client";
+
+import { AlertTriangle, LoaderCircle, Plus, Play, RotateCcw, Save, Square, Trash2, UserPlus } from "lucide-react";
+
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import { Input } from "@/components/ui/input";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Textarea } from "@/components/ui/textarea";
+
+import { useSettingsStore } from "../../settings/store";
+
+export function RegisterCard() {
+  const config = useSettingsStore((state) => state.registerConfig);
+  const isLoading = useSettingsStore((state) => state.isLoadingRegister);
+  const isSaving = useSettingsStore((state) => state.isSavingRegister);
+  const setProxy = useSettingsStore((state) => state.setRegisterProxy);
+  const setTotal = useSettingsStore((state) => state.setRegisterTotal);
+  const setThreads = useSettingsStore((state) => state.setRegisterThreads);
+  const setMode = useSettingsStore((state) => state.setRegisterMode);
+  const setTargetQuota = useSettingsStore((state) => state.setRegisterTargetQuota);
+  const setTargetAvailable = useSettingsStore((state) => state.setRegisterTargetAvailable);
+  const setCheckInterval = useSettingsStore((state) => state.setRegisterCheckInterval);
+  const setMailField = useSettingsStore((state) => state.setRegisterMailField);
+  const addProvider = useSettingsStore((state) => state.addRegisterProvider);
+  const updateProvider = useSettingsStore((state) => state.updateRegisterProvider);
+  const deleteProvider = useSettingsStore((state) => state.deleteRegisterProvider);
+  const save = useSettingsStore((state) => state.saveRegister);
+  const toggle = useSettingsStore((state) => state.toggleRegister);
+  const reset = useSettingsStore((state) => state.resetRegister);
+
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center rounded-xl border border-stone-200 bg-white/80 p-10">
+        <LoaderCircle className="size-5 animate-spin text-stone-400" />
+      </div>
+    );
+  }
+
+  if (!config) return null;
+
+  const stats = config.stats || { success: 0, fail: 0, done: 0, running: 0, threads: config.threads };
+  const providers = config.mail.providers || [];
+  const logs = config.logs || [];
+  const updateProviderType = (index: number, type: string) => {
+    updateProvider(index, {
+      type,
+      enable: true,
+      ...(type === "cloudflare_temp_email" ? { api_base: "", admin_password: "", domain: [] } : {}),
+      ...(type === "tempmail_lol" ? { api_key: "", domain: [] } : {}),
+      ...(type === "duckmail" ? { api_key: "", default_domain: "duckmail.sbs" } : {}),
+      ...(type === "gptmail" ? { api_key: "", default_domain: "" } : {}),
+    });
+  };
+
+  return (
+    <div className="grid h-[calc(100vh-132px)] min-h-[640px] items-stretch gap-0 overflow-hidden rounded-xl border border-stone-200 bg-white/70 xl:grid-cols-2">
+      <section className="space-y-4 overflow-y-auto border-b border-stone-200 p-4 xl:border-r xl:border-b-0">
+          <div className="flex items-start justify-between gap-3">
+            <div className="flex items-center gap-3">
+              <div className="flex size-9 items-center justify-center rounded-md bg-stone-100">
+                <UserPlus className="size-5 text-stone-600" />
+              </div>
+              <div>
+                <h2 className="text-lg font-semibold tracking-tight">注册配置</h2>
+              </div>
+            </div>
+            <Button className="h-9 rounded-xl bg-stone-950 px-4 text-white hover:bg-stone-800" onClick={() => void save()} disabled={isSaving || config.enabled}>
+              {isSaving ? <LoaderCircle className="size-4 animate-spin" /> : <Save className="size-4" />}
+              保存配置
+            </Button>
+          </div>
+
+          <div className="grid gap-4 md:grid-cols-3">
+            <div className="space-y-2">
+              <label className="text-sm text-stone-700">注册模式</label>
+              <Select value={config.mode || "total"} onValueChange={(value) => setMode(value as "total" | "quota" | "available")} disabled={config.enabled}>
+                <SelectTrigger className="h-10 rounded-xl border-stone-200 bg-white">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="total">注册总数</SelectItem>
+                  <SelectItem value="quota">号池剩余额度</SelectItem>
+                  <SelectItem value="available">可用账号数量</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+            <div className="space-y-2">
+              <label className="text-sm text-stone-700">注册总数</label>
+              <Input value={String(config.total)} onChange={(event) => setTotal(event.target.value)} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled || config.mode !== "total"} />
+            </div>
+            <div className="space-y-2">
+              <label className="text-sm text-stone-700">线程数</label>
+              <Input value={String(config.threads)} onChange={(event) => setThreads(event.target.value)} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+            </div>
+            <div className="space-y-2">
+              <label className="text-sm text-stone-700">注册代理</label>
+              <Input value={config.proxy} onChange={(event) => setProxy(event.target.value)} placeholder="http://127.0.0.1:7890" className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+            </div>
+            <div className="space-y-2">
+              <label className="text-sm text-stone-700">目标剩余额度</label>
+              <Input value={String(config.target_quota || "")} onChange={(event) => setTargetQuota(event.target.value)} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled || config.mode !== "quota"} />
+            </div>
+            <div className="space-y-2">
+              <label className="text-sm text-stone-700">目标可用账号</label>
+              <Input value={String(config.target_available || "")} onChange={(event) => setTargetAvailable(event.target.value)} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled || config.mode !== "available"} />
+            </div>
+            <div className="space-y-2">
+              <label className="text-sm text-stone-700">检查间隔（秒）</label>
+              <Input value={String(config.check_interval || "")} onChange={(event) => setCheckInterval(event.target.value)} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled || config.mode === "total"} />
+            </div>
+          </div>
+
+          <div className="space-y-3 border-t border-stone-200 pt-3">
+            <div className="flex items-center justify-between gap-3">
+              <div>
+                <h3 className="text-sm font-semibold text-stone-800">邮箱配置</h3>
+                <p className="mt-1 text-xs text-stone-500">可配置多个 provider，按启用顺序轮换。</p>
+              </div>
+              <Button type="button" variant="outline" className="h-9 rounded-xl border-stone-200 bg-white px-3 text-stone-700" onClick={addProvider} disabled={config.enabled}>
+                <Plus className="size-4" />
+                添加
+              </Button>
+            </div>
+
+            <div className="grid gap-4 md:grid-cols-3">
+              <div className="space-y-2">
+                <label className="text-sm text-stone-700">请求超时</label>
+                <Input value={String(config.mail.request_timeout || "")} onChange={(event) => setMailField("request_timeout", event.target.value)} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+              </div>
+              <div className="space-y-2">
+                <label className="text-sm text-stone-700">等待验证码超时</label>
+                <Input value={String(config.mail.wait_timeout || "")} onChange={(event) => setMailField("wait_timeout", event.target.value)} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+              </div>
+              <div className="space-y-2">
+                <label className="text-sm text-stone-700">轮询间隔</label>
+                <Input value={String(config.mail.wait_interval || "")} onChange={(event) => setMailField("wait_interval", event.target.value)} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+              </div>
+            </div>
+
+            <div className="space-y-3">
+              {providers.map((provider, index) => {
+                const type = String(provider.type || "tempmail_lol");
+                const domains = Array.isArray(provider.domain) ? provider.domain.map(String).join("\n") : "";
+                return (
+                  <div key={index} className="space-y-3 border-t border-stone-200 pt-3 first:border-t-0 first:pt-0">
+                    <div className="flex items-center justify-between gap-3">
+                      <label className="flex items-center gap-3 text-sm text-stone-700">
+                        <Checkbox checked={Boolean(provider.enable)} onCheckedChange={(checked) => updateProvider(index, { enable: Boolean(checked) })} disabled={config.enabled} />
+                        启用
+                      </label>
+                      <button type="button" className="rounded-lg p-2 text-stone-400 transition hover:bg-rose-50 hover:text-rose-500 disabled:opacity-50" onClick={() => deleteProvider(index)} disabled={config.enabled || providers.length <= 1} title="删除 provider">
+                        <Trash2 className="size-4" />
+                      </button>
+                    </div>
+
+                    <div className="grid gap-4 md:grid-cols-2">
+                      <div className="space-y-2">
+                        <label className="text-sm text-stone-700">类型</label>
+                        <Select value={type} onValueChange={(value) => updateProviderType(index, value)} disabled={config.enabled}>
+                          <SelectTrigger className="h-10 rounded-xl border-stone-200 bg-white">
+                            <SelectValue />
+                          </SelectTrigger>
+                          <SelectContent>
+                            <SelectItem value="cloudflare_temp_email">cloudflare_temp_email</SelectItem>
+                            <SelectItem value="tempmail_lol">tempmail_lol</SelectItem>
+                            <SelectItem value="duckmail">duckmail</SelectItem>
+                            <SelectItem value="gptmail">gptmail(未测试)</SelectItem>
+                          </SelectContent>
+                        </Select>
+                      </div>
+                      {type === "cloudflare_temp_email" ? (
+                        <>
+                          <div className="space-y-2">
+                            <label className="text-sm text-stone-700">API Base</label>
+                            <Input value={String(provider.api_base || "")} onChange={(event) => updateProvider(index, { api_base: event.target.value })} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+                          </div>
+                          <div className="space-y-2">
+                            <label className="text-sm text-stone-700">Admin Password</label>
+                            <Input value={String(provider.admin_password || "")} onChange={(event) => updateProvider(index, { admin_password: event.target.value })} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+                          </div>
+                        </>
+                      ) : null}
+                      {type === "tempmail_lol" || type === "duckmail" || type === "gptmail" ? (
+                        <div className="space-y-2">
+                          <label className="text-sm text-stone-700">API Key</label>
+                          <Input value={String(provider.api_key || "")} onChange={(event) => updateProvider(index, { api_key: event.target.value })} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+                        </div>
+                      ) : null}
+                      {type === "duckmail" || type === "gptmail" ? (
+                        <div className="space-y-2">
+                          <label className="text-sm text-stone-700">Default Domain</label>
+                          <Input value={String(provider.default_domain || "")} onChange={(event) => updateProvider(index, { default_domain: event.target.value })} placeholder={type === "duckmail" ? "duckmail.sbs" : ""} className="h-10 rounded-xl border-stone-200 bg-white" disabled={config.enabled} />
+                        </div>
+                      ) : null}
+                    </div>
+
+                    {type === "tempmail_lol" || type === "cloudflare_temp_email" ? (
+                      <div className="space-y-2">
+                        <label className="text-sm text-stone-700">Domain</label>
+                        <Textarea value={domains} onChange={(event) => updateProvider(index, { domain: event.target.value.split(/[\n,]/).map((item) => item.trim()).filter(Boolean) })} placeholder="每行一个域名，留空则使用服务默认域名" className="min-h-20 rounded-xl border-stone-200 bg-white font-mono text-xs" disabled={config.enabled} />
+                      </div>
+                    ) : null}
+                  </div>
+                );
+              })}
+            </div>
+          </div>
+
+      </section>
+
+      <section className="flex min-h-0 flex-col p-4">
+        <div className="space-y-3">
+            <div className="flex items-start justify-between gap-3">
+              <div>
+                <h2 className="text-lg font-semibold tracking-tight">运行结果</h2>
+                <p className="mt-1 text-sm text-stone-500">SSE 实时推送当前状态。</p>
+              </div>
+              <Badge variant={config.enabled ? "success" : "secondary"} className="rounded-md">
+                {config.enabled ? "运行中" : "已停止"}
+              </Badge>
+            </div>
+            <div className="grid grid-cols-4 gap-2">
+              {[
+                ["成功 / 成功率", `${stats.success} / ${stats.success_rate || 0}%`],
+                ["失败", stats.fail],
+                ["完成", stats.done],
+                ["运行 / 线程", `${stats.running} / ${stats.threads}`],
+                ["运行时间", `${stats.elapsed_seconds || 0}s`],
+                ["平均注册单个", `${stats.avg_seconds || 0}s`],
+                ["当前额度", stats.current_quota || 0],
+                ["正常账号", stats.current_available || 0],
+              ].map(([label, value]) => (
+                <div key={label} className="border border-stone-200 bg-white/70 px-3 py-2">
+                  <div className="text-xs text-stone-400">{label}</div>
+                  <div className="mt-1 text-base font-semibold text-stone-800">{value}</div>
+                </div>
+              ))}
+            </div>
+            <div className="grid grid-cols-3 gap-2">
+              <Button className="h-10 rounded-xl bg-stone-950 px-3 text-white hover:bg-stone-800" onClick={() => void toggle()} disabled={isSaving}>
+                {isSaving ? <LoaderCircle className="size-4 animate-spin" /> : config.enabled ? <Square className="size-4" /> : <Play className="size-4" />}
+                {config.enabled ? "停止" : "启动"}
+              </Button>
+              <Button variant="outline" className="h-10 rounded-xl border-stone-200 bg-white px-3 text-stone-700" onClick={() => void reset()} disabled={isSaving || config.enabled}>
+                <RotateCcw className="size-4" />
+                重置
+              </Button>
+              <Button variant="outline" className="h-10 rounded-xl border-stone-200 bg-white px-3 text-stone-700" onClick={() => void save()} disabled={isSaving || config.enabled}>
+                <Save className="size-4" />
+                保存
+              </Button>
+            </div>
+            <div className="flex items-center gap-2 border border-amber-200 bg-amber-50 px-3 py-2 text-xs text-amber-800">
+              <AlertTriangle className="size-4 shrink-0" />
+              启动之前注意先保存配置。
+            </div>
+        </div>
+
+        <div className="mt-4 flex min-h-0 flex-1 flex-col space-y-3 overflow-hidden border-t border-stone-200 pt-4">
+            <div className="flex items-center justify-between">
+              <div>
+                <h3 className="text-sm font-semibold text-stone-900">实时日志</h3>
+                <p className="mt-1 text-xs text-stone-500">只保留内存中的最近 300 条。</p>
+              </div>
+              <Badge variant="secondary" className="rounded-md">
+                {logs.length}
+              </Badge>
+            </div>
+            <div className="min-h-0 flex-1 overflow-y-auto border border-stone-200 bg-white/70 p-3 font-mono text-xs leading-6">
+              {logs.length === 0 ? (
+                <div className="text-stone-500">暂无日志</div>
+              ) : (
+                logs.slice().reverse().map((item, index) => (
+                  <div key={`${item.time}-${index}`} className={item.level === "red" ? "text-rose-600" : item.level === "green" ? "text-emerald-700" : item.level === "yellow" ? "text-amber-700" : "text-stone-700"}>
+                    <span className="text-stone-400">{new Date(item.time).toLocaleTimeString()}</span>
+                    <span className="pl-2">{item.text}</span>
+                  </div>
+                ))
+              )}
+            </div>
+        </div>
+      </section>
+    </div>
+  );
+}

web/src/app/register/page.tsx

@@ -0,0 +1,74 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+import { LoaderCircle } from "lucide-react";
+
+import webConfig from "@/constants/common-env";
+import { useAuthGuard } from "@/lib/use-auth-guard";
+import type { RegisterConfig } from "@/lib/api";
+import { getStoredAuthKey } from "@/store/auth";
+
+import { useSettingsStore } from "../settings/store";
+import { RegisterCard } from "./components/register-card";
+
+function RegisterDataController() {
+  const didLoadRef = useRef(false);
+  const loadRegister = useSettingsStore((state) => state.loadRegister);
+  const setRegisterConfig = useSettingsStore((state) => state.setRegisterConfig);
+
+  useEffect(() => {
+    if (didLoadRef.current) return;
+    didLoadRef.current = true;
+    void loadRegister();
+  }, [loadRegister]);
+
+  useEffect(() => {
+    let source: EventSource | null = null;
+    let closed = false;
+    void getStoredAuthKey().then((token) => {
+      if (closed || !token) return;
+      const baseUrl = webConfig.apiUrl.replace(/\/$/, "");
+      source = new EventSource(`${baseUrl}/api/register/events?token=${encodeURIComponent(token)}`);
+      source.onmessage = (event) => {
+        setRegisterConfig(JSON.parse(event.data) as RegisterConfig);
+      };
+    });
+    return () => {
+      closed = true;
+      source?.close();
+    };
+  }, [setRegisterConfig]);
+
+  return null;
+}
+
+function RegisterPageContent() {
+  return (
+    <>
+      <RegisterDataController />
+      <section className="mb-2 flex flex-col gap-1 lg:flex-row lg:items-start lg:justify-between">
+        <div className="space-y-1">
+          <div className="text-xs font-semibold tracking-[0.18em] text-stone-500 uppercase">Register</div>
+          <h1 className="text-2xl font-semibold tracking-tight">ChatGPT注册机</h1>
+        </div>
+      </section>
+      <section>
+        <RegisterCard />
+      </section>
+    </>
+  );
+}
+
+export default function RegisterPage() {
+  const { isCheckingAuth, session } = useAuthGuard(["admin"]);
+
+  if (isCheckingAuth || !session || session.role !== "admin") {
+    return (
+      <div className="flex min-h-[40vh] items-center justify-center">
+        <LoaderCircle className="size-5 animate-spin text-stone-400" />
+      </div>
+    );
+  }
+
+  return <RegisterPageContent />;
+}

web/src/app/settings/store.ts

@@ -8,12 +8,18 @@ import {
   deleteCPAPool,
   fetchCPAPoolFiles,
   fetchCPAPools,
+  fetchRegisterConfig,
+  resetRegister as resetRegisterApi,
   fetchSettingsConfig,
+  startRegister,
   startCPAImport,
+  stopRegister,
   updateCPAPool,
+  updateRegisterConfig,
   updateSettingsConfig,
   type CPAPool,
   type CPARemoteFile,
+  type RegisterConfig,
   type SettingsConfig,
 } from "@/lib/api";
 
@@ -55,6 +61,10 @@ type SettingsStore = {
   isLoadingConfig: boolean;
   isSavingConfig: boolean;
 
+  registerConfig: RegisterConfig | null;
+  isLoadingRegister: boolean;
+  isSavingRegister: boolean;
+
   pools: CPAPool[];
   isLoadingPools: boolean;
   deletingId: string | null;
@@ -87,6 +97,23 @@ type SettingsStore = {
   setProxy: (value: string) => void;
   setBaseUrl: (value: string) => void;
 
+  loadRegister: (silent?: boolean) => Promise<void>;
+  setRegisterConfig: (config: RegisterConfig) => void;
+  setRegisterProxy: (value: string) => void;
+  setRegisterTotal: (value: string) => void;
+  setRegisterThreads: (value: string) => void;
+  setRegisterMode: (value: "total" | "quota" | "available") => void;
+  setRegisterTargetQuota: (value: string) => void;
+  setRegisterTargetAvailable: (value: string) => void;
+  setRegisterCheckInterval: (value: string) => void;
+  setRegisterMailField: (key: "request_timeout" | "wait_timeout" | "wait_interval", value: string) => void;
+  addRegisterProvider: () => void;
+  updateRegisterProvider: (index: number, updates: Record<string, unknown>) => void;
+  deleteRegisterProvider: (index: number) => void;
+  saveRegister: () => Promise<void>;
+  toggleRegister: () => Promise<void>;
+  resetRegister: () => Promise<void>;
+
   loadPools: (silent?: boolean) => Promise<void>;
   openAddDialog: () => void;
   openEditDialog: (pool: CPAPool) => void;
@@ -113,6 +140,10 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
   isLoadingConfig: true,
   isSavingConfig: false,
 
+  registerConfig: null,
+  isLoadingRegister: true,
+  isSavingRegister: false,
+
   pools: [],
   isLoadingPools: true,
   deletingId: null,
@@ -240,6 +271,159 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
     });
   },
 
+  loadRegister: async (silent = false) => {
+    if (!silent) set({ isLoadingRegister: true });
+    try {
+      const data = await fetchRegisterConfig();
+      set({ registerConfig: data.register });
+    } catch (error) {
+      if (!silent) toast.error(error instanceof Error ? error.message : "加载注册配置失败");
+    } finally {
+      if (!silent) set({ isLoadingRegister: false });
+    }
+  },
+
+  setRegisterConfig: (config) => {
+    set({ registerConfig: config, isLoadingRegister: false });
+  },
+
+  setRegisterProxy: (value) => {
+    set((state) => state.registerConfig ? { registerConfig: { ...state.registerConfig, proxy: value } } : {});
+  },
+
+  setRegisterTotal: (value) => {
+    set((state) => state.registerConfig ? { registerConfig: { ...state.registerConfig, total: Number(value) || 0 } } : {});
+  },
+
+  setRegisterThreads: (value) => {
+    set((state) => state.registerConfig ? { registerConfig: { ...state.registerConfig, threads: Number(value) || 0 } } : {});
+  },
+
+  setRegisterMode: (value) => {
+    set((state) => state.registerConfig ? { registerConfig: { ...state.registerConfig, mode: value } } : {});
+  },
+
+  setRegisterTargetQuota: (value) => {
+    set((state) => state.registerConfig ? { registerConfig: { ...state.registerConfig, target_quota: Number(value) || 0 } } : {});
+  },
+
+  setRegisterTargetAvailable: (value) => {
+    set((state) => state.registerConfig ? { registerConfig: { ...state.registerConfig, target_available: Number(value) || 0 } } : {});
+  },
+
+  setRegisterCheckInterval: (value) => {
+    set((state) => state.registerConfig ? { registerConfig: { ...state.registerConfig, check_interval: Number(value) || 0 } } : {});
+  },
+
+  setRegisterMailField: (key, value) => {
+    set((state) => state.registerConfig ? {
+      registerConfig: {
+        ...state.registerConfig,
+        mail: { ...state.registerConfig.mail, [key]: Number(value) || 0 },
+      },
+    } : {});
+  },
+
+  addRegisterProvider: () => {
+    set((state) => state.registerConfig ? {
+      registerConfig: {
+        ...state.registerConfig,
+        mail: {
+          ...state.registerConfig.mail,
+          providers: [
+            ...(state.registerConfig.mail.providers || []),
+            { enable: true, type: "tempmail_lol", api_key: "", domain: [] },
+          ],
+        },
+      },
+    } : {});
+  },
+
+  updateRegisterProvider: (index, updates) => {
+    set((state) => {
+      if (!state.registerConfig) return {};
+      const providers = [...(state.registerConfig.mail.providers || [])];
+      providers[index] = { ...(providers[index] || {}), ...updates };
+      return { registerConfig: { ...state.registerConfig, mail: { ...state.registerConfig.mail, providers } } };
+    });
+  },
+
+  deleteRegisterProvider: (index) => {
+    set((state) => state.registerConfig ? {
+      registerConfig: {
+        ...state.registerConfig,
+        mail: {
+          ...state.registerConfig.mail,
+          providers: (state.registerConfig.mail.providers || []).filter((_, itemIndex) => itemIndex !== index),
+        },
+      },
+    } : {});
+  },
+
+  saveRegister: async () => {
+    const { registerConfig } = get();
+    if (!registerConfig) return;
+    try {
+      set({ isSavingRegister: true });
+      const data = await updateRegisterConfig({
+        mail: registerConfig.mail,
+        proxy: registerConfig.proxy.trim(),
+        total: Math.max(1, Number(registerConfig.total) || 1),
+        threads: Math.max(1, Number(registerConfig.threads) || 1),
+        mode: registerConfig.mode,
+        target_quota: Math.max(1, Number(registerConfig.target_quota) || 1),
+        target_available: Math.max(1, Number(registerConfig.target_available) || 1),
+        check_interval: Math.max(1, Number(registerConfig.check_interval) || 5),
+      });
+      set({ registerConfig: data.register });
+      toast.success("注册配置已保存");
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "保存注册配置失败");
+    } finally {
+      set({ isSavingRegister: false });
+    }
+  },
+
+  toggleRegister: async () => {
+    const { registerConfig } = get();
+    if (!registerConfig) return;
+    set({ isSavingRegister: true });
+    try {
+      if (!registerConfig.enabled) {
+        await updateRegisterConfig({
+          mail: registerConfig.mail,
+          proxy: registerConfig.proxy.trim(),
+          total: Math.max(1, Number(registerConfig.total) || 1),
+          threads: Math.max(1, Number(registerConfig.threads) || 1),
+          mode: registerConfig.mode,
+          target_quota: Math.max(1, Number(registerConfig.target_quota) || 1),
+          target_available: Math.max(1, Number(registerConfig.target_available) || 1),
+          check_interval: Math.max(1, Number(registerConfig.check_interval) || 5),
+        });
+      }
+      const data = registerConfig.enabled ? await stopRegister() : await startRegister();
+      set({ registerConfig: data.register });
+      toast.success(registerConfig.enabled ? "注册任务已停止" : "注册任务已启动");
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "切换注册状态失败");
+    } finally {
+      set({ isSavingRegister: false });
+    }
+  },
+
+  resetRegister: async () => {
+    set({ isSavingRegister: true });
+    try {
+      const data = await resetRegisterApi();
+      set({ registerConfig: data.register });
+      toast.success("注册统计已重置");
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "重置注册统计失败");
+    } finally {
+      set({ isSavingRegister: false });
+    }
+  },
+
   loadPools: async (silent = false) => {
     if (!silent) {
       set({ isLoadingPools: true });

web/src/components/top-nav.tsx

@@ -12,6 +12,7 @@ import { cn } from "@/lib/utils";
 const adminNavItems = [
   { href: "/image", label: "画图" },
   { href: "/accounts", label: "号池管理" },
+  { href: "/register", label: "注册机" },
   { href: "/image-manager", label: "图片管理" },
   { href: "/logs", label: "日志管理" },
   { href: "/settings", label: "设置" },

web/src/lib/api.ts

@@ -98,6 +98,44 @@ export type UserKey = {
   last_used_at: string | null;
 };
 
+export type RegisterConfig = {
+  enabled: boolean;
+  mail: {
+    request_timeout: number;
+    wait_timeout: number;
+    wait_interval: number;
+    providers: Array<Record<string, unknown>>;
+  };
+  proxy: string;
+  total: number;
+  threads: number;
+  mode: "total" | "quota" | "available";
+  target_quota: number;
+  target_available: number;
+  check_interval: number;
+  stats: {
+    job_id?: string;
+    success: number;
+    fail: number;
+    done: number;
+    running: number;
+    threads: number;
+    elapsed_seconds?: number;
+    avg_seconds?: number;
+    success_rate?: number;
+    current_quota?: number;
+    current_available?: number;
+    started_at?: string;
+    updated_at?: string;
+    finished_at?: string;
+  };
+  logs?: Array<{
+    time: string;
+    text: string;
+    level: string;
+  }>;
+};
+
 export async function login(authKey: string) {
   const normalizedAuthKey = String(authKey || "").trim();
   return httpRequest<LoginResponse>("/auth/login", {
@@ -245,6 +283,29 @@ export async function deleteUserKey(keyId: string) {
   });
 }
 
+export async function fetchRegisterConfig() {
+  return httpRequest<{ register: RegisterConfig }>("/api/register");
+}
+
+export async function updateRegisterConfig(updates: Partial<RegisterConfig>) {
+  return httpRequest<{ register: RegisterConfig }>("/api/register", {
+    method: "POST",
+    body: updates,
+  });
+}
+
+export async function startRegister() {
+  return httpRequest<{ register: RegisterConfig }>("/api/register/start", { method: "POST" });
+}
+
+export async function stopRegister() {
+  return httpRequest<{ register: RegisterConfig }>("/api/register/stop", { method: "POST" });
+}
+
+export async function resetRegister() {
+  return httpRequest<{ register: RegisterConfig }>("/api/register/reset", { method: "POST" });
+}
+
 // ── CPA (CLIProxyAPI) ──────────────────────────────────────────────
 
 export type CPAPool = {