fix help message error

src/modules/fancyzones/FancyZonesCLI/CommandLine/Commands/SetHotkeyCommand.cs

@@ -9,6 +9,7 @@ using System.CommandLine.Invocation;
 using System.Globalization;
 using System.Linq;
 
+using FancyZonesCLI.Utils;
 using FancyZonesEditorCommon.Data;
 using FancyZonesEditorCommon.Utils;
 
@@ -35,13 +36,19 @@ internal sealed partial class SetHotkeyCommand : FancyZonesBaseCommand
     {
         // FancyZones running guard is handled by FancyZonesBaseCommand.
         int key = context.ParseResult.GetValueForArgument(_key);
-        string layout = context.ParseResult.GetValueForArgument(_layout);
+        string layoutInput = context.ParseResult.GetValueForArgument(_layout);
 
         if (key < 0 || key > 9)
         {
             throw new InvalidOperationException(Properties.Resources.set_hotkey_error_invalid_key);
         }
 
+        // Normalize GUID to Windows format with braces (supports input with or without braces)
+        if (!GuidHelper.TryNormalizeGuid(layoutInput, out string layout))
+        {
+            throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, Properties.Resources.set_hotkey_error_not_custom, layoutInput));
+        }
+
         // Editor only allows assigning hotkeys to existing custom layouts.
         var customLayouts = FancyZonesDataIO.ReadCustomLayouts();
 
@@ -60,7 +67,7 @@ internal sealed partial class SetHotkeyCommand : FancyZonesBaseCommand
 
         if (!matchedLayout.HasValue)
         {
-            throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, Properties.Resources.set_hotkey_error_not_custom, layout));
+            throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, Properties.Resources.set_hotkey_error_not_custom, layoutInput));
         }
 
         string layoutName = matchedLayout.Value.Name;

src/modules/fancyzones/FancyZonesCLI/CommandLine/Commands/SetLayoutCommand.cs

@@ -140,9 +140,12 @@ internal sealed partial class SetLayoutCommand : FancyZonesBaseCommand
             return null;
         }
 
