claudectl-core 0.73.0

use std::fs;
use std::path::PathBuf;

use crate::session::{ClaudeSession, RawSession};

fn sessions_dir() -> PathBuf {
    dirs_home().join(".claude").join("sessions")
}

fn dirs_home() -> PathBuf {
    std::env::var_os("HOME")
        .map(PathBuf::from)
        .unwrap_or_else(|| PathBuf::from("/tmp"))
}

pub fn projects_dir() -> PathBuf {
    dirs_home().join(".claude").join("projects")
}

pub fn scan_sessions() -> Vec<ClaudeSession> {
    let dir = sessions_dir();
    cleanup_stale_sessions(&dir);

    let mut sessions = Vec::new();

    // A missing `~/.claude/sessions` is no longer the end of the sweep: on a
    // machine with Codex and not Claude Code it is the *normal* state, and
    // returning early here hid every Codex session (#524).
    let entries = match fs::read_dir(&dir) {
        Ok(e) => e,
        Err(_) => {
            sessions.extend(scan_codex_sessions());
            return sessions;
        }
    };

    for entry in entries.flatten() {
        let path = entry.path();
        if path.extension().and_then(|e| e.to_str()) != Some("json") {
            continue;
        }

        let content = match fs::read_to_string(&path) {
            Ok(c) => c,
            Err(e) => {
                crate::logger::log(
                    "WARN",
                    &format!("session file read error: {}: {e}", path.display()),
                );
                continue;
            }
        };

        let raw: RawSession = match serde_json::from_str(&content) {
            Ok(r) => r,
            Err(e) => {
                crate::logger::log(
                    "WARN",
                    &format!("session file parse error: {}: {e}", path.display()),
                );
                continue;
            }
        };

        // JSONL path resolved later by resolve_jsonl_paths() after command_args are populated
        sessions.push(ClaudeSession::from_raw(raw));
    }

    sessions.extend(scan_codex_sessions());

    sessions
}

/// Codex sessions, from their rollout transcripts (#524).
///
/// Appended to the Claude Code sweep rather than routed through
/// `coord::adapter`'s registry: getting Codex sessions rendered does not need
/// that refactor, and the refactor touches all three crates.
///
/// Returns nothing when `~/.codex` is absent, which is the common case.
fn scan_codex_sessions() -> Vec<ClaudeSession> {
    use crate::agent::codex;

    if !crate::agent::is_family_present(crate::agent::vocab::CODEX) {
        return Vec::new();
    }
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_secs())
        .unwrap_or(0);

    codex::scan(now, codex::CODEX_SESSION_TTL_SECS)
        .iter()
        .map(ClaudeSession::from_codex_rollout)
        .collect()
}

/// Resolve JSONL paths for sessions. Must be called AFTER command_args are populated
/// (i.e., after fetch_ps_data), so we can use --resume UUIDs for correct mapping.
pub fn resolve_jsonl_paths(sessions: &mut [ClaudeSession]) {
    for session in sessions.iter_mut() {
        // A Codex session's transcript is its rollout file, already set by
        // `from_codex_rollout`. Everything below looks under
        // `~/.claude/projects` and would overwrite it with a wrong path or,
        // worse, with another session's via the latest-mtime fallback (#524).
        if !session.is_claude_code() {
            continue;
        }
        let slug = cwd_to_slug(&session.cwd);
        let project_dir = projects_dir().join(&slug);

        // Priority 1: Try the session's own ID in the expected project dir
        let own_path = project_dir.join(format!("{}.jsonl", session.session_id));
        if own_path.exists() {
            session.jsonl_path = Some(own_path);
            continue;
        }

        // Priority 2: Try the --resume UUID from command args
        if let Some(resume_id) = extract_resume_uuid(&session.command_args) {
            let resume_path = project_dir.join(format!("{resume_id}.jsonl"));
            if resume_path.exists() {
                session.jsonl_path = Some(resume_path);
                continue;
            }
        }

        // Priority 3: Fall back to most recently modified .jsonl in the project dir
        if let Some(latest) = find_latest_jsonl(&project_dir) {
            session.jsonl_path = Some(latest);
            continue;
        }

        // Priority 4: Search ALL project directories for a JSONL matching the session ID.
        // This handles cwd encoding mismatches between claudectl and Claude Code
        // (e.g., symlink resolution, path normalization differences).
        if let Some(found) = search_all_projects_for_session(&session.session_id) {
            crate::logger::log(
                "DEBUG",
                &format!(
                    "session {}: slug mismatch — found JSONL via project scan: {}",
                    session.session_id,
                    found.display()
                ),
            );
            session.jsonl_path = Some(found);
            continue;
        }

        crate::logger::log(
            "DEBUG",
            &format!(
                "session {}: no JSONL found (slug={}, project_dir_exists={})",
                session.session_id,
                slug,
                project_dir.exists()
            ),
        );
    }
}

