bytestashy 0.1.1

A command-line interface for ByteStash for the easy posting of snippets without opening a browser.
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

// src/main.rs
mod api_client;
mod config;

use clap::{Parser, Subcommand};
use std::process;

use api_client::APIClient;

/// BitsCLI: Ein Tool, um Snippets per API hochzuladen.
#[derive(Parser)]
#[command(name = "bytestashy", version, about = "CLI für Snippet‐Uploads auf ByteStash")]
struct Cli {
    files: Vec<String>,

    #[command(subcommand)]
    command: Option<Commands>,
}

#[derive(Subcommand)]
enum Commands {
    /// Loggt ein, erzeugt einen API-Key und speichert diesen lokal.
    Login {
        /// Basis-URL der API, z. B. https://meine.app.tld
        api_url: String,
    },
}

fn main() {
    let cli = Cli::parse();

    match &cli.command {
        Some(Commands::Login { api_url }) => {
            // Verhalten wie bisher für "bits login <api_url>"
            if let Err(err) = APIClient::login_and_create_key(api_url) {
                eprintln!("Fehler beim Login/API-Key-Erzeugung: {}", err);
                process::exit(1);
            }
        }
        None => {
            // Falls kein Subcommand angegeben wurde, behandeln wir die übergebenen Dateien als Upload
            let files = &cli.files;
            if files.is_empty() {
                eprintln!("Bitte mindestens eine Datei angeben.");
                process::exit(1);
            }

            // 1. Versuchen, aus config.json api_url + api_key zu laden
            let client = match APIClient::new() {
                Ok(c) => c,
                Err(err) => {
                    eprintln!("{}", err);
                    eprintln!("Führe zuerst `bits login <api-url>` aus, um den API-Key zu erzeugen.");
                    process::exit(1);
                }
            };

            // 2. Interaktive Abfragen: title, description, is_public, categories, fragments
            let title: String = dialoguer::Input::new()
                .with_prompt("Titel für das Snippet")
                .interact_text()
                .unwrap_or_else(|e| {
                    eprintln!("Fehler beim Einlesen des Titels: {}", e);
                    process::exit(1);
                });

            let description: String = dialoguer::Input::new()
                .with_prompt("Beschreibung (optional)")
                .allow_empty(true)
                .interact_text()
                .unwrap_or_else(|e| {
                    eprintln!("Fehler beim Einlesen der Beschreibung: {}", e);
                    process::exit(1);
                });

            let is_public: bool = dialoguer::Confirm::new()
                .with_prompt("Soll das Snippet öffentlich sein?")
                .default(false)
                .interact()
                .unwrap_or_else(|e| {
                    eprintln!("Fehler beim Einlesen der Auswahl: {}", e);
                    process::exit(1);
                });

            let categories: String = dialoguer::Input::new()
                .with_prompt("Kategorien (Komma-separiert, z.B. \"rust,cli,security\")")
                .allow_empty(true)
                .interact_text()
                .unwrap_or_else(|e| {
                    eprintln!("Fehler beim Einlesen der Kategorien: {}", e);
                    process::exit(1);
                });

            // 3. Snippet erstellen
            match client.create_snippet(
                &title,
                &description,
                is_public,
                &categories,
                &files,
            ) {
                Ok(json) => {
                    println!("Snippet erfolgreich erstellt.");
                    println!("{}/snippets/{}", client.api_url, json.get("id").unwrap());
                }
                Err(err) => {
                    eprintln!("Fehler beim Erstellen des Snippets: {}", err);
                    process::exit(1);
                }
            }
        }
    }
}