markbase/markbase-smb/src/main.rs

use clap::Parser;
use markbase_smb::{SMBConfig, SMBManager, AccessControlList, UserPermission, AuthManager, SMBMonitor};

#[derive(Parser)]
#[command(name = "markbase-smb")]
#[command(about = "MarkBase SMB Configuration and Management Tool", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Parser)]
enum Commands {
    /// Create SMB share configuration
    Create {
        /// Share name
        #[arg(short, long, default_value = "markbase")]
        name: String,
        
        /// Path to share
        #[arg(short, long, default_value = "/Users/accusys/momentry/var/sftpgo/data")]
        path: String,
    },
    
    /// Remove SMB share
    Remove {
        /// Share name
        #[arg(short, long)]
        name: String,
    },
    
    /// List existing SMB shares
    List,
    
    /// Show SMB status
    Status,
    
    /// Manage user permissions
    User {
        #[command(subcommand)]
        action: UserCommands,
    },
    
    /// Show monitoring stats
    Stats,
    
    /// Show access logs
    Logs {
        /// Number of log entries to show
        #[arg(short, long, default_value_t = 10)]
        limit: usize,
    },
}

#[derive(Parser)]
enum UserCommands {
    /// Add user permission
    Add {
        #[arg(short, long)]
        username: String,
        
        #[arg(short, long, default_value = "readonly")]
        permission: String,
    },
    
    /// Remove user permission
    Remove {
        #[arg(short, long)]
        username: String,
    },
    
    /// List all user permissions
    List,
}

fn main() -> anyhow::Result<()> {
    let cli = Cli::parse();
    
    match cli.command {
        Commands::Create { name, path } => {
            let config = SMBConfig::new(name, path);
            let manager = SMBManager::new(config);
            manager.create_share()?;
        }
        Commands::Remove { name } => {
            let config = SMBConfig::new(name, "/dummy".to_string());
            let manager = SMBManager::new(config);
            manager.remove_share()?;
        }
        Commands::List => {
            let shares = SMBManager::list_shares()?;
            if shares.is_empty() {
                println!("No SMB shares configured");
            } else {
                println!("Existing SMB shares:");
                for share in shares {
                    println!("  - {}", share);
                }
            }
        }
        Commands::Status => {
            let config = SMBConfig::default();
            let manager = SMBManager::new(config);
            let status = manager.status()?;
            println!("{}", serde_json::to_string_pretty(&status)?);
        }
        Commands::User { action } => {
            match action {
                UserCommands::Add { username, permission } => {
                    let acl = AccessControlList::new();
                    let perm = match permission.as_str() {
                        "readonly" => UserPermission::readonly(username),
                        "full" => UserPermission::full_access(username),
                        "admin" => UserPermission::admin(username),
                        _ => UserPermission::readonly(username),
                    };
                    
                    println!("User permission configuration:");
                    println!("{}", serde_json::to_string_pretty(&perm)?);
                    println!("\nTo apply, update system SMB configuration with this user.");
                }
                UserCommands::Remove { username } => {
                    println!("Removing user '{}' from ACL", username);
                    println!("To apply, update system SMB configuration.");
                }
                UserCommands::List => {
                    let acl = AccessControlList::new();
                    println!("Default ACL configuration:");
                    println!("{}", serde_json::to_string_pretty(&acl)?);
                }
            }
        }
        Commands::Stats => {
            let monitor = SMBMonitor::new();
            let stats = monitor.get_stats();
            println!("SMB Connection Statistics:");
            println!("{}", serde_json::to_string_pretty(&stats)?);
        }
        Commands::Logs { limit } => {
            let monitor = SMBMonitor::new();
            let logs = monitor.get_logs(limit);
            if logs.is_empty() {
                println!("No access logs recorded");
            } else {
                println!("Recent access logs ({} entries):", logs.len());
                for log in logs {
                    println!("{}", serde_json::to_string_pretty(&log)?);
                }
            }
        }
    }
    
    Ok(())
}