kayro-cli 0.2.0

Create, build, and run Kayro desktop apps for humans and agents
Documentation
use crate::{
    args::BuildArgs,
    cargo_command, cargo_progress,
    error::CliError,
    output::Reporter,
    packaging,
    process::{Cancellation, CommandSpec, run_cargo_build, run_cargo_command, run_command},
    project::Project,
    target::resolve_target,
};

pub fn run(
    project: &Project,
    arguments: &BuildArgs,
    reporter: &Reporter,
    cancellation: &Cancellation,
    dry_run: bool,
) -> Result<(), CliError> {
    let profile = arguments.profile();
    if profile.trim().is_empty() {
        return Err(CliError::InvalidConfig {
            field: "profile",
            message: "profile names cannot be empty".to_owned(),
        });
    }
    let target = if arguments.frontend_only {
        None
    } else {
        resolve_target(arguments.target.as_deref(), arguments.arch)?
    };
    let target_dir = arguments.target_dir.as_ref().map(|path| {
        if path.is_absolute() {
            path.clone()
        } else {
            project.root.join(path)
        }
    });
    if !arguments.frontend_only {
        packaging::validate(project, arguments, target.as_deref())?;
    }

    let host_packages = if !dry_run && !arguments.skip_types && !arguments.native_only {
        cargo_progress::estimate(project, &arguments.cargo, None)
    } else {
        None
    };
    if !arguments.skip_types && !arguments.native_only {
        run_cargo_command(
            cargo_command::type_generation(project, &arguments.cargo),
            reporter,
            cancellation,
            dry_run,
            host_packages,
        )?;
    }

    if !arguments.native_only {
        run_command(frontend_command(project), reporter, cancellation, dry_run)?;
    }

    if arguments.frontend_only {
        return Ok(());
    }

    let command = cargo_command::native_build(
        project,
        &arguments.cargo,
        profile,
        target.as_deref(),
        target_dir.as_deref(),
    );
    let native_packages = if dry_run {
        None
    } else if target.is_none() {
        host_packages.or_else(|| cargo_progress::estimate(project, &arguments.cargo, None))
    } else {
        cargo_progress::estimate(project, &arguments.cargo, target.as_deref())
    };
    let artifacts = run_cargo_build(command, reporter, cancellation, dry_run, native_packages)?;
    if dry_run {
        packaging::plan(project, arguments, target.as_deref(), reporter)?;
        return Ok(());
    }
    if !dry_run && artifacts.is_empty() {
        return Err(CliError::NoExecutableArtifact);
    }
    for artifact in &artifacts {
        reporter.artifact(artifact, target.as_deref(), profile);
    }
    packaging::run(
        project,
        arguments,
        &artifacts,
        target.as_deref(),
        profile,
        reporter,
        cancellation,
    )?;
    Ok(())
}

fn frontend_command(project: &Project) -> CommandSpec {
    let mut command =
        CommandSpec::from_argv("web", project.frontend_dir.clone(), &project.build_command);
    command.env("KAYRO_CONFIG", &project.config_path);
    command
}