refactor(agent): split openclaw/manager.rs into focused submodules (#344)

`openclaw/manager.rs` was a 2,830-line file mixing the OpenClawManager
struct/impl, the tungstenite WebSocket loop, identity loading, Ed25519
signing, URL/IP validation, exponential backoff, and ~1,090 lines of
integration tests. Split it into focused siblings, all production files
now under 500 lines:

- manager.rs (315) - OpenClawManager struct + public API surface
- connection.rs (454) - WebSocket session/reconnect loop
- runtime_state.rs (187) - per-gateway runtime snapshot mutators
- identity.rs (241) - device identity loading + filesystem fallback
- device_proof.rs (202) - Ed25519 signing + payload + scope validation
- url_validation.rs (150) - URL parsing, DNS resolution, IP allowlist
- dto.rs (110) - public DTOs (status, snapshot, view, requests, events)
- command.rs (82) - `openclaw` external binary invocation
- backoff.rs (40) - reconnect attempt + jittered sleep helpers
- util.rs (34) - shared scalar helpers (now_ms, normalize_*)
- session.rs (26) - internal channel types
- tests.rs (1116) - integration tests (tests-only, may exceed 600)

`mod.rs` declares the new submodules and preserves the existing public
re-exports. `manager::GatewayView` is re-exported on the manager path so
`api_server.rs` `crate::openclaw::manager::GatewayView` keeps resolving.

All 27 openclaw tests still pass.

Co-authored-by: bb-connor <bb-connor@users.noreply.github.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: bb-connor

apps/agent/src-tauri/src/openclaw/backoff.rs

@@ -0,0 +1,40 @@
+//! Reconnect backoff and connection-stability helpers.
+
+use std::time::Duration;
+
+pub(super) fn was_connected_long_enough(
+    connected_at_ms: Option<u64>,
+    stable_reset: Duration,
+    now_ms_value: u64,
+) -> bool {
+    connected_at_ms.is_some_and(|connected_at| {
+        now_ms_value.saturating_sub(connected_at) >= stable_reset.as_millis() as u64
+    })
+}
+
+pub(super) fn next_reconnect_attempt(current_attempt: u32, was_stable: bool) -> u32 {
+    if was_stable {
+        1
+    } else {
+        current_attempt.saturating_add(1)
+    }
+}
+
+/// Compute the next reconnect sleep duration, applying exponential growth plus
+/// ±20% jitter to prevent thundering-herd reconnect storms.
+pub(super) fn compute_reconnect_sleep_ms(reconnect_attempt: u32) -> u64 {
+    let base_backoff_ms = (400.0_f64 * 1.6_f64.powi(reconnect_attempt as i32)).round() as u64;
+    let base_backoff_ms = base_backoff_ms.clamp(250, 12_000);
+    let jitter_range = (base_backoff_ms as f64 * 0.2) as u64;
+    let jitter = if jitter_range > 0 {
+        use std::collections::hash_map::DefaultHasher;
+        use std::hash::{Hash, Hasher};
+        let mut hasher = DefaultHasher::new();
+        std::time::SystemTime::now().hash(&mut hasher);
+        reconnect_attempt.hash(&mut hasher);
+        (hasher.finish() % (jitter_range * 2 + 1)) as i64 - jitter_range as i64
+    } else {
+        0
+    };
+    (base_backoff_ms as i64 + jitter).max(100) as u64
+}

apps/agent/src-tauri/src/openclaw/command.rs

@@ -0,0 +1,82 @@
+//! Invocation of the `openclaw` external binary with JSON output parsing.
+
+use anyhow::Result;
+use serde_json::Value;
+
+pub(super) fn extract_json_payload(output: &str) -> Result<Value> {
+    let mut saw_candidate = false;
+    let mut best: Option<(Value, usize)> = None;
+    let mut last_error: Option<String> = None;
+
+    for (idx, ch) in output.char_indices() {
+        if ch != '{' && ch != '[' {
+            continue;
+        }
+        saw_candidate = true;
+        let json = &output[idx..];
+        let deser = serde_json::Deserializer::from_str(json);
+        let mut stream = deser.into_iter::<Value>();
+        match stream.next() {
+            Some(Ok(value)) => {
+                let remainder = &json[stream.byte_offset()..];
+                let remainder_len = remainder.trim().len();
+                if remainder_len == 0 {
+                    return Ok(value);
+                }
+
+                match &best {
+                    Some((_, best_len)) if remainder_len >= *best_len => {}
+                    _ => best = Some((value, remainder_len)),
+                }
+            }
+            Some(Err(err)) => {
+                last_error = Some(format!("Failed to parse OpenClaw JSON: {}", err));
+            }
+            None => {}
+        }
+    }
+
+    if let Some((value, _)) = best {
+        return Ok(value);
+    }
+
+    Err(anyhow::anyhow!(last_error.unwrap_or_else(|| {
+        if saw_candidate {
+            "Failed to parse OpenClaw JSON".to_string()
+        } else {
+            "OpenClaw returned no JSON payload".to_string()
+        }
+    })))
+}
+
+pub(super) async fn run_openclaw_json(args: Vec<String>) -> Result<Value> {
+    let output = tokio::task::spawn_blocking(move || {
+        let mut full_args = vec!["--no-color".to_string()];
+        full_args.extend(args);
+
+        std::process::Command::new("openclaw")
+            .args(full_args)
+            .output()
+            .map_err(|e| anyhow::anyhow!("Failed to execute openclaw: {}", e))
+    })
+    .await
+    .map_err(|e| anyhow::anyhow!("Failed to join openclaw task: {}", e))??;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        return Err(anyhow::anyhow!(
+            "OpenClaw exited with {}: {}{}",
+            output.status,
+            stderr.trim(),
+            if stderr.trim().is_empty() && !stdout.trim().is_empty() {
+                format!(" (stdout: {})", stdout.trim())
+            } else {
+                "".to_string()
+            }
+        ));
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    extract_json_payload(&stdout)
+}