/// Search all directories under ~/.claude/projects/ for a JSONL file matching the session ID.
/// This is a fallback when the cwd-based slug doesn't match the actual directory on disk.
fn search_all_projects_for_session(session_id: &str) -> Option<PathBuf> {
    let filename = format!("{session_id}.jsonl");
    let base = projects_dir();
    let entries = fs::read_dir(&base).ok()?;

    for entry in entries.flatten() {
        let path = entry.path();
        if !path.is_dir() {
            continue;
        }
        let candidate = path.join(&filename);
        if candidate.exists() {
            return Some(candidate);
        }
    }
    None
}

/// Extract the UUID from a --resume argument in command args.
fn extract_resume_uuid(command_args: &str) -> Option<String> {
    let marker = "--resume ";
    let start = command_args.find(marker)? + marker.len();
    let rest = &command_args[start..];
    // Take until whitespace — could be a UUID or a named session
    let token: String = rest.chars().take_while(|c| !c.is_whitespace()).collect();
    if token.is_empty() {
        return None;
    }
    // Strip surrounding quotes
    let token = token.trim_matches('"').trim_matches('\'');
    Some(token.to_string())
}

/// Find the most recently modified .jsonl file in a project directory.
fn find_latest_jsonl(dir: &PathBuf) -> Option<PathBuf> {
    let entries = fs::read_dir(dir).ok()?;
    let mut best: Option<(PathBuf, std::time::SystemTime)> = None;

    for entry in entries.flatten() {
        let path = entry.path();
        if path.extension().and_then(|e| e.to_str()) != Some("jsonl") {
            continue;
        }
        let modified = entry.metadata().ok()?.modified().ok()?;
        if best.as_ref().is_none_or(|(_, t)| modified > *t) {
            best = Some((path, modified));
        }
    }

    best.map(|(p, _)| p)
}

/// Feature #29: Scan for subagent task .jsonl files.
/// Claude Code spawns sub-agents whose files live in:
///   /tmp/claude-{uid}/{project_slug}/{sessionId}/tasks/
pub fn scan_subagents(sessions: &mut [ClaudeSession]) {
    let uid = unsafe { libc::getuid() };
    let tmp_base = PathBuf::from(format!("/tmp/claude-{uid}"));

    if !tmp_base.exists() {
        for session in sessions.iter_mut() {
            session.active_subagent_count = 0;
            session.active_subagent_jsonl_paths.clear();
        }
        return;
    }

    for session in sessions.iter_mut() {
        // `/tmp/claude-<uid>` is Claude Code's subagent layout; a Codex
        // session has nothing there (#524).
        if !session.is_claude_code() {
            session.active_subagent_count = 0;
            session.active_subagent_jsonl_paths.clear();
            continue;
        }
        let slug = cwd_to_slug(&session.cwd);
        let tasks_dir = tmp_base.join(&slug).join(&session.session_id).join("tasks");

        if !tasks_dir.exists() {
            session.active_subagent_count = 0;
            session.active_subagent_jsonl_paths.clear();
            continue;
        }

        let mut jsonls = Vec::new();
        collect_subagent_jsonls(&tasks_dir, &mut jsonls);
        jsonls.sort();
        session.active_subagent_count = jsonls.len();
        session.active_subagent_jsonl_paths = jsonls;
    }
}

fn collect_subagent_jsonls(dir: &PathBuf, jsonls: &mut Vec<PathBuf>) {
    let Ok(entries) = fs::read_dir(dir) else {
        return;
    };

    for entry in entries.flatten() {
        let path = entry.path();
        if path.is_dir() {
            collect_subagent_jsonls(&path, jsonls);
            continue;
        }
        if path.extension().and_then(|ext| ext.to_str()) == Some("jsonl") {
            jsonls.push(path);
        }
    }
}

