run_stack/

cli.rs

//! run-stack: one command to boot a full local stack in Docker.
//!
//! A port of the shell version in ../run. Commands that are not ported yet say
//! so and name the one to use instead, rather than failing as unknown.

use anyhow::Result;
use clap::{Parser, Subcommand};

use crate::compose::Compose;
use crate::generate;
use crate::env::Env;
use crate::workspace::Workspace;

#[derive(Parser)]
#[command(
    name = "run-stack",
    // Anything not defined below is handed to the shell implementation, so the
    // port never takes a command away.
    allow_external_subcommands = true,
    // Says which implementation answered: both are called rst, and which one
    // wins depends on PATH order.
    version = concat!(env!("CARGO_PKG_VERSION"), " (rust)"),
    about = "Dockerised local stacks: API, web apps, mobile, database, dashboard"
)]
struct Cli {
    #[command(subcommand)]
    command: Option<Command>,
}

#[derive(Subcommand)]
enum Command {
    /// Build if needed and start the stack
    #[command(visible_alias = "run")]
    Up {
        /// Only these services
        services: Vec<String>,
        /// Rebuild images first
        #[arg(long)]
        build: bool,
        /// Only the services listed under config `essential`
        #[arg(long)]
        essential: bool,
    },
    /// Stop everything, keep data
    Down { services: Vec<String> },
    /// Service status
    #[command(visible_alias = "status")]
    Ps { services: Vec<String> },
    /// Follow logs
    Logs { services: Vec<String> },
    /// Stop then start
    Restart {
        services: Vec<String>,
        #[arg(long)]
        build: bool,
        /// Only the services listed under config `essential`
        #[arg(long)]
        essential: bool,
    },
    /// Open a shell in a container
    #[command(visible_alias = "sh")]
    Shell {
        #[arg(default_value = "backend")]
        service: String,
    },
    /// List the apps this workspace runs
    #[command(visible_alias = "list")]
    Apps,
    /// Host ports and the URLs that must match them
    Ports,
    /// Print the resolved configuration
    Config,
    /// Print the docker compose command instead of running it
    Explain { command: Vec<String> },
    /// Print the environment compose is given: one key, or all of it
    Env { key: Option<String> },
    /// What is ported so far, and what is not
    Ported,
    /// List every CLI command in a table
    Commands {
        /// One canonical command name per line
        #[arg(long)]
        raw: bool,
    },
    /// Install the latest run-stack from crates.io and migrate configs
    #[command(visible_alias = "selfupdate")]
    SelfUpdate {
        /// Pass --verbose to cargo
        #[arg(long, short = 'V')]
        verbose: bool,
    },
    /// Anything the shell implementation still owns
    #[command(external_subcommand)]
    Delegated(Vec<String>),
    /// Write the generated compose overlays without starting anything
    Generate,
}

#[allow(dead_code)]
const UNUSED_NOT_PORTED: &[(&str, &str)] = &[
    ("init", "the prompts and the app scan"),
    ("create", "workspace setup"),
    ("migrate", "layout conversion"),
    ("clean", "volume deletion"),
    ("rebuild", "image rebuild"),
    ("dash", "dashboard"),
    ("ios", "simulator launch"),
    ("android", "emulator launch"),
    ("device", "device launch"),
    ("mobile", "metro restart"),
    ("reload", "metro reload"),
    ("prebuild", "expo prebuild"),
    ("desktop", "electron / tauri shell"),
    ("deploy", "deploy targets"),
    ("backend", "commands in the API container"),
    ("artisan", "laravel"),
    ("composer", "laravel"),
    ("pnpm", "workspace package manager"),
    ("seed", "database seeders"),
    ("fresh", "schema rebuild"),
    ("services", "compose service table"),
    ("completion", "shell completion"),
];

pub fn main() {
    let code = match run() {
        Ok(code) => code,
        Err(error) => {
            eprintln!("error: {error:#}");
            1
        }
    };
    std::process::exit(code);
}

