Add license section to README, new SVG icons, and improve profile handling

- Added a License section to the README file specifying MIT License.
- Introduced new SVG icons for external links and chevron in the config directory.
- Enhanced profile loading and saving logic in the configuration module to handle errors more gracefully.
- Implemented a function to save the current profile only if it is missing.
- Updated various references from "key" to "button" in the UI and error messages for consistency.
- Improved the handling of blank profiles and added tests for profile loading and saving.
- Refactored configuration parsing to validate keys and handle empty lists appropriately.
- Enhanced the UI to include an About dialog with links to the project's website and issue tracker.

Author: EriksRemess

Cargo.lock

@@ -1,7 +1,8 @@
 [package]
 name = "streamrs"
-version = "0.5.2"
+version = "0.5.3"
 edition = "2024"
+license = "MIT"
 
 [dependencies]
 adw = { package = "libadwaita", version = "0.9.1" }

Cargo.toml

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eriks Remess
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE

@@ -154,3 +154,7 @@ Developer-focused setup, source builds, packaging, maintainer notes, and contrib
 ## Credits
 
 - Icon pack source: https://marketplace.elgato.com/product/hexaza-3d4ed1dc-bf33-4f30-9ecd-201769f10c0d
+
+## License
+
+MIT. See [LICENSE](LICENSE).

Readme.md

