homeboy 0.72.0

CLI for multi-component deployment and development workflow automation
Documentation 
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

use clap::{Args, Subcommand};
use serde::Serialize;

use homeboy::undo;

use super::CmdResult;

#[derive(Args)]
pub struct UndoArgs {
    #[command(subcommand)]
    pub command: Option<UndoCommand>,

    /// Restore a specific snapshot by ID (default: latest)
    #[arg(long)]
    pub id: Option<String>,
}

#[derive(Subcommand)]
pub enum UndoCommand {
    /// List available undo snapshots
    List,
    /// Delete a snapshot without restoring
    Delete {
        /// Snapshot ID to delete
        id: String,
    },
}

#[derive(Serialize)]
#[serde(tag = "command")]
pub enum UndoOutput {
    #[serde(rename = "undo.restore")]
    Restore(undo::RestoreResult),

    #[serde(rename = "undo.list")]
    List {
        snapshots: Vec<undo::SnapshotSummary>,
    },

    #[serde(rename = "undo.delete")]
    Delete { id: String, deleted: bool },
}

pub fn run(args: UndoArgs, _global: &super::GlobalArgs) -> CmdResult<UndoOutput> {
    match args.command {
        Some(UndoCommand::List) => {
            let snapshots = undo::list_snapshots()?;
            if snapshots.is_empty() {
                homeboy::log_status!("undo", "No snapshots available");
            } else {
                homeboy::log_status!("undo", "{} snapshot(s) available:", snapshots.len());
                for snap in &snapshots {
                    homeboy::log_status!(
                        "undo",
                        "  {} — {} ({} file(s), {})",
                        snap.id,
                        snap.label,
                        snap.file_count,
                        snap.age
                    );
                }
            }
            Ok((UndoOutput::List { snapshots }, 0))
        }
        Some(UndoCommand::Delete { id }) => {
            undo::delete_snapshot(&id)?;
            Ok((UndoOutput::Delete { id, deleted: true }, 0))
        }
        None => {
            // Default: restore latest (or specific --id)
            let result = undo::restore(args.id.as_deref())?;
            let has_errors = !result.errors.is_empty();
            let exit_code = if has_errors { 1 } else { 0 };
            Ok((UndoOutput::Restore(result), exit_code))
        }
    }
}