render-session 0.1.0

use clap::{Parser, Subcommand};

#[derive(Debug, Parser)]
#[command(
    name = "render-session",
    about = "render-session: MCP server + HTTP viewer for AI session output",
    version
)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Debug, Subcommand)]
enum Commands {
    /// Run the MCP stdio server (default entry point from .mcp.json).
    /// Delegates to the render-session-mcp binary found next to this executable.
    Mcp,

    /// Start the HTTP viewer server
    Serve {
        /// Port to listen on
        #[arg(long, default_value = "8000")]
        port: u16,

        /// Project directory to serve content from
        #[arg(long)]
        dir: String,

        /// Phase 4 (c): viewer-internal watcher tick (seconds). When set, the viewer
        /// runs `auto_capture_once` every <tick> seconds in the background. None
        /// disables the watcher (Phase 1+ default behavior preserved).
        #[arg(long)]
        watch_tick: Option<u64>,
    },

    /// Generate list.json and render-lanes.md from config
    Gen {
        /// Project directory containing .render-session.yaml
        #[arg(long)]
        project: String,
    },

    /// Write a report from stdin
    Report {
        /// Directory to write the report into
        #[arg(long)]
        dir: String,

        /// Report title
        #[arg(long)]
        title: String,
    },

    /// Capture session jsonl from Claude Code projects and emit to render-site/.
    Capture {
        /// Project directory (where render-site/ lives)
        #[arg(long)]
        project: std::path::PathBuf,

        /// Capture mode: session | recent | both (default: both)
        #[arg(long, default_value = "both")]
        mode: String,

        /// Claude Code project slug (default: derived from project path via canonicalize + replace('/', "-"))
        #[arg(long)]
        slug: Option<String>,

        /// Recent mode: number of turns to emit (default: 5)
        #[arg(long, default_value_t = 5)]
        n: usize,

        /// Recent mode: include turns without visual artifact (default: false)
        #[arg(long, default_value_t = false)]
        all: bool,
    },
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt::Subscriber::builder()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
        .init();
    let cli = Cli::parse();
    match cli.command {
        Commands::Mcp => {
            // B-plan: delegate to render-session-mcp binary.
            // Prefer the sibling binary in the same install directory; fall back to PATH.
            let exe_dir = std::env::current_exe()
                .ok()
                .and_then(|p| p.parent().map(|d| d.to_path_buf()));
            let mcp_path = exe_dir
                .map(|d| d.join("render-session-mcp"))
                .filter(|p| p.exists())
                .unwrap_or_else(|| std::path::PathBuf::from("render-session-mcp"));

            let status = tokio::process::Command::new(&mcp_path)
                .stdin(std::process::Stdio::inherit())
                .stdout(std::process::Stdio::inherit())
                .stderr(std::process::Stdio::inherit())
                .status()
                .await
                .map_err(|e| {
                    tracing::error!(
                        error = %e,
                        path = %mcp_path.display(),
                        "failed to spawn render-session-mcp"
                    );
                    e
                })?;

            if !status.success() {
                let code = status.code().unwrap_or(-1);
                tracing::error!(exit_code = code, "render-session-mcp exited non-zero");
                anyhow::bail!("render-session-mcp exited with {}", status);
            }
        }
        Commands::Serve {
            port,
            dir,
            watch_tick,
        } => {
            // Spawn the parent-death watch loop so that if the MCP server (our parent)
            // dies, this serve process self-exits within ~5 seconds.
            tokio::spawn(render_session_core::child::watch_parent_death());
            let watch_tick_dur = watch_tick.map(|t| {
                let clamped = if t == 0 {
                    tracing::warn!("watch_tick=0 not allowed, clamping to 1");
                    1
                } else {
                    t
                };
                std::time::Duration::from_secs(clamped)
            });
            render_session_core::serve::run(port, std::path::PathBuf::from(dir), watch_tick_dur)
                .await?;
        }
        Commands::Gen { project } => {
            let project_path = std::path::PathBuf::from(&project);

            let mut layers: Vec<render_session_core::config::Config> = Vec::new();
            if let Some(c) = render_session_core::config::load_user_global().map_err(|e| {
                tracing::error!(
                    error = %e,
                    project = %project,
                    layer = "user-global",
                    "config load failed"
                );
                e
            })? {
                layers.push(c);
            }
            if let Some(c) =
                render_session_core::config::load_project(&project_path).map_err(|e| {
                    tracing::error!(
                        error = %e,
                        project = %project,
                        layer = "project",
                        "config load failed"
                    );
                    e
                })?
            {
                layers.push(c);
            }
            if let Some(c) = render_session_core::config::load_lane(&project_path).map_err(|e| {
                tracing::error!(
                    error = %e,
                    project = %project,
                    layer = "lane",
                    "config load failed"
                );
                e
            })? {
                layers.push(c);
            }

            let merged = render_session_core::config::merge(layers);

            let list_path = render_session_core::gen::emit_list_json(&merged, &project_path)
                .map_err(|e| {
                    tracing::error!(error = %e, project = %project, "emit_list_json failed");
                    e
                })?;
            tracing::info!(file = %list_path.display(), "list.json emitted");
            println!("{}", list_path.display());

            let rules_path = render_session_core::gen::emit_rules_md(&merged, &project_path)
                .map_err(|e| {
                    tracing::error!(error = %e, project = %project, "emit_rules_md failed");
                    e
                })?;
            tracing::info!(file = %rules_path.display(), "render-lanes.md emitted");
            println!("{}", rules_path.display());
        }
        Commands::Report { dir, title } => {
            use tokio::io::AsyncReadExt as _;
            let mut body = String::new();
            tokio::io::stdin()
                .read_to_string(&mut body)
                .await
                .map_err(|e| {
                    tracing::error!(error = %e, "failed to read stdin for report");
                    e
                })?;
            let path = render_session_core::writer::write_report(
                std::path::Path::new(&dir),
                &title,
                &body,
            )
            .await
            .map_err(|e| {
                tracing::error!(error = %e, dir = %dir, title = %title, "write_report failed");
                e
            })?;
            println!("{}", path.display());
        }
        Commands::Capture {
            project,
            mode,
            slug,
            n,
            all,
        } => {
            let claude_slug = match slug {
                Some(s) => s,
                None => derive_slug(&project).map_err(|e| {
                    tracing::error!(project = %project.display(), error = %e, "derive_slug failed");
                    e
                })?,
            };
            let only_with_visual = !all;

            // Phase 4 (b): load project config, extract recent.filter if present.
            // yaml absent → Ok(None) → legacy path. yaml parse error → warn + legacy path.
            let project_config = match render_session_core::config::load_project(&project) {
                Ok(Some(cfg)) => Some(cfg),
                Ok(None) => None,
                Err(e) => {
                    tracing::warn!(
                        project = %project.display(),
                        error = %e,
                        "yaml parse failed, falling back to legacy path"
                    );
                    None
                }
            };
            let merged = match project_config {
                Some(cfg) => render_session_core::config::merge(vec![cfg]),
                None => render_session_core::config::Config::default(),
            };
            let filter_chain_cfg = merged
                .categories
                .get("recent")
                .and_then(|c| c.filter.as_ref());
            let filter_registry: Option<render_session_core::filters::FilterRegistry> =
                filter_chain_cfg
                    .map(|_| render_session_core::filters::FilterRegistry::with_builtins());
            let filter_arg = match (filter_registry.as_ref(), filter_chain_cfg) {
                (Some(reg), Some(cfg)) => Some((reg, cfg)),
                _ => None,
            };

            match mode.as_str() {
                "session" => {
                    // session mode: filter not applied (single-item capture).
                    if let Some(p) = render_session_core::sources::session::capture_session(
                        &project,
                        &claude_slug,
                    )
                    .map_err(|e| {
                        tracing::error!(error = %e, "capture_session failed");
                        e
                    })? {
                        println!("{}", p.display());
                    }
                }
                "recent" => {
                    for p in render_session_core::sources::session::capture_recent(
                        &project,
                        &claude_slug,
                        n,
                        only_with_visual,
                        filter_arg,
                    )
                    .map_err(|e| {
                        tracing::error!(error = %e, "capture_recent failed");
                        e
                    })? {
                        println!("{}", p.display());
                    }
                }
                "both" => {
                    // session: filter not applied
                    if let Some(p) = render_session_core::sources::session::capture_session(
                        &project,
                        &claude_slug,
                    )
                    .map_err(|e| {
                        tracing::error!(error = %e, "capture_session failed");
                        e
                    })? {
                        println!("{}", p.display());
                    }
                    // recent: filter applied if configured
                    for p in render_session_core::sources::session::capture_recent(
                        &project,
                        &claude_slug,
                        n,
                        only_with_visual,
                        filter_arg,
                    )
                    .map_err(|e| {
                        tracing::error!(error = %e, "capture_recent failed");
                        e
                    })? {
                        println!("{}", p.display());
                    }
                }
                other => {
                    anyhow::bail!("invalid mode {:?}, expected session|recent|both", other);
                }
            }
        }
    }
    Ok(())
}

