Fix OAuth status reporting and recovery wakeups

Author: AuuCoder

app/platform/update_check.py

@@ -15,6 +15,7 @@
 
 _GITHUB_RELEASES_API_URL = "https://api.github.com/repos/AuuCoder/gptGrok2api/releases?per_page=20"
 _GITHUB_CHANGELOG_URL = "https://raw.githubusercontent.com/AuuCoder/gptGrok2api/main/CHANGELOG.md"
+_GITHUB_VERSION_URL = "https://raw.githubusercontent.com/AuuCoder/gptGrok2api/main/VERSION"
 _RELEASE_PAGE_URL = "https://github.com/AuuCoder/gptGrok2api/releases"
 _CACHE_TTL_SECONDS = 86400.0
 _ERROR_TTL_SECONDS = 300.0
@@ -88,7 +89,7 @@ def _success_cache_ttl(payload: dict[str, Any]) -> float:
     current_version = str(payload.get("current_version") or "")
     latest_version = str(payload.get("latest_version") or "")
     changelog = str(payload.get("changelog") or "")
-    release_pending = _is_newer(current_version, latest_version)
+    release_pending = bool(payload.get("release_pending")) or _is_newer(current_version, latest_version)
     has_unreleased_notes = bool(re.search(r"^##\s+Unreleased\s*$", changelog, re.MULTILINE))
     if release_pending or has_unreleased_notes:
         return _ERROR_TTL_SECONDS
@@ -104,6 +105,7 @@ def _build_payload(release: dict[str, Any] | None = None, error: str = "") -> di
     published_at = str(release.get("published_at") or "").strip()
     release_notes = str(release.get("body") or "").strip()
     changelog = str(release.get("changelog") or "").strip()
