v0.11.6

build(deps): bump reqwest from 0.12.28 to 0.13.2

.github/workflows/lint.yml

@@ -15,7 +15,7 @@ jobs:
             os: ubuntu-latest
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install stable toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -23,7 +23,7 @@ jobs:
           target: ${{ matrix.target }}
 
       - name: Cache dependencies
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             ~/.cargo/registry
@@ -46,7 +46,7 @@ jobs:
             os: ubuntu-latest
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install stable toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -54,7 +54,7 @@ jobs:
           target: ${{ matrix.target }}
 
       - name: Cache dependencies
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             ~/.cargo/registry
@@ -77,7 +77,7 @@ jobs:
             os: ubuntu-latest
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install stable toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -86,7 +86,7 @@ jobs:
           components: rustfmt, clippy
 
       - name: Cache dependencies
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: |
             ~/.cargo/registry

.github/workflows/release.yml

@@ -9,8 +9,8 @@ jobs:
   create-release:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: taiki-e/create-gh-release-action@v1.9.1
+      - uses: actions/checkout@v6
+      - uses: taiki-e/create-gh-release-action@v1.9.2
         with:
           draft: true
           token: ${{ secrets.GITHUB_TOKEN }}
@@ -29,8 +29,8 @@ jobs:
             os: windows-latest
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4
-      - uses: taiki-e/upload-rust-binary-action@v1.26.0
+      - uses: actions/checkout@v6
+      - uses: taiki-e/upload-rust-binary-action@v1.28.0
         with:
           target: ${{ matrix.target }}
           bin: alterware-launcher

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "alterware-launcher"
-version = "0.11.3"
+version = "0.11.6"
 edition = "2021"
 build = "res/build.rs"
 
@@ -18,12 +18,12 @@ rand = "0.9"
 semver = "1.0"
 colored = "3.0"
 once_cell = "1.21"
-reqwest = { version = "0.12", features = ["stream"] }
+reqwest = { version = "0.13", features = ["stream"] }
 futures-util = "0.3"
 futures = "0.3"
-indicatif = "0.17"
-tokio = { version="1.45", features = ["rt-multi-thread", "macros"] }
-simple-log = "2.3"
+indicatif = "0.18"
+tokio = { version="1.47", features = ["rt-multi-thread", "macros"] }
+simple-log = "2.4"
 walkdir = "2.5"
 
 [target.'cfg(unix)'.dependencies]
@@ -37,11 +37,11 @@ self-replace = "1.5"
 
 [build-dependencies]
 winresource = "0.1"
-static_vcruntime = "2.0"
+static_vcruntime = "3.0"
 
 [dev-dependencies]
 strip-ansi-escapes = "0.2"
-serial_test = "3.2"
+serial_test = "3.4"
 
 [package.metadata.winresource]
 OriginalFilename = "alterware-launcher.exe"

README.md

@@ -146,11 +146,8 @@
   - Install or reinstall redistributables
 - ```--prerelease```
   - Update to prerelease version of the launcher
-- ```--rate```
-  - Rate and display CDN servers
 - ```--cdn-url```
 - ```--offline```
-- ```--skip-connectivity-check```
 
 
 ##### Example:
@@ -175,7 +172,6 @@ alterware-launcher.exe iw6 --bonus -u --path "C:\Games\IW6x" --pass "-headless"
 - `prerelease`: Update to prerelease version of clients and launcher. Default: `false`.
 - `cdn_url`
 - `offline`
-- `skip-connectivity-check`
 
 ---
 

src/cdn.rs