/// Resolve git worktree identity for each session (for conflict detection).
/// Sessions in different worktrees of the same repo get different IDs.
/// Runs `git rev-parse --show-toplevel` once per unique cwd.
pub fn resolve_worktree_ids(sessions: &mut [ClaudeSession]) {
    // Cache results to avoid running git multiple times for the same cwd
    let mut cache: std::collections::HashMap<String, String> = std::collections::HashMap::new();

    for session in sessions.iter_mut() {
        if session.worktree_id.is_some() {
            continue;
        }
        let id = if let Some(cached) = cache.get(&session.cwd) {
            cached.clone()
        } else {
            let resolved = std::process::Command::new("git")
                .args(["rev-parse", "--show-toplevel"])
                .current_dir(&session.cwd)
                .output()
                .ok()
                .and_then(|o| {
                    if o.status.success() {
                        String::from_utf8(o.stdout)
                            .ok()
                            .map(|s| s.trim().to_string())
                    } else {
                        None
                    }
                })
                // Fall back to cwd if not a git repo
                .unwrap_or_else(|| session.cwd.clone());
            cache.insert(session.cwd.clone(), resolved.clone());
            resolved
        };
        session.worktree_id = Some(id);
    }
}

/// Characters Claude Code replaces with `-` when it names a project
/// directory under `~/.claude/projects`.
///
/// Verified against the `cwd` field of all 316 transcripts on a real machine
/// versus the directory each one sits in: this set explains 296 exactly, and
/// none of the remaining 20 differ only in punctuation — those record a
/// genuinely different path (a session that moved between a repo root and a
/// worktree), which no mapping can account for.
const SLUG_SEPARATORS: [char; 4] = ['/', '.', '_', '+'];

/// The project directory Claude Code keeps a session's transcript in, for a
/// session whose working directory is `cwd`.
///
/// Public because conversation transfer (#478 item 3) has to write a
/// transcript to exactly this path: `claude --resume` looks only here and
/// does not search, so a transcript placed anywhere else is not resumable.
pub fn project_dir_for(cwd: &str) -> PathBuf {
    projects_dir().join(cwd_to_slug(cwd))
}

fn cwd_to_slug(cwd: &str) -> String {
    let trimmed = cwd.trim_end_matches('/');
    if trimmed.is_empty() {
        return "-".to_string();
    }
    trimmed
        .chars()
        .map(|c| if SLUG_SEPARATORS.contains(&c) { '-' } else { c })
        .collect()
}

/// Remove session JSON files for dead PIDs whose files are older than 24 hours.
/// This prevents stale files from previous runs accumulating in ~/.claude/sessions/.
fn cleanup_stale_sessions(dir: &std::path::Path) {
    const MAX_AGE: std::time::Duration = std::time::Duration::from_secs(24 * 3600);
    let now = std::time::SystemTime::now();

    let Ok(entries) = fs::read_dir(dir) else {
        return;
    };

    for entry in entries.flatten() {
        let path = entry.path();
        if path.extension().and_then(|e| e.to_str()) != Some("json") {
            continue;
        }
        let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else {
            continue;
        };
        let Ok(pid) = stem.parse::<u32>() else {
            continue;
        };

        if pid_alive(pid) {
            continue;
        }

        let Ok(metadata) = entry.metadata() else {
            continue;
        };
        let Ok(modified) = metadata.modified() else {
            continue;
        };
        let Ok(age) = now.duration_since(modified) else {
            continue;
        };

        if age > MAX_AGE {
            crate::logger::log(
                "DEBUG",
                &format!(
                    "cleaning stale session file: {} (PID {pid})",
                    path.display()
                ),
            );
            let _ = fs::remove_file(&path);
        }
    }
}

fn pid_alive(pid: u32) -> bool {
    unsafe { libc::kill(pid as libc::pid_t, 0) == 0 }
}

