feat: add server status monitoring and global model list for settings

Add OpenCode server status/restart controls and a new settings_model_list
endpoint that loads models from configured providers without requiring
a connected workspace session. Fix model selection to use qualified IDs
when multiple providers share the same model slug.

Author: jacobjmc

src-tauri/src/backend/app_server.rs

@@ -55,11 +55,57 @@ struct ServerProcess {
     base_url: String,
 }
 
+fn rest_base_url() -> String {
+    format!("http://127.0.0.1:{REST_PORT}")
+}
+
+async fn start_managed_server_process(
+    codex_bin: Option<String>,
+    codex_args: Option<&str>,
+) -> Result<ServerProcess, String> {
+    let base_url = rest_base_url();
+    let mut command = build_codex_command_with_bin(
+        codex_bin,
+        codex_args,
+        vec![
+            "serve".to_string(),
+            "--port".to_string(),
+            REST_PORT.to_string(),
+        ],
+    )?;
+    command.stdin(std::process::Stdio::null());
+    command.stdout(std::process::Stdio::null());
+    command.stderr(std::process::Stdio::null());
+
+    let child = command.spawn().map_err(|e| {
+        if e.kind() == ErrorKind::NotFound {
+            "OpenCode CLI not found. Install OpenCode and ensure `opencode` is on your PATH."
+                .to_string()
+        } else {
+            e.to_string()
+        }
+    })?;
+
+    let start = std::time::Instant::now();
+    let health_timeout = Duration::from_secs(30);
+    loop {
+        if start.elapsed() > health_timeout {
+            return Err("OpenCode server did not become healthy within 30 seconds.".to_string());
+        }
+        if health_check(&base_url).await.is_ok() {
+            break;
+        }
+        sleep(Duration::from_millis(200)).await;
+    }
+
+    Ok(ServerProcess { child, base_url })
+}
+
 async fn ensure_server_running(
     codex_bin: Option<String>,
     codex_args: Option<&str>,
 ) -> Result<String, String> {
-    let base_url = format!("http://127.0.0.1:{REST_PORT}");
+    let base_url = rest_base_url();
 
     // Fast path: if already initialized, just return the URL.
     if SERVER_PROCESS.get().is_some() {
@@ -73,47 +119,8 @@ async fn ensure_server_running(
 
     let init_result = SERVER_PROCESS
         .get_or_try_init(|| async {
-            let mut command = build_codex_command_with_bin(
-                codex_bin,
-                codex_args,
-                vec![
-                    "serve".to_string(),
-                    "--port".to_string(),
-                    REST_PORT.to_string(),
-                ],
-            )?;
-            command.stdin(std::process::Stdio::null());
-            command.stdout(std::process::Stdio::null());
-            command.stderr(std::process::Stdio::null());
-
-            let child = command.spawn().map_err(|e| {
-                if e.kind() == ErrorKind::NotFound {
-                    "OpenCode CLI not found. Install OpenCode and ensure `opencode` is on your PATH."
-                        .to_string()
-                } else {
-                    e.to_string()
-                }
-            })?;
-
-            // Poll health endpoint until ready.
-            let start = std::time::Instant::now();
-            let health_timeout = Duration::from_secs(30);
-            loop {
-                if start.elapsed() > health_timeout {
-                    return Err(
-                        "OpenCode server did not become healthy within 30 seconds.".to_string()
-                    );
-                }
-                if health_check(&base_url).await.is_ok() {
-                    break;
-                }
-                sleep(Duration::from_millis(200)).await;
-            }
-
-            Ok(Mutex::new(ServerProcess {
-                child,
-                base_url: base_url.clone(),
-            }))
+            let server = start_managed_server_process(codex_bin, codex_args).await?;
+            Ok::<Mutex<ServerProcess>, String>(Mutex::new(server))
         })
         .await;
 
@@ -139,6 +146,89 @@ async fn health_check(base_url: &str) -> Result<Value, String> {
     resp.json::<Value>().await.map_err(|e| e.to_string())
 }
 
+pub(crate) async fn global_rest_get(
+    codex_bin: Option<String>,
+    codex_args: Option<&str>,
+    path: &str,
+    directory: Option<&str>,
+) -> Result<Value, String> {
+    let base_url = ensure_server_running(codex_bin, codex_args).await?;
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(300))
+        .build()
+        .map_err(|e| e.to_string())?;
+    let mut url = format!("{base_url}{path}");
+    if let Some(directory) = directory.filter(|value| !value.trim().is_empty()) {
+        let separator = if path.contains('?') { "&" } else { "?" };
+        url = format!("{url}{separator}directory={}", urlencoding::encode(directory));
+    }
+    let resp = client.get(&url).send().await.map_err(|e| e.to_string())?;
+    if !resp.status().is_success() {
+        let status = resp.status();
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("REST GET {path} failed ({status}): {body}"));
+    }
+    resp.json::<Value>().await.map_err(|e| e.to_string())
+}
+
+pub(crate) async fn opencode_server_status() -> Value {
+    let base_url = rest_base_url();
+    let managed = SERVER_PROCESS.get().is_some();
+    match health_check(&base_url).await {
+        Ok(health) => json!({
+            "baseUrl": base_url,
+            "healthy": true,
+            "managed": managed,
+            "source": if managed { "managed" } else { "external" },
+            "version": health.get("version").cloned().unwrap_or(Value::Null),
+            "health": health,
+        }),
+        Err(error) => json!({
+            "baseUrl": base_url,
+            "healthy": false,
+            "managed": managed,
+            "source": if managed { "managed" } else { "none" },
+            "version": Value::Null,
+            "error": error,
+        }),
+    }
+}
+
+pub(crate) async fn restart_opencode_server(
+    codex_bin: Option<String>,
+    codex_args: Option<&str>,
+) -> Result<Value, String> {
+    let base_url = rest_base_url();
+    if let Some(server_mutex) = SERVER_PROCESS.get() {
+        let mut guard = server_mutex.lock().await;
+        let _ = kill_child_process_tree(&mut guard.child).await;
+        let replacement = start_managed_server_process(codex_bin, codex_args).await?;
+        *guard = replacement;
+        return Ok(json!({
+            "restarted": true,
+            "status": opencode_server_status().await,
+        }));
+    }
+
+    if health_check(&base_url).await.is_ok() {
+        return Err(format!(
+            "OpenCode server at {base_url} is running but is not managed by OpenCode Monitor. Stop it manually, then retry."
+        ));
+    }
+
+    let _ = SERVER_PROCESS
+        .get_or_try_init(|| async {
+            let server = start_managed_server_process(codex_bin, codex_args).await?;
+            Ok::<Mutex<ServerProcess>, String>(Mutex::new(server))
+        })
+        .await?;
+
+    Ok(json!({
+        "restarted": true,
+        "status": opencode_server_status().await,
+    }))
+}
+
 // ---------------------------------------------------------------------------
 // WorkspaceSession (REST-based)
 // ---------------------------------------------------------------------------

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -797,6 +797,54 @@ impl DaemonState {
         codex_core::model_list_core(&self.sessions, workspace_id).await
     }
 
+    async fn settings_model_list(&self, workspace_id: Option<String>) -> Result<Value, String> {
+        let (codex_bin, codex_args) = {
+            let settings = self.app_settings.lock().await;
+            (settings.codex_bin.clone(), settings.codex_args.clone())
+        };
+        let directory = if let Some(workspace_id) = workspace_id.clone() {
+            let workspaces = self.workspaces.lock().await;
+            workspaces.get(&workspace_id).map(|entry| entry.path.clone())
+        } else {
+            None
+        };
+        let providers =
+            backend::app_server::global_rest_get(
+                codex_bin,
+                codex_args.as_deref(),
+                "/config/providers",
+                directory.as_deref(),
+            )
+            .await?;
+        let mut response = codex_core::model_list_response_from_providers(&providers);
+        if let Some(obj) = response.as_object_mut() {
+            obj.insert(
+                "debug".to_string(),
+                {
+                    let mut debug = codex_core::model_list_debug_from_providers(&providers);
+                    if let Some(debug_obj) = debug.as_object_mut() {
+                        debug_obj.insert("requestWorkspaceId".to_string(), json!(workspace_id));
+                        debug_obj.insert("requestDirectory".to_string(), json!(directory));
+                    }
+                    debug
+                },
+            );
+        }
+        Ok(response)
+    }
+
+    async fn opencode_server_status(&self) -> Result<Value, String> {
+        Ok(backend::app_server::opencode_server_status().await)
+    }
+
+    async fn opencode_server_restart(&self) -> Result<Value, String> {
+        let (codex_bin, codex_args) = {
+            let settings = self.app_settings.lock().await;
+            (settings.codex_bin.clone(), settings.codex_args.clone())
+        };
+        backend::app_server::restart_opencode_server(codex_bin, codex_args.as_deref()).await
+    }
+
     async fn collaboration_mode_list(&self, workspace_id: String) -> Result<Value, String> {
         codex_core::collaboration_mode_list_core(&self.sessions, workspace_id).await
     }

src-tauri/src/bin/codex_monitor_daemon/rpc/codex.rs

@@ -250,6 +250,12 @@ pub(super) async fn try_handle(
             };
             Some(state.model_list(workspace_id).await)
         }
