markbase/markbase-smb/src/main.rs

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

#[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(())
}