@thomasfarineau/anvil 0.0.2 → 0.0.4

package/src/rust/src/lib.rs

@@ -15,15 +15,34 @@ const RESOURCES_URL: &str = "https://resources.download.minecraft.net/";
 
 // ── Config (config.json) ──────────────────────────────────────────────────────
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct ModConfig {
+    pub url: String,
+    #[serde(default)] pub name:      String,
+    #[serde(default)] pub file_name: String,
+}
+
+/// Fichier arbitraire (config de mod, options.txt…) déployé dans le dossier
+/// de l'instance pendant le setup. Servi par un anvil-server en général.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct FileConfig {
+    pub path: String,
+    pub url:  String,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct InstanceConfig {
     pub id:             String,
-    pub name:           String,
-    pub mc_version:     String,
+    // name / mc_version sont optionnels dans config.json : une instance
+    // `{ "id": "..." }` est résolue au démarrage auprès du anvil-server.
+    #[serde(default)] pub name:           String,
+    #[serde(default)] pub mc_version:     String,
     #[serde(default)] pub loader:         String,
     #[serde(default)] pub loader_version: String,
     #[serde(default)] pub server_ip:      String,
     #[serde(default = "default_port")] pub server_port: u16,
+    #[serde(default)] pub mods:           Vec<ModConfig>,
+    #[serde(default)] pub files:          Vec<FileConfig>,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -37,6 +56,8 @@ pub struct LauncherConfig {
     #[serde(default = "default_true")]         pub window_resizable:   bool,
     #[serde(default)]                          pub logo:               String,
     #[serde(default = "default_session")]      pub session:            String,
+    #[serde(rename = "anvil-server", default)] pub anvil_server:       String,
+    #[serde(rename = "anvil-key", default)]    pub anvil_key:          String,
     #[serde(default)]                          pub instances:          Vec<InstanceConfig>,
 }
 
@@ -59,6 +80,8 @@ impl Default for LauncherConfig {
             window_resizable:   true,
             logo:               String::new(),
             session:            default_session(),
+            anvil_server:       String::new(),
+            anvil_key:          String::new(),
             instances:          Vec::new(),
         }
     }
@@ -97,6 +120,7 @@ pub struct AppState {
     pub settings:       Mutex<Settings>,
     pub data_dir:       PathBuf,
     pub custom_session: Mutex<Option<CustomSession>>,
+    pub running:        Mutex<HashMap<String, std::sync::Arc<Mutex<std::process::Child>>>>,
 }
 
 // ── Types Mojang (internes) ───────────────────────────────────────────────────
@@ -193,6 +217,16 @@ pub struct InstanceStatus {
     pub id:        String,
     pub name:      String,
     pub installed: bool,
+    pub running:   bool,
+}
+
+#[derive(Serialize, Clone)]
+pub struct ModInfo {
+    pub file_name: String,
+    pub name:      String,
+    pub enabled:   bool,
+    pub size:      u64,
+    pub managed:   bool,
 }
 
 #[derive(Serialize, Clone)]
@@ -241,6 +275,35 @@ fn instance_data_dir(launcher_dir: &Path, instance: &InstanceConfig) -> PathBuf
 
 fn log_dir(launcher_dir: &Path) -> PathBuf { launcher_dir.join("logs") }
 
