chore: add more context info

Cargo.lock

@@ -4131,8 +4131,6 @@ dependencies = [
  "objc2-metal-performance-shaders",
  "objc2-metal-performance-shaders-graph",
  "once_cell",
- "rayon",
- "reqwest",
  "rustfft",
  "serde",
  "serde_json",
@@ -4181,7 +4179,6 @@ dependencies = [
  "rayon",
  "reqwest",
  "serde_json",
- "strum",
  "tempfile",
  "tokio",
  "tracing",

README.md

@@ -39,12 +39,12 @@ Koharu can be run in headless mode via command line.
 
 ```bash
 # macOS / Linux
-koharu -b 0.0.0.0:5003
+koharu --port 4000 --headless
 # Windows
-koharu.exe -b 0.0.0.0:5003
+koharu.exe --port 4000 --headless
 ```
 
-You can now access Koharu Web UI at `http://<your-server-ip>:5003`.
+You can now access Koharu Web UI at `http://<your-server-ip>:4000`.
 
 ### File association
 

koharu-ml/Cargo.toml

@@ -29,9 +29,7 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tokio = { workspace = true }
 rustfft = { workspace = true }
-reqwest = { workspace = true }
 once_cell = { workspace = true }
-rayon = { workspace = true }
 dirs = { workspace = true }
 futures = { workspace = true }
 num_cpus = { workspace = true }

koharu-runtime/Cargo.toml

@@ -24,7 +24,6 @@ futures = { workspace = true }
 once_cell = { workspace = true }
 libloading = { workspace = true }
 num_cpus = { workspace = true }
-strum = { workspace = true }
 csv = { workspace = true }
 flate2 = { workspace = true }
 

koharu-runtime/src/dylib.rs

@@ -5,7 +5,7 @@ use std::{
     sync::Arc,
 };
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use futures::stream::{self, StreamExt, TryStreamExt};
 use koharu_core::http::{http_client, http_download};
 use once_cell::sync::OnceCell;
@@ -13,7 +13,7 @@ use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use tokio::task;
 use tracing::debug;
 
-use crate::{pypi::PYPI_ENDPOINT, zip::fetch_record};
+use crate::zip::fetch_record;
 
 /// Keep handles to loaded dynamic libraries alive for process lifetime
 static DYLIB_HANDLES: OnceCell<Vec<libloading::Library>> = OnceCell::new();
@@ -226,9 +226,16 @@ fn current_platform_tags() -> Result<&'static [&'static str]> {
 
 async fn fetch_and_extract(pkg: &str, platform_tags: &[&str], out_dir: Arc<PathBuf>) -> Result<()> {
     // 1) Query PyPI JSON
-    let meta_url = format!("{}/pypi/{pkg}/json", *PYPI_ENDPOINT);
-    let resp = http_client().get(&meta_url).send().await?;
-    let json: serde_json::Value = resp.json().await?;
+    let meta_url = format!("https://pypi.org/pypi/{pkg}/json");
+    let resp = http_client()
+        .get(&meta_url)
+        .send()
+        .await
+        .context("failed to fetch package metadata")?;
+    let json: serde_json::Value = resp
+        .json()
+        .await
+        .context("failed to parse package metadata")?;
 
     // 2) Choose a wheel
     let files = json
@@ -239,7 +246,6 @@ async fn fetch_and_extract(pkg: &str, platform_tags: &[&str], out_dir: Arc<PathB
     for f in files {
         let filename = f.get("filename").and_then(|v| v.as_str()).unwrap_or("");
         let file_url = f.get("url").and_then(|v| v.as_str()).unwrap_or("");
-        let file_url = PYPI_ENDPOINT.refine_url(file_url);
 
         if !filename.ends_with(".whl") {
             continue;
@@ -253,7 +259,9 @@ async fn fetch_and_extract(pkg: &str, platform_tags: &[&str], out_dir: Arc<PathB
     debug!("{pkg}: selected wheel {wheel_name}");
 
     // 3) Use RECORD to check local dylibs; download only if needed
-    let entries = fetch_record(&wheel_url).await?;
+    let entries = fetch_record(&wheel_url)
+        .await
+        .context("failed to fetch RECORD")?;
 
     // Fast path: existence + size-only check; no hashing.
     // If size is None and file exists, treat as OK (no further verification).
@@ -273,10 +281,14 @@ async fn fetch_and_extract(pkg: &str, platform_tags: &[&str], out_dir: Arc<PathB
 
     if needs_download {
         debug!("{pkg}: downloading {wheel_name}...");
-        let bytes = http_download(&wheel_url).await?;
+        let bytes = http_download(&wheel_url)
+            .await
+            .context("failed to download wheel")?;
         let out = Arc::clone(&out_dir);
 
-        task::spawn_blocking(move || extract_from_wheel(&bytes, out.as_ref())).await??;
+        task::spawn_blocking(move || extract_from_wheel(&bytes, out.as_ref()))
+            .await?
+            .context("failed to extract dylibs")?;
         debug!("{pkg}: download and extract complete");
         Ok(())
     } else {

koharu-runtime/src/lib.rs

@@ -1,6 +1,5 @@
 mod dylib;
 mod fonts;
-mod pypi;
 mod zip;
 
 pub use dylib::{ensure_dylibs, preload_dylibs};

koharu-runtime/src/pypi.rs

@@ -1,44 +0,0 @@
-use std::time::{Duration, Instant};
-
-use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use strum::Display;
-
-pub static PYPI_ENDPOINT: once_cell::sync::Lazy<&PypiEndpoint> = once_cell::sync::Lazy::new(|| {
-    [PypiEndpoint::Official, PypiEndpoint::Tsinghua]
-        .par_iter()
-        .map(|endpoint| {
-            let start = Instant::now();
-            let url = format!("{endpoint}/pypi/sampleproject/json");
-            let resp = reqwest::blocking::get(&url);
-            match resp {
-                Ok(resp) if resp.status().is_success() => {
-                    let duration = start.elapsed();
-                    (duration, endpoint)
-                }
-                _ => (Duration::MAX, endpoint),
-            }
-        })
-        .min_by_key(|(duration, _)| *duration)
-        .map(|(_, endpoint)| endpoint)
-        .unwrap_or_else(|| &PypiEndpoint::Official)
-});
-
-#[derive(Debug, Clone, Display)]
-pub enum PypiEndpoint {
-    #[strum(serialize = "https://pypi.org")]
-    Official,
-    #[strum(serialize = "https://mirrors.tuna.tsinghua.edu.cn")]
-    Tsinghua,
-}
-
-impl PypiEndpoint {
-    pub fn refine_url(&self, path: &str) -> String {
-        match self {
-            PypiEndpoint::Tsinghua => path.replace(
-                "https://files.pythonhosted.org",
-                format!("{self}/pypi/web").as_str(),
-            ),
-            _ => path.to_string(),
-        }
-    }
-}

koharu/src/app.rs

@@ -6,7 +6,7 @@ use std::{
     },
 };
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use clap::Parser;
 use koharu_ml::{DeviceName, cuda_is_available, device_name};
 use koharu_runtime::{ensure_dylibs, preload_dylibs};
@@ -170,10 +170,12 @@ async fn prefetch() -> Result<()> {
     Ok(())
 }
 
-async fn build_resources(use_cpu: bool, _register_file_assoc: bool) -> Result<AppResources> {
+async fn build_resources(cpu: bool, _register_file_assoc: bool) -> Result<AppResources> {
     if cuda_is_available() {
-        ensure_dylibs(LIB_ROOT.to_path_buf()).await?;
-        preload_dylibs(LIB_ROOT.to_path_buf())?;
+        ensure_dylibs(LIB_ROOT.to_path_buf())
+            .await
+            .context("Failed to ensure dynamic libraries")?;
+        preload_dylibs(LIB_ROOT.to_path_buf()).context("Failed to preload dynamic libraries")?;
 
         #[cfg(target_os = "windows")]
         {
@@ -181,7 +183,7 @@ async fn build_resources(use_cpu: bool, _register_file_assoc: bool) -> Result<Ap
                 tracing::warn!(?err, "Failed to register .khr file association");
             }
 
-            crate::windows::add_dll_directory(&LIB_ROOT)?;
+            crate::windows::add_dll_directory(&LIB_ROOT).context("Failed to add DLL directory")?;
         }
 
         tracing::info!(
@@ -190,10 +192,14 @@ async fn build_resources(use_cpu: bool, _register_file_assoc: bool) -> Result<Ap
         );
     }
 
-    let ml_device = device_name(use_cpu);
-    let ml = Arc::new(ml::Model::new(use_cpu).await?);
-    let llm = Arc::new(llm::Model::new(use_cpu));
-    let renderer = Arc::new(Renderer::new()?);
+    let ml_device = device_name(cpu);
+    let ml = Arc::new(
+        ml::Model::new(cpu)
+            .await
+            .context("Failed to initialize ML model")?,
+    );
+    let llm = Arc::new(llm::Model::new(cpu));
+    let renderer = Arc::new(Renderer::new().context("Failed to initialize renderer")?);
     let state = Arc::new(RwLock::new(State::default()));
 
     Ok(AppResources {