refactor(Mountain/Vine): Centralize effect mapping and standardize gRPC error handling

- Introduced `erase_and_map_effect` helper in `EffectCreation` to uniformly handle capability requirements and JSON serialization for all ActionEffects, replacing manual mapping and simplifying effect creation
- Renamed `RPCError` to `RpcError` in `Vine.proto` to match Rust naming conventions and reflect recent standardization efforts
- Simplified error handling in `TreeViewProvider` by removing redundant error type specification
- Refactored `VineError` variants to be more concise:
  - Replaced detailed error variants with generalized `ClientNotConnected` and `RpcError`
  - Added automatic conversion from `tonic::Status` to `RpcError`
- Updated gRPC service methods to use snake_case per Rust conventions
- Added `transport` feature to tonic-build in Cargo.toml for future IPC enhancements

This refactoring aligns with Land's final architecture by:
1) Strengthening the `Track` dispatcher's ability to handle `Common`-defined ActionEffects with proper capability resolution
2) Ensuring consistent error handling across the `Vine` gRPC layer
3) Reducing boilerplate in effect-to-RPC mapping while maintaining type safety
4) Preparing for enhanced transport capabilities in the IPC layer between Mountain and Cocoon

Author: NikolaRHristov

Cargo.toml

@@ -9,10 +9,10 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 tauri-build = { workspace = true, features = [] }
 toml = { workspace = true }
-tonic-build = { workspace = true }
+tonic-build = { workspace = true, features = ["transport"] }
 
 [dependencies]