+/// Dossier mods/ de l'instance (lu par Fabric/Forge/Quilt depuis le game dir)
+fn mods_dir(launcher_dir: &Path, inst: &InstanceConfig) -> PathBuf {
+    instance_data_dir(launcher_dir, inst).join("mods")
+}
+
+fn mod_file_name(m: &ModConfig) -> String {
+    if !m.file_name.is_empty() { return m.file_name.clone(); }
+    let base = m.url.split(['?', '#']).next().unwrap_or(&m.url);
+    let name = base.rsplit('/').next().filter(|n| !n.is_empty()).unwrap_or("mod.jar");
+    if name.ends_with(".jar") { name.to_string() } else { format!("{name}.jar") }
+}
+
+fn check_file_name(name: &str) -> Result<(), String> {
+    if name.is_empty() || name.contains('/') || name.contains('\\') || name.contains("..") {
+        return Err(format!("Nom de fichier invalide : '{name}'"));
+    }
+    Ok(())
+}
+
+fn open_in_file_manager(path: &Path) -> Result<(), String> {
+    std::fs::create_dir_all(path).map_err(|e| e.to_string())?;
+    let cmd = if cfg!(windows) { "explorer" }
+              else if cfg!(target_os = "macos") { "open" }
+              else { "xdg-open" };
+    std::process::Command::new(cmd).arg(path).spawn()
+        .map(|_| ())
+        .map_err(|e| format!("Impossible d'ouvrir le dossier : {e}"))
+}
+
 fn find_bundled_java(launcher_dir: &Path) -> Option<PathBuf> {
     let java_dir = launcher_dir.join("java");
     let bin = if cfg!(windows) { "javaw.exe" } else { "java" };
@@ -308,6 +371,80 @@ fn find_config_json(app: &AppHandle) -> LauncherConfig {
     LauncherConfig::default()
 }
 
+// ── anvil-server ──────────────────────────────────────────────────────────────
+
+fn anvil_server_url(cfg: &LauncherConfig) -> Result<String, String> {
+    let url = cfg.anvil_server.trim().trim_end_matches('/');
+    if url.is_empty() {
+        return Err("Aucun serveur anvil configuré (champ 'anvil-server' de config.json).".into());
+    }
+    Ok(url.to_string())
+}
+
+fn anvil_cache_file(data_dir: &Path) -> PathBuf {
+    data_dir.join("anvil-server-cache").join("instances.json")
+}
+
+/// Clé d'API à joindre si l'URL cible le anvil-server configuré.
+/// Les URLs externes (CDN de mods…) ne reçoivent jamais la clé.
+fn anvil_key_for<'a>(cfg: &'a LauncherConfig, url: &str) -> Option<&'a str> {
+    if cfg.anvil_key.is_empty() { return None; }
+    match anvil_server_url(cfg) {
+        Ok(server) if url.starts_with(&server) => Some(cfg.anvil_key.as_str()),
+        _ => None,
+    }
+}
+
+async fn fetch_remote_instances(
+    client: &reqwest::Client,
+    cfg:    &LauncherConfig,
+    server: &str,
+) -> Result<Vec<InstanceConfig>, String> {
+    let mut req = client.get(format!("{server}/api/launcher/instances"));
+    if !cfg.anvil_key.is_empty() { req = req.header("x-anvil-key", &cfg.anvil_key); }
+    let resp = req.send().await.map_err(|e| e.to_string())?;
+    if !resp.status().is_success() {
+        return Err(format!("HTTP {}", resp.status()));
+    }
+    resp.json::<Vec<InstanceConfig>>().await.map_err(|e| e.to_string())
+}
+
+/// Récupère la liste des instances actives auprès du anvil-server (le
+/// config.json ne déclare plus les instances, seulement le serveur et la
+/// clé d'API). La liste est mise en cache sur disque afin que le launcher
+/// reste utilisable hors-ligne.
+fn resolve_remote_instances(config: &mut LauncherConfig, data_dir: &Path, logs: &Path) {
+    let Ok(server) = anvil_server_url(config) else { return };
+    let cache_file = anvil_cache_file(data_dir);
+
+    tauri::async_runtime::block_on(async {
+        let Ok(client) = reqwest::Client::builder()
+            .user_agent("HomeLauncher/1.0")
+            .timeout(std::time::Duration::from_secs(8))
+            .build() else { return };
+
+        match fetch_remote_instances(&client, config, &server).await {
+            Ok(remote) => {
+                launcher_log(logs, &format!(
+                    "anvil-server: {} instance(s) résolue(s)", remote.len()
+                ));
+                let _ = save_json(&cache_file, &remote);
+                config.instances = remote;
+            }
+            Err(e) => {
+                launcher_log(logs, &format!(
+                    "anvil-server: échec ({e}) — utilisation du cache"
+                ));
+                if let Ok(text) = std::fs::read_to_string(&cache_file) {
+                    if let Ok(cached) = serde_json::from_str::<Vec<InstanceConfig>>(&text) {
+                        config.instances = cached;
+                    }
+                }
+            }
+        }
+    });
+}
+
 // ── Utilitaires JSON ──────────────────────────────────────────────────────────
 
 fn load_json<T: serde::de::DeserializeOwned + Default>(path: &Path) -> T {
@@ -341,6 +478,37 @@ fn maven_path(name: &str) -> String {
     format!("{}/{}/{}/{}-{}.jar", p[0].replace('.', "/"), p[1], p[2], p[1], p[2])
 }
 
+/// Maven coordinate without its version: "group:artifact[:classifier]".
+/// Used to dedupe libraries so a single ASM/Guava/etc. survives on the
+/// classpath — Fabric aborts if two versions of the same jar are present.
+fn lib_key(name: &str) -> String {
+    let p: Vec<&str> = name.split(':').collect();
+    if p.len() < 3 { return name.to_string(); }
+    // Keep group:artifact plus any classifier (index 3+), drop the version.
+    let mut key = format!("{}:{}", p[0], p[1]);
+    for extra in &p[3..] { key.push(':'); key.push_str(extra); }
+    key
+}
+
+/// Collapse a merged (vanilla + loader) library list so each coordinate
+/// appears once. The later entry wins — loader libraries follow the parent's
+/// in the merge, so Fabric's versions override vanilla's.
+fn dedup_libraries(libs: Vec<LibEntry>) -> Vec<LibEntry> {
+    let mut seen: HashMap<String, usize> = HashMap::new();
+    let mut out: Vec<LibEntry> = Vec::new();
+    for lib in libs {
+        let key = lib_key(&lib.name);
+        match seen.get(&key) {
+            Some(&i) => out[i] = lib,
+            None => {
+                seen.insert(key, out.len());
+                out.push(lib);
+            }
+        }
+    }
+    out
+}
+
 async fn http_bytes(client: &reqwest::Client, url: &str) -> Result<Vec<u8>, String> {
     client.get(url).send().await.map_err(|e| format!("GET {url}: {e}"))?
         .bytes().await.map_err(|e| e.to_string()).map(|b| b.to_vec())
@@ -353,6 +521,32 @@ async fn save_if_missing(client: &reqwest::Client, url: &str, dest: &Path) -> Re
     std::fs::write(dest, &bytes).map_err(|e| e.to_string())
 }
 
+/// Variante de http_bytes qui joint la clé d'API si l'URL cible le
+/// anvil-server configuré (mods hébergés, fichiers de config).
+async fn http_bytes_keyed(
+    client: &reqwest::Client,
+    cfg:    &LauncherConfig,
+    url:    &str,
+) -> Result<Vec<u8>, String> {
+    let mut req = client.get(url);
+    if let Some(key) = anvil_key_for(cfg, url) { req = req.header("x-anvil-key", key); }
+    req.send().await.map_err(|e| format!("GET {url}: {e}"))?
+        .error_for_status().map_err(|e| format!("GET {url}: {e}"))?
+        .bytes().await.map_err(|e| e.to_string()).map(|b| b.to_vec())
+}
+
+async fn save_if_missing_keyed(
+    client: &reqwest::Client,
+    cfg:    &LauncherConfig,
+    url:    &str,
+    dest:   &Path,
+) -> Result<(), String> {
+    if dest.exists() { return Ok(()); }
+    if let Some(p) = dest.parent() { std::fs::create_dir_all(p).map_err(|e| e.to_string())?; }
+    let bytes = http_bytes_keyed(client, cfg, url).await?;
+    std::fs::write(dest, &bytes).map_err(|e| e.to_string())
+}
+
 fn unzip_natives(zip_bytes: &[u8], dest: &Path) -> Result<(), String> {
     use std::io::Read;
     let mut archive = zip::ZipArchive::new(std::io::Cursor::new(zip_bytes))
@@ -422,10 +616,12 @@ fn get_default_launcher_dir(state: State<AppState>) -> String {
 fn get_init_status(state: State<AppState>) -> InitStatus {
     let settings     = state.settings.lock().unwrap().clone();
     let launcher_dir = get_launcher_dir(&settings, &state.config);
+    let running      = state.running.lock().unwrap();
     let instances    = state.config.instances.iter().map(|inst| InstanceStatus {
         id:        inst.id.clone(),
         name:      inst.name.clone(),
         installed: is_instance_installed(&launcher_dir, inst),
+        running:   running.contains_key(&inst.id),
     }).collect();
     InitStatus {
         launcher_dir: launcher_dir.to_string_lossy().into(),
@@ -641,6 +837,206 @@ async fn install_fabric(
     Ok(())
 }
 
+// ── Mods ──────────────────────────────────────────────────────────────────────
+
+/// Télécharge les mods déclarés dans config.json qui manquent dans mods/.
+/// Un mod désactivé (.jar.disabled) n'est pas re-téléchargé.
+async fn sync_mods(
+    app:          &AppHandle,
+    client:       &reqwest::Client,
+    cfg:          &LauncherConfig,
+    launcher_dir: &Path,
+    inst:         &InstanceConfig,
+) -> Result<(), String> {
+    if inst.mods.is_empty() { return Ok(()); }
+    let dir = mods_dir(launcher_dir, inst);
+    std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
+
+    let total = inst.mods.len();
+    for (i, m) in inst.mods.iter().enumerate() {
+        let file = mod_file_name(m);
+        check_file_name(&file)?;
+        if dir.join(&file).exists() || dir.join(format!("{file}.disabled")).exists() { continue; }
+        let label = if m.name.is_empty() { file.clone() } else { m.name.clone() };
+        let _ = app.emit("setup:progress", SetupProgress {
+            step:    inst.id.clone(),
+            current: 100 * i / total.max(1),
+            total:   100,
+            label:   format!("Mod {label} ({}/{total})", i + 1),
+            error:   false,
+        });
+        save_if_missing_keyed(client, cfg, &m.url, &dir.join(&file)).await
+            .map_err(|e| format!("Mod '{label}': {e}"))?;
+    }
+    Ok(())
+}
+
+fn check_rel_path(path: &str) -> Result<(), String> {
+    if path.is_empty() || path.contains("..") || path.starts_with('/')
+        || path.contains('\\') || path.contains(':')
+    {
+        return Err(format!("Chemin de fichier invalide : '{path}'"));
+    }
+    Ok(())
+}
+
+/// Télécharge les fichiers déclarés (configs de mods…) dans le dossier de
+/// l'instance. Toujours écrasés : le anvil-server est la source de vérité.
+async fn sync_files(
+    app:          &AppHandle,
+    client:       &reqwest::Client,
+    cfg:          &LauncherConfig,
+    launcher_dir: &Path,
+    inst:         &InstanceConfig,
+) -> Result<(), String> {
+    if inst.files.is_empty() { return Ok(()); }
+    let base  = instance_data_dir(launcher_dir, inst);
+    let total = inst.files.len();
+    for (i, f) in inst.files.iter().enumerate() {
+        check_rel_path(&f.path)?;
+        let _ = app.emit("setup:progress", SetupProgress {
+            step:    inst.id.clone(),
+            current: 100 * i / total.max(1),
+            total:   100,
+            label:   format!("Fichier {} ({}/{total})", f.path, i + 1),
+            error:   false,
+        });
+        let dest = base.join(&f.path);
+        if let Some(p) = dest.parent() { std::fs::create_dir_all(p).map_err(|e| e.to_string())?; }
+        let bytes = http_bytes_keyed(client, cfg, &f.url).await
+            .map_err(|e| format!("Fichier '{}': {e}", f.path))?;
+        std::fs::write(&dest, &bytes).map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+fn find_instance<'a>(cfg: &'a LauncherConfig, instance_id: &str) -> Result<&'a InstanceConfig, String> {
+    cfg.instances.iter().find(|i| i.id == instance_id)
+        .ok_or_else(|| format!("Instance '{instance_id}' introuvable dans config.json"))
+}
+
+#[tauri::command]
+fn get_mods(state: State<AppState>, instance_id: String) -> Result<Vec<ModInfo>, String> {
+    let settings     = state.settings.lock().unwrap().clone();
+    let launcher_dir = get_launcher_dir(&settings, &state.config);
+    let inst         = find_instance(&state.config, &instance_id)?;
+    let dir          = mods_dir(&launcher_dir, inst);
+
+    let managed: HashMap<String, &ModConfig> = inst.mods.iter()
+        .map(|m| (mod_file_name(m), m)).collect();
+
+    let mut mods = Vec::new();
+    if let Ok(entries) = std::fs::read_dir(&dir) {
+        for e in entries.flatten() {
+            let raw = e.file_name().to_string_lossy().to_string();
+            let (file, enabled) = match raw.strip_suffix(".disabled") {
+                Some(base) => (base.to_string(), false),
+                None       => (raw.clone(), true),
+            };
+            if !file.ends_with(".jar") { continue; }
+            let decl = managed.get(&file);
+            mods.push(ModInfo {
+                name:      decl.map(|m| m.name.clone()).filter(|n| !n.is_empty())
+                               .unwrap_or_else(|| file.trim_end_matches(".jar").to_string()),
+                file_name: file,
+                enabled,
+                size:      e.metadata().map(|m| m.len()).unwrap_or(0),
+                managed:   decl.is_some(),
+            });
+        }
+    }
+    mods.sort_by(|a, b| a.file_name.cmp(&b.file_name));
+    Ok(mods)
+}
+
+#[tauri::command]
+async fn add_mod(
+    state:       State<'_, AppState>,
+    instance_id: String,
+    url:         String,
+    file_name:   Option<String>,
+) -> Result<ModInfo, String> {
+    let settings     = state.settings.lock().unwrap().clone();
+    let launcher_dir = get_launcher_dir(&settings, &state.config);
+    let inst         = find_instance(&state.config, &instance_id)?;
+
+    let m    = ModConfig { url, name: String::new(), file_name: file_name.unwrap_or_default() };
+    let file = mod_file_name(&m);
+    check_file_name(&file)?;
+
+    let dir = mods_dir(&launcher_dir, inst);
+    std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
+    let dest = dir.join(&file);
+    if dest.exists() { return Err(format!("Le mod '{file}' existe déjà.")); }
+
+    let client = reqwest::Client::builder().user_agent("HomeLauncher/1.0").build()
+        .map_err(|e| e.to_string())?;
+    let bytes = http_bytes_keyed(&client, &state.config, &m.url).await?;
+    std::fs::write(&dest, &bytes).map_err(|e| e.to_string())?;
+
+    Ok(ModInfo {
+        name:      file.trim_end_matches(".jar").to_string(),
+        file_name: file,
+        enabled:   true,
+        size:      bytes.len() as u64,
+        managed:   false,
+    })
+}
+
+#[tauri::command]
+fn remove_mod(state: State<AppState>, instance_id: String, file_name: String) -> Result<(), String> {
+    check_file_name(&file_name)?;
+    let settings     = state.settings.lock().unwrap().clone();
+    let launcher_dir = get_launcher_dir(&settings, &state.config);
+    let inst         = find_instance(&state.config, &instance_id)?;
+    let dir          = mods_dir(&launcher_dir, inst);
+    for candidate in [dir.join(&file_name), dir.join(format!("{file_name}.disabled"))] {
+        if candidate.exists() {
+            return std::fs::remove_file(&candidate).map_err(|e| e.to_string());
+        }
+    }
+    Err(format!("Mod '{file_name}' introuvable."))
+}
+
+#[tauri::command]
+fn set_mod_enabled(
+    state:       State<AppState>,
+    instance_id: String,
+    file_name:   String,
+    enabled:     bool,
+) -> Result<(), String> {
+    check_file_name(&file_name)?;
+    let settings     = state.settings.lock().unwrap().clone();
+    let launcher_dir = get_launcher_dir(&settings, &state.config);
+    let inst         = find_instance(&state.config, &instance_id)?;
+    let dir          = mods_dir(&launcher_dir, inst);
+    let active       = dir.join(&file_name);
+    let disabled     = dir.join(format!("{file_name}.disabled"));
+    match (enabled, active.exists(), disabled.exists()) {
+        (true,  true,  _)     => Ok(()),
+        (true,  false, true)  => std::fs::rename(&disabled, &active).map_err(|e| e.to_string()),
+        (false, true,  _)     => std::fs::rename(&active, &disabled).map_err(|e| e.to_string()),
+        (false, false, true)  => Ok(()),
+        _ => Err(format!("Mod '{file_name}' introuvable.")),
+    }
+}
+
+#[tauri::command]
+fn open_mods_folder(state: State<AppState>, instance_id: String) -> Result<(), String> {
+    let settings     = state.settings.lock().unwrap().clone();
+    let launcher_dir = get_launcher_dir(&settings, &state.config);
+    let inst         = find_instance(&state.config, &instance_id)?;
+    open_in_file_manager(&mods_dir(&launcher_dir, inst))
+}
+
+#[tauri::command]
+fn open_instance_folder(state: State<AppState>, instance_id: String) -> Result<(), String> {
+    let settings     = state.settings.lock().unwrap().clone();
+    let launcher_dir = get_launcher_dir(&settings, &state.config);
+    let inst         = find_instance(&state.config, &instance_id)?;
+    open_in_file_manager(&instance_data_dir(&launcher_dir, inst))
+}
+
 #[tauri::command]
 async fn run_setup(app: AppHandle, state: State<'_, AppState>) -> Result<(), String> {
     let settings     = state.settings.lock().unwrap().clone();
@@ -668,19 +1064,34 @@ async fn run_setup(app: AppHandle, state: State<'_, AppState>) -> Result<(), Str
         .map_err(|e| e.to_string())?;
 
     for inst in &cfg.instances {
-        if is_instance_installed(&launcher_dir, inst) {
+        let result = if inst.mc_version.is_empty() {
+            // Instance déclarée par {id} mais jamais résolue : serveur anvil
+            // injoignable et aucun cache disponible.
+            Err(format!(
+                "Instance '{}' non résolue — anvil-server injoignable ?", inst.id
+            ))
+        } else if is_instance_installed(&launcher_dir, inst) {
             launcher_log(&logs, &format!("Instance '{}' déjà installée", inst.id));
-            let _ = app.emit("setup:progress", SetupProgress {
-                step: inst.id.clone(), current: 100, total: 100,
-                label: format!("{} déjà installé.", inst.name), error: false,
-            });
-            continue;
-        }
-        launcher_log(&logs, &format!("Installation instance '{}' ({})", inst.id, inst.mc_version));
-        let result = if inst.loader == "fabric" {
-            install_fabric(&app, &client, &game_dir, inst).await
+            // On synchronise quand même mods et fichiers : un ajout côté
+            // config/serveur doit être téléchargé sans réinstaller l'instance.
+            match sync_mods(&app, &client, &cfg, &launcher_dir, inst).await {
+                Ok(_) => sync_files(&app, &client, &cfg, &launcher_dir, inst).await,
+                Err(e) => Err(e),
+            }
         } else {
-            install_vanilla(&app, &client, &game_dir, inst).await
+            launcher_log(&logs, &format!("Installation instance '{}' ({})", inst.id, inst.mc_version));
+            let r = if inst.loader == "fabric" {
+                install_fabric(&app, &client, &game_dir, inst).await
+            } else {
+                install_vanilla(&app, &client, &game_dir, inst).await
+            };
+            match r {
+                Ok(_) => match sync_mods(&app, &client, &cfg, &launcher_dir, inst).await {
+                    Ok(_) => sync_files(&app, &client, &cfg, &launcher_dir, inst).await,
+                    Err(e) => Err(e),
+                },
+                Err(e) => Err(e),
+            }
         };
         match result {
             Ok(_) => {
@@ -688,7 +1099,7 @@ async fn run_setup(app: AppHandle, state: State<'_, AppState>) -> Result<(), Str
                     step: inst.id.clone(), current: 100, total: 100,
                     label: format!("{} installé.", inst.name), error: false,
                 });
-                launcher_log(&logs, &format!("Instance '{}' installée", inst.id));
+                launcher_log(&logs, &format!("Instance '{}' prête", inst.id));
             }
             Err(e) => {
                 launcher_log(&logs, &format!("Erreur instance '{}': {e}", inst.id));
@@ -727,7 +1138,11 @@ fn read_version_chain(game_dir: &Path, version_id: &str) -> Result<VersionJson,
             (None, Some(pa)) => ver.arguments = Some(pa),
             _ => {}
         }
-        ver.libraries = { let mut m = parent.libraries; m.extend(std::mem::take(&mut ver.libraries)); m };
+        ver.libraries = {
+            let mut m = parent.libraries;
+            m.extend(std::mem::take(&mut ver.libraries));
+            dedup_libraries(m)
+        };
     }
     Ok(ver)
 }
@@ -763,6 +1178,14 @@ fn verify_instance(launcher_dir: &Path, inst: &InstanceConfig) -> Result<(), Str
         if !path.exists() { missing.push(format!("lib : {}", lib.name)); }
     }
 
+    let m_dir = mods_dir(launcher_dir, inst);
+    for m in &inst.mods {
+        let file = mod_file_name(m);
+        if !m_dir.join(&file).exists() && !m_dir.join(format!("{file}.disabled")).exists() {
+            missing.push(format!("mod : {file}"));
+        }
+    }
+
     if missing.is_empty() { Ok(()) } else {
         Err(format!(
             "{} fichier(s) manquant(s) dans '{}' :\n{}\n\nRelancez la configuration initiale.",
@@ -840,6 +1263,10 @@ async fn launch_game(
         .ok_or_else(|| format!("Instance '{instance_id}' introuvable"))?
         .clone();
 
+    if state.running.lock().unwrap().contains_key(&instance_id) {
+        return Err(format!("L'instance '{}' est déjà en cours d'exécution.", inst.name));
+    }
+
     verify_instance(&launcher_dir, &inst)?;
 
     let java     = find_bundled_java(&launcher_dir).unwrap();
@@ -864,6 +1291,15 @@ async fn launch_game(
                 None    => offline_auth(&fallback_name),
             }
         },
+        // La session est gérée par le anvil-server : pas de fallback offline,
+        // le joueur doit être connecté.
+        "anvil-session" => {
+            let guard = state.custom_session.lock().unwrap();
+            match &*guard {
+                Some(s) => (s.username.clone(), s.uuid.clone(), s.access_token.clone(), "msa"),
+                None    => return Err("Aucune session active — connectez-vous d'abord.".into()),
+            }
+        },
         _ => offline_auth(&fallback_name),
     };
 
@@ -1003,17 +1439,50 @@ async fn launch_game(
             }
         });
     }
+    // Enregistre le process pour stop_game / get_running_instances.
+    // Le thread de fin utilise try_wait en boucle pour ne pas garder le lock.
+    let child = std::sync::Arc::new(Mutex::new(child));
+    state.running.lock().unwrap().insert(instance_id.clone(), child.clone());
+
     let iid_exit = instance_id.clone();
     let logs2    = logs.clone();
+    let app_exit = app.clone();
     std::thread::spawn(move || {
-        let code = child.wait().ok().and_then(|s| s.code()).unwrap_or(-1);
+        let code = loop {
+            match child.lock().unwrap().try_wait() {
+                Ok(Some(status)) => break status.code().unwrap_or(-1),
+                Ok(None)         => {}
+                Err(_)           => break -1,
+            }
+            std::thread::sleep(std::time::Duration::from_millis(400));
+        };
+        let state = app_exit.state::<AppState>();
+        state.running.lock().unwrap().remove(&iid_exit);
         launcher_log(&logs2, &format!("Instance '{}' terminée (code {code})", iid_exit));
-        let _ = app.emit("game:exit", serde_json::json!({ "instance_id": iid_exit, "code": code }));
+        let _ = app_exit.emit("game:exit", serde_json::json!({ "instance_id": iid_exit, "code": code }));
     });
 
     Ok(())
 }
 
+#[tauri::command]
+fn stop_game(state: State<AppState>, instance_id: String) -> Result<(), String> {
+    let child = state.running.lock().unwrap().get(&instance_id).cloned()
+        .ok_or_else(|| format!("Instance '{instance_id}' non lancée."))?;
+    let result = child.lock().unwrap().kill().map_err(|e| format!("Impossible d'arrêter le jeu : {e}"));
+    result
+}
+
+#[tauri::command]
+fn get_running_instances(state: State<AppState>) -> Vec<String> {
+    state.running.lock().unwrap().keys().cloned().collect()
+}
+
+#[tauri::command]
+fn get_launcher_version() -> String {
+    env!("CARGO_PKG_VERSION").into()
+}
+
 // ── Mise à jour ───────────────────────────────────────────────────────────────
 
 #[tauri::command]
@@ -1053,29 +1522,161 @@ async fn do_update(app: AppHandle, url: String) -> Result<(), String> {
     Ok(())
 }
 
+// ── Session anvil-server ──────────────────────────────────────────────────────
+
+#[derive(Serialize, Clone)]
+pub struct AnvilLoginResult {
+    pub status:   String, // "ok" | "totp_required"
+    pub username: String,
+    pub uuid:     String,
+}
+
+fn anvil_session_path(data_dir: &Path) -> PathBuf { data_dir.join("anvil_session.json") }
+
+fn anvil_http_client() -> Result<reqwest::Client, String> {
+    reqwest::Client::builder()
+        .user_agent("HomeLauncher/1.0")
+        .timeout(std::time::Duration::from_secs(10))
+        .build()
+        .map_err(|e| e.to_string())
+}
+
+/// POST vers le anvil-server avec la clé d'API du config.json.
+fn anvil_post(
+    client: &reqwest::Client,
+    cfg:    &LauncherConfig,
+    url:    String,
+) -> reqwest::RequestBuilder {
+    let mut req = client.post(url);
+    if !cfg.anvil_key.is_empty() { req = req.header("x-anvil-key", &cfg.anvil_key); }
+    req
+}
+
+/// Connexion au anvil-server (mode session "anvil-session").
+/// Retourne status "totp_required" si le compte exige un code 2FA.
+#[tauri::command]
+async fn anvil_session_login(
+    state:    State<'_, AppState>,
+    username: String,
+    password: String,
+    code:     Option<String>,
+) -> Result<AnvilLoginResult, String> {
+    let server = anvil_server_url(&state.config)?;
+    let client = anvil_http_client()?;
+    let resp = anvil_post(&client, &state.config, format!("{server}/api/launcher/session"))
+        .json(&serde_json::json!({ "username": username, "password": password, "code": code }))
+        .send().await.map_err(|e| format!("Erreur réseau : {e}"))?;
+
+    let status = resp.status();
+    let body: serde_json::Value = resp.json().await.unwrap_or_default();
+
+    if status.is_success() {
+        let session = CustomSession {
+            username:     body["username"].as_str().unwrap_or(&username).to_string(),
+            uuid:         body["uuid"].as_str().unwrap_or_default().to_string(),
+            access_token: body["access_token"].as_str().unwrap_or_default().to_string(),
+        };
+        let _ = save_json(&anvil_session_path(&state.data_dir), &session);
+        let result = AnvilLoginResult {
+            status: "ok".into(), username: session.username.clone(), uuid: session.uuid.clone(),
+        };
+        *state.custom_session.lock().unwrap() = Some(session);
+        Ok(result)
+    } else {
+        match body["error"].as_str() {
+            Some("totp_required") => Ok(AnvilLoginResult {
+                status: "totp_required".into(), username: String::new(), uuid: String::new(),
+            }),
+            Some("invalid_code") => Err("Code 2FA invalide.".into()),
+            Some("missing_api_key") | Some("invalid_api_key") =>
+                Err("Clé d'API invalide — vérifiez 'anvil-key' dans config.json.".into()),
+            _ => Err("Identifiants invalides.".into()),
+        }
+    }
+}
+
+/// Restaure la session persistée si elle est encore valide côté serveur.
+/// Hors-ligne, la session en cache est conservée pour permettre de jouer.
+#[tauri::command]
+async fn anvil_session_restore(state: State<'_, AppState>) -> Result<Option<AnvilLoginResult>, String> {
+    let path = anvil_session_path(&state.data_dir);
+    let saved: Option<CustomSession> = std::fs::read_to_string(&path).ok()
+        .and_then(|s| serde_json::from_str(&s).ok());
+    let Some(saved) = saved else { return Ok(None) };
+    let Ok(server) = anvil_server_url(&state.config) else { return Ok(None) };
+    let client = anvil_http_client()?;
+
+    let session = match anvil_post(&client, &state.config, format!("{server}/api/launcher/session/validate"))
+        .json(&serde_json::json!({ "token": saved.access_token }))
+        .send().await
+    {
+        Ok(resp) if resp.status().is_success() => {
+            let body: serde_json::Value = resp.json().await.unwrap_or_default();
+            CustomSession {
+                username:     body["username"].as_str().unwrap_or(&saved.username).to_string(),
+                uuid:         body["uuid"].as_str().unwrap_or(&saved.uuid).to_string(),
+                access_token: saved.access_token,
+            }
+        }
+        Ok(resp) => {
+            let body: serde_json::Value = resp.json().await.unwrap_or_default();
+            if body["error"].as_str() == Some("invalid_token") {
+                // Token révoqué ou expiré : on oublie la session.
+                std::fs::remove_file(&path).ok();
+                return Ok(None);
+            }
+            saved // autre erreur (clé d'API…) : on garde la session locale
+        }
+        Err(_) => saved, // serveur injoignable : session hors-ligne
+    };
+
+    let result = AnvilLoginResult {
+        status: "ok".into(), username: session.username.clone(), uuid: session.uuid.clone(),
+    };
+    *state.custom_session.lock().unwrap() = Some(session);
+    Ok(Some(result))
+}
+
+#[tauri::command]
+async fn anvil_session_logout(state: State<'_, AppState>) -> Result<(), String> {
+    let saved = state.custom_session.lock().unwrap().take();
+    std::fs::remove_file(anvil_session_path(&state.data_dir)).ok();
+    if let (Ok(server), Some(session)) = (anvil_server_url(&state.config), saved) {
+        if let Ok(client) = anvil_http_client() {
+            let _ = anvil_post(&client, &state.config, format!("{server}/api/launcher/session/logout"))
+                .json(&serde_json::json!({ "token": session.access_token }))
+                .send().await;
+        }
+    }
+    Ok(())
+}
+
 // ── Entry point ───────────────────────────────────────────────────────────────
 
-#[cfg_attr(mobile, tauri::mobile_entry_point)]
 #[tauri::command]
 fn set_custom_session(state: State<'_, AppState>, session: Option<CustomSession>) -> Result<(), String> {
     *state.custom_session.lock().unwrap() = session;
     Ok(())
 }
 
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
         .setup(|app| {
             let data_dir = app.path().app_data_dir()
                 .unwrap_or_else(|_| dirs::data_local_dir().unwrap_or_default().join("HomeLauncher"));
             std::fs::create_dir_all(&data_dir)?;
-            let config:   LauncherConfig = find_config_json(app.handle());
-            let settings: Settings       = load_json(&data_dir.join("settings.json"));
+            let mut config: LauncherConfig = find_config_json(app.handle());
+            let settings:   Settings       = load_json(&data_dir.join("settings.json"));
 
             // Log du démarrage dans le launcher_dir final
             let launcher_dir = get_launcher_dir(&settings, &config);
             launcher_log(&log_dir(&launcher_dir),
                 &format!("HomeLauncher démarré — {} instance(s)", config.instances.len()));
 
+            // Résolution des instances déclarées par id auprès du anvil-server
+            resolve_remote_instances(&mut config, &data_dir, &log_dir(&launcher_dir));
+
             // Appliquer les options de fenêtre depuis config.json
             if let Some(win) = app.get_webview_window("main") {
                 let _ = win.set_title(&config.app_name);
@@ -1083,7 +1684,13 @@ pub fn run() {
                 let _ = win.set_resizable(config.window_resizable);
             }
 
-            app.manage(AppState { config, settings: Mutex::new(settings), data_dir, custom_session: Mutex::new(None) });
+            app.manage(AppState {
+                config,
+                settings:       Mutex::new(settings),
+                data_dir,
+                custom_session: Mutex::new(None),
+                running:        Mutex::new(HashMap::new()),
+            });
             if cfg!(debug_assertions) {
                 app.handle().plugin(
                     tauri_plugin_log::Builder::default().level(log::LevelFilter::Info).build()
@@ -1096,8 +1703,13 @@ pub fn run() {
             get_settings, save_settings,
             get_default_launcher_dir, get_init_status,
             run_setup, verify_game, launch_game,
+            stop_game, get_running_instances,
+            get_mods, add_mod, remove_mod, set_mod_enabled,
+            open_mods_folder, open_instance_folder,
             check_update, do_update,
             set_custom_session,
+            anvil_session_login, anvil_session_restore, anvil_session_logout,
+            get_launcher_version,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");