fix(cli): add session cleanup commands (delete and prune)

Fixes bounty issue #1656

Added new subcommands to the sessions command:
- `sessions list` - list sessions (default behavior, backwards compatible)
- `sessions delete <id>` - delete a specific session by ID
- `sessions prune --older-than <days>` - delete old sessions

Features:
- Partial session ID matching (first 8 chars are sufficient)
- Confirmation prompts with --force flag to skip
- Dry-run mode for prune command
- Support for --all flag on list subcommand

Also fixed a pre-existing compilation error in snapshot.rs where
`permissions` was destructured as `_` but later used.

Author: factorydroid

cortex-cli/src/main.rs

@@ -298,14 +298,67 @@ struct ResumeCommand {
     config_overrides: CliConfigOverrides,
 }
 
-/// Sessions command.
+/// Sessions command with subcommands.
 #[derive(Args)]
 struct SessionsCommand {
+    #[command(subcommand)]
+    action: Option<SessionsSubcommand>,
+
+    /// Show all sessions including from other directories (for list subcommand)
+    #[arg(long)]
+    all: bool,
+}
+
+/// Sessions subcommands.
+#[derive(Subcommand)]
+enum SessionsSubcommand {
+    /// List all sessions (default if no subcommand given)
+    List(SessionsListArgs),
+
+    /// Delete a specific session by ID
+    #[command(visible_alias = "rm")]
+    Delete(SessionsDeleteArgs),
+
+    /// Delete old sessions (garbage collection)
+    #[command(visible_alias = "gc")]
+    Prune(SessionsPruneArgs),
+}
+
+/// Arguments for sessions list subcommand.
+#[derive(Args)]
+struct SessionsListArgs {
     /// Show all sessions including from other directories
     #[arg(long)]
     all: bool,
 }
 
+/// Arguments for sessions delete subcommand.
+#[derive(Args)]
+struct SessionsDeleteArgs {
+    /// Session ID to delete (first 8 characters are sufficient)
+    session_id: String,
+
+    /// Skip confirmation prompt
+    #[arg(short, long)]
+    force: bool,
+}
+
+/// Arguments for sessions prune subcommand.
+#[derive(Args)]
+struct SessionsPruneArgs {
+    /// Delete sessions older than this many days
+    #[arg(long, default_value = "30")]
+    older_than: u64,
+
+    /// Skip confirmation prompt
+    #[arg(short, long)]
+    force: bool,
+
+    /// Show what would be deleted without actually deleting
+    #[arg(long)]
+    dry_run: bool,
+}
+
 /// Config command.
 #[derive(Args)]
 struct ConfigCommand {
@@ -478,7 +531,7 @@ async fn main() -> Result<()> {
             }
         },
         Some(Commands::Resume(resume_cli)) => run_resume(resume_cli).await,
-        Some(Commands::Sessions(sessions_cli)) => list_sessions(sessions_cli.all).await,
+        Some(Commands::Sessions(sessions_cli)) => run_sessions(sessions_cli).await,
         Some(Commands::Export(export_cli)) => export_cli.run().await,
         Some(Commands::Import(import_cli)) => import_cli.run().await,
         Some(Commands::Config(config_cli)) => show_config(config_cli).await,
@@ -676,6 +729,19 @@ async fn run_resume(resume_cli: ResumeCommand) -> Result<()> {
     Ok(())
 }
 