/// Derive the Claude Code project slug from a project directory path.
///
/// Canonicalizes the path and replaces every `/` with `-`, matching legacy
/// `render-session.py:41`.  Intended for macOS/Linux only; Windows path
/// separator handling is deferred to Phase 6+.
fn derive_slug(project: &std::path::Path) -> anyhow::Result<String> {
    let canonical = project.canonicalize().map_err(|e| {
        tracing::error!(project = %project.display(), error = %e, "canonicalize failed");
        e
    })?;
    Ok(canonical.to_string_lossy().replace('/', "-"))
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    /// Verify that spawning a short-lived process and awaiting its status works correctly.
    ///
    /// We spawn `true` (exits 0) and verify status.success() == true.
    /// We also verify that dropping the Future before poll does NOT kill the child
    /// (kill_on_drop defaults to false for tokio::process::Command).
    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
    async fn test_mcp_commands_status_await() {
        // Spawn a process that exits immediately with success.
        // Use `/bin/true` on Unix (always exits 0).
        let true_bin = if cfg!(target_os = "macos") || cfg!(target_os = "linux") {
            "true"
        } else {
            "cmd"
        };

        let status = tokio::process::Command::new(true_bin)
            .stdin(std::process::Stdio::null())
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null())
            .status()
            .await
            .expect("spawn `true`");

        assert!(status.success(), "`true` must exit with success");

        // Now verify kill_on_drop=false behaviour: spawn a long-running process,
        // drop the Child handle before it exits, then verify the process is still alive.
        let child = tokio::process::Command::new("sleep")
            .arg("30")
            .stdin(std::process::Stdio::null())
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null())
            .kill_on_drop(false)
            .spawn()
            .expect("spawn `sleep 30`");

        let pid = child.id().expect("child has pid") as libc::pid_t;

        // Drop the Child handle — with kill_on_drop=false the process keeps running.
        drop(child);

        // Give the OS a moment to process.
        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;

        // kill(pid, 0) == 0 means process exists.
        #[allow(unsafe_code)]
        let probe = unsafe { libc::kill(pid, 0) };
        assert_eq!(
            probe, 0,
            "child should still be alive after handle drop (kill_on_drop=false)"
        );

        // Clean up.
        #[allow(unsafe_code)]
        unsafe {
            libc::kill(pid, libc::SIGTERM);
        }
    }
}