Fix profile save verification and Steam Guard UX

ja7den2006 · ja7den2006 · commit 4ea6771f8806 · 2026-04-30T22:02:15.000-04:00
diff --git a/README.md b/README.md
@@ -64,6 +64,8 @@ print(client.get_trade_offer_url())
 print(client.get_group_membership_state("Valve"))
 ```
 
+If Steam Guard is required, the credential login flow prompts automatically in an interactive terminal. You can still pass `steam_guard_code="12345"` explicitly for non-interactive runs.
+
 ## Verified Workflow Examples
 
 ### Save and restore a logged-in session
diff --git a/docs/authentication.md b/docs/authentication.md
@@ -60,7 +60,9 @@ client.login_to_community("YOUR_USERNAME", "YOUR_PASSWORD")
 print(client.get_account_info())
 ```
 
-If Steam Guard is required, pass a code:
+If Steam Guard is required and your script is running in an interactive terminal, `login_to_community(...)` prompts automatically.
+
+If you already have the code, you can pass it directly:
 
 ```python
 client.login_to_community(
@@ -70,13 +72,13 @@ client.login_to_community(
 )
 ```
 
-Or provide a callback:
+Advanced callers can still provide their own code provider:
 
 ```python
 client.login_to_community(
     "YOUR_USERNAME",
     "YOUR_PASSWORD",
-    steam_guard_code_provider=lambda prompt: input("Steam Guard code: "),
+    steam_guard_code_provider=lambda confirmation: get_code_somehow(confirmation),
 )
 ```
 
@@ -145,4 +147,3 @@ This is useful when you need to hit a supported Steam Community page that does n
 
 - `SteamResponseError`
   - Steam returned malformed or unexpected content
