refactor: streamline runtime management surfaces

2026-03-27 09:16:52 -03:00
1 parent c91cbe51f2
commit ae3b69b27e
@@ -62,14 +62,6 @@ Copia um arquivo `.gguf` para um diretorio de modelos.
 ## Configuracao e paths
 ### `save_config`
 Compatibilidade legada para salvar `RuntimeConfig` em arquivo.
 ### `load_config`
 Leitura da configuracao persistida.
 ### `find_server_binary`
 Resolve o caminho do binario `localllm` para diagnostico e start local.
@@ -78,15 +70,7 @@ Resolve o caminho do binario `localllm` para diagnostico e start local.
 Retorna o diretorio de dados do app.
-## Comandos legados de compatibilidade
+O backend desktop agora expoe apenas a superficie unificada do runtime manager para configuracao e ciclo de vida.
 O backend ainda expoe:
 - `start_server`
 - `stop_server`
 - `server_status`
 Esses comandos existem como shims de compatibilidade. O fluxo principal do frontend atual deve preferir o runtime manager unificado (`bootstrap_runtime_command`, `get_runtime_snapshot_command`, `save_runtime_config_command_handler`, `start_runtime_command`, `stop_runtime_command`).
 ## Tipos principais
@@ -0,0 +1,69 @@
 use std::process::Command;
 #[derive(serde::Serialize, Clone, Debug, PartialEq, Eq)]
 pub struct GpuInfo {
    pub name: String,
    pub vram_mib: u32,
    pub recommended_layers: i32,
 }
 fn parse_gpu_info(stdout: &str) -> Result<GpuInfo, String> {
    let line = stdout.lines().next().unwrap_or("").trim();
    if line.is_empty() {
        return Err("No GPU found".into());
    }
    let parts: Vec<&str> = line.splitn(2, ',').collect();
    if parts.len() < 2 {
        return Err(format!("Unexpected nvidia-smi output: {line}"));
    }
    let name = parts[0].trim().to_string();
    let vram_mib: u32 = parts[1].trim().parse().unwrap_or(0);
    let usable = vram_mib.saturating_sub(1024);
    let recommended_layers = (usable / 80).min(200) as i32;
    Ok(GpuInfo {
        name,
        vram_mib,
        recommended_layers,
    })
 }
 #[tauri::command]
 pub fn query_gpu() -> Result<GpuInfo, String> {
    let output = Command::new("nvidia-smi")
        .args([
            "--query-gpu=name,memory.total",
            "--format=csv,noheader,nounits",
        ])
        .output()
        .map_err(|_| "nvidia-smi not found — no NVIDIA GPU detected".to_string())?;
    if !output.status.success() {
        return Err("nvidia-smi failed — no NVIDIA GPU detected".into());
    }
    parse_gpu_info(&String::from_utf8_lossy(&output.stdout))
 }
 #[cfg(test)]
 mod tests {
    use super::parse_gpu_info;
    #[test]
    fn parse_gpu_info_accepts_valid_csv_line() {
        let info = parse_gpu_info("RTX 4090,24564\n").expect("parse gpu info");
        assert_eq!(info.name, "RTX 4090");
        assert_eq!(info.vram_mib, 24564);
        assert_eq!(info.recommended_layers, 200);
    }
    #[test]
    fn parse_gpu_info_rejects_malformed_output() {
        let error = parse_gpu_info("RTX 4090").expect_err("reject malformed output");
        assert!(error.contains("Unexpected nvidia-smi output"));
    }
 }
@@ -1,53 +1,14 @@
 use std::path::Path;
 use std::process::Command;
 use tauri::{AppHandle, Manager, State};
 use tauri_plugin_dialog::DialogExt;
 mod gpu;
 mod model_files;
 mod runtime;
 use runtime::config::{load_runtime_config, save_runtime_config};
 use runtime::process::find_localllm_binary;
 use runtime::types::{RuntimeConfig, RuntimeSnapshot};
 use runtime::{bootstrap_runtime, get_runtime_snapshot, save_runtime_config_command, start_runtime, stop_runtime, RuntimeState};
-
+use gpu::query_gpu;
-// ─── GPU ──────────────────────────────────────────────────────────────────────
+use model_files::{import_model, pick_model_files, pick_models_dir, scan_models};
 #[derive(serde::Serialize)]
 pub struct GpuInfo {
    pub name: String,
    pub vram_mib: u32,
    pub recommended_layers: i32,
 }
 #[tauri::command]
 fn query_gpu() -> Result<GpuInfo, String> {
    let output = Command::new("nvidia-smi")
        .args(["--query-gpu=name,memory.total", "--format=csv,noheader,nounits"])
        .output()
        .map_err(|_| "nvidia-smi not found — no NVIDIA GPU detected".to_string())?;
    if !output.status.success() {
        return Err("nvidia-smi failed — no NVIDIA GPU detected".into());
    }
    let stdout = String::from_utf8_lossy(&output.stdout);
    let line = stdout.lines().next().unwrap_or("").trim().to_string();
    if line.is_empty() {
        return Err("No GPU found".into());
    }
    let parts: Vec<&str> = line.splitn(2, ',').collect();
    if parts.len() < 2 {
        return Err(format!("Unexpected nvidia-smi output: {line}"));
    }
    let name = parts[0].trim().to_string();
    let vram_mib: u32 = parts[1].trim().parse().unwrap_or(0);
    let usable = vram_mib.saturating_sub(1024);
    let recommended_layers = (usable / 80).min(200) as i32;
    Ok(GpuInfo { name, vram_mib, recommended_layers })
 }
 // ─── Server lifecycle ─────────────────────────────────────────────────────────
@@ -86,189 +47,6 @@ fn stop_runtime_command(state: State<RuntimeState>) -> Result<RuntimeSnapshot, S
    stop_runtime(state)
 }
 #[tauri::command]
 fn start_server(
    app: AppHandle,
    state: State<RuntimeState>,
    model_path: String,
    addr: String,
    gpu_layers: i32,
    ctx_size: u32,
 ) -> Result<String, String> {
    let mut config = load_runtime_config(&app).unwrap_or_default();
    config.connection_mode = runtime::types::ConnectionMode::Local;
    config.model_path = Some(model_path);
    config.addr = addr;
    config.gpu_layers = gpu_layers;
    config.ctx_size = ctx_size;
    save_runtime_config(&app, &config)?;
    let snapshot = start_runtime(app, state)?;
    Ok(format!("Local API {}", snapshot.resolved_url))
 }
 #[tauri::command]
 fn stop_server(state: State<RuntimeState>) -> Result<String, String> {
    let snapshot = stop_runtime(state)?;
    Ok(format!("Local API stopped ({})", snapshot.resolved_url))
 }
 #[tauri::command]
 fn server_status(state: State<RuntimeState>) -> String {
    match get_runtime_snapshot(state) {
        Ok(snapshot) if snapshot.process_running => "running".into(),
        _ => "stopped".into(),
    }
 }
 // ─── Model files ──────────────────────────────────────────────────────────────
 #[derive(serde::Serialize, serde::Deserialize, Clone)]
 pub struct ModelFile {
    pub name: String,
    pub path: String,
 }
 /// Scan a directory for .gguf model files.
 #[tauri::command]
 fn scan_models(dir: String) -> Result<Vec<ModelFile>, String> {
    let path = Path::new(&dir);
    if !path.exists() {
        return Err(format!("Directory not found: {dir}"));
    }
    if !path.is_dir() {
        return Err(format!("Not a directory: {dir}"));
    }
    let entries = std::fs::read_dir(path).map_err(|e| e.to_string())?;
    let mut models = Vec::new();
    for entry in entries.flatten() {
        let p = entry.path();
        if p.is_file() {
            if let Some(ext) = p.extension() {
                if ext.eq_ignore_ascii_case("gguf") {
                    let name = p.file_name().unwrap_or_default().to_string_lossy().to_string();
                    let full_path = p.to_string_lossy().to_string();
                    models.push(ModelFile { name, path: full_path });
                }
            }
        }
    }
    models.sort_by(|a, b| a.name.cmp(&b.name));
    Ok(models)
 }
 /// Open a native folder picker and scan the chosen directory for .gguf files.
 /// Returns (chosen_dir, models[]).
 #[derive(serde::Serialize)]
 pub struct PickDirResult {
    pub dir: String,
    pub models: Vec<ModelFile>,
 }
 #[tauri::command]
 async fn pick_models_dir(app: AppHandle) -> Result<PickDirResult, String> {
    let folder = app
        .dialog()
        .file()
        .set_title("Select models folder")
        .blocking_pick_folder();
    match folder {
        Some(path) => {
            let dir = path.to_string();
            let models = scan_models(dir.clone())?;
            Ok(PickDirResult { dir, models })
        }
        None => Err("cancelled".into()),
    }
 }
 /// Open a native multi-file picker filtered to .gguf files.
 /// Returns the selected ModelFile list (files in their original locations — no copy).
 #[tauri::command]
 async fn pick_model_files(app: AppHandle) -> Result<Vec<ModelFile>, String> {
    let files = app
        .dialog()
        .file()
        .set_title("Select model files")
        .add_filter("GGUF models", &["gguf"])
        .blocking_pick_files();
    match files {
        Some(paths) => {
            let models: Vec<ModelFile> = paths
                .iter()
                .map(|p| {
                    let path_str = p.to_string();
                    let name = Path::new(&path_str)
                        .file_name()
                        .unwrap_or_default()
                        .to_string_lossy()
                        .to_string();
                    ModelFile { name, path: path_str }
                })
                .collect();
            Ok(models)
        }
        None => Err("cancelled".into()),
    }
 }
 /// Copy a .gguf file into the models directory.
 #[tauri::command]
 fn import_model(src_path: String, dest_dir: String) -> Result<ModelFile, String> {
    let src = Path::new(&src_path);
    if !src.exists() {
        return Err(format!("Source file not found: {src_path}"));
    }
    if !src.is_file() {
        return Err("Source is not a file".into());
    }
    let ext = src.extension().unwrap_or_default();
    if !ext.eq_ignore_ascii_case("gguf") {
        return Err("Only .gguf files are supported".into());
    }
    let dest_dir_path = Path::new(&dest_dir);
    if !dest_dir_path.exists() {
        std::fs::create_dir_all(dest_dir_path)
            .map_err(|e| format!("Failed to create models directory: {e}"))?;
    }
    let file_name = src.file_name().unwrap_or_default();
    let dest_path = dest_dir_path.join(file_name);
    if src == dest_path {
        return Ok(ModelFile {
            name: file_name.to_string_lossy().to_string(),
            path: dest_path.to_string_lossy().to_string(),
        });
    }
    std::fs::copy(src, &dest_path).map_err(|e| format!("Failed to copy model: {e}"))?;
    Ok(ModelFile {
        name: file_name.to_string_lossy().to_string(),
        path: dest_path.to_string_lossy().to_string(),
    })
 }
 // ─── Persistent config ────────────────────────────────────────────────────────
 /// All user-configurable settings, persisted to app data dir as config.json.
 #[tauri::command]
 fn save_config(app: AppHandle, config: RuntimeConfig) -> Result<(), String> {
    save_runtime_config(&app, &config)?;
    Ok(())
 }
 #[tauri::command]
 fn load_config(app: AppHandle) -> Result<RuntimeConfig, String> {
    load_runtime_config(&app)
 }
 /// Returns the resolved path to the localllm binary (useful for debugging).
 #[tauri::command]
 fn find_server_binary() -> Result<String, String> {
@@ -308,11 +86,6 @@ pub fn run() {
            save_runtime_config_command_handler,
            start_runtime_command,
            stop_runtime_command,
            start_server,
            stop_server,
            server_status,
            save_config,
            load_config,
            get_app_data_dir,
            find_server_binary,
        ])
