hai/src/main.rs

/*
 *  SPDX-FileCopyrightText: 2025 April Faye John <april.john@denic.de> & Contributors
 *  SPDX-License-Identifier: AGPL-3.0-or-later
 */

#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release

mod bininfo;
mod gui;
mod pman;
mod quic;

use std::fs::File;
use std::net::SocketAddr;
use std::str::FromStr;
use bunt::println;
use clap::{Parser, Subcommand};
use config::{Config, FileFormat, Source};
use log::{debug, info};
use pman::{init_process_manager, ProcessCommand, ProcessManager};
use shadow_rs::shadow;
use std::sync::{Arc, Mutex, OnceLock};
use tokio::{signal, sync::mpsc::Sender};
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
use trust_dns_resolver::{Resolver, TokioAsyncResolver};

shadow!(build);

static PMAN_SENDER: OnceLock<Sender<ProcessCommand>> = OnceLock::new();

/// Simple program to greet a person
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
    /// Config File to load
    #[arg(short, long)]
    config: Option<String>,

    /// Number of times to greet
    //#[arg(short, long, default_value_t = 1)]
    //count: u8,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Debug, Subcommand)]
enum Commands {
    #[command(about = "Start client without GUI")]
    CliClient,
    #[command(about = "List compile time backed info to audit binary")]
    Shadow,
    #[command(about = "Start client as GUI")]
    GuiClient,
    Devtest,
}

fn config() -> &'static Config {
    static CONFIG: OnceLock<Config> = OnceLock::new();
    CONFIG.get_or_init(|| {
        Config::builder()
            .add_source(config::Environment::with_prefix("HAI").separator("_"))
            .add_source(get_config_file_source())
            .build()
            .unwrap()
    })
}

static CONFIG_FILE: OnceLock<Option<String>> = OnceLock::new();

fn get_config_file_source() -> impl Source {
    let file = CONFIG_FILE.get();
    let default_dir = dirs::config_dir().unwrap();
    let file_buf = default_dir.join("hai").join("config.toml");
    println!("{}", file_buf.to_string_lossy());
    let file_content = std::fs::read_to_string(file_buf).unwrap();
    config::File::from_str(&*file_content, FileFormat::Toml)
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {

    env_logger::init();
    let args = Args::parse();
    CONFIG_FILE.get_or_init(|| {
        args.config
    });

    rustls::crypto::aws_lc_rs::default_provider().install_default().expect("Couldnt install rustls crypto into process");

    let _ = init_process_manager();

    match args.command {
        Commands::CliClient => {
            let host = config().get_string("remote_host")?;
            let port = config().get::<u16>("remote_port")?;
            let resolver = TokioAsyncResolver::tokio(
                ResolverConfig::quad9_tls(),
                ResolverOpts::default(),
            );
            let response = resolver.lookup_ip(&host).await?;
            let ip_addr = response.iter().next().expect("no addresses returned!");
            let ip_sock = SocketAddr::new(ip_addr, port);
            let client_endpoint = quic::client::make_client_endpoint(ip_sock.clone(), None).unwrap();
            let client = client_endpoint.connect(ip_sock, &host)?.await?;
            println!("[client] connected: addr={}", client.remote_address());
        }

        Commands::Shadow => {
            bininfo::print_info();
            return Ok(());
        }

        Commands::GuiClient => {
            let res = gui::gui_main();
            if let Err(e) = res {
                println!("{}", e);
            }
            return Ok(());
        }

        Commands::Devtest => {
            PMAN_SENDER.get().unwrap().send(ProcessCommand::SpawnShellCmd {
                cmd: "sleep 100 && echo hello meow".to_string(),
            }).await.expect("TODO: panic message");
            tokio::select! {
                _ = signal::ctrl_c() => {
                    info!("Ctrl-c received");
                    let sender = PMAN_SENDER.get().unwrap();
                    let _ = sender.send(ProcessCommand::Shutdown).await;
                }
            }
        }
    };

    //handling anything here for gui wont work
    println!("exit");
    Ok(())
}