Improved logging (#678)

runtime/src/dotnet.rs

@@ -33,6 +33,59 @@ static DOTNET_INITIALIZED: Lazy<Mutex<bool>> = Lazy::new(|| Mutex::new(false));
 pub const PID_FILE_NAME: &str = "mindwork_ai_studio.pid";
 const SIDECAR_TYPE:SidecarType = SidecarType::Dotnet;
 
+/// Removes ANSI escape sequences and non-printable control chars from stdout lines.
+fn sanitize_stdout_line(line: &str) -> String {
+    let mut sanitized = String::with_capacity(line.len());
+    let mut chars = line.chars().peekable();
+
+    while let Some(ch) = chars.next() {
+        if ch == '\u{1B}' {
+            if let Some(next) = chars.peek().copied() {
+                // CSI sequence: ESC [ ... <final>
+                if next == '[' {
+                    chars.next();
+                    for csi_char in chars.by_ref() {
+                        let code = csi_char as u32;
+                        if (0x40..=0x7E).contains(&code) {
+                            break;
+                        }
+                    }
+                    continue;
+                }
+
+                // OSC sequence: ESC ] ... (BEL or ESC \)
+                if next == ']' {
+                    chars.next();
+                    let mut previous_was_escape = false;
+                    for osc_char in chars.by_ref() {
+                        if osc_char == '\u{07}' {
+                            break;
+                        }
+
+                        if previous_was_escape && osc_char == '\\' {
+                            break;
+                        }
+
+                        previous_was_escape = osc_char == '\u{1B}';
+                    }
+                    continue;
+                }
+            }
+
+            // Unknown escape sequence: ignore the escape char itself.
+            continue;
+        }
+
+        if ch.is_control() && ch != '\t' {
+            continue;
+        }
+
+        sanitized.push(ch);
+    }
+
+    sanitized
+}
+
 /// Returns the desired port of the .NET server. Our .NET app calls this endpoint to get
 /// the port where the .NET server should listen to.
 #[get("/system/dotnet/port")]
@@ -111,11 +164,12 @@ pub fn start_dotnet_server() {
         // NOTE: Log events are sent via structured HTTP API calls.
         // This loop serves for fundamental output (e.g., startup errors).
         while let Some(CommandEvent::Stdout(line)) = rx.recv().await {
-            let line = line.trim_end();
-            info!(Source = ".NET Server (stdout)"; "{line}");
+            let line = sanitize_stdout_line(line.trim_end());
+            if !line.trim().is_empty() {
+                info!(Source = ".NET Server (stdout)"; "{line}");
+            }
         }
     });
-
 }
 
 /// This endpoint is called by the .NET server to signal that the server is ready.

runtime/src/environment.rs

@@ -15,6 +15,9 @@ pub static DATA_DIRECTORY: OnceLock<String> = OnceLock::new();
 /// The config directory where the application stores its configuration.
 pub static CONFIG_DIRECTORY: OnceLock<String> = OnceLock::new();
 
+/// The user language cached once per runtime process.
+static USER_LANGUAGE: OnceLock<String> = OnceLock::new();
+
 /// Returns the config directory.
 #[get("/system/directories/config")]
 pub fn get_config_directory(_token: APIToken) -> String {
@@ -87,12 +90,11 @@ fn normalize_locale_tag(locale: &str) -> Option<String> {
 }
 
 #[cfg(target_os = "linux")]
-fn read_locale_from_environment() -> Option<String> {
+fn read_locale_from_environment() -> Option<(String, &'static str)> {
     if let Ok(language) = env::var("LANGUAGE") {
         for candidate in language.split(':') {
             if let Some(locale) = normalize_locale_tag(candidate) {
-                info!("Detected user language from Linux environment variable 'LANGUAGE': '{}'.", locale);
-                return Some(locale);
+                return Some((locale, "LANGUAGE"));
             }
         }
     }
@@ -100,8 +102,7 @@ fn read_locale_from_environment() -> Option<String> {
     for key in ["LC_ALL", "LC_MESSAGES", "LANG"] {
         if let Ok(value) = env::var(key) {
             if let Some(locale) = normalize_locale_tag(&value) {
-                info!("Detected user language from Linux environment variable '{}': '{}'.", key, locale);
-                return Some(locale);
+                return Some((locale, key));
             }
         }
     }
@@ -110,10 +111,35 @@ fn read_locale_from_environment() -> Option<String> {
 }
 
 #[cfg(not(target_os = "linux"))]
-fn read_locale_from_environment() -> Option<String> {
+fn read_locale_from_environment() -> Option<(String, &'static str)> {
     None
 }
 
+enum LanguageDetectionSource {
+    SysLocale,
+    LinuxEnvironmentVariable(&'static str),
+    DefaultLanguage,
+}
+
+fn detect_user_language() -> (String, LanguageDetectionSource) {
+    if let Some(locale) = get_locale() {
+        if let Some(normalized_locale) = normalize_locale_tag(&locale) {
+            return (normalized_locale, LanguageDetectionSource::SysLocale);
+        }
+
+        warn!("sys-locale returned an unusable locale value: '{}'.", locale);
+    }
+
+    if let Some((locale, key)) = read_locale_from_environment() {
+        return (locale, LanguageDetectionSource::LinuxEnvironmentVariable(key));
+    }
+
+    (
+        String::from(DEFAULT_LANGUAGE),
+        LanguageDetectionSource::DefaultLanguage,
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use super::normalize_locale_tag;
@@ -137,21 +163,32 @@ mod tests {
 
 #[get("/system/language")]
 pub fn read_user_language(_token: APIToken) -> String {
-    if let Some(locale) = get_locale() {
-        if let Some(normalized_locale) = normalize_locale_tag(&locale) {
-            info!("Detected user language from sys-locale: '{}'.", normalized_locale);
-            return normalized_locale;
-        }
+    USER_LANGUAGE
+        .get_or_init(|| {
+            let (user_language, source) = detect_user_language();
+            match source {
+                LanguageDetectionSource::SysLocale => {
+                    info!("Detected user language from sys-locale: '{}'.", user_language);
+                },
 
-        warn!("sys-locale returned an unusable locale value: '{}'.", locale);
-    }
+                LanguageDetectionSource::LinuxEnvironmentVariable(key) => {
+                    info!(
+                        "Detected user language from Linux environment variable '{}': '{}'.",
+                        key, user_language
+                    );
+                },
 
-    if let Some(locale) = read_locale_from_environment() {
-        return locale;
-    }
+                LanguageDetectionSource::DefaultLanguage => {
+                    warn!(
+                        "Could not determine the system language. Use default '{}'.",
+                        DEFAULT_LANGUAGE
+                    );
+                },
+            }
 
-    warn!("Could not determine the system language. Use default '{}'.", DEFAULT_LANGUAGE);
-    String::from(DEFAULT_LANGUAGE)
+            user_language
+        })
+        .clone()
 }
 
 #[get("/system/enterprise/config/id")]