refactor(Vine): Rename CocoonServiceServer and fix Tauri State usage

This commit continues the refinement of Mountain's Vine gRPC server and Tauri IPC infrastructure. The primary change renames `CocoonServiceServer` to `CocoonServiceImpl` across the Vine server module to better reflect its role as a concrete implementation of the `CocoonService` trait defined in the `Common` contract. The module structure is updated accordingly for clarity.

The Wind-Air Tauri commands are now properly integrated into Mountain's Binary entry point by importing and registering all commands with the Tauri application handler. Additionally, critical fixes are made to the Wind-Air command parameters: all commands now correctly use `tauri::State<'_, tauri::AppHandle>` instead of taking the AppHandle by value, ensuring proper Tauri state management and resolving lifetime issues.

Import paths for the `ExtensionManagementService` trait are standardized across Mountain codebase by removing redundant module name repetition, aligning with the `Common` crate's export structure. The obsolete backup file for ApplicationState is removed as part of cleanup.

These changes ensure proper integration of Wind-Air functionality with Mountain's IPC layer and maintain consistency with Land's architectural patterns.

Author: NikolaRHristov

Source/ApplicationState/ApplicationState.rs.bak

@@ -64,6 +64,19 @@ use crate::{
 	Vine,
 };
 
+// Import Wind-Air commands
+use crate::IPC::WindAirCommands::{
+	CheckForUpdates,
+	DownloadUpdate,
+	ApplyUpdate,
+	DownloadFile,
+	AuthenticateUser,
+	IndexFiles,
+	SearchFiles,
+	GetAirStatus,
+	GetAirMetrics,
+};
+
 // =============================================================================
 // Debug Helpers (Highly Verbose, Low Intrusion)
 // =============================================================================
@@ -569,6 +582,20 @@ pub fn Fn() {
 			// -----------------------------------------------------------------
 			.manage(AppState.clone())
 			// -----------------------------------------------------------------
+			// [Boot] [Tauri] [Commands] Wind-Air commands
+			// -----------------------------------------------------------------
+			.invoke_handler(tauri::generate_handler![
+				CheckForUpdates,
+				DownloadUpdate,
+				ApplyUpdate,
+				DownloadFile,
+				AuthenticateUser,
+				IndexFiles,
+				SearchFiles,
+				GetAirStatus,
+				GetAirMetrics,
+			])
+			// -----------------------------------------------------------------
 			// [Lifecycle] Setup hook
 			// -----------------------------------------------------------------
 			.setup({

Source/Binary.rs

@@ -26,7 +26,7 @@ use Common::{
 	Document::DocumentProvider::DocumentProvider,
 	Environment::{Environment::Environment, Requires::Requires},
 	Error::CommonError::CommonError,
-	ExtensionManagement::ExtensionManagementService::ExtensionManagementService,
+	ExtensionManagement::ExtensionManagementService,
 	FileSystem::{FileSystemReader::FileSystemReader, FileSystemWriter::FileSystemWriter},
 	IPC::IPCProvider::IPCProvider,
 	Keybinding::KeybindingProvider::KeybindingProvider,

Source/Environment/MountainEnvironment.rs

@@ -139,7 +139,7 @@ impl AirClientWrapper {
 /// `UpdateInfoDTO` with update information or error message
 #[tauri::command]
 pub async fn CheckForUpdates(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
     current_version: Option<String>,
     channel: Option<String>,
 ) -> Result<UpdateInfoDTO, String> {
@@ -194,15 +194,15 @@ pub async fn CheckForUpdates(
 /// `DownloadResultDTO` with download status
 #[tauri::command]
 pub async fn DownloadUpdate(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
     url: String,
     destination: String,
     checksum: Option<String>,
 ) -> Result<DownloadResultDTO, String> {
     debug!("[WindAirCommands] DownloadUpdate called: {} -> {}", url, destination);
 
-    let air_address = get_air_address(&app_handle)?;
-    let client = get_or_create_air_client(&app_handle, air_address).await?;
+    let air_address = get_air_address(app_handle.inner())?;
+    let client = get_or_create_air_client(app_handle.inner(), air_address).await?;
 
     let request = DownloadRequest {
         request_id: uuid::Uuid::new_v4().to_string(),
@@ -246,14 +246,14 @@ pub async fn DownloadUpdate(
 /// Success status or error message
 #[tauri::command]
 pub async fn ApplyUpdate(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
     update_id: String,
     update_path: String,
 ) -> Result<bool, String> {
     debug!("[WindAirCommands] ApplyUpdate called: id={}, path={}", update_id, update_path);
 
-    let air_address = get_air_address(&app_handle)?;
-    let client = get_or_create_air_client(&app_handle, air_address).await?;
+    let air_address = get_air_address(app_handle.inner())?;
+    let client = get_or_create_air_client(app_handle.inner(), air_address).await?;
 
     // Use ApplyUpdateRequest from Air module
     let request = ApplyUpdateRequest {
@@ -292,7 +292,7 @@ pub async fn ApplyUpdate(
 /// `DownloadResultDTO` with download status
 #[tauri::command]
 pub async fn DownloadFile(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
     url: String,
     destination: String,
 ) -> Result<DownloadResultDTO, String> {
@@ -344,15 +344,15 @@ pub async fn DownloadFile(
 /// `AuthResponseDTO` with authentication token
 #[tauri::command]
 pub async fn AuthenticateUser(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
     username: String,
     password: String,
     provider: String,
 ) -> Result<AuthResponseDTO, String> {
     debug!("[WindAirCommands] AuthenticateUser called: {} via {}", username, provider);
 
-    let air_address = get_air_address(&app_handle)?;
-    let client = get_or_create_air_client(&app_handle, air_address).await?;
+    let air_address = get_air_address(app_handle.inner())?;
+    let client = get_or_create_air_client(app_handle.inner(), air_address).await?;
 
     let request = AuthenticationRequest {
         request_id: uuid::Uuid::new_v4().to_string(),
@@ -396,16 +396,16 @@ pub async fn AuthenticateUser(
 /// `IndexResultDTO` with indexing results
 #[tauri::command]
 pub async fn IndexFiles(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
     path: String,
     patterns: Vec<String>,
     exclude_patterns: Option<Vec<String>>,
     max_depth: Option<u32>,
 ) -> Result<IndexResultDTO, String> {
     debug!("[WindAirCommands] IndexFiles called: {} with patterns: {:?}", path, patterns);
 
-    let air_address = get_air_address(&app_handle)?;
-    let client = get_or_create_air_client(&app_handle, air_address).await?;
+    let air_address = get_air_address(app_handle.inner())?;
+    let client = get_or_create_air_client(app_handle.inner(), air_address).await?;
 
     let request = IndexRequest {
         request_id: uuid::Uuid::new_v4().to_string(),
@@ -449,15 +449,15 @@ pub async fn IndexFiles(
 /// `SearchResultsDTO` with matching files
 #[tauri::command]
 pub async fn SearchFiles(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
     query: String,
     index_id: Option<String>,
     max_results: Option<u32>,
 ) -> Result<SearchResultsDTO, String> {
     debug!("[WindAirCommands] SearchFiles called: query={}, index={:?}", query, index_id);
 
-    let air_address = get_air_address(&app_handle)?;
-    let client = get_or_create_air_client(&app_handle, air_address).await?;
+    let air_address = get_air_address(app_handle.inner())?;
+    let client = get_or_create_air_client(app_handle.inner(), air_address).await?;
 
     let request = SearchRequest {
         request_id: uuid::Uuid::new_v4().to_string(),
@@ -506,12 +506,12 @@ pub async fn SearchFiles(
 /// `AirServiceStatusDTO` with service status information
 #[tauri::command]
 pub async fn GetAirStatus(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
 ) -> Result<AirServiceStatusDTO, String> {
     debug!("[WindAirCommands] GetAirStatus called");
 
-    let air_address = get_air_address(&app_handle)?;
-    let client = get_or_create_air_client(&app_handle, air_address).await?;
+    let air_address = get_air_address(app_handle.inner())?;
+    let client = get_or_create_air_client(app_handle.inner(), air_address).await?;
 
     let request = StatusRequest {
         request_id: uuid::Uuid::new_v4().to_string(),
@@ -553,13 +553,13 @@ pub async fn GetAirStatus(
 /// `AirMetricsDTO` with metrics data
 #[tauri::command]
 pub async fn GetAirMetrics(
-    app_handle: tauri::AppHandle,
+    app_handle: tauri::State<'_, tauri::AppHandle>,
     metric_type: Option<String>,
 ) -> Result<AirMetricsDTO, String> {
     debug!("[WindAirCommands] GetAirMetrics called with type: {:?}", metric_type);
 
-    let air_address = get_air_address(&app_handle)?;
-    let client = get_or_create_air_client(&app_handle, air_address).await?;
+    let air_address = get_air_address(app_handle.inner())?;
+    let client = get_or_create_air_client(app_handle.inner(), air_address).await?;
 
     let request = MetricsRequest {
         request_id: uuid::Uuid::new_v4().to_string(),

Source/IPC/WindAirCommands.rs

@@ -19,7 +19,7 @@ use std::{collections::HashMap, env, sync::Arc};
 use Common::{
 	Environment::Requires::Requires,
 	Error::CommonError::CommonError,
-	ExtensionManagement::ExtensionManagementService::ExtensionManagementService,
+	ExtensionManagement::ExtensionManagementService,
 	WorkSpace::WorkSpaceProvider::WorkSpaceProvider,
 };
 use log::info;

Source/ProcessManagement/InitializationData.rs

@@ -0,0 +1,184 @@
+//! # CocoonServiceServer
+//!
+//! Implements the gRPC server for Mountain-Cocoon communication.
+
+#![allow(non_snake_case, non_camel_case_types)]
+
+use std::sync::Arc;
+use log::{debug, error, info};
+use tonic::{Request, Response, Status};
+use async_trait::async_trait;
+
+use super::super::Generated::{
+    cocoon_service_server::CocoonService,
+    GenericRequest, GenericResponse, GenericNotification, CancelOperationRequest, Empty, RpcError
+};
+use crate::{
+    ApplicationState::ApplicationState,
+    Environment::MountainEnvironment::MountainEnvironment,
+};
+use Common::ExtensionManagement::ExtensionManagementService;
+
+/// Implementation of the CocoonService gRPC server
+pub struct CocoonServiceImpl {
+    /// Mountain environment
+    environment: Arc<MountainEnvironment>,
+}
+
+impl CocoonServiceImpl {
+    /// Creates a new instance of the CocoonService server
+    pub fn new(environment: Arc<MountainEnvironment>) -> Self {
+info!("[CocoonServiceImpl] New instance created");
+        
+        Self {
+            environment,
+        }
+    }
+    
+    /// Handle generic Mountain requests from Cocoon
+    async fn handle_mountain_request(
+        &self,
+        request: GenericRequest,
+    ) -> Result<GenericResponse, Status> {
+        debug!(
+            "[CocoonServiceImpl] Handling Mountain request '{}' with ID {}",
+            request.method, request.request_identifier
+        );
+        
+        match request.method.as_str() {
+            "InitializeExtensionHost" => {
+                info!("[CocoonServiceImpl] Initializing extension host");
+                
+                // Return success response
+                Ok(GenericResponse {
+                    request_identifier: request.request_identifier,
+                    result: serde_json::to_vec(&"initialized").map_err(|e| {
+                        Status::internal(format!("Failed to serialize response: {}", e))
+                    })?,
+                    error: None,
+                })
+            }
+            
+            "GetExtensions" => {
+                debug!("[CocoonServiceServer] Getting extensions");
+                
+                let extension_service: Arc<dyn ExtensionManagementService> = (*self.environment).Require();
+                let extensions = extension_service.get_extensions().await.map_err(|e| {
+                    Status::internal(format!("Failed to get extensions: {}", e))
+                })?;
+                
+                Ok(GenericResponse {
+                    request_identifier: request.request_identifier,
+                    result: serde_json::to_vec(&extensions).map_err(|e| {
+                        Status::internal(format!("Failed to serialize extensions: {}", e))
+                    })?,
+                    error: None,
+                })
+            }
+            
+            "ActivateExtension" => {
+                debug!("[CocoonServiceServer] Activating extension");
+                
+                let params: serde_json::Value = serde_json::from_slice(&request.parameter)
+                    .map_err(|e| Status::invalid_argument(format!("Invalid parameters: {}", e)))?;
+                
+                let extension_id = params["extensionId"]
+                    .as_str()
+                    .ok_or_else(|| Status::invalid_argument("Missing extensionId parameter"))?;
+                
+                let extension_service: Arc<dyn ExtensionManagementService> = (*self.environment).Require();
+                extension_service.activate_extension(extension_id).await
+                    .map_err(|e| Status::internal(format!("Failed to activate extension: {}", e)))?;
+                
+                Ok(GenericResponse {
+                    request_identifier: request.request_identifier,
+                    result: serde_json::to_vec(&"activated").map_err(|e| {
+                        Status::internal(format!("Failed to serialize response: {}", e))
+                    })?,
+                    error: None,
+                })
+            }
+            
+            _ => {
+                error!(
+                    "[CocoonServiceServer] Unknown Mountain request method '{}'",
+                    request.method
+                );
+                
+                Err(Status::unimplemented(format!(
+                    "Unknown method: {}",
+                    request.method
+                )))
+            }
+        }
+    }
+}
+
+#[async_trait]
+impl CocoonService for CocoonServiceImpl {
+    /// Process Mountain requests from Cocoon
+    async fn process_mountain_request(
+        &self,
+        request: Request<GenericRequest>,
+    ) -> Result<Response<GenericResponse>, Status> {
+        let request_data = request.into_inner();
+        
+        match self.handle_mountain_request(request_data).await {
+            Ok(response) => Ok(Response::new(response)),
+            Err(status) => {
+                error!("[CocoonServiceImpl] Error processing Mountain request: {}", status);
+                Err(status)
+            }
+        }
+    }
+    
+    /// Send Mountain notifications to Cocoon
+    async fn send_mountain_notification(
+        &self,
+        request: Request<GenericNotification>,
+    ) -> Result<Response<Empty>, Status> {
+        let notification = request.into_inner();
+        
+        debug!(
+            "[CocoonServiceServer] Received Mountain notification '{}'",
+            notification.method
+        );
+        
+        // Handle notifications (fire-and-forget)
+        match notification.method.as_str() {
+            "ExtensionActivated" => {
+                info!("[CocoonServiceServer] Extension activated notification");
+            }
+            
+            "ExtensionDeactivated" => {
+                info!("[CocoonServiceServer] Extension deactivated notification");
+            }
+            
+            _ => {
+                debug!(
+                    "[CocoonServiceServer] Unknown Mountain notification '{}'",
+                    notification.method
+                );
+            }
+        }
+        
+        Ok(Response::new(Empty {}))
+    }
+    
+    /// Cancel operations requested by Mountain
+    async fn cancel_operation(
+        &self,
+        request: Request<CancelOperationRequest>,
+    ) -> Result<Response<Empty>, Status> {
+        let cancel_request = request.into_inner();
+        
+        info!(
+            "[CocoonServiceServer] Cancelling operation with ID {}",
+            cancel_request.request_identifier_to_cancel
+        );
+        
+        // TODO: Implement operation cancellation logic
+        
+        Ok(Response::new(Empty {}))
+    }
+}