style: rustfmt-style wrapping in daemon and shared modules

Author: Dimillian

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

@@ -262,7 +262,11 @@ pub(super) async fn try_handle(
             };
             let cursor = parse_optional_string(params, "cursor");
             let limit = parse_optional_u32(params, "limit");
-            Some(state.experimental_feature_list(workspace_id, cursor, limit).await)
+            Some(
+                state
+                    .experimental_feature_list(workspace_id, cursor, limit)
+                    .await,
+            )
         }
         "collaboration_mode_list" => {
             let workspace_id = match parse_string(params, "workspaceId") {

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

@@ -70,9 +70,10 @@ pub(super) async fn try_handle(
     match method {
         "list_workspaces" => Some(serialize_value(state.list_workspaces().await)),
         "is_workspace_path_dir" => {
-            let request =
-                parse_request_or_err!(params, workspace_rpc::IsWorkspacePathDirRequest);
-            Some(serialize_value(state.is_workspace_path_dir(request.path).await))
+            let request = parse_request_or_err!(params, workspace_rpc::IsWorkspacePathDirRequest);
+            Some(serialize_value(
+                state.is_workspace_path_dir(request.path).await,
+            ))
         }
         "add_workspace" => {
             let request = parse_request_or_err!(params, workspace_rpc::AddWorkspaceRequest);
@@ -123,10 +124,7 @@ pub(super) async fn try_handle(
         "connect_workspace" => {
             let request = parse_request_or_err!(params, workspace_rpc::IdRequest);
             Some(
-                serialize_ok(
-                    state.connect_workspace(request.id, client_version.to_string()),
-                )
-                .await,
+                serialize_ok(state.connect_workspace(request.id, client_version.to_string())).await,
             )
         }
         "set_workspace_runtime_codex_args" => {
@@ -188,11 +186,8 @@ pub(super) async fn try_handle(
             let request =
                 parse_request_or_err!(params, workspace_rpc::UpdateWorkspaceCodexBinRequest);
             Some(
-                serialize_result(state.update_workspace_codex_bin(
-                    request.id,
-                    request.codex_bin,
-                ))
-                .await,
+                serialize_result(state.update_workspace_codex_bin(request.id, request.codex_bin))
+                    .await,
             )
         }
         "list_workspace_files" => {
@@ -224,8 +219,12 @@ pub(super) async fn try_handle(
                 Err(err) => return Some(Err(err)),
             };
             Some(
-                serialize_result(state.file_read(request.scope, request.kind, request.workspace_id))
-                    .await,
+                serialize_result(state.file_read(
+                    request.scope,
+                    request.kind,
+                    request.workspace_id,
+                ))
+                .await,
             )
         }
         "file_write" => {

src-tauri/src/codex/mod.rs

@@ -18,12 +18,7 @@ use crate::shared::codex_core;
 use crate::state::AppState;
 use crate::types::WorkspaceEntry;
 
-fn emit_thread_live_event(
-    app: &AppHandle,
-    workspace_id: &str,
-    method: &str,
-    params: Value,
-) {
+fn emit_thread_live_event(app: &AppHandle, workspace_id: &str, method: &str, params: Value) {
     let _ = app.emit(
         "app-server-event",
         AppServerEvent {
@@ -132,8 +127,12 @@ pub(crate) async fn thread_live_subscribe(
         .await;
     }
 
-    codex_core::thread_live_subscribe_core(&state.sessions, workspace_id.clone(), thread_id.clone())
-        .await?;
+    codex_core::thread_live_subscribe_core(
+        &state.sessions,
+        workspace_id.clone(),
+        thread_id.clone(),
+    )
+    .await?;
     let subscription_id = format!("{}:{}", workspace_id, thread_id);
     emit_thread_live_event(
         &app,
@@ -233,8 +232,7 @@ pub(crate) async fn list_threads(
         .await;
     }
 
-    codex_core::list_threads_core(&state.sessions, workspace_id, cursor, limit, sort_key, cwd)
-        .await
+    codex_core::list_threads_core(&state.sessions, workspace_id, cursor, limit, sort_key, cwd).await
 }
 
 #[tauri::command]
@@ -565,8 +563,8 @@ pub(crate) async fn get_agents_settings(
     app: AppHandle,
 ) -> Result<agents_config_core::AgentsSettingsDto, String> {
     if remote_backend::is_remote_mode(&*state).await {
-        let response = remote_backend::call_remote(&*state, app, "get_agents_settings", json!({}))
-            .await?;
+        let response =
+            remote_backend::call_remote(&*state, app, "get_agents_settings", json!({})).await?;
         return serde_json::from_value(response).map_err(|err| err.to_string());
     }
 
@@ -600,13 +598,9 @@ pub(crate) async fn create_agent(
     app: AppHandle,
 ) -> Result<agents_config_core::AgentsSettingsDto, String> {
     if remote_backend::is_remote_mode(&*state).await {
-        let response = remote_backend::call_remote(
-            &*state,
-            app,
-            "create_agent",
-            json!({ "input": input }),
-        )
-        .await?;
+        let response =
+            remote_backend::call_remote(&*state, app, "create_agent", json!({ "input": input }))
+                .await?;
         return serde_json::from_value(response).map_err(|err| err.to_string());
     }
 
@@ -620,13 +614,9 @@ pub(crate) async fn update_agent(
     app: AppHandle,
 ) -> Result<agents_config_core::AgentsSettingsDto, String> {
     if remote_backend::is_remote_mode(&*state).await {
-        let response = remote_backend::call_remote(
-            &*state,
-            app,
-            "update_agent",
-            json!({ "input": input }),
-        )
-        .await?;
+        let response =
+            remote_backend::call_remote(&*state, app, "update_agent", json!({ "input": input }))
+                .await?;
         return serde_json::from_value(response).map_err(|err| err.to_string());
     }
 
@@ -640,13 +630,9 @@ pub(crate) async fn delete_agent(
     app: AppHandle,
 ) -> Result<agents_config_core::AgentsSettingsDto, String> {
     if remote_backend::is_remote_mode(&*state).await {
-        let response = remote_backend::call_remote(
-            &*state,
-            app,
-            "delete_agent",
-            json!({ "input": input }),
-        )
-        .await?;
+        let response =
+            remote_backend::call_remote(&*state, app, "delete_agent", json!({ "input": input }))
+                .await?;
         return serde_json::from_value(response).map_err(|err| err.to_string());
     }
 

src-tauri/src/shared/agents_config_core.rs

@@ -193,10 +193,14 @@ pub(crate) fn update_agent_core(input: UpdateAgentInput) -> Result<AgentsSetting
                 if let Some(old_relative_path) = managed_relative_path_from_config(old_value) {
                     let new_relative_path = managed_relative_config_for_name(&name);
                     if old_relative_path != new_relative_path {
-                        let old_abs_path =
-                            resolve_safe_managed_abs_path_for_read(&codex_home, &old_relative_path)?;
-                        let new_abs_path =
-                            resolve_safe_managed_abs_path_for_write(&codex_home, &new_relative_path)?;
+                        let old_abs_path = resolve_safe_managed_abs_path_for_read(
+                            &codex_home,
+                            &old_relative_path,
+                        )?;
+                        let new_abs_path = resolve_safe_managed_abs_path_for_write(
+                            &codex_home,
+                            &new_relative_path,
+                        )?;
                         if new_abs_path.exists() {
                             return Err(format!(
                                 "target config file already exists: {}",
@@ -316,8 +320,9 @@ pub(crate) fn delete_agent_core(input: DeleteAgentInput) -> Result<AgentsSetting
             if let Some(relative_path) = managed_relative_path_from_config(config_file.as_str()) {
                 let target = resolve_safe_managed_abs_path_for_read(&codex_home, &relative_path)?;
                 if target.exists() {
-                    let backup = std::fs::read(&target)
-                        .map_err(|err| format!("Failed to read agent config file before delete: {err}"))?;
+                    let backup = std::fs::read(&target).map_err(|err| {
+                        format!("Failed to read agent config file before delete: {err}")
+                    })?;
                     std::fs::remove_file(&target)
                         .map_err(|err| format!("Failed to delete agent config file: {err}"))?;
                     deleted_config_backup = Some((target, backup));
@@ -326,7 +331,9 @@ pub(crate) fn delete_agent_core(input: DeleteAgentInput) -> Result<AgentsSetting
         }
     }
 
-    if let Err(persist_error) = config_toml_core::persist_global_config_document(&codex_home, &document) {
+    if let Err(persist_error) =
+        config_toml_core::persist_global_config_document(&codex_home, &document)
+    {
         if let Some((path, backup)) = deleted_config_backup {
             if let Err(restore_error) = std::fs::write(&path, backup) {
                 return Err(format!(
@@ -600,7 +607,9 @@ fn managed_relative_path_from_config(raw_path: &str) -> Option<PathBuf> {
     }
 }
 
-fn resolve_managed_agent_config_relative_path(agent_name: &str) -> Result<(PathBuf, PathBuf), String> {
+fn resolve_managed_agent_config_relative_path(
+    agent_name: &str,
+) -> Result<(PathBuf, PathBuf), String> {
     let name = normalize_agent_lookup_name(agent_name)?;
     let codex_home = resolve_codex_home()?;
     let (_, document) = config_toml_core::load_global_config_document(&codex_home)?;
@@ -803,7 +812,10 @@ mod tests {
     fn normalize_agent_name_accepts_expected_shape() {
         assert_eq!(normalize_agent_name("explorer").expect("valid"), "explorer");
         assert_eq!(normalize_agent_name("a-1_b").expect("valid"), "a-1_b");
-        assert_eq!(normalize_agent_name(" Explorer ").expect("valid"), "explorer");
+        assert_eq!(
+            normalize_agent_name(" Explorer ").expect("valid"),
+            "explorer"
+        );
         assert_eq!(normalize_agent_name("A-1_B").expect("valid"), "a-1_b");
         assert_eq!(
             normalize_agent_name("Hello world").expect("valid"),
@@ -825,13 +837,11 @@ mod tests {
     #[test]
     fn managed_path_detection_accepts_agents_prefix() {
         assert_eq!(
-            managed_relative_path_from_config("./agents/researcher.toml")
-                .expect("managed path"),
+            managed_relative_path_from_config("./agents/researcher.toml").expect("managed path"),
             PathBuf::from("agents/researcher.toml")
         );
         assert_eq!(
-            managed_relative_path_from_config("agents/researcher.toml")
-                .expect("managed path"),
+            managed_relative_path_from_config("agents/researcher.toml").expect("managed path"),
             PathBuf::from("agents/researcher.toml")
         );
     }
@@ -857,10 +867,7 @@ mod tests {
         let mut role = clone_role_table(role_item).expect("clone role");
         role["description"] = value("New");
 
-        assert_eq!(
-            role.get("custom_key").and_then(Item::as_str),
-            Some("keep")
-        );
+        assert_eq!(role.get("custom_key").and_then(Item::as_str), Some("keep"));
         assert_eq!(role.get("description").and_then(Item::as_str), Some("New"));
     }
 
@@ -910,8 +917,7 @@ mod tests {
 
     #[test]
     fn build_template_content_uses_provided_model_and_reasoning() {
-        let content =
-            build_template_content(Some("blank"), Some("gpt-5.1"), Some("high"), None);
+        let content = build_template_content(Some("blank"), Some("gpt-5.1"), Some("high"), None);
         assert!(content.contains("model = \"gpt-5.1\""));
         assert!(content.contains("model_reasoning_effort = \"high\""));
     }

src-tauri/src/shared/codex_aux_core.rs

@@ -13,7 +13,8 @@ use crate::backend::app_server::{
 use crate::shared::process_core::tokio_command;
 use crate::types::AppSettings;
 
-const DEFAULT_COMMIT_MESSAGE_PROMPT: &str = "Generate a concise git commit message for the following changes. \
+const DEFAULT_COMMIT_MESSAGE_PROMPT: &str =
+    "Generate a concise git commit message for the following changes. \
 Follow conventional commit format (e.g., feat:, fix:, refactor:, docs:, etc.). \
 Keep the summary line under 72 characters. \
 Only output the commit message, nothing else.\n\n\
@@ -629,7 +630,8 @@ where
 #[cfg(test)]
 mod tests {
     use super::{
-        build_commit_message_prompt_for_diff, parse_agent_description_value, parse_run_metadata_value,
+        build_commit_message_prompt_for_diff, parse_agent_description_value,
+        parse_run_metadata_value,
     };
 
     #[test]
@@ -643,7 +645,8 @@ mod tests {
 
     #[test]
     fn parse_run_metadata_value_normalizes_worktree_name_alias() {
-        let raw = r#"{"title":"Fix Login Redirect Loop","worktree_name":"fix-login-redirect-loop"}"#;
+        let raw =
+            r#"{"title":"Fix Login Redirect Loop","worktree_name":"fix-login-redirect-loop"}"#;
         let parsed = parse_run_metadata_value(raw).expect("parse metadata");
         assert_eq!(parsed["title"], "Fix Login Redirect Loop");
         assert_eq!(parsed["worktreeName"], "fix/login-redirect-loop");

src-tauri/src/shared/codex_core.rs

@@ -368,7 +368,9 @@ pub(crate) async fn experimental_feature_list_core(
 ) -> Result<Value, String> {
     let session = get_session_clone(sessions, &workspace_id).await?;
     let params = json!({ "cursor": cursor, "limit": limit });
-    session.send_request("experimentalFeature/list", params).await
+    session
+        .send_request("experimentalFeature/list", params)
+        .await
 }
 
 pub(crate) async fn account_rate_limits_core(

src-tauri/src/shared/codex_update_core.rs

@@ -197,13 +197,7 @@ pub(crate) async fn codex_update_core(
             ok,
         )
     } else {
-        (
-            "unknown".to_string(),
-            None,
-            false,
-            String::new(),
-            false,
-        )
+        ("unknown".to_string(), None, false, String::new(), false)
     };
 
     let after_version = if method == "unknown" {

src-tauri/src/shared/git_ui_core/commands.rs

@@ -82,8 +82,12 @@ fn count_effective_dir_entries(root: &Path) -> Result<usize, String> {
     let entries = fs::read_dir(root).map_err(|err| format!("Failed to read directory: {err}"))?;
     let mut count = 0usize;
     for entry in entries {
-        let entry =
-            entry.map_err(|err| format!("Failed to read directory entry in {}: {err}", root.display()))?;
+        let entry = entry.map_err(|err| {
+            format!(
+                "Failed to read directory entry in {}: {err}",
+                root.display()
+            )
+        })?;
         let name = entry.file_name();
         let name = name.to_string_lossy();
         if name == ".git" || name == ".DS_Store" || name == "Thumbs.db" {
@@ -169,8 +173,7 @@ pub(super) fn validate_normalized_repo_name(value: &str) -> Result<String, Strin
     let normalized = normalize_repo_full_name(value);
     if normalized.is_empty() {
         return Err(
-            "Repository name is empty after normalization. Use 'repo' or 'owner/repo'."
-                .to_string(),
+            "Repository name is empty after normalization. Use 'repo' or 'owner/repo'.".to_string(),
         );
     }
     Ok(normalized)

src-tauri/src/shared/git_ui_core/tests.rs

@@ -76,7 +76,10 @@ fn github_repo_names_match_normalizes_and_ignores_case() {
         "https://github.com/Owner/Repo.git",
         "owner/repo"
     ));
-    assert!(commands::github_repo_names_match("OWNER/REPO", "owner/repo"));
+    assert!(commands::github_repo_names_match(
+        "OWNER/REPO",
+        "owner/repo"
+    ));
 }
 
 #[test]
@@ -91,11 +94,15 @@ fn github_repo_names_match_detects_mismatch() {
 fn validate_normalized_repo_name_rejects_empty_slug_after_normalization() {
     assert_eq!(
         commands::validate_normalized_repo_name(".git"),
-        Err("Repository name is empty after normalization. Use 'repo' or 'owner/repo'.".to_string())
+        Err(
+            "Repository name is empty after normalization. Use 'repo' or 'owner/repo'.".to_string()
+        )
     );
     assert_eq!(
         commands::validate_normalized_repo_name("git@github.com:.git"),
-        Err("Repository name is empty after normalization. Use 'repo' or 'owner/repo'.".to_string())
+        Err(
+            "Repository name is empty after normalization. Use 'repo' or 'owner/repo'.".to_string()
+        )
     );
 }