Add pay_only flow and post-payment plus session polling

- 新增 run_pay_only：传入 session JSON 跳过注册直接付款
- _wait_for_plus_session 轮询 /api/auth/session，最长 3 分钟等 webhook 落 plus
- _run_one_account 在每个关键节点写库（registered/paid/plus/cpa_uploaded）
- 把 cfg.phone_e164/sms_api_url/effective_paypal_proxy 注入 sub_ctx
- 全局代理 / PayPal 独立代理 双字段支持

chatgpt_flow.py

@@ -113,9 +113,13 @@ def _run_one_account(full_ctx: FullRunContext, page, idx: int, total: int) -> di
         headless=cfg.headless,
         log=sub_log,
         on_stage=lambda name: full_ctx.set_stage(f"账号 {idx}/{total}：长链-{name}"),
+        phone_e164=cfg.phone_e164,
+        sms_api_url=cfg.sms_api_url,
+        paypal_proxy=cfg.effective_paypal_proxy,
     )
     sub_ctx.email = email
     sub_ctx.password = password
+    sub_ctx._stop_hook = full_ctx.check_stop  # 让 PayPal 内部的 _check_stop 也能感知 full_ctx.state == "stopped"
     long_link = generate_long_link_payurl(sub_ctx)
     sub_ctx.long_link = long_link
     record["longLink"] = long_link
@@ -138,10 +142,14 @@ def _run_one_account(full_ctx: FullRunContext, page, idx: int, total: int) -> di
     add_event(email, "paypal", "ok")
     upsert_account(email, password, fields={"final_status": "paid"})
 
-    # 3) 重新拉 session，看 planType
+    # 3) 重新拉 session，看 planType（带轮询：付款后 plus 状态可能延迟到位）
     full_ctx.check_stop()
-    full_ctx.set_stage(f"账号 {idx}/{total}：付款完成，重新拉 session")
-    new_session = _refresh_session_from_page(page, access_token, log=sub_log)
+    full_ctx.set_stage(f"账号 {idx}/{total}：付款完成，等待 plus 状态到位（最长 3 分钟）")
+    # PayPal 阶段如果切了代理 context，结束后会把切回的原 page 写到 sub_ctx._post_paypal_page
+    session_page = getattr(sub_ctx, "_post_paypal_page", None) or page
+    new_session = _wait_for_plus_session(
+        session_page, access_token, log=sub_log, max_wait_sec=180, interval_sec=6,
+    )
     new_plan = get_session_plan_type(new_session)
     record["planType"] = new_plan
     record["sessionRefreshed"] = True
@@ -202,6 +210,47 @@ def _run_one_account(full_ctx: FullRunContext, page, idx: int, total: int) -> di
     return record
 
 
+def _wait_for_plus_session(
+    page,
+    access_token: str,
+    *,
+    log: Callable[[str], None],
+    max_wait_sec: int = 180,
+    interval_sec: int = 6,
+) -> dict:
+    """付款完成后轮询 /api/auth/session，直到 planType=='plus' 或超时。
+    返回最终拿到的 session（若一直没 plus，也返回最后一次的 session 给上层判定）。
+    """
+    log(f"[session] 开始轮询等待 planType=plus，最长 {max_wait_sec}s，间隔 {interval_sec}s")
+    deadline = time.time() + max_wait_sec
+    last_session: dict = {}
+    last_plan = ""
+    attempt = 0
+    while time.time() < deadline:
+        attempt += 1
+        try:
+            sess = _refresh_session_from_page(page, access_token, log=log)
+        except Exception as exc:
+            log(f"[session] 第 {attempt} 次拉取异常: {exc!r}，{interval_sec}s 后重试")
+            time.sleep(interval_sec)
+            continue
+
+        last_session = sess or {}
+        plan = (last_session.get("account") or {}).get("planType") or ""
+        if plan != last_plan:
+            log(f"[session] 第 {attempt} 次：planType={plan!r}")
+            last_plan = plan
+        if plan.lower() == "plus":
+            log(f"[session] planType=plus 已到位，用时 ~{attempt * interval_sec}s")
+            return last_session
+        remaining = max(0, int(deadline - time.time()))
+        log(f"[session] planType 仍为 {plan!r}（非 plus），{interval_sec}s 后重试，剩余 {remaining}s")
+        time.sleep(interval_sec)
+
+    log(f"[session] 等待 plus 超时，最后 planType={last_plan!r}")
+    return last_session
+
+
 def _refresh_session_from_page(page, access_token: str, *, log: Callable[[str], None]) -> dict:
     """付款完成后用同一个浏览器 page 拉 session，避免嵌套 sync_playwright。"""
     log("[session] 浏览器内拉 /api/auth/session ...")