/// Whether a discovered session is running right now.
///
/// `scan_sessions` keeps a session whose process has exited, because the
/// dashboard shows it as Finished for a while. Anything that has to mean
/// "alive", like renewing the session's leases (#569), must ask this instead.
/// A Claude Code session is alive while its pid is. A Codex session has no
/// pid of its own (one app-server serves them all), so discovery's recency
/// window is the only signal, and it's alive unless already marked Finished.
pub fn session_running(session: &ClaudeSession) -> bool {
    if session.is_claude_code() {
        session.pid != 0 && pid_alive(session.pid)
    } else {
        session.status != crate::session::SessionStatus::Finished
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn raw_session(pid: u32) -> ClaudeSession {
        ClaudeSession::from_raw(RawSession {
            pid,
            session_id: "s".into(),
            cwd: "/tmp".into(),
            started_at: 0,
        })
    }

    #[test]
    fn a_session_whose_process_exists_is_running() {
        assert!(session_running(&raw_session(std::process::id())));
    }

    /// Discovery keeps a session whose process exited; "discovered" must not
    /// be read as "running" (#569).
    #[test]
    fn a_session_whose_process_is_gone_is_not_running() {
        // Spawn and reap a process, so its pid is certainly not ours or live.
        let mut child = std::process::Command::new("true").spawn().unwrap();
        let pid = child.id();
        child.wait().unwrap();
        assert!(!session_running(&raw_session(pid)));
        assert!(!session_running(&raw_session(0)));
    }

    #[test]
    fn a_session_without_a_pid_of_its_own_runs_until_finished() {
        let mut s = raw_session(0);
        s.agent_family = crate::agent::vocab::CODEX.to_string();
        assert!(session_running(&s));
        s.status = crate::session::SessionStatus::Finished;
        assert!(!session_running(&s));
    }

    #[test]
    fn slug_basic_path() {
        assert_eq!(cwd_to_slug("/Users/foo/bar"), "-Users-foo-bar");
    }

    #[test]
    fn slug_trailing_slash() {
        // Must strip trailing slash — otherwise slug ends with "-" and won't match disk
        assert_eq!(
            cwd_to_slug("/Users/foo/bar/"),
            "-Users-foo-bar",
            "trailing slash must be stripped before slugifying"
        );
    }

    #[test]
    fn slug_multiple_trailing_slashes() {
        assert_eq!(cwd_to_slug("/Users/foo/bar///"), "-Users-foo-bar");
    }

    #[test]
    fn slug_with_hyphens_in_name() {
        assert_eq!(
            cwd_to_slug("/Users/dev/data-platform-answers"),
            "-Users-dev-data-platform-answers"
        );
    }

    #[test]
    fn slug_root() {
        assert_eq!(cwd_to_slug("/"), "-");
    }

    #[test]
    fn slug_single_component() {
        assert_eq!(cwd_to_slug("/tmp"), "-tmp");
    }

    // The cases below come from paths that actually occur on a developer
    // machine. Every case above happens to contain none of the affected
    // characters, which is why mapping only `/` passed them.

    /// A worktree path: `.claude` becomes `--claude`, because the `/` before
    /// it and the `.` in it both map to `-`. Every worktree this project's
    /// own workflow creates has this shape.
    #[test]
    fn slug_dot_directory_in_a_worktree_path() {
        assert_eq!(
            cwd_to_slug("/Users/barada/Sandbox/Mason/lamina/.claude/worktrees/fix-3180"),
            "-Users-barada-Sandbox-Mason-lamina--claude-worktrees-fix-3180"
        );
    }

    /// An underscore in a project name.
    #[test]
    fn slug_underscore_becomes_hyphen() {
        assert_eq!(
            cwd_to_slug("/Users/barada/Sandbox/Mason/clm_toolkit"),
            "-Users-barada-Sandbox-Mason-clm-toolkit"
        );
    }

    /// A `+` in a branch-named worktree.
    #[test]
    fn slug_plus_becomes_hyphen() {
        assert_eq!(
            cwd_to_slug(
                "/Users/barada/Sandbox/Mason/claudectl/.claude/worktrees/feat+jev-classification"
            ),
            "-Users-barada-Sandbox-Mason-claudectl--claude-worktrees-feat-jev-classification"
        );
    }

    /// All four separators at once, with an existing `-` left alone.
    #[test]
    fn slug_maps_every_separator() {
        assert_eq!(
            cwd_to_slug("/a.b/c_d/e+f/g-h"),
            "-a-b-c-d-e-f-g-h",
            "'.', '_' and '+' map to '-' alongside '/'; an existing '-' is unchanged"
        );
    }
}