refactor(Mountain): Enhance debug logging and refine effect system

- **Debug Logging**: Added colored trace-level logging for debug builds in `Binary.rs` to improve development visibility, formatting Mountain logs with application context and level-specific colors
- **Tauri Configuration**: Enabled `any_thread()` mode for Windows/Linux in Tauri builder to resolve potential runtime constraints
- **Terminal Provider**: Removed unnecessary `mut` qualifiers from PTY variables in `TerminalProvider.rs` as they aren't mutated after creation
- **Effect System**: Updated `box_effect` in `EffectCreation.rs` to:
  - Require `MountainEnvironment` instead of `MountainRunTime` for context resolution
  - Add `From<CommonError>` bound to error types for improved interoperability
  - Remove obsolete comment about effect mappings

These changes strengthen Mountain's core infrastructure:
1. Debug logging aids development while maintaining release-mode minimalism
2. Thread configuration prevents potential Tauri runtime issues
3. Terminal implementation adheres to Rust's ownership best practices
4. Effect system now properly leverages the `Environment` trait from `Common` crate, ensuring correct dependency resolution through `Requires` trait
5. Error handling alignment supports the standardized gRPC error system refined in recent commits

Author: NikolaRHristov

Source/Binary.rs

@@ -30,7 +30,32 @@ fn InitializeLogging() {
 		// This is unsafe but only runs once at startup.
 		unsafe { std::env::set_var("RUST_LOG", LogLevel) };
 	}
-	env_logger::init();
+
+	#[cfg(debug_assertions)]
+	{
+		env_logger::Builder::new()
+			.filter_level(log::LevelFilter::Trace)
+			.format(|Buffer, Record| {
+				use std::io::Write;
+
+				use colored::Colorize;
+				writeln!(
+					Buffer,
+					"[{}] [{}]: {}",
+					"Mountain".red(),
+					match Record.level() {
+						log::Level::Error => "ERROR".red().bold(),
+						log::Level::Warn => "WARN".yellow().bold(),
+						log::Level::Info => "INFO".green(),
+						log::Level::Debug => "DEBUG".blue(),
+						log::Level::Trace => "TRACE".magenta(),
+					},
+					Record.args()
+				)
+			})
+			.try_init()
+			.expect("Failed to initialize env_logger. Another logger might be active.");
+	}
 }
 
 /// The main asynchronous function that sets up and runs the application.
@@ -51,8 +76,14 @@ pub fn Fn() {
 			let SchedulerForShutdown = Arc::new(Scheduler);
 			let SchedulerForRunTime = SchedulerForShutdown.clone();
 
+			#[allow(unused_mut)]
 			let mut Builder = tauri::Builder::default();
 
+			#[cfg(any(windows, target_os = "linux"))]
+			{
+				Builder = Builder.any_thread();
+			}
+
 			Builder
 				.manage(ApplicationState::default())
 				.setup(move |Application| {

Source/Environment/TerminalProvider.rs

@@ -47,7 +47,7 @@ impl TerminalProvider for MountainEnvironment {
 		let mut TerminalState = TerminalStateDTO::Create(TerminalIdentifier, Name.clone(), &OptionsValue, DefaultShell);
 
 		let PtySystem = NativePtySystem::default();
-		let mut PtyPair = PtySystem
+		let PtyPair = PtySystem
 			.openpty(PtySize::default())
 			.map_err(|e| CommonError::IPCError { Description:format!("Failed to open PTY: {}", e) })?;
 
@@ -57,7 +57,7 @@ impl TerminalProvider for MountainEnvironment {
 			Command.cwd(CWD);
 		}
 
-		let mut ChildProcess = PtyPair
+		let ChildProcess = PtyPair
 			.slave
 			.spawn_command(Command)
 			.map_err(|e| CommonError::IPCError { Description:format!("Failed to spawn shell process: {}", e) })?;

Source/Track/EffectCreation.rs

@@ -11,12 +11,16 @@ use std::{future::Future, pin::Pin, sync::Arc};
 use Common::{
 	self,
 	Effect::{ActionEffect::ActionEffect, ApplicationRunTime::ApplicationRunTime as ApplicationRunTimeTrait},
+	Environment::Requires::Requires,
 	Error::CommonError::CommonError,
 };
 use serde_json::{Value, from_value};
 use tauri::{AppHandle, Runtime};
 
-use crate::RunTime::ApplicationRunTime::ApplicationRunTime as MountainRunTime;
+use crate::{
+	Environment::MountainEnvironment::MountainEnvironment,
+	RunTime::ApplicationRunTime::ApplicationRunTime as MountainRunTime,
+};
 
 /// A type alias for a boxed, runnable effect. This is the "type-erased" unit of
 /// work.
@@ -43,8 +47,8 @@ fn box_effect<C, O, E>(effect:ActionEffect<Arc<C>, E, O>) -> MappedEffect
 where
 	C: ?Sized + Send + Sync + 'static,
 	O: serde::Serialize + Send + Sync + 'static,
-	E: Into<CommonError> + Send + Sync + 'static,
-	MountainRunTime: Common::Environment::Requires::Requires<C>, {
+	E: Into<CommonError> + From<CommonError> + Send + Sync + 'static,
+	MountainEnvironment: Requires<C>, {
 	Box::new(move |runtime:Arc<MountainRunTime>| {
 		Box::pin(async move {
 			let result = runtime.Run(effect).await;
@@ -126,7 +130,6 @@ pub fn CreateEffectForRequest<R:Runtime>(
 			box_effect(Common::UserInterface::ShowOpenDialog::ShowOpenDialog(Options))
 		},
 
-		// ... Add mappings for all other effects here ...
 		_ => return Err(format!("No ActionEffect mapping found for method: {}", Method)),
 	};