feat(cargo): add feature flags for optional heavy dependencies

- Make wasmtime, ssh2, and image optional dependencies behind feature flags
  (wasm-extensions, remote-ssh, image-processing)
- All features enabled by default for backward compatibility
- Replace tokio 'full' with explicit feature list
- Add #[cfg] gates throughout codebase with stub fallbacks
- Add dev profile settings for faster debug builds

Author: echobt

src-tauri/Cargo.toml

@@ -32,7 +32,7 @@ serde_json = "1"
 rmp-serde = "1"
 
 # Async runtime
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "1", features = ["rt-multi-thread", "sync", "time", "io-util", "net", "fs", "process", "macros"] }
 async-channel = "2"
 futures = "0.3"
 
@@ -46,7 +46,7 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 # Utilities
 open = "5"
-ssh2 = "0.9"
+ssh2 = { version = "0.9", optional = true }
 uuid = { version = "1", features = ["v4"] }
 once_cell = "1"
 dirs = "5"
@@ -87,7 +87,7 @@ git2 = "0.19"
 zip = "0.6"
 
 # WASM extension runtime
-wasmtime = { version = "29", features = ["cranelift"] }
+wasmtime = { version = "29", features = ["cranelift"], optional = true }
 
 # File encoding
 encoding_rs = "0.8"
@@ -101,7 +101,7 @@ libc = "0.2"
 # MCP support
 interprocess = { version = "2.2", features = ["tokio"] }
 enigo = "0.3"
-image = "0.24"
+image = { version = "0.24", optional = true }
 
 # Note: plist and wry are provided by tauri and don't need direct dependencies
 
@@ -141,8 +141,15 @@ tauri-plugin-deep-link = "2.4"
 tempfile = "3"
 
 [features]
-default = ["custom-protocol"]
+default = ["custom-protocol", "wasm-extensions", "remote-ssh", "image-processing"]
 custom-protocol = ["tauri/custom-protocol"]
+wasm-extensions = ["dep:wasmtime"]
+remote-ssh = ["dep:ssh2"]
+image-processing = ["dep:image"]
+
+[profile.dev]
+opt-level = 0
+debug = 2
 
 [profile.dev.package."*"]
 opt-level = 2

src-tauri/src/app/mod.rs

