Remove server remote browser support

backend/app/routers/custom_pages.py

@@ -1,7 +1,6 @@
 """Custom pages CRUD router + authenticated iframe proxy."""
 from __future__ import annotations
 
-import logging
 import re
 from datetime import datetime, timezone
 from typing import Any, List, Literal, Optional
@@ -18,12 +17,8 @@ from app.models.admin_user import AdminUser
 from app.models.custom_page import CustomPage
 from app.models.upstream import Upstream
 from app.services.upstream_client import _find_user_id
-from app.services.auth_capture_service import extract_all
-from app.services.browser_session_service import browser_sessions
 from app.utils.auth import decode_token, get_current_user, get_user_from_token_param
 
-logger = logging.getLogger(__name__)
-
 router = APIRouter(prefix="/api/custom-pages", tags=["custom-pages"])
 
 # Headers that prevent iframe embedding — strip them from proxied responses
@@ -45,7 +40,7 @@ class CustomPageCreate(BaseModel):
     sort_order: int = 0
     enabled: bool = True
     use_proxy: bool = False
-    access_mode: Literal["direct", "proxy", "remote_browser"] = "direct"
+    access_mode: Literal["direct", "proxy"] = "direct"
     description: Optional[str] = None
     login_username: Optional[str] = None
     login_password: Optional[str] = None
@@ -63,7 +58,7 @@ class CustomPageUpdate(BaseModel):
     sort_order: Optional[int] = None
     enabled: Optional[bool] = None
     use_proxy: Optional[bool] = None
-    access_mode: Optional[Literal["direct", "proxy", "remote_browser"]] = None
+    access_mode: Optional[Literal["direct", "proxy"]] = None
     description: Optional[str] = None
     login_username: Optional[str] = None
     login_password: Optional[str] = None
@@ -118,7 +113,7 @@ def _page_response(page: CustomPage) -> CustomPageResponse:
         sort_order=page.sort_order,
         enabled=page.enabled,
         use_proxy=page.use_proxy,
-        access_mode=page.access_mode,
+        access_mode="proxy" if page.use_proxy or page.access_mode == "proxy" else "direct",
         description=page.description,
         login_username=page.login_username,
         login_username_selector=page.login_username_selector,
@@ -143,6 +138,8 @@ def list_pages(db: Session = Depends(get_db), _=Depends(get_current_user)):
 @router.post("", response_model=CustomPageResponse, status_code=201)
 def create_page(body: CustomPageCreate, db: Session = Depends(get_db), _=Depends(get_current_user)):
     data = body.model_dump()