@@ -6,93 +6,19 @@ use std::time::Duration;
 
 static CURRENT_CDN: Mutex<Option<Arc<Server>>> = Mutex::new(None);
 
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Region {
-    Africa,
-    Asia,
-    Europe,
-    NorthAmerica,
-    Oceania,
-    SouthAmerica,
-    Global,
-    Unknown,
-}
-
-impl Region {
-    pub fn from_str(region_str: &str) -> Self {
-        match region_str {
-            "Africa" => Region::Africa,
-            "Asia" => Region::Asia,
-            "Europe" => Region::Europe,
-            "NorthAmerica" => Region::NorthAmerica,
-            "Oceania" => Region::Oceania,
-            "SouthAmerica" => Region::SouthAmerica,
-            _ => Region::Unknown,
-        }
-    }
-
-    pub fn coordinates(&self) -> Option<(f64, f64)> {
-        match self {
-            Region::Europe => Some((54.0, 15.0)),
-            Region::Asia => Some((35.0, 105.0)),
-            Region::NorthAmerica => Some((45.0, -100.0)),
-            Region::SouthAmerica => Some((-15.0, -60.0)),
-            Region::Africa => Some((0.0, 20.0)),
-            Region::Oceania => Some((-25.0, 140.0)),
-            Region::Global => None,
-            Region::Unknown => None,
-        }
-    }
-
-    pub fn distance_to(&self, other: Region) -> f64 {
-        if *self == Region::Global || other == Region::Global {
-            return 0.0;
-        }
-
-        if *self == other {
-            return 0.0;
-        }
-
-        let (lat1, lon1) = match self.coordinates() {
-            Some(coords) => coords,
-            None => return 20000.0,
-        };
-
-        let (lat2, lon2) = match other.coordinates() {
-            Some(coords) => coords,
-            None => return 20000.0,
-        };
-
-        // haversine
-        let r = 6371.0;
-        let d_lat = (lat2 - lat1).to_radians();
-        let d_lon = (lon2 - lon1).to_radians();
-        let lat1_rad = lat1.to_radians();
-        let lat2_rad = lat2.to_radians();
-
-        let a = (d_lat / 2.0).sin().powi(2)
-            + lat1_rad.cos() * lat2_rad.cos() * (d_lon / 2.0).sin().powi(2);
-        let c = 2.0 * a.sqrt().atan2((1.0 - a).sqrt());
-
-        r * c
-    }
-}
-
 #[derive(Clone, Copy, Debug)]
 pub struct Server {
     pub host: &'static str,
     pub rating: u8,
     pub latency: Option<std::time::Duration>,
-    pub region: Region,
 }
 
 impl Server {
-    pub const fn new(host: &'static str, region: Region) -> Self {
+    pub const fn new(host: &'static str) -> Self {
         Server {
             host,
             rating: 255,
             latency: None,
-            region,
         }
     }
 
@@ -100,7 +26,7 @@ impl Server {
         format!("https://{}/", self.host)
     }
 
-    async fn rate(&mut self, asn: u32, user_region: Region, is_initial: bool) {
+    async fn rate(&mut self, asn: u32, is_initial: bool) {
         let timeout = if is_initial {
             Duration::from_millis(1000)
         } else {
@@ -109,16 +35,15 @@ impl Server {
         match http::rating_request(&self.url(), timeout).await {
             Ok((latency, is_cloudflare)) => {
                 self.latency = Some(latency);
-                self.rating = self.calculate_rating(latency, is_cloudflare, asn, user_region);
+                self.rating = self.calculate_rating(latency, is_cloudflare, asn);
 
                 info!(
-                    "Server {} rated {} ({}ms, rating: {}, cloudflare: {}, region: {:?})",
+                    "Server {} rated {} ({}ms, rating: {}, cloudflare: {})",
                     self.host,
                     self.rating,
                     latency.as_millis(),
                     self.rating,
                     is_cloudflare,
-                    self.region
                 );
             }
             Err(e) => {
@@ -147,13 +72,7 @@ impl Server {
         rating.clamp(1.0, 255.0) as u8
     }
 
-    fn calculate_rating(
-        &self,
-        latency: std::time::Duration,
-        is_cloudflare: bool,
-        asn: u32,
-        user_region: Region,
-    ) -> u8 {
+    fn calculate_rating(&self, latency: std::time::Duration, is_cloudflare: bool, asn: u32) -> u8 {
         let mut rating = self.rate_latency(latency);
 
         // Additional factors for full rating
@@ -165,25 +84,6 @@ impl Server {
             }
         }
 
-        let distance_km = user_region.distance_to(self.region);
-        let region_multiplier = if self.region == Region::Global {
-            1.4
-        } else if distance_km == 0.0 {
-            1.3
-        } else if user_region == Region::Unknown {
-            1.0
-        } else if distance_km <= 2000.0 {
-            1.25
-        } else if distance_km <= 5000.0 {
-            1.15
-        } else if distance_km <= 10000.0 {
-            1.05
-        } else {
-            1.0
-        };
-
-        rating = (rating as f32 * region_multiplier).min(255.0) as u8;
-
         rating
     }
 }
@@ -198,23 +98,13 @@ impl Hosts {
     pub async fn new() -> Self {
         let cdn_hosts = crate::global::CDN_HOSTS.to_vec();
 
-        let mut hosts = Hosts {
+        let hosts = Hosts {
             servers: cdn_hosts,
             active_index: RwLock::new(None),
         };
 
-        let (asn, region_str) = crate::http::get_location_info().await;
-        let user_region = Region::from_str(&region_str);
-        info!(
-            "Detected user region as {:?} (region: {})",
-            user_region, region_str
-        );
-
-        hosts.rate(asn, user_region, true).await;
-
         if hosts.servers.iter().all(|server| server.rating == 0) {
             info!("All CDN servers failed with 1000ms timeout, retrying with 5000ms timeout");
-            hosts.rate(asn, user_region, false).await;
         }
 
         hosts
@@ -250,11 +140,11 @@ impl Hosts {
     }
 
     /// rate and order all servers, then select the best one
-    pub async fn rate(&mut self, asn: u32, user_region: Region, is_initial: bool) {
+    pub async fn rate(&mut self, asn: u32, is_initial: bool) {
         let rating_futures: Vec<_> = self
             .servers
             .iter_mut()
-            .map(|server| server.rate(asn, user_region, is_initial))
+            .map(|server| server.rate(asn, is_initial))
             .collect();
 
         join_all(rating_futures).await;
@@ -270,61 +160,3 @@ impl Hosts {
         self.active_url()
     }
 }
-
-/// CDN rating function for --rate flag
-pub async fn rate_cdns_and_display() {
-    use colored::Colorize;
-
-    let (asn, region_str) = crate::http::get_location_info().await;
-    let user_region = Region::from_str(&region_str);
-
-    if user_region == Region::Unknown {
-        println!(
-            "User region: {} (using Global server preference)",
-            "Unknown".bright_red()
-        );
-    } else {
-        println!("User region: {user_region:?}");
-    }
-
-    println!("Rating CDNs...");
-
-    let cdn_hosts = crate::global::CDN_HOSTS.to_vec();
-
-    let mut hosts = Hosts {
-        servers: cdn_hosts,
-        active_index: RwLock::new(None),
-    };
-
-    hosts.rate(asn, user_region, true).await;
-
-    if hosts.servers.iter().all(|server| server.rating == 0) {
-        println!("Retrying with longer timeout...");
-        hosts.rate(asn, user_region, false).await;
-    }
-
-    println!();
-    for server in hosts.servers.iter() {
-        let latency_str = server
-            .latency
-            .map_or("timeout".to_string(), |l| format!("{} ms", l.as_millis()));
-
-        println!(
-            "{}: rating {}, latency {}",
-            server.host.bright_white(),
-            server.rating.to_string().bright_cyan(),
-            latency_str
-        );
-    }
-
-    // Show selected CDN
-    if hosts.next() {
-        if let Some(best_url) = hosts.active_url() {
-            println!();
-            println!("Selected: {}", best_url.bright_green());
-        }
-    } else {
-        println!();
-        println!("{}", "No available CDN servers".bright_red());
-    }
-}

src/github.rs

@@ -66,7 +66,7 @@ pub async fn latest_version(
     let tag = latest_tag(owner, repo, prerelease).await?;
     let cleaned_tag = tag.replace('v', "");
     Version::parse(&cleaned_tag)
-        .map_err(|e| format!("Failed to parse version '{}': {}", cleaned_tag, e).into())
+        .map_err(|e| format!("Failed to parse version '{cleaned_tag}': {e}").into())
 }
 
 pub fn download_url(owner: &str, repo: &str, tag: Option<&str>) -> String {

src/global.rs

@@ -6,18 +6,13 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Mutex;
 
-use crate::cdn::{Hosts, Region, Server};
+use crate::cdn::{Hosts, Server};
 
 pub const GH_OWNER: &str = "alterware";
 pub const GH_REPO: &str = "alterware-launcher";
 pub const DEFAULT_MASTER: &str = "https://cdn.alterware.ovh";
 
-pub const CDN_HOSTS: [Server; 2] = [
-    Server::new("cdn.alterware.ovh", Region::Global),
-    Server::new("us-cdn.alterware.ovh", Region::NorthAmerica),
-];
-
-pub const IP2ASN: &str = "https://ip2asn.getserve.rs/v1/as/ip/self";
+pub const CDN_HOSTS: [Server; 1] = [Server::new("cdn.alterware.ovh")];
 
 pub static USER_AGENT: Lazy<String> = Lazy::new(|| {
     format!(
@@ -31,8 +26,6 @@ pub static USER_AGENT: Lazy<String> = Lazy::new(|| {
 
 pub static MASTER_URL: Lazy<Mutex<String>> = Lazy::new(|| Mutex::new(String::from(DEFAULT_MASTER)));
 
-pub static IS_OFFLINE: Lazy<Mutex<bool>> = Lazy::new(|| Mutex::new(false));
-
 pub static PREFIXES: Lazy<HashMap<&'static str, PrintPrefix>> = Lazy::new(|| {
     HashMap::from([
         (
@@ -79,54 +72,3 @@ pub static PREFIXES: Lazy<HashMap<&'static str, PrintPrefix>> = Lazy::new(|| {
         ),
     ])
 });
-
-pub async fn check_connectivity_and_rate_cdns() -> Pin<Box<dyn Future<Output = bool> + Send>> {
-    Box::pin(async move {
-        crate::println_info!("Initializing CDN rating system...");
-        let hosts = Hosts::new().await;
-        let best_cdn = hosts.get_master_url();
-
-        if let Some(cdn_url) = best_cdn {
-            let cdn_url = cdn_url.trim_end_matches('/');
-            *MASTER_URL.lock().unwrap() = cdn_url.to_string();
-            crate::println_info!("Selected CDN: {}", cdn_url);
-
-            match crate::http_async::get_body_string(cdn_url).await {
-                Ok(_) => {
-                    info!("Successfully connected to CDN: {}", cdn_url);
-                    true
-                }
-                Err(e) => {
-                    error!("Failed to connect to selected CDN {}: {}", cdn_url, e);
-                    *IS_OFFLINE.lock().unwrap() = true;
-                    false
-                }
-            }
-        } else {
-            crate::println_error!("No CDN hosts are available");
-            *IS_OFFLINE.lock().unwrap() = true;
-            false
-        }
-    })
-}
-
-pub fn check_connectivity(
-    master_url: Option<String>,
-) -> Pin<Box<dyn Future<Output = bool> + Send>> {
-    Box::pin(async move {
-        if let Some(url) = master_url {
-            *MASTER_URL.lock().unwrap() = url.clone();
-            crate::println_info!("Using fallback connectivity check on {}", url);
-
-            match crate::http_async::get_body_string(&url).await {
-                Ok(_) => true,
-                Err(_) => {
-                    *IS_OFFLINE.lock().unwrap() = true;
-                    false
-                }
-            }
-        } else {
-            check_connectivity_and_rate_cdns().await.await
-        }
-    })
-}

src/http.rs

@@ -1,5 +1,4 @@
 use reqwest::header::HeaderMap;
-use serde_json::Value;
 use simple_log::*;
 use std::time::{Duration, Instant};
 
@@ -17,18 +16,18 @@ pub async fn quick_request(url: &str) -> Result<String, Box<dyn std::error::Erro
         .await;
 
     if let Err(e) = &res {
-        error!("Failed to get {}: {}", url, e);
-        return Err(format!("Failed to get {} {}", url, e).into());
+        error!("Failed to get {url}: {e}");
+        return Err(format!("Failed to get {url} {e}").into());
     }
 
     let res = res.unwrap();
     match res.text().await {
         Ok(text) => {
-            info!("Successfully received response from: {}", url);
+            info!("Successfully received response from: {url}");
             Ok(text)
         }
         Err(e) => {
-            warn!("Failed to get response text from {}: {}", url, e);
+            warn!("Failed to get response text from {url}: {e}");
             Err(e.into())
         }
     }
@@ -64,8 +63,8 @@ pub async fn rating_request(
     let latency = start.elapsed();
 
     if let Err(e) = &res {
-        error!("Failed to get {}: {} (after {:?})", url, e, latency);
-        return Err(format!("Failed to get {} {} (after {:?})", url, e, latency).into());
+        error!("Failed to get {url}: {e} (after {latency:?})");
+        return Err(format!("Failed to get {url} {e} (after {latency:?})").into());
     }
 
     let res = res.unwrap();
@@ -74,36 +73,10 @@ pub async fn rating_request(
 
     // We don't need the response body for rating
     if let Err(e) = res.text().await {
-        warn!(
-            "Failed to get response text from {}: {} (after {:?})",
-            url, e, latency
-        );
+        warn!("Failed to get response text from {url}: {e} (after {latency:?})");
         return Err(e.into());
     }
 
-    info!(
-        "Successfully rated {} in {:?} (cloudflare: {})",
-        url, latency, is_cloudflare
-    );
+    info!("Successfully rated {url} in {latency:?} (cloudflare: {is_cloudflare})");
     Ok((latency, is_cloudflare))
 }
-
-/// Retrieve client ASN and region
-pub async fn get_location_info() -> (u32, String) {
-    let response = quick_request(crate::global::IP2ASN).await;
-    if let Ok(as_data_str) = response {
-        if let Ok(as_data) = serde_json::from_str::<Value>(&as_data_str) {
-            let as_number = as_data
-                .get("as_number")
-                .and_then(|v| v.as_u64())
-                .unwrap_or(0) as u32;
-            let region = as_data
-                .get("region")
-                .and_then(|v| v.as_str())
-                .unwrap_or("Unknown")
-                .to_string();
-            return (as_number, region);
-        }
-    }
-    (0, "Unknown".to_string())
-}

src/http_async.rs

@@ -32,10 +32,14 @@ pub async fn download_file_progress(
         .send()
         .await
         .map_err(|e| {
-            error!("Failed to GET from '{}': {}", url, e);
+            error!("Failed to GET from '{url}': {e}");
             format!("Failed to GET from '{url}'")
         })?;
 
+    if !res.status().is_success() {
+        return Err(format!("Request failed with status: {}", res.status()));
+    }
+
     let total_size = res.content_length().unwrap_or(size);
     debug!("Download size: {}", misc::human_readable_bytes(total_size));
     pb.set_length(total_size);
@@ -89,14 +93,18 @@ pub async fn get_body(url: &str) -> Result<Vec<u8>, String> {
         )
         .send()
         .await
-        .map_err(|e| format!("Failed to send request: {}", e))?;
+        .map_err(|e| format!("Failed to send request: {e}"))?;
 
     debug!("{} {url}", res.status());
 
+    if !res.status().is_success() {
+        return Err(format!("Request failed with status: {}", res.status()));
+    }
+
     res.bytes()
         .await
         .map(|b| b.to_vec())
-        .map_err(|e| format!("Failed to get body: {}", e))
+        .map_err(|e| format!("Failed to get body: {e}"))
 }
 
 pub async fn get_body_string(url: &str) -> Result<String, String> {
@@ -119,7 +127,7 @@ pub async fn get_json<T: serde::de::DeserializeOwned>(url: &str) -> Result<T, St
         .header("Accept", "application/json")
         .send()
         .await
-        .map_err(|e| format!("Failed to send request: {}", e))?;
+        .map_err(|e| format!("Failed to send request: {e}"))?;
 
     debug!("{} {}", res.status(), url);
 
@@ -130,7 +138,7 @@ pub async fn get_json<T: serde::de::DeserializeOwned>(url: &str) -> Result<T, St
     let body = res
         .bytes()
         .await
-        .map_err(|e| format!("Failed to read response body: {}", e))?;
+        .map_err(|e| format!("Failed to read response body: {e}"))?;
 
-    serde_json::from_slice::<T>(&body).map_err(|e| format!("Failed to parse JSON: {}", e))
+    serde_json::from_slice::<T>(&body).map_err(|e| format!("Failed to parse JSON: {e}"))
 }

src/main.rs

@@ -626,8 +626,6 @@ async fn main() {
         println!("    --redist: (Re-)Install redistributables");
         println!("    --prerelease: Update to prerelease version of clients and launcher");
         println!("    --offline: Run in offline mode");
-        println!("    --skip-connectivity-check: Don't check connectivity");
-        println!("    --rate: Display CDN rating information and exit");
         println!("\nExample:\n    alterware-launcher.exe iw6 --pass \"-headless\"");
         return;
     }
@@ -663,11 +661,6 @@ async fn main() {
         install_path = env::current_dir().unwrap();
     }
 
-    if arg_bool(&args, "--rate") {
-        cdn::rate_cdns_and_display().await;
-        return;
-    }
-
     let mut cfg = config::load(install_path.join("alterware-launcher.json"));
 
     if let Some(cdn_url) = arg_value(&args, "--cdn-url") {
@@ -680,11 +673,6 @@ async fn main() {
         arg_remove(&mut args, "--offline");
     }
 
-    if arg_bool(&args, "--skip-connectivity-check") {
-        cfg.skip_connectivity_check = true;
-        arg_remove(&mut args, "--skip-connectivity-check");
-    }
-
     let initial_cdn = if !cfg.cdn_url.is_empty() {
         info!("Using custom CDN URL: {}", cfg.cdn_url);
         Some(cfg.cdn_url.clone())
@@ -692,14 +680,6 @@ async fn main() {
         None
     };
 
-    if !cfg.offline && !cfg.skip_connectivity_check {
-        if initial_cdn.is_some() {
-            cfg.offline = !global::check_connectivity(initial_cdn).await;
-        } else {
-            cfg.offline = !global::check_connectivity_and_rate_cdns().await.await;
-        }
-    }
-
     if cfg.offline {
         // Check if this is a first-time run (no stored data)
         let stored_data = cache::get_stored_data();
@@ -763,9 +743,9 @@ async fn main() {
             std::process::exit(1);
         };
 
-        info!("Launching game in offline mode with client: {}", client);
+        info!("Launching game in offline mode with client: {client}");
         // Launch game without updates
-        launch(&install_path.join(format!("{}.exe", client)), &cfg.args);
+        launch(&install_path.join(format!("{client}.exe")), &cfg.args);
         return;
     }
 

src/misc.rs

@@ -41,7 +41,7 @@ pub fn is_program_in_path(program: &str) -> bool {
             paths.to_str().map(|paths| {
                 paths
                     .split(':')
-                    .any(|dir| fs::metadata(format!("{}/{}", dir, program)).is_ok())
+                    .any(|dir| fs::metadata(format!("{dir}/{program}")).is_ok())
             })
         })
         .unwrap_or(false)
@@ -53,9 +53,9 @@ pub fn is_program_in_path(program: &str) -> bool {
         .and_then(|paths| {
             paths.to_str().map(|paths| {
                 paths.split(';').any(|dir| {
-                    fs::metadata(format!("{}\\{}.exe", dir, program)).is_ok()
-                        || fs::metadata(format!("{}\\{}.cmd", dir, program)).is_ok()
-                        || fs::metadata(format!("{}\\{}.bat", dir, program)).is_ok()
+                    fs::metadata(format!("{dir}\\{program}.exe")).is_ok()
+                        || fs::metadata(format!("{dir}\\{program}.cmd")).is_ok()
+                        || fs::metadata(format!("{dir}\\{program}.bat")).is_ok()
                 })
             })
         })

src/self_update.rs

@@ -15,7 +15,7 @@ pub async fn self_update_available(prerelease: Option<bool>) -> bool {
     let latest_version = match github::latest_version(GH_OWNER, GH_REPO, prerelease).await {
         Ok(v) => v,
         Err(e) => {
-            error!("Failed to get latest version: {}", e);
+            error!("Failed to get latest version: {e}");
             return false;
         }
     };
@@ -93,7 +93,7 @@ pub async fn run(update_only: bool, prerelease: Option<bool>) {
             "alterware-launcher.exe"
         };
 
-        http_async::download_file(
+        if let Err(e) = http_async::download_file(
             &format!(
                 "{}/download/{}",
                 github::download_url(GH_OWNER, GH_REPO, None),
@@ -102,7 +102,11 @@ pub async fn run(update_only: bool, prerelease: Option<bool>) {
             &file_path,
         )
         .await
-        .unwrap();
+        {
+            error!("Self-update download failed: {e}");
+            crate::println_error!("Self-update failed ({e}), skipping update.");
+            return;
+        }
 
         if !file_path.exists() {
             crate::println_error!("Failed to download launcher update.");

src/structs.rs

@@ -54,8 +54,6 @@ pub struct Config {
     pub cdn_url: String,
     #[serde(default)]
     pub offline: bool,
-    #[serde(default)]
-    pub skip_connectivity_check: bool,
 }
 
 impl Default for Config {
@@ -73,7 +71,6 @@ impl Default for Config {
             prerelease: false,
             cdn_url: String::default(),
             offline: false,
-            skip_connectivity_check: false,
         }
     }
 }