+        "settings_model_list" => {
+            let workspace_id = parse_optional_string(params, "workspaceId");
+            Some(state.settings_model_list(workspace_id).await)
+        }
+        "opencode_server_status" => Some(state.opencode_server_status().await),
+        "opencode_server_restart" => Some(state.opencode_server_restart().await),
         "collaboration_mode_list" => {
             let workspace_id = match parse_string(params, "workspaceId") {
                 Ok(value) => value,

src-tauri/src/codex/mod.rs

@@ -8,7 +8,10 @@ pub(crate) mod args;
 pub(crate) mod config;
 pub(crate) mod home;
 
-use crate::backend::app_server::spawn_workspace_session as spawn_workspace_session_inner;
+use crate::backend::app_server::{
+    global_rest_get, opencode_server_status as app_server_status,
+    restart_opencode_server as app_server_restart, spawn_workspace_session as spawn_workspace_session_inner,
+};
 pub(crate) use crate::backend::app_server::WorkspaceSession;
 use crate::backend::events::AppServerEvent;
 use crate::event_sink::TauriEventSink;
@@ -481,6 +484,82 @@ pub(crate) async fn model_list(
     codex_core::model_list_core(&state.sessions, workspace_id).await
 }
 
+#[tauri::command]
+pub(crate) async fn settings_model_list(
+    workspace_id: Option<String>,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "settings_model_list",
+            json!({ "workspaceId": workspace_id }),
+        )
+        .await;
+    }
+
+    let (codex_bin, codex_args) = {
+        let settings = state.app_settings.lock().await;
+        (settings.codex_bin.clone(), settings.codex_args.clone())
+    };
+    let directory = if let Some(workspace_id) = workspace_id.clone() {
+        let workspaces = state.workspaces.lock().await;
+        workspaces.get(&workspace_id).map(|entry| entry.path.clone())
+    } else {
+        None
+    };
+    let providers = global_rest_get(
+        codex_bin,
+        codex_args.as_deref(),
+        "/config/providers",
+        directory.as_deref(),
+    )
+    .await?;
+    let mut response = codex_core::model_list_response_from_providers(&providers);
+    if let Some(obj) = response.as_object_mut() {
+        obj.insert(
+            "debug".to_string(),
+            {
+                let mut debug = codex_core::model_list_debug_from_providers(&providers);
+                if let Some(debug_obj) = debug.as_object_mut() {
+                    debug_obj.insert("requestWorkspaceId".to_string(), json!(workspace_id));
+                    debug_obj.insert("requestDirectory".to_string(), json!(directory));
+                }
+                debug
+            },
+        );
+    }
+    Ok(response)
+}
+
+#[tauri::command]
+pub(crate) async fn opencode_server_status(
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(&*state, app, "opencode_server_status", json!({})).await;
+    }
+    Ok(app_server_status().await)
+}
+
+#[tauri::command]
+pub(crate) async fn opencode_server_restart(
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(&*state, app, "opencode_server_restart", json!({})).await;
+    }
+    let (codex_bin, codex_args) = {
+        let settings = state.app_settings.lock().await;
+        (settings.codex_bin.clone(), settings.codex_args.clone())
+    };
+    app_server_restart(codex_bin, codex_args.as_deref()).await
+}
+
 #[tauri::command]
 pub(crate) async fn account_rate_limits(
     workspace_id: String,

src-tauri/src/lib.rs

@@ -276,6 +276,9 @@ pub fn run() {
             git::checkout_git_branch,
             git::create_git_branch,
             codex::model_list,
+            codex::settings_model_list,
+            codex::opencode_server_status,
+            codex::opencode_server_restart,
             codex::account_rate_limits,
             codex::account_read,
             codex::codex_login,

src-tauri/src/remote_backend/mod.rs

@@ -172,8 +172,11 @@ fn can_retry_after_disconnect(method: &str) -> bool {
             | "list_workspace_files"
             | "list_workspaces"
             | "model_list"
+            | "opencode_server_restart"
+            | "opencode_server_status"
             | "read_workspace_file"
             | "resume_thread"
+            | "settings_model_list"
             | "skills_list"
             | "worktree_setup_status"
     )