Release v1.1.0

Author: AuuCoder

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.1.0 - 2026-07-23
+
++ [新增] OpenAI 账号存活追踪、跨进程 scheduler lease 和手动探测接口；网络或 Token 异常仅记录当次失败，不直接判定账号停用。
++ [新增] Outlook Token 邮箱池改用 SQLite lease 原子预占，支持多进程注册与旧 JSON 状态自动迁移，避免并发 worker 重复领取或覆盖新状态。
++ [新增] Codex Agent Identity 独立加密归档，支持单账号 `auth.json` 和批量 ZIP 导出，私钥不写入普通账号列表。
++ [修复] Grok 默认切换到已验证的 xconsole 注册链路，对齐无 Castle 发码、`ValidatePassword`、`tos=$undefined` 和创建阶段空 Castle；真实 OAuth 探测可获得 100 万 Token 初始额度，同时保留旧链路回退。
++ [优化] Grok Device Code OAuth 优先复用已有 SSO，失效时再回退邮箱密码；增加可选 Authorization Code + PKCE 对照授权和 402 权益延迟复检。
++ [优化] 本地 Turnstile 不再受 solver 内部固定 2 线程隐藏阀限制；注册页“注册解题并发”成为唯一控制项，默认为 2，设为 0 可取消共享并发上限。
+
 ## 1.0.9 - 2026-07-22
 
 + [新增] GPT 对接 Sub2API 支持 Codex Agent Identity 新模式；兼容新版 JWT claims、Cloudflare WARP 重试，并在上游不支持 Agent Identity 时自动降级为 Codex Session 导入。

README.md

@@ -50,6 +50,14 @@ docker compose -f docker-compose.warp.yml --profile local-icloud up -d
 
 定时创建按账号执行：新接口每个账号每小时最多 `20` 个，旧接口每个账号每小时最多 `5` 个；两种登录态都保存后每小时最多 `25` 个。每个账号累计达到 `750` 个后自动停止该账号，所有账号达到目标后定时器自动结束。控制台支持按选中账号启动定时创建，默认每 `60` 分钟执行一轮；邮箱卡片可直接查看或复制邮箱地址、单邮箱 API 及 `邮箱----API` 组合。
 
+## OpenAI 注册归档与存活追踪
+
+Outlook Token 邮箱池使用 `data/outlook_token_used.db` 原子预占邮箱，支持多进程注册；旧版 `data/outlook_token_used.json` 会在首次访问时自动迁移。每次领取都有独立 lease，超时 worker 不会覆盖邮箱后来产生的新状态。
+
+OpenAI 注册默认把 Agent Identity 独立加密归档到 `data/openai_agent_identities.db`，密钥保存在权限为 `0600` 的 `data/openai_agent_identities.key`，私钥不会写入普通账号列表。账号页可以导出单账号 `auth.json` 或多账号 ZIP；列表元数据接口为 `GET /api/accounts/agent-identities`。
+
+OpenAI 存活追踪默认每 `60` 分钟运行，并通过跨进程 scheduler lease 避免重复探测。配置、状态和手动执行接口分别为 `POST /api/register/openai/survival`、`GET /api/register/openai/survival` 和 `POST /api/register/openai/survival/run`；Token 失效或网络错误只记为本次探测失败，不会直接把账号判定为停用。
+
 ## Grok 后台探测与自动恢复
 
 Grok 账号探测随服务启动自动在后台运行，无需在账号管理页手动启用或点击执行。默认每 `60` 分钟运行一轮，每批处理 `50` 个账号；首次启动且没有历史完成记录时会立即执行。

VERSION

@@ -1 +1 @@
-1.0.9
+1.1.0

api/accounts.py

@@ -31,11 +31,13 @@
 from services.oauth_login_service import OAuthLoginError, oauth_login_service
 from services.sub2api_service import (
     build_openai_oauth_export_account,
+    ensure_openai_agent_identity,
     list_remote_accounts as sub2api_list_remote_accounts,
     list_remote_groups as sub2api_list_remote_groups,
     sub2api_config,
     sub2api_import_service,
 )
+from services.openai_agent_identity_store import openai_agent_identity_store
 
 
 
@@ -71,7 +73,7 @@ class AccountRefreshRequest(BaseModel):
 
 class AccountExportRequest(BaseModel):
     access_tokens: list[str] = Field(default_factory=list)
-    format: Literal["json", "zip", "cpa", "sub2api"] = "json"
+    format: Literal["json", "zip", "cpa", "sub2api", "agent_identity"] = "json"
 
 
 class AccountUpdateRequest(BaseModel):
