#[macro_use] extern crate rust_i18n; mod audio; mod autostart; mod bridge; mod capture; mod config; mod doctor; mod i18n; mod inhibit; mod input; mod launcher; mod protocol; mod proxy; mod session; mod terminal; mod tray; mod uninstall; mod upstream; mod video; mod wallpaper; mod wine; mod wol; use anyhow::Result; use clap::{Parser, Subcommand, ValueEnum}; // Locale catalogs are embedded from `locales/` at the crate root. i18n!("locales", fallback = "en"); /// Native Linux companion for NetEase UU Remote. /// /// uur runs the official Windows client inside a managed Wine prefix and /// bridges its input and screen capture onto the real Linux desktop through /// X11 XTest or the Wayland RemoteDesktop portal. #[derive(Parser)] #[command(name = "uur", version, about, arg_required_else_help = true)] struct Cli { #[command(subcommand)] command: Command, } #[derive(Subcommand)] enum Command { /// One-time provisioning: EULA gate, Wine prefix, official client download. Setup { /// Accept the NetEase UU Remote EULA non-interactively. #[arg(long)] accept_eula: bool, /// Update the existing Wine prefix, retry Wine components, and repair an incomplete client installation. #[arg(long)] repair: bool, }, /// Print the live environment report (sessions, wine, portals, backends). Doctor, /// Print the current X11 pointer position (verification helper). Pointer, /// Capture the desktop through the ScreenCast portal (video path). Capture, /// Start a full session: capture + bridge + the managed client. Run, /// Stop every uur-owned process and the managed Wine prefix. Stop, /// Remove this user's integration and source installation; optionally erase all managed data. Uninstall { /// Delete the managed Wine prefix, account data, installer cache, configuration and logs. #[arg(long)] purge: bool, /// Show the exact removal plan without stopping processes or changing files. #[arg(long)] dry_run: bool, /// Confirm removal without an interactive prompt. #[arg(long)] yes: bool, }, /// Manage optional XDG login autostart. Autostart { #[command(subcommand)] action: AutostartAction, }, /// Inspect or configure host Wake-on-LAN. Wol { #[command(subcommand)] action: WolAction, }, /// Select the portal capture source used on Wayland. Display { #[command(subcommand)] action: DisplayAction, }, /// Internal input bridge process. Not part of the public CLI. #[command(hide = true, name = "__bridge")] InternalBridge, /// Internal capture process. Not part of the public CLI. #[command(hide = true, name = "__capture")] InternalCapture, /// Internal native PTY bridge. Not part of the public CLI. #[command(hide = true, name = "__terminal")] InternalTerminal, /// Internal Linux wallpaper synchronizer. Not part of the public CLI. #[command(hide = true, name = "__wallpaper")] InternalWallpaper, /// Internal desktop suspend/idle inhibitor. Not part of the public CLI. #[command(hide = true, name = "__inhibit")] InternalInhibit, /// Internal native desktop tray. Not part of the public CLI. #[command(hide = true, name = "__tray")] InternalTray, /// Internal authenticated XDG application launcher. #[command(hide = true, name = "__launcher")] InternalLauncher, /// Query NetEase's official release feed. Upstream { #[command(subcommand)] action: UpstreamAction, }, } #[derive(Subcommand)] enum UpstreamAction { /// Print the latest official UU Remote release known to NetEase. Check, } #[derive(Subcommand)] enum AutostartAction { /// Start the managed session after graphical login. Enable, /// Remove the login autostart entry. Disable, /// Report whether login autostart is enabled. Status, } #[derive(Subcommand)] enum WolAction { /// Report the selected physical wired adapter and Magic Packet state. Status { #[arg(long)] interface: Option, }, /// Enable Magic Packet wake for the adapter and its NetworkManager profile. Enable { #[arg(long)] interface: Option, }, /// Disable Magic Packet wake for the adapter and its NetworkManager profile. Disable { #[arg(long)] interface: Option, }, } #[derive(Subcommand)] enum DisplayAction { /// Show the configured source type. Status, /// Use a monitor, one window, or a portal-provided virtual display. Source { source: DisplaySource }, /// Choose portal capture, or explicitly enable direct Wayland monitor capture. Backend { backend: CaptureBackend, /// Name from `uur display outputs`; required if more than one output is present. #[arg(long)] output: Option, }, /// List native Wayland outputs without capturing their content. Outputs, } #[derive(Clone, ValueEnum)] enum CaptureBackend { Portal, Wayland, } #[derive(Clone, ValueEnum)] enum DisplaySource { Monitor, Window, Virtual, } impl DisplaySource { fn as_str(&self) -> &'static str { match self { Self::Monitor => "monitor", Self::Window => "window", Self::Virtual => "virtual", } } } fn main() -> Result<()> { // CLI output is routinely piped; a closed pipe is not an error. unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL); } i18n::init(); let cli = Cli::parse(); match cli.command { Command::Setup { accept_eula, repair, } => wine::setup(accept_eula, repair), Command::Doctor => doctor::report(), Command::Pointer => bridge::print_pointer(), Command::Capture => capture::run_standalone(), Command::Run => session::start(), Command::Stop => session::stop(), Command::Uninstall { purge, dry_run, yes, } => uninstall::run(purge, dry_run, yes), Command::Autostart { action } => match action { AutostartAction::Enable => autostart::enable(), AutostartAction::Disable => autostart::disable(), AutostartAction::Status => autostart::status(), }, Command::Wol { action } => match action { WolAction::Status { interface } => wol::status(interface.as_deref()), WolAction::Enable { interface } => wol::configure(interface.as_deref(), true), WolAction::Disable { interface } => wol::configure(interface.as_deref(), false), }, Command::Display { action } => { if matches!(action, DisplayAction::Outputs) { return capture::list_wayland_outputs(); } let mut config = config::Config::load()?; match action { DisplayAction::Status => { println!("{}", t!("display.status", source = config.capture_source)); println!("capture backend: {}", config.capture_backend); if let Some(output) = &config.capture_output { println!("output: {output}"); } Ok(()) } DisplayAction::Backend { backend, output } => { config.capture_backend = match backend { CaptureBackend::Portal => "portal", CaptureBackend::Wayland => "wayland", } .into(); config.capture_output = output; if config.capture_backend == "wayland" { config.capture_source = "monitor".into(); } config.capture_restore_token = None; config.remote_desktop_restore_token = None; config.store()?; println!( "{}", if config.capture_backend == "wayland" { t!("capture.direct_enabled").to_string() } else { t!("capture.portal_enabled").to_string() } ); Ok(()) } DisplayAction::Outputs => unreachable!(), DisplayAction::Source { source } => { config.capture_source = source.as_str().to_string(); config.capture_restore_token = None; config.remote_desktop_restore_token = None; config.store()?; println!("{}", t!("display.changed", source = source.as_str())); Ok(()) } } } Command::InternalBridge => bridge::serve(), Command::InternalCapture => capture::run(), Command::InternalTerminal => terminal::serve(), Command::InternalWallpaper => wallpaper::serve(), Command::InternalInhibit => inhibit::serve(), Command::InternalTray => tray::serve(), Command::InternalLauncher => launcher::serve(), Command::Upstream { action: UpstreamAction::Check, } => upstream::check(), } }