feat(cli): implement command line interface and app initialization

Author: Itsusinn

crates/wind/Cargo.toml

@@ -3,5 +3,34 @@ name = "wind"
 version.workspace = true
 repository.workspace = true
 edition.workspace = true
-description.workspace = true
-license = "AGPL-3.0-or-later"
+description = "A proxy tool written in Rust"
+license = "AGPL-3.0-or-later"
+
+[dependencies]
+wind-core = { version = "0.1.1", path = "../wind-core"}
+wind-socks = { version = "0.1.1", path = "../wind-socks"}
+wind-tuic = { version = "0.1.1", path = "../wind-tuic"}
+
+# Async
+tokio = { version = "1", features = ["rt-multi-thread", "signal", "net"] }
+tokio-util = { version = "0.7", features = ["rt"] }
+
+tracing = "0.1"
+
+clap = { version = "4", features = ["derive"] }
+clap_derive = { version = "4" }
+
+time = { version = "0.3", features = ["macros", "local-offset"] }
+tracing-subscriber = { version = "0.3", default-features = false, features = ["tracing-log", "std", "local-time","fmt", "ansi"] }
+const-str = "0.7"
+
+eyre = "0.6"
+uuid = { version = "1", features = ["serde"] }
+
+# Configuration
+figment = { version = "0.10", features = ["yaml", "env", "toml"] }
+serde = { version = "1", features = ["derive"] }
+serde_yaml = "0.9.34-deprecated"
+toml = "0.9"
+educe = { version = "0.6", features = ["Default"] }
+humantime-serde = "1"

crates/wind/src/cli.rs

@@ -0,0 +1,42 @@
+use std::path::PathBuf;
+
+use clap::{ArgAction, Parser, Subcommand};
+
+#[derive(Parser)]
+#[command(about, long_about = None)]
+pub struct Cli {
+	/// Set a custom config
+	#[arg(short, visible_short_alias = 'f', long, value_name = "FILE/BASE64-TEXT")]
+	pub config: Option<String>,
+
+	/// Set configuration directory
+	#[arg(short = 'C', visible_short_alias = 'd', long, value_name = "PATH")]
+	pub config_dir: Option<PathBuf>,
+
+	/// Set working directory
+	#[arg(short = 'D', long, value_name = "PATH")]
+	pub work_dir: Option<PathBuf>,
+
+	/// Show current version
+	#[arg(short = 'v', visible_short_alias = 'V', long, action = ArgAction::SetTrue)]
+	pub version: bool,
+
+	#[command(subcommand)]
+	pub command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+pub enum Commands {
+	/// Initialize a new default configuration file
+	Init {
+		/// Specify the configuration file format (yaml or toml)
+		#[arg(short, long, value_enum, default_value = "yaml")]
+		format: ConfigFormat,
+	},
+}
+
+#[derive(clap::ValueEnum, Clone, Debug)]
+pub enum ConfigFormat {
+	Yaml,
+	Toml,
+}

crates/wind/src/conf/mod.rs

@@ -0,0 +1,2 @@
+pub mod persistent;
+pub mod runtime;

crates/wind/src/conf/persistent.rs

@@ -0,0 +1,168 @@
+use std::{
+	net::{Ipv4Addr, SocketAddr},
+	path::PathBuf,
+	time::Duration,
+};
+
+use educe::Educe;
+use figment::{
+	Figment,
+	providers::{Env, Format, Toml, Yaml},
+};
+use serde::{Deserialize, Serialize};
+use wind_core::types::TargetAddr;
+use wind_socks::inbound::AuthMode;
+
+#[derive(Debug, Deserialize, Serialize, Educe)]
+#[educe(Default)]
+pub struct PersistentConfig {
+	pub socks_opt: SocksOpt,
+	pub tuic_opt: TuicOpt,
+}
+
+#[derive(Debug, Deserialize, Serialize, Educe)]
+#[educe(Default)]
+pub struct SocksOpt {
+	#[educe(Default(expression = "127.0.0.1:6666".parse().unwrap()))]
+	pub listen_addr: SocketAddr,
+
+	#[educe(Default = None)]
+	pub public_addr: Option<std::net::IpAddr>,
+
+	#[educe(Default = AuthModeConfig::NoAuth)]
+	pub auth: AuthModeConfig,
+
+	#[educe(Default = false)]
+	pub skip_auth: bool,
+
+	#[educe(Default = true)]
+	pub allow_udp: bool,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone, Educe)]
+#[educe(Default)]
+pub enum AuthModeConfig {
+	#[educe(Default)]
+	NoAuth,
+	Password {
+		username: String,
+		password: String,
+	},
+}
+
+impl From<AuthModeConfig> for AuthMode {
+	fn from(config: AuthModeConfig) -> Self {
+		match config {
+			AuthModeConfig::NoAuth => AuthMode::NoAuth,
+			AuthModeConfig::Password { username, password } => AuthMode::Password { username, password },
+		}
+	}
+}
+
+#[derive(Debug, Deserialize, Serialize, Educe)]
+#[educe(Default)]
+pub struct TuicOpt {
+	#[educe(Default = TargetAddr::IPv4(Ipv4Addr::new(127, 0, 0, 1), 9443))]
+	pub server_addr: TargetAddr,
+
+	#[educe(Default = "localhost")]
+	pub sni: String,
+
+	#[educe(Default = "c1e6dbe2-f417-4890-994c-9ee15b926597".parse().unwrap())]
+	pub uuid: uuid::Uuid,
+
+	#[educe(Default = "test_passwd")]
+	pub password: String,
+
+	#[educe(Default = false)]
+	pub zero_rtt_handshake: bool,
+
+	#[serde(with = "humantime_serde")]
+	#[educe(Default(expression = Duration::from_secs(10)))]
+	pub heartbeat: Duration,
+
+	#[serde(with = "humantime_serde")]
+	#[educe(Default(expression = Duration::from_secs(20)))]
+	pub gc_interval: Duration,
+
+	#[serde(with = "humantime_serde")]
+	#[educe(Default(expression = Duration::from_secs(20)))]
+	pub gc_lifetime: Duration,
+
+	#[educe(Default = true)]
+	pub skip_cert_verify: bool,
+
+	#[educe(Default(expression = vec![String::from("h3")]))]
+	pub alpn: Vec<String>,
+}
+
+impl PersistentConfig {
+	pub fn export_to_file(&self, file_path: &PathBuf, format: &str) -> eyre::Result<()> {
+		use std::{fs, io::Write};
+
+		match format.to_lowercase().as_str() {
+			"yaml" => {
+				let yaml_content = serde_yaml::to_string(&self)?;
+				let mut file = fs::File::create(file_path)?;
+				file.write_all(yaml_content.as_bytes())?;
+			}
+			"toml" => {
+				let toml_content = toml::to_string_pretty(&self)?;
+				let mut file = fs::File::create(file_path)?;
+				file.write_all(toml_content.as_bytes())?;
+			}
+			_ => return Err(eyre::eyre!("Unsupported file format: {}", format)),
+		}
+
+		Ok(())
+	}
+
+	pub fn load(config_path: Option<String>, config_dir: Option<PathBuf>) -> eyre::Result<Self> {
+		// Start with empty figment (will use default values via serde)
+		let mut figment = Figment::new();
+
+		// Load from default configuration location
+		if let Some(config_dir) = config_dir {
+			let config_file = config_dir.join("config.toml");
+			if config_file.exists() {
+				figment = figment.merge(Toml::file(config_file));
+			}
+
+			let config_file = config_dir.join("config.yaml");
+			if config_file.exists() {
+				figment = figment.merge(Yaml::file(config_file));
+			}
+		} else {
+			// Try to load from default locations in current directory
+			let config_toml = std::path::Path::new("config.toml");
+			if config_toml.exists() {
+				figment = figment.merge(Toml::file(config_toml));
+			}
+
+			let config_yaml = std::path::Path::new("config.yaml");
+			if config_yaml.exists() {
+				figment = figment.merge(Yaml::file(config_yaml));
+			}
+		}
+
+		// If specific config path is provided, use that
+		if let Some(config_path) = config_path {
+			if config_path.ends_with(".toml") {
+				figment = figment.merge(Toml::file(config_path));
+			} else if config_path.ends_with(".yaml") || config_path.ends_with(".yml") {
+				figment = figment.merge(Yaml::file(config_path));
+			} else {
+				// Assume it's TOML format
+				figment = figment.merge(Toml::file(config_path));
+			}
+		}
+
+		// Environment variables can override config files
+		figment = figment.merge(Env::prefixed("WIND_"));
+
+		// Extract the configuration
+		let config: PersistentConfig = figment.extract()?;
+
+		Ok(config)
+	}
+}

