zinit_client/cli/

commands.rs

//! CLI command implementations

use crate::cli::args::{Args, Command, ServerAction};
use crate::client::ZinitClient;
use anyhow::{Context, Result};
use colored::Colorize;
use std::process::Command as ProcessCommand;

/// Run a CLI command
pub async fn run_command(args: &Args) -> Result<()> {
    // Handle -i (stdin) flag
    if args.stdin {
        return run_stdin().await;
    }

    // Handle -c (inline script) flag
    if let Some(script) = &args.inline_script {
        return run_inline(script).await;
    }

    match &args.command {
        Some(Command::Server { action }) => run_server_command(action).await,
        Some(Command::List) => run_list().await,
        Some(Command::Status { name }) => run_status(name).await,
        Some(Command::Start { name }) => run_start(name).await,
        Some(Command::Stop { name }) => run_stop(name).await,
        Some(Command::Restart { name }) => run_restart(name).await,
        Some(Command::Delete { name }) => run_delete(name).await,
        Some(Command::Kill { name, signal }) => run_kill(name, signal).await,
        Some(Command::Stats { name }) => run_stats(name).await,
        Some(Command::Logs {
            service,
            follow: _,
            lines,
        }) => run_logs(service.as_deref(), *lines).await,
        Some(Command::Repl) => run_repl().await,
        Some(Command::Tui) => run_tui().await,
        Some(Command::Ping) => run_ping().await,
        None => {
            if let Some(script) = &args.script {
                run_script(script).await
            } else {
                println!("Use --help for usage information");
                Ok(())
            }
        }
    }
}

fn get_client() -> Result<ZinitClient> {
    ZinitClient::try_default()
}

async fn run_server_command(action: &ServerAction) -> Result<()> {
    match action {
        ServerAction::Start { background, port } => {
            let mut cmd = ProcessCommand::new("zinit-server");
            if *background {
                cmd.arg("-bg");
            }
            if let Some(p) = port {
                cmd.arg("--port").arg(p.to_string());
            }

            let status = cmd.status().context("Failed to start zinit-server")?;
            if !status.success() {
                anyhow::bail!("zinit-server exited with error");
            }
            Ok(())
        }
        ServerAction::Stop => {
            let _ = ProcessCommand::new("pkill")
                .args(["-f", "zinit-server"])
                .status();
            println!("Server stopped");
            Ok(())
        }
        ServerAction::Restart => {
            let _ = ProcessCommand::new("pkill")
                .args(["-f", "zinit-server"])
                .status();
            std::thread::sleep(std::time::Duration::from_millis(500));

            let status = ProcessCommand::new("zinit-server")
                .arg("-bg")
                .status()
                .context("Failed to start zinit-server")?;
            if !status.success() {
                anyhow::bail!("zinit-server exited with error");
            }
            println!("Server restarted");
            Ok(())
        }
    }
}

async fn run_list() -> Result<()> {
    let client = get_client()?;
    let services = client.list().await?;

    if services.is_empty() {
        println!("No services registered");
        return Ok(());
    }

    println!("{}", "Services:".bold());
    for name in &services {
        match client.status(name).await {
            Ok(status) => {
                // Check if service was intentionally stopped:
                // - Exit code 143 = killed by SIGTERM (128+15)
                // - Exit code 137 = killed by SIGKILL (128+9)
                // - Signaled with SIGTERM
                // These are typically xinit-managed services that go to sleep when idle
                let is_sleeping = status.state.contains("143")
                    || status.state.contains("137")
                    || status.state.contains("SIGTERM")
                    || status.state.contains("SIGKILL");

                let state_colored = if is_sleeping {
                    "Sleeping".blue()
                } else {
                    match status.state.as_str() {
                        s if s.contains("Running") => status.state.green(),
                        s if s.contains("Success") => status.state.green(),
                        s if s.contains("Blocked") => status.state.yellow(),
                        s if s.contains("Spawned") => status.state.cyan(),
                        _ => status.state.red(),
                    }
                };
                println!("  {} {} (pid: {})", name.bold(), state_colored, status.pid);
            }
            Err(_) => {
                println!("  {} {}", name.bold(), "unknown".dimmed());
            }
        }
    }

    Ok(())
}

async fn run_status(name: &str) -> Result<()> {
    let client = get_client()?;
    let status = client.status(name).await?;

    println!("{}: {}", "Service".bold(), name);
    println!("  {}: {}", "State".bold(), status.state);
    println!("  {}: {}", "Target".bold(), status.target);
    println!("  {}: {}", "PID".bold(), status.pid);

    Ok(())
}

async fn run_start(name: &str) -> Result<()> {
    let client = get_client()?;
    client.start(name).await?;
    println!("Started service: {}", name.green());
    Ok(())
}

