Add support for custom configuration file paths

src/BitMono.CLI/GlobalUsings.cs

@@ -10,16 +10,19 @@
 global using System.Threading;
 global using System.Threading.Tasks;
 global using BitMono.Host.Extensions;
+global using BitMono.Host.Configurations;
 global using BitMono.Obfuscation.Files;
 global using BitMono.Obfuscation.Starter;
 global using BitMono.Shared.Models;
 global using BitMono.Utilities.Paths;
 global using CommandLine;
 global using Microsoft.Extensions.DependencyInjection;
 global using Microsoft.Extensions.Options;
+global using Microsoft.Extensions.Configuration;
 global using Pocket.Extensions;
 global using Serilog;
 global using System.Collections.Generic;
 global using System.Linq;
+global using BitMono.Shared;
 global using Serilog.Configuration;
 global using ILogger = Serilog.ILogger;

src/BitMono.CLI/Modules/ObfuscationNeeds.cs

@@ -9,6 +9,10 @@ internal class ObfuscationNeeds
     public string OutputPath { get; set; }
     public ObfuscationNeedsWay Way { get; set; }
     public List<string> Protections { get; set; }
+    public ProtectionSettings? ProtectionSettings { get; set; }
+    public string? CriticalsFile { get; set; }
+    public string? LoggingFile { get; set; }
+    public string? ObfuscationFile { get; set; }
 #pragma warning restore CS8618
 }
 

src/BitMono.CLI/Modules/ObfuscationNeedsFactory.cs

@@ -3,23 +3,16 @@ namespace BitMono.CLI.Modules;
 internal class ObfuscationNeedsFactory
 {
     private readonly string[] _args;
-    private readonly ObfuscationSettings _obfuscationSettings;
-    private readonly List<ProtectionSetting> _protectionSettings;
-    private readonly ILogger _logger;
 
-    public ObfuscationNeedsFactory(string[] args,
-        ObfuscationSettings obfuscationSettings, List<ProtectionSetting> protectionSettings, ILogger logger)
+    public ObfuscationNeedsFactory(string[] args)
     {
         _args = args;
-        _obfuscationSettings = obfuscationSettings;
-        _protectionSettings = protectionSettings;
-        _logger = logger;
     }
 
     public ObfuscationNeeds? Create(CancellationToken cancellationToken)
     {
         return _args.IsEmpty()
-            ? new ReadlineObfuscationNeedsFactory(_args, _obfuscationSettings, _protectionSettings, _logger).Create(cancellationToken)
-            : new OptionsObfuscationNeedsFactory(_args, _obfuscationSettings, _logger).Create(cancellationToken);
+            ? new ReadlineObfuscationNeedsFactory(_args).Create(cancellationToken)
+            : new OptionsObfuscationNeedsFactory(_args).Create(cancellationToken);
     }
 }

src/BitMono.CLI/Modules/Options.cs

@@ -11,6 +11,15 @@ internal class Options
     [Option('o', "output", Required = false, HelpText = "Set output path.")]
     public string? Output { get; set; }
 
-    [Option('p', "protections", Required = false, HelpText = "Set protections, also can be set via protections.json.")]
+    [Option('p', "protections", Required = false, HelpText = "Set protections list, also can be set via protections.json.")]
     public IEnumerable<string> Protections { get; set; } = [];
+
+    [Option("criticals-file", Required = false, HelpText = "Set criticals configuration file path.")]
+    public string? CriticalsFile { get; set; }
+
+    [Option("logging-file", Required = false, HelpText = "Set logging configuration file path.")]
+    public string? LoggingFile { get; set; }
+
+    [Option("obfuscation-file", Required = false, HelpText = "Set obfuscation configuration file path.")]
+    public string? ObfuscationFile { get; set; }
 }

src/BitMono.CLI/Modules/OptionsObfuscationNeedsFactory.cs

