cmfy 0.1.1

A CLI companion app for Comfy UI
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

mod commands;
mod io;

use clap::{
    builder::{styling::AnsiColor, Styles},
    Parser, Subcommand,
};
use cmfy::{Client, Result};
use commands::{Cancel, Capture, Clear, Get, History, List, Open, Queue, Run, Stats, Submit};

pub fn build_styles() -> Styles {
    Styles::styled()
        .header(AnsiColor::Yellow.on_default().underline())
        .usage(AnsiColor::Yellow.on_default().underline())
        .literal(AnsiColor::Green.on_default())
        .placeholder(AnsiColor::BrightWhite.on_default())
        .error(AnsiColor::BrightRed.on_default())
}

#[derive(Parser, Debug)]
#[clap(version)]
#[command(styles=build_styles(), color=clap::ColorChoice::Always, infer_subcommands = true)]
struct Cli {
    /// hostname of the server
    #[arg(short, long, env = "COMFY_SERVER", value_name = "SERVER", default_value = "localhost")]
    server: String,

    /// port of the server
    #[arg(short, long, env = "COMFY_PORT", value_name = "PORT", default_value_t = 8188)]
    port: u32,

    /// command to execute
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand, Debug)]
enum Command {
    Stats(Stats),
    History(History),
    Queue(Queue),
    List(List),
    Cancel(Cancel),
    Clear(Clear),
    Open(Open),
    Capture(Capture),
    Get(Get),
    Submit(Submit),
}

impl Run for Command {
    async fn run(self, client: Client) -> Result<()> {
        use Command::*;
        match self {
            Stats(cmd) => cmd.run(client).await,
            History(cmd) => cmd.run(client).await,
            Queue(cmd) => cmd.run(client).await,
            List(cmd) => cmd.run(client).await,
            Cancel(cmd) => cmd.run(client).await,
            Clear(cmd) => cmd.run(client).await,
            Open(cmd) => cmd.run(client).await,
            Capture(cmd) => cmd.run(client).await,
            Get(cmd) => cmd.run(client).await,
            Submit(cmd) => cmd.run(client).await,
        }
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let args = Cli::parse();
    let client = Client::new(args.server, args.port);
    args.command.run(client).await
}