fn run() -> Result<i32> {
    let cli = Cli::parse();
    let Some(command) = cli.command else {
        print_status();
        return Ok(0);
    };

    if let Command::Ported = command {
        print_status();
        return Ok(0);
    }

    if let Command::Commands { raw } = command {
        return crate::commands::run(raw);
    }

    if let Command::SelfUpdate { verbose } = command {
        return crate::self_update::run(verbose);
    }

    // The shell version needs to know which workspace, but must be allowed to
    // run outside one: `create` makes the workspace in the first place.
    if let Command::Delegated(argv) = &command {
        let (name, rest) = argv.split_first().expect("clap yields a name");
        let workspace = Workspace::find(&std::env::current_dir()?).ok();
        return crate::delegate::run(name, rest, workspace.as_ref());
    }

    let workspace = Workspace::find(&std::env::current_dir()?)?;

    match command {
        Command::Ported
        | Command::Commands { .. }
        | Command::Delegated(_)
        | Command::SelfUpdate { .. } => unreachable!("handled above"),
        Command::Config => {
            print!("{}", workspace.config()?.to_json());
            Ok(0)
        }
        Command::Apps => {
            print_apps(&workspace)?;
            Ok(0)
        }
        Command::Ports => {
            let config = workspace.config()?;
            for key in config.keys().filter(|key| key.ends_with("_PORT")) {
                println!("{:<24} {}", key, config.port(key, 0));
            }
            Ok(0)
        }
        Command::Generate => {
            regenerate(&workspace)?;
            println!("wrote the overlays in {}", workspace.run_dir.display());
            Ok(0)
        }
        Command::Env { key } => {
            let mut env = Env::load(&workspace.env_path())?;
            env.derive(&workspace.root);
            match key {
                Some(key) => println!("{}", env.get(&key).unwrap_or("")),
                None => {
                    for (key, value) in env.iter() {
                        println!("{key}={value}");
                    }
                }
            }
            Ok(0)
        }
        Command::Explain { command } => {
            let compose = compose_for(&workspace)?;
            println!("docker {}", compose.args(&command).join(" "));
            Ok(0)
        }
        Command::Up {
            services,
            build,
            essential,
        } => {
            crate::compose::require_docker()?;
            regenerate(&workspace)?;
            let services = resolve_services(&workspace, services, essential)?;
            let mut args = vec!["up".to_string(), "-d".to_string()];
            if build {
                args.push("--build".into());
            }
            if services.is_empty() {
                args.push("--remove-orphans".into());
            }
            args.extend(services);
            compose_for(&workspace)?.run(&args)
        }
        Command::Down { services } => {
            crate::compose::require_docker()?;
            let mut args = vec!["down".to_string()];
            args.extend(services);
            compose_for(&workspace)?.run(&args)
        }
        Command::Ps { services } => {
            crate::compose::require_docker()?;
            let mut args = vec!["ps".to_string()];
            args.extend(services);
            compose_for(&workspace)?.run(&args)
        }
        Command::Logs { services } => {
            crate::compose::require_docker()?;
            let mut args = vec![
                "logs".to_string(),
                "-f".to_string(),
                "--tail=100".to_string(),
            ];
            args.extend(services);
            compose_for(&workspace)?.run(&args)
        }
        Command::Restart {
            services,
            build,
            essential,
        } => {
            crate::compose::require_docker()?;
            regenerate(&workspace)?;
            let services = resolve_services(&workspace, services, essential)?;
            let compose = compose_for(&workspace)?;
            let mut down = vec!["down".to_string()];
            down.extend(services.clone());
            compose.run(&down)?;
            let mut up = vec!["up".to_string(), "-d".to_string()];
            if build {
                up.push("--build".into());
            }
            up.extend(services);
            compose.run(&up)
        }
        Command::Shell { service } => {
            crate::compose::require_docker()?;
            let compose = compose_for(&workspace)?;
            let bash = vec!["exec".to_string(), service.clone(), "bash".to_string()];
            match compose.run(&bash)? {
                0 => Ok(0),
                // Plenty of images have no bash.
                _ => compose.run(&["exec".to_string(), service, "sh".to_string()]),
            }
        }
    }
}

