volli 0.1.10

#![cfg_attr(test, allow(unused_crate_dependencies))]

use clap::{Args, CommandFactory, Parser, Subcommand};
use tracing_subscriber::EnvFilter;

mod commands;
mod namegen;

struct FilterWriter<W: std::io::Write> {
    inner: W,
    buf: Vec<u8>,
}

impl<W: std::io::Write> FilterWriter<W> {
    fn new(inner: W) -> Self {
        Self {
            inner,
            buf: Vec::new(),
        }
    }
}

impl<W: std::io::Write> std::io::Write for FilterWriter<W> {
    fn write(&mut self, data: &[u8]) -> std::io::Result<usize> {
        for &b in data {
            self.buf.push(b);
            if b == b'\n' {
                if !self
                    .buf
                    .windows(b"completions".len())
                    .any(|w| w == b"completions")
                {
                    self.inner.write_all(&self.buf)?;
                }
                self.buf.clear();
            }
        }
        Ok(data.len())
    }

    fn flush(&mut self) -> std::io::Result<()> {
        if !self.buf.is_empty()
            && !self
                .buf
                .windows(b"completions".len())
                .any(|w| w == b"completions")
        {
            self.inner.write_all(&self.buf)?;
        }
        self.buf.clear();
        self.inner.flush()
    }
}

fn default_profile() -> String {
    commands::utils::default_profile()
}

#[derive(Parser)]
#[command(name = "volli", about = "Distributed diagnostics CLI", version)]
struct Cli {
    /// Configuration profile name
    #[arg(long, global = true, default_value_t = default_profile(), value_hint = clap::ValueHint::Other)]
    profile: String,
    /// Increase verbosity (-v, -vv)
    #[arg(short, long, global = true, action = clap::ArgAction::Count)]
    verbose: u8,
    /// Silence output
    #[arg(short, long, global = true, action = clap::ArgAction::SetTrue)]
    quiet: bool,
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Run as coordinator server
    Serve(ServeOpts),
    /// Run as cluster agent
    Agent(AgentOpts),
    /// Administrative tasks
    Admin(AdminOpts),
    /// Manage configuration profiles
    Profile(ProfileOpts),
    /// Generate shell completion script
    #[command(hide = true)]
    Completions { shell: clap_complete::Shell },
}

#[derive(Args)]
/// Options for the `admin` subcommand
struct AdminOpts {
    #[command(subcommand)]
    command: AdminCommand,
}

#[derive(Subcommand)]
enum AdminCommand {
    /// Print an agent join command
    AgentToken,
    /// Print a coordinator join command
    CoordToken,
}

#[derive(Args)]
/// Options for the `profile` subcommand
struct ProfileOpts {
    #[command(subcommand)]
    command: ProfileCommand,
}

#[derive(Args)]
/// Show profile details
struct ProfileShow {
    /// Profile name
    profile: String,
    /// Show coordinator profile only
    #[arg(long)]
    coord: bool,
    /// Show agent profile only
    #[arg(long)]
    agent: bool,
}

#[derive(Subcommand)]
enum ProfileCommand {
    /// List available profiles
    List,
    /// Show profile details
    Show(ProfileShow),
    /// Delete a profile
    Delete(ProfileDelete),
    /// Rename a profile
    Rename(ProfileRename),
    /// Update profile values
    Update(ProfileUpdate),
    /// Export a profile
    Export(ProfileExport),
    /// Import a profile
    Import(ProfileImport),
    /// Edit a profile in $EDITOR
    Edit(ProfileEdit),
}

#[derive(Args)]
/// Delete a profile
struct ProfileDelete {
    /// Profile name
    profile: String,
    /// Delete agent profile
    #[arg(long)]
    agent: bool,
    /// Delete server profile
    #[arg(long)]
    serve: bool,
}

