muthr 0.1.12

A zero-trust orchestrator that automates llama.cpp and Lima to safely run local AI agents in isolated 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
133
134
135
136
137
138
139
140
141
142
143

pub mod config;
pub mod download;
pub mod engine;
pub mod model;
pub mod preset;
pub mod sandbox;
pub mod services;
pub mod system;
pub mod theme;
pub mod ui;

use clap::{CommandFactory, Parser, Subcommand};
use clap_complete::{generate, Shell};

#[derive(Parser)]
#[command(
    name = "muthr",
    version,
    author,
    about,
    arg_required_else_help = true,
    propagate_version = true
)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    #[command(about = "start the llama-server (background daemon or foreground)")]
    Serve {
        #[arg(long)]
        profile: Option<String>,
        #[arg(short, long, default_value_t = 8080)]
        port: u16,
        #[arg(
            long,
            help = "run in foreground (blocking) instead of background daemon"
        )]
        foreground: bool,
    },

    #[command(about = "stop the running llama-server daemon")]
    Stop,

    #[command(about = "show active profile and server status")]
    Status,

    #[command(about = "list available preset profiles")]
    List,

    #[command(about = "provision and start a lima sandbox vm")]
    Up {
        #[arg(short, long, default_value_t = 8080)]
        port: u16,
    },

    #[command(about = "stop the current sandbox vm")]
    Down,

    #[command(about = "list all sandbox vms")]
    Ls,

    #[command(about = "manage mcp services vm (start/stop/status/restart)")]
    Services {
        #[command(subcommand)]
        action: ServicesCommands,
    },

    #[command(about = "download a gguf model from huggingface")]
    Download {
        #[arg(help = "HuggingFace repo or URL")]
        source: String,
        #[arg(help = "GGUF filename (required for repo syntax)")]
        file: Option<String>,
    },

    #[command(about = "run darwin-rebuild and sync neovim configuration")]
    Rebase {
        #[arg(long, help = "skip dry-run preview and proceed directly")]
        yes: bool,
    },

    #[command(about = "remove .DS_Store files from the project")]
    Clean,

    #[command(about = "generate shell completion scripts")]
    Completion {
        #[arg(value_enum)]
        shell: Shell,
    },

    #[command(about = "browse and select ghostty themes")]
    Themes,
}

#[derive(Subcommand)]
pub enum ServicesCommands {
    #[command(about = "start the MCP services VM")]
    Start,
    #[command(about = "stop the MCP services VM")]
    Stop,
    #[command(about = "show MCP services VM status")]
    Status,
    #[command(about = "restart the MCP services VM")]
    Restart,
}

#[tokio::main]
async fn main() -> color_eyre::Result<()> {
    color_eyre::install()?;
    run().await
}

async fn run() -> Result<(), color_eyre::Report> {
    let cli = Cli::parse();

    match cli.command {
        Commands::Serve {
            profile,
            port,
            foreground,
        } => engine::serve(profile, port, foreground).await?,
        Commands::Status => engine::status().await?,
        Commands::Stop => engine::stop().await?,
        Commands::List => engine::list()?,
        Commands::Up { port } => sandbox::up(port).await?,
        Commands::Down => sandbox::down().await?,
        Commands::Ls => sandbox::list().await?,
        Commands::Services { action } => services::run(action).await?,
        Commands::Download { source, file } => download::download(&source, file.as_deref()).await?,
        Commands::Rebase { yes } => system::rebase(yes).await?,
        Commands::Clean => system::clean().await?,
        Commands::Themes => theme::run()?,
        Commands::Completion { shell } => {
            let mut cmd = Cli::command();
            generate(shell, &mut cmd, "muthr", &mut std::io::stdout());
        }
    }

    Ok(())
}