async fn run_stop(name: &str) -> Result<()> {
    let client = get_client()?;
    client.stop(name).await?;
    println!("Stopped service: {}", name.yellow());
    Ok(())
}

async fn run_restart(name: &str) -> Result<()> {
    let client = get_client()?;
    client.restart(name).await?;
    println!("Restarted service: {}", name.green());
    Ok(())
}

async fn run_delete(name: &str) -> Result<()> {
    let client = get_client()?;
    client.delete(name).await?;
    println!("Deleted service: {}", name.red());
    Ok(())
}

async fn run_kill(name: &str, signal: &str) -> Result<()> {
    let client = get_client()?;
    client.kill(name, signal).await?;
    println!("Sent {} to service: {}", signal, name);
    Ok(())
}

async fn run_stats(name: &str) -> Result<()> {
    let client = get_client()?;
    let stats = client.stats(name).await?;

    println!("{}: {}", "Service".bold(), name);
    println!("  {}: {}", "PID".bold(), stats.pid);
    println!(
        "  {}: {} MB",
        "Memory".bold(),
        stats.memory_usage / 1024 / 1024
    );
    println!("  {}: {:.1}%", "CPU".bold(), stats.cpu_usage);

    if !stats.children.is_empty() {
        println!("  {}:", "Children".bold());
        for child in &stats.children {
            println!(
                "    PID {}: {} MB, {:.1}% CPU",
                child.pid,
                child.memory_usage / 1024 / 1024,
                child.cpu_usage
            );
        }
    }

    Ok(())
}

async fn run_logs(service: Option<&str>, lines: u32) -> Result<()> {
    let client = get_client()?;

    let logs = if let Some(name) = service {
        client.logs_filter(name).await?
    } else {
        client.logs_tail(lines).await?
    };

    for line in logs {
        println!("{}", line);
    }

    Ok(())
}

async fn run_script(path: &str) -> Result<()> {
    use std::path::Path;

    let script_path = Path::new(path);

    // Check if it's a directory - run all .rhai files in it
    if script_path.is_dir() {
        let mut scripts: Vec<_> = std::fs::read_dir(script_path)?
            .filter_map(|e| e.ok())
            .filter(|e| {
                e.path()
                    .extension()
                    .map(|ext| ext == "rhai")
                    .unwrap_or(false)
            })
            .collect();

        scripts.sort_by_key(|e| e.path());

        if scripts.is_empty() {
            println!("No .rhai scripts found in {}", path);
            return Ok(());
        }

        for entry in scripts {
            let file_path = entry.path();
            println!("{} {}", "Running:".green(), file_path.display());
            match crate::rhai::run_script_file(&file_path) {
                Ok(result) => {
                    if !result.is_unit() {
                        println!("{} {:?}", "=>".green(), result);
                    }
                }
                Err(e) => {
                    println!("{}: {}", "Error".red(), e);
                }
            }
        }
    } else {
        // Single file
        match crate::rhai::run_script_file(script_path) {
            Ok(result) => {
                if !result.is_unit() {
                    println!("{} {:?}", "=>".green(), result);
                }
            }
            Err(e) => {
                println!("{}: {}", "Error".red(), e);
                anyhow::bail!("Script execution failed");
            }
        }
    }

    Ok(())
}

async fn run_stdin() -> Result<()> {
    use std::io::Read;
    let mut script = String::new();
    std::io::stdin()
        .read_to_string(&mut script)
        .context("Failed to read from stdin")?;

    match crate::rhai::run_script(&script) {
        Ok(result) => {
            if !result.is_unit() {
                println!("{} {:?}", "=>".green(), result);
            }
            Ok(())
        }
        Err(e) => {
            println!("{}: {}", "Error".red(), e);
            anyhow::bail!("Script execution failed");
        }
    }
}

async fn run_inline(script: &str) -> Result<()> {
    match crate::rhai::run_script(script) {
        Ok(result) => {
            if !result.is_unit() {
                println!("{} {:?}", "=>".green(), result);
            }
            Ok(())
        }
        Err(e) => {
            println!("{}: {}", "Error".red(), e);
            anyhow::bail!("Script execution failed");
        }
    }
}

async fn run_repl() -> Result<()> {
    let handle = crate::client::ZinitHandle::new()?;
    crate::repl::run_repl(handle)?;
    Ok(())
}

async fn run_tui() -> Result<()> {
    let handle = crate::client::ZinitHandle::new()?;
    crate::tui::run_tui(handle)?;
    Ok(())
}

async fn run_ping() -> Result<()> {
    let client = get_client()?;
    let response = client.ping().await?;
    println!(
        "{}: {} (version {})",
        "Server".bold(),
        response.message.green(),
        response.version
    );
    Ok(())
}