Add new arguments for add command

Author: Aeliux

src/EasySign.CommandLine/BundleWorker.cs

@@ -60,13 +60,19 @@ protected bool LoadBundle(bool readOnly = true)
         /// <param name="statusContext">
         /// The status context for interacting with <see cref="AnsiConsole.Status"/>.
         /// </param>
+        /// <param name="files">
+        /// The files to add to the bundle.
+        /// </param>
         /// <param name="replace">
         /// A value indicating whether to replace existing entries.
         /// </param>
+        /// <param name="recursive">
+        /// A value indicating whether to add files recursively.
+        /// </param>
         /// <param name="continueOnError">
         /// A value indicating whether to continue adding files if an error occurs.
         /// </param>
-        protected virtual void RunAdd(StatusContext statusContext, bool replace, bool continueOnError)
+        protected virtual void RunAdd(StatusContext statusContext, string[] files, bool replace, bool recursive, bool continueOnError)
         {
             Logger.LogInformation("Running add command");
 
@@ -85,13 +91,16 @@ protected virtual void RunAdd(StatusContext statusContext, bool replace, bool co
 
             statusContext.Status("[yellow]Adding Files[/]");
 
-            Logger.LogDebug("Discovering files in the directory: {RootPath}", Bundle.RootPath);
-            string[] foundFiles = Utilities.SafeEnumerateFiles(Bundle.RootPath, "*").ToArray();
-            Logger.LogInformation("Discovered {FileCount} files", foundFiles.Count());
+            if (files.Length == 0)
+            {
+                Logger.LogDebug("Discovering files in the directory: {RootPath}", Bundle.RootPath);
+                files = Utilities.SafeEnumerateFiles(Bundle.RootPath, "*", recursive).ToArray();
+                Logger.LogInformation("Discovered {FileCount} files", files.Length);
+            }
 
             Logger.LogInformation("Starting file adder multi-thread task");
             bool errorOccurred = false;
-            _ = Parallel.ForEach(foundFiles, (file, state) =>
+            _ = Parallel.ForEach(files, (file, state) =>
             {
                 if (file == Bundle.BundlePath) return;
                 string entryName = Manifest.GetNormalizedEntryName(Path.GetRelativePath(Bundle.RootPath, file));
@@ -100,12 +109,19 @@ protected virtual void RunAdd(StatusContext statusContext, bool replace, bool co
 
                 try
                 {
+                    if (!Utilities.IsFileWithinRoot(file, Bundle.RootPath))
+                    {
+                        Logger.LogWarning("File {file} is outside the bundle root path", file);
+                        AnsiConsole.MarkupLine($"[{Color.Yellow}]Ignored:[/] File {file} is outside the bundle root path");
+                        return;
+                    }
+
                     if (Bundle.Manifest.Entries.ContainsKey(entryName))
                     {
                         if (!replace)
                         {
                             Logger.LogWarning("Entry already exists: {EntryName}", entryName);
-                            AnsiConsole.MarkupLine($"[{Color.Orange1}]Exists:[/] {entryName}");
+                            AnsiConsole.MarkupLine($"[{Color.Yellow}]Exists:[/] {entryName}");
                             return;
                         }
 

src/EasySign.CommandLine/CommandProvider.cs

@@ -79,24 +79,46 @@ public Command Add
         {
             get
             {
+                Argument<string[]> filesArg = new Argument<string[]>("files", description: "Files to add to the bundle, Must be inside the bundle root path\n" +
+                    "if not specified, all files in the bundle root path will be added", parse: x =>
+                    {
+                        List<string> result = [];
+                        foreach (var file in x.Tokens.Select(t => t.Value))
+                        {
+                            if (string.IsNullOrEmpty(file)) continue;
+
+                            result.Add(Path.GetFullPath(file));
+                        }
+
+                        return result.ToArray();
+                    })
+                {
+                    Arity = ArgumentArity.ZeroOrMore,
+                };
+
                 Option<bool> replaceOpt = new Option<bool>("--replace", "Replace existing entries");
                 replaceOpt.AddAlias("-r");
 
+                Option<bool> recursiveOpt = new Option<bool>("--recursive", "Add all files within the bundle root path recursively");
+                recursiveOpt.AddAlias("-R");
+
                 Option<bool> continueOpt = new Option<bool>("--continue", "Continue adding files if an error occurs");
                 continueOpt.AddAlias("-c");
 
                 Command command = new Command("add", "Create new bundle or update an existing one")
                 {
                     BundlePath,
+                    filesArg,
                     replaceOpt,
+                    recursiveOpt,
                     continueOpt,
                 };
 
-                command.SetHandler((bundlePath, replace, continueOnError) =>
+                command.SetHandler((bundlePath, files, replace, recursive, continueOnError) =>
                 {
                     InitializeBundle(bundlePath);
-                    Utilities.RunInStatusContext("[yellow]Preparing[/]", ctx => RunAdd(ctx, replace, continueOnError));
-                }, BundlePath, replaceOpt, continueOpt);
+                    Utilities.RunInStatusContext("[yellow]Preparing[/]", ctx => RunAdd(ctx, files, replace, recursive, continueOnError));
+                }, BundlePath, filesArg, replaceOpt, recursiveOpt, continueOpt);
 
                 return command;
             }

src/EasySign.CommandLine/Utilities.cs

@@ -23,13 +23,42 @@ public static void RunInStatusContext(string initialStatus, Action<StatusContext
                 .Start(initialStatus, action);
         }
 
+        /// <summary>
+        /// Checks if a file is within a specified root path.
+        /// </summary>
+        /// <param name="filePath">
+        /// The file path to check.
+        /// </param>
+        /// <param name="rootPath">
+        /// The root path to check against.
+        /// </param>
+        /// <returns>
+        /// True if the file is within the root path; otherwise, false.
+        /// </returns>
+        public static bool IsFileWithinRoot(string filePath, string rootPath)
+        {
+            // Get the full absolute paths
+            string absoluteFilePath = Path.GetFullPath(filePath);
+            string absoluteRootPath = Path.GetFullPath(rootPath);
+
+            // Ensure the root path ends with a directory separator
+            if (!absoluteRootPath.EndsWith(Path.DirectorySeparatorChar.ToString()))
+            {
+                absoluteRootPath += Path.DirectorySeparatorChar;
+            }
+
+            // Check if the file path starts with the root path (using OrdinalIgnoreCase for case-insensitive comparison on Windows)
+            return absoluteFilePath.StartsWith(absoluteRootPath, StringComparison.OrdinalIgnoreCase);
+        }
+
         /// <summary>
         /// Safely enumerates files in the specified path that match the search pattern.
         /// </summary>
         /// <param name="path">The path to search for files.</param>
         /// <param name="searchPattern">The search pattern to match files.</param>
+        /// <param name="recursive">Whether to search recursively in subdirectories.</param>
         /// <returns>An enumerable collection of file paths.</returns>
-        public static IEnumerable<string> SafeEnumerateFiles(string path, string searchPattern)
+        public static IEnumerable<string> SafeEnumerateFiles(string path, string searchPattern, bool recursive = true)
         {
             ConcurrentQueue<string> folders = new();
             folders.Enqueue(path);
@@ -55,14 +84,17 @@ public static IEnumerable<string> SafeEnumerateFiles(string path, string searchP
 
                 try
                 {
-                    subDirs = Directory.GetDirectories(currentDir);
+                    if (recursive)
+                    {
+                        subDirs = Directory.GetDirectories(currentDir);
+                    }
                 }
                 catch (UnauthorizedAccessException) { continue; }
                 catch (DirectoryNotFoundException) { continue; }
 
-                foreach (string str in subDirs)
+                foreach (string dir in subDirs)
                 {
-                    folders.Enqueue(str);
+                    folders.Enqueue(dir);
                 }
             }
         }