-tauri = { version = "*", features = [
+tauri = { workspace = true, features = [
 	"wry",
 	"tray-icon",
 	"devtools",

Proto/Vine.proto

@@ -36,7 +36,7 @@ message GenericRequest {
 message GenericResponse {
   uint64 request_id = 1;
   bytes result = 2; // The successful result, JSON-serialized.
-  optional RPCError error = 3;
+  optional RpcError error = 3;
 }
 
 // A generic notification message, which is fire-and-forget and does not have an ID.
@@ -46,7 +46,7 @@ message GenericNotification {
 }
 
 // A structured error payload, compliant with JSON-RPC error objects.
-message RPCError {
+message RpcError {
   int32 code = 1;
   string message = 2;
   bytes data = 3; // Optional, additional error data, JSON-serialized.

Source/Environment/TreeViewProvider.rs

@@ -18,9 +18,8 @@ impl TreeViewProvider for MountainEnvironment {
 	/// Registers a new tree data provider from Cocoon.
 	async fn RegisterTreeDataProvider(&self, ViewIdentifier:String, Options:Value) -> Result<(), CommonError> {
 		info!("[TreeViewProvider] Registering data provider for view: {}", ViewIdentifier);
-		let OptionsDTO:Common::TreeView::DTO::TreeViewOptionsDTO = serde_json::from_value(Options).map_err(|e| {
-			CommonError::CommonError::InvalidArgument { ArgumentName:"Options".into(), Reason:e.to_string() }
-		})?;
+		let OptionsDTO:Common::TreeView::DTO::TreeViewOptionsDTO::TreeViewOptionsDTO = serde_json::from_value(Options)
+			.map_err(|e| CommonError::InvalidArgument { ArgumentName:"Options".into(), Reason:e.to_string() })?;
 
 		let NewState = TreeViewStateDTO {
 			ViewIdentifier:ViewIdentifier.clone(),

Source/Track/EffectCreation.rs

@@ -9,8 +9,7 @@
 use std::sync::Arc;
 
 use Common::{
-	self,
-	Effect::{ActionEffect::ActionEffect, ApplicationRunTime::ApplicationRunTime},
+	Effect::{ActionEffect::ActionEffect, ApplicationRunTime::ApplicationRunTime as ApplicationRunTimeTrait},
 	Error::CommonError::CommonError,
 };
 use serde_json::{Value, from_value};
@@ -34,6 +33,22 @@ macro_rules! get_param {
 	};
 }
 
+/// A helper function to erase the specific capability type of an effect,
+/// mapping it to a generic effect that can be run by the dispatcher.
+fn erase_and_map_effect<C, O, E>(effect:ActionEffect<Arc<C>, E, O>) -> MappedEffect
+where
+	C: ?Sized + Send + Sync + 'static,
+	O: serde::Serialize + Send + 'static,
+	E: Into<CommonError> + Send + Sync + 'static,
+	MountainRunTime: Common::Environment::Requires::Requires<C>, {
+	let mapped_effect = effect.map(|output| serde_json::to_value(output).unwrap_or(Value::Null));
+
+	ActionEffect::New(Arc::new(move |runtime:Arc<MountainRunTime>| {
+		let effect_clone = mapped_effect.clone();
+		Box::pin(async move { runtime.Run(effect_clone).await.map_err(|e| e.into()) })
+	}))
+}
+
 /// Creates an `ActionEffect` for a request from any source (frontend or
 /// sidecar).
 pub fn CreateEffectForRequest<R:Runtime>(
@@ -47,31 +62,36 @@ pub fn CreateEffectForRequest<R:Runtime>(
 
 	// This is the main RPC-to-Effect mapping. It deserializes the `params`
 	// into the arguments required by the corresponding effect constructor.
-	let Effect:MappedEffect = match Method {
+	let effect:MappedEffect = match Method {
 		// --- Command Effects ---
 		"Command.Execute" => {
 			let ID = get_param!(ParametersArray, 0, String)?;
 			let Args = ParametersArray.get(1).cloned().unwrap_or(Value::Null);
-			Common::Command::ExecuteCommand::ExecuteCommand(ID, Args).map(to_value)
+			let specific_effect = Common::Command::ExecuteCommand::ExecuteCommand(ID, Args);
+			erase_and_map_effect(specific_effect)
 		},
 		"Command.Register" => {
 			let SidecarID = get_param!(ParametersArray, 0, String)?;
 			let CommandID = get_param!(ParametersArray, 1, String)?;
-			Common::Command::RegisterCommand::RegisterCommand(SidecarID, CommandID).map(to_value)
+			let specific_effect = Common::Command::RegisterCommand::RegisterCommand(SidecarID, CommandID);
+			erase_and_map_effect(specific_effect)
 		},
 
 		// --- FileSystem Read Effects ---
 		"FileSystem.ReadFile" => {
 			let Path = get_param!(ParametersArray, 0, _)?;
-			Common::FileSystem::ReadFile::ReadFile(Path).map(to_value)
+			let specific_effect = Common::FileSystem::ReadFile::ReadFile(Path);
+			erase_and_map_effect(specific_effect)
 		},
 		"FileSystem.StatFile" => {
 			let Path = get_param!(ParametersArray, 0, _)?;
-			Common::FileSystem::StatFile::StatFile(Path).map(to_value)
+			let specific_effect = Common::FileSystem::StatFile::StatFile(Path);
+			erase_and_map_effect(specific_effect)
 		},
 		"FileSystem.ReadDirectory" => {
 			let Path = get_param!(ParametersArray, 0, _)?;
-			Common::FileSystem::ReadDirectory::ReadDirectory(Path).map(to_value)
+			let specific_effect = Common::FileSystem::ReadDirectory::ReadDirectory(Path);
+			erase_and_map_effect(specific_effect)
 		},
 
 		// --- FileSystem Write Effects ---
@@ -80,42 +100,34 @@ pub fn CreateEffectForRequest<R:Runtime>(
 			let Content = get_param!(ParametersArray, 1, Vec<u8>)?;
 			let Create = get_param!(ParametersArray, 2, bool)?;
 			let Overwrite = get_param!(ParametersArray, 3, bool)?;
-			Common::FileSystem::WriteFileBytes::WriteFileBytes(Path, Content, Create, Overwrite).map(to_value)
+			let specific_effect = Common::FileSystem::WriteFileBytes::WriteFileBytes(Path, Content, Create, Overwrite);
+			erase_and_map_effect(specific_effect)
 		},
 		"FileSystem.Delete" => {
 			let Path = get_param!(ParametersArray, 0, _)?;
 			let Recursive = get_param!(ParametersArray, 1, bool)?;
 			let UseTrash = get_param!(ParametersArray, 2, bool)?;
-			Common::FileSystem::Delete::Delete(Path, Recursive, UseTrash).map(to_value)
+			let specific_effect = Common::FileSystem::Delete::Delete(Path, Recursive, UseTrash);
+			erase_and_map_effect(specific_effect)
 		},
 
 		// --- UserInterface Effects ---
 		"UserInterface.ShowMessage" => {
 			let Severity = get_param!(ParametersArray, 0, _)?;
 			let Message = get_param!(ParametersArray, 1, String)?;
 			let Options = ParametersArray.get(2).cloned().unwrap_or(Value::Null);
-			Common::UserInterface::ShowMessage::ShowMessage(Severity, Message, Options).map(to_value)
+			let specific_effect = Common::UserInterface::ShowMessage::ShowMessage(Severity, Message, Options);
+			erase_and_map_effect(specific_effect)
 		},
 		"UserInterface.ShowOpenDialog" => {
 			let Options = get_param!(ParametersArray, 0, _)?;
-			Common::UserInterface::ShowOpenDialog::ShowOpenDialog(Options).map(to_value)
+			let specific_effect = Common::UserInterface::ShowOpenDialog::ShowOpenDialog(Options);
+			erase_and_map_effect(specific_effect)
 		},
 
 		// ... Add mappings for all other effects here ...
 		_ => return Err(format!("No ActionEffect mapping found for method: {}", Method)),
-	}?;
-
-	Ok(Effect)
-}
+	};
 
-/// A helper function to map the output of any effect to a `serde_json::Value`.
-fn to_value<TOutput:serde::Serialize, TError, TRunTime>(
-	effect:ActionEffect<Arc<TRunTime>, TError, TOutput>,
-) -> Result<MappedEffect, String>
-where
-	TRunTime: ApplicationRunTime<EnvironmentType = crate::Environment::MountainEnvironment::MountainEnvironment>
-		+ Send
-		+ Sync
-		+ 'static, {
-	Ok(effect.map(|output| serde_json::to_value(output).unwrap_or(Value::Null)))
+	Ok(effect)
 }

Source/Vine/Client.rs

@@ -71,12 +71,12 @@ pub async fn SendRequest(
 		match timeout(Duration::from_millis(TimeoutMilliseconds), Future).await {
 			Ok(Ok(Response)) => {
 				let ResponseData = Response.into_inner();
-				if let Some(RPCError) = ResponseData.error {
+				if let Some(RpcError) = ResponseData.error {
 					error!(
 						"[VineClient] Received RPC error from sidecar '{}': {}",
-						SidecarIdentifier, RPCError.message
+						SidecarIdentifier, RpcError.message
 					);
-					Err(VineError::RPCError(RPCError.message))
+					Err(VineError::RpcError(RpcError.message))
 				} else {
 					let DeserializedValue = from_slice(&ResponseData.result)?;
 					Ok(DeserializedValue)

Source/Vine/Error.rs

@@ -12,19 +12,12 @@ use thiserror::Error;
 pub enum VineError {
 	/// A gRPC client channel for the specified sidecar could not be found or
 	/// is not ready.
-	#[error("Sidecar '{SidecarIdentifier}' not found or its gRPC client channel is not ready: {Details}")]
-	ClientChannelError { SidecarIdentifier:String, Details:String },
+	#[error("Sidecar '{0}' not found or its gRPC client channel is not ready.")]
+	ClientNotConnected(String),
 
 	/// An RPC call to a sidecar failed with a specific gRPC status.
-	#[error(
-		"gRPC call to sidecar '{SidecarIdentifier}' (method: '{MethodName}') failed: {StatusCode} - {StatusMessage}"
-	)]
-	gRPCRequestFailed {
-		SidecarIdentifier:String,
-		MethodName:String,
-		StatusCode:String,
-		StatusMessage:String,
-	},
+	#[error("gRPC call failed: {0}")]
+	RpcError(String),
 
 	/// An error occurred while serializing or deserializing a JSON payload.
 	#[error("JSON serialization error for gRPC payload: {0}")]
@@ -43,10 +36,18 @@ pub enum VineError {
 	/// A shared state mutex was "poisoned," indicating a panic.
 	#[error("Internal state lock poisoned: {0}")]
 	InternalLockError(String),
+
+	/// An error occurred from an invalid URI.
+	#[error("Invalid URI: {0}")]
+	InvalidUri(#[from] tonic::transport::uri::InvalidUri),
 }
 
 impl<T> From<PoisonError<MutexGuard<'_, T>>> for VineError {
 	fn from(Error:PoisonError<MutexGuard<'_, T>>) -> Self {
 		VineError::InternalLockError(format!("Shared state lock poisoned: {}", Error))
 	}
 }
+
+impl From<tonic::Status> for VineError {
+	fn from(status:tonic::Status) -> Self { VineError::RpcError(status.to_string()) }
+}

Source/Vine/Server/MountainVinegRPCService.rs

@@ -20,7 +20,7 @@ use crate::{
 		GenericNotification,
 		GenericRequest,
 		GenericResponse,
-		RPCError,
+		RpcError,
 		mountain_service_server::MountainService,
 	},
 };
@@ -42,7 +42,10 @@ impl MountainVinegRPCService {
 #[tonic::async_trait]
 impl MountainService for MountainVinegRPCService {
 	/// Handles generic request-response RPCs from Cocoon.
-	async fn ProcessCocoonRequest(&self, request:Request<GenericRequest>) -> Result<Response<GenericResponse>, Status> {
+	async fn process_cocoon_request(
+		&self,
+		request:Request<GenericRequest>,
+	) -> Result<Response<GenericResponse>, Status> {
 		let RequestData = request.into_inner();
 		let MethodName = RequestData.method;
 		let RequestIdentifier = RequestData.request_id;
@@ -60,7 +63,7 @@ impl MountainService for MountainVinegRPCService {
 				return Ok(Response::new(GenericResponse {
 					request_id:RequestIdentifier,
 					result:vec![],
-					error:Some(RPCError { message:msg, code:-32700, data:vec![] }),
+					error:Some(RpcError { message:msg, code:-32700, data:vec![] }),
 				}));
 			},
 		};
@@ -91,7 +94,7 @@ impl MountainService for MountainVinegRPCService {
 				Ok(Response::new(GenericResponse {
 					request_id:RequestIdentifier,
 					result:vec![],
-					error:Some(RPCError {
+					error:Some(RpcError {
 						message:ErrorString,
 						code:-32000, // JSON-RPC Generic Server Error
 						data:vec![],
@@ -102,7 +105,7 @@ impl MountainService for MountainVinegRPCService {
 	}
 
 	/// Handles generic fire-and-forget notifications from Cocoon.
-	async fn SendCocoonNotification(&self, request:Request<GenericNotification>) -> Result<Response<Empty>, Status> {
+	async fn send_cocoon_notification(&self, request:Request<GenericNotification>) -> Result<Response<Empty>, Status> {
 		let NotificationData = request.into_inner();
 		let MethodName = NotificationData.method;
 		info!("[VineServer] Received gRPC Notification: Method='{}'", MethodName);
@@ -118,7 +121,7 @@ impl MountainService for MountainVinegRPCService {
 	}
 
 	/// Handles a request from Cocoon to cancel a long-running operation.
-	async fn CancelOperation(&self, _request:Request<CancelOperationRequest>) -> Result<Response<Empty>, Status> {
+	async fn cancel_operation(&self, _request:Request<CancelOperationRequest>) -> Result<Response<Empty>, Status> {
 		info!("[VineServer] Received CancelOperation request, but cancellation is not yet implemented.");
 		// A full implementation would map the request_id_to_cancel to a
 		// CancellationToken and trigger it.