feat(backend): enhance instance management for editor support

- Sync instance.version_id after start_game, install_fabric, install_forge
- Add jvm_args_override and memory_override to Instance struct
- Add file management commands: list_instance_directory, delete_instance_file, open_file_explorer
- Support per-instance settings overrides (Java args, memory)

2 files changed, 135 insertions, 6 deletions

diff --git a/src-tauri/src/core/instance.rs b/src-tauri/src/core/instance.rs
index 183e1cc..573273e 100644
--- a/src-tauri/src/core/instance.rs
+++ b/src-tauri/src/core/instance.rs
@@ -25,6 +25,16 @@ pub struct Instance {
     pub notes: Option<String>,              // 备注（可选）
     pub mod_loader: Option<String>,         // 模组加载器类型："fabric", "forge", "vanilla"
     pub mod_loader_version: Option<String>, // 模组加载器版本
+    pub jvm_args_override: Option<String>,  // JVM参数覆盖（可选）
+    #[serde(default)]
+    pub memory_override: Option<MemoryOverride>, // 内存设置覆盖（可选）
+}
+
+/// Memory settings override for an instance
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MemoryOverride {
+    pub min: u32, // MB
+    pub max: u32, // MB
 }
 
 /// Configuration for all instances
@@ -99,6 +109,8 @@ impl InstanceState {
             notes: None,
             mod_loader: Some("vanilla".to_string()),
             mod_loader_version: None,
+            jvm_args_override: None,
+            memory_override: None,
         };
 
         let mut config = self.instances.lock().unwrap();
@@ -253,6 +265,8 @@ impl InstanceState {
                 .unwrap()
                 .as_secs() as i64,
             last_played: None,
+            jvm_args_override: source_instance.jvm_args_override.clone(),
+            memory_override: source_instance.memory_override.clone(),
         };
 
         self.update_instance(new_instance.clone())?;
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index a506713..35e2ef5 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -1,7 +1,7 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::process::Stdio;
 use std::sync::Mutex;
 use tauri::{Emitter, Manager, State, Window}; // Added Emitter
@@ -854,6 +854,12 @@ async fn start_game(
         }
     });
 
+    // Update instance's version_id to track last launched version
+    if let Some(mut instance) = instance_state.get_instance(&instance_id) {
+        instance.version_id = Some(version_id.clone());
+        let _ = instance_state.update_instance(instance);
+    }
+
     Ok(format!("Launched Minecraft {} successfully!", version_id))
 }
 
@@ -1693,10 +1699,11 @@ async fn install_fabric(
         format!("Fabric installed successfully: {}", result.id)
     );
 
-    // Update Instance's mod_loader metadata
+    // Update Instance's mod_loader metadata and version_id
     if let Some(mut instance) = instance_state.get_instance(&instance_id) {
         instance.mod_loader = Some("fabric".to_string());
-        instance.mod_loader_version = Some(loader_version);
+        instance.mod_loader_version = Some(loader_version.clone());
+        instance.version_id = Some(result.id.clone());
         instance_state.update_instance(instance)?;
     }
 
@@ -2107,10 +2114,11 @@ async fn install_forge(
         format!("Forge installed successfully: {}", result.id)
     );
 
-    // Update Instance's mod_loader metadata
+    // Update Instance's mod_loader metadata and version_id
     if let Some(mut instance) = instance_state.get_instance(&instance_id) {
         instance.mod_loader = Some("forge".to_string());
-        instance.mod_loader_version = Some(forge_version);
+        instance.mod_loader_version = Some(forge_version.clone());
+        instance.version_id = Some(result.id.clone());
         instance_state.update_instance(instance)?;
     }
 
@@ -2422,6 +2430,110 @@ async fn migrate_shared_caches(
     })
 }
 
+/// File information for instance file browser
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct FileInfo {
+    name: String,
+    path: String,
+    is_directory: bool,
+    size: u64,
+    modified: i64,
+}
+
+/// List files in an instance subdirectory (mods, resourcepacks, shaderpacks, saves, screenshots)
+#[tauri::command]
+async fn list_instance_directory(
+    instance_state: State<'_, core::instance::InstanceState>,
+    instance_id: String,
+    folder: String, // "mods" | "resourcepacks" | "shaderpacks" | "saves" | "screenshots"
+) -> Result<Vec<FileInfo>, String> {
+    let game_dir = instance_state
+        .get_instance_game_dir(&instance_id)
+        .ok_or_else(|| format!("Instance {} not found", instance_id))?;
+
+    let target_dir = game_dir.join(&folder);
+    if !target_dir.exists() {
+        tokio::fs::create_dir_all(&target_dir)
+            .await
+            .map_err(|e| e.to_string())?;
+    }
+
+    let mut files = Vec::new();
+    let mut entries = tokio::fs::read_dir(&target_dir)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    while let Some(entry) = entries.next_entry().await.map_err(|e| e.to_string())? {
+        let metadata = entry.metadata().await.map_err(|e| e.to_string())?;
+        let modified = metadata
+            .modified()
+            .ok()
+            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+            .map(|d| d.as_secs() as i64)
+            .unwrap_or(0);
+
+        files.push(FileInfo {
+            name: entry.file_name().to_string_lossy().to_string(),
+            path: entry.path().to_string_lossy().to_string(),
+            is_directory: metadata.is_dir(),
+            size: metadata.len(),
+            modified,
+        });
+    }
+
+    // Sort: directories first, then by name
+    files.sort_by(|a, b| {
+        b.is_directory
+            .cmp(&a.is_directory)
+            .then(a.name.to_lowercase().cmp(&b.name.to_lowercase()))
+    });
+
+    Ok(files)
+}
+
+/// Delete a file in an instance directory
+#[tauri::command]
+async fn delete_instance_file(path: String) -> Result<(), String> {
+    let path_buf = std::path::PathBuf::from(&path);
+    if path_buf.is_dir() {
+        tokio::fs::remove_dir_all(&path_buf)
+            .await
+            .map_err(|e| e.to_string())?;
+    } else {
+        tokio::fs::remove_file(&path_buf)
+            .await
+            .map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+/// Open instance directory in system file explorer
+#[tauri::command]
+async fn open_file_explorer(path: String) -> Result<(), String> {
+    #[cfg(target_os = "windows")]
+    {
+        std::process::Command::new("explorer")
+            .arg(&path)
+            .spawn()
+            .map_err(|e| e.to_string())?;
+    }
+    #[cfg(target_os = "macos")]
+    {
+        std::process::Command::new("open")
+            .arg(&path)
+            .spawn()
+            .map_err(|e| e.to_string())?;
+    }
+    #[cfg(target_os = "linux")]
+    {
+        std::process::Command::new("xdg-open")
+            .arg(&path)
+            .spawn()
+            .map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
 fn main() {
     tauri::Builder::default()
         .plugin(tauri_plugin_fs::init())
@@ -2529,7 +2641,10 @@ fn main() {
             set_active_instance,
             get_active_instance,
             duplicate_instance,
-            migrate_shared_caches
+            migrate_shared_caches,
+            list_instance_directory,
+            delete_instance_file,
+            open_file_explorer
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");