feat: actualizar la validación de nombres de perfil y mejorar la documentación sobre restricciones de nombres en Windows

gvastethecreator · gvastethecreator · commit b4b413d4ad32 · 2026-04-13T03:23:38.000-03:00
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -24,8 +24,21 @@ jobs:
       - name: Cache cargo
         uses: Swatinem/rust-cache@v2
 
+      - name: Verify tag matches Cargo.toml version
+        shell: pwsh
+        run: |
+          $tagVersion = "${{ github.ref_name }}" -replace '^v', ''
+          $cargoToml = Get-Content Cargo.toml -Raw
+          if ($cargoToml -notmatch '(?m)^version\s*=\s*"([^"]+)"') {
+            throw "Could not parse package version from Cargo.toml"
+          }
+          $cargoVersion = $Matches[1]
+          if ($cargoVersion -ne $tagVersion) {
+            throw "Tag version '$tagVersion' does not match Cargo.toml version '$cargoVersion'"
+          }
+
       - name: Build release
-        run: cargo build --release
+        run: cargo build --release --locked
 
       - name: Package portable zip
         shell: pwsh
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,7 +2,21 @@
 
 ## Unreleased
 
-### Added
+## [0.1.2] - 2026-04-13
+
+### Fixed
+
+- invalid profile names entered via CLI or the settings window are now rejected instead of being silently rewritten or falling back to the current profile when launching an extra instance;
+- forced process termination now waits briefly for the target to exit so stale windows disappear more reliably after a kill action.
+
+### Changed
+
+- the GitHub release workflow now verifies that the pushed tag matches `Cargo.toml` and builds the release artifacts with `--locked`;
+- user-facing docs now document the Windows-safe profile naming rules used by Panopticon.
+
+## Earlier project notes
+
+### Earlier additions
 
 - persistent per-monitor filters;
 - tag and application filters from the tray;
@@ -13,7 +27,7 @@
 - documentation and `cargo audit` jobs in GitHub Actions;
 - i18n system with English (default) and Spanish support.
 
-### Changed
+### Earlier changes
 
 - README updated with real repository links;
 - architecture documented with filters and grouping flow;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "panopticon"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 description = "Real-time window thumbnail viewer for Windows using the DWM API"
 readme = "README.md"
diff --git a/README.md b/README.md
@@ -60,6 +60,8 @@ To run a named profile:
 cargo run --release -- --profile work
 ```
 
+Profile names are used as TOML filenames on Windows, so avoid reserved characters such as `<>:"/\\|?*` and control characters.
+
 Panopticon also understands:
 
 - `cargo run --release -- --profile=work`
diff --git a/docs/CONFIGURATION.md b/docs/CONFIGURATION.md
@@ -241,6 +241,7 @@ Panopticon supports separate per-file profiles.
 - the app can start with `--profile <name>`;
 - the CLI also accepts `--profile=<name>` for the same behaviour;
 - `--help` prints the available startup flags and `--version` prints the current app version;
+- interactive profile names must be valid Windows filename stems, so avoid `<>:"/\\|?*` and control characters;
 - the settings window allows saving the current state to another profile;
 - it also allows opening another instance with a different profile;
 - if no extra profiles exist, the runtime seeds `profile-1` and `profile-2`.
diff --git a/docs/GETTING_STARTED.md b/docs/GETTING_STARTED.md
@@ -33,6 +33,8 @@ cargo run --release -- --profile work
 
 This loads the configuration from `%APPDATA%\Panopticon\profiles\work.toml`.
 
+Profile names become Windows filenames, so keep them free of reserved characters such as `<>:"/\\|?*` and control characters.
+
 You can also use `--profile=work`, inspect the CLI with `--help`, or print the current app version with `--version`.
 
 ## What happens at startup
diff --git a/docs/PRD.md b/docs/PRD.md
@@ -2,7 +2,7 @@
 
 ## Project: Panopticon
 
-**Documented product version:** 0.1.1  
+**Documented product version:** 0.1.2  
 **Document status:** updated to reflect the current implementation  
 **Target platform:** Windows 10 / Windows 11 (64-bit)  
 **Actual stack:** Rust + Slint + Win32/DWM  
diff --git a/src/app/secondary_windows.rs b/src/app/secondary_windows.rs
@@ -5,7 +5,7 @@ use std::path::Path;
 use std::process::Command;
 use std::rc::Rc;
 