+/// Handle sessions command with subcommands.
+async fn run_sessions(sessions_cli: SessionsCommand) -> Result<()> {
+    match sessions_cli.action {
+        None => {
+            // Default: list sessions (backwards compatible)
+            list_sessions(sessions_cli.all).await
+        }
+        Some(SessionsSubcommand::List(args)) => list_sessions(args.all).await,
+        Some(SessionsSubcommand::Delete(args)) => delete_session(args).await,
+        Some(SessionsSubcommand::Prune(args)) => prune_sessions(args).await,
+    }
+}
+
 async fn list_sessions(show_all: bool) -> Result<()> {
     let config = cortex_engine::Config::default();
     let sessions = cortex_engine::list_sessions(&config.cortex_home)?;
@@ -741,6 +807,162 @@ async fn list_sessions(show_all: bool) -> Result<()> {
     if !show_all {
         println!("          Cortex sessions --all  (show all directories)");
     }
+    println!("\nTo delete: Cortex sessions delete <session-id>");
+    println!("To cleanup: Cortex sessions prune --older-than 30");
+    Ok(())
+}
+
+/// Delete a specific session by ID.
+async fn delete_session(args: SessionsDeleteArgs) -> Result<()> {
+    use std::io::{BufRead, Write};
+
+    let config = cortex_engine::Config::default();
+    let sessions = cortex_engine::list_sessions(&config.cortex_home)?;
+
+    // Find the session (support partial ID match)
+    let session = sessions
+        .iter()
+        .find(|s| s.id.starts_with(&args.session_id) || s.id == args.session_id);
+
+    let session = match session {
+        Some(s) => s,
+        None => {
+            eprintln!("No session found matching '{}'", args.session_id);
+            eprintln!("\nUse 'Cortex sessions' to list available sessions.");
+            return Ok(());
+        }
+    };
+
+    // Confirm deletion unless --force is used
+    if !args.force {
+        let date = if session.timestamp.len() >= 19 {
+            session.timestamp[..19].replace('T', " ")
+        } else {
+            session.timestamp.clone()
+        };
+        println!("Session to delete:");
+        println!("  ID: {}", session.id);
+        println!("  Date: {}", date);
+        println!("  Messages: {}", session.message_count);
+        println!("  CWD: {}", session.cwd.display());
+        println!();
+        print!("Delete this session? [y/N]: ");
+        io::stdout().flush()?;
+
+        let mut input = String::new();
+        io::stdin().lock().read_line(&mut input)?;
+
+        if !input.trim().eq_ignore_ascii_case("y") {
+            println!("Cancelled.");
+            return Ok(());
+        }
+    }
+
+    // Delete the session files
+    let sessions_dir = config.cortex_home.join("sessions");
+    let session_file = sessions_dir.join(format!("{}.jsonl", session.id));
+
+    if session_file.exists() {
+        std::fs::remove_file(&session_file)?;
+        println!(
+            "Deleted session: {}",
+            &session.id[..8.min(session.id.len())]
+        );
+    } else {
+        eprintln!("Session file not found: {}", session_file.display());
+    }
+
+    Ok(())
+}
+
+/// Prune (garbage collect) old sessions.
+async fn prune_sessions(args: SessionsPruneArgs) -> Result<()> {
+    use std::io::{BufRead, Write};
+
+    let config = cortex_engine::Config::default();
+    let sessions = cortex_engine::list_sessions(&config.cortex_home)?;
+
+    if sessions.is_empty() {
+        println!("No sessions found.");
+        return Ok(());
+    }
+
+    // Calculate cutoff date
+    let cutoff = chrono::Utc::now() - chrono::Duration::days(args.older_than as i64);
+    let cutoff_str = cutoff.to_rfc3339();
+
+    // Find sessions older than cutoff
+    let to_delete: Vec<_> = sessions
+        .iter()
+        .filter(|s| s.timestamp < cutoff_str)
+        .collect();
+
+    if to_delete.is_empty() {
+        println!("No sessions older than {} days found.", args.older_than);
+        return Ok(());
+    }
+
+    println!(
+        "Found {} session(s) older than {} days:",
+        to_delete.len(),
+        args.older_than
+    );
+    println!("{:-<80}", "");
+
+    for session in &to_delete {
+        let date = if session.timestamp.len() >= 19 {
+            session.timestamp[..19].replace('T', " ")
+        } else {
+            session.timestamp.clone()
+        };
+        println!(
+            "  {} | {} | {} msgs",
+            &session.id[..8.min(session.id.len())],
+            date,
+            session.message_count
+        );
+    }
+    println!();
+
+    if args.dry_run {
+        println!("(Dry run - no sessions were deleted)");
+        return Ok(());
+    }
+
+    // Confirm deletion unless --force is used
+    if !args.force {
+        print!("Delete {} session(s)? [y/N]: ", to_delete.len());
+        io::stdout().flush()?;
+
+        let mut input = String::new();
+        io::stdin().lock().read_line(&mut input)?;
+
+        if !input.trim().eq_ignore_ascii_case("y") {
+            println!("Cancelled.");
+            return Ok(());
+        }
+    }
+
+    // Delete the sessions
+    let sessions_dir = config.cortex_home.join("sessions");
+    let mut deleted_count = 0;
+
+    for session in &to_delete {
+        let session_file = sessions_dir.join(format!("{}.jsonl", session.id));
+        if session_file.exists() {
+            if let Err(e) = std::fs::remove_file(&session_file) {
+                eprintln!(
+                    "Failed to delete session {}: {}",
+                    &session.id[..8.min(session.id.len())],
+                    e
+                );
+            } else {
+                deleted_count += 1;
+            }
+        }
+    }
+
+    println!("Deleted {} session(s).", deleted_count);
     Ok(())
 }
 
@@ -860,13 +1082,13 @@ async fn run_serve(serve_cli: ServeCommand) -> Result<()> {
     let result = cortex_app_server::run(config).await;
 
     // Stop mDNS advertising on shutdown
-    if let Some(ref mut mdns) = mdns_service {
-        if let Err(e) = mdns.stop_advertising().await {
-            eprintln!("Warning: Failed to stop mDNS advertising: {e}");
-        }
+    if let Some(ref mut mdns) = mdns_service
+        && let Err(e) = mdns.stop_advertising().await
+    {
+        eprintln!("Warning: Failed to stop mDNS advertising: {e}");
     }
 
-    result.map_err(Into::into)
+    result
 }
 
 async fn run_servers(servers_cli: ServersCommand) -> Result<()> {

cortex-engine/src/tasks/snapshot.rs

@@ -292,7 +292,7 @@ impl SnapshotManager {
             match state {
                 FileState::Exists {
                     content,
-                    permissions: _,
+                    permissions,
                     ..
                 } => {
                     // Create parent directories
@@ -309,6 +309,8 @@ impl SnapshotManager {
                         use std::os::unix::fs::PermissionsExt;
                         fs::set_permissions(path, std::fs::Permissions::from_mode(*mode))?;
                     }
+                    #[cfg(not(unix))]
+                    let _ = permissions; // Silence unused warning on non-Unix
 
                     result.restored.push(path.clone());
                 }