fix(rgtv-cli): migrate to ureq 3.x API (repairs main; unblocks #87, #88)

PR #82 bumped ureq 2.12.1 → 3.3.0 in /rgtv-cli but did not migrate the
call sites, leaving main red since 2026-05-22 (`Check / Fmt / Clippy /
Test (rgtv-cli)` failing on every PR including dependabot bumps #87,
#88). The TODO in Cargo.toml flagged the remaining work.

This commit completes the migration:

- AgentBuilder → Agent::config_builder().build().into()
- timeout_read/timeout_write → timeout_recv_body/timeout_send_body
- http_status_as_error(false) keeps 4xx/5xx as Ok responses so the
  broker's structured error body is still surfaceable
- RequestBuilder::set → RequestBuilder::header
- Response::into_string / into_json → body_mut().read_to_string() then
  serde_json::from_str, factored into parse_response() so the broker
  error-body fast path lives in one place
- POST with no body now uses send_empty() (call() is WithoutBody-only
  in v3)
- ureq_err() simplified to the transport-error path; HTTP-status errors
  flow through parse_response()

Verified locally (matches the Rust CI pipeline):
- cargo fmt --check                          OK
- cargo check --all-targets                  OK
- cargo clippy --all-targets -- -D warnings  OK
- cargo test                                 OK

After this lands, `@dependabot rebase` on #87 (nixpkgs) and #88
(rust-overlay) should bring them green; the only remaining failing
check on those PRs is `analyze (javascript-typescript, none)` (CodeQL
workflow drift, not caused by the dependabot bumps).

Foundational follow-up (NOT in this PR, flagged for owner action): the
underlying reason a red-CI dependabot PR ever reached main is that
`main` branch protection has no `required_status_checks` block — see
`gh api repos/.../branches/main/protection`. Adding the Rust CI checks
to required status checks would prevent another silent red-bump merge.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

rgtv-cli/Cargo.toml

@@ -14,7 +14,7 @@ path = "src/main.rs"
 
 [dependencies]
 # Synchronous HTTP client — no async overhead needed for a CLI.
-ureq = { version = "3", features = ["json"] }  # TODO: migrate to ureq 3.x API (AgentBuilder/Error/RequestBuilder all renamed)
+ureq = { version = "3", features = ["json"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 # Zeroize heap allocations holding raw credential values after use.

rgtv-cli/src/main.rs

@@ -109,64 +109,78 @@ impl Config {
 // ---------------------------------------------------------------------------
 
 /// A short-timeout ureq agent appropriate for interactive CLI calls.
+///
+/// `http_status_as_error(false)` keeps 4xx/5xx as `Ok` responses so the
+/// broker's structured error body can still be surfaced (see `parse_response`).
 fn http_agent() -> ureq::Agent {
-    ureq::AgentBuilder::new()
-        .timeout_read(Duration::from_secs(10))
-        .timeout_write(Duration::from_secs(5))
+    ureq::Agent::config_builder()
+        .timeout_recv_body(Some(Duration::from_secs(10)))
+        .timeout_send_body(Some(Duration::from_secs(5)))
+        .http_status_as_error(false)
         .build()
+        .into()
 }
 
 fn bearer(token: &str) -> String {
     format!("Bearer {token}")
 }
 
-/// Convert a ureq error into a human-readable string, surfacing the broker's
-/// own error message when it returns a structured error body.
+/// Convert a transport-level ureq error into a human-readable string.
+///
+/// HTTP-status errors don't reach this path (see `http_agent`) — they come
+/// back as `Ok` responses whose status code is checked by `parse_response`.
 fn ureq_err(e: ureq::Error) -> String {
-    match e {
-        ureq::Error::Status(code, resp) => {
-            let body = resp.into_string().unwrap_or_default();
-            if let Ok(b) = serde_json::from_str::<BrokerError>(&body) {
-                format!("broker {code}: {}", b.error)
-            } else {
-                format!("broker {code}: {body}")
-            }
+    format!("transport: {e}")
+}
+
+/// Parse a response, surfacing the broker's structured error body on non-2xx.
+fn parse_response<T: serde::de::DeserializeOwned>(
+    mut resp: ureq::http::Response<ureq::Body>,
+    what: &str,
+) -> Result<T, String> {
+    let status = resp.status().as_u16();
+    let body = resp
+        .body_mut()
+        .read_to_string()
+        .map_err(|e| format!("read {what} body: {e}"))?;
+    if !(200..300).contains(&status) {
+        if let Ok(b) = serde_json::from_str::<BrokerError>(&body) {
+            return Err(format!("broker {status}: {}", b.error));
         }
-        ureq::Error::Transport(t) => format!("transport: {t}"),
+        return Err(format!("broker {status}: {body}"));
     }
+    serde_json::from_str(&body).map_err(|e| format!("parse {what}: {e}"))
 }
 
 fn get_health(cfg: &Config) -> Result<HealthResponse, String> {
     let url = format!("{}/health", cfg.base_url);
     let resp = http_agent()
         .get(&url)
-        .set("Authorization", &bearer(&cfg.agent_token))
+        .header("Authorization", bearer(&cfg.agent_token))
         .call()
         .map_err(ureq_err)?;
-    resp.into_json().map_err(|e| format!("parse health: {e}"))
+    parse_response(resp, "health")
 }
 
 fn get_credentials(cfg: &Config) -> Result<CredentialsResponse, String> {
     let url = format!("{}/v1/credentials", cfg.base_url);
     let resp = http_agent()
         .get(&url)
-        .set("Authorization", &bearer(&cfg.agent_token))
+        .header("Authorization", bearer(&cfg.agent_token))
         .call()
         .map_err(ureq_err)?;
-    resp.into_json()
-        .map_err(|e| format!("parse credentials: {e}"))
+    parse_response(resp, "credentials")
 }
 
 fn post_grant(cfg: &Config, hint: &str) -> Result<GrantResponse, String> {
     let url = format!("{}/v1/grants", cfg.base_url);
     let body = serde_json::json!({ "hint": hint });
     let resp = http_agent()
         .post(&url)
-        .set("Authorization", &bearer(&cfg.agent_token))
-        .set("Content-Type", "application/json")
+        .header("Authorization", bearer(&cfg.agent_token))
         .send_json(body)
         .map_err(ureq_err)?;
-    resp.into_json().map_err(|e| format!("parse grant: {e}"))
+    parse_response(resp, "grant")
 }
 
 /// Redeem a grant and return the credential value wrapped in Zeroizing<String>
@@ -175,10 +189,10 @@ fn post_redeem(cfg: &Config, grant_id: &str) -> Result<Zeroizing<String>, String
     let url = format!("{}/v1/grants/{grant_id}/redeem", cfg.base_url);
     let resp = http_agent()
         .post(&url)
-        .set("Authorization", &bearer(&cfg.agent_token))
-        .call()
+        .header("Authorization", bearer(&cfg.agent_token))
+        .send_empty()
         .map_err(ureq_err)?;
-    let body: RedeemBody = resp.into_json().map_err(|e| format!("parse redeem: {e}"))?;
+    let body: RedeemBody = parse_response(resp, "redeem")?;
     Ok(Zeroizing::new(body.value))
 }