#[derive(Args)]
/// Rename a profile
struct ProfileRename {
    /// Current profile name
    old: String,
    /// New profile name
    new: String,
    /// Rename coordinator profile
    #[arg(long)]
    coord: bool,
    /// Rename agent profile
    #[arg(long)]
    agent: bool,
}

#[derive(Args)]
/// Update profile fields
struct ProfileUpdate {
    /// Profile name
    profile: String,
    /// Add coordinator host
    #[arg(long)]
    add_join_host: Option<String>,
    /// Add coordinator from join token
    #[arg(long)]
    add_join_token: Option<String>,
    /// Remove coordinator host by index
    #[arg(long)]
    remove_join_index: Option<usize>,
    /// Join TCP port (use with --add-join-host)
    #[arg(long)]
    join_tcp_port: Option<u16>,
    /// Join QUIC port (use with --add-join-host)
    #[arg(long)]
    join_quic_port: Option<u16>,
    /// Bind host
    #[arg(long)]
    bind_host: Option<String>,
    /// TCP port
    #[arg(long)]
    tcp_port: Option<u16>,
    /// QUIC port
    #[arg(long)]
    quic_port: Option<u16>,
    /// Advertise host
    #[arg(long)]
    advertise_host: Option<String>,
    /// Agent connection whitelist (comma-separated CIDRs)
    #[arg(long)]
    agent_whitelist: Option<String>,
    /// Coordinator connection whitelist (comma-separated CIDRs)
    #[arg(long)]
    coord_whitelist: Option<String>,
    /// Agent secret
    #[arg(long)]
    agent_secret: Option<String>,
}

#[derive(Args)]
/// Export a profile
struct ProfileExport {
    /// Profile name
    profile: String,
    /// Export coordinator profile
    #[arg(long)]
    coord: bool,
    /// Export agent profile
    #[arg(long)]
    agent: bool,
    /// Write to stdout instead of file
    #[arg(long)]
    stdout: bool,
    /// Output file name
    #[arg(long)]
    output: Option<String>,
}

#[derive(Args)]
/// Import a profile
struct ProfileImport {
    /// YAML file to import
    file: String,
    /// Profile name override
    #[arg(long)]
    name: Option<String>,
    /// Overwrite existing profile
    #[arg(long)]
    force: bool,
}

#[derive(Args)]
/// Run the coordinator server
struct ProfileEdit {
    /// Profile name
    profile: String,
    /// Edit coordinator profile
    #[arg(long)]
    coord: bool,
    /// Edit agent profile
    #[arg(long)]
    agent: bool,
}

#[derive(Args)]
struct ServeOpts {
    /// Run as a daemon
    #[arg(short, long)]
    daemon: bool,
    /// Generate or overwrite coordinator credentials and exit
    #[arg(long)]
    bootstrap: bool,
    /// Skip confirmation prompts
    #[arg(long)]
    force: bool,
    /// Join existing coordinator using secret
    #[arg(long)]
    join: Option<String>,
    /// Address to bind listeners to
    #[arg(long)]
    bind: Option<String>,
    /// Hostname or IP advertised in join tokens
    #[arg(long, alias = "host")]
    advertise_host: Option<String>,
    /// Override host from join secret
    #[arg(long)]
    join_host: Option<String>,
    /// Override TCP port from join secret
    #[arg(long)]
    join_tcp_port: Option<u16>,
    /// Override QUIC port from join secret
    #[arg(long)]
    join_quic_port: Option<u16>,
    /// TCP port to listen on
    #[arg(long)]
    tcp_port: Option<u16>,
    /// QUIC port to listen on
    #[arg(long)]
    quic_port: Option<u16>,
    /// TLS certificate path
    #[arg(long)]
    cert: Option<String>,
    /// TLS private key path
    #[arg(long)]
    key: Option<String>,
    /// Directory for all profiles and secrets
    #[arg(long)]
    config_dir: Option<String>,
    /// Persist overrides back to the profile
    #[arg(long)]
    update_profile: bool,
}