@@ -33,10 +33,14 @@ fn first_readable_dir(candidates: &[PathBuf]) -> Option<PathBuf> {
 }
 
 fn resolve_default_profile_name() -> String {
-    load_current_profile()
-        .ok()
-        .flatten()
-        .unwrap_or_else(|| DEFAULT_PROFILE.to_string())
+    match load_current_profile() {
+        Ok(Some(profile)) => profile,
+        Ok(None) => DEFAULT_PROFILE.to_string(),
+        Err(err) => {
+            eprintln!("{err}");
+            DEFAULT_PROFILE.to_string()
+        }
+    }
 }
 
 fn default_config_path(profile: &str) -> PathBuf {

config/about-chevron-right.svg

@@ -1,5 +1,7 @@
 use crate::paths::{current_profile_path, default_config_path_for_profile};
 use std::fs;
+use std::io::Write;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 pub const DEFAULT_PROFILE: &str = "default";
 pub const BLANK_PROFILE: &str = "blank";
@@ -8,6 +10,41 @@ fn is_discoverable_profile_name(profile: &str) -> bool {
     profile != BLANK_PROFILE && normalize_profile_name(profile).is_some()
 }
 
+fn normalize_current_profile_candidate(raw: &str) -> Option<String> {
+    let mut candidate = raw.trim();
+    if let Some((key, value)) = candidate.split_once('=')
+        && key.trim().eq_ignore_ascii_case("profile")
+    {
+        candidate = value.trim();
+    }
+    candidate = candidate.trim_matches(|ch| ch == '"' || ch == '\'');
+    normalize_profile_name(candidate)
+}
+
+fn parse_current_profile_contents(raw: &str) -> Result<Option<String>, String> {
+    let mut first_invalid = None::<String>;
+    for line in raw.lines() {
+        let mut candidate = line.trim();
+        if candidate.is_empty() || candidate.starts_with('#') {
+            continue;
+        }
+        candidate = candidate.trim_start_matches('\u{feff}').trim_start();
+        if candidate.is_empty() || candidate.starts_with('#') {
+            continue;
+        }
+        if let Some(profile) = normalize_current_profile_candidate(candidate) {
+            return Ok(Some(profile));
+        }
+        if first_invalid.is_none() {
+            first_invalid = Some(candidate.to_string());
+        }
+    }
+    if let Some(invalid) = first_invalid {
+        return Err(invalid);
+    }
+    Ok(None)
+}
+
 pub fn normalize_profile_name(raw: &str) -> Option<String> {
     let profile = raw.trim();
     if profile.is_empty() {
@@ -102,17 +139,14 @@ pub fn load_current_profile() -> Result<Option<String>, String> {
     if !path.is_file() {
         return Ok(None);
     }
-    let raw = fs::read_to_string(&path)
+    let bytes = fs::read(&path)
         .map_err(|err| format!("Failed to read current profile '{}': {err}", path.display()))?;
-    let trimmed = raw.trim();
-    if trimmed.is_empty() {
-        return Ok(None);
-    }
-    normalize_profile_name(trimmed).map(Some).ok_or_else(|| {
+    let raw = String::from_utf8_lossy(&bytes);
+    parse_current_profile_contents(&raw).map_err(|invalid| {
         format!(
             "Current profile file '{}' contains invalid profile '{}'",
             path.display(),
-            trimmed
+            invalid
         )
     })
 }
@@ -129,14 +163,56 @@ pub fn save_current_profile(profile: &str) -> Result<(), String> {
             )
         })?;
     }
-    fs::write(&path, format!("{profile}\n")).map_err(|err| {
+    let file_name = path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or("current_profile");
+    let unique = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let tmp_path = path.with_file_name(format!(".{file_name}.tmp-{}-{unique}", std::process::id()));
+    let data = format!("{profile}\n");
+
+    let mut file = fs::File::create(&tmp_path).map_err(|err| {
+        format!(
+            "Failed to create temporary current profile '{}': {err}",
+            tmp_path.display()
+        )
+    })?;
+    file.write_all(data.as_bytes()).map_err(|err| {
+        format!(
+            "Failed to write temporary current profile '{}': {err}",
+            tmp_path.display()
+        )
+    })?;
+    file.sync_all().map_err(|err| {
+        format!(
+            "Failed to sync temporary current profile '{}': {err}",
+            tmp_path.display()
+        )
+    })?;
+
+    fs::rename(&tmp_path, &path).map_err(|err| {
+        let _ = fs::remove_file(&tmp_path);
         format!(
             "Failed to write current profile '{}': {err}",
             path.display()
         )
     })
 }
 
+pub fn save_current_profile_if_missing(profile: &str) -> Result<bool, String> {
+    match load_current_profile() {
+        Ok(Some(_)) => Ok(false),
+        Ok(None) => {
+            save_current_profile(profile)?;
+            Ok(true)
+        }
+        Err(err) => Err(err),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -233,6 +309,36 @@ mod tests {
         });
     }
 
+    #[test]
+    fn load_current_profile_accepts_profile_assignment_line() {
+        with_temp_xdg_config_home("profile-assignment", || {
+            let path = current_profile_path();
+            if let Some(parent) = path.parent() {
+                fs::create_dir_all(parent).expect("current profile dir should be created");
+            }
+            fs::write(&path, "profile = \"test_profile\"\n")
+                .expect("assignment fixture should be written");
+
+            let loaded = load_current_profile().expect("profile assignment should load");
+            assert_eq!(loaded.as_deref(), Some("test_profile"));
+        });
+    }
+
+    #[test]
+    fn load_current_profile_ignores_comments_and_blank_lines() {
+        with_temp_xdg_config_home("comments-and-blanks", || {
+            let path = current_profile_path();
+            if let Some(parent) = path.parent() {
+                fs::create_dir_all(parent).expect("current profile dir should be created");
+            }
+            fs::write(&path, "\n# selected profile\n\nwork_setup\n")
+                .expect("comment fixture should be written");
+
+            let loaded = load_current_profile().expect("commented profile should load");
+            assert_eq!(loaded.as_deref(), Some("work_setup"));
+        });
+    }
+
     #[test]
     fn profile_slug_from_input_accepts_spaces() {
         assert_eq!(
@@ -251,4 +357,23 @@ mod tests {
         assert_eq!(profile_display_name("work_setup"), "Work Setup");
         assert_eq!(profile_display_name("work"), "Work");
     }
+
+    #[test]
+    fn save_current_profile_if_missing_writes_once() {
+        with_temp_xdg_config_home("save-if-missing", || {
+            let wrote = save_current_profile_if_missing("test_profile")
+                .expect("missing current profile should be created");
+            assert!(wrote, "first write should persist profile");
+
+            let wrote_again = save_current_profile_if_missing("default")
+                .expect("existing current profile should not be overwritten");
+            assert!(
+                !wrote_again,
+                "existing current profile should remain unchanged"
+            );
+
+            let loaded = load_current_profile().expect("current profile should load");
+            assert_eq!(loaded.as_deref(), Some("test_profile"));
+        });
+    }
 }

config/about-external-link.svg

@@ -9,9 +9,7 @@ pub(crate) fn read_config_file(path: &Path) -> Result<String, String> {
     streamrs::config::toml::read_to_string(path)
 }
 
-pub(crate) fn parse_config(path: &Path, raw: &str) -> Result<Config, String> {
-    let config: Config = streamrs::config::toml::parse_from_str(path, raw)?;
-
+fn validate_config(path: &Path, config: &Config) -> Result<(), String> {
     if config.keys.is_empty() {
         return Err(format!("Config '{}' has no keys", path.display()));
     }
@@ -24,7 +22,19 @@ pub(crate) fn parse_config(path: &Path, raw: &str) -> Result<Config, String> {
             KEY_COUNT
         ));
     }
+    Ok(())
+}
 
+pub(crate) fn load_config(path: &Path, profile: &str) -> Result<Config, String> {
+    let config = streamrs::config::streamrs_profile::load_config_for_profile(path, profile)?;
+    validate_config(path, &config)?;
+    Ok(config)
+}
+
+#[cfg(test)]
+pub(crate) fn parse_config(path: &Path, raw: &str) -> Result<Config, String> {
+    let config: Config = streamrs::config::toml::parse_from_str(path, raw)?;
+    validate_config(path, &config)?;
     Ok(config)
 }
 

src/cli/preview.rs

@@ -1,7 +1,18 @@
-use crate::config::streamrs_schema::StreamrsConfig;
+use crate::config::current_profile::BLANK_PROFILE;
+use crate::config::streamrs_schema::{StreamrsConfig, blank_profile_config};
 use crate::paths::{config_load_candidates, profile_from_config_path};
 use std::path::Path;
 
+pub fn load_config_for_profile(path: &Path, profile: &str) -> Result<StreamrsConfig, String> {
+    if profile == BLANK_PROFILE || profile_from_config_path(path) == BLANK_PROFILE {
+        return Ok(blank_profile_config());
+    }
+    if !path.is_file() {
+        return Ok(StreamrsConfig::default());
+    }
+    crate::config::toml::load_from_file(path)
+}
+
 pub fn load_with_fallbacks(path: &Path) -> Result<Option<StreamrsConfig>, String> {
     let profile = profile_from_config_path(path);
     for candidate in config_load_candidates(&profile, path) {