crates/wind/src/conf/runtime.rs

@@ -0,0 +1,33 @@
+use wind_socks::inbound::SocksInboundOpt;
+use wind_tuic::outbound::TuicOutboundOpts;
+
+use crate::{conf::persistent::PersistentConfig, util::target_addr_to_socket_addr};
+
+pub struct Config {
+	pub socks_opt: SocksInboundOpt,
+	pub tuic_opt: TuicOutboundOpts,
+}
+impl Config {
+	pub fn from_persist(config: PersistentConfig) -> Self {
+		Self {
+			socks_opt: SocksInboundOpt {
+				listen_addr: config.socks_opt.listen_addr,
+				public_addr: config.socks_opt.public_addr,
+				auth: config.socks_opt.auth.into(),
+				skip_auth: config.socks_opt.skip_auth,
+				allow_udp: config.socks_opt.allow_udp,
+			},
+			tuic_opt: TuicOutboundOpts {
+				peer_addr: target_addr_to_socket_addr(&config.tuic_opt.server_addr),
+				sni: config.tuic_opt.sni.clone(),
+				auth: (config.tuic_opt.uuid, config.tuic_opt.password.as_bytes().to_vec().into()),
+				zero_rtt_handshake: config.tuic_opt.zero_rtt_handshake,
+				heartbeat: config.tuic_opt.heartbeat,
+				gc_interval: config.tuic_opt.gc_interval,
+				gc_lifetime: config.tuic_opt.gc_lifetime,
+				skip_cert_verify: config.tuic_opt.skip_cert_verify,
+				alpn: config.tuic_opt.alpn.clone(),
+			},
+		}
+	}
+}

crates/wind/src/log.rs

@@ -0,0 +1,27 @@
+use time::macros::format_description;
+use tracing::{Level, level_filters::LevelFilter};
+use tracing_subscriber::{fmt::time::LocalTime, layer::SubscriberExt as _, util::SubscriberInitExt as _};
+
+pub fn init_log(level: Level) -> eyre::Result<()> {
+	let filter = tracing_subscriber::filter::Targets::new()
+		.with_targets(vec![
+			("wind", level),
+			("wind_core", level),
+			("wind_tuic", level),
+			("wind_socks", level),
+		])
+		.with_default(LevelFilter::INFO);
+	let registry = tracing_subscriber::registry();
+	registry
+		.with(filter)
+		.with(
+			tracing_subscriber::fmt::layer()
+				.with_target(true)
+				.with_timer(LocalTime::new(format_description!(
+					"[year repr:last_two]-[month]-[day] [hour]:[minute]:[second]"
+				))),
+		)
+		.try_init()?;
+
+	Ok(())
+}