@@ -0,0 +1,188 @@
 use std::path::Path;
 use tauri::AppHandle;
 use tauri_plugin_dialog::DialogExt;
 #[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct ModelFile {
    pub name: String,
    pub path: String,
 }
 #[derive(serde::Serialize)]
 pub struct PickDirResult {
    pub dir: String,
    pub models: Vec<ModelFile>,
 }
 fn model_file_from_path(path: &Path) -> ModelFile {
    ModelFile {
        name: path
            .file_name()
            .unwrap_or_default()
            .to_string_lossy()
            .to_string(),
        path: path.to_string_lossy().to_string(),
    }
 }
 fn scan_model_dir(path: &Path) -> Result<Vec<ModelFile>, String> {
    if !path.exists() {
        return Err(format!("Directory not found: {}", path.display()));
    }
    if !path.is_dir() {
        return Err(format!("Not a directory: {}", path.display()));
    }
    let entries = std::fs::read_dir(path).map_err(|e| e.to_string())?;
    let mut models = Vec::new();
    for entry in entries.flatten() {
        let path = entry.path();
        if path.is_file()
            && path
            .extension()
            .map(|ext| ext.eq_ignore_ascii_case("gguf"))
            .unwrap_or(false)
        {
            models.push(model_file_from_path(&path));
        }
    }
    models.sort_by(|a, b| a.name.cmp(&b.name));
    Ok(models)
 }
 fn import_model_file(src: &Path, dest_dir: &Path) -> Result<ModelFile, String> {
    if !src.exists() {
        return Err(format!("Source file not found: {}", src.display()));
    }
    if !src.is_file() {
        return Err("Source is not a file".into());
    }
    if !src
        .extension()
        .unwrap_or_default()
        .eq_ignore_ascii_case("gguf")
    {
        return Err("Only .gguf files are supported".into());
    }
    if !dest_dir.exists() {
        std::fs::create_dir_all(dest_dir)
            .map_err(|e| format!("Failed to create models directory: {e}"))?;
    }
    let file_name = src.file_name().unwrap_or_default();
    let dest_path = dest_dir.join(file_name);
    if src == dest_path {
        return Ok(model_file_from_path(&dest_path));
    }
    std::fs::copy(src, &dest_path).map_err(|e| format!("Failed to copy model: {e}"))?;
    Ok(model_file_from_path(&dest_path))
 }
 #[tauri::command]
 pub fn scan_models(dir: String) -> Result<Vec<ModelFile>, String> {
    scan_model_dir(Path::new(&dir))
 }
 #[tauri::command]
 pub async fn pick_models_dir(app: AppHandle) -> Result<PickDirResult, String> {
    let folder = app
        .dialog()
        .file()
        .set_title("Select models folder")
        .blocking_pick_folder();
    match folder {
        Some(path) => {
            let dir = path.to_string();
            let models = scan_model_dir(Path::new(&dir))?;
            Ok(PickDirResult { dir, models })
        }
        None => Err("cancelled".into()),
    }
 }
 #[tauri::command]
 pub async fn pick_model_files(app: AppHandle) -> Result<Vec<ModelFile>, String> {
    let files = app
        .dialog()
        .file()
        .set_title("Select model files")
        .add_filter("GGUF models", &["gguf"])
        .blocking_pick_files();
    match files {
        Some(paths) => Ok(paths.iter().map(|path| model_file_from_path(Path::new(&path.to_string()))).collect()),
        None => Err("cancelled".into()),
    }
 }
 #[tauri::command]
 pub fn import_model(src_path: String, dest_dir: String) -> Result<ModelFile, String> {
    import_model_file(Path::new(&src_path), Path::new(&dest_dir))
 }
 #[cfg(test)]
 mod tests {
    use super::{import_model_file, scan_model_dir};
    use std::path::PathBuf;
    use std::time::{SystemTime, UNIX_EPOCH};
    fn temp_path(name: &str) -> PathBuf {
        let unique = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("system time")
            .as_nanos();
        std::env::temp_dir().join(format!("forgelm-{name}-{unique}"))
    }
    #[test]
    fn scan_model_dir_filters_and_sorts_gguf_files() {
        let dir = temp_path("scan-models");
        std::fs::create_dir_all(&dir).expect("create temp dir");
        std::fs::write(dir.join("zeta.gguf"), b"demo").expect("write zeta");
        std::fs::write(dir.join("alpha.gguf"), b"demo").expect("write alpha");
        std::fs::write(dir.join("notes.txt"), b"ignore").expect("write non-model file");
        let models = scan_model_dir(&dir).expect("scan model dir");
        let names: Vec<_> = models.into_iter().map(|model| model.name).collect();
        assert_eq!(names, vec!["alpha.gguf", "zeta.gguf"]);
        let _ = std::fs::remove_dir_all(&dir);
    }
    #[test]
    fn scan_model_dir_ignores_directories_named_like_models() {
        let dir = temp_path("scan-model-dirs");
        std::fs::create_dir_all(dir.join("folder.gguf")).expect("create fake model dir");
        std::fs::write(dir.join("real.gguf"), b"demo").expect("write model file");
        let models = scan_model_dir(&dir).expect("scan model dir");
        let names: Vec<_> = models.into_iter().map(|model| model.name).collect();
        assert_eq!(names, vec!["real.gguf"]);
        let _ = std::fs::remove_dir_all(&dir);
    }
    #[test]
    fn import_model_file_returns_existing_model_when_source_matches_destination() {
        let dir = temp_path("import-model");
        std::fs::create_dir_all(&dir).expect("create temp dir");
        let model_path = dir.join("demo.gguf");
        std::fs::write(&model_path, b"demo").expect("write demo model");
        let model = import_model_file(&model_path, &dir).expect("import model file");
        assert_eq!(model.name, "demo.gguf");
        assert_eq!(PathBuf::from(model.path), model_path);
        let _ = std::fs::remove_dir_all(&dir);
    }
 }
@@ -1,129 +1,18 @@
 pub mod config;
 pub mod health;
 pub mod process;
 pub mod state;
 pub mod types;
 use std::process::Child;
 use std::sync::Mutex;
 use std::time::Duration;
 use tauri::{AppHandle, State};
 use self::config::{load_runtime_config, save_runtime_config};
