#![allow(dead_code)]
use crate::utils::project;
use crate::utils::tmux::{kill_session, list_sessions, SessionInfo};
use anyhow::{Context, Result};
use std::fs;
use std::path::Path;
use std::process::Command;
use std::time::{Duration, SystemTime};
#[derive(Debug, Clone)]
pub struct SessionHealth {
pub name: String,
pub status: SessionStatus,
pub windows: usize,
pub active_panes: usize,
pub age_seconds: u64,
pub last_activity: Option<SystemTime>,
pub issues: Vec<SessionIssue>,
}
#[derive(Debug, Clone, PartialEq)]
pub enum SessionStatus {
Healthy,
Degraded,
Dead,
Orphaned,
}
#[derive(Debug, Clone)]
pub enum SessionIssue {
NoActivePanes,
IdleTooLong(Duration),
ZombieProcesses(usize),
WorkspaceMissing(String),
GitIssues(String),
TmuxSocketIssues(String),
HighMemoryUsage(u64),
}
#[derive(Debug, Clone)]
pub enum RecoveryAction {
None,
Restart,
Cleanup,
Repair,
Prompt,
}
#[derive(Debug, Clone)]
pub struct RecoveryConfig {
pub max_idle_time: Duration,
pub max_session_age: Duration,
pub auto_cleanup: bool,
pub cleanup_dirs: Vec<String>,
pub monitored_processes: Vec<String>,
}
impl Default for RecoveryConfig {
fn default() -> Self {
Self {
max_idle_time: Duration::from_secs(3600), max_session_age: Duration::from_secs(86400), auto_cleanup: false,
cleanup_dirs: vec!["/tmp".to_string(), "/var/tmp".to_string()],
monitored_processes: vec!["tmux".to_string(), "git".to_string(), "sprite".to_string()],
}
}
}
pub fn analyze_session_health(config: &RecoveryConfig) -> Result<Vec<SessionHealth>> {
let sessions = match list_sessions() {
Ok(sessions) => sessions,
Err(_) => {
return Ok(Vec::new());
}
};
let mut health_reports = Vec::new();
for session in sessions {
let health = check_session_health(&session, config)?;
health_reports.push(health);
}
Ok(health_reports)
}
pub fn check_session_health(
session: &SessionInfo,
config: &RecoveryConfig,
) -> Result<SessionHealth> {
let mut issues = Vec::new();
let mut active_panes = 0;
let is_responsive = check_session_responsiveness(&session.name)?;
match crate::utils::tmux::get_session_panes(&session.name) {
Ok(panes) => {
active_panes = panes.len();
if active_panes == 0 {
issues.push(SessionIssue::NoActivePanes);
}
}
Err(_) => {
issues.push(SessionIssue::TmuxSocketIssues(
"Failed to list session panes".to_string(),
));
}
}
let age_seconds = parse_session_age(&session.created)?;
if age_seconds > config.max_session_age.as_secs() {
issues.push(SessionIssue::IdleTooLong(Duration::from_secs(age_seconds)));
}
if let Some(workspace_issue) = check_workspace_integrity(&session.name)? {
issues.push(workspace_issue);
}
if let Ok(zombie_count) = count_zombie_processes(&session.name) {
if zombie_count > 0 {
issues.push(SessionIssue::ZombieProcesses(zombie_count));
}
}
let status = if !is_responsive
|| issues
.iter()
.any(|i| matches!(i, SessionIssue::TmuxSocketIssues(_)))
{
SessionStatus::Dead
} else if issues
.iter()
.any(|i| matches!(i, SessionIssue::WorkspaceMissing(_)))
{
SessionStatus::Orphaned
} else if !issues.is_empty() {
SessionStatus::Degraded
} else {
SessionStatus::Healthy
};
Ok(SessionHealth {
name: session.name.clone(),
status,
windows: session.windows,
active_panes,
age_seconds,
last_activity: None, issues,
})
}
fn check_session_responsiveness(session_name: &str) -> Result<bool> {
let output = Command::new("tmux")
.args(["display-message", "-p", "-t", session_name, "#S"])
.output()
.context("Failed to check session responsiveness")?;
Ok(output.status.success() && !output.stdout.is_empty())
}
fn parse_session_age(_created_str: &str) -> Result<u64> {
Ok(3600) }
fn check_workspace_integrity(session_name: &str) -> Result<Option<SessionIssue>> {
match project::find_project_root() {
Ok(project_root) => {
let config_path = project_root.join("agents").join("agents.yaml");
if !config_path.exists() {
return Ok(Some(SessionIssue::WorkspaceMissing(format!(
"Sprite configuration not found at {}",
config_path.display()
))));
}
let git_metadata = project_root.join(".git");
if !git_metadata.exists() {
return Ok(Some(SessionIssue::GitIssues(format!(
"Project root {} is not a git repository",
project_root.display()
))));
}
Ok(None)
}
Err(_) => Ok(Some(SessionIssue::WorkspaceMissing(format!(
"No Sprite project detected for session {}",
session_name
)))),
}
}
fn count_zombie_processes(_session_name: &str) -> Result<usize> {
Ok(0)
}
pub fn get_recovery_action(health: &SessionHealth, config: &RecoveryConfig) -> RecoveryAction {
match health.status {
SessionStatus::Healthy => RecoveryAction::None,
SessionStatus::Dead => {
if config.auto_cleanup {
RecoveryAction::Cleanup
} else {
RecoveryAction::Prompt
}
}
SessionStatus::Orphaned => {
if config.auto_cleanup {
RecoveryAction::Cleanup
} else {
RecoveryAction::Prompt
}
}
SessionStatus::Degraded => {
if health
.issues
.iter()
.any(|i| matches!(i, SessionIssue::NoActivePanes))
{
RecoveryAction::Repair
} else if health.age_seconds > config.max_session_age.as_secs() {
if config.auto_cleanup {
RecoveryAction::Cleanup
} else {
RecoveryAction::Prompt
}
} else {
RecoveryAction::Repair
}
}
}
}
pub fn perform_recovery_action(session_name: &str, action: RecoveryAction) -> Result<()> {
match action {
RecoveryAction::None => Ok(()),
RecoveryAction::Restart => {
println!("🔄 Restarting session: {}", session_name);
kill_session(session_name)?;
Ok(())
}
RecoveryAction::Cleanup => {
println!("🧹 Cleaning up session: {}", session_name);
cleanup_session_resources(session_name)?;
kill_session(session_name)?;
Ok(())
}
RecoveryAction::Repair => {
println!("🔧 Repairing session: {}", session_name);
repair_session(session_name)?;
Ok(())
}
RecoveryAction::Prompt => {
println!("❓ Action required for session: {}", session_name);
Ok(())
}
}
}
pub fn cleanup_session_resources(session_name: &str) -> Result<()> {
let temp_patterns = vec![
format!("/tmp/sprite-{}-*", session_name),
format!("/var/tmp/sprite-{}-*", session_name),
format!("/tmp/tmux-{}*", session_name),
];
for pattern in temp_patterns {
if let Ok(output) = Command::new("find")
.args(["/tmp", "-name", &pattern, "-delete"])
.output()
{
if !output.status.success() {
eprintln!(
"Warning: Failed to cleanup pattern {}: {}",
pattern,
String::from_utf8_lossy(&output.stderr)
);
}
}
}
let state_dir = Path::new(".sprites");
if state_dir.exists() {
let session_state = state_dir.join(format!("{}.json", session_name));
if session_state.exists() {
fs::remove_file(&session_state).with_context(|| {
format!("Failed to remove session state file: {:?}", session_state)
})?;
}
}
Ok(())
}
fn repair_session(session_name: &str) -> Result<()> {
match crate::utils::tmux::get_session_panes(session_name) {
Ok(panes) if panes.is_empty() => {
crate::utils::tmux::create_window(session_name, "recovery")?;
println!("✅ Created recovery window for session: {}", session_name);
}
Ok(_) => {
println!("✅ Session {} appears to be functioning", session_name);
}
Err(e) => {
eprintln!("❌ Failed to repair session {}: {}", session_name, e);
return Err(e);
}
}
Ok(())
}
pub fn cleanup_old_sessions(config: &RecoveryConfig) -> Result<Vec<String>> {
let health_reports = analyze_session_health(config)?;
let mut cleaned_sessions = Vec::new();
for health in health_reports {
let action = get_recovery_action(&health, config);
if matches!(action, RecoveryAction::Cleanup) {
if let Err(e) = perform_recovery_action(&health.name, action) {
eprintln!("Failed to cleanup session {}: {}", health.name, e);
} else {
cleaned_sessions.push(health.name);
}
}
}
Ok(cleaned_sessions)
}
pub fn cleanup_temp_files(config: &RecoveryConfig) -> Result<()> {
for temp_dir in &config.cleanup_dirs {
if Path::new(temp_dir).exists() {
cleanup_directory(temp_dir, "sprite-*")?;
cleanup_directory(temp_dir, "tmux-*")?;
}
}
Ok(())
}
fn cleanup_directory(dir: &str, pattern: &str) -> Result<()> {
let output = Command::new("find")
.args([dir, "-name", pattern, "-mtime", "+1", "-delete"])
.output()
.context("Failed to cleanup temporary files")?;
if !output.status.success() {
eprintln!(
"Warning: Failed to cleanup {} in {}: {}",
pattern,
dir,
String::from_utf8_lossy(&output.stderr)
);
}
Ok(())
}
pub fn generate_health_report(health_reports: &[SessionHealth]) -> String {
let mut report = String::new();
report.push_str("🏥 Session Health Report\n");
report.push_str("========================\n\n");
let mut healthy_count = 0;
let mut degraded_count = 0;
let mut dead_count = 0;
let mut orphaned_count = 0;
for health in health_reports {
match health.status {
SessionStatus::Healthy => healthy_count += 1,
SessionStatus::Degraded => degraded_count += 1,
SessionStatus::Dead => dead_count += 1,
SessionStatus::Orphaned => orphaned_count += 1,
}
let status_icon = match health.status {
SessionStatus::Healthy => "🟢",
SessionStatus::Degraded => "🟡",
SessionStatus::Dead => "🔴",
SessionStatus::Orphaned => "⚪",
};
report.push_str(&format!(
"{} {} ({} windows, {} panes, {}s old)\n",
status_icon, health.name, health.windows, health.active_panes, health.age_seconds
));
if !health.issues.is_empty() {
for issue in &health.issues {
let issue_desc = match issue {
SessionIssue::NoActivePanes => "No active panes".to_string(),
SessionIssue::IdleTooLong(duration) => format!("Idle for {:?}", duration),
SessionIssue::ZombieProcesses(count) => format!("{} zombie processes", count),
SessionIssue::WorkspaceMissing(path) => format!("Workspace missing: {}", path),
SessionIssue::GitIssues(msg) => format!("Git issues: {}", msg),
SessionIssue::TmuxSocketIssues(msg) => format!("Tmux socket issues: {}", msg),
SessionIssue::HighMemoryUsage(bytes) => {
format!("High memory usage: {} MB", bytes / 1024 / 1024)
}
};
report.push_str(&format!(" ⚠️ {}\n", issue_desc));
}
}
report.push('\n');
}
report.push_str("--- Summary ---\n");
report.push_str(&format!("🟢 Healthy: {}\n", healthy_count));
report.push_str(&format!("🟡 Degraded: {}\n", degraded_count));
report.push_str(&format!("🔴 Dead: {}\n", dead_count));
report.push_str(&format!("⚪ Orphaned: {}\n", orphaned_count));
report
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_recovery_config_default() {
let config = RecoveryConfig::default();
assert_eq!(config.max_idle_time, Duration::from_secs(3600));
assert_eq!(config.max_session_age, Duration::from_secs(86400));
assert!(!config.auto_cleanup);
}
#[test]
fn test_session_age_parsing() {
let age = parse_session_age("created Wed Oct 18 10:30:00 2023").unwrap();
assert_eq!(age, 3600); }
#[test]
fn test_health_report_generation() {
let health = SessionHealth {
name: "test-session".to_string(),
status: SessionStatus::Healthy,
windows: 3,
active_panes: 3,
age_seconds: 1800,
last_activity: None,
issues: vec![],
};
let report = generate_health_report(&[health]);
assert!(report.contains("Session Health Report"));
assert!(report.contains("test-session"));
assert!(report.contains("🟢"));
}
#[test]
fn test_recovery_action_selection() {
let config = RecoveryConfig::default();
let healthy_session = SessionHealth {
name: "healthy".to_string(),
status: SessionStatus::Healthy,
windows: 1,
active_panes: 1,
age_seconds: 100,
last_activity: None,
issues: vec![],
};
let action = get_recovery_action(&healthy_session, &config);
assert!(matches!(action, RecoveryAction::None));
}
}