-
diff --git a/docs/community.md b/docs/community.md
@@ -38,6 +38,8 @@ client.update_summary("Profile summary text")
 client.update_location(country="US", state="IN", city="123")
 ```
 
+The single-field helpers only submit the field you asked to change. Steam sometimes replies with warning-style `success: 2` payloads for profile saves, so SteamCommunityKit verifies the requested field after the write before treating the call as successful.
+
 ## Privacy
 
 Read privacy:
@@ -105,4 +107,3 @@ Useful fields include:
 - `registration_form_visible`
 - `revoke_available`
 - `reason`
-
diff --git a/src/steamcommunitykit/client.py b/src/steamcommunitykit/client.py
@@ -1957,7 +1957,7 @@ def login_to_community(
         persistence: bool = True,
         steam_guard_code: Optional[str] = None,
         steam_guard_code_provider: Optional[Callable[[dict], str]] = None,
-        prompt_for_steam_guard: bool = False,
+        prompt_for_steam_guard: Optional[bool] = None,
         poll_interval: float = 1.5,
         poll_timeout: float = 60.0,
     ) -> CredentialLoginResult:
diff --git a/src/steamcommunitykit/services/auth.py b/src/steamcommunitykit/services/auth.py
@@ -2,6 +2,7 @@
 
 import base64
 import json
+import sys
 import time
 import urllib.parse
 from collections.abc import Mapping
@@ -176,7 +177,7 @@ def login_with_credentials(
         persistence: bool = True,
         steam_guard_code: Optional[str] = None,
         steam_guard_code_provider: Optional[Callable[[dict], str]] = None,
-        prompt_for_steam_guard: bool = False,
+        prompt_for_steam_guard: Optional[bool] = None,
         poll_interval: float = 1.5,
         poll_timeout: float = 60.0,
     ) -> CredentialLoginResult:
@@ -200,8 +201,8 @@ def login_with_credentials(
             if confirmation is not None:
                 code = steam_guard_code
                 if code is None and steam_guard_code_provider is not None:
-                    code = steam_guard_code_provider(started)
-                if code is None and prompt_for_steam_guard:
+                    code = steam_guard_code_provider(confirmation)
+                if code is None and self._should_prompt_for_steam_guard(prompt_for_steam_guard):
                     code = self.prompt_for_steam_guard_code(confirmation)
                 if code is None:
                     raise SteamAuthenticationError(
@@ -296,6 +297,25 @@ def _format_steam_guard_required_message(confirmation: dict) -> str:
             return "A Steam Guard email code is required for this login."
         return "A Steam Guard confirmation is required for this login."
 
+    @staticmethod
+    def _terminal_can_prompt() -> bool:
+        stdin = getattr(sys, "stdin", None)
+        stdout = getattr(sys, "stdout", None)
+        return bool(
+            stdin is not None
+            and stdout is not None
+            and hasattr(stdin, "isatty")
+            and hasattr(stdout, "isatty")
+            and stdin.isatty()
+            and stdout.isatty()
+        )
+
+    @classmethod
+    def _should_prompt_for_steam_guard(cls, prompt_for_steam_guard: Optional[bool]) -> bool:
+        if prompt_for_steam_guard is not None:
+            return bool(prompt_for_steam_guard)
+        return cls._terminal_can_prompt()
+
     @staticmethod
     def prompt_for_steam_guard_code(confirmation: dict) -> str:
         confirmation_type = int(confirmation.get("confirmation_type", 0))
diff --git a/src/steamcommunitykit/services/community.py b/src/steamcommunitykit/services/community.py
@@ -39,15 +39,134 @@ def _extract_json_data_attribute(html_text: str, attribute_name: str) -> dict:
             ) from exc
 
     @staticmethod
-    def _ensure_ajax_success(response: dict, action: str) -> dict:
+    def _normalize_ajax_error_message(message: object) -> str:
+        return html.unescape(
+            str(message or "")
+            .replace("<br />", "\n")
+            .replace("<br \\/>", "\n")
+            .replace("<br/>", "\n")
+        ).strip()
+
+    @classmethod
+    def _ensure_ajax_success(cls, response: dict, action: str) -> dict:
         success = response.get("success")
-        error_message = html.unescape(str(response.get("errmsg", "")).replace("<br />", " ").strip())
+        error_message = cls._normalize_ajax_error_message(response.get("errmsg"))
         if success == 1:
             return response
         if error_message:
-            raise SteamResponseError("{0} failed: {1}".format(action, error_message))
+            raise SteamResponseError(
+                "{0} failed: {1}".format(action, " ".join(error_message.splitlines()))
+            )
         raise SteamResponseError("{0} failed.".format(action))
 
+    @staticmethod
+    def _profile_edit_state_value(profile_edit_state: dict, field_name: str):
+        if field_name == "personaName":
+            return profile_edit_state.get("strPersonaName", "")
+        if field_name == "real_name":
+            return profile_edit_state.get("strRealName", "")
+        if field_name == "summary":
+            return profile_edit_state.get("strSummary", "")
+        if field_name == "customURL":
+            return profile_edit_state.get("strCustomURL", "")
+        if field_name == "country":
+            return (profile_edit_state.get("LocationData") or {}).get("locCountryCode", "")
+        if field_name == "state":
+            return (profile_edit_state.get("LocationData") or {}).get("locStateCode", "")
+        if field_name == "city":
+            return (profile_edit_state.get("LocationData") or {}).get("locCityCode", "")
+        if field_name == "hide_profile_awards":
+            return int(bool((profile_edit_state.get("ProfilePreferences") or {}).get("hide_profile_awards", 0)))
+        return None
+
+    @staticmethod
+    def _normalize_profile_edit_value(field_name: str, value):
+        if field_name == "hide_profile_awards":
+            return int(bool(value))
+        if value is None:
+            return ""
+        return str(value)
+
+    def _verify_profile_edit_updates(
+        self,
+        steam_id: str,
+        requested_updates: Dict[str, object],
+    ) -> dict:
+        profile_edit_state = self.get_profile_edit_state(steam_id)
+        mismatches = {}
+        for field_name, expected_value in requested_updates.items():
+            actual_value = self._profile_edit_state_value(profile_edit_state, field_name)
+            if self._normalize_profile_edit_value(
+                field_name,
+                actual_value,
+            ) != self._normalize_profile_edit_value(field_name, expected_value):
+                mismatches[field_name] = {
+                    "expected": expected_value,
+                    "actual": actual_value,
+                }
+        return {
+            "profile_edit_state": profile_edit_state,
+            "mismatches": mismatches,
+        }
+
+    def _finalize_profile_edit_response(
+        self,
+        steam_id: str,
+        response: dict,
+        requested_updates: Dict[str, object],
+    ) -> dict:
+        success = response.get("success")
+        if success == 1:
+            return response
+        error_message = self._normalize_ajax_error_message(response.get("errmsg"))
+        if success != 2:
+            if error_message:
+                raise SteamResponseError(
+                    "Profile update failed: {0}".format(" ".join(error_message.splitlines()))
+                )
+            raise SteamResponseError("Profile update failed.")
+
+        try:
+            verification = self._verify_profile_edit_updates(steam_id, requested_updates)
+        except Exception as exc:
+            if error_message:
+                raise SteamResponseError(
+                    "Profile update returned an ambiguous Steam response: {0}".format(
+                        " ".join(error_message.splitlines())
+                    )
+                ) from exc
+            raise SteamResponseError("Profile update returned an ambiguous Steam response.") from exc
+
+        if verification["mismatches"]:
+            mismatch_details = ", ".join(
+                "{0} expected {1!r} but Steam now reports {2!r}".format(
+                    field_name,
+                    details["expected"],
+                    details["actual"],
+                )
+                for field_name, details in verification["mismatches"].items()
+            )
+            if error_message:
+                raise SteamResponseError(
+                    "Profile update failed: {0} ({1})".format(
+                        " ".join(error_message.splitlines()),
+                        mismatch_details,
+                    )
+                )
+            raise SteamResponseError(
+                "Profile update failed: {0}".format(mismatch_details)
+            )
+
+        finalized = dict(response)
+        finalized["verified"] = True
+        finalized["verified_fields"] = sorted(requested_updates.keys())
+        finalized["warnings"] = [
+            line.strip()
+            for line in error_message.splitlines()
+            if line.strip()
+        ]
+        return finalized
+
     def _resolved_steam_id(self, steam_id=None) -> str:
         if steam_id is None:
             return self.transport.require_community_credentials().steam_id
@@ -322,41 +441,44 @@ def edit_profile(
         country: Optional[str] = None,
         state: Optional[str] = None,
         city: Optional[Union[int, str]] = None,
-        hide_profile_awards: bool = False,
+        hide_profile_awards: Optional[bool] = None,
     ) -> dict:
         credentials = self.transport.require_community_credentials()
         normalized_steam_id = self._resolved_steam_id(steam_id)
         data = {
             "sessionID": credentials.session_id,
             "type": "profileSave",
-            "hide_profile_awards": int(hide_profile_awards),
             "json": 1,
         }
+        requested_updates = {}
         if persona_name is not None:
-            data["personaName"] = ensure_not_blank(persona_name, "persona_name")
+            normalized_persona_name = ensure_not_blank(persona_name, "persona_name")
+            data["personaName"] = normalized_persona_name
+            requested_updates["personaName"] = normalized_persona_name
         if real_name is not None:
             data["real_name"] = real_name
+            requested_updates["real_name"] = real_name
         if summary is not None:
             data["summary"] = summary
+            requested_updates["summary"] = summary
         if custom_url is not None:
             data["customURL"] = custom_url
+            requested_updates["customURL"] = custom_url
         if country is not None:
             data["country"] = country
+            requested_updates["country"] = country
         if state is not None:
             data["state"] = state
+            requested_updates["state"] = state
         if city is not None:
             data["city"] = str(city)
+            requested_updates["city"] = str(city)
+        if hide_profile_awards is not None:
+            normalized_hide_profile_awards = int(bool(hide_profile_awards))
+            data["hide_profile_awards"] = normalized_hide_profile_awards
+            requested_updates["hide_profile_awards"] = normalized_hide_profile_awards
 
-        editable_fields = {
-            "personaName",
-            "real_name",
-            "summary",
-            "customURL",
-            "country",
-            "state",
-            "city",
-        }
-        if not any(field in data for field in editable_fields):
+        if not requested_updates:
             raise SteamValidationError("edit_profile requires at least one editable field.")
 
         response = self.transport.request(
@@ -366,7 +488,11 @@ def edit_profile(
             headers=self._headers(f"{COMMUNITY_BASE_URL}/profiles/{normalized_steam_id}/edit/"),
             cookies=self._community_cookies(),
         )
-        return self._ensure_ajax_success(response, "Profile update")
+        return self._finalize_profile_edit_response(
+            normalized_steam_id,
+            response,
+            requested_updates,
+        )
 
     def upload_avatar(self, image_path: Union[str, Path], steam_id=None) -> dict:
         credentials = self.transport.require_community_credentials()
diff --git a/tests/test_client.py b/tests/test_client.py
