stackenv 0.1.3

Native, zero-container multi-project dev environment manager. No Docker, no VMs.
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
122
123
124
125
126
127
128
129
130
131
132

use crate::core::orchestrate;
use clap::{Parser, Subcommand};
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "stack", version, about = "Native, zero-container multi-project dev environment manager. No Docker, no VMs.")]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    New { target: String },
    Add {
        kind: String,
        name: String,
        version: Option<String>,
        #[arg(long)]
        schema: Option<String>,
        #[arg(long)]
        port: Option<u16>,
        #[arg(long)]
        command: Option<String>,
        #[arg(long)]
        path: Option<String>,
        #[arg(long)]
        manager: Option<String>,
        #[arg(long)]
        plugin: Option<String>,
        #[arg(long)]
        binary: Option<String>,
    },
    Remove { kind: String, name: String },
    Register {
        kind: String,
        name: String,
        version: String,
        path: Option<String>,
        #[arg(long)]
        external: bool,
        #[arg(long)]
        port: Option<u16>,
    },
    List,
    Prune {
        #[arg(long)]
        yes: bool,
        #[arg(long)]
        purge_data: bool,
    },
    LoadEnv { path: Option<String> },
    Up {
        #[arg(default_value = ".")]
        dir: PathBuf,
        #[arg(long)]
        prompt: bool,
    },
    Down {
        project: Option<String>,
        #[arg(long)]
        all: bool,
    },
    #[command(alias = "ps")]
    Status,
    Stats {
        #[arg(long)]
        no_stream: bool,
    },
    Logs {
        name: Option<String>,
        #[arg(short = 'f', long)]
        follow: bool,
        #[arg(long)]
        tail: Option<usize>,
    },
    Doctor {
        #[arg(long)]
        fix: bool,
    },
    Hook { shell: String },
    Activate { shell: String },
    Setup {
        #[arg(long, default_value = "pwsh")]
        shell: String,
    },
}

pub fn run() {
    let cli = Cli::parse();

    let result: anyhow::Result<()> = match cli.command {
        Command::New { target } => orchestrate::new_project(&target),
        Command::Add { kind, name, version, schema, port, command, path, manager, plugin, binary } => {
            orchestrate::add(&kind, &name, version, schema, port, command, path, manager, plugin, binary)
        }
        Command::Remove { kind, name } => orchestrate::remove(&kind, &name),
        Command::Register { kind, name, version, path, external, port } => orchestrate::register(&kind, &name, &version, path.as_deref(), external, port),
        Command::List => {
            orchestrate::list();
            Ok(())
        }
        Command::Prune { yes, purge_data } => orchestrate::prune(yes, purge_data),
        Command::LoadEnv { path } => orchestrate::load_env(path),
        Command::Up { dir, prompt } => orchestrate::up(&dir, prompt),
        Command::Down { project, all } => orchestrate::down(project, all),
        Command::Status => {
            orchestrate::status();
            Ok(())
        }
        Command::Stats { no_stream } => {
            orchestrate::stats(no_stream);
            Ok(())
        }
        Command::Logs { name, follow, tail } => orchestrate::logs(name, follow, tail),
        Command::Doctor { fix } => orchestrate::doctor(fix),
        Command::Hook { shell } => orchestrate::hook(&shell),
        Command::Activate { shell } => {
            orchestrate::activate(&shell);
            Ok(())
        }
        Command::Setup { shell } => {
            orchestrate::setup(&shell);
            Ok(())
        }
    };

    if let Err(e) = result {
        eprintln!("stack: {e:#}");
        std::process::exit(1);
    }
}