grok-cli-acp 0.1.2

package/src/utils/network.rs

@@ -0,0 +1,320 @@
+//! Network utilities for detecting and handling network issues
+//!
+//! This module provides utilities specifically designed for handling network
+//! instability common with satellite internet connections like Starlink,
+//! including connection drops, timeouts, and recovery strategies.
+
+use anyhow::{anyhow, Error};
+use std::time::{Duration, Instant};
+use tracing::{debug, info, warn};
+
+/// Patterns that indicate Starlink or satellite network issues
+const STARLINK_ERROR_PATTERNS: &[&str] = &[
+    "connection reset",
+    "connection dropped",
+    "network unreachable",
+    "no route to host",
+    "broken pipe",
+    "connection refused",
+    "timeout",
+    "dns resolution failed",
+    "temporary failure in name resolution",
+    "network is down",
+    "host is unreachable",
+];
+
+/// HTTP status codes that commonly occur during satellite network issues
+const SATELLITE_HTTP_ERRORS: &[u16] = &[
+    502, // Bad Gateway
+    503, // Service Unavailable
+    504, // Gateway Timeout
+    520, // Web Server Unknown Error (Cloudflare)
+    521, // Web Server Is Down (Cloudflare)
+    522, // Connection Timed Out (Cloudflare)
+    523, // Origin Is Unreachable (Cloudflare)
+    524, // A Timeout Occurred (Cloudflare)
+];
+
+/// Network drop detection result
+#[derive(Debug, Clone)]
+pub struct NetworkDropInfo {
+    pub is_drop: bool,
+    pub confidence: DropConfidence,
+    pub suggested_action: SuggestedAction,
+    pub retry_delay: Duration,
+}
+
+/// Confidence level in network drop detection
+#[derive(Debug, Clone, PartialEq)]
+pub enum DropConfidence {
+    Low,
+    Medium,
+    High,
+}
+
+/// Suggested action to take when network drop is detected
+#[derive(Debug, Clone)]
+pub enum SuggestedAction {
+    Retry,
+    RetryWithBackoff,
+    WaitAndRetry(Duration),
+    CheckConnection,
+    Abort,
+}
+
+/// Detect if an error indicates a network drop, particularly from Starlink
+pub fn detect_network_drop(error: &Error) -> bool {
+    let error_string = error.to_string().to_lowercase();
+
+    // Check for direct error patterns
+    for pattern in STARLINK_ERROR_PATTERNS {
+        if error_string.contains(pattern) {
+            debug!("Network drop detected: pattern '{}' found", pattern);
+            return true;
+        }
+    }
+
+    // Check for HTTP status codes
+    for &status in SATELLITE_HTTP_ERRORS {
+        if error_string.contains(&status.to_string()) {
+            debug!("Network drop detected: HTTP status {} found", status);
+            return true;
+        }
+    }
+
+    // Check for reqwest-specific timeout errors
+    if error_string.contains("reqwest") && error_string.contains("timeout") {
+        debug!("Network drop detected: reqwest timeout");
+        return true;
+    }
+
+    false
+}
+
+/// Analyze network error and provide detailed information
+pub fn analyze_network_error(error: &Error) -> NetworkDropInfo {
+    let error_string = error.to_string().to_lowercase();
+    let mut confidence = DropConfidence::Low;
+    let mut suggested_action = SuggestedAction::Retry;
+    let mut retry_delay = Duration::from_secs(1);
+
+    // High confidence indicators
+    if error_string.contains("connection reset")
+        || error_string.contains("broken pipe")
+        || error_string.contains("network unreachable")
+    {
+        confidence = DropConfidence::High;
+        suggested_action = SuggestedAction::WaitAndRetry(Duration::from_secs(5));
+        retry_delay = Duration::from_secs(5);
+    }
+    // Medium confidence indicators
+    else if error_string.contains("timeout")
+        || error_string.contains("connection refused")
+        || SATELLITE_HTTP_ERRORS
+            .iter()
+            .any(|&status| error_string.contains(&status.to_string()))
+    {
+        confidence = DropConfidence::Medium;
+        suggested_action = SuggestedAction::RetryWithBackoff;
+        retry_delay = Duration::from_secs(2);
+    }
+    // Low confidence - generic network errors
+    else if error_string.contains("network") || error_string.contains("dns") {
+        confidence = DropConfidence::Low;
+        suggested_action = SuggestedAction::Retry;
+        retry_delay = Duration::from_secs(1);
+    }
+
+    let is_drop = confidence != DropConfidence::Low || detect_network_drop(error);
+
+    NetworkDropInfo {
+        is_drop,
+        confidence,
+        suggested_action,
+        retry_delay,
+    }
+}
+
+/// Check if we're likely on a Starlink connection
+pub async fn detect_starlink_connection() -> bool {
+    // Try to resolve Starlink-specific domains or check for satellite-specific patterns
+    // This is a heuristic approach
+
+    // Check if we can resolve starlink.com (indicates possible Starlink connection)
+    if let Ok(addrs) = tokio::net::lookup_host("starlink.com:80").await
+        && addrs.count() > 0 {
+            info!("Starlink domain resolution successful - possible Starlink connection");
+            return true;
+        }
+
+    // Additional heuristics could be added here:
+    // - Check for specific IP ranges
+    // - Analyze latency patterns
+    // - Check for satellite-specific network characteristics
+
+    false
+}
+
+/// Perform a network connectivity test
+pub async fn test_connectivity(timeout: Duration) -> Result<Duration, Error> {
+    let start = Instant::now();
+
+    // Test connectivity to multiple reliable endpoints
+    let test_hosts = vec!["google.com:80", "cloudflare.com:80", "github.com:80"];
+
+    for host in test_hosts {
+        match tokio::time::timeout(timeout, tokio::net::TcpStream::connect(host)).await {
+            Ok(Ok(_stream)) => {
+                let elapsed = start.elapsed();
+                info!("Connectivity test successful to {} in {:?}", host, elapsed);
+                return Ok(elapsed);
+            }
+            Ok(Err(e)) => {
+                warn!("Failed to connect to {}: {}", host, e);
+                continue;
+            }
+            Err(_) => {
+                warn!("Timeout connecting to {}", host);
+                continue;
+            }
+        }
+    }
+
+    Err(anyhow!("All connectivity tests failed"))
+}
+
+/// Calculate optimal retry delay based on network conditions
+pub fn calculate_retry_delay(attempt: u32, is_starlink: bool) -> Duration {
+    let base_delay = if is_starlink {
+        // Longer delays for satellite connections
+        Duration::from_secs(2_u64.pow(attempt.min(4)))
+    } else {
+        // Standard exponential backoff
+        Duration::from_secs(2_u64.pow(attempt.min(3)))
+    };
+
+    // Add jitter to prevent thundering herd
+    let jitter = Duration::from_millis(rand::random::<u64>() % 1000);
+    base_delay + jitter
+}
+
+/// Network health monitor for continuous connection quality assessment
+pub struct NetworkHealthMonitor {
+    consecutive_failures: u32,
+    last_success: Option<Instant>,
+    total_requests: u64,
+    failed_requests: u64,
+}
+
+impl NetworkHealthMonitor {
+    pub fn new() -> Self {
+        Self {
+            consecutive_failures: 0,
+            last_success: None,
+            total_requests: 0,
+            failed_requests: 0,
+        }
+    }
+
+    pub fn record_success(&mut self) {
+        self.consecutive_failures = 0;
+        self.last_success = Some(Instant::now());
+        self.total_requests += 1;
+    }
+
+    pub fn record_failure(&mut self) {
+        self.consecutive_failures += 1;
+        self.total_requests += 1;
+        self.failed_requests += 1;
+    }
+
+    pub fn health_score(&self) -> f64 {
+        if self.total_requests == 0 {
+            return 1.0;
+        }
+
+        let success_rate =
+            (self.total_requests - self.failed_requests) as f64 / self.total_requests as f64;
+
+        // Penalize consecutive failures
+        let consecutive_penalty = (self.consecutive_failures as f64 * 0.1).min(0.5);
+
+        (success_rate - consecutive_penalty).max(0.0)
+    }
+
+    pub fn should_increase_timeout(&self) -> bool {
+        self.consecutive_failures >= 3 || self.health_score() < 0.5
+    }
+
+    pub fn reset(&mut self) {
+        self.consecutive_failures = 0;
+        self.total_requests = 0;
+        self.failed_requests = 0;
+        self.last_success = None;
+    }
+}
+
+impl Default for NetworkHealthMonitor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_detect_network_drop() {
+        assert!(detect_network_drop(&anyhow!("Connection reset by peer")));
+        assert!(detect_network_drop(&anyhow!("Network unreachable")));
+        assert!(detect_network_drop(&anyhow!("HTTP 502 Bad Gateway")));
+        assert!(!detect_network_drop(&anyhow!("Invalid API key")));
+        assert!(!detect_network_drop(&anyhow!("JSON parsing error")));
+    }
+
+    #[test]
+    fn test_analyze_network_error() {
+        let reset_error = anyhow!("Connection reset by peer");
+        let analysis = analyze_network_error(&reset_error);
+        assert!(analysis.is_drop);
+        assert_eq!(analysis.confidence, DropConfidence::High);
+
+        let timeout_error = anyhow!("Request timeout");
+        let analysis = analyze_network_error(&timeout_error);
+        assert!(analysis.is_drop);
+        assert_eq!(analysis.confidence, DropConfidence::Medium);
+    }
+
+    #[test]
+    fn test_calculate_retry_delay() {
+        let delay1 = calculate_retry_delay(1, false);
+        let delay2 = calculate_retry_delay(2, false);
+        assert!(delay2 >= delay1);
+
+        let starlink_delay = calculate_retry_delay(1, true);
+        let regular_delay = calculate_retry_delay(1, false);
+        // Starlink delays should generally be longer (though jitter may affect this)
+        // We just test that both are reasonable
+        assert!(starlink_delay >= Duration::from_secs(1));
+        assert!(regular_delay >= Duration::from_secs(1));
+    }
+
+    #[test]
+    fn test_network_health_monitor() {
+        let mut monitor = NetworkHealthMonitor::new();
+        assert_eq!(monitor.health_score(), 1.0);
+
+        monitor.record_success();
+        assert_eq!(monitor.health_score(), 1.0);
+
+        monitor.record_failure();
+        assert!(monitor.health_score() < 1.0);
+        assert!(monitor.health_score() > 0.0);
+
+        // Multiple consecutive failures
+        monitor.record_failure();
+        monitor.record_failure();
+        assert!(monitor.should_increase_timeout());
+    }
+}

