refactor(Mountain): Overhaul effect dispatching and Vine client

- Replaced ActionEffect-based dispatch with closure-based execution in Track module, simplifying type signatures and error handling
- Updated Vine client to use correct gRPC methods (send_mountain_notification) and hashed request IDs
- Centralized lock error handling via map_lock_error helper and propagated CommonError consistently
- Migrated Cocoon management to Tauri's path resolver API with improved error propagation
- Removed outdated comments and stubs across ApplicationState, ConfigurationProvider, and DocumentStateDTO
- Added trivial_bounds feature to simplify trait bounds in Library

These changes enhance IPC reliability with Cocoon, streamline effect execution, and improve error handling consistency throughout Mountain.

Author: NikolaRHristov

Cargo.toml

@@ -52,6 +52,7 @@ parking_lot = { workspace = true }
 lazy_static = { workspace = true }
 portable-pty = { workspace = true }
 prost = { workspace = true }
+http = { workspace = true }
 
 # regex = { workspace = true }
 # unbug = { workspace = true }

Source/ApplicationState/ApplicationState.rs

@@ -11,12 +11,14 @@ use std::{
 	sync::{
 		Arc,
 		Mutex as StandardMutex,
+		PoisonError,
 		atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering as AtomicOrdering},
 	},
 };
 
+use Common::Error::CommonError::CommonError;
 use log::{error, info, warn};