+    if "access_mode" not in body.model_fields_set and data.get("use_proxy"):
+        data["access_mode"] = "proxy"
     data["use_proxy"] = data["access_mode"] == "proxy"
     for key in (
         "login_username",
@@ -210,166 +207,6 @@ def delete_page(pid: int, db: Session = Depends(get_db), _=Depends(get_current_u
     db.commit()
 
 
-# ---- One-click refresh auth ----
-
-import json as _json
-
-
-class RefreshAuthResponse(BaseModel):
-    success: bool
-    message: str
-    warning: Optional[str] = None
-
-
-def _norm_path(value: Any) -> str:
-    return str(value or "").strip().rstrip("/")
-
-
-def _detect_upstream_platform(upstream: Upstream, auth_config: dict) -> str:
-    api_prefix = _norm_path(upstream.api_prefix)
-    groups_endpoint = _norm_path(upstream.groups_endpoint)
-    rate_endpoint = _norm_path(upstream.rate_endpoint)
-    login_path = _norm_path(auth_config.get("login_path"))
-
-    if groups_endpoint == "/api/user/self/groups" or login_path == "/api/user/login":
-        return "new-api-user"
-    if api_prefix == "/api/v1" or groups_endpoint in {"/groups/available", "/groups/rates"} or login_path == "/auth/login":
-        return "sub2api"
-    return "unknown"
-
-
-def _first_candidate(candidates: list[dict], *types: str) -> Optional[dict]:
-    for c in candidates:
-        if c.get("type") in types:
-            return c
-    return None
-
-
-def _pick_best_candidate(candidates: list[dict], preferred_auth_type: str, platform: str = "unknown") -> Optional[dict]:
-    if not candidates:
-        return None
-
-    if platform == "sub2api":
-        return _first_candidate(candidates, "bearer_token", "api_key")
-    if platform == "new-api-user":
-        return _first_candidate(candidates, "cookie_bundle", "cookie", "bearer_token", "api_key")
-    if preferred_auth_type == "cookie":
-        return _first_candidate(candidates, "cookie_bundle", "cookie")
-    elif preferred_auth_type in ("bearer", "api_key"):
-        type_map = {"bearer": "bearer_token", "api_key": "api_key"}
-        preferred = type_map.get(preferred_auth_type)
-        if preferred:
-            return _first_candidate(candidates, preferred)
-    # fallback：排序后取第一个
-    return candidates[0]
-
-
-@router.post("/{pid}/refresh-auth", response_model=RefreshAuthResponse)
-async def refresh_auth(pid: int, db: Session = Depends(get_db), _=Depends(get_current_user)):
-    page = db.query(CustomPage).filter(CustomPage.id == pid).first()
-    if not page:
-        raise HTTPException(404, "page not found")
-    if page.access_mode != "remote_browser":
-        raise HTTPException(400, "page is not in remote_browser mode")
-    if not page.linked_upstream_id:
-        raise HTTPException(400, "page has no linked upstream")
-    upstream = db.query(Upstream).filter(Upstream.id == page.linked_upstream_id).first()
-    if not upstream:
-        raise HTTPException(404, "linked upstream not found")
-
-    try:
-        session = browser_sessions.find_by_page_id(page.id)
-    except KeyError:
-        return RefreshAuthResponse(success=False, message="请先打开远程浏览器并登录")
-
-    try:
-        result = await extract_all(session)
-    except Exception as exc:
-        return RefreshAuthResponse(success=False, message=f"提取失败: {exc}")
-
-    candidates = result.get("candidates", [])
-    existing_config = _json.loads(upstream.auth_config_json or "{}")
-    platform = _detect_upstream_platform(upstream, existing_config)
-    candidate = _pick_best_candidate(candidates, upstream.auth_type, platform)
-    if not candidate:
-        if platform == "sub2api" and _first_candidate(candidates, "cookie_bundle", "cookie"):
-            return RefreshAuthResponse(
-                success=False,
-                message="Sub2API 需要 Bearer Token；当前只提取到 Cookie。请在远程浏览器完成登录后刷新页面或触发一次接口请求，再重新提取。",
-            )
-        return RefreshAuthResponse(success=False, message="未提取到有效凭证，请确认已在远程浏览器中登录")
-
-    ctype = candidate["type"]
-
-    if ctype in ("cookie_bundle", "cookie"):
-        upstream.auth_type = "cookie"
-        # cookie_bundle.value 已是完整 cookie_string；cookie.value 是 "name=value" 格式
-        existing_config["cookie_string"] = candidate.get("value", "")
-        if candidate.get("new_api_user"):
-            existing_config["new_api_user"] = candidate["new_api_user"]
-            if platform == "new-api-user":
-                upstream.api_prefix = ""
-                upstream.groups_endpoint = "/api/user/self/groups"
-                upstream.rate_endpoint = "/api/user/self/groups"
-    elif ctype == "bearer_token":
-        upstream.auth_type = "bearer"
-        raw = candidate.get("value", "")
-        # Clean up: strip whitespace, remove "Bearer " prefix if present
-        token = raw.strip()
-        if token.startswith("Bearer "):
-            token = token[7:].strip()
-        # Validate token can be used as HTTP header value
-        try:
-            token.encode("latin-1")
-        except UnicodeEncodeError:
-            return RefreshAuthResponse(
-                success=False,
-                message="提取到的 Token 含有非 HTTP 标头字符，请确认已在远程浏览器中正确登录并重试",
-            )
-        existing_config["token"] = token
-    elif ctype == "api_key":
-        upstream.auth_type = "api_key"
-        existing_config["key"] = candidate.get("value", "")
-        existing_config.setdefault("header", "X-API-Key")
-
-    upstream.auth_config_json = _json.dumps(existing_config, ensure_ascii=False)
-    upstream.updated_at = datetime.now(timezone.utc)
-
-    # ── 宽松验证：写回后尝试调用 get_available_groups 验证凭证可用性 ──
-    # 失败时仍然 commit（凭证已写入），但在 message 里说明验证失败
-    # 这样用户仍能看到新凭证已写入，便于 debug（cf_clearance 绑 IP 时验证必然失败）
-    warning_msg: Optional[str] = None
-    try:
-        from app.services.upstream_client import UpstreamClient
-        groups_endpoint = upstream.groups_endpoint or "/groups/available"
-        new_auth_config = _json.loads(upstream.auth_config_json)
-        with UpstreamClient(
-            base_url=upstream.base_url,
-            api_prefix=upstream.api_prefix or "",
-            auth_type=upstream.auth_type,
-            auth_config=new_auth_config,
-            timeout=float(upstream.timeout_seconds or 30),
-        ) as uc:
-            uc.get_available_groups(groups_endpoint)
-        logger.info("refresh_auth: upstream %s credential verification passed", upstream.id)
-    except Exception as exc:
-        warning_msg = (
-            f"凭证已写入但 API 验证失败：{exc}。"
-            "若 SmartUp 与远程浏览器不在同一 IP，cf_clearance 可能无法复用，请手动测试连接。"
-        )
-        logger.warning(
-            "refresh_auth: upstream %s credential verification failed (written anyway): %s",
-            upstream.id, exc,
-        )
-
-    db.commit()
-    auth_type_label = upstream.auth_type
-    cookie_count = candidate.get("cookie_count", "")
-    count_str = f"（{cookie_count} 个 cookie）" if cookie_count else ""
-    success_msg = f"凭证已刷新 ({auth_type_label}{count_str})"
-    return RefreshAuthResponse(success=True, message=success_msg, warning=warning_msg)
-
-
 # ---- Frame Proxy (simple: strip X-Frame-Options / CSP, pass through content) ----
 
 _STRIP_RESP = {