@@ -3,14 +3,10 @@ namespace BitMono.CLI.Modules;
 internal class OptionsObfuscationNeedsFactory
 {
     private readonly string[] _args;
-    private readonly ObfuscationSettings _obfuscationSettings;
-    private readonly ILogger _logger;
 
-    public OptionsObfuscationNeedsFactory(string[] args, ObfuscationSettings obfuscationSettings, ILogger logger)
+    public OptionsObfuscationNeedsFactory(string[] args)
     {
         _args = args;
-        _obfuscationSettings = obfuscationSettings;
-        _logger = logger.ForContext<OptionsObfuscationNeedsFactory>();
     }
 
     [SuppressMessage("ReSharper", "AssignNullToNotNullAttribute")]
@@ -22,20 +18,54 @@ public OptionsObfuscationNeedsFactory(string[] args, ObfuscationSettings obfusca
             with.HelpWriter = Console.Error;
         });
         var parserResult = parser.ParseArguments<Options>(_args);
-        if (parserResult.Errors.IsEmpty() == false)
+        if (!parserResult.Errors.IsEmpty())
         {
             return null;
         }
         var options = parserResult.Value;
+
+        ObfuscationSettings? obfuscationSettings = null;
+        try
+        {
+            if (options.ObfuscationFile != null && File.Exists(options.ObfuscationFile))
+            {
+                var obfuscationConfig = new BitMonoObfuscationConfiguration(options.ObfuscationFile);
+                obfuscationSettings = obfuscationConfig.Configuration.Get<ObfuscationSettings>();
+            }
+            else if (File.Exists(KnownConfigNames.Obfuscation))
+            {
+                var obfuscationConfig = new BitMonoObfuscationConfiguration();
+                obfuscationSettings = obfuscationConfig.Configuration.Get<ObfuscationSettings>();
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Warning: Could not load obfuscation configuration: {ex}");
+        }
+
         var filePath = PathFormatterUtility.Format(options.File!);
-        if (File.Exists(filePath) == false)
+        if (!File.Exists(filePath))
         {
-            _logger.Fatal($"File {filePath} cannot be found, please, try again!");
+            Console.WriteLine($"File {filePath} cannot be found, please, try again!");
             return null;
         }
-        ObfuscationNeeds needs;
         var fileBaseDirectory = Path.GetDirectoryName(filePath);
-        if (_obfuscationSettings.ForceObfuscation)
+
+        ProtectionSettings? protectionSettings = null;
+        if (options.Protections.Any())
+        {
+            protectionSettings = new ProtectionSettings
+            {
+                Protections = options.Protections.Select(x => new ProtectionSetting
+                {
+                    Name = x,
+                    Enabled = true
+                }).ToList()
+            };
+        }
+
+        ObfuscationNeeds needs;
+        if (obfuscationSettings?.ForceObfuscation == true)
         {
             needs = new ObfuscationNeeds
             {
@@ -44,7 +74,11 @@ public OptionsObfuscationNeedsFactory(string[] args, ObfuscationSettings obfusca
                 ReferencesDirectoryName = fileBaseDirectory,
                 OutputPath = fileBaseDirectory,
                 Protections = options.Protections.ToList(),
-                Way = ObfuscationNeedsWay.Options
+                ProtectionSettings = protectionSettings,
+                Way = ObfuscationNeedsWay.Options,
+                CriticalsFile = options.CriticalsFile,
+                LoggingFile = options.LoggingFile,
+                ObfuscationFile = options.ObfuscationFile
             };
         }
         else
@@ -55,12 +89,16 @@ public OptionsObfuscationNeedsFactory(string[] args, ObfuscationSettings obfusca
                 FileBaseDirectory = fileBaseDirectory,
                 ReferencesDirectoryName = options.Libraries?.IsNullOrEmpty() == false
                     ? options.Libraries
-                    : Path.Combine(fileBaseDirectory, _obfuscationSettings.ReferencesDirectoryName),
+                    : Path.Combine(fileBaseDirectory, obfuscationSettings?.ReferencesDirectoryName ?? "libs"),
                 OutputPath = options.Output?.IsNullOrEmpty() == false
                     ? options.Output
-                    : Path.Combine(fileBaseDirectory, _obfuscationSettings.OutputDirectoryName),
+                    : Path.Combine(fileBaseDirectory, obfuscationSettings?.OutputDirectoryName ?? "output"),
                 Protections = options.Protections.ToList(),
-                Way = ObfuscationNeedsWay.Options
+                ProtectionSettings = protectionSettings,
+                Way = ObfuscationNeedsWay.Options,
+                CriticalsFile = options.CriticalsFile,
+                LoggingFile = options.LoggingFile,
+                ObfuscationFile = options.ObfuscationFile
             };
         }