@@ -748,14 +750,71 @@ async def get_refresh_progress(progress_id: str, authorization: str | None = Hea
     async def export_accounts(body: AccountExportRequest, authorization: str | None = Header(default=None)):
         require_admin(authorization)
         access_tokens = _unique_tokens(body.access_tokens)
+        timestamp = _download_timestamp()
+
+        if body.format == "agent_identity":
+            selected = set(access_tokens)
+            accounts = [
+                account
+                for account in account_service.list_accounts()
+                if not selected or _account_payload_token(account) in selected
+            ]
+            auth_items: list[dict[str, Any]] = []
+            errors: list[str] = []
+            for account in accounts:
+                try:
+                    auth_items.append(ensure_openai_agent_identity(account))
+                except Exception as exc:
+                    label = _clean_text(account.get("email")) or "unknown account"
+                    errors.append(f"{label}: {str(exc)[:200]}")
+            if not auth_items:
+                detail = "；".join(errors[:3]) or "没有可导出的 Agent Identity"
+                raise HTTPException(status_code=400, detail={"error": detail})
+            if len(auth_items) == 1:
+                return Response(
+                    json.dumps(auth_items[0], ensure_ascii=False, indent=2) + "\n",
+                    media_type="application/json",
+                    headers={
+                        "Cache-Control": "no-store",
+                        "Content-Disposition": 'attachment; filename="auth.json"',
+                    },
+                )
+            archive = io.BytesIO()
+            used_names: set[str] = set()
+            with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as bundle:
+                for index, auth_json in enumerate(auth_items, start=1):
+                    identity = auth_json.get("agent_identity") if isinstance(auth_json, dict) else {}
+                    identity = identity if isinstance(identity, dict) else {}
+                    base_name = _safe_export_name(
+                        _clean_text(identity.get("email")),
+                        f"account-{index}",
+                    )
+                    name = base_name
+                    suffix = 2
+                    while name in used_names:
+                        name = f"{base_name}-{suffix}"
+                        suffix += 1
+                    used_names.add(name)
+                    bundle.writestr(
+                        f"{name}/auth.json",
+                        json.dumps(auth_json, ensure_ascii=False, indent=2) + "\n",
+                    )
+            return Response(
+                archive.getvalue(),
+                media_type="application/zip",
+                headers={
+                    "Cache-Control": "no-store",
+                    "Content-Disposition": f'attachment; filename="openai-agent-identities-{timestamp}.zip"',
+                },
+            )
+
         items = account_service.build_export_items(access_tokens)
         if not items:
             raise HTTPException(
                 status_code=400,
                 detail={"error": "没有可导出的完整账号，需要同时有 access_token、refresh_token 和 id_token"},
             )
 
-        timestamp = _download_timestamp()
         if body.format in {"zip", "cpa"}:
             content = _account_zip_bytes(items)
             return Response(
@@ -783,6 +842,12 @@ async def export_accounts(body: AccountExportRequest, authorization: str | None
             headers={"Content-Disposition": f'attachment; filename="codex-accounts-{timestamp}.json"'},
         )
 
+    @router.get("/api/accounts/agent-identities")
+    async def list_agent_identities(authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        items = openai_agent_identity_store.summary()
+        return {"total": len(items), "items": items}
+
     @router.post("/api/accounts/update")
     async def update_account(body: AccountUpdateRequest, authorization: str | None = Header(default=None)):
         require_admin(authorization)

api/accounts_test.py

@@ -60,6 +60,21 @@ def setUp(self) -> None:
             "last_refresh": "2029-01-01T00:00:00+00:00",
         }
 
+    @staticmethod
+    def _agent_identity(account_id: str, email: str) -> dict:
+        return {
+            "auth_mode": "agent_identity",
+            "agent_identity": {
+                "agent_runtime_id": f"runtime-{account_id}",
+                "agent_private_key": f"private-{account_id}",
+                "account_id": account_id,
+                "chatgpt_user_id": f"user-{account_id}",
+                "email": email,
+                "plan_type": "free",
+                "chatgpt_account_is_fedramp": False,
+            },
+        }
+
     def test_sub2api_export_uses_standard_account_envelope(self) -> None:
         with patch.object(accounts_api, "require_admin"), patch.object(
             accounts_api.account_service,
@@ -100,6 +115,78 @@ def test_cpa_export_is_zip_of_codex_auth_files(self) -> None:
         self.assertEqual(exported["type"], "codex")
         self.assertEqual(exported["access_token"], "access-token")
 
+    def test_single_agent_identity_export_is_auth_json(self) -> None:
+        auth_json = self._agent_identity("one", "one@example.test")
+        with patch.object(accounts_api, "require_admin"), patch.object(
+            accounts_api.account_service,
+            "list_accounts",
+            return_value=[self.item],
+        ), patch.object(
+            accounts_api,
+            "ensure_openai_agent_identity",
+            return_value=auth_json,
+        ):
+            response = self.client.post(
+                "/api/accounts/export",
+                json={"access_tokens": ["access-token"], "format": "agent_identity"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.headers["content-type"], "application/json")
+        self.assertEqual(response.headers["content-disposition"], 'attachment; filename="auth.json"')
+        self.assertEqual(response.json(), auth_json)
+
+    def test_multiple_agent_identity_export_is_zip(self) -> None:
+        accounts = [
+            {**self.item, "access_token": "token-one", "email": "one@example.test"},
+            {**self.item, "access_token": "token-two", "email": "two@example.test"},
+        ]
+        identities = [
+            self._agent_identity("one", "one@example.test"),
+            self._agent_identity("two", "two@example.test"),
+        ]
+        with patch.object(accounts_api, "require_admin"), patch.object(
+            accounts_api.account_service,
+            "list_accounts",
+            return_value=accounts,
+        ), patch.object(
+            accounts_api,
+            "ensure_openai_agent_identity",
+            side_effect=identities,
+        ):
+            response = self.client.post(
+                "/api/accounts/export",
+                json={"access_tokens": [], "format": "agent_identity"},
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.headers["content-type"], "application/zip")
+        with zipfile.ZipFile(io.BytesIO(response.content)) as archive:
+            self.assertEqual(archive.namelist(), [
+                "one-example.test/auth.json",
+                "two-example.test/auth.json",
+            ])
+            exported = [json.loads(archive.read(name)) for name in archive.namelist()]
+        self.assertEqual(exported, identities)
+
+    def test_agent_identity_list_does_not_include_private_keys(self) -> None:
+        summaries = [{
+            "account_id": "one",
+            "email": "one@example.test",
+            "agent_runtime_id": "runtime-one",
+            "updated_at": "2030-01-01T00:00:00+00:00",
+        }]
+        with patch.object(accounts_api, "require_admin"), patch.object(
+            accounts_api.openai_agent_identity_store,
+            "summary",
+            return_value=summaries,
+        ):
+            response = self.client.get("/api/accounts/agent-identities")
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"total": 1, "items": summaries})
+        self.assertNotIn("agent_private_key", response.text)
+
 
 if __name__ == "__main__":
     unittest.main()

api/app.py

@@ -36,6 +36,7 @@
 from services.log_service import cleanup_old_logs, start_log_cleanup_scheduler
 from services.grok_runtime import grok_runtime
 from services.register_service import register_service
+from services.openai_survival_service import openai_survival_service
 from services.realtime_monitor_service import realtime_monitor_service
 from utils.log import logger
 
@@ -77,6 +78,7 @@ async def lifespan(host_app: FastAPI):
             cleanup_thread = start_image_cleanup_scheduler(stop_event)
             log_cleanup_thread = start_log_cleanup_scheduler(stop_event)
             register_service.start_grok_probe_scheduler(stop_event)
+            openai_survival_thread = openai_survival_service.start_scheduler(stop_event)
             backup_service.start()
             config.cleanup_old_images()
             cleanup_old_logs()
@@ -88,6 +90,8 @@ async def lifespan(host_app: FastAPI):
                 cleanup_thread.join(timeout=1)
                 log_cleanup_thread.join(timeout=1)
                 register_service.stop_grok_probe_scheduler()
+                openai_survival_service.stop_scheduler()
+                openai_survival_thread.join(timeout=1)
                 try:
                     dashboard_metrics_service.flush()
                 except Exception as exc:

api/register.py

@@ -12,6 +12,7 @@
 
 from api.support import require_admin
 from services.register_service import GrokAccountChatTestError, register_service
+from services.openai_survival_service import openai_survival_service
 
 
 class RegisterConfigRequest(BaseModel):
@@ -20,6 +21,7 @@ class RegisterConfigRequest(BaseModel):
     mail: dict | None = None
     checkout: dict | None = None
     sub2api_sync: dict | None = None
+    agent_identity_archive: dict | None = None
     proxy: str | None = None
     total: int | None = None
     threads: int | None = None
@@ -43,6 +45,13 @@ class GptMailStatusRequest(BaseModel):
     force: bool | None = None
 
 
+class OpenAISurvivalConfigRequest(BaseModel):
+    enabled: bool | None = None
+    interval_minutes: int | None = Field(default=None, ge=15, le=1440)
+    concurrency: int | None = Field(default=None, ge=1, le=8)
+    refresh_codex_rt: bool | None = None
+
+
 class GrokAccountIdsRequest(BaseModel):
     ids: list[str] = Field(default_factory=list)
 
@@ -55,6 +64,10 @@ class GrokAccountDisabledRequest(GrokAccountIdsRequest):
     disabled: bool
 
 
+class GrokProbePollingRequest(BaseModel):
+    enabled: bool
+
+
 class GrokAccountChatTestRequest(BaseModel):
     prompt: str = Field(min_length=1, max_length=1_200)
     model: str | None = Field(default=None, max_length=128)
@@ -144,6 +157,31 @@ async def refresh_gptmail_public_key(body: GptMailStatusRequest, authorization:
         except Exception as exc:
             raise HTTPException(status_code=400, detail=str(exc)) from exc
 
+    @router.get("/api/register/openai/survival")
+    async def get_openai_survival(authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        return {"survival": openai_survival_service.status()}
+
+    @router.post("/api/register/openai/survival")
+    async def update_openai_survival(
+        body: OpenAISurvivalConfigRequest,
+        authorization: str | None = Header(default=None),
+    ):
+        require_admin(authorization)
+        try:
+            status = openai_survival_service.update_config(body.model_dump(exclude_none=True))
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {"survival": status}
+
+    @router.post("/api/register/openai/survival/run")
+    async def run_openai_survival(authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        return {
+            "started": openai_survival_service.run_now(),
+            "survival": openai_survival_service.status(),
+        }
+
     @router.get("/api/register/grok/accounts")
     async def list_grok_accounts(
         page: int = Query(default=1, ge=1),
@@ -171,8 +209,17 @@ async def list_grok_accounts(
             "summary": view.get("summary") if isinstance(view.get("summary"), dict) else {},
             "runtime_available": bool(view.get("runtime_available")),
             "runtime_error": str(view.get("runtime_error") or ""),
+            "probe_scheduler": register_service.grok_probe_scheduler_status(),
         }
 
+    @router.post("/api/register/grok/probe-polling")
+    async def set_grok_probe_polling(
+        body: GrokProbePollingRequest,
+        authorization: str | None = Header(default=None),
+    ):
+        require_admin(authorization)
+        return {"probe_scheduler": register_service.set_grok_probe_scheduler_enabled(body.enabled)}
+
     @router.post("/api/register/grok/accounts/runtime/snapshot")
     async def refresh_grok_runtime_snapshot(authorization: str | None = Header(default=None)):
         require_admin(authorization)

api/register_test.py

@@ -38,7 +38,11 @@ def test_list_grok_accounts_supports_filters_and_pagination(self) -> None:
             register_api.register_service,
             "grok_accounts_view",
             return_value=view,
-        ) as list_accounts:
+        ) as list_accounts, patch.object(
+            register_api.register_service,
+            "grok_probe_scheduler_status",
+            return_value={"enabled": False, "running": False, "next_run_at": ""},
+        ):
             response = self.client.get(
                 "/api/register/grok/accounts",
                 params={
@@ -62,10 +66,24 @@ def test_list_grok_accounts_supports_filters_and_pagination(self) -> None:
                 "summary": {"total": 8, "synced": 3},
                 "runtime_available": True,
                 "runtime_error": "",
+                "probe_scheduler": {"enabled": False, "running": False, "next_run_at": ""},
             },
         )
         list_accounts.assert_called_once_with(keyword="example", status="active")
 
+    def test_grok_probe_polling_toggle_uses_persistent_service_setting(self) -> None:
+        status = {"enabled": True, "running": False, "next_run_at": "2030-01-01T00:00:00+00:00"}
+        with patch.object(register_api, "require_admin"), patch.object(
+            register_api.register_service,
+            "set_grok_probe_scheduler_enabled",
+            return_value=status,
+        ) as toggle:
+            response = self.client.post("/api/register/grok/probe-polling", json={"enabled": True})
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"probe_scheduler": status})
+        toggle.assert_called_once_with(True)
+
     def test_stop_checkout_retries_uses_dedicated_service_action(self) -> None:
         response_payload = {"enabled": False, "checkout_tasks": [{"status": "cancelled"}]}
         with patch.object(register_api, "require_admin"), patch.object(