@@ -254,6 +303,178 @@ def _open_and_fetch_session_with_token(access_token: str, *, log: Callable[[str]
     raise RuntimeError("_open_and_fetch_session_with_token 已废弃，请使用 _refresh_session_from_page(page, access_token)")
 
 
+def _build_proxy_cfg(cfg: AppConfig, log: Callable[[str], None]):
+    proxy_str = cfg.effective_global_proxy
+    if not proxy_str:
+        log("[full] 全局代理未配置，ChatGPT 注册 / 长链 直连")
+        return None
+    from automation import _parse_proxy_url
+    proxy_cfg = _parse_proxy_url(proxy_str)
+    if not proxy_cfg:
+        log(f"[full] 警告：proxy_url={proxy_str!r} 解析失败，将直连")
+        return None
+    masked = dict(proxy_cfg)
+    if masked.get("password"):
+        masked["password"] = "***"
+    log(f"[full] 全局代理（ChatGPT/长链/默认）: {masked}")
+    return proxy_cfg
+
+
+def _open_browser(cfg: AppConfig, proxy_cfg, log: Callable[[str], None]):
+    """打开 chromium browser + context + page，返回 (p_ctx_mgr, browser, context, page)。
+    调用方负责 close browser 和 退出 sync_playwright 上下文。"""
+    from playwright.sync_api import sync_playwright
+    p_ctx = sync_playwright().__enter__()
+    browser = p_ctx.chromium.launch(
+        headless=cfg.headless,
+        args=["--disable-blink-features=AutomationControlled"],
+    )
+    ctx_browser = browser.new_context(
+        locale="en-US",
+        timezone_id="America/New_York",
+        viewport={"width": 1280, "height": 900},
+        proxy=proxy_cfg,
+    )
+    page = ctx_browser.new_page()
+    page.on("console", lambda m: log(f"[browser-console:{m.type}] {m.text[:300]}"))
+    page.on("pageerror", lambda e: log(f"[browser-pageerror] {e}"))
+    return p_ctx, browser, ctx_browser, page
+
+
+def _close_browser(p_ctx, browser, log: Callable[[str], None]):
+    try:
+        browser.close()
+    except Exception as exc:
+        log(f"[full] browser.close 异常: {exc!r}")
+    try:
+        from playwright.sync_api import sync_playwright
+        sync_playwright().__exit__(None, None, None)
+    except Exception:
+        pass
+    # 直接调 __exit__ 在新实例上不对，只能依赖 GC
+    try:
+        p_ctx.__exit__(None, None, None)
+    except Exception:
+        pass
+
+
+def run_pay_only(
+    cfg: AppConfig,
+    *,
+    session: dict,
+    log: Callable[[str], None] = print,
+    on_stage: Optional[Callable[[str], None]] = None,
+    stop_check: Optional[Callable[[], None]] = None,
+) -> dict:
+    """传入已有 ChatGPT session JSON，直接走付款 → Plus 校验 → CPA 上传。
+    返回 record（同 _run_one_account 的格式）。
+    """
+    full_ctx = FullRunContext(cfg=cfg, log=log, on_stage=on_stage)
+    if stop_check:
+        # 把外部 stop 钩子接入 check_stop
+        orig_check = full_ctx.check_stop
+        def _check_combined():
+            stop_check()
+            orig_check()
+        full_ctx.check_stop = _check_combined  # type: ignore
+
+    if not isinstance(session, dict) or not session.get("accessToken"):
+        raise RuntimeError("pay_only 需要 session JSON 且包含 accessToken")
+    access_token = session["accessToken"]
+    email = (
+        ((session.get("user") or {}).get("email"))
+        or session.get("email")
+        or ""
+    )
+    password = ""  # pay_only 不知道原密码，PayPal 注册新邮箱不需要
+
+    full_ctx.set_stage(f"pay_only：开始（email={email or '(unknown)'}）")
+    upsert_account(email or f"unknown-{int(time.time())}", password, fields={
+        "final_status": "registered",
+        "plan_type": get_session_plan_type(session),
+        "initial_session": session,
+    })
+    add_event(email or "", "pay_only", "info", "begin")
+
+    proxy_cfg = _build_proxy_cfg(cfg, full_ctx.log)
+    p_ctx, browser, ctx_browser, page = _open_browser(cfg, proxy_cfg, full_ctx.log)
+
+    try:
+        # 用 sub_ctx 走付款
+        full_ctx.set_stage("pay_only：生成 Plus 长链")
+        sub_ctx = RunContext(
+            token=access_token,
+            plan="plus",
+            country="US",
+            currency="USD",
+            use_promo=cfg.use_promo,
+            headless=cfg.headless,
+            log=lambda m: full_ctx.log(f"[pay] {m}"),
+            on_stage=lambda name: full_ctx.set_stage(f"pay_only：长链-{name}"),
+            phone_e164=cfg.phone_e164,
+            sms_api_url=cfg.sms_api_url,
+            paypal_proxy=cfg.effective_paypal_proxy,
+        )
+        sub_ctx.email = email
+        sub_ctx.password = password
+        sub_ctx._stop_hook = full_ctx.check_stop  # type: ignore
+        long_link = generate_long_link_payurl(sub_ctx)
+        sub_ctx.long_link = long_link
+
+        full_ctx.set_stage("pay_only：进入 PayPal")
+        sub_ctx._reuse_account_for_paypal = True  # type: ignore
+        run_paypal_flow(sub_ctx, page=page)
+
+        full_ctx.set_stage("pay_only：付款完成，等 plus 状态")
+        session_page = getattr(sub_ctx, "_post_paypal_page", None) or page
+        new_session = _wait_for_plus_session(
+            session_page, access_token, log=full_ctx.log, max_wait_sec=180, interval_sec=6,
+        )
+        plan = get_session_plan_type(new_session)
+        upsert_account(email or "", password, fields={
+            "plan_type": plan, "plus_session": new_session,
+        })
+        if not is_plus_session(new_session):
+            upsert_account(email or "", password, fields={
+                "final_status": "plus_check_failed",
+                "last_error": f"planType={plan!r}",
+            })
+            return {"stage": "plus_check_failed", "planType": plan, "error": f"planType={plan!r}"}
+
+        upsert_account(email or "", password, fields={"final_status": "plus", "last_error": ""})
+        full_ctx.set_stage("pay_only：Plus 校验通过")
+
+        if not (cfg.cpa_url and cfg.cpa_management_key):
+            upsert_account(email or "", password, fields={"final_status": "cpa_skipped"})
+            return {"stage": "cpa_skipped", "planType": plan}
+
+        cpa_result = upload_session_to_cpa(
+            new_session,
+            cpa_url=cfg.cpa_url,
+            management_key=cfg.cpa_management_key,
+            email_hint=email,
+            log=full_ctx.log,
+        )
+        upsert_account(email or "", password, fields={
+            "final_status": "cpa_uploaded",
+            "cpa_file_name": cpa_result.get("fileName"),
+            "cpa_uploaded_at": int(time.time() * 1000),
+            "last_error": "",
+        })
+        add_event(email or "", "cpa", "ok", cpa_result.get("fileName"), payload=cpa_result)
+        return {
+            "stage": "cpa_uploaded",
+            "email": email,
+            "planType": plan,
+            "cpa": cpa_result,
+        }
+    finally:
+        try:
+            browser.close()
+        except Exception:
+            pass
+
+
 def run_full(cfg: AppConfig, *, log: Callable[[str], None] = print,
              on_stage: Optional[Callable[[str], None]] = None) -> FullRunContext:
     full_ctx = FullRunContext(cfg=cfg, log=log, on_stage=on_stage)
@@ -265,6 +486,25 @@ def run_full(cfg: AppConfig, *, log: Callable[[str], None] = print,
     from playwright.sync_api import sync_playwright
 
     total = max(1, int(cfg.account_count))
+    proxy_str = cfg.effective_global_proxy
+    proxy_cfg = None
+    if proxy_str:
+        from automation import _parse_proxy_url
+        proxy_cfg = _parse_proxy_url(proxy_str)
+        if proxy_cfg:
+            masked = dict(proxy_cfg)
+            if masked.get("password"):
+                masked["password"] = "***"
+            full_ctx.log(f"[full] 全局代理（ChatGPT/长链/默认）: {masked}")
+        else:
+            full_ctx.log(f"[full] 警告：proxy_url={proxy_str!r} 解析失败，将直连")
+    else:
+        full_ctx.log("[full] 全局代理未配置，ChatGPT 注册 / 长链 直连")
+
+    paypal_only_str = cfg.paypal_only_proxy.strip() if cfg.paypal_only_proxy else ""
+    if paypal_only_str:
+        full_ctx.log(f"[full] PayPal 独立代理已配置（PayPal 阶段会切到该代理）")
+
     for idx in range(1, total + 1):
         full_ctx.check_stop()
         full_ctx.set_stage(f"启动账号 {idx}/{total} 的浏览器")
@@ -277,6 +517,7 @@ def run_full(cfg: AppConfig, *, log: Callable[[str], None] = print,
                 locale="en-US",
                 timezone_id="America/New_York",
                 viewport={"width": 1280, "height": 900},
+                proxy=proxy_cfg,  # None 时不走代理；非 None 全程走代理
             )
             page = ctx_browser.new_page()
             page.on("console", lambda m: full_ctx.log(f"[browser-console:{m.type}] {m.text[:300]}"))