-use self::health::{check_health, wait_for_health};
+use self::health::wait_for_health;
-use self::process::{find_localllm_binary, spawn_localllm};
+use self::process::spawn_localllm;
-use self::types::{
+use self::state::{build_snapshot, refresh_process_state, requires_runtime_restart, runtime_error};
-    ConnectionMode, RuntimeConfig, RuntimeErrorInfo, RuntimeSnapshot, RuntimeStatus, StartPolicy,
+use self::types::{ConnectionMode, RuntimeConfig, RuntimeSnapshot, RuntimeStatus, StartPolicy};
 };
 pub struct RuntimeInner {
    pub child: Option<Child>,
    pub status: RuntimeStatus,
    pub last_error: Option<RuntimeErrorInfo>,
    pub config: RuntimeConfig,
 }
 pub struct RuntimeState(pub Mutex<RuntimeInner>);
 impl RuntimeState {
    pub fn new() -> Self {
        Self(Mutex::new(RuntimeInner {
            child: None,
            status: RuntimeStatus::Stopped,
            last_error: None,
            config: RuntimeConfig::default(),
        }))
    }
 }
 fn runtime_error(code: &str, message: impl Into<String>) -> RuntimeErrorInfo {
    RuntimeErrorInfo {
        code: code.to_string(),
        message: message.into(),
    }
 }
 fn resolve_runtime_url(config: &RuntimeConfig) -> String {
    match config.connection_mode {
        ConnectionMode::Local => format!("http://{}", config.addr.trim()),
        ConnectionMode::Remote => config.server_url.trim().trim_end_matches('/').to_string(),
    }
 }
 fn requires_runtime_restart(current: &RuntimeConfig, next: &RuntimeConfig) -> bool {
    current.connection_mode != next.connection_mode
        || current.model_path != next.model_path
        || current.addr != next.addr
        || current.gpu_layers != next.gpu_layers
        || current.ctx_size != next.ctx_size
 }
 fn refresh_process_state(inner: &mut RuntimeInner) {
    let Some(child) = inner.child.as_mut() else {
        if matches!(
            inner.status,
            RuntimeStatus::Starting | RuntimeStatus::Ready | RuntimeStatus::Degraded
        ) {
            inner.status = RuntimeStatus::Stopped;
        }
        return;
    };
    match child.try_wait() {
        Ok(Some(status)) => {
            inner.child = None;
            inner.status = RuntimeStatus::Error;
            inner.last_error = Some(runtime_error(
                "unexpected_exit",
                format!("Local API exited unexpectedly with status {status}"),
            ));
        }
        Ok(None) => {
            if inner.status == RuntimeStatus::Stopped {
                inner.status = RuntimeStatus::Ready;
            }
            if inner.config.connection_mode == ConnectionMode::Local
                && matches!(inner.status, RuntimeStatus::Ready | RuntimeStatus::Degraded)
            {
                if check_health(&inner.config.addr, Duration::from_millis(400)) {
                    inner.status = RuntimeStatus::Ready;
                    if inner.last_error.as_ref().map(|error| error.code.as_str())
                        == Some("health_check_failed")
                    {
                        inner.last_error = None;
                    }
                } else {
                    inner.status = RuntimeStatus::Degraded;
                    inner.last_error = Some(runtime_error(
                        "health_check_failed",
                        format!(
                            "Local API process is still running, but /health is no longer ready on {}.",
                            inner.config.addr
                        ),
                    ));
                }
            }
        }
        Err(error) => {
            inner.child = None;
            inner.status = RuntimeStatus::Error;
            inner.last_error = Some(runtime_error("process_probe_failed", error.to_string()));
        }
    }
 }
 fn build_snapshot(inner: &RuntimeInner) -> RuntimeSnapshot {
    RuntimeSnapshot {
        status: inner.status,
        ready: inner.status == RuntimeStatus::Ready,
        process_running: inner.child.is_some(),
        resolved_url: resolve_runtime_url(&inner.config),
        binary_path: find_localllm_binary().map(|path| path.to_string_lossy().to_string()),
        last_error: inner.last_error.clone(),
        config: inner.config.clone(),
    }
 }
 pub fn get_runtime_snapshot(state: State<'_, RuntimeState>) -> Result<RuntimeSnapshot, String> {
    let mut inner = state.0.lock().map_err(|e| e.to_string())?;
@@ -275,115 +164,4 @@ pub fn stop_runtime(state: State<'_, RuntimeState>) -> Result<RuntimeSnapshot, S
    Ok(build_snapshot(&inner))
 }
-#[cfg(test)]
+pub use state::RuntimeState;
 mod tests {
    use super::*;
    fn spawn_healthy_server() -> String {
        let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind healthy port");
        let addr = listener
            .local_addr()
            .expect("read healthy addr")
            .to_string();
        std::thread::spawn(move || {
            if let Ok((mut stream, _)) = listener.accept() {
                use std::io::{Read, Write};
                let mut buffer = [0_u8; 1024];
                let _ = stream.read(&mut buffer);
                let _ = stream.write_all(
                    b"HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: 58\r\n\r\n{\"status\":\"ok\",\"model_loaded\":true,\"model_id\":\"demo\"}",
                );
                let _ = stream.flush();
            }
        });
        addr
    }
    fn unused_local_addr() -> String {
        let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind unused port");
        let addr = listener.local_addr().expect("read local addr").to_string();
        drop(listener);
        addr
    }
    fn spawn_sleeping_child() -> Child {
        std::process::Command::new("python")
            .args(["-c", "import time; time.sleep(60)"])
            .spawn()
            .expect("spawn sleeping child")
    }
    #[test]
    fn runtime_revalidation_marks_unhealthy_local_process_as_degraded() {
        let mut child = spawn_sleeping_child();
        let addr = unused_local_addr();
        let (status, error_code) = {
            let mut inner = RuntimeInner {
                child: Some(child),
                status: RuntimeStatus::Ready,
                last_error: None,
                config: RuntimeConfig {
                    model_path: Some("D:/models/demo.gguf".to_string()),
                    addr,
                    ..RuntimeConfig::default()
                },
            };
            refresh_process_state(&mut inner);
            child = inner.child.take().expect("process remains managed");
            (
                inner.status,
                inner.last_error.as_ref().map(|error| error.code.clone()),
            )
        };
        let _ = child.kill();
        let _ = child.wait();
        assert_eq!(status, RuntimeStatus::Degraded);
        assert_eq!(error_code.as_deref(), Some("health_check_failed"));
    }
    #[test]
    fn runtime_revalidation_restores_local_process_to_ready_after_health_recovers() {
        let mut child = spawn_sleeping_child();
        let addr = spawn_healthy_server();
        let (status, error_code) = {
            let mut inner = RuntimeInner {
                child: Some(child),
                status: RuntimeStatus::Degraded,
                last_error: Some(runtime_error(
                    "health_check_failed",
                    "Local API process is still running, but /health is no longer ready.",
                )),
                config: RuntimeConfig {
                    model_path: Some("D:/models/demo.gguf".to_string()),
                    addr,
                    ..RuntimeConfig::default()
                },
            };
            refresh_process_state(&mut inner);
            child = inner.child.take().expect("process remains managed");
            (
                inner.status,
                inner.last_error.as_ref().map(|error| error.code.clone()),
            )
        };
        let _ = child.kill();
        let _ = child.wait();
        assert_eq!(status, RuntimeStatus::Ready);
        assert_eq!(error_code, None);
    }
 }
@@ -0,0 +1,231 @@
 use std::process::Child;
 use std::sync::Mutex;
 use std::time::Duration;
 use super::health::check_health;
 use super::process::find_localllm_binary;
 use super::types::{
    ConnectionMode, RuntimeConfig, RuntimeErrorInfo, RuntimeSnapshot, RuntimeStatus,
 };
 pub struct RuntimeInner {
    pub child: Option<Child>,
    pub status: RuntimeStatus,
    pub last_error: Option<RuntimeErrorInfo>,
    pub config: RuntimeConfig,
 }
 pub struct RuntimeState(pub Mutex<RuntimeInner>);
 impl RuntimeState {
    pub fn new() -> Self {
        Self(Mutex::new(RuntimeInner {
            child: None,
            status: RuntimeStatus::Stopped,
            last_error: None,
            config: RuntimeConfig::default(),
        }))
    }
 }
 pub(crate) fn runtime_error(code: &str, message: impl Into<String>) -> RuntimeErrorInfo {
    RuntimeErrorInfo {
        code: code.to_string(),
        message: message.into(),
    }
 }
 fn resolve_runtime_url(config: &RuntimeConfig) -> String {
    match config.connection_mode {
        ConnectionMode::Local => format!("http://{}", config.addr.trim()),
        ConnectionMode::Remote => config.server_url.trim().trim_end_matches('/').to_string(),
    }
 }
 pub(crate) fn requires_runtime_restart(current: &RuntimeConfig, next: &RuntimeConfig) -> bool {
    current.connection_mode != next.connection_mode
        || current.model_path != next.model_path
        || current.addr != next.addr
        || current.gpu_layers != next.gpu_layers
        || current.ctx_size != next.ctx_size
 }
 pub(crate) fn refresh_process_state(inner: &mut RuntimeInner) {
    let Some(child) = inner.child.as_mut() else {
        if matches!(
            inner.status,
            RuntimeStatus::Starting | RuntimeStatus::Ready | RuntimeStatus::Degraded
        ) {
            inner.status = RuntimeStatus::Stopped;
        }
        return;
    };
    match child.try_wait() {
        Ok(Some(status)) => {
            inner.child = None;
            inner.status = RuntimeStatus::Error;
            inner.last_error = Some(runtime_error(
                "unexpected_exit",
                format!("Local API exited unexpectedly with status {status}"),
            ));
        }
        Ok(None) => {
            if inner.status == RuntimeStatus::Stopped {
                inner.status = RuntimeStatus::Ready;
            }
            if inner.config.connection_mode == ConnectionMode::Local
                && matches!(inner.status, RuntimeStatus::Ready | RuntimeStatus::Degraded)
            {
                if check_health(&inner.config.addr, Duration::from_millis(400)) {
                    inner.status = RuntimeStatus::Ready;
                    if inner.last_error.as_ref().map(|error| error.code.as_str())
                        == Some("health_check_failed")
                    {
                        inner.last_error = None;
                    }
                } else {
                    inner.status = RuntimeStatus::Degraded;
                    inner.last_error = Some(runtime_error(
                        "health_check_failed",
                        format!(
                            "Local API process is still running, but /health is no longer ready on {}.",
                            inner.config.addr
                        ),
                    ));
                }
            }
        }
        Err(error) => {
            inner.child = None;
            inner.status = RuntimeStatus::Error;
            inner.last_error = Some(runtime_error("process_probe_failed", error.to_string()));
        }
    }
 }
 pub(crate) fn build_snapshot(inner: &RuntimeInner) -> RuntimeSnapshot {
    RuntimeSnapshot {
        status: inner.status,
        ready: inner.status == RuntimeStatus::Ready,
        process_running: inner.child.is_some(),
        resolved_url: resolve_runtime_url(&inner.config),
        binary_path: find_localllm_binary().map(|path| path.to_string_lossy().to_string()),
        last_error: inner.last_error.clone(),
        config: inner.config.clone(),
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn spawn_healthy_server() -> String {
        let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind healthy port");
        let addr = listener
            .local_addr()
            .expect("read healthy addr")
            .to_string();
        std::thread::spawn(move || {
            if let Ok((mut stream, _)) = listener.accept() {
                use std::io::{Read, Write};
                let mut buffer = [0_u8; 1024];
                let _ = stream.read(&mut buffer);
                let _ = stream.write_all(
                    b"HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: 58\r\n\r\n{\"status\":\"ok\",\"model_loaded\":true,\"model_id\":\"demo\"}",
                );
                let _ = stream.flush();
            }
        });
        addr
    }
    fn unused_local_addr() -> String {
        let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind unused port");
        let addr = listener.local_addr().expect("read local addr").to_string();
        drop(listener);
        addr
    }
    fn spawn_sleeping_child() -> Child {
        std::process::Command::new("python")
            .args(["-c", "import time; time.sleep(60)"])
            .spawn()
            .expect("spawn sleeping child")
    }
    #[test]
    fn runtime_revalidation_marks_unhealthy_local_process_as_degraded() {
        let mut child = spawn_sleeping_child();
        let addr = unused_local_addr();
        let (status, error_code) = {
            let mut inner = RuntimeInner {
                child: Some(child),
                status: RuntimeStatus::Ready,
                last_error: None,
                config: RuntimeConfig {
                    model_path: Some("D:/models/demo.gguf".to_string()),
                    addr,
                    ..RuntimeConfig::default()
                },
            };
            refresh_process_state(&mut inner);
            child = inner.child.take().expect("process remains managed");
            let error_code: Option<String> =
                inner.last_error.as_ref().map(|error| error.code.clone());
            (inner.status, error_code)
        };
        let _ = child.kill();
        let _ = child.wait();
        assert_eq!(status, RuntimeStatus::Degraded);
        assert_eq!(error_code.as_deref(), Some("health_check_failed"));
    }
    #[test]
    fn runtime_revalidation_restores_local_process_to_ready_after_health_recovers() {
        let mut child = spawn_sleeping_child();
        let addr = spawn_healthy_server();
        let (status, error_code) = {
            let mut inner = RuntimeInner {
                child: Some(child),
                status: RuntimeStatus::Degraded,
                last_error: Some(runtime_error(
                    "health_check_failed",
                    "Local API process is still running, but /health is no longer ready.",
                )),
                config: RuntimeConfig {
                    model_path: Some("D:/models/demo.gguf".to_string()),
                    addr,
                    ..RuntimeConfig::default()
                },
            };
            refresh_process_state(&mut inner);
            child = inner.child.take().expect("process remains managed");
            let error_code: Option<String> =
                inner.last_error.as_ref().map(|error| error.code.clone());
            (inner.status, error_code)
        };
        let _ = child.kill();
        let _ = child.wait();
        assert_eq!(status, RuntimeStatus::Ready);
        assert_eq!(error_code, None);
    }
 }
@@ -4,6 +4,7 @@ import ChatView from "./components/ChatView";
 import { useDB } from "./hooks/useDB";
 import { useModels } from "./hooks/useModels";
 import { useRuntimeManager } from "./features/runtime/useRuntimeManager";
 import { useRuntimeReadyModelRefresh } from "./features/runtime/useRuntimeReadyModelRefresh";
 import type { Chat } from "./lib/types";
 import "./App.css";
@@ -19,12 +20,7 @@ export default function App() {
    Boolean(runtime.connection.serverUrl),
  );
-  // Auto-refresh models when server starts
+  useRuntimeReadyModelRefresh(runtime.snapshot.status, refreshModels);
  useEffect(() => {
    if (runtime.snapshot.status === "ready") {
      setTimeout(refreshModels, 2000);
    }
  }, [runtime.snapshot.status, refreshModels]);
  const loadChats = useCallback(() => {
    if (!db) return;
@@ -1,580 +0,0 @@
 .server-panel {
  margin: 8px 10px;
  border-radius: var(--radius);
  background: var(--bg3);
  border: 1px solid var(--border);
  overflow: hidden;
  transition: box-shadow 0.2s;
 }
 .server-panel:has(.server-panel-body) {
  box-shadow: 0 2px 12px rgba(0,0,0,0.3);
 }
 /* ── Header ── */
 .server-panel-header {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: 10px 12px;
  cursor: pointer;
  user-select: none;
  transition: background 0.15s;
 }
 .server-panel-header:hover {
  background: rgba(255,255,255,0.03);
 }
 .server-panel-title {
  display: flex;
  align-items: center;
  gap: 8px;
 }
 .server-status-dot {
  width: 8px;
  height: 8px;
  border-radius: 50%;
  flex-shrink: 0;
  transition: background 0.3s, box-shadow 0.3s;
 }
 .server-panel-label {
  font-size: 12px;
  font-weight: 600;
  color: var(--text);
  letter-spacing: 0.01em;
 }
 .server-panel-header-right {
  display: flex;
  align-items: center;
  gap: 8px;
 }
 .server-status-badge {
  font-size: 10px;
  font-weight: 700;
  letter-spacing: 0.04em;
  text-transform: uppercase;
  transition: color 0.3s;
 }
 .server-panel-chevron {
  font-size: 9px;
  color: var(--text3);
  transition: transform 0.2s;
 }
 /* ── Body ── */
 .server-panel-body {
  padding: 4px 12px 12px;
  display: flex;
  flex-direction: column;
  gap: 4px;
  border-top: 1px solid var(--border);
  animation: sp-expand 0.15s ease;
 }
@keyframes sp-expand {
  from { opacity: 0; transform: translateY(-4px); }
  to   { opacity: 1; transform: translateY(0); }
 }
 /* ── GPU badge ── */
 .sp-gpu-badge {
  display: flex;
  align-items: center;
  gap: 6px;
  font-size: 11px;
  font-weight: 500;
  color: var(--success);
  background: rgba(48, 209, 88, 0.08);
  border: 1px solid rgba(48, 209, 88, 0.18);
  border-radius: var(--radius-sm);
  padding: 5px 8px;
  margin-top: 6px;
 }
 .sp-gpu-cpu {
  color: var(--text2);
  background: rgba(255,255,255,0.04);
  border-color: var(--border);
 }
 .sp-gpu-loading {
  color: var(--warning);
  background: rgba(255, 214, 10, 0.07);
  border-color: rgba(255, 214, 10, 0.2);
 }
 .sp-gpu-icon {
  font-size: 12px;
  flex-shrink: 0;
 }
 .sp-gpu-vram {
  margin-left: auto;
  font-size: 10px;
  font-weight: 700;
  color: var(--text2);
  background: rgba(255,255,255,0.06);
  padding: 1px 6px;
  border-radius: 4px;
 }
 /* ── Labels ── */
 .sp-label {
  font-size: 10px;
  font-weight: 700;
  color: var(--text3);
  text-transform: uppercase;
  letter-spacing: 0.06em;
  margin-top: 8px;
 }
 .sp-label-hint {
  color: var(--accent);
  font-weight: 500;
  text-transform: none;
  letter-spacing: 0;
 }
 /* ── Inputs ── */
 .sp-input {
  background: var(--bg4);
  border: 1px solid var(--border);
  border-radius: var(--radius-sm);
  color: var(--text);
  font-size: 12px;
  padding: 7px 9px;
  outline: none;
  width: 100%;
  box-sizing: border-box;
  transition: border-color 0.15s, background 0.15s;
  font-family: inherit;
 }
 .sp-input:focus {
  border-color: var(--accent);
  background: var(--bg5);
 }
 .sp-input:disabled {
  opacity: 0.45;
  cursor: not-allowed;
 }
 .sp-input-num {
  width: 72px;
 }
 /* ── Directory row ── */
 .sp-dir-row {
  display: flex;
  gap: 6px;
  align-items: center;
 }
 .sp-dir-row .sp-input {
  flex: 1;
 }
 .sp-scan-btn {
  background: var(--bg5);
  border: 1px solid var(--border);
  border-radius: var(--radius-sm);
  color: var(--text2);
  font-size: 14px;
  width: 32px;
  height: 32px;
  display: flex;
  align-items: center;
  justify-content: center;
  cursor: pointer;
  flex-shrink: 0;
  transition: background 0.15s, color 0.15s, border-color 0.15s;
  font-family: inherit;
 }
 .sp-scan-btn:hover:not(:disabled) {
  background: var(--accent);
  border-color: var(--accent);
  color: #fff;
 }
 .sp-scan-btn:disabled {
  opacity: 0.4;
  cursor: not-allowed;
 }
 /* ── Model select ── */
 .sp-model-select {
  background: var(--bg4);
  border: 1px solid var(--border);
  border-radius: var(--radius-sm);
  color: var(--text);
  font-size: 12px;
  padding: 7px 9px;
  outline: none;
  width: 100%;
  box-sizing: border-box;
  cursor: pointer;
  font-family: inherit;
  transition: border-color 0.15s;
  appearance: none;
  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' viewBox='0 0 10 6'%3E%3Cpath d='M0 0l5 6 5-6z' fill='%236b7280'/%3E%3C/svg%3E");
  background-repeat: no-repeat;
  background-position: right 9px center;
  padding-right: 28px;
 }
 .sp-model-select:focus {
  border-color: var(--accent);
 }
 .sp-model-select:disabled {
  opacity: 0.45;
  cursor: not-allowed;
 }
 .sp-scan-error {
  font-size: 10px;
  color: var(--danger);
  margin-top: 2px;
  line-height: 1.4;
 }
 /* ── Layers row ── */
 .sp-layers-row {
  display: flex;
  align-items: center;
  gap: 8px;
 }
 .sp-btn-max {
  background: rgba(91,106,240,0.15);
  color: var(--accent);
  border: 1px solid rgba(91,106,240,0.3);
  border-radius: var(--radius-sm);
  padding: 5px 10px;
  font-size: 11px;
  font-weight: 700;
  cursor: pointer;
  transition: background 0.15s, border-color 0.15s;
  font-family: inherit;
  white-space: nowrap;
 }
 .sp-btn-max:hover:not(:disabled) {
  background: rgba(91,106,240,0.25);
  border-color: var(--accent);
 }
 .sp-btn-max:disabled {
  opacity: 0.35;
  cursor: not-allowed;
 }
 .sp-layers-hint {
  font-size: 11px;
  color: var(--text3);
 }
 /* ── VRAM bar ── */
 .sp-vram-bar {
  position: relative;
  height: 20px;
  background: var(--bg4);
  border: 1px solid var(--border);
  border-radius: var(--radius-sm);
  overflow: hidden;
  margin-top: 4px;
 }
 .sp-vram-fill {
  height: 100%;
  background: linear-gradient(90deg, var(--accent), #818cf8);
  transition: width 0.35s ease;
  border-radius: var(--radius-sm);
 }
 .sp-vram-label {
  position: absolute;
  inset: 0;
  display: flex;
  align-items: center;
  justify-content: center;
  font-size: 10px;
  font-weight: 700;
  color: #fff;
  text-shadow: 0 1px 3px rgba(0,0,0,0.7);
  letter-spacing: 0.02em;
 }
 /* ── Action buttons ── */
 .sp-actions {
  margin-top: 10px;
 }
 .sp-btn {
  width: 100%;
  padding: 9px 12px;
  border: none;
  border-radius: var(--radius-sm);
  font-size: 13px;
  font-weight: 700;
  cursor: pointer;
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 7px;
  transition: opacity 0.15s, transform 0.1s, box-shadow 0.15s;
  letter-spacing: 0.01em;
  font-family: inherit;
 }
 .sp-btn:active:not(:disabled) {
  transform: scale(0.98);
 }
 .sp-btn:disabled {
  opacity: 0.4;
  cursor: not-allowed;
 }
 .sp-btn-icon {
  font-size: 11px;
 }
 .sp-btn-start {
  background: linear-gradient(135deg, var(--accent), #7c3aed);
  color: #fff;
  box-shadow: 0 2px 12px rgba(91,106,240,0.3);
 }
 .sp-btn-start:hover:not(:disabled) {
  opacity: 0.9;
  box-shadow: 0 4px 16px rgba(91,106,240,0.45);
 }
 .sp-btn-stop {
  background: rgba(240,64,64,0.15);
  color: var(--danger);
  border: 1px solid rgba(240,64,64,0.3);
 }
 .sp-btn-stop:hover:not(:disabled) {
  background: rgba(240,64,64,0.25);
  border-color: var(--danger);
 }
 /* ── Status message ── */
 .sp-message {
  font-size: 11px;
  color: var(--success);
  margin-top: 6px;
  word-break: break-all;
  line-height: 1.5;
  padding: 5px 8px;
  background: rgba(48,209,88,0.07);
  border-radius: var(--radius-sm);
  border: 1px solid rgba(48,209,88,0.15);
 }
 .sp-message-error {
  color: var(--danger);
  background: rgba(240,64,64,0.07);
  border-color: rgba(240,64,64,0.2);
 }
 /* ── Dir path display ── */
 .sp-dir-path {
  flex: 1;
  font-size: 11px;
  color: var(--text2);
  background: var(--bg4);
  border: 1px solid var(--border);
  border-radius: var(--radius-sm);
  padding: 7px 9px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
  min-width: 0;
 }
 /* ── No models placeholder ── */
 .sp-no-models {
  font-size: 11px;
  color: var(--text3);
  text-align: center;
  padding: 10px 8px;
  background: var(--bg4);
  border: 1px dashed var(--border);
  border-radius: var(--radius-sm);
 }
 /* ── Extra models list ── */
 .sp-extra-models {
  display: flex;
  flex-direction: column;
  gap: 3px;
  margin-top: 4px;
 }
 .sp-extra-model-item {
  display: flex;
  align-items: center;
  gap: 6px;
  background: var(--bg4);
  border: 1px solid var(--border);
  border-radius: var(--radius-sm);
  padding: 4px 8px;
 }
 .sp-extra-model-name {
  flex: 1;
  font-size: 11px;
  color: var(--text2);
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
  min-width: 0;
 }
 .sp-extra-model-remove {
  background: none;
  border: none;
  color: var(--text3);
  font-size: 14px;
  line-height: 1;
  cursor: pointer;
  padding: 0 2px;
  flex-shrink: 0;
  transition: color 0.12s;
  font-family: inherit;
 }
 .sp-extra-model-remove:hover {
  color: var(--danger);
 }
 /* ── Add models button ── */
 .sp-add-models-btn {
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 5px;
  width: 100%;
  padding: 6px 10px;
  background: var(--bg4);
  border: 1px dashed var(--border);
  border-radius: var(--radius-sm);
  color: var(--text2);
  font-size: 11px;
  font-weight: 600;
  cursor: pointer;
  transition: background 0.12s, border-color 0.12s, color 0.12s;
  font-family: inherit;
  margin-top: 4px;
 }
 .sp-add-models-btn:hover {
  background: rgba(91,106,240,0.1);
  border-color: var(--accent);
  color: var(--accent);
 }
 /* ── Drop zone ── */
 .sp-drop-zone {
  position: relative;
  border-radius: var(--radius-sm);
  transition: border-color 0.15s, background 0.15s;
 }
 .sp-drop-zone--active {
  outline: 2px dashed var(--accent);
  outline-offset: 2px;
  background: rgba(91,106,240,0.06);
  border-radius: var(--radius-sm);
 }
 .sp-drop-zone--disabled {
  pointer-events: none;
 }
 .sp-drop-overlay {
  position: absolute;
  inset: 0;
  z-index: 10;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  gap: 6px;
  background: rgba(91,106,240,0.18);
  border-radius: var(--radius-sm);
  backdrop-filter: blur(2px);
  font-size: 12px;
  font-weight: 600;
  color: var(--accent);
  pointer-events: none;
 }
 .sp-drop-icon {
  font-size: 22px;
 }
 .sp-drop-hint {
  font-size: 10px;
  color: var(--text3);
  text-align: center;
  margin-top: 4px;
  padding: 0 2px;
  line-height: 1.4;
 }
 /* ── Context size row ── */
 .sp-ctx-row {
  display: flex;
  flex-direction: column;
  gap: 6px;
 }
 .sp-ctx-presets {
  display: flex;
  flex-wrap: wrap;
  gap: 4px;
 }
 .sp-ctx-preset {
  background: var(--bg4);
  border: 1px solid var(--border);
  border-radius: 4px;
  color: var(--text2);
  font-size: 10px;
  font-weight: 600;
  padding: 3px 7px;
  cursor: pointer;
  transition: background 0.12s, border-color 0.12s, color 0.12s;
  font-family: inherit;
  letter-spacing: 0.02em;
 }
 .sp-ctx-preset:hover:not(:disabled) {
  background: rgba(91,106,240,0.15);
  border-color: var(--accent);
  color: var(--accent);
 }
 .sp-ctx-preset--active {
  background: rgba(91,106,240,0.2);
  border-color: var(--accent);
  color: var(--accent);
 }
 .sp-ctx-preset:disabled {
  opacity: 0.35;
  cursor: not-allowed;
 }
@@ -1,561 +0,0 @@
 import { useState, useEffect, useCallback, useRef } from "react";
 import { invoke } from "@tauri-apps/api/core";
 import type { ProcessStatus, ServerConfig } from "../hooks/useServerProcess";
 import "./ServerPanel.css";
 interface Props {
  status: ProcessStatus;
  message: string;
  onStart: (cfg: ServerConfig) => void;
  onStop: () => void;
 }
 interface GpuInfo {
  name: string;
  vram_mib: number;
  recommended_layers: number;
 }
 interface ModelFile {
  name: string;
  path: string;
 }
 interface PickDirResult {
  dir: string;
  models: ModelFile[];
 }
 interface AppConfig {
  models_dir?: string;
  model_path?: string;
  addr?: string;
  gpu_layers?: number;
  ctx_size?: number;
  api_key?: string;
  server_url?: string;
  extra_model_paths?: string[];
 }
 const STATUS_LABEL: Record<ProcessStatus, string> = {
  stopped: "Stopped",
  starting: "Starting…",
  running: "Running",
  stopping: "Stopping…",
  error: "Error",
 };
 const STATUS_COLOR: Record<ProcessStatus, string> = {
  stopped: "#6b7280",
  starting: "#f59e0b",
  running: "#22c55e",
  stopping: "#f59e0b",
  error: "#ef4444",
 };
 const DEFAULT_CTX = 4096;
 const CTX_PRESETS = [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072];
 export default function ServerPanel({ status, message, onStart, onStop }: Props) {
  const [modelsDir, setModelsDir] = useState<string>("");
  const [scannedModels, setScannedModels] = useState<ModelFile[]>([]);
  const [extraModels, setExtraModels] = useState<ModelFile[]>([]);
  const [selectedModel, setSelectedModel] = useState<string>("");
  const [addr, setAddr] = useState("127.0.0.1:8080");
  const [gpuLayers, setGpuLayers] = useState(0);
  const [ctxSize, setCtxSize] = useState(DEFAULT_CTX);
  const [gpuInfo, setGpuInfo] = useState<GpuInfo | null>(null);
  const [gpuError, setGpuError] = useState<string>("");
  const [expanded, setExpanded] = useState(true);
  const [scanning, setScanning] = useState(false);
  const [scanError, setScanError] = useState("");
  const [isDragOver, setIsDragOver] = useState(false);
  const [configLoaded, setConfigLoaded] = useState(false);
  const dropRef = useRef<HTMLDivElement>(null);
  // All models = scanned from dir + extra picked files (deduplicated by path)
  const allModels: ModelFile[] = [
    ...scannedModels,
    ...extraModels.filter((e) => !scannedModels.some((s) => s.path === e.path)),
  ];
  // ── Persist config to app data dir ──────────────────────────────────────────
  const persistConfig = useCallback(
    async (overrides: Partial<AppConfig> = {}) => {
      const cfg: AppConfig = {
        models_dir: modelsDir || undefined,
        model_path: selectedModel || undefined,
        addr,
        gpu_layers: gpuLayers,
        ctx_size: ctxSize,
        extra_model_paths: extraModels.map((m) => m.path),
        ...overrides,
      };
      try {
        await invoke("save_config", { config: cfg });
      } catch {
        // Fallback to localStorage if not in Tauri context
        localStorage.setItem("forgelm_config", JSON.stringify(cfg));
      }
    },
    [modelsDir, selectedModel, addr, gpuLayers, ctxSize, extraModels]
  );
  // ── Load config on mount ─────────────────────────────────────────────────────
  useEffect(() => {
    const loadConfig = async () => {
      let cfg: AppConfig = {};
      try {
        cfg = await invoke<AppConfig>("load_config");
      } catch {
        // Fallback: try localStorage
        const raw = localStorage.getItem("forgelm_config");
        if (raw) {
          try { cfg = JSON.parse(raw); } catch { /* ignore */ }
        }
      }
      if (cfg.addr) setAddr(cfg.addr);
      if (cfg.gpu_layers !== undefined) setGpuLayers(cfg.gpu_layers);
      if (cfg.ctx_size !== undefined) setCtxSize(cfg.ctx_size);
      if (cfg.model_path) setSelectedModel(cfg.model_path);
      // Restore extra model paths
      if (cfg.extra_model_paths?.length) {
        const extras: ModelFile[] = cfg.extra_model_paths.map((p) => ({
          name: p.split(/[\\/]/).pop() ?? p,
          path: p,
        }));
        setExtraModels(extras);
      }
      // Restore models dir and scan it
      if (cfg.models_dir) {
        setModelsDir(cfg.models_dir);
        setConfigLoaded(true); // trigger scan in next effect
      } else {
        setConfigLoaded(true);
      }
    };
    loadConfig();
    // Detect GPU
    invoke<GpuInfo>("query_gpu")
      .then((info) => {
        setGpuInfo(info);
        setGpuLayers((prev) => prev || info.recommended_layers);
      })
      .catch((e) => setGpuError(String(e)));
  }, []); // eslint-disable-line react-hooks/exhaustive-deps
  // Scan models dir once config is loaded
  useEffect(() => {
    if (configLoaded && modelsDir) {
      scanDir(modelsDir);
    }
  }, [configLoaded]); // eslint-disable-line react-hooks/exhaustive-deps
  // ── Scan directory ───────────────────────────────────────────────────────────
  const scanDir = useCallback(async (dir: string) => {
    if (!dir.trim()) return;
    setScanning(true);
    setScanError("");
    try {
      const models = await invoke<ModelFile[]>("scan_models", { dir: dir.trim() });
      setScannedModels(models);
      // Auto-select first if current selection is gone
      setSelectedModel((prev) => {
        const allPaths = [
          ...models.map((m) => m.path),
          ...extraModels.map((m) => m.path),
        ];
        if (prev && allPaths.includes(prev)) return prev;
        return models[0]?.path ?? extraModels[0]?.path ?? "";
      });
    } catch (e) {
      setScanError(String(e));
      setScannedModels([]);
    } finally {
      setScanning(false);
    }
  }, [extraModels]);
  // ── Native folder picker ─────────────────────────────────────────────────────
  const handlePickDir = useCallback(async () => {
    try {
      const result = await invoke<PickDirResult>("pick_models_dir");
      setModelsDir(result.dir);
      setScannedModels(result.models);
      if (result.models.length > 0) {
        setSelectedModel((prev) => {
          const allPaths = [
            ...result.models.map((m) => m.path),
            ...extraModels.map((m) => m.path),
          ];
          if (prev && allPaths.includes(prev)) return prev;
          return result.models[0].path;
        });
      }
      await persistConfig({ models_dir: result.dir });
    } catch (e) {
      if (String(e) !== "cancelled") setScanError(String(e));
    }
  }, [extraModels, persistConfig]);
  // ── Native file picker (multi-select) ────────────────────────────────────────
  const handlePickFiles = useCallback(async () => {
    try {
      const picked = await invoke<ModelFile[]>("pick_model_files");
      if (!picked.length) return;
      setExtraModels((prev) => {
        const merged = [...prev];
        for (const m of picked) {
          if (!merged.some((x) => x.path === m.path)) merged.push(m);
        }
        return merged;
      });
      // Select the first newly picked model
      setSelectedModel((prev) => prev || picked[0].path);
      await persistConfig({
        extra_model_paths: [
          ...extraModels.map((m) => m.path),
          ...picked.map((m) => m.path),
        ],
      });
    } catch (e) {
      if (String(e) !== "cancelled") setScanError(String(e));
    }
  }, [extraModels, persistConfig]);
  // ── Drag-and-drop ────────────────────────────────────────────────────────────
  const handleDragOver = useCallback((e: React.DragEvent) => {
    e.preventDefault();
    e.stopPropagation();
    if (e.dataTransfer.types.includes("Files")) setIsDragOver(true);
  }, []);
  const handleDragLeave = useCallback((e: React.DragEvent) => {
    e.preventDefault();
    e.stopPropagation();
    if (dropRef.current && !dropRef.current.contains(e.relatedTarget as Node)) {
      setIsDragOver(false);
    }
  }, []);
  const handleDrop = useCallback(async (e: React.DragEvent) => {
    e.preventDefault();
    e.stopPropagation();
    setIsDragOver(false);
    const files = Array.from(e.dataTransfer.files);
    const ggufFiles = files.filter((f) => f.name.toLowerCase().endsWith(".gguf"));
    if (!ggufFiles.length) {
      setScanError("Only .gguf files are supported");
      return;
    }
    const newModels: ModelFile[] = [];
    for (const f of ggufFiles) {
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      const filePath = (f as any).path as string | undefined;
      if (filePath) {
        newModels.push({ name: f.name, path: filePath });
      }
    }
    if (newModels.length) {
      setExtraModels((prev) => {
        const merged = [...prev];
        for (const m of newModels) {
          if (!merged.some((x) => x.path === m.path)) merged.push(m);
        }
        return merged;
      });
      setSelectedModel((prev) => prev || newModels[0].path);
      await persistConfig({
        extra_model_paths: [
          ...extraModels.map((m) => m.path),
          ...newModels.map((m) => m.path),
        ],
      });
    } else {
      setScanError("Could not read file path. Use 'Add Models…' button instead.");
    }
  }, [extraModels, persistConfig]);
  // ── Remove a model from the extra list ───────────────────────────────────────
  const removeModel = useCallback(async (path: string) => {
    setExtraModels((prev) => {
      const next = prev.filter((m) => m.path !== path);
      persistConfig({ extra_model_paths: next.map((m) => m.path) });
      return next;
    });
    setSelectedModel((prev) => (prev === path ? allModels.find((m) => m.path !== path)?.path ?? "" : prev));
  }, [allModels, persistConfig]);
  // ── Start / Stop ─────────────────────────────────────────────────────────────
  const isActive = status === "running" || status === "starting" || status === "stopping";
  const maxLayers = gpuInfo ? gpuInfo.recommended_layers : 999;
  const canStart = !!selectedModel.trim() && !isActive;
  const handleStart = async () => {
    await persistConfig();
    onStart({ modelPath: selectedModel, addr, gpuLayers, ctxSize });
  };
  const handleLayersChange = (val: number) => {
    setGpuLayers(Math.max(0, Math.min(val, maxLayers)));
  };
  const vramPct = gpuInfo && gpuLayers > 0
    ? Math.min(100, (gpuLayers / gpuInfo.recommended_layers) * 100)
    : 0;
  return (
    <div className="server-panel">
      {/* Header */}
      <div className="server-panel-header" onClick={() => setExpanded(!expanded)}>
        <div className="server-panel-title">
          <span className="server-status-dot" style={{ background: STATUS_COLOR[status] }} />
          <span className="server-panel-label">Local Server</span>
        </div>
        <div className="server-panel-header-right">
          <span className="server-status-badge" style={{ color: STATUS_COLOR[status] }}>
            {STATUS_LABEL[status]}
          </span>
          <span className="server-panel-chevron">{expanded ? "▲" : "▼"}</span>
        </div>
      </div>
      {expanded && (
        <div className="server-panel-body">
          {/* GPU badge */}
          {gpuInfo ? (
            <div className="sp-gpu-badge">
              <span className="sp-gpu-icon">⚡</span>
              <span>{gpuInfo.name}</span>
              <span className="sp-gpu-vram">{(gpuInfo.vram_mib / 1024).toFixed(1)} GB</span>
            </div>
          ) : gpuError ? (
            <div className="sp-gpu-badge sp-gpu-cpu">
              <span className="sp-gpu-icon">🖥</span>
              <span>CPU only</span>
            </div>
          ) : (
            <div className="sp-gpu-badge sp-gpu-loading">
              <span className="sp-gpu-icon">⟳</span>
              <span>Detecting GPU…</span>
            </div>
          )}
          {/* Models directory */}
          <label className="sp-label">Models folder</label>
          <div className="sp-dir-row">
            <div className="sp-dir-path" title={modelsDir || "No folder selected"}>
              {modelsDir ? modelsDir.split(/[\\/]/).pop() : "No folder selected"}
            </div>
            <button
              className="sp-scan-btn"
              onClick={handlePickDir}
              disabled={isActive}
              title="Browse for models folder"
            >
              📁
            </button>
            <button
              className="sp-scan-btn"
              onClick={() => modelsDir && scanDir(modelsDir)}
              disabled={isActive || scanning || !modelsDir}
              title="Rescan folder"
            >
              {scanning ? "…" : "⟳"}
            </button>
          </div>
          {/* Model list + drop zone */}
          <label className="sp-label">
            Models
            {allModels.length > 0 && (
              <span className="sp-label-hint"> ({allModels.length} available)</span>
            )}
          </label>
          <div
            ref={dropRef}
            className={`sp-drop-zone${isDragOver ? " sp-drop-zone--active" : ""}${isActive ? " sp-drop-zone--disabled" : ""}`}
            onDragOver={!isActive ? handleDragOver : undefined}
            onDragLeave={!isActive ? handleDragLeave : undefined}
            onDrop={!isActive ? handleDrop : undefined}
          >
            {isDragOver && (
              <div className="sp-drop-overlay">
                <span className="sp-drop-icon">📦</span>
                <span>Drop .gguf to add</span>
              </div>
            )}
            {allModels.length > 0 ? (
              <select
                className="sp-model-select"
                value={selectedModel}
                onChange={(e) => setSelectedModel(e.target.value)}
                disabled={isActive}
              >
                {allModels.map((m) => (
                  <option key={m.path} value={m.path} title={m.path}>
                    {m.name}
                  </option>
                ))}
              </select>
            ) : (
              <div className="sp-no-models">
                No models found — browse a folder or add files below
              </div>
            )}
            {!isActive && (
              <div className="sp-drop-hint">Drop .gguf here or use the button below</div>
            )}
          </div>
          {/* Extra models list (removable) */}
          {extraModels.length > 0 && (
            <div className="sp-extra-models">
              {extraModels.map((m) => (
                <div key={m.path} className="sp-extra-model-item">
                  <span className="sp-extra-model-name" title={m.path}>{m.name}</span>
                  {!isActive && (
                    <button
                      className="sp-extra-model-remove"
                      onClick={() => removeModel(m.path)}
                      title="Remove from list"
                    >
                      ×
                    </button>
                  )}
                </div>
              ))}
            </div>
          )}
          {/* Add models button */}
          {!isActive && (
            <button className="sp-add-models-btn" onClick={handlePickFiles}>
              <span>＋</span> Add Models…
            </button>
          )}
          {scanError && <div className="sp-scan-error">{scanError}</div>}
          {/* Context size */}
          <label className="sp-label">
            Context size
            <span className="sp-label-hint"> (tokens)</span>
          </label>
          <div className="sp-ctx-row">
            <input
              className="sp-input sp-input-num"
              type="number"
              min={512}
              max={131072}
              step={512}
              value={ctxSize}
              onChange={(e) => setCtxSize(Math.max(512, Math.min(131072, parseInt(e.target.value, 10) || DEFAULT_CTX)))}
              disabled={isActive}
            />
            <div className="sp-ctx-presets">
              {CTX_PRESETS.map((p) => (
                <button
                  key={p}
                  className={`sp-ctx-preset${ctxSize === p ? " sp-ctx-preset--active" : ""}`}
                  onClick={() => setCtxSize(p)}
                  disabled={isActive}
                  title={`${p.toLocaleString()} tokens`}
                >
                  {p >= 1024 ? `${p / 1024}k` : p}
                </button>
              ))}
            </div>
          </div>
          {/* Address */}
          <label className="sp-label">Listen address</label>
          <input
            className="sp-input"
            type="text"
            value={addr}
            onChange={(e) => setAddr(e.target.value)}
            placeholder="127.0.0.1:8080"
            disabled={isActive}
          />
          {/* GPU Layers */}
          <label className="sp-label">
            GPU layers
            {gpuInfo && <span className="sp-label-hint"> (max {gpuInfo.recommended_layers})</span>}
          </label>
          <div className="sp-layers-row">
            <input
              className="sp-input sp-input-num"
              type="number"
              min={0}
              max={maxLayers}
              value={gpuLayers}
              onChange={(e) => handleLayersChange(parseInt(e.target.value, 10) || 0)}
              disabled={isActive}
            />
            {gpuInfo && (
              <button
                className="sp-btn-max"
                onClick={() => handleLayersChange(gpuInfo.recommended_layers)}
                disabled={isActive}
                title="Set to maximum recommended"
              >
                Max
              </button>
            )}
            {gpuLayers === 0 && <span className="sp-layers-hint">CPU only</span>}
          </div>
          {/* VRAM bar */}
          {gpuInfo && gpuLayers > 0 && (
            <div className="sp-vram-bar">
              <div className="sp-vram-fill" style={{ width: `${vramPct}%` }} />
              <span className="sp-vram-label">
                ~{Math.round(gpuLayers * 80)} MB / {gpuInfo.vram_mib} MB VRAM
              </span>
            </div>
          )}
          {/* Action buttons */}
          <div className="sp-actions">
            {status === "stopped" || status === "error" ? (
              <button
                className="sp-btn sp-btn-start"
                onClick={handleStart}
                disabled={!canStart}
                title={!selectedModel ? "Select a model first" : ""}
              >
                <span className="sp-btn-icon">▶</span> Start Server
              </button>
            ) : (
              <button
                className="sp-btn sp-btn-stop"
                onClick={onStop}
                disabled={status === "starting" || status === "stopping"}
              >
                <span className="sp-btn-icon">■</span> Stop Server
              </button>
            )}
          </div>
          {message && (
            <div className={`sp-message ${status === "error" ? "sp-message-error" : ""}`}>
              {message}
            </div>
          )}
        </div>
      )}
    </div>
  );
 }
@@ -5,6 +5,14 @@ import {
  queryRuntimeGpu,
  scanRuntimeModels,
 } from "../api";
 import {
  chooseModel,
  createRuntimeConfigPatch,
  dedupeModels,
  getLocalRuntimeStartReason,
  pathName,
  toModelFile,
 } from "../runtime-settings-form";
 import type {
  RuntimeConfig,
  RuntimeGpuInfo,
@@ -15,33 +23,6 @@ import "./RuntimeSettingsDrawer.css";
 const CTX_PRESETS = [2048, 4096, 8192, 16384, 32768, 65536];
 function pathName(path: string | null | undefined): string {
  if (!path) return "";
  const parts = path.split(/[\\/]/).filter(Boolean);
  return parts[parts.length - 1] || path;
 }
 function toModelFile(path: string): RuntimeModelFile {
  return { name: pathName(path) || path, path };
 }
 function dedupeModels(models: RuntimeModelFile[]): RuntimeModelFile[] {
  const seen = new Set<string>();
  return models.filter((model) => {
    if (seen.has(model.path)) return false;
    seen.add(model.path);
    return true;
  });
 }
 function chooseModel(current: string, scanned: RuntimeModelFile[], extra: RuntimeModelFile[]): string {
  const nextChoices = [...scanned, ...extra].map((model) => model.path);
  if (current && (nextChoices.length === 0 || nextChoices.includes(current))) {
    return current;
  }
  return scanned[0]?.path || extra[0]?.path || "";
 }
 interface Props {
  open: boolean;
  snapshot: RuntimeSnapshot;
@@ -128,29 +109,31 @@ export default function RuntimeSettingsDrawer({
  const savedLocalModel = snapshot.config.model_path?.trim() || "";
  const hasPendingModeChange = mode !== snapshot.config.connection_mode;
  const maxLayers = gpuInfo?.recommended_layers ?? 200;
-  const startReason =
+  const startReason = getLocalRuntimeStartReason({
-    mode !== "local"
+    mode,
-      ? "Save mode before starting the local runtime."
+    binaryPath: snapshot.binary_path,
-      : !snapshot.binary_path
+    selectedModel,
-        ? "Build or bundle the local API binary before starting."
+  });
        : !selectedModel.trim()
          ? "Choose a model before starting the local runtime."
          : "";
  if (!open) return null;
-  const buildPatch = (): Partial<RuntimeConfig> => ({
+  const buildPatch = (): RuntimeConfig =>
-    connection_mode: mode,
+    createRuntimeConfigPatch(
-    start_policy: startPolicy,
+      snapshot.config,
-    server_url: serverUrl.trim(),
+      {
-    api_key: apiKey.trim(),
+        mode,
-    models_dir: mode === "local" ? (modelsDir.trim() || null) : snapshot.config.models_dir,
+        startPolicy,
-    model_path: mode === "local" ? (selectedModel.trim() || null) : snapshot.config.model_path,
+        serverUrl,
-    addr: mode === "local" ? addr.trim() || snapshot.config.addr : snapshot.config.addr,
+        apiKey,
-    gpu_layers: mode === "local" ? Math.max(0, Math.min(gpuLayers, maxLayers)) : snapshot.config.gpu_layers,
+        modelsDir,
-    ctx_size: mode === "local" ? Math.max(512, ctxSize || 4096) : snapshot.config.ctx_size,
+        selectedModel,
-    extra_model_paths: mode === "local" ? extraModels.map((model) => model.path) : snapshot.config.extra_model_paths,
+        addr,
-  });
+        gpuLayers,
        ctxSize,
        extraModels,
      },
      maxLayers,
    );
  const handleSave = async () => {
    setLocalError("");
@@ -0,0 +1,132 @@
 import { describe, expect, it } from "vitest";
 import {
  chooseModel,
  createRuntimeConfigPatch,
  dedupeModels,
  getLocalRuntimeStartReason,
  pathName,
  toModelFile,
  type RuntimeSettingsFormState,
 } from "./runtime-settings-form";
 import { createDefaultRuntimeSnapshot } from "./runtime-utils";
 function createFormState(overrides: Partial<RuntimeSettingsFormState> = {}): RuntimeSettingsFormState {
  return {
    mode: "local",
    startPolicy: "manual",
    serverUrl: "https://api.example.com/",
    apiKey: " sk-demo ",
    modelsDir: "D:/models",
    selectedModel: "D:/models/demo.gguf",
    addr: "127.0.0.1:8080",
    gpuLayers: 48,
    ctxSize: 8192,
    extraModels: [{ name: "demo.gguf", path: "D:/models/demo.gguf" }],
    ...overrides,
  };
 }
 describe("runtime settings form helpers", () => {
  it("keeps the current model when it still exists", () => {
    const current = "D:/models/demo.gguf";
    const scanned = [{ name: "demo.gguf", path: current }];
    const extra = [{ name: "other.gguf", path: "D:/models/other.gguf" }];
    expect(chooseModel(current, scanned, extra)).toBe(current);
  });
  it("falls back to the first available model when the current one disappears", () => {
    expect(
      chooseModel(
        "D:/models/missing.gguf",
        [{ name: "demo.gguf", path: "D:/models/demo.gguf" }],
        [],
      ),
    ).toBe("D:/models/demo.gguf");
  });
  it("deduplicates model entries by path while keeping first occurrence", () => {
    expect(
      dedupeModels([
        { name: "demo.gguf", path: "D:/models/demo.gguf" },
        { name: "duplicate.gguf", path: "D:/models/demo.gguf" },
        { name: "other.gguf", path: "D:/models/other.gguf" },
      ]),
    ).toEqual([
      { name: "demo.gguf", path: "D:/models/demo.gguf" },
      { name: "other.gguf", path: "D:/models/other.gguf" },
    ]);
  });
  it("builds a trimmed local patch from the form state", () => {
    const snapshot = createDefaultRuntimeSnapshot();
    const patch = createRuntimeConfigPatch(snapshot.config, createFormState(), 32);
    expect(patch).toMatchObject({
      connection_mode: "local",
      server_url: "https://api.example.com",
      api_key: "sk-demo",
      model_path: "D:/models/demo.gguf",
      models_dir: "D:/models",
      gpu_layers: 32,
      ctx_size: 8192,
      extra_model_paths: ["D:/models/demo.gguf"],
    });
  });
  it("keeps saved local values untouched when editing remote mode", () => {
    const snapshot = createDefaultRuntimeSnapshot();
    const patch = createRuntimeConfigPatch(
      {
        ...snapshot.config,
        model_path: "D:/models/keep.gguf",
        models_dir: "D:/models",
        extra_model_paths: ["D:/models/keep.gguf"],
      },
      createFormState({
        mode: "remote",
        serverUrl: " https://api.example.com/ ",
        apiKey: " remote-key ",
        modelsDir: "",
        selectedModel: "",
        extraModels: [],
      }),
      16,
    );
    expect(patch).toMatchObject({
      connection_mode: "remote",
      server_url: "https://api.example.com",
      api_key: "remote-key",
      model_path: "D:/models/keep.gguf",
      models_dir: "D:/models",
      extra_model_paths: ["D:/models/keep.gguf"],
    });
  });
  it("explains why local runtime start is blocked", () => {
    expect(
      getLocalRuntimeStartReason({ mode: "local", binaryPath: null, selectedModel: "D:/models/demo.gguf" }),
    ).toContain("Build or bundle");
    expect(
      getLocalRuntimeStartReason({ mode: "local", binaryPath: "D:/bin/localllm.exe", selectedModel: "" }),
    ).toContain("Choose a model");
    expect(
      getLocalRuntimeStartReason({
        mode: "local",
        binaryPath: "D:/bin/localllm.exe",
        selectedModel: "D:/models/demo.gguf",
      }),
    ).toBe("");
  });
  it("normalizes model file labels from a path", () => {
    expect(pathName("D:/models/demo.gguf")).toBe("demo.gguf");
    expect(toModelFile("D:/models/demo.gguf")).toEqual({
      name: "demo.gguf",
      path: "D:/models/demo.gguf",
    });
  });
 });
@@ -0,0 +1,98 @@
 import type {
  ConnectionMode,
  RuntimeConfig,
  RuntimeModelFile,
  StartPolicy,
 } from "./types";
 function normalizeUrl(value: string): string {
  const trimmed = value.trim();
  return trimmed.replace(/\/+$/, "");
 }
 export interface RuntimeSettingsFormState {
  mode: ConnectionMode;
  startPolicy: StartPolicy;
  serverUrl: string;
  apiKey: string;
  modelsDir: string;
  selectedModel: string;
  addr: string;
  gpuLayers: number;
  ctxSize: number;
  extraModels: RuntimeModelFile[];
 }
 export function pathName(path: string | null | undefined): string {
  if (!path) return "";
  const parts = path.split(/[\\/]/).filter(Boolean);
  return parts[parts.length - 1] || path;
 }
 export function toModelFile(path: string): RuntimeModelFile {
  return { name: pathName(path) || path, path };
 }
 export function dedupeModels(models: RuntimeModelFile[]): RuntimeModelFile[] {
  const seen = new Set<string>();
  return models.filter((model) => {
    if (seen.has(model.path)) return false;
    seen.add(model.path);
    return true;
  });
 }
 export function chooseModel(current: string, scanned: RuntimeModelFile[], extra: RuntimeModelFile[]): string {
  const nextChoices = [...scanned, ...extra].map((model) => model.path);
  if (current && (nextChoices.length === 0 || nextChoices.includes(current))) {
    return current;
  }
  return scanned[0]?.path || extra[0]?.path || "";
 }
 export function getLocalRuntimeStartReason(params: {
  mode: ConnectionMode;
  binaryPath: string | null;
  selectedModel: string;
 }): string {
  const { mode, binaryPath, selectedModel } = params;
  if (mode !== "local") {
    return "Save mode before starting the local runtime.";
  }
  if (!binaryPath) {
    return "Build or bundle the local API binary before starting.";
  }
  if (!selectedModel.trim()) {
    return "Choose a model before starting the local runtime.";
  }
  return "";
 }
 export function createRuntimeConfigPatch(
  snapshotConfig: RuntimeConfig,
  form: RuntimeSettingsFormState,
  maxLayers: number,
 ): RuntimeConfig {
  return {
    connection_mode: form.mode,
    start_policy: form.startPolicy,
    server_url: normalizeUrl(form.serverUrl),
    api_key: form.apiKey.trim(),
    models_dir: form.mode === "local" ? (form.modelsDir.trim() || null) : snapshotConfig.models_dir,
    model_path: form.mode === "local" ? (form.selectedModel.trim() || null) : snapshotConfig.model_path,
    addr: form.mode === "local" ? form.addr.trim() || snapshotConfig.addr : snapshotConfig.addr,
    gpu_layers:
      form.mode === "local"
        ? Math.max(0, Math.min(form.gpuLayers, maxLayers))
        : snapshotConfig.gpu_layers,
    ctx_size: form.mode === "local" ? Math.max(512, form.ctxSize || 4096) : snapshotConfig.ctx_size,
    extra_model_paths:
      form.mode === "local"
        ? form.extraModels.map((model) => model.path)
        : snapshotConfig.extra_model_paths,
  };
 }
@@ -0,0 +1,82 @@
 /* @vitest-environment jsdom */
 import { createRoot, type Root } from "react-dom/client";
 import { act } from "react-dom/test-utils";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { RuntimeStatus } from "./types";
 import { useRuntimeReadyModelRefresh } from "./useRuntimeReadyModelRefresh";
 function Harness({ status, onRefresh }: { status: RuntimeStatus; onRefresh: () => void }) {
  useRuntimeReadyModelRefresh(status, onRefresh);
  return null;
 }
 describe("useRuntimeReadyModelRefresh", () => {
  let container: HTMLDivElement;
  let root: Root;
  beforeEach(() => {
    // @ts-expect-error React test environment flag
    globalThis.IS_REACT_ACT_ENVIRONMENT = true;
    container = document.createElement("div");
    document.body.appendChild(container);
    root = createRoot(container);
  });
  afterEach(() => {
    act(() => root.unmount());
    container.remove();
    // @ts-expect-error React test environment flag
    globalThis.IS_REACT_ACT_ENVIRONMENT = false;
  });
  it("refreshes once when the runtime transitions into ready", async () => {
    const onRefresh = vi.fn();
    await act(async () => {
      root.render(<Harness status="stopped" onRefresh={onRefresh} />);
    });
    await act(async () => {
      root.render(<Harness status="ready" onRefresh={onRefresh} />);
    });
    await act(async () => {
      root.render(<Harness status="ready" onRefresh={onRefresh} />);
    });
    expect(onRefresh).toHaveBeenCalledTimes(1);
  });
  it("refreshes again after leaving ready and coming back", async () => {
    const onRefresh = vi.fn();
    await act(async () => {
      root.render(<Harness status="ready" onRefresh={onRefresh} />);
    });
    await act(async () => {
      root.render(<Harness status="degraded" onRefresh={onRefresh} />);
    });
    await act(async () => {
      root.render(<Harness status="ready" onRefresh={onRefresh} />);
    });
    expect(onRefresh).toHaveBeenCalledTimes(1);
  });
  it("ignores non-ready transitions", async () => {
    const onRefresh = vi.fn();
    await act(async () => {
      root.render(<Harness status="starting" onRefresh={onRefresh} />);
    });
    await act(async () => {
      root.render(<Harness status="stopping" onRefresh={onRefresh} />);
    });
    expect(onRefresh).not.toHaveBeenCalled();
  });
 });
@@ -0,0 +1,14 @@
 import { useEffect, useRef } from "react";
 import type { RuntimeStatus } from "./types";
 export function useRuntimeReadyModelRefresh(status: RuntimeStatus, onRefresh: () => void) {
  const previousStatus = useRef<RuntimeStatus>(status);
  useEffect(() => {
    if (status === "ready" && previousStatus.current !== "ready") {
      onRefresh();
    }
    previousStatus.current = status;
  }, [status, onRefresh]);
 }
@@ -0,0 +1,21 @@
 import { describe, expect, it } from "vitest";
 import { getNextSelectedModel } from "./model-selection";
 const models = [
  { id: "alpha", object: "model", created: 1, owned_by: "me" },
  { id: "beta", object: "model", created: 2, owned_by: "me" },
 ];
 describe("getNextSelectedModel", () => {
  it("keeps the current selection when it still exists", () => {
    expect(getNextSelectedModel("beta", models)).toBe("beta");
  });
  it("falls back to the first model when the selection is missing", () => {
    expect(getNextSelectedModel("missing", models)).toBe("alpha");
  });
  it("clears the selection when the model list becomes empty", () => {
    expect(getNextSelectedModel("alpha", [])).toBe("");
  });
 });
@@ -0,0 +1,13 @@
 import type { ModelInfo } from "../lib/types";
 export function getNextSelectedModel(current: string, models: ModelInfo[]): string {
  if (models.length === 0) {
    return "";
  }
  if (current && models.some((model) => model.id === current)) {
    return current;
  }
  return models[0]?.id || "";
 }
@@ -1,5 +1,6 @@
 import { useState, useEffect, useCallback } from "react";
 import type { ModelInfo, ServerStatus } from "../lib/types";
 import { getNextSelectedModel } from "./model-selection";
 export function useModels(server: string, apiKey: string, enabled = true) {
  const [models, setModels] = useState<ModelInfo[]>([]);
@@ -24,17 +25,13 @@ export function useModels(server: string, apiKey: string, enabled = true) {
      const data = await res.json();
      const list: ModelInfo[] = data.data || [];
      setModels(list);
-      if (list.length === 0) {
+      setSelectedModel((current) => getNextSelectedModel(current, list));
        setSelectedModel("");
      } else if (!selectedModel || !list.some((item) => item.id === selectedModel)) {
        setSelectedModel(list[0].id);
      }
      setStatus("ok");
    } catch {
      setModels([]);
      setStatus("error");
    }
-  }, [enabled, server, apiKey, selectedModel]);
+  }, [enabled, server, apiKey]);
  useEffect(() => {
    refresh();
@@ -1,66 +0,0 @@
 import { useState, useEffect, useCallback } from "react";
 import { invoke } from "@tauri-apps/api/core";
 export type ProcessStatus = "stopped" | "starting" | "running" | "stopping" | "error";
 export interface ServerConfig {
  modelPath: string;
  addr: string;
  gpuLayers: number;
  ctxSize: number;
 }
 export function useServerProcess() {
  const [status, setStatus] = useState<ProcessStatus>("stopped");
  const [message, setMessage] = useState<string>("");
  // Poll actual process status every 3s
  useEffect(() => {
    const poll = async () => {
      try {
        const s = await invoke<string>("server_status");
        setStatus((prev) => {
          if (prev === "starting" || prev === "stopping") return prev;
          return s === "running" ? "running" : "stopped";
        });
      } catch {
        // not in Tauri context (browser dev)
      }
    };
    poll();
    const id = setInterval(poll, 3000);
    return () => clearInterval(id);
  }, []);
  const start = useCallback(async (cfg: ServerConfig) => {
    setStatus("starting");
    setMessage("");
    try {
      const msg = await invoke<string>("start_server", {
        modelPath: cfg.modelPath,
        addr: cfg.addr,
        gpuLayers: cfg.gpuLayers,
        ctxSize: cfg.ctxSize,
      });
      setStatus("running");
      setMessage(msg);
    } catch (e) {
      setStatus("error");
      setMessage(String(e));
    }
  }, []);
  const stop = useCallback(async () => {
    setStatus("stopping");
    try {
      const msg = await invoke<string>("stop_server");
      setStatus("stopped");
      setMessage(msg);
    } catch (e) {
      setStatus("error");
      setMessage(String(e));
    }
  }, []);
  return { status, message, start, stop };
 }