+        // Normalize GUID to Windows format with braces (supports input with or without braces)
+        string normalizedLayout = GuidHelper.NormalizeGuid(layout) ?? layout;
+
         foreach (var customLayout in customLayouts.CustomLayouts)
         {
-            if (customLayout.Uuid.Equals(layout, StringComparison.OrdinalIgnoreCase))
+            if (customLayout.Uuid.Equals(normalizedLayout, StringComparison.OrdinalIgnoreCase))
             {
                 return customLayout;
             }

src/modules/fancyzones/FancyZonesCLI/CommandLine/FancyZonesCliUsage.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.CommandLine;
+using System.Globalization;
 using System.Linq;
 
 namespace FancyZonesCLI.CommandLine;
@@ -13,15 +14,15 @@ internal static class FancyZonesCliUsage
     public static void PrintUsage()
     {
         Console.OutputEncoding = System.Text.Encoding.UTF8;
-        Console.WriteLine("FancyZones CLI - Command line interface for FancyZones");
+        Console.WriteLine(Properties.Resources.usage_title);
         Console.WriteLine();
 
         var cmd = FancyZonesCliCommandFactory.CreateRootCommand();
 
-        Console.WriteLine("Usage: FancyZonesCLI [command] [options]");
+        Console.WriteLine(Properties.Resources.usage_syntax);
         Console.WriteLine();
 
-        Console.WriteLine("Options:");
+        Console.WriteLine(Properties.Resources.usage_options);
         foreach (var option in cmd.Options)
         {
             var aliases = string.Join(", ", option.Aliases);
@@ -30,7 +31,7 @@ internal static class FancyZonesCliUsage
         }
 
         Console.WriteLine();
-        Console.WriteLine("Commands:");
+        Console.WriteLine(Properties.Resources.usage_commands);
         foreach (var command in cmd.Subcommands)
         {
             if (command.IsHidden)
@@ -51,7 +52,7 @@ internal static class FancyZonesCliUsage
         }
 
         Console.WriteLine();
-        Console.WriteLine("Examples:");
+        Console.WriteLine(Properties.Resources.usage_examples);
         Console.WriteLine("  FancyZonesCLI --help");
         Console.WriteLine("  FancyZonesCLI --version");
         Console.WriteLine("  FancyZonesCLI get-monitors");
@@ -59,4 +60,135 @@ internal static class FancyZonesCliUsage
         Console.WriteLine("  FancyZonesCLI set-layout <uuid> --monitor 1");
         Console.WriteLine("  FancyZonesCLI get-hotkeys");
     }
+
+    public static void PrintCommandUsage(string commandName)
+    {
+        Console.OutputEncoding = System.Text.Encoding.UTF8;
+
+        var rootCmd = FancyZonesCliCommandFactory.CreateRootCommand();
+
+        // Find matching subcommand by name or alias
+        var subcommand = rootCmd.Subcommands.FirstOrDefault(c =>
+            c.Aliases.Any(a => string.Equals(a, commandName, StringComparison.OrdinalIgnoreCase)));
+
+        if (subcommand == null)
+        {
+            Console.WriteLine(string.Format(CultureInfo.InvariantCulture, Properties.Resources.usage_unknown_command, commandName));
+            Console.WriteLine();
+            Console.WriteLine(Properties.Resources.usage_run_help);
+            return;
+        }
+
+        // Command name and description
+        Console.WriteLine($"{Properties.Resources.usage_command} {subcommand.Name}");
+        if (!string.IsNullOrEmpty(subcommand.Description))
+        {
+            Console.WriteLine($"  {subcommand.Description}");
+        }
+
+        Console.WriteLine();
+
+        // Usage line
+        string argsLabel = string.Join(" ", subcommand.Arguments.Select(a => $"<{a.Name}>"));
+        string optionsLabel = subcommand.Options.Any() ? " [options]" : string.Empty;
+        Console.WriteLine($"Usage: FancyZonesCLI {subcommand.Name} {argsLabel}{optionsLabel}".TrimEnd());
+        Console.WriteLine();
+
+        // Aliases
+        var aliases = subcommand.Aliases.Where(a => !string.Equals(a, subcommand.Name, StringComparison.OrdinalIgnoreCase)).ToList();
+        if (aliases.Count > 0)
+        {
+            Console.WriteLine($"{Properties.Resources.usage_aliases} {string.Join(", ", aliases)}");
+            Console.WriteLine();
+        }
+
+        // Arguments
+        if (subcommand.Arguments.Any())
+        {
+            Console.WriteLine(Properties.Resources.usage_arguments);
+            foreach (var arg in subcommand.Arguments)
+            {
+                var argDescription = arg.Description ?? string.Empty;
+                Console.WriteLine($"  <{arg.Name}>{(arg.Arity.MinimumNumberOfValues == 0 ? $" {Properties.Resources.usage_optional}" : string.Empty),-20} {argDescription}");
+            }
+
+            Console.WriteLine();
+        }
+
+        // Options
+        if (subcommand.Options.Any())
+        {
+            Console.WriteLine(Properties.Resources.usage_options);
+            foreach (var option in subcommand.Options)
+            {
+                var optAliases = string.Join(", ", option.Aliases);
+                var optDescription = option.Description ?? string.Empty;
+                Console.WriteLine($"  {optAliases,-25} {optDescription}");
+            }
+
+            Console.WriteLine();
+        }
+
+        // Command-specific examples
+        PrintCommandExamples(subcommand.Name);
+    }
+
+    private static void PrintCommandExamples(string commandName)
+    {
+        Console.WriteLine(Properties.Resources.usage_examples);
+
+        switch (commandName.ToLowerInvariant())
+        {
+            case "get-monitors":
+                Console.WriteLine("  FancyZonesCLI get-monitors");
+                Console.WriteLine("  FancyZonesCLI m");
+                break;
+
+            case "get-layouts":
+                Console.WriteLine("  FancyZonesCLI get-layouts");
+                Console.WriteLine("  FancyZonesCLI ls");
+                break;
+
+            case "get-active-layout":
+                Console.WriteLine("  FancyZonesCLI get-active-layout");
+                Console.WriteLine("  FancyZonesCLI active");
+                break;
+
+            case "set-layout":
+                Console.WriteLine("  FancyZonesCLI set-layout focus");
+                Console.WriteLine("  FancyZonesCLI set-layout columns --monitor 1");
+                Console.WriteLine("  FancyZonesCLI set-layout {uuid} --all");
+                Console.WriteLine("  FancyZonesCLI s rows -m 2");
+                break;
+
+            case "open-editor":
+                Console.WriteLine("  FancyZonesCLI open-editor");
+                Console.WriteLine("  FancyZonesCLI e");
+                break;
+
+            case "open-settings":
+                Console.WriteLine("  FancyZonesCLI open-settings");
+                Console.WriteLine("  FancyZonesCLI settings");
+                break;
+
+            case "get-hotkeys":
+                Console.WriteLine("  FancyZonesCLI get-hotkeys");
+                Console.WriteLine("  FancyZonesCLI hk");
+                break;
+
+            case "set-hotkey":
+                Console.WriteLine("  FancyZonesCLI set-hotkey 1 {layout-uuid}");
+                Console.WriteLine("  FancyZonesCLI shk 2 0CEBCBA9-9C32-4395-B93E-DC77485AD6D0");
+                break;
+
+            case "remove-hotkey":
+                Console.WriteLine("  FancyZonesCLI remove-hotkey 1");
+                Console.WriteLine("  FancyZonesCLI rhk 2");
+                break;
+
+            default:
+                Console.WriteLine($"  FancyZonesCLI {commandName}");
+                break;
+        }
+    }
 }

