fix session cmd (#13)

* fix session cmd

* address feedback

cli/src/main.rs

@@ -6,14 +6,93 @@ mod output;
 
 use serde_json::json;
 use std::env;
+use std::fs;
 use std::process::exit;
 
+#[cfg(unix)]
+use libc;
+
+#[cfg(windows)]
+use windows_sys::Win32::Foundation::CloseHandle;
+#[cfg(windows)]
+use windows_sys::Win32::System::Threading::{OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION};
+
 use commands::{gen_id, parse_command, ParseError};
 use connection::{ensure_daemon, send_command};
 use flags::{clean_args, parse_flags};
 use install::run_install;
 use output::{print_help, print_response};
 
+fn run_session(args: &[String], session: &str, json_mode: bool) {
+    let subcommand = args.get(1).map(|s| s.as_str());
+
+    match subcommand {
+        Some("list") => {
+            let tmp = env::temp_dir();
+            let mut sessions: Vec<String> = Vec::new();
+
+            if let Ok(entries) = fs::read_dir(&tmp) {
+                for entry in entries.flatten() {
+                    let name = entry.file_name().to_string_lossy().to_string();
+                    // Look for socket files (Unix) or pid files
+                    if name.starts_with("agent-browser-") && name.ends_with(".pid") {
+                        let session_name = name
+                            .strip_prefix("agent-browser-")
+                            .and_then(|s| s.strip_suffix(".pid"))
+                            .unwrap_or("");
+                        if !session_name.is_empty() {
+                            // Check if session is actually running
+                            let pid_path = tmp.join(&name);
+                            if let Ok(pid_str) = fs::read_to_string(&pid_path) {
+                                if let Ok(pid) = pid_str.trim().parse::<u32>() {
+                                    #[cfg(unix)]
+                                    let running = unsafe { libc::kill(pid as i32, 0) == 0 };
+                                    #[cfg(windows)]
+                                    let running = unsafe {
+                                        let handle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid);
+                                        if handle != 0 {
+                                            CloseHandle(handle);
+                                            true
+                                        } else {
+                                            false
+                                        }
+                                    };
+                                    if running {
+                                        sessions.push(session_name.to_string());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if json_mode {
+                println!(
+                    r#"{{"success":true,"data":{{"sessions":{}}}}}"#,
+                    serde_json::to_string(&sessions).unwrap_or_default()
+                );
+            } else if sessions.is_empty() {
+                println!("No active sessions");
+            } else {
+                println!("Active sessions:");
+                for s in &sessions {
+                    let marker = if s == session { "→" } else { " " };
+                    println!("{} {}", marker, s);
+                }
+            }
+        }
+        None | Some(_) => {
+            // Just show current session
+            if json_mode {
+                println!(r#"{{"success":true,"data":{{"session":"{}"}}}}"#, session);
+            } else {
+                println!("{}", session);
+            }
+        }
+    }
+}
+
 fn main() {
     let args: Vec<String> = env::args().skip(1).collect();
     let flags = parse_flags(&args);
@@ -31,6 +110,12 @@ fn main() {
         return;
     }
 
+    // Handle session separately (doesn't need daemon)
+    if clean.get(0).map(|s| s.as_str()) == Some("session") {
+        run_session(&clean, &flags.session, flags.json);
+        return;
+    }
+
     let cmd = match parse_command(&clean, &flags) {
         Ok(c) => c,
         Err(e) => {