+    release_pending = bool(release.get("release_pending"))
     has_remote = bool(release)
     return {
         "current_version": current_version,
@@ -113,6 +115,7 @@ def _build_payload(release: dict[str, Any] | None = None, error: str = "") -> di
         "published_at": published_at,
         "release_notes": release_notes,
         "changelog": changelog,
+        "release_pending": release_pending,
         "update_available": has_remote and bool(latest_version) and _is_newer(latest_version, current_version),
         "checked_at": _utc_now_iso(),
         "status": "error" if error else "ok",
@@ -152,16 +155,34 @@ async def _fetch_github_changelog(session: aiohttp.ClientSession) -> str:
     return await _fetch_github_text(session, _GITHUB_CHANGELOG_URL, "text/plain")
 
 
+async def _fetch_github_version(session: aiohttp.ClientSession) -> str:
+    version = _normalize_version(
+        await _fetch_github_text(session, _GITHUB_VERSION_URL, "text/plain")
+    )
+    if _parse_version(version) is None:
+        raise RuntimeError("GitHub VERSION returned an invalid version")
+    return version
+
+
 async def _fetch_latest_release() -> dict[str, Any]:
     timeout = aiohttp.ClientTimeout(total=10)
     async with aiohttp.ClientSession(timeout=timeout) as session:
-        releases, changelog = await asyncio.gather(
+        releases, changelog, repository_version = await asyncio.gather(
             _fetch_github_releases(session),
             _fetch_github_changelog(session),
+            _fetch_github_version(session),
         )
     latest = _select_latest_release(releases)
-    if latest is None:
-        raise RuntimeError("GitHub Releases returned no published version")
+    released_version = _normalize_version(
+        str((latest or {}).get("tag_name") or (latest or {}).get("name") or "")
+    )
+    if latest is None or _is_newer(repository_version, released_version):
+        latest = {
+            "tag_name": f"v{repository_version}",
+            "name": f"v{repository_version}",
+            "html_url": _RELEASE_PAGE_URL,
+            "release_pending": True,
+        }
     return {**latest, "changelog": changelog}
 
 

app/platform/update_check_test.py

@@ -45,6 +45,16 @@ def test_success_cache_uses_short_ttl_while_release_is_pending(self):
 
         self.assertEqual(update_check._success_cache_ttl(payload), update_check._ERROR_TTL_SECONDS)
 
+    def test_success_cache_uses_short_ttl_for_repository_version_fallback(self):
+        payload = {
+            "current_version": "1.2.0",
+            "latest_version": "1.2.0",
+            "changelog": "# Changelog\n\n## 1.2.0 - 2026-07-25\n",
+            "release_pending": True,
+        }
+
+        self.assertEqual(update_check._success_cache_ttl(payload), update_check._ERROR_TTL_SECONDS)
+
     def test_success_cache_uses_short_ttl_for_unreleased_changelog(self):
         payload = {
             "current_version": "1.0.4",
@@ -76,12 +86,45 @@ async def test_fetch_latest_release_combines_github_release_and_changelog(self):
             update_check,
             "_fetch_github_changelog",
             new=AsyncMock(return_value="# Changelog"),
+        ), patch.object(
+            update_check,
+            "_fetch_github_version",
+            new=AsyncMock(return_value="1.0.3"),
         ):
             release = await update_check._fetch_latest_release()
 
         self.assertEqual(release["tag_name"], "v1.0.3")
         self.assertEqual(release["changelog"], "# Changelog")
 
+    async def test_fetch_latest_release_falls_back_to_repository_version(self):
+        releases = [
+            {
+                "tag_name": "v1.1.0",
+                "name": "v1.1.0",
+                "draft": False,
+                "html_url": "https://github.com/AuuCoder/gptGrok2api/releases/tag/v1.1.0",
+            }
+        ]
+        with patch.object(
+            update_check,
+            "_fetch_github_releases",
+            new=AsyncMock(return_value=releases),
+        ), patch.object(
+            update_check,
+            "_fetch_github_changelog",
+            new=AsyncMock(return_value="# Changelog\n\n## 1.2.0"),
+        ), patch.object(
+            update_check,
+            "_fetch_github_version",
+            new=AsyncMock(return_value="1.2.0"),
+        ):
+            release = await update_check._fetch_latest_release()
+
+        self.assertEqual(release["tag_name"], "v1.2.0")
+        self.assertEqual(release["html_url"], update_check._RELEASE_PAGE_URL)
+        self.assertTrue(release["release_pending"])
+        self.assertEqual(release["changelog"], "# Changelog\n\n## 1.2.0")
+
 
 if __name__ == "__main__":
     unittest.main()

services/register_service.py

@@ -297,11 +297,23 @@ def _grok_oauth_display_status(value: object) -> str:
         return "normal"
     if probe_status == "limited":
         return "limited"
-    if probe_status in {"invalid", "unknown"}:
+    if probe_status == "invalid":
         return "invalid"
+    if probe_status == "unknown":
+        return "unknown"
     return "normal" if status == "active" else "invalid"
 
 
+def _grok_oauth_probe_recoverable(value: object) -> bool:
+    probe = value if isinstance(value, dict) else {}
+    if _clean_text(probe.get("status")).lower() != "invalid":
+        return False
+    code = _clean_text(probe.get("code")).lower()
+    return code != "permission-denied" and not (
+        code == "personal-team-blocked" or code.startswith("personal-team-blocked:")
+    )
+
+
 def _grok_oauth_authorizable(item: object) -> bool:
     """Return whether an SSO registration record is ready for OAuth."""
     if not isinstance(item, dict):
@@ -1548,7 +1560,7 @@ def _grok_status_matches(item: dict[str, Any], status: str) -> bool:
             if oauth_status == "denied":
                 authorization = item.get("oauth_authorization") if isinstance(item.get("oauth_authorization"), dict) else {}
                 return not isinstance(item.get("oauth"), dict) and _clean_text(authorization.get("status")).lower() == "denied"
-            if oauth_status in {"unauthorized", "normal", "limited", "no_quota", "expired", "invalid"}:
+            if oauth_status in {"unauthorized", "normal", "limited", "no_quota", "expired", "invalid", "unknown"}:
                 if oauth_status == "unauthorized":
                     return _grok_oauth_authorizable(item) and not isinstance(item.get("oauth"), dict)
                 return _grok_oauth_display_status(item.get("oauth")) == oauth_status
@@ -1689,7 +1701,7 @@ def grok_accounts_view(self, *, keyword: str = "", status: str = "all") -> dict[
             "oauth_linked": sum(1 for item in merged_items if isinstance(item.get("oauth"), dict)),
             "oauth_status": {
                 status: sum(1 for value in oauth_display_statuses if value == status)
-                for status in ("unauthorized", "denied", "normal", "limited", "no_quota", "expired", "invalid")
+                for status in ("unauthorized", "denied", "normal", "limited", "no_quota", "expired", "invalid", "unknown")
             },
             "runtime_status": runtime_status,
             "calls_total": calls_total,
@@ -2272,7 +2284,7 @@ def _recover_grok_oauth_account(
         if not oauth_account_id or _clean_text(oauth_item.get("status")).lower() == "disabled":
             return {"status": "deferred"}
         probe = oauth_item.get("probe") if isinstance(oauth_item.get("probe"), dict) else {}
-        if _clean_text(probe.get("status")).lower() != "invalid":
+        if not _grok_oauth_probe_recoverable(probe):
             return {"status": "deferred"}
 
         now = datetime.now(timezone.utc)
@@ -2375,10 +2387,7 @@ def _grok_oauth_has_inflight_recovery() -> bool:
             return False
         return any(
             _clean_text(item.get("status")).lower() != "disabled"
-            and _clean_text(
-                item.get("probe", {}).get("status") if isinstance(item.get("probe"), dict) else ""
-            ).lower()
-            == "invalid"
+            and _grok_oauth_probe_recoverable(item.get("probe"))
             and _clean_text(
                 item.get("recovery", {}).get("status") if isinstance(item.get("recovery"), dict) else ""
             ).lower()
@@ -2387,6 +2396,21 @@ def _grok_oauth_has_inflight_recovery() -> bool:
             if isinstance(item, dict)
         )
 
+    @staticmethod
+    def _grok_oauth_has_due_invalid_recovery() -> bool:
+        try:
+            items = xai_cli_oauth_store.list_accounts(redacted=True)
+        except Exception:
+            return False
+        now = datetime.now(timezone.utc)
+        return any(
+            _clean_text(item.get("status")).lower() != "disabled"
+            and _grok_oauth_probe_recoverable(item.get("probe"))
+            and RegisterService._grok_oauth_recovery_due(item, now=now)
+            for item in items
+            if isinstance(item, dict)
+        )
+
     @staticmethod
     def _grok_oauth_unlinked_sources() -> tuple[list[dict[str, Any]], int]:
         oauth_emails = {
@@ -2422,6 +2446,19 @@ def _grok_oauth_has_unlinked_accounts(self) -> bool:
             return False
         return bool(sources)
 
+    def handle_grok_oauth_probe_results(self, results: list[dict[str, Any]]) -> None:
+        has_invalid = any(
+            isinstance(item, dict)
+            and _grok_oauth_probe_recoverable(item)
+            for item in results
+        )
+        if not has_invalid:
+            return
+        with self._lock:
+            enabled = bool(self._grok_probe_config_locked().get("enabled"))
+        if enabled:
+            self._grok_probe_wake_event.set()
+
     def _queue_unlinked_grok_oauth_accounts(
         self,
         *,
@@ -2571,6 +2608,7 @@ def _run_grok_probe_scheduler(self, stop_event: threading.Event) -> None:
                     recovery_sweep_due = (
                         recovery_sweep_due
                         or self._grok_oauth_has_inflight_recovery()
+                        or self._grok_oauth_has_due_invalid_recovery()
                         or self._grok_oauth_has_unlinked_accounts()
                     )
                     if recovery_sweep_due and not cycle_stop.is_set():
@@ -2583,6 +2621,12 @@ def _run_grok_probe_scheduler(self, stop_event: threading.Event) -> None:
                 permission_retry = self._run_grok_permission_retry_once(cycle_stop)
                 if cycle_stop.is_set():
                     continue
+                if self._grok_oauth_has_due_invalid_recovery():
+                    self._run_grok_oauth_recovery_sweep(
+                        include_backfill=False,
+                        stop_event=cycle_stop,
+                    )
+                    continue
                 with self._lock:
                     probe = self._grok_probe_config_locked()
                     should_run = bool(probe.get("enabled")) and self._grok_probe_due_locked(probe)
@@ -2709,6 +2753,7 @@ def _run_grok_oauth_recovery_sweep(
         *,
         limit: int | None = None,
         reclaim_inflight: bool = False,
+        include_backfill: bool = True,
         stop_event: Any | None = None,
     ) -> dict[str, int]:
         summary = {
@@ -2734,14 +2779,7 @@ def _run_grok_oauth_recovery_sweep(
                 item
                 for item in oauth_items
                 if _clean_text(item.get("status")).lower() != "disabled"
-                and _clean_text(
-                    item.get("probe", {}).get("status") if isinstance(item.get("probe"), dict) else ""
-                ).lower()
-                == "invalid"
-                and _clean_text(
-                    item.get("probe", {}).get("code") if isinstance(item.get("probe"), dict) else ""
-                ).lower()
-                != "permission-denied"
+                and _grok_oauth_probe_recoverable(item.get("probe"))
             ]
             candidates.sort(
                 key=lambda item: 0
@@ -2781,9 +2819,10 @@ def _run_grok_oauth_recovery_sweep(
                     summary["failed"] += 1
                 else:
                     summary["deferred"] += 1
-            backfill = self._queue_unlinked_grok_oauth_accounts(stop_event=stop_event)
-            for key, value in backfill.items():
-                summary[f"backfill_{key}"] = value
+            if include_backfill:
+                backfill = self._queue_unlinked_grok_oauth_accounts(stop_event=stop_event)
+                for key, value in backfill.items():
+                    summary[f"backfill_{key}"] = value
         except _GrokProbeCancelled:
             cancelled = True
         except Exception as error:
@@ -2996,7 +3035,7 @@ def _run_grok_probe_once(self, stop_event: Any | None = None) -> dict[str, int]:
                         status = _clean_text(result.get("status")).lower() if isinstance(result, dict) else "unknown"
                         key = status if status in {"valid", "limited", "invalid", "unknown"} else "unknown"
                         summary[f"oauth_{key}"] += 1
-                        if status != "invalid" or not isinstance(result, dict):
+                        if not isinstance(result, dict) or not _grok_oauth_probe_recoverable(result):
                             continue
                         oauth_account_id = _clean_text(result.get("account_id"))
                         candidate = oauth_by_id.get(oauth_account_id)
@@ -3005,7 +3044,14 @@ def _run_grok_probe_once(self, stop_event: Any | None = None) -> dict[str, int]:
                             continue
                         _raise_if_grok_probe_cancelled(stop_event)
                         recovery = self._recover_grok_oauth_account(
-                            {**candidate, "status": "invalid", "probe": {"status": "invalid"}},
+                            {
+                                **candidate,
+                                "status": "invalid",
+                                "probe": {
+                                    "status": "invalid",
+                                    "code": _clean_text(result.get("code")),
+                                },
+                            },
                             source_by_email,
                         )
                         recovery_status = _clean_text(recovery.get("status")).lower()
@@ -4203,3 +4249,4 @@ def _start_xai_cli_oauth_protocol(
 from services.xai_cli_oauth_service import xai_cli_oauth_service
 
 xai_cli_oauth_service.protocol_event_sink = register_service.handle_grok_oauth_protocol_event
+xai_cli_oauth_service.probe_event_sink = register_service.handle_grok_oauth_probe_results