src/modules/fancyzones/FancyZonesCLI/Program.cs

@@ -12,6 +12,8 @@ namespace FancyZonesCLI;
 
 internal sealed class Program
 {
+    private static readonly string[] HelpFlags = ["--help", "-h", "-?"];
+
     private static async Task<int> Main(string[] args)
     {
         Logger.InitializeLogger();
@@ -21,14 +23,17 @@ internal sealed class Program
         NativeMethods.InitializeWindowMessages();
 
         // Intercept help requests early and print custom usage.
-        if (args.Any(a => string.Equals(a, "--help", StringComparison.OrdinalIgnoreCase) ||
-                          string.Equals(a, "-h", StringComparison.OrdinalIgnoreCase) ||
-                          string.Equals(a, "-?", StringComparison.OrdinalIgnoreCase)))
+        if (TryHandleHelpRequest(args))
         {
-            FancyZonesCliUsage.PrintUsage();
             return 0;
         }
 
+        // Detect PowerShell script block expansion (when {} is interpreted as script block)
+        if (DetectPowerShellScriptBlockArgs(args))
+        {
+            return 1;
+        }
+
         RootCommand rootCommand = FancyZonesCliCommandFactory.CreateRootCommand();
         int exitCode = await rootCommand.InvokeAsync(args);
 
@@ -43,4 +48,69 @@ internal sealed class Program
 
         return exitCode;
     }
+
+    /// <summary>
+    /// Handles help requests for root command and subcommands.
+    /// </summary>
+    /// <returns>True if help was printed, false otherwise.</returns>
+    private static bool TryHandleHelpRequest(string[] args)
+    {
+        bool hasHelpFlag = args.Any(a => HelpFlags.Any(h => string.Equals(a, h, StringComparison.OrdinalIgnoreCase)));
+        if (!hasHelpFlag)
+        {
+            return false;
+        }
+
+        // Get non-help arguments to identify subcommand
+        var nonHelpArgs = args.Where(a => !HelpFlags.Any(h => string.Equals(a, h, StringComparison.OrdinalIgnoreCase))).ToArray();
+
+        if (nonHelpArgs.Length == 0)
+        {
+            // Root help: fancyzones cli --help
+            FancyZonesCliUsage.PrintUsage();
+        }
+        else
+        {
+            // Subcommand help: fancyzones cli <command> --help
+            string subcommandName = nonHelpArgs[0];
+            FancyZonesCliUsage.PrintCommandUsage(subcommandName);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Detects when PowerShell interprets {GUID} as a script block and converts it to encoded command args.
+    /// This happens when users forget to quote GUIDs with braces in PowerShell.
+    /// </summary>
+    /// <returns>True if PowerShell script block args were detected, false otherwise.</returns>
+    private static bool DetectPowerShellScriptBlockArgs(string[] args)
+    {
+        // PowerShell converts {scriptblock} to: -encodedCommand <base64> -inputFormat xml -outputFormat text
+        bool hasEncodedCommand = args.Any(a => string.Equals(a, "-encodedCommand", StringComparison.OrdinalIgnoreCase));
+        bool hasInputFormat = args.Any(a => string.Equals(a, "-inputFormat", StringComparison.OrdinalIgnoreCase));
+        bool hasOutputFormat = args.Any(a => string.Equals(a, "-outputFormat", StringComparison.OrdinalIgnoreCase));
+
+        if (hasEncodedCommand || (hasInputFormat && hasOutputFormat))
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine(Properties.Resources.error_powershell_scriptblock_title);
+            Console.ResetColor();
+            Console.WriteLine();
+            Console.WriteLine(Properties.Resources.error_powershell_scriptblock_explanation);
+            Console.WriteLine(Properties.Resources.error_powershell_scriptblock_hint);
+            Console.WriteLine();
+            Console.WriteLine($"  {Properties.Resources.error_powershell_scriptblock_option1}");
+            Console.WriteLine($"    {Properties.Resources.error_powershell_scriptblock_option1_example}");
+            Console.WriteLine();
+            Console.WriteLine($"  {Properties.Resources.error_powershell_scriptblock_option2}");
+            Console.WriteLine($"    {Properties.Resources.error_powershell_scriptblock_option2_example}");
+            Console.WriteLine();
+
+            Logger.LogWarning("PowerShell script block expansion detected - user needs to quote GUID or omit braces");
+            return true;
+        }
+
+        return false;
+    }
 }

src/modules/fancyzones/FancyZonesCLI/Properties/Resources.Designer.cs

@@ -349,5 +349,113 @@ namespace FancyZonesCLI.Properties {
                 return ResourceManager.GetString("editor_params_timeout", resourceCulture);
             }
         }
