fix(auth): hide persistence diagnostics from events

Author: elkaix

src/pythinker_code/auth/copilot.py

@@ -272,7 +272,7 @@ async def login_copilot(config: Config, *, open_browser: bool = True) -> AsyncIt
         )
     except Exception as exc:
         logger.warning("Failed to persist GitHub Copilot login: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to save GitHub Copilot login: {exc}")
+        yield OAuthEvent("error", "Failed to save GitHub Copilot login.")
         return
     yield OAuthEvent(
         "success",
@@ -300,6 +300,6 @@ def _remove(cfg: Config) -> None:
         await persist_logout(config, _copilot_oauth_ref(), _remove)
     except Exception as exc:
         logger.warning("Failed to persist GitHub Copilot logout: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to log out of GitHub Copilot: {exc}")
+        yield OAuthEvent("error", "Failed to log out of GitHub Copilot.")
         return
     yield OAuthEvent("success", "Logged out of GitHub Copilot successfully.")

src/pythinker_code/auth/digitalocean.py

@@ -189,7 +189,7 @@ async def login_digitalocean(
         )
     except Exception as exc:
         logger.warning("Failed to persist DigitalOcean login: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to save DigitalOcean login: {exc}")
+        yield OAuthEvent("error", "Failed to save DigitalOcean login.")
         return
 
     message = _router_status_message(catalog.status)
@@ -222,6 +222,6 @@ def _remove(cfg: Config) -> None:
         await persist_config_change(config, _remove)
     except Exception as exc:
         logger.warning("Failed to persist DigitalOcean logout: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to log out of DigitalOcean: {exc}")
+        yield OAuthEvent("error", "Failed to log out of DigitalOcean.")
         return
     yield OAuthEvent("success", "Logged out of DigitalOcean successfully.")

src/pythinker_code/auth/snowflake.py

@@ -330,7 +330,7 @@ async def login_snowflake(
         )
     except Exception as exc:
         logger.warning("Failed to persist Snowflake Cortex login: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to save Snowflake Cortex login: {exc}")
+        yield OAuthEvent("error", "Failed to save Snowflake Cortex login.")
         return
 
     yield OAuthEvent(
@@ -367,6 +367,6 @@ def _remove(cfg: Config) -> None:
             await persist_config_change(config, _remove)
     except Exception as exc:
         logger.warning("Failed to persist Snowflake Cortex logout: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to log out of Snowflake Cortex: {exc}")
+        yield OAuthEvent("error", "Failed to log out of Snowflake Cortex.")
         return
     yield OAuthEvent("success", "Logged out of Snowflake Cortex successfully.")

src/pythinker_code/auth/xai.py

@@ -250,7 +250,7 @@ async def login_xai_browser(
         )
     except Exception as exc:
         logger.warning("Failed to persist xAI Grok login: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to save xAI Grok login: {exc}")
+        yield OAuthEvent("error", "Failed to save xAI Grok login.")
         return
     yield OAuthEvent("success", f"xAI Grok configured with model {config.default_model}.")
 
@@ -310,7 +310,7 @@ async def login_xai_headless(config: Config) -> AsyncIterator[OAuthEvent]:
         )
     except Exception as exc:
         logger.warning("Failed to persist xAI Grok login: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to save xAI Grok login: {exc}")
+        yield OAuthEvent("error", "Failed to save xAI Grok login.")
         return
     yield OAuthEvent("success", f"xAI Grok configured with model {config.default_model}.")
 
@@ -335,6 +335,6 @@ def _remove(cfg: Config) -> None:
         await persist_logout(config, _xai_oauth_ref(), _remove)
     except Exception as exc:
         logger.warning("Failed to persist xAI Grok logout: {exc}", exc=exc)
-        yield OAuthEvent("error", f"Failed to log out of xAI Grok: {exc}")
+        yield OAuthEvent("error", "Failed to log out of xAI Grok.")
         return
     yield OAuthEvent("success", "Logged out of xAI Grok successfully.")

tests/auth/test_copilot_auth.py

@@ -116,6 +116,55 @@ async def fake_refresh_copilot_token(github_token: str) -> OAuthToken:
     assert {model.provider for model in config.models.values()} == {"managed:copilot"}
 
 
+@pytest.mark.asyncio
+async def test_copilot_persistence_errors_hide_internal_details(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pythinker_code.auth import copilot
+
+    diagnostic = "permission denied at /private/credentials/github-copilot.json"
+    config = Config(is_from_default_location=True)
+
+    async def fake_request_device_code(**_kwargs: Any) -> DeviceCode:
+        return DeviceCode(
+            user_code="ABCD-EFGH",
+            verification_uri="https://github.com/login/device",
+            device_code="device-secret",
+            interval=5,
+            expires_in=900,
+        )
+
+    async def fake_poll_device_token(**_kwargs: Any) -> dict[str, Any]:
+        return {"access_token": "github-oauth-token"}
+
+    async def fake_refresh_copilot_token(_github_token: str) -> OAuthToken:
+        return OAuthToken.from_response(
+            {
+                "access_token": "copilot-bearer",
+                "refresh_token": "github-oauth-token",
+                "expires_in": 1500,
+            }
+        )
+
+    async def fail_persistence(*_args: object, **_kwargs: object) -> None:
+        raise OSError(diagnostic)
+
+    monkeypatch.setattr(copilot, "request_device_code", fake_request_device_code)
+    monkeypatch.setattr(copilot, "poll_device_token", fake_poll_device_token)
+    monkeypatch.setattr(copilot, "refresh_copilot_token", fake_refresh_copilot_token)
+    monkeypatch.setattr(copilot, "persist_login", fail_persistence)
+    monkeypatch.setattr(copilot, "persist_logout", fail_persistence)
+    _mock_unavailable_catalog(monkeypatch)
+
+    login_events = [event async for event in copilot.login_copilot(config, open_browser=False)]
+    logout_events = [event async for event in copilot.logout_copilot(config)]
+
+    assert login_events[-1].message == "Failed to save GitHub Copilot login."
+    assert logout_events[-1].message == "Failed to log out of GitHub Copilot."
+    assert diagnostic not in login_events[-1].json
+    assert diagnostic not in logout_events[-1].json
+
+
 class _ExchangeResponse:
     def __init__(self, status: int, payload: object) -> None:
         self.status = status

tests/auth/test_digitalocean_auth.py

@@ -213,6 +213,38 @@ async def fake_implicit_flow(**kwargs: Any) -> ImplicitAuthorization:
     assert (tmp_path / "config.toml").exists()
 
 
+@pytest.mark.asyncio
+async def test_digitalocean_persistence_errors_hide_internal_details(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pythinker_code.auth import digitalocean as do
+    from pythinker_code.auth.oauth_flows import ImplicitAuthorization
+
+    diagnostic = "permission denied at /private/config.toml"
+    config = Config(is_from_default_location=True)
+
+    async def fake_implicit_flow(**_kwargs: Any) -> ImplicitAuthorization:
+        return ImplicitAuthorization("access-token", None, "state")
+
+    async def fake_catalog(_access_token: str) -> do.RouterCatalog:
+        return do.RouterCatalog(do.RouterDiscovery.OK, ("primary",))
+
+    async def fail_persistence(*_args: object, **_kwargs: object) -> None:
+        raise OSError(diagnostic)
+
+    monkeypatch.setattr(do, "run_loopback_implicit_flow", fake_implicit_flow)
+    monkeypatch.setattr(do, "_fetch_router_catalog", fake_catalog)
+    monkeypatch.setattr(do, "persist_config_change", fail_persistence)
+
+    login_events = [event async for event in do.login_digitalocean(config)]
+    logout_events = [event async for event in do.logout_digitalocean(config)]
+
+    assert login_events[-1].message == "Failed to save DigitalOcean login."
+    assert logout_events[-1].message == "Failed to log out of DigitalOcean."
+    assert diagnostic not in login_events[-1].json
+    assert diagnostic not in logout_events[-1].json
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "response",

tests/auth/test_snowflake_auth.py

@@ -294,6 +294,51 @@ async def fake_exchange(
     assert "snowflake-refresh-secret" not in rendered_events
 
 
+@pytest.mark.asyncio
+async def test_snowflake_persistence_errors_hide_internal_details(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pythinker_code.auth import snowflake
+
+    diagnostic = "permission denied at /private/credentials/snowflake.json"
+    config = Config(is_from_default_location=True)
+
+    async def fake_loopback(**_kwargs: Any) -> LoopbackAuthorization:
+        return LoopbackAuthorization("auth-code", "verifier", "http://127.0.0.1:49231/")
+
+    async def fake_exchange(
+        _account: str,
+        _code: str,
+        _code_verifier: str,
+        _redirect_uri: str,
+    ) -> dict[str, Any]:
+        return {
+            "access_token": "snowflake-access",
+            "refresh_token": "snowflake-refresh",
+            "expires_in": 600,
+        }
+
+    async def fake_models() -> tuple[snowflake.SnowflakeModel, ...]:
+        return snowflake.SNOWFLAKE_MODELS
+
+    async def fail_persistence(*_args: object, **_kwargs: object) -> None:
+        raise OSError(diagnostic)
+
+    monkeypatch.setattr(snowflake, "run_loopback_pkce_flow", fake_loopback)
+    monkeypatch.setattr(snowflake, "_exchange_code_for_tokens", fake_exchange)
+    monkeypatch.setattr(snowflake, "_discover_snowflake_models", fake_models)
+    monkeypatch.setattr(snowflake, "persist_login", fail_persistence)
+    monkeypatch.setattr(snowflake, "persist_config_change", fail_persistence)
+
+    login_events = [event async for event in snowflake.login_snowflake(config, "myorg-acct")]
+    logout_events = [event async for event in snowflake.logout_snowflake(config)]
+
+    assert login_events[-1].message == "Failed to save Snowflake Cortex login."
+    assert logout_events[-1].message == "Failed to log out of Snowflake Cortex."
+    assert diagnostic not in login_events[-1].json
+    assert diagnostic not in logout_events[-1].json
+
+
 @pytest.mark.asyncio
 async def test_login_snowflake_fails_when_refresh_token_is_missing(
     monkeypatch: pytest.MonkeyPatch,

tests/auth/test_xai_auth.py

@@ -107,6 +107,71 @@ async def fake_exchange(code: str, code_verifier: str, redirect_uri: str) -> dic
     assert config.default_model == "xai/grok-4"
 
 
+@pytest.mark.asyncio
+async def test_xai_persistence_errors_hide_internal_details(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from pythinker_code.auth import xai
+
+    diagnostic = "permission denied at /private/credentials/xai.json"
+    config = Config(is_from_default_location=True)
+
+    async def fake_loopback(**_kwargs: Any) -> LoopbackAuthorization:
+        return LoopbackAuthorization("auth-code", "verifier", "http://127.0.0.1:56121/callback")
+
+    async def fake_exchange(
+        _code: str,
+        _code_verifier: str,
+        _redirect_uri: str,
+    ) -> dict[str, Any]:
+        return {
+            "access_token": "xai-access",
+            "refresh_token": "xai-refresh",
+            "expires_in": 3600,
+        }
+
+    async def fake_request_device_code(**_kwargs: Any) -> DeviceCode:
+        return DeviceCode(
+            user_code="GROK-CODE",
+            verification_uri="https://auth.x.ai/activate",
+            device_code="device-secret",
+            interval=5,
+            expires_in=900,
+        )
+
+    async def fake_poll_device_token(**_kwargs: Any) -> dict[str, Any]:
+        return {
+            "access_token": "xai-access",
+            "refresh_token": "xai-refresh",
+            "expires_in": 3600,
+        }
+
+    async def fake_models() -> tuple[xai.XAIModel, ...]:
+        return xai.XAI_MODELS
+
+    async def fail_persistence(*_args: object, **_kwargs: object) -> None:
+        raise OSError(diagnostic)
+
+    monkeypatch.setattr(xai, "run_loopback_pkce_flow", fake_loopback)
+    monkeypatch.setattr(xai, "_exchange_code_for_tokens", fake_exchange)
+    monkeypatch.setattr(xai, "request_device_code", fake_request_device_code)
+    monkeypatch.setattr(xai, "poll_device_token", fake_poll_device_token)
+    monkeypatch.setattr(xai, "_discover_xai_models", fake_models)
+    monkeypatch.setattr(xai, "persist_login", fail_persistence)
+    monkeypatch.setattr(xai, "persist_logout", fail_persistence)
+
+    browser_events = [event async for event in xai.login_xai_browser(config)]
+    headless_events = [event async for event in xai.login_xai_headless(config)]
+    logout_events = [event async for event in xai.logout_xai(config)]
+
+    assert browser_events[-1].message == "Failed to save xAI Grok login."
+    assert headless_events[-1].message == "Failed to save xAI Grok login."
+    assert logout_events[-1].message == "Failed to log out of xAI Grok."
+    assert diagnostic not in browser_events[-1].json
+    assert diagnostic not in headless_events[-1].json
+    assert diagnostic not in logout_events[-1].json
+
+
 @pytest.mark.asyncio
 async def test_login_xai_headless_uses_device_flow(
     monkeypatch: pytest.MonkeyPatch,