-use tauri::{Manager, Wry};
+use tauri::Wry;
 
 use super::{
 	DTO::{
@@ -38,10 +40,6 @@ use super::{
 use crate::Environment::CommandProvider::CommandHandler;
 
 /// The central, shared, thread-safe state for the entire Mountain application.
-///
-/// This struct consolidates all dynamic state required by the backend, from
-/// workspace information and configuration to the state of active UI components
-/// like terminals and WebViews.
 #[derive(Clone)]
 pub struct ApplicationState {
 	// --- WorkSpace State ---
@@ -78,16 +76,12 @@ pub struct ApplicationState {
 	pub ActiveTreeViews:Arc<StandardMutex<HashMap<String, TreeViewStateDTO>>>,
 
 	// --- IPC & User Interface State ---
-	pub PendingUserInterfaceRequests: Arc<
-		StandardMutex<
-			HashMap<
-				String,
-				tokio::sync::oneshot::Sender<Result<serde_json::Value, Common::Error::CommonError::CommonError>>,
-			>,
-		>,
-	>,
+	pub PendingUserInterfaceRequests:
+		Arc<StandardMutex<HashMap<String, tokio::sync::oneshot::Sender<Result<serde_json::Value, CommonError>>>>>,
 }
 
+fn map_lock_error<T>(e:PoisonError<T>) -> CommonError { CommonError::StateLockPoisoned { Context:e.to_string() } }
+
 impl Default for ApplicationState {
 	fn default() -> Self {
 		info!("[ApplicationState] Initializing default application state...");
@@ -114,8 +108,6 @@ impl Default for ApplicationState {
 
 		let GlobalMementoFilePath = Internal::ResolveMementoStorageFilePath(&ApplicationDataDirectoryPath, true, "");
 		let InitialGlobalMementoMap = Internal::LoadInitialMementoFromDisk(&GlobalMementoFilePath);
-		// let InitialCommandRegistryMap =
-		// crate::Handler::Command::RegisterNativeCommands(); // TODO: Re-integrate
 
 		info!("[ApplicationState] Default state initialization complete.");
 		Self {
@@ -128,7 +120,7 @@ impl Default for ApplicationState {
 			GlobalMementoPath:GlobalMementoFilePath,
 			WorkSpaceMemento:Arc::new(StandardMutex::new(HashMap::new())),
 			WorkSpaceMementoPath:Arc::new(StandardMutex::new(None)),
-			CommandRegistry:Arc::new(StandardMutex::new(HashMap::new())), // TODO: Use InitialCommandRegistryMap
+			CommandRegistry:Arc::new(StandardMutex::new(HashMap::new())),
 			DiagnosticsMap:Arc::new(StandardMutex::new(HashMap::new())),
 			OpenDocuments:Arc::new(StandardMutex::new(HashMap::new())),
 			OutputChannels:Arc::new(StandardMutex::new(HashMap::new())),
@@ -149,17 +141,16 @@ impl Default for ApplicationState {
 }
 
 impl ApplicationState {
-	/// Generates a unique, filesystem-safe identifier string for the current
+	/// Generates a unique, filesystem-safe identifier for the current
 	/// workspace.
-	pub fn GetWorkSpaceIdentifier(&self) -> Result<String, String> {
-		let LockErrorMapper = |e| format!("[AppState] Lock error: {}", e);
-		let ConfigurationPathGuard = self.WorkSpaceConfigurationPath.lock().map_err(LockErrorMapper)?;
+	pub fn GetWorkSpaceIdentifier(&self) -> Result<String, CommonError> {
+		let ConfigurationPathGuard = self.WorkSpaceConfigurationPath.lock().map_err(map_lock_error)?;
 		if let Some(ConfigurationPath) = ConfigurationPathGuard.as_ref() {
 			return Ok(ConfigurationPath.file_name().unwrap_or_default().to_string_lossy().into_owned());
 		}
 		drop(ConfigurationPathGuard);
 
-		let FoldersGuard = self.WorkSpaceFolders.lock().map_err(LockErrorMapper)?;
+		let FoldersGuard = self.WorkSpaceFolders.lock().map_err(map_lock_error)?;
 		if let Some(FirstFolder) = FoldersGuard.first() {
 			let PathString = FirstFolder.URI.path();
 			// Create a more stable hash for the identifier.
@@ -184,14 +175,13 @@ impl ApplicationState {
 	/// Updates the path to the workspace memento file and reloads its content
 	/// from disk.
 	pub fn UpdateWorkSpaceMementoPathAndReload(&self, ApplicationDataDirectory:&Path) -> Result<(), String> {
-		let LockErrorMapper = |e| format!("[AppState] Lock error: {}", e);
-		let WorkSpaceIdentifier = self.GetWorkSpaceIdentifier()?;
-		let mut PathGuard = self.WorkSpaceMementoPath.lock().map_err(LockErrorMapper)?;
+		let WorkSpaceIdentifier = self.GetWorkSpaceIdentifier().map_err(|e| e.to_string())?;
+		let mut PathGuard = self.WorkSpaceMementoPath.lock().map_err(|e| e.to_string())?;
 
 		if WorkSpaceIdentifier == "NO_WORKSPACE" {
 			if PathGuard.is_some() {
 				*PathGuard = None;
-				self.WorkSpaceMemento.lock().map_err(LockErrorMapper)?.clear();
+				self.WorkSpaceMemento.lock().map_err(|e| e.to_string())?.clear();
 			}
 			return Ok(());
 		}
@@ -206,7 +196,7 @@ impl ApplicationState {
 			}
 			*PathGuard = Some(NewMementoPath.clone());
 			let NewMementoContent = Internal::LoadInitialMementoFromDisk(&NewMementoPath);
-			*self.WorkSpaceMemento.lock().map_err(LockErrorMapper)? = NewMementoContent;
+			*self.WorkSpaceMemento.lock().map_err(|e| e.to_string())? = NewMementoContent;
 		}
 		Ok(())
 	}

Source/ApplicationState/DTO/DocumentStateDTO.rs

@@ -8,11 +8,7 @@ use serde_json::Value;
 use url::Url;
 
 use super::RPCModelContentChangeDTO::RPCModelContentChangeDTO;
-use crate::ApplicationState::Internal::{
-	AnalyzeTextLinesAndEOL,
-	URLSerializationHelper, /* DetectFileEncodingFromBytes,
-	                         * DetectLanguageIdentifierFromFilePath, */
-};
+use crate::ApplicationState::Internal::{AnalyzeTextLinesAndEOL, URLSerializationHelper};
 
 /// Represents the complete in-memory state of a single text document.
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -39,9 +35,8 @@ impl DocumentStateDTO {
 	/// Creates a new `DocumentStateDTO` from its initial content.
 	pub fn Create(URI:Url, LanguageIdentifier:Option<String>, Content:String) -> Self {
 		let (Lines, EOL) = AnalyzeTextLinesAndEOL(&Content);
-		// A real implementation would have more robust language/encoding detection.
 		let LanguageID = LanguageIdentifier.unwrap_or_else(|| "plaintext".to_string());
-		let Encoding = "utf8".to_string(); // Stub for encoding detection
+		let Encoding = "utf8".to_string();
 
 		Self {
 			URI,
@@ -61,18 +56,14 @@ impl DocumentStateDTO {
 	pub fn ToDTO(&self) -> Value { serde_json::to_value(self).unwrap_or(Value::Null) }
 
 	/// Applies a set of changes to the document.
-	///
-	/// This is a complex operation that simulates how a text buffer would be
-	/// updated. For this implementation, it is simplified.
 	pub fn ApplyChanges(&mut self, NewVersion:i64, ChangesValue:&Value) -> Result<(), String> {
 		if NewVersion <= self.Version {
 			return Ok(()); // Ignore stale changes
 		}
 
-		let RPCChanges:Vec<RPCModelContentChangeDTO> = match serde_json::from_value(ChangesValue.clone()) {
+		let _RPCChanges:Vec<RPCModelContentChangeDTO> = match serde_json::from_value(ChangesValue.clone()) {
 			Ok(changes) => changes,
 			Err(_) => {
-				// Fallback for a full-content change, which is a common scenario.
 				if let Some(FullText) = ChangesValue.as_str() {
 					let (NewLines, NewEOL) = AnalyzeTextLinesAndEOL(FullText);
 					self.Lines = NewLines;
@@ -85,10 +76,6 @@ impl DocumentStateDTO {
 			},
 		};
 
-		// A full implementation would require a rope data structure or complex logic
-		// to apply deltas efficiently. We will log a warning and accept the new
-		// version number, but the content will be out of sync until the next full
-		// update.
 		log::warn!(
 			"Applying changes to {} by version bump only (delta application is a stub).",
 			self.URI

Source/Environment/CommandProvider.rs

@@ -35,7 +35,6 @@ pub enum CommandHandler<R:Runtime + 'static> {
 	Proxied { SidecarIdentifier:String, CommandIdentifier:String },
 }
 
-// Manually implement Clone because fn pointers are not automatically Clone
 impl<R:Runtime> Clone for CommandHandler<R> {
 	fn clone(&self) -> Self {
 		match self {

Source/Environment/ConfigurationProvider.rs

@@ -27,8 +27,6 @@ use serde_json::{Map, Value};
 use tauri::Manager;
 
 use super::MountainEnvironment::MountainEnvironment;
-// TODO: Re-integrate IPC client for notifications
-// use crate::Vine::Client;
 
 #[async_trait]
 impl ConfigurationProvider for MountainEnvironment {
@@ -59,16 +57,21 @@ impl ConfigurationProvider for MountainEnvironment {
 	) -> Result<(), CommonError> {
 		info!("[ConfigurationProvider] Updating key '{}' in target {:?}", Key, Target);
 
-		let ConfigPath = match Target {
+		let config_path_result:Result<Option<PathBuf>, CommonError> = match Target {
 			ConfigurationTarget::User => {
-				self.ApplicationHandle.path().app_config_dir().map(|p| p.join("settings.json"))
+				self.ApplicationHandle
+					.path()
+					.app_config_dir()
+					.map(|p| Some(p.join("settings.json")))
+					.map_err(|e| CommonError::ConfigurationLoad { Description:e.to_string() })
 			},
 			ConfigurationTarget::WorkSpace => {
-				self.ApplicationState
+				Ok(self
+					.ApplicationState
 					.WorkSpaceConfigurationPath
 					.lock()
 					.map_err(super::Utility::MapApplicationStateLockErrorToCommonError)?
-					.clone()
+					.clone())
 			},
 			_ => {
 				return Err(CommonError::NotImplemented {
@@ -77,11 +80,12 @@ impl ConfigurationProvider for MountainEnvironment {
 			},
 		};
 
+		let ConfigPath = config_path_result?;
+
 		if let Some(Path) = ConfigPath {
 			let mut CurrentConfig = ReadAndParseConfigurationFile(self, &Some(Path.clone())).await;
 
 			if let Value::Object(Map) = &mut CurrentConfig {
-				// A more robust implementation would handle nested keys like "a.b.c".
 				if ValueToSet.is_null() {
 					Map.remove(&Key);
 				} else {
@@ -95,8 +99,6 @@ impl ConfigurationProvider for MountainEnvironment {
 			let FileSystemWriter:Arc<dyn FileSystemWriter> = self.Require();
 			FileSystemWriter.WriteFile(&Path, ContentBytes, true, true).await?;
 
-			// After writing, trigger a full reload to update the in-memory state and notify
-			// sidecars.
 			InitializeAndMergeConfigurations(self).await;
 			Ok(())
 		} else {
@@ -116,15 +118,11 @@ impl ConfigurationInspector for MountainEnvironment {
 		_Key:String,
 		_Overrides:ConfigurationOverridesDTO,
 	) -> Result<Option<InspectResultDataDTO>, CommonError> {
-		// This is a complex operation requiring reading from all config files
-		// without merging them to build the final DTO. It is a stub for now.
 		warn!("[ConfigurationProvider] InspectConfigurationValue is not fully implemented.");
 		Ok(None)
 	}
 }
 
-// --- Internal Helper Functions ---
-
 /// An internal helper to read and parse a single JSON configuration file.
 async fn ReadAndParseConfigurationFile(Environment:&MountainEnvironment, Path:&Option<PathBuf>) -> Value {
 	if let Some(p) = Path {
@@ -142,24 +140,21 @@ async fn ReadAndParseConfigurationFile(Environment:&MountainEnvironment, Path:&O
 
 /// Logic to load and merge all configuration files into the effective
 /// configuration stored in `ApplicationState`.
-///
-/// This should be called at startup and after any settings file changes.
 pub async fn InitializeAndMergeConfigurations(Environment:&MountainEnvironment) {
 	info!("[ConfigurationProvider] Initializing and merging all configurations...");
 
 	let UserSettingsPath = Environment
 		.ApplicationHandle
 		.path()
 		.app_config_dir()
-		.map(|p| p.join("settings.json"));
+		.map(|p| p.join("settings.json"))
+		.ok();
 
 	let WorkSpaceSettingsPath = Environment.ApplicationState.WorkSpaceConfigurationPath.lock().unwrap().clone();
 
 	let UserConfig = ReadAndParseConfigurationFile(Environment, &UserSettingsPath).await;
 	let WorkSpaceConfig = ReadAndParseConfigurationFile(Environment, &WorkSpaceSettingsPath).await;
 
-	// A real implementation would also load default and folder-level settings.
-	// The merge order is critical: workspace settings override user settings.
 	let mut Merged = UserConfig.as_object().cloned().unwrap_or_default();
 	if let Some(WorkSpaceMap) = WorkSpaceConfig.as_object() {
 		for (k, v) in WorkSpaceMap {
@@ -171,17 +166,7 @@ pub async fn InitializeAndMergeConfigurations(Environment:&MountainEnvironment)
 		Value::Object(Merged),
 	);
 
-	// Update the central application state.
 	*Environment.ApplicationState.Configuration.lock().unwrap() = FinalConfig.clone();
 
-	// TODO: Notify Cocoon of the change using the IPCProvider.
-	// let Payload = serde_json::json!({ "keys": [], "source": 0 }); // Simplified
-	// let IPCProvider: Arc<dyn IPCProvider> = Environment.Require();
-	// IPCProvider.SendNotificationToSidecar(
-	//     "cocoon-main".to_string(),
-	//     "$acceptConfigurationChanged".to_string(),
-	//     serde_json::json!([Payload, FinalConfig]),
-	// ).await.unwrap_or_else(|e| warn!("[ConfigurationProvider] Failed to notify
-	// Cocoon of config change: {}", e));
 	info!("[ConfigurationProvider] Configuration state updated and merged.");
 }

Source/Environment/OutputProvider.rs

@@ -26,7 +26,6 @@ impl OutputChannelManager for MountainEnvironment {
 			.lock()
 			.map_err(Utility::MapApplicationStateLockErrorToCommonError)?;
 
-		// Create the channel if it doesn't exist.
 		ChannelsGuard
 			.entry(ChannelIdentifier.clone())
 			.or_insert_with(|| OutputChannelStateDTO::Create(&Name, LanguageIdentifier.clone()));
@@ -123,9 +122,7 @@ impl OutputChannelManager for MountainEnvironment {
 	}
 
 	/// Closes the view of an output channel in the UI.
-	async fn Close(&self, ChannelIdentifier:String) -> Result<(), CommonError> {
-		// This would typically just update the IsVisible flag and emit an event.
-		// For simplicity, this is a stub.
+	async fn Close(&self, _ChannelIdentifier:String) -> Result<(), CommonError> {
 		warn!("[OutputProvider] Close is not fully implemented.");
 		Ok(())
 	}

Source/Environment/SecretProvider.rs

@@ -8,18 +8,12 @@ use Common::{Error::CommonError::CommonError, Secret::SecretProvider::SecretProv
 use async_trait::async_trait;
 use keyring::Entry;
 use log::{info, trace};
-use tauri::Manager;
 
 use super::MountainEnvironment::MountainEnvironment;
 
 /// Constructs the service name for the keyring entry.
-///
-/// This is a crucial security feature that namespaces secrets on a
-/// per-extension basis, preventing one extension from reading another's
-/// secrets. It combines the application's unique identifier with the
-/// extension's identifier.
 fn GetKeyringServiceName(Environment:&MountainEnvironment, ExtensionIdentifier:&str) -> String {
-	format!("{}.{}", Environment.ApplicationHandle.config().identifier, ExtensionIdentifier)
+	format!("{}.{}", Environment.ApplicationHandle.package_info().name, ExtensionIdentifier)
 }
 
 #[async_trait]
@@ -36,7 +30,7 @@ impl SecretProvider for MountainEnvironment {
 
 		match Entry.get_password() {
 			Ok(Password) => Ok(Some(Password)),
-			Err(keyring::Error::NoEntry) => Ok(None), // Not finding a secret is not an error.
+			Err(keyring::Error::NoEntry) => Ok(None),
 			Err(e) => Err(CommonError::SecretsAccess { Key, Reason:e.to_string() }),
 		}
 	}
@@ -66,8 +60,6 @@ impl SecretProvider for MountainEnvironment {
 		let Entry = Entry::new(&ServiceName, &Key)
 			.map_err(|e| CommonError::SecretsAccess { Key:Key.clone(), Reason:e.to_string() })?;
 
-		// This operation is idempotent; it is considered successful even if the
-		// entry doesn't exist.
 		match Entry.delete_credential() {
 			Ok(_) | Err(keyring::Error::NoEntry) => Ok(()),
 			Err(e) => Err(CommonError::SecretsAccess { Key, Reason:e.to_string() }),

Source/Library.rs

@@ -6,6 +6,7 @@
 //! components.
 
 #![allow(non_snake_case, non_camel_case_types)]
+#![feature(trivial_bounds)]
 
 pub mod ApplicationState;
 pub mod Environment;