-use panopticon::settings::{AppSelectionEntry, AppSettings, HiddenAppEntry};
+use panopticon::settings::{AppSelectionEntry, AppSettings, HiddenAppEntry, ProfileNameValidation};
 use panopticon::theme as theme_catalog;
 use panopticon::ui_option_ops::{
     app_option_label, current_profile_label, hidden_app_option_label, parse_option_value,
@@ -95,12 +95,18 @@ pub(crate) fn open_settings_window(
                 let Some(settings_window) = guard.as_ref() else {
                     return;
                 };
-                let requested = panopticon::settings::normalize_profile_name(
+                let profile_name = match panopticon::settings::validate_profile_name_input(
                     &settings_window.get_profile_name(),
-                );
-                let Some(profile_name) = requested else {
-                    tracing::warn!("ignoring empty/invalid profile save request");
-                    return;
+                ) {
+                    ProfileNameValidation::Valid(profile_name) => profile_name,
+                    ProfileNameValidation::Empty => {
+                        tracing::warn!("ignoring empty profile save request");
+                        return;
+                    }
+                    ProfileNameValidation::Invalid(reason) => {
+                        tracing::warn!(%reason, "ignoring invalid profile save request");
+                        return;
+                    }
                 };
 
                 let settings_snapshot = state.borrow().settings.normalized();
@@ -122,10 +128,16 @@ pub(crate) fn open_settings_window(
                 };
 
                 let current_profile = state.borrow().profile_name.clone();
-                let requested = panopticon::settings::normalize_profile_name(
+                let requested = match panopticon::settings::validate_profile_name_input(
                     &settings_window.get_profile_name(),
-                )
-                .or(current_profile);
+                ) {
+                    ProfileNameValidation::Valid(profile_name) => Some(profile_name),
+                    ProfileNameValidation::Empty => current_profile,
+                    ProfileNameValidation::Invalid(reason) => {
+                        tracing::warn!(%reason, "ignoring invalid extra-instance profile request");
+                        return;
+                    }
+                };
 
                 let settings_snapshot = state.borrow().settings.normalized();
                 if let Some(profile_name) = requested.as_deref() {
diff --git a/src/app/thumbnail_interactions.rs b/src/app/thumbnail_interactions.rs
@@ -307,7 +307,11 @@ fn close_target_window(hwnd: HWND) {
 }
 
 fn kill_target_process(hwnd: HWND) {
-    use windows::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
+    use windows::Win32::Foundation::{CloseHandle, WAIT_OBJECT_0, WAIT_TIMEOUT};
+    use windows::Win32::System::Threading::{
+        OpenProcess, TerminateProcess, WaitForSingleObject, PROCESS_QUERY_LIMITED_INFORMATION,
+        PROCESS_TERMINATE,
+    };
 
     if hwnd.0.is_null() {
         return;
@@ -320,11 +324,32 @@ fn kill_target_process(hwnd: HWND) {
         return;
     }
     unsafe {
-        if let Ok(process) = OpenProcess(PROCESS_TERMINATE, false, pid) {
-            if let Err(error) = TerminateProcess(process, 1) {
-                tracing::warn!(%error, pid, "TerminateProcess failed");
+        match OpenProcess(
+            PROCESS_TERMINATE | PROCESS_QUERY_LIMITED_INFORMATION,
+            false,
+            pid,
+        ) {
+            Ok(process) => {
+                if let Err(error) = TerminateProcess(process, 1) {
+                    tracing::warn!(%error, pid, "TerminateProcess failed");
+                } else {
+                    match WaitForSingleObject(process, 1_000) {
+                        WAIT_OBJECT_0 => {
+                            tracing::info!(pid, "terminated process after thumbnail kill request");
+                        }
+                        WAIT_TIMEOUT => {
+                            tracing::warn!(pid, "timed out waiting for terminated process");
+                        }
+                        status => tracing::warn!(
+                            pid,
+                            wait_status = status.0,
+                            "unexpected wait status after process termination"
+                        ),
+                    }
+                }
+                let _ = CloseHandle(process);
             }
-            let _ = windows::Win32::Foundation::CloseHandle(process);
+            Err(error) => tracing::warn!(%error, pid, "OpenProcess failed for termination"),
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
@@ -588,9 +588,13 @@ fn parse_startup_args_from(
 }
 
 fn parse_profile_name(raw_profile: &str) -> Result<String, String> {
-    panopticon::settings::normalize_profile_name(raw_profile).ok_or_else(|| {
-        format!("Profile name is empty or invalid after Windows-safe normalization: {raw_profile}")
-    })
+    match panopticon::settings::validate_profile_name_input(raw_profile) {
+        panopticon::settings::ProfileNameValidation::Valid(profile_name) => Ok(profile_name),
+        panopticon::settings::ProfileNameValidation::Empty => {
+            Err("Profile name cannot be empty".to_owned())
+        }
+        panopticon::settings::ProfileNameValidation::Invalid(reason) => Err(reason),
+    }
 }
 
 fn cli_usage() -> String {
diff --git a/src/settings.rs b/src/settings.rs
@@ -35,11 +35,23 @@ const DEFAULT_SHORTCUT_OPEN_SETTINGS: &str = "O";
 const DEFAULT_SHORTCUT_OPEN_MENU: &str = "M";
 const DEFAULT_SHORTCUT_REFRESH: &str = "R";
 const DEFAULT_SHORTCUT_EXIT: &str = "Esc";
+const INVALID_PROFILE_NAME_CHARACTERS: [char; 9] = [':', '"', '<', '>', '|', '?', '*', '/', '\\'];
 
 const fn default_true() -> bool {
     true
 }
 
+/// Validation result for an interactively supplied profile name.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ProfileNameValidation {
+    /// Input was blank after trimming surrounding whitespace.
+    Empty,
+    /// Input is valid and can be stored as a profile filename.
+    Valid(String),
+    /// Input contains characters that Windows filenames cannot represent.
+    Invalid(String),
+}
+
 /// Visual styling persisted for a manual tag/group.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(default)]
@@ -1058,15 +1070,59 @@ fn normalize_filter_value(value: &str) -> Option<String> {
     (!trimmed.is_empty()).then(|| trimmed.to_owned())
 }
 
+fn is_invalid_profile_name_character(character: char) -> bool {
+    character.is_control() || INVALID_PROFILE_NAME_CHARACTERS.contains(&character)
+}
+
+fn invalid_profile_name_characters(value: &str) -> Vec<char> {
+    let mut invalid = Vec::new();
+    for character in value.chars() {
+        if is_invalid_profile_name_character(character) && !invalid.contains(&character) {
+            invalid.push(character);
+        }
+    }
+    invalid
+}
+
+fn format_profile_name_character(character: char) -> String {
+    if character.is_control() {
+        format!("U+{:04X}", u32::from(character))
+    } else {
+        character.to_string()
+    }
+}
+
+/// Validate a user-supplied profile name before it is used as a settings file stem.
+#[must_use]
+pub fn validate_profile_name_input(value: &str) -> ProfileNameValidation {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return ProfileNameValidation::Empty;
+    }
+
+    let invalid = invalid_profile_name_characters(trimmed);
+    if !invalid.is_empty() {
+        let invalid_chars = invalid
+            .into_iter()
+            .map(format_profile_name_character)
+            .collect::<Vec<_>>()
+            .join(", ");
+        return ProfileNameValidation::Invalid(format!(
+            "Profile name contains invalid Windows filename characters: {invalid_chars}"
+        ));
+    }
+
+    match normalize_profile_name(trimmed) {
+        Some(profile_name) => ProfileNameValidation::Valid(profile_name),
+        None => ProfileNameValidation::Empty,
+    }
+}
+
 #[must_use]
 pub fn normalize_profile_name(value: &str) -> Option<String> {
     let sanitized = value
         .chars()
-        .filter_map(|character| match character {
-            ':' | '"' | '<' | '>' | '|' | '?' | '*' | '/' | '\\' => None,
-            character if character.is_control() => None,
-            character => Some(character),
-        })
+        .filter(|character| !is_invalid_profile_name_character(*character))
         .collect::<String>();
 
     normalize_filter_value(&sanitized)
@@ -1142,8 +1198,9 @@ fn derive_tag_from_label(label: &str) -> Option<String> {
 #[allow(clippy::expect_used)]
 mod tests {
     use super::{
-        normalize_shortcut_binding, AppRule, AppSettings, BackgroundImageFit, HiddenAppEntry,
-        ShortcutBindings, TagStyle, ThumbnailRefreshMode,
+        normalize_shortcut_binding, validate_profile_name_input, AppRule, AppSettings,
+        BackgroundImageFit, HiddenAppEntry, ProfileNameValidation, ShortcutBindings, TagStyle,
+        ThumbnailRefreshMode,
     };
     use crate::layout::LayoutType;
 
@@ -1518,4 +1575,24 @@ mod tests {
         assert_eq!(normalize_shortcut_binding("", "X"), "X");
         assert_eq!(normalize_shortcut_binding("ctrl+t", "X"), "X");
     }
+
+    #[test]
+    fn profile_name_validation_distinguishes_blank_valid_and_invalid_input() {
+        assert_eq!(
+            validate_profile_name_input("  work  "),
+            ProfileNameValidation::Valid("work".to_owned())
+        );
+        assert_eq!(
+            validate_profile_name_input("   "),
+            ProfileNameValidation::Empty
+        );
+        assert!(matches!(
+            validate_profile_name_input("ops?board"),
+            ProfileNameValidation::Invalid(ref reason) if reason.contains('?')
+        ));
+        assert!(matches!(
+            validate_profile_name_input("ops\u{0007}board"),
+            ProfileNameValidation::Invalid(ref reason) if reason.contains("U+0007")
+        ));
+    }
 }
