kayro-cli 0.1.0

Create, build, and run Kayro desktop apps for humans and agents
Documentation
use std::{env, ffi::OsString, path::Path};

use crate::{args::CargoOptions, process::CommandSpec, project::Project};

pub fn type_generation(project: &Project, options: &CargoOptions) -> CommandSpec {
    let mut command = base("types", project);
    command
        .arg("run")
        .arg("--manifest-path")
        .arg(&project.native_manifest)
        .arg("--quiet")
        .arg("--message-format=json-render-diagnostics");
    add_options(&mut command, options);
    command
        .env("KAYRO_TYPES_ONLY", "1")
        .env("KAYRO_CONFIG", &project.config_path);
    command
}

pub fn native_dev(project: &Project, options: &CargoOptions, dev_url: &str) -> CommandSpec {
    let mut command = base("native", project);
    command
        .arg("run")
        .arg("--manifest-path")
        .arg(&project.native_manifest)
        .arg("--message-format=json-render-diagnostics");
    add_options(&mut command, options);
    command
        .env("KAYRO_DEV_URL", dev_url)
        .env("KAYRO_CONFIG", &project.config_path);
    command
}

pub fn native_build(
    project: &Project,
    options: &CargoOptions,
    profile: &str,
    target: Option<&str>,
    target_dir: Option<&Path>,
) -> CommandSpec {
    let mut command = base("native", project);
    command
        .arg("build")
        .arg("--manifest-path")
        .arg(&project.native_manifest)
        .arg("--profile")
        .arg(profile)
        .arg("--message-format=json-render-diagnostics");
    if let Some(target) = target {
        command.arg("--target").arg(target);
    }
    if let Some(target_dir) = target_dir {
        command.arg("--target-dir").arg(target_dir);
    }
    add_options(&mut command, options);
    command.env("KAYRO_CONFIG", &project.config_path);
    command
}

fn base(phase: &str, project: &Project) -> CommandSpec {
    CommandSpec::new(
        phase,
        env::var_os("CARGO").unwrap_or_else(|| OsString::from("cargo")),
        project.root.clone(),
    )
}

fn add_options(command: &mut CommandSpec, options: &CargoOptions) {
    if !options.unlocked {
        command.arg("--locked");
    }
    if options.offline {
        command.arg("--offline");
    }
    if options.no_default_features {
        command.arg("--no-default-features");
    }
    if !options.features.is_empty() {
        command.arg("--features").arg(options.features.join(","));
    }
    if let Some(jobs) = options.jobs {
        command.arg("--jobs").arg(jobs.to_string());
    }
    if let Some(binary) = &options.bin {
        command.arg("--bin").arg(binary);
    }
    for argument in &options.cargo_arg {
        command.arg(argument);
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use url::Url;

    use super::*;
    use crate::project::BundleSettings;

    fn project() -> Project {
        Project {
            root: PathBuf::from("/tmp/app"),
            config_path: PathBuf::from("/tmp/app/kayro.toml"),
            app_name: "Test App".to_owned(),
            identifier: "dev.test.app".to_owned(),
            frontend_dir: PathBuf::from("/tmp/app"),
            native_manifest: PathBuf::from("/tmp/app/src-kayro/Cargo.toml"),
            dev_command: vec!["bun".into(), "run".into(), "dev:web".into()],
            build_command: vec!["bun".into(), "run".into(), "build:web".into()],
            dev_url: Url::parse("http://127.0.0.1:5173").unwrap(),
            bundle: BundleSettings {
                active: true,
                version: None,
                publisher: None,
                description: None,
                copyright: None,
                icons: Vec::new(),
                resources: Vec::new(),
                macos_minimum_system_version: "13.0".to_owned(),
            },
        }
    }

    fn options() -> CargoOptions {
        CargoOptions {
            features: vec!["custom".into()],
            no_default_features: true,
            unlocked: false,
            offline: true,
            jobs: Some(4),
            bin: Some("desktop".into()),
            cargo_arg: vec!["--timings".into()],
        }
    }

    #[test]
    fn native_build_forwards_reproducibility_and_target_flags() {
        let command = native_build(
            &project(),
            &options(),
            "release",
            Some("aarch64-apple-darwin"),
            Some(Path::new("/tmp/target")),
        );
        let display = command.display();

        assert!(display.contains("--target aarch64-apple-darwin"));
        assert!(display.contains("--locked"));
        assert!(display.contains("--offline"));
        assert!(display.contains("--features custom"));
        assert!(display.contains("--message-format=json-render-diagnostics"));
    }

    #[test]
    fn cargo_run_phases_request_machine_readable_build_messages() {
        let project = project();
        let options = options();

        assert!(
            type_generation(&project, &options)
                .display()
                .contains("--message-format=json-render-diagnostics")
        );
        assert!(
            native_dev(&project, &options, "http://127.0.0.1:5173")
                .display()
                .contains("--message-format=json-render-diagnostics")
        );
    }
}