+        
+        internal static string error_powershell_scriptblock_title {
+            get {
+                return ResourceManager.GetString("error_powershell_scriptblock_title", resourceCulture);
+            }
+        }
+        
+        internal static string error_powershell_scriptblock_explanation {
+            get {
+                return ResourceManager.GetString("error_powershell_scriptblock_explanation", resourceCulture);
+            }
+        }
+        
+        internal static string error_powershell_scriptblock_hint {
+            get {
+                return ResourceManager.GetString("error_powershell_scriptblock_hint", resourceCulture);
+            }
+        }
+        
+        internal static string error_powershell_scriptblock_option1 {
+            get {
+                return ResourceManager.GetString("error_powershell_scriptblock_option1", resourceCulture);
+            }
+        }
+        
+        internal static string error_powershell_scriptblock_option1_example {
+            get {
+                return ResourceManager.GetString("error_powershell_scriptblock_option1_example", resourceCulture);
+            }
+        }
+        
+        internal static string error_powershell_scriptblock_option2 {
+            get {
+                return ResourceManager.GetString("error_powershell_scriptblock_option2", resourceCulture);
+            }
+        }
+        
+        internal static string error_powershell_scriptblock_option2_example {
+            get {
+                return ResourceManager.GetString("error_powershell_scriptblock_option2_example", resourceCulture);
+            }
+        }
+        
+        internal static string usage_title {
+            get {
+                return ResourceManager.GetString("usage_title", resourceCulture);
+            }
+        }
+        
+        internal static string usage_syntax {
+            get {
+                return ResourceManager.GetString("usage_syntax", resourceCulture);
+            }
+        }
+        
+        internal static string usage_options {
+            get {
+                return ResourceManager.GetString("usage_options", resourceCulture);
+            }
+        }
+        
+        internal static string usage_commands {
+            get {
+                return ResourceManager.GetString("usage_commands", resourceCulture);
+            }
+        }
+        
+        internal static string usage_examples {
+            get {
+                return ResourceManager.GetString("usage_examples", resourceCulture);
+            }
+        }
+        
+        internal static string usage_arguments {
+            get {
+                return ResourceManager.GetString("usage_arguments", resourceCulture);
+            }
+        }
+        
+        internal static string usage_aliases {
+            get {
+                return ResourceManager.GetString("usage_aliases", resourceCulture);
+            }
+        }
+        
+        internal static string usage_command {
+            get {
+                return ResourceManager.GetString("usage_command", resourceCulture);
+            }
+        }
+        
+        internal static string usage_optional {
+            get {
+                return ResourceManager.GetString("usage_optional", resourceCulture);
+            }
+        }
+        
+        internal static string usage_unknown_command {
+            get {
+                return ResourceManager.GetString("usage_unknown_command", resourceCulture);
+            }
+        }
+        
+        internal static string usage_run_help {
+            get {
+                return ResourceManager.GetString("usage_run_help", resourceCulture);
+            }
+        }
     }
 }

src/modules/fancyzones/FancyZonesCLI/Properties/Resources.resx

