harmont-cli 0.0.8

Command-line client for the Harmont CI platform.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

pub mod init;
pub mod pipelines;
pub mod plugin;
pub mod render;
pub mod run;
pub mod version;

pub use plugin::PluginCommand;
pub use run::RunArgs;

use std::path::PathBuf;

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

use crate::context::RunContext;

#[derive(Debug, Parser)]
#[command(
    name = "hm",
    version,
    about = "hm — CLI for the Harmont CI platform",
    long_about = "hm is the command-line interface for Harmont.\n\n\
                   Run `hm run` to push local code through a pipeline without committing.",
    propagate_version = true,
    arg_required_else_help = true,
    disable_help_subcommand = true
)]
pub struct Cli {
    /// Enable verbose/debug logging.
    #[arg(long, short, global = true)]
    pub verbose: bool,

    /// Disable colored output.
    #[arg(long, global = true)]
    pub no_color: bool,

    /// Write a Chrome trace JSON to the given path for performance analysis.
    #[arg(long, global = true, hide = true, value_name = "PATH")]
    pub debug_trace: Option<std::path::PathBuf>,

    #[command(subcommand)]
    pub command: Command,
}

#[derive(Debug, Clone, Subcommand)]
pub enum Command {
    /// Initialize a .hm/ pipeline from a project template.
    Init(init::InitArgs),

    /// Run a pipeline locally via Docker.
    Run(RunArgs),

    /// Print the pipeline discovery envelope (JSON) for every pipeline in the repo.
    Pipelines(pipelines::PipelinesArgs),

    /// Render one pipeline's v0 IR (JSON) without running it.
    Render(render::RenderArgs),

    /// Show hm version.
    Version,

    /// Manage plugins.
    #[command(subcommand)]
    Plugin(PluginCommand),

    /// Manage harmont Docker image cache.
    #[command(subcommand)]
    Cache(CacheCommand),

    /// Interact with the Harmont cloud API.
    #[command(subcommand)]
    Cloud(hm_plugin_cloud::cli::CloudCommand),
}

#[derive(Debug, Clone, Subcommand)]
pub enum CacheCommand {
    /// Save harmont Docker images to a cache directory.
    Save(CacheSaveArgs),
    /// Restore harmont Docker images from a cache directory.
    Restore(CacheRestoreArgs),
    /// Remove all cached workspaces and Docker images.
    Clean,
}

#[derive(Debug, Clone, clap::Args)]
pub struct CacheSaveArgs {
    /// Directory to save image tars into.
    pub dir: PathBuf,
}

#[derive(Debug, Clone, clap::Args)]
pub struct CacheRestoreArgs {
    /// Directory containing cached image tars.
    pub dir: PathBuf,
}

/// Dispatch a parsed CLI command to the appropriate handler. Returns an exit code.
///
/// # Errors
///
/// Returns an error if the dispatched handler fails.
pub async fn dispatch(command: Command, ctx: RunContext) -> Result<i32> {
    match command {
        Command::Init(args) => crate::commands::init::handle(args).await.map(|()| 0),
        Command::Run(args) => crate::commands::run::handle(args, ctx).await,
        Command::Pipelines(args) => crate::cli::pipelines::run(args).await.map(|()| 0),
        Command::Render(args) => crate::cli::render::run(args).await.map(|()| 0),
        Command::Cache(cmd) => match cmd {
            CacheCommand::Save(args) => crate::commands::cache::handle_save(&args.dir).await,
            CacheCommand::Restore(args) => crate::commands::cache::handle_restore(&args.dir).await,
            CacheCommand::Clean => crate::commands::cache::handle_clean().await,
        },
        Command::Version => version::run().await.map(|()| 0),
        Command::Plugin(cmd) => plugin::run(cmd).await.map(|()| 0),
        Command::Cloud(cmd) => {
            let env = std::env::vars().collect();
            hm_plugin_cloud::cli::dispatch_command(cmd, env).await
        }
    }
}