/// The overlays depend on what the workspace holds right now, so they are
/// written before every start rather than committed.
fn regenerate(workspace: &Workspace) -> Result<()> {
    let mut env = Env::load(&workspace.env_path())?;
    env.derive(&workspace.root);
    generate::all(&workspace.run_dir, &env, &crate::compose::package_dir()?)
}

fn compose_for(workspace: &Workspace) -> Result<Compose> {
    let mut env = Env::load(&workspace.env_path())?;
    env.derive(&workspace.root);
    Compose::new(workspace, env)
}

fn resolve_services(
    workspace: &Workspace,
    services: Vec<String>,
    essential: bool,
) -> Result<Vec<String>> {
    if !essential {
        return Ok(services);
    }
    if !services.is_empty() {
        anyhow::bail!("pass service names or --essential, not both");
    }
    let listed = workspace.config()?.essential_services();
    if listed.is_empty() {
        anyhow::bail!(
            "no essential services configured — add them under \"essential\" in run.config.json"
        );
    }
    Ok(listed)
}

fn print_apps(workspace: &Workspace) -> Result<()> {
    let config = workspace.config()?;
    println!("{:<10} {:<24} {:<6}", "ROLE", "PACKAGE", "PORT");
    println!(
        "{:<10} {:<24} {:<6}",
        "backend",
        config.str_or("BACKEND_STACK", "laravel"),
        config.port("BACKEND_PORT", 8000)
    );
    println!(
        "{:<10} {:<24} {:<6}",
        "web",
        config.str_or("WEB_APP", "web"),
        config.port("WEB_PORT", 5173)
    );
    for (flag, app_key, port_key, role, default_port) in [
        ("RUN_ADMIN", "ADMIN_APP", "ADMIN_PORT", "admin", 5174),
        ("RUN_LANDING", "LANDING_APP", "LANDING_PORT", "landing", 5175),
        ("RUN_MOBILE", "MOBILE_APP", "MOBILE_CLIENT_PORT", "mobile", 8081),
        ("RUN_DESKTOP", "DESKTOP_APP", "DESKTOP_PORT", "desktop", 5176),
    ] {
        if config.bool_or(flag, false) {
            println!(
                "{:<10} {:<24} {:<6}",
                role,
                config.str_or(app_key, role),
                config.port(port_key, default_port)
            );
        }
    }
    for app in config.extra_apps() {
        let port_key = format!("{}_PORT", crate::config::key_of(&app));
        println!("{:<10} {:<24} {:<6}", "extra", app, config.port(&port_key, 0));
    }
    Ok(())
}

fn print_status() {
    println!("run-stack {} (rust port in progress)\n", env!("CARGO_PKG_VERSION"));
    println!("Ported:");
    for line in [
        "up [--build] [--essential] [svc...]  start the stack",
        "down [service...]           stop it, keep data",
        "ps / status [service...]    service status",
        "logs [service...]           follow logs",
        "restart [--build] [--essential] [svc...]  down then up",
        "shell / sh [service]        shell into a container",
        "apps / list                 the apps this workspace runs",
        "ports                       host ports",
        "config                      the resolved configuration",
        "explain <compose args>      print the docker command, run nothing",
        "env [KEY]                   the environment compose is given",
        "generate                    write the compose overlays, start nothing",
        "commands [--raw]            every CLI command in a table",
        "self-update [--verbose]     install latest from crates.io, migrate configs",
    ] {
        println!("  {line}");
    }
    println!("\nHanded to the shell implementation, transparently:");
    let mut line = String::from("  ");
    for (name, _) in crate::delegate::PENDING {
        if line.len() + name.len() + 2 > 76 {
            println!("{line}");
            line = String::from("  ");
        }
        line.push_str(name);
        line.push_str(", ");
    }
    println!("{}", line.trim_end_matches(", "));
}