#[derive(Args)]
/// Run the agent node
struct AgentOpts {
    /// Run as a daemon
    #[arg(short, long)]
    daemon: bool,
    /// Connection string host[:port]
    #[arg(default_value = "localhost")]
    connect: String,
    /// Join secret
    #[arg(long)]
    join: Option<String>,
    /// Overwrite existing profile when joining
    #[arg(long)]
    force: bool,
    /// Force protocol (tcp or quic)
    #[arg(long)]
    protocol: Option<String>,
    /// Override host from join secret
    #[arg(long)]
    join_host: Option<String>,
    /// Directory for all profiles and secrets
    #[arg(long)]
    config_dir: Option<String>,
    /// Persist overrides back to the profile
    #[arg(long)]
    update_profile: bool,
}

#[tokio::main]
async fn main() {
    let cli = Cli::parse();
    let level = if cli.quiet {
        "warn"
    } else {
        match cli.verbose {
            0 => {
                if cfg!(debug_assertions) {
                    "debug"
                } else {
                    "info"
                }
            }
            1 => "debug",
            _ => "trace",
        }
    };
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(level));
    tracing_subscriber::fmt().with_env_filter(filter).init();
    match cli.command {
        Commands::Completions { shell } => {
            let mut cmd = Cli::command();
            let stdout = std::io::stdout();
            let handle = stdout.lock();
            let mut writer = FilterWriter::new(handle);
            clap_complete::generate(shell, &mut cmd, "volli", &mut writer);
        }
        Commands::Serve(opts) => {
            commands::serve::run(cli.profile.clone(), opts).await;
        }
        Commands::Agent(opts) => {
            commands::agent::run(cli.profile.clone(), opts).await;
        }
        Commands::Admin(opts) => {
            commands::admin::run(cli.profile.clone(), opts).await;
        }
        Commands::Profile(opts) => {
            commands::profile::run(opts);
        }
    }
}

#[cfg(test)]

mod tests {
    use eyre::Report;
    async fn send_cmd(profile: &str, cmd: &str) -> Result<(), Report> {
        commands::utils::send_cmd(profile, cmd).await
    }

    fn cmd_socket_path(profile: &str) -> std::path::PathBuf {
        commands::utils::cmd_socket_path(profile)
    }

    fn export_path(profile: &str, output: Option<&str>) -> String {
        commands::utils::export_path(profile, output)
    }

    use super::*;
    use tokio::io::{AsyncBufReadExt, AsyncWriteExt};

    #[tokio::test]
    async fn send_cmd_missing_socket_errors() {
        let path = cmd_socket_path("missing");
        let _ = std::fs::remove_file(&path);
        let res = send_cmd("missing", "hi").await;
        assert!(res.is_err());
    }

    #[tokio::test]
    async fn send_cmd_writes_and_reads() {
        let path = cmd_socket_path("ok");
        let _ = std::fs::remove_file(&path);
        let listener = tokio::net::UnixListener::bind(&path).unwrap();
        let server = tokio::spawn(async move {
            let (stream, _) = listener.accept().await.unwrap();
            let mut reader = tokio::io::BufReader::new(stream);
            let mut cmd = String::new();
            reader.read_line(&mut cmd).await.unwrap();
            assert_eq!(cmd, "ping\n");
            reader.get_mut().write_all(b"pong\n").await.unwrap();
        });
        send_cmd("ok", "ping").await.unwrap();
        server.await.unwrap();
        std::fs::remove_file(&path).ok();
    }

    #[test]
    fn export_path_defaults() {
        assert_eq!(export_path("p1", None), "p1.yaml");
        assert_eq!(export_path("p1", Some("out.yaml")), "out.yaml");
    }

    #[test]
    fn socket_path_contains_profile() {
        let path = cmd_socket_path("abc");
        let filename = path.file_name().unwrap().to_string_lossy();
        assert_eq!(filename, "volli-abc.sock");
    }
}