package/src/utils/rate_limiter.rs

@@ -0,0 +1,166 @@
+use crate::config::RateLimitConfig;
+use anyhow::{Result, anyhow};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::PathBuf;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use tracing::warn;
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+pub struct UsageStats {
+    pub total_input_tokens: u64,
+    pub total_output_tokens: u64,
+    pub request_count: u64,
+    pub last_request_time: Option<u64>, // Unix timestamp in seconds
+
+    // We store timestamps as u64 (Unix timestamp) for serialization
+    pub request_history: Vec<(u64, u32)>, // (Timestamp, TokenCount)
+}
+
+impl UsageStats {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load usage stats from disk
+    pub fn load() -> Result<Self> {
+        let path = get_usage_stats_path()?;
+        if path.exists() {
+            let json = fs::read_to_string(&path)?;
+            let stats: UsageStats = serde_json::from_str(&json)?;
+            Ok(stats)
+        } else {
+            Ok(Self::default())
+        }
+    }
+
+    /// Save usage stats to disk
+    pub fn save(&self) -> Result<()> {
+        let path = get_usage_stats_path()?;
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let json = serde_json::to_string_pretty(self)?;
+        fs::write(path, json)?;
+        Ok(())
+    }
+
+    /// Checks if the next request of estimated `tokens` size is allowed
+    pub fn check_limit(
+        &mut self,
+        config: &RateLimitConfig,
+        estimated_tokens: u32,
+    ) -> Result<(), String> {
+        self.clean_old_history(Duration::from_secs(60));
+
+        let current_tokens: u32 = self.request_history.iter().map(|(_, tokens)| *tokens).sum();
+        let current_requests = self.request_history.len() as u32;
+
+        if current_requests >= config.max_requests_per_minute {
+            return Err("Rate limit exceeded: Requests per minute".to_string());
+        }
+
+        if current_tokens + estimated_tokens > config.max_tokens_per_minute {
+            return Err("Rate limit exceeded: Tokens per minute".to_string());
+        }
+
+        Ok(())
+    }
+
+    /// Call this AFTER a successful API call to record actual usage
+    pub fn record_usage(&mut self, input_tokens: u32, output_tokens: u32) {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        let total = input_tokens + output_tokens;
+
+        self.total_input_tokens += input_tokens as u64;
+        self.total_output_tokens += output_tokens as u64;
+        self.request_count += 1;
+        self.last_request_time = Some(now);
+        self.request_history.push((now, total));
+
+        // Auto-save after update
+        if let Err(e) = self.save() {
+            warn!("Failed to save usage stats: {}. Stats will not persist.", e);
+        }
+    }
+
+    fn clean_old_history(&mut self, window: Duration) {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        let window_secs = window.as_secs();
+
+        self.request_history
+            .retain(|(time, _)| now.saturating_sub(*time) < window_secs);
+    }
+}
+
+fn get_usage_stats_path() -> Result<PathBuf> {
+    let home_dir = dirs::home_dir().ok_or_else(|| anyhow!("Could not determine home directory"))?;
+    Ok(home_dir.join(".grok").join("usage_stats.json"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::thread;
+
+    #[test]
+    fn test_clean_old_history() {
+        let mut stats = UsageStats::default();
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+
+        // Add an old record (61 seconds ago)
+        stats.request_history.push((now - 61, 100));
+        // Add a recent record (10 seconds ago)
+        stats.request_history.push((now - 10, 50));
+
+        stats.clean_old_history(Duration::from_secs(60));
+
+        assert_eq!(stats.request_history.len(), 1);
+        assert_eq!(stats.request_history[0].1, 50);
+    }
+
+    #[test]
+    fn test_check_limit_requests() {
+        let config = RateLimitConfig {
+            max_requests_per_minute: 2,
+            max_tokens_per_minute: 1000,
+        };
+        let mut stats = UsageStats::default();
+
+        assert!(stats.check_limit(&config, 10).is_ok());
+        stats.record_usage(5, 5); // 1st request
+
+        assert!(stats.check_limit(&config, 10).is_ok());
+        stats.record_usage(5, 5); // 2nd request
+
+        // 3rd request should fail
+        assert!(stats.check_limit(&config, 10).is_err());
+    }
+
+    #[test]
+    fn test_check_limit_tokens() {
+        let config = RateLimitConfig {
+            max_requests_per_minute: 10,
+            max_tokens_per_minute: 100,
+        };
+        let mut stats = UsageStats::default();
+
+        assert!(stats.check_limit(&config, 50).is_ok());
+        stats.record_usage(50, 0);
+
+        assert!(stats.check_limit(&config, 50).is_ok());
+        stats.record_usage(50, 0);
+
+        // 101st token should fail
+        assert!(stats.check_limit(&config, 1).is_err());
+    }
+}

package/src/utils/session.rs

@@ -0,0 +1,73 @@
+use crate::display::interactive::InteractiveSession;
+use anyhow::{anyhow, Result};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// Get the sessions directory path
+fn get_sessions_dir() -> Result<PathBuf> {
+    let home_dir = dirs::home_dir().ok_or_else(|| anyhow!("Could not determine home directory"))?;
+    Ok(home_dir.join(".grok").join("sessions"))
+}
+
+/// Save a session to disk
+pub fn save_session(session: &InteractiveSession, name: &str) -> Result<PathBuf> {
+    let sessions_dir = get_sessions_dir()?;
+    if !sessions_dir.exists() {
+        fs::create_dir_all(&sessions_dir)?;
+    }
+
+    let file_path = sessions_dir.join(format!("{}.json", name));
+    let json = serde_json::to_string_pretty(session)?;
+
+    fs::write(&file_path, json)?;
+    Ok(file_path)
+}
+
+/// Load a session from disk
+pub fn load_session(name: &str) -> Result<InteractiveSession> {
+    let sessions_dir = get_sessions_dir()?;
+    let file_path = sessions_dir.join(format!("{}.json", name));
+
+    if !file_path.exists() {
+        return Err(anyhow!("Session '{}' not found", name));
+    }
+
+    let json = fs::read_to_string(&file_path)?;
+    let session: InteractiveSession = serde_json::from_str(&json)?;
+    Ok(session)
+}
+
+/// List all saved sessions
+pub fn list_sessions() -> Result<Vec<String>> {
+    let sessions_dir = get_sessions_dir()?;
+    if !sessions_dir.exists() {
+        return Ok(Vec::new());
+    }
+
+    let mut sessions = Vec::new();
+    for entry in fs::read_dir(sessions_dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.extension().and_then(|s| s.to_str()) == Some("json")
+            && let Some(stem) = path.file_stem().and_then(|s| s.to_str()) {
+                sessions.push(stem.to_string());
+            }
+    }
+
+    sessions.sort();
+    Ok(sessions)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn test_save_and_load_session() {
+        // We can't easily mock dirs::home_dir without more complex dependency injection or env var tricks
+        // So we will verify serialization logic separately if needed, but for now this module
+        // relies on file system integration.
+        // A proper test would mock the session dir.
+    }
+}