feat: create credentials command

src/auth/create/mod.rs

@@ -0,0 +1 @@
+pub mod ssh;

src/auth/create/ssh.rs

@@ -0,0 +1,299 @@
+use dialoguer::{Confirm, Input, Select};
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+pub fn setup_ssh_auth() {
+    println!("🔐 SSH Authentication Setup");
+    println!("Setting up SSH authentication for Git operations...\n");
+
+    let home_dir = std::env::var("HOME")
+        .or_else(|_| std::env::var("USERPROFILE"))
+        .unwrap_or_else(|_| ".".to_string());
+    let ssh_dir = Path::new(&home_dir).join(".ssh");
+
+    // Create .ssh directory if it doesn't exist
+    if !ssh_dir.exists() {
+        println!("📁 Creating .ssh directory...");
+        if let Err(e) = fs::create_dir_all(&ssh_dir) {
+            eprintln!("❌ Failed to create .ssh directory: {}", e);
+            return;
+        }
+        println!("✅ .ssh directory created successfully");
+    }
+
+    // Check for existing SSH keys
+    let key_types = [
+        ("id_ed25519", "Ed25519 (recommended)"),
+        ("id_rsa", "RSA"),
+        ("id_ecdsa", "ECDSA"),
+    ];
+
+    let mut existing_keys = Vec::new();
+    for (key_name, key_type) in &key_types {
+        let private_key = ssh_dir.join(key_name);
+        let public_key = ssh_dir.join(format!("{}.pub", key_name));
+
+        if private_key.exists() && public_key.exists() {
+            // Read the public key to extract identity
+            let identity = match fs::read_to_string(&public_key) {
+                Ok(content) => {
+                    // Extract the comment/email part (last part after the key data)
+                    let parts: Vec<&str> = content.split_whitespace().collect();
+                    if parts.len() >= 3 {
+                        parts[2..].join(" ")
+                    } else {
+                        "No identity found".to_string()
+                    }
+                }
+                Err(_) => "Could not read key".to_string(),
+            };
+
+            existing_keys.push((*key_name, *key_type, public_key, identity));
+        }
+    }
+
+    if !existing_keys.is_empty() {
+        println!("🔍 Found existing SSH keys:");
+        for (i, (key_name, key_type, _, identity)) in existing_keys.iter().enumerate() {
+            println!(" {}. {} ({}) - {}", i + 1, key_name, key_type, identity);
+        }
+
+        let options = vec!["Use existing key", "Generate new key", "Exit"];
+        match Select::new()
+            .with_prompt("Choose an option")
+            .default(0)
+            .items(&options)
+            .interact()
+        {
+            Ok(0) => {
+                if existing_keys.len() == 1 {
+                    display_public_key_and_guide(&existing_keys[0].2);
+                } else {
+                    select_existing_key(&existing_keys);
+                }
+                return;
+            }
+            Ok(1) => {
+                // Continue to generate new key
+            }
+            Ok(2) | Err(_) => {
+                println!("Setup cancelled.");
+                return;
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    // Generate new SSH key
+    generate_new_ssh_key(&ssh_dir);
+}
+
+fn select_existing_key(existing_keys: &[(&str, &str, std::path::PathBuf, String)]) {
+    let key_options: Vec<String> = existing_keys
+        .iter()
+        .map(|(key_name, key_type, _, identity)| {
+            format!("{} ({}) - {}", key_name, key_type, identity)
+        })
+        .collect();
+
+    match Select::new()
+        .with_prompt("Select which key to use")
+        .default(0)
+        .items(&key_options)
+        .interact()
+    {
+        Ok(choice) => {
+            display_public_key_and_guide(&existing_keys[choice].2);
+        }
+        Err(_) => {
+            println!("Selection cancelled.");
+        }
+    }
+}
+
+fn generate_new_ssh_key(ssh_dir: &Path) {
+    println!("\n🔑 Generating new SSH key...");
+
+    // Get user email
+    let email = match Input::<String>::new()
+        .with_prompt("Enter your email address")
+        .validate_with(|input: &String| -> Result<(), &str> {
+            if input.trim().is_empty() {
+                Err("Email cannot be empty")
+            } else if !input.contains('@') {
+                Err("Please enter a valid email address")
+            } else {
+                Ok(())
+            }
+        })
+        .interact()
+    {
+        Ok(email) => email.trim().to_string(),
+        Err(_) => {
+            println!("Email input cancelled. Exiting.");
+            return;
+        }
+    };
+
+    // Choose key type
+    let key_types = vec![
+        "Ed25519 (recommended, modern and secure)",
+        "RSA 4096 (widely compatible)",
+    ];
+
+    let key_choice = match Select::new()
+        .with_prompt("Choose SSH key type")
+        .default(0)
+        .items(&key_types)
+        .interact()
+    {
+        Ok(choice) => choice,
+        Err(_) => {
+            println!("Key type selection cancelled. Exiting.");
+            return;
+        }
+    };
+
+    let (key_type, key_name, ssh_keygen_args) = match key_choice {
+        1 => ("RSA", "id_rsa", vec!["-t", "rsa", "-b", "4096"]),
+        _ => ("Ed25519", "id_ed25519", vec!["-t", "ed25519"]),
+    };
+
+    println!("\n🔧 Generating {} key...", key_type);
+    let key_path = ssh_dir.join(key_name);
+
+    // Build ssh-keygen command
+    let mut cmd = Command::new("ssh-keygen");
+    cmd.args(&ssh_keygen_args)
+        .arg("-C")
+        .arg(&email)
+        .arg("-f")
+        .arg(&key_path)
+        .arg("-N")
+        .arg(""); // Empty passphrase for simplicity
+
+    match cmd.status() {
+        Ok(status) if status.success() => {
+            println!("✅ SSH key generated successfully!");
+            // Add to ssh-agent
+            add_key_to_agent(&key_path);
+            // Display public key and guide
+            let public_key_path = ssh_dir.join(format!("{}.pub", key_name));
+            display_public_key_and_guide(&public_key_path);
+        }
+        Ok(status) => {
+            eprintln!("❌ ssh-keygen failed with status: {}", status);
+        }
+        Err(e) => {
+            eprintln!("❌ Failed to run ssh-keygen: {}", e);
+            eprintln!("Make sure OpenSSH is installed on your system.");
+        }
+    }
+}
+
+fn add_key_to_agent(key_path: &Path) {
+    println!("\n🔧 Adding key to ssh-agent...");
+
+    // Check if ssh-agent is running
+    if std::env::var("SSH_AUTH_SOCK").is_err() {
+        println!("SSH agent is not running. Starting ssh-agent...");
+        // Try to start ssh-agent
+        match Command::new("ssh-agent").arg("-s").output() {
+            Ok(output) if output.status.success() => {
+                let agent_output = String::from_utf8_lossy(&output.stdout);
+                println!("SSH agent started. You may need to run the following commands:");
+                println!("{}", agent_output.trim());
+            }
+            _ => {
+                println!("⚠️ Could not start ssh-agent automatically.");
+                println!("You may need to start it manually with: eval $(ssh-agent -s)");
+            }
+        }
+    }
+
+    // Add key to agent
+    match Command::new("ssh-add").arg(key_path).status() {
+        Ok(status) if status.success() => {
+            println!("✅ Key added to ssh-agent successfully!");
+        }
+        Ok(_) => {
+            println!("⚠️ Failed to add key to ssh-agent");
+            println!(
+                "💡 You can add it manually with: ssh-add {}",
+                key_path.display()
+            );
+        }
+        Err(_) => {
+            println!("⚠️ ssh-add not available");
+            println!(
+                "💡 You can add it manually later with: ssh-add {}",
+                key_path.display()
+            );
+        }
+    }
+}
+
+fn display_public_key_and_guide(public_key_path: &Path) {
+    println!("\n📋 Your SSH Public Key:");
+    println!("{}", "─".repeat(60));
+
+    match fs::read_to_string(public_key_path) {
+        Ok(public_key) => {
+            println!("{}", public_key.trim());
+            println!("{}", "─".repeat(60));
+
+            println!("\n🚀 Next Steps:");
+            println!("\n1. Copy the public key above (it's already selected for you)");
+            println!("\n2. Add it to your GitHub account:");
+            println!(" • Go to: https://github.com/settings/ssh/new");
+            println!(" • Or navigate to: GitHub → Settings → SSH and GPG keys → New SSH key");
+            println!("\n3. Fill in the form:");
+            println!(" • Title: Give it a descriptive name (e.g., 'My Laptop - bgit')");
+            println!(" • Key type: Authentication Key");
+            println!(" • Key: Paste the public key from above");
+            println!("\n4. Click 'Add SSH key' and enter your GitHub password if prompted");
+            println!("\n5. Test your connection:");
+            println!(" ssh -T git@github.com");
+            println!(
+                "\n🎉 You're all set! Your bgit tool can now authenticate with GitHub using SSH."
+            );
+
+            // Offer to open GitHub in browser
+            if Confirm::new()
+                .with_prompt("Would you like to open GitHub SSH settings in your default browser?")
+                .default(false)
+                .interact()
+                .unwrap_or(false)
+            {
+                open_github_ssh_settings();
+            }
+        }
+        Err(e) => {
+            eprintln!("❌ Failed to read public key file: {}", e);
+        }
+    }
+}
+
+fn open_github_ssh_settings() {
+    let url = "https://github.com/settings/ssh/new";
+
+    #[cfg(target_os = "windows")]
+    let cmd = Command::new("cmd").args(["/c", "start", url]).status();
+
+    #[cfg(target_os = "macos")]
+    let cmd = Command::new("open").arg(url).status();
+
+    #[cfg(target_os = "linux")]
+    let cmd = Command::new("xdg-open").arg(url).status();
+
+    match cmd {
+        Ok(status) if status.success() => {
+            println!("🌐 Opening GitHub SSH settings in your browser...");
+        }
+        _ => {
+            println!("⚠️ Could not open browser automatically.");
+            println!("🔗 Please visit: {}", url);
+        }
+    }
+}

src/auth/git_auth.rs

@@ -0,0 +1,33 @@
+use git2::{CertificateCheckStatus, CredentialType, RemoteCallbacks};
+use log::debug;
+use std::sync::{Arc, Mutex};
+
+use crate::auth::{git_http::try_userpass_authentication, git_ssh::ssh_authenticate_git};
+
+pub fn setup_auth_callbacks() -> RemoteCallbacks<'static> {
+    let mut callbacks = RemoteCallbacks::new();
+
+    // Track attempt count across callback invocations
+    let attempt_count: Arc<Mutex<usize>> = Arc::new(Mutex::new(0));
+
+    callbacks.credentials(move |url, username_from_url, allowed_types| {
+        let mut count = attempt_count.lock().unwrap();
+        *count += 1;
+        let current_attempt = *count;
+        drop(count);
+
+        if allowed_types.contains(CredentialType::USER_PASS_PLAINTEXT) {
+            try_userpass_authentication(username_from_url)
+        } else {
+            ssh_authenticate_git(url, username_from_url, allowed_types, current_attempt)
+        }
+    });
+
+    // Set up certificate check callback for HTTPS
+    callbacks.certificate_check(|_cert, _host| {
+        debug!("Skipping certificate verification (INSECURE)");
+        Ok(CertificateCheckStatus::CertificateOk)
+    });
+
+    callbacks
+}

src/auth/git_http.rs

@@ -0,0 +1,55 @@
+use dialoguer::{Input, Password, theme::ColorfulTheme};
+use git2::{Cred, Error, ErrorClass, ErrorCode};
+use log::debug;
+
+pub fn try_userpass_authentication(username_from_url: Option<&str>) -> Result<Cred, Error> {
+    debug!("USER_PASS_PLAINTEXT authentication is allowed, prompting for credentials");
+
+    // Prompt for username if not provided in URL
+    let username = if let Some(user) = username_from_url {
+        user.to_string()
+    } else {
+        Input::<String>::with_theme(&ColorfulTheme::default())
+            .with_prompt("Enter your username")
+            .interact()
+            .map_err(|e| {
+                Error::new(
+                    ErrorCode::Auth,
+                    ErrorClass::Net,
+                    format!("Failed to read username: {}", e),
+                )
+            })?
+    };
+
+    let token = Password::with_theme(&ColorfulTheme::default())
+        .with_prompt("Enter your personal access token")
+        .interact()
+        .map_err(|e| {
+            Error::new(
+                ErrorCode::Auth,
+                ErrorClass::Net,
+                format!("Failed to read token: {}", e),
+            )
+        })?;
+
+    if !username.is_empty() && !token.is_empty() {
+        debug!("Creating credentials with username and token");
+        match Cred::userpass_plaintext(&username, &token) {
+            Ok(cred) => {
+                debug!("Username/token authentication succeeded");
+                Ok(cred)
+            }
+            Err(e) => {
+                debug!("Username/token authentication failed: {}", e);
+                Err(e)
+            }
+        }
+    } else {
+        debug!("Username or token is empty, skipping userpass authentication");
+        Err(Error::new(
+            ErrorCode::Auth,
+            ErrorClass::Net,
+            "Username or token cannot be empty",
+        ))
+    }
+}