@@ -396,7 +396,7 @@ pub fn register_state(
     builder: tauri::Builder<tauri::Wry>,
     remote_manager: Arc<RemoteManager>,
 ) -> tauri::Builder<tauri::Wry> {
-    builder
+    let builder = builder
         .manage(ServerState(Arc::new(Mutex::new(None))))
         .manage(LogState(Arc::new(Mutex::new(VecDeque::new()))))
         .manage(PortState(Arc::new(Mutex::new(0))))
@@ -438,7 +438,6 @@ pub fn register_state(
         .manage(crate::themes::ThemeState::new())
         .manage(crate::keybindings::KeybindingsState::new())
         .manage(crate::wsl::WSLState::new())
-        .manage(crate::ssh_terminal::SSHTerminalState::new())
         .manage(crate::rules_library::RulesWatcherState::new())
         .manage(LazyState::new(crate::testing::TestWatcherState::new))
         .manage(LazyState::new(crate::factory::FactoryState::new))
@@ -458,7 +457,12 @@ pub fn register_state(
         .manage(LazyState::new(SandboxState::new))
         .manage(crate::remote::tunnel::TunnelState::new())
         .manage(crate::git::forge::ForgeState::new())
-        .manage(LazyState::new(CollabState::new))
+        .manage(LazyState::new(CollabState::new));
+
+    #[cfg(feature = "remote-ssh")]
+    let builder = builder.manage(crate::ssh_terminal::SSHTerminalState::new());
+
+    builder
 }
 
 // ===== Setup =====
@@ -676,9 +680,12 @@ pub fn handle_run_event(app: &AppHandle, event: RunEvent) {
             let _ = terminal_state.close_all(app);
             info!("All terminals closed on app exit");
 
-            let ssh_state = app.state::<crate::ssh_terminal::SSHTerminalState>();
-            let _ = ssh_state.close_all(app);
-            info!("All SSH sessions closed on app exit");
+            #[cfg(feature = "remote-ssh")]
+            {
+                let ssh_state = app.state::<crate::ssh_terminal::SSHTerminalState>();
+                let _ = ssh_state.close_all(app);
+                info!("All SSH sessions closed on app exit");
+            }
 
             let lsp_state = app.state::<LspState>();
             let _ = lsp_state.stop_all_servers();
@@ -731,8 +738,16 @@ pub fn handle_run_event(app: &AppHandle, event: RunEvent) {
             {
                 let ext_state = app.state::<LazyState<ExtensionsState>>();
                 let manager = ext_state.get().0.lock();
-                manager.wasm_runtime.unload_all();
-                info!("WASM extension runtime stopped on app exit");
+                #[cfg(feature = "wasm-extensions")]
+                {
+                    manager.wasm_runtime.unload_all();
+                    info!("WASM extension runtime stopped on app exit");
+                }
+                #[cfg(not(feature = "wasm-extensions"))]
+                {
+                    drop(manager);
+                    info!("WASM extension runtime not enabled, skipping cleanup");
+                }
             }
 
             {

src-tauri/src/app/terminal_commands.rs

@@ -1,3 +1,4 @@
+#[cfg(feature = "remote-ssh")]
 #[macro_export]
 macro_rules! terminal_commands {
     (@commands $callback:ident [ $($acc:tt)* ]) => {
@@ -50,3 +51,42 @@ macro_rules! terminal_commands {
         ])
     };
 }
+
+#[cfg(not(feature = "remote-ssh"))]
+#[macro_export]
+macro_rules! terminal_commands {
+    (@commands $callback:ident [ $($acc:tt)* ]) => {
+        $callback!([ $($acc)*
+            // Terminal PTY commands
+            $crate::terminal::commands::terminal_create,
+            $crate::terminal::commands::terminal_write,
+            $crate::terminal::commands::terminal_update,
+            $crate::terminal::commands::terminal_resize,
+            $crate::terminal::commands::terminal_close,
+            $crate::terminal::commands::terminal_list,
+            $crate::terminal::commands::terminal_get,
+            $crate::terminal::commands::terminal_send_interrupt,
+            $crate::terminal::commands::terminal_send_eof,
+            $crate::terminal::commands::terminal_ack,
+            $crate::terminal::commands::terminal_close_all,
+            $crate::terminal::commands::terminal_get_default_shell,
+            // Port management commands
+            $crate::terminal::commands::get_process_on_port,
+            $crate::terminal::commands::kill_process_on_port,
+            $crate::terminal::commands::list_listening_ports,
+            // Shell detection commands
+            $crate::terminal::commands::terminal_detect_shells,
+            $crate::terminal::commands::path_exists,
+            $crate::terminal::commands::terminal_detect_links,
+            $crate::terminal::commands::terminal_search,
+            $crate::terminal::commands::terminal_parse_shell_integration,
+            $crate::terminal::commands::terminal_strip_sequences,
+            // Terminal profiles commands
+            $crate::terminal::profiles::terminal_profiles_list,
+            $crate::terminal::profiles::terminal_profiles_save,
+            $crate::terminal::profiles::terminal_profiles_delete,
+            $crate::terminal::profiles::terminal_profiles_get,
+            $crate::terminal::profiles::terminal_profiles_set_default,
+        ])
+    };
+}

src-tauri/src/app/tests.rs

@@ -34,6 +34,7 @@ fn state_types_are_send_sync() {
     assert_send_sync::<crate::LazyState<crate::sandbox::commands::SandboxState>>();
     assert_send_sync::<crate::testing::TestWatcherState>();
     assert_send_sync::<crate::LazyState<crate::testing::TestWatcherState>>();
+    #[cfg(feature = "remote-ssh")]
     assert_send_sync::<crate::ssh_terminal::SSHTerminalState>();
     assert_send_sync::<crate::wsl::WSLState>();
 }
@@ -64,6 +65,7 @@ fn state_initialization_does_not_panic() {
     let _ = crate::extensions::activation::ActivationState::new();
     let _ = crate::extensions::registry::RegistryState::new();
     let _ = crate::testing::TestWatcherState::new();
+    #[cfg(feature = "remote-ssh")]
     let _ = crate::ssh_terminal::SSHTerminalState::new();
     let _ = crate::wsl::WSLState::new();
 }

src-tauri/src/extensions/commands.rs

@@ -146,22 +146,30 @@ pub async fn update_extension(app: AppHandle, name: String, version: String) ->
 /// Get activation time metrics for all loaded WASM extensions.
 #[tauri::command]
 pub async fn get_activation_time_metrics(app: AppHandle) -> Result<Vec<serde_json::Value>, String> {
-    let state = app.state::<LazyState<ExtensionsState>>();
-    let manager = state.get().0.lock();
-    let states = manager.wasm_runtime.get_states();
-    let metrics: Vec<serde_json::Value> = states
-        .into_iter()
-        .map(|s| {
-            serde_json::json!({
-                "id": s.id,
-                "status": s.status,
-                "activationTime": s.activation_time,
-                "error": s.error,
-                "lastActivity": s.last_activity,
+    #[cfg(feature = "wasm-extensions")]
+    {
+        let state = app.state::<LazyState<ExtensionsState>>();
+        let manager = state.get().0.lock();
+        let states = manager.wasm_runtime.get_states();
+        let metrics: Vec<serde_json::Value> = states
+            .into_iter()
+            .map(|s| {
+                serde_json::json!({
+                    "id": s.id,
+                    "status": s.status,
+                    "activationTime": s.activation_time,
+                    "error": s.error,
+                    "lastActivity": s.last_activity,
+                })
             })
-        })
-        .collect();
-    Ok(metrics)
+            .collect();
+        Ok(metrics)
+    }
+    #[cfg(not(feature = "wasm-extensions"))]
+    {
+        let _ = app;
+        Ok(Vec::new())
+    }
 }
 
 /// Update all installed extensions that have available updates.

src-tauri/src/extensions/contributions.rs

@@ -183,17 +183,25 @@ pub async fn execute_extension_command(
     command: String,
     args: Option<Vec<serde_json::Value>>,
 ) -> Result<serde_json::Value, String> {
-    let state = app.state::<LazyState<ExtensionsState>>();
-    let mut manager = state.get().0.lock();
+    #[cfg(feature = "wasm-extensions")]
+    {
+        let state = app.state::<LazyState<ExtensionsState>>();
+        let mut manager = state.get().0.lock();
 
-    let args_json = serde_json::to_string(&args.unwrap_or_default())
-        .map_err(|e| format!("Failed to serialize args: {}", e))?;
+        let args_json = serde_json::to_string(&args.unwrap_or_default())
+            .map_err(|e| format!("Failed to serialize args: {}", e))?;
 
-    let result = manager
-        .wasm_runtime
-        .execute_command(&extension_id, &command, &args_json)?;
+        let result = manager
+            .wasm_runtime
+            .execute_command(&extension_id, &command, &args_json)?;
 
-    serde_json::from_str(&result).unwrap_or(Ok(serde_json::Value::String(result)))
+        serde_json::from_str(&result).unwrap_or(Ok(serde_json::Value::String(result)))
+    }
+    #[cfg(not(feature = "wasm-extensions"))]
+    {
+        let _ = (app, extension_id, command, args);
+        Err("WASM extensions feature is not enabled".to_string())
+    }
 }
 
 // ============================================================================

src-tauri/src/extensions/state.rs

@@ -12,6 +12,7 @@ use tracing::{info, warn};
 
 use super::types::{Extension, ExtensionManifest, ExtensionSource};
 use super::utils::{copy_dir_recursive, extensions_directory_path};
+#[cfg(feature = "wasm-extensions")]
 use super::wasm::WasmRuntime;
 
 /// State for managing extensions
@@ -26,7 +27,7 @@ pub struct ExtensionsManager {
     pub extensions_dir: PathBuf,
     /// Enabled extensions (persisted)
     pub enabled_extensions: HashMap<String, bool>,
-    /// WASM extension runtime
+    #[cfg(feature = "wasm-extensions")]
     pub wasm_runtime: WasmRuntime,
 }
 
@@ -44,6 +45,7 @@ impl ExtensionsManager {
             extensions: HashMap::new(),
             extensions_dir,
             enabled_extensions: HashMap::new(),
+            #[cfg(feature = "wasm-extensions")]
             wasm_runtime: WasmRuntime::new(),
         }
     }
@@ -147,8 +149,10 @@ impl ExtensionsManager {
 
     /// Uninstall an extension
     pub fn uninstall_extension(&mut self, name: &str) -> Result<(), String> {
-        // Unload from WASM runtime if loaded
-        let _ = self.wasm_runtime.unload_extension(name);
+        #[cfg(feature = "wasm-extensions")]
+        {
+            let _ = self.wasm_runtime.unload_extension(name);
+        }
 
         if let Some(ext) = self.extensions.remove(name) {
             fs::remove_dir_all(&ext.path)