@@ -230,4 +230,62 @@ Tip: For templates, use the type name (e.g., 'focus', 'columns', 'rows', 'grid',
   <data name="editor_params_timeout" xml:space="preserve">
     <value>Could not get current monitor information (timed out after {0}ms waiting for '{1}').</value>
   </data>
+
+  <!-- PowerShell Script Block Detection -->
+  <data name="error_powershell_scriptblock_title" xml:space="preserve">
+    <value>Error: Invalid GUID format detected.</value>
+  </data>
+  <data name="error_powershell_scriptblock_explanation" xml:space="preserve">
+    <value>PowerShell interprets curly braces {} as script blocks.</value>
+  </data>
+  <data name="error_powershell_scriptblock_hint" xml:space="preserve">
+    <value>Please quote your GUID or use it without braces:</value>
+  </data>
+  <data name="error_powershell_scriptblock_option1" xml:space="preserve">
+    <value>Option 1 - Quote the GUID:</value>
+  </data>
+  <data name="error_powershell_scriptblock_option1_example" xml:space="preserve">
+    <value>FancyZonesCLI shk 1 '{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}'</value>
+  </data>
+  <data name="error_powershell_scriptblock_option2" xml:space="preserve">
+    <value>Option 2 - Omit the braces (recommended):</value>
+  </data>
+  <data name="error_powershell_scriptblock_option2_example" xml:space="preserve">
+    <value>FancyZonesCLI shk 1 xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx</value>
+  </data>
+
+  <!-- CLI Usage -->
+  <data name="usage_title" xml:space="preserve">
+    <value>FancyZones CLI - Command line interface for FancyZones</value>
+  </data>
+  <data name="usage_syntax" xml:space="preserve">
+    <value>Usage: FancyZonesCLI [command] [options]</value>
+  </data>
+  <data name="usage_options" xml:space="preserve">
+    <value>Options:</value>
+  </data>
+  <data name="usage_commands" xml:space="preserve">
+    <value>Commands:</value>
+  </data>
+  <data name="usage_examples" xml:space="preserve">
+    <value>Examples:</value>
+  </data>
+  <data name="usage_arguments" xml:space="preserve">
+    <value>Arguments:</value>
+  </data>
+  <data name="usage_aliases" xml:space="preserve">
+    <value>Aliases:</value>
+  </data>
+  <data name="usage_command" xml:space="preserve">
+    <value>Command:</value>
+  </data>
+  <data name="usage_optional" xml:space="preserve">
+    <value>(optional)</value>
+  </data>
+  <data name="usage_unknown_command" xml:space="preserve">
+    <value>Unknown command: {0}</value>
+  </data>
+  <data name="usage_run_help" xml:space="preserve">
+    <value>Run 'FancyZonesCLI --help' to see available commands.</value>
+  </data>
 </root>

src/modules/fancyzones/FancyZonesCLI/Utils/GuidHelper.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+#nullable enable
+
+namespace FancyZonesCLI.Utils;
+
+/// <summary>
+/// Helper class for normalizing GUID strings to Windows format with braces.
+/// Supports input with or without braces: both "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+/// and "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}" are accepted.
+/// </summary>
+internal static class GuidHelper
+{
+    /// <summary>
+    /// Normalizes a GUID string to Windows format with braces.
+    /// Returns null if the input is not a valid GUID.
+    /// </summary>
+    /// <param name="input">GUID string with or without braces.</param>
+    /// <returns>GUID in "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}" format, or null if invalid.</returns>
+    public static string? NormalizeGuid(string? input)
+    {
+        if (string.IsNullOrWhiteSpace(input))
+        {
+            return null;
+        }
+
+        if (Guid.TryParse(input, out Guid guid))
+        {
+            // "B" format includes braces: {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+            return guid.ToString("B").ToUpperInvariant();
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Tries to normalize a GUID string to Windows format with braces.
+    /// </summary>
+    /// <param name="input">GUID string with or without braces.</param>
+    /// <param name="normalizedGuid">The normalized GUID string, or the original input if normalization fails.</param>
+    /// <returns>True if the input was successfully normalized; otherwise, false.</returns>
+    public static bool TryNormalizeGuid(string? input, [NotNullWhen(true)] out string? normalizedGuid)
+    {
+        normalizedGuid = NormalizeGuid(input);
+        return normalizedGuid != null;
+    }
+}