abpilot-cli 0.1.0

ABPilot Cli
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
144
145
146
147
148
149
150
151

mod commands;
mod config;

use clap::{Parser, Subcommand};
use commands::login::login;
use commands::app;
use commands::world;

#[derive(Parser)]
#[command(name = "abpilot")]
#[command(about = "ABPilot CLI Tool", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Login to ABPilot
    Login,
    /// Manage apps
    App {
        #[command(subcommand)]
        action: AppCommands,
    },
    /// Manage worlds
    World {
        #[command(subcommand)]
        action: WorldCommands,
    },
}

#[derive(Subcommand)]
enum AppCommands {
    /// List all apps
    List,
    /// Create a new app
    Create {
        /// Name for the app
        name: String,
    },
    /// Delete an app
    Delete {
        /// App ID to delete
        app_id: String,
    },
    /// Reset app secret
    ResetSecret {
        /// App ID
        app_id: String,
    },
    /// Upload files to app
    Upload {
        /// App ID
        app_id: String,
        /// Files to upload
        files: Vec<String>,
    },
    /// Download files from app
    Download {
        /// App ID
        app_id: String,
        /// Files to download
        files: Vec<String>,
    },
}

#[derive(Subcommand)]
enum WorldCommands {
    /// List all worlds
    List,
    /// Create a new world
    Create {
        /// Name for the world
        name: String,
    },
    /// Delete a world
    Delete {
        /// World ID to delete
        world_id: String,
    },
    /// Get world details
    Get {
        /// World ID
        world_id: String,
    },
    /// Reset world secret
    ResetSecret {
        /// World ID
        world_id: String,
    },
    /// Upload files to world
    Upload {
        /// World ID
        world_id: String,
        /// Files to upload
        files: Vec<String>,
    },
    /// Download files from world
    Download {
        /// World ID
        world_id: String,
        /// Files to download
        files: Vec<String>,
    },
}

#[tokio::main]
async fn main() {
    let cli = Cli::parse();

    match cli.command {
        Commands::Login => {
            if let Err(e) = login().await {
                eprintln!("Login failed: {}", e);
                std::process::exit(1);
            }
        }
        Commands::App { action } => {
            let result = match action {
                AppCommands::List => app::list().await,
                AppCommands::Create { name } => app::create(name).await,
                AppCommands::Delete { app_id } => app::delete(app_id).await,
                AppCommands::ResetSecret { app_id } => app::reset_secret(app_id).await,
                AppCommands::Upload { app_id, files } => app::upload(app_id, files).await,
                AppCommands::Download { app_id, files } => app::download(app_id, files).await,
            };
            
            if let Err(e) = result {
                eprintln!("Error: {}", e);
                std::process::exit(1);
            }
        }
        Commands::World { action } => {
            let result = match action {
                WorldCommands::List => world::list().await,
                WorldCommands::Create { name } => world::create(name).await,
                WorldCommands::Delete { world_id } => world::delete(world_id).await,
                WorldCommands::Get { world_id } => world::get(world_id).await,
                WorldCommands::ResetSecret { world_id } => world::reset_secret(world_id).await,
                WorldCommands::Upload { world_id, files } => world::upload(world_id, files).await,
                WorldCommands::Download { world_id, files } => world::download(world_id, files).await,
            };
            
            if let Err(e) = result {
                eprintln!("Error: {}", e);
                std::process::exit(1);
            }
        }
    }
}