Just fix

Author: Jordonbc

Backend/build.rs

@@ -256,14 +256,15 @@ fn main() {
 
     // Navigate: plugins.updater.endpoints
     if let Some(plugins) = json.get_mut("plugins")
-        && let Some(updater) = plugins.get_mut("updater") {
-            let endpoints: Vec<serde_json::Value> = channel
-                .updater_endpoints
-                .iter()
-                .map(|s| serde_json::Value::String((*s).to_string()))
-                .collect();
-            updater["endpoints"] = serde_json::Value::Array(endpoints);
-        }
+        && let Some(updater) = plugins.get_mut("updater")
+    {
+        let endpoints: Vec<serde_json::Value> = channel
+            .updater_endpoints
+            .iter()
+            .map(|s| serde_json::Value::String((*s).to_string()))
+            .collect();
+        updater["endpoints"] = serde_json::Value::Array(endpoints);
+    }
 
     json["mainBinaryName"] = serde_json::Value::String(channel.main_binary_name.into());
     json["productName"] = serde_json::Value::String(channel.product_name.into());
@@ -272,9 +273,10 @@ fn main() {
         && let Some(windows) = app
             .get_mut("windows")
             .and_then(|value| value.as_array_mut())
-            && let Some(main_window) = windows.first_mut() {
-                main_window["title"] = serde_json::Value::String(channel.window_title.into());
-            }
+        && let Some(main_window) = windows.first_mut()
+    {
+        main_window["title"] = serde_json::Value::String(channel.window_title.into());
+    }
 
     // The app should only ever point at a dev server when running `cargo tauri dev`.
     // In all other cases (including `cargo build`, `cargo run`, `cargo tauri build`, Flatpak, CI),
@@ -285,17 +287,19 @@ fn main() {
     // We build the frontend ahead of time and ship it as production assets.
     if strip_dev_server
         && let Some(build) = json.get_mut("build")
-            && let Some(build_obj) = build.as_object_mut() {
-                build_obj.remove("devUrl");
-                build_obj.remove("beforeDevCommand");
-            }
+        && let Some(build_obj) = build.as_object_mut()
+    {
+        build_obj.remove("devUrl");
+        build_obj.remove("beforeDevCommand");
+    }
 
     // Flatpak apps update via Flatpak, not the in-app updater.
     if is_flatpak_build() {
         if let Some(plugins) = json.get_mut("plugins")
-            && let Some(updater) = plugins.get_mut("updater") {
-                updater["active"] = serde_json::Value::Bool(false);
-            }
+            && let Some(updater) = plugins.get_mut("updater")
+        {
+            updater["active"] = serde_json::Value::Bool(false);
+        }
         if let Some(bundle) = json.get_mut("bundle") {
             bundle["createUpdaterArtifacts"] = serde_json::Value::Bool(false);
         }
@@ -353,10 +357,11 @@ fn main() {
     println!("cargo:rerun-if-changed=src");
 
     if let Ok(head) = fs::read_to_string(".git/HEAD")
-        && let Some(rest) = head.trim().strip_prefix("ref: ") {
-            let ref_path = format!(".git/{rest}");
-            println!("cargo:rerun-if-changed={ref_path}");
-        }
+        && let Some(rest) = head.trim().strip_prefix("ref: ")
+    {
+        let ref_path = format!(".git/{rest}");
+        println!("cargo:rerun-if-changed={ref_path}");
+    }
 
     let branch = git_branch().unwrap_or_else(|| "unknown".into());
     let hash = git_short_hash().unwrap_or_else(|| "nogit".into());

Backend/src/logging.rs

@@ -258,56 +258,58 @@ pub fn init() {
         };
 
         // Check if message contains JSON-like structure that can be extracted and formatted.
-        if msg.len() > 100 && (ts == log::Level::Debug || ts == log::Level::Trace)
-            && let (Some(start), Some(end)) = (msg.find('{'), msg.rfind('}')) {
-                let json_part = &msg[start..=end];
-
-                let regex = regex::Regex::new(r#"String\("([^"]*)"\)"#).ok();
-
-                // Strategy 1: strict conversion of common Rust debug wrappers.
-                let mut attempts: Vec<String> = Vec::with_capacity(2);
-                let mut cleaned = json_part.replace("Object ", "");
-                if let Some(re) = &regex {
-                    cleaned = re.replace_all(&cleaned, r#""$1""#).to_string();
-                }
-                attempts.push(cleaned);
-
-                // Strategy 2: aggressive conversion fallback for odd wrapper nesting.
-                let aggressive = json_part
-                    .replace("Object ", "")
-                    .replace("String(\"", "\"")
-                    .replace("\")", "\"");
-                attempts.push(aggressive);
-
-                for json_clean in attempts {
-                    if let Ok(value) = serde_json::from_str::<serde_json::Value>(&json_clean)
-                        && let Ok(pretty) = serde_json::to_string_pretty(&value) {
-                            let label = clean_label(&msg[..start]);
-                            let header =
-                                format!("[{}] [{}] {:5} [{}]: {} ", date, time, ts, source, label);
-                            let lines: Vec<&str> = pretty.lines().collect();
-                            return writeln!(
-                                buf,
-                                "{}{}",
-                                header,
-                                lines.join(&format!("\n{}", " ".repeat(header.len())))
-                            );
-                        }
+        if msg.len() > 100
+            && (ts == log::Level::Debug || ts == log::Level::Trace)
+            && let (Some(start), Some(end)) = (msg.find('{'), msg.rfind('}'))
+        {
+            let json_part = &msg[start..=end];
+
+            let regex = regex::Regex::new(r#"String\("([^"]*)"\)"#).ok();
+
+            // Strategy 1: strict conversion of common Rust debug wrappers.
+            let mut attempts: Vec<String> = Vec::with_capacity(2);
+            let mut cleaned = json_part.replace("Object ", "");
+            if let Some(re) = &regex {
+                cleaned = re.replace_all(&cleaned, r#""$1""#).to_string();
+            }
+            attempts.push(cleaned);
+
+            // Strategy 2: aggressive conversion fallback for odd wrapper nesting.
+            let aggressive = json_part
+                .replace("Object ", "")
+                .replace("String(\"", "\"")
+                .replace("\")", "\"");
+            attempts.push(aggressive);
+
+            for json_clean in attempts {
+                if let Ok(value) = serde_json::from_str::<serde_json::Value>(&json_clean)
+                    && let Ok(pretty) = serde_json::to_string_pretty(&value)
+                {
+                    let label = clean_label(&msg[..start]);
+                    let header = format!("[{}] [{}] {:5} [{}]: {} ", date, time, ts, source, label);
+                    let lines: Vec<&str> = pretty.lines().collect();
+                    return writeln!(
+                        buf,
+                        "{}{}",
+                        header,
+                        lines.join(&format!("\n{}", " ".repeat(header.len())))
+                    );
                 }
-
-                // Fallback: non-JSON Rust debug structs (e.g., RemoteRelease { ... })
-                let label = clean_label(&msg[..start]);
-                let pretty = format_braced(json_part);
-                let header = format!("[{}] [{}] {:5} [{}]: {} ", date, time, ts, source, label);
-                let lines: Vec<&str> = pretty.lines().collect();
-                return writeln!(
-                    buf,
-                    "{}{}",
-                    header,
-                    lines.join(&format!("\n{}", " ".repeat(header.len())))
-                );
             }
 
+            // Fallback: non-JSON Rust debug structs (e.g., RemoteRelease { ... })
+            let label = clean_label(&msg[..start]);
+            let pretty = format_braced(json_part);
+            let header = format!("[{}] [{}] {:5} [{}]: {} ", date, time, ts, source, label);
+            let lines: Vec<&str> = pretty.lines().collect();
+            return writeln!(
+                buf,
+                "{}{}",
+                header,
+                lines.join(&format!("\n{}", " ".repeat(header.len())))
+            );
+        }
+
         writeln!(buf, "[{}] [{}] {:5} [{}]: {}", date, time, ts, source, msg)
     });
 

Backend/src/plugin_bundles.rs

@@ -409,24 +409,26 @@ impl PluginBundleStore {
         let plugin_dir = self.root.join(&plugin_id);
 
         if let Some(installed) = self.get_current_installed(&plugin_id)?
-            && installed.bundle_sha256 == bundle_sha256 && installed.version == version {
-                write_plugin_source_metadata(&plugin_dir, source_metadata)?;
-                if auto_approve {
-                    self.approve_capabilities(&plugin_id, &version, true)?;
-                }
-                let approval = self
-                    .get_current_installed(&plugin_id)?
-                    .map(|current| current.approval)
-                    .unwrap_or(installed.approval);
-                return Ok(InstalledPlugin {
-                    plugin_id,
-                    version,
-                    bundle_sha256,
-                    requested_capabilities,
-                    approval,
-                    install_dir: plugin_dir,
-                });
+            && installed.bundle_sha256 == bundle_sha256
+            && installed.version == version
+        {
+            write_plugin_source_metadata(&plugin_dir, source_metadata)?;
+            if auto_approve {
+                self.approve_capabilities(&plugin_id, &version, true)?;
             }
+            let approval = self
+                .get_current_installed(&plugin_id)?
+                .map(|current| current.approval)
+                .unwrap_or(installed.approval);
+            return Ok(InstalledPlugin {
+                plugin_id,
+                version,
+                bundle_sha256,
+                requested_capabilities,
+                approval,
+                install_dir: plugin_dir,
+            });
+        }
 
         let staging = self
             .root
@@ -612,9 +614,10 @@ impl PluginBundleStore {
                 continue;
             }
             if let Ok(text) = fs::read_to_string(&index_path)
-                && let Ok(index) = serde_json::from_str::<InstalledPluginIndex>(&text) {
-                    out.push(index);
-                }
+                && let Ok(index) = serde_json::from_str::<InstalledPluginIndex>(&text)
+            {
+                out.push(index);
+            }
         }
         out.sort_by(|a, b| a.plugin_id.cmp(&b.plugin_id));
         Ok(out)
@@ -869,9 +872,10 @@ fn read_built_in_plugin_ids() -> HashSet<String> {
         };
         let id = manifest.id.trim();
         if !id.is_empty()
-            && let Ok(normalized) = normalize_plugin_id(id) {
-                out.insert(normalized);
-            }
+            && let Ok(normalized) = normalize_plugin_id(id)
+        {
+            out.insert(normalized);
+        }
     }
     out
 }

Backend/src/plugin_paths.rs

@@ -152,21 +152,22 @@ fn bundled_resource_base_dirs(resource_dir_name: &str) -> Vec<PathBuf> {
     let _ = resource_dir_name;
 
     if let Ok(exe) = env::current_exe()
-        && let Some(dir) = exe.parent() {
-            push_unique_path(&mut candidates, dir.join("resources"));
-            push_unique_path(&mut candidates, dir.to_path_buf());
-            if let Some(target_dir) = dir.parent() {
-                push_unique_path(&mut candidates, target_dir.join("openvcs"));
-                #[cfg(target_os = "macos")]
-                push_unique_path(&mut candidates, target_dir.join("Resources"));
-            }
-            #[cfg(target_os = "linux")]
-            push_linux_package_resource_bases(&mut candidates, dir, resource_dir_name);
-            push_unique_path(
-                &mut candidates,
-                dir.join("_up_").join("target").join("openvcs"),
-            );
+        && let Some(dir) = exe.parent()
+    {
+        push_unique_path(&mut candidates, dir.join("resources"));
+        push_unique_path(&mut candidates, dir.to_path_buf());
+        if let Some(target_dir) = dir.parent() {
+            push_unique_path(&mut candidates, target_dir.join("openvcs"));
+            #[cfg(target_os = "macos")]
+            push_unique_path(&mut candidates, target_dir.join("Resources"));
         }
+        #[cfg(target_os = "linux")]
+        push_linux_package_resource_bases(&mut candidates, dir, resource_dir_name);
+        push_unique_path(
+            &mut candidates,
+            dir.join("_up_").join("target").join("openvcs"),
+        );
+    }
 
     if let Some(resource_dir) = RESOURCE_DIR.get() {
         push_unique_path(&mut candidates, resource_dir.clone());

Backend/src/plugin_runtime/manager.rs

@@ -375,9 +375,10 @@ impl PluginRuntimeManager {
         let running: Vec<String> = self.processes.lock().keys().cloned().collect();
         for plugin_id in running {
             if !desired_running.contains(&plugin_id)
-                && let Err(err) = self.stop_plugin(&plugin_id) {
-                    errors.push(format!("stop {}: {}", plugin_id, err));
-                }
+                && let Err(err) = self.stop_plugin(&plugin_id)
+            {
+                errors.push(format!("stop {}: {}", plugin_id, err));
+            }
         }
 
         let after: Vec<String> = self.processes.lock().keys().cloned().collect();
@@ -539,12 +540,13 @@ impl PluginRuntimeManager {
 
         let mut lock = self.processes.lock();
         if let Some(existing) = lock.get(&spec.key)
-            && existing.workspace_root == spec.spawn.allowed_workspace_root {
-                let runtime = Arc::clone(&existing.runtime);
-                drop(lock);
-                trace!("start_plugin_spec: found concurrent insert, reusing");
-                return runtime.ensure_running();
-            }
+            && existing.workspace_root == spec.spawn.allowed_workspace_root
+        {
+            let runtime = Arc::clone(&existing.runtime);
+            drop(lock);
+            trace!("start_plugin_spec: found concurrent insert, reusing");
+            return runtime.ensure_running();
+        }
 
         let runtime_to_stop = lock
             .get(&spec.key)

Backend/src/plugin_runtime/node_instance.rs

@@ -371,9 +371,10 @@ impl NodePluginRuntimeInstance {
             .ok_or_else(|| "node runtime did not initialize".to_string())?;
         let result = f(process);
         if let Err(err) = &result
-            && err.contains("disconnected") {
-                lock.take();
-            }
+            && err.contains("disconnected")
+        {
+            lock.take();
+        }
         result
     }
 

Backend/src/state.rs

@@ -268,9 +268,10 @@ fn load_recents_from_disk() -> Result<Vec<PathBuf>, String> {
                 }
                 serde_json::Value::Object(map) => {
                     if let Some(serde_json::Value::String(s)) = map.get("path")
-                        && !s.trim().is_empty() {
-                            out.push(PathBuf::from(s));
-                        }
+                        && !s.trim().is_empty()
+                    {
+                        out.push(PathBuf::from(s));
+                    }
                 }
                 _ => {}
             }