feat(configmanager): add CLI feature parity with UI

Expand ConfigManager.Cli with pipeline, config, backup, and connection commands
to match the feature set of ConfigManager.Ui, plus README documentation.

NEW/src/Utils/JdeScoping.ConfigManager.Cli/Commands/BackupCommands.cs

@@ -0,0 +1,347 @@
+using System.CommandLine;
+using JdeScoping.ConfigManager.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JdeScoping.ConfigManager.Cli.Commands;
+
+/// <summary>
+/// Backup management command implementations.
+/// </summary>
+public static class BackupCommands
+{
+    /// <summary>
+    /// Creates the backup create command.
+    /// </summary>
+    public static Command CreateCreateCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("create", "Create backup of appsettings.json");
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet) =>
+        {
+            var exitCode = await CreateBackupAsync(serviceProvider, configPath, verbose, quiet);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the backup list command.
+    /// </summary>
+    public static Command CreateListCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("list", "List available backups");
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet) =>
+        {
+            var exitCode = await ListBackupsAsync(serviceProvider, configPath, verbose, quiet);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the backup restore command.
+    /// </summary>
+    public static Command CreateRestoreCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("restore", "Restore a specific backup");
+
+        var timestampArgument = new Argument<string>("timestamp", "The backup timestamp (e.g., 2026-01-15_120000)");
+        command.AddArgument(timestampArgument);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, string timestamp) =>
+        {
+            var exitCode = await RestoreBackupAsync(serviceProvider, configPath, verbose, quiet, timestamp);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, timestampArgument);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the backup cleanup command.
+    /// </summary>
+    public static Command CreateCleanupCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("cleanup", "Remove old backups");
+
+        var keepOption = new Option<int>(
+            aliases: ["--keep", "-k"],
+            getDefaultValue: () => 10,
+            description: "Number of backups to keep");
+        command.AddOption(keepOption);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, int keep) =>
+        {
+            var exitCode = await CleanupBackupsAsync(serviceProvider, configPath, verbose, quiet, keep);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, keepOption);
+
+        return command;
+    }
+
+    private static async Task<int> CreateBackupAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var backupService = serviceProvider.GetRequiredService<IBackupService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        if (!File.Exists(appSettingsPath))
+        {
+            Console.Error.WriteLine($"Error: appsettings.json not found at {appSettingsPath}");
+            return 1;
+        }
+
+        try
+        {
+            var backupPath = await backupService.CreateBackupAsync(appSettingsPath);
+
+            if (!quiet)
+            {
+                Console.WriteLine("Backup created successfully");
+                Console.WriteLine($"Path: {backupPath}");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> ListBackupsAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var backupService = serviceProvider.GetRequiredService<IBackupService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        try
+        {
+            var backups = await backupService.GetBackupsAsync(appSettingsPath);
+
+            if (!quiet)
+            {
+                Console.WriteLine($"=== Backups ({backups.Count}) ===");
+            }
+
+            if (backups.Count == 0)
+            {
+                if (!quiet)
+                    Console.WriteLine("No backups found");
+                return 0;
+            }
+
+            if (!quiet)
+            {
+                Console.WriteLine($"{"Timestamp",-20} {"Size",-12} {"Path"}");
+                Console.WriteLine(new string('-', 60));
+            }
+
+            foreach (var backup in backups)
+            {
+                var timestamp = backup.Timestamp.ToString("yyyy-MM-dd_HHmmss");
+                var size = FormatFileSize(backup.Size);
+                var path = verbose ? backup.Path : Path.GetFileName(backup.Path);
+
+                Console.WriteLine($"{timestamp,-20} {size,-12} {path}");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> RestoreBackupAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        string timestamp)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var backupService = serviceProvider.GetRequiredService<IBackupService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        try
+        {
+            var backups = await backupService.GetBackupsAsync(appSettingsPath);
+            var backup = backups.FirstOrDefault(b => b.Path.Contains(timestamp));
+
+            if (backup == null)
+            {
+                Console.Error.WriteLine($"Error: Backup with timestamp '{timestamp}' not found");
+
+                if (backups.Count > 0)
+                {
+                    Console.Error.WriteLine();
+                    Console.Error.WriteLine("Available backups:");
+                    foreach (var b in backups.Take(5))
+                    {
+                        Console.Error.WriteLine($"  {b.Timestamp:yyyy-MM-dd_HHmmss}");
+                    }
+                }
+
+                return 1;
+            }
+
+            // Create a backup of current config before restoring
+            if (File.Exists(appSettingsPath))
+            {
+                var currentBackup = await backupService.CreateBackupAsync(appSettingsPath);
+                if (!quiet)
+                {
+                    Console.WriteLine($"Current config backed up to: {Path.GetFileName(currentBackup)}");
+                }
+            }
+
+            await backupService.RestoreBackupAsync(backup.Path, appSettingsPath);
+
+            if (!quiet)
+            {
+                Console.WriteLine("Backup restored successfully");
+                Console.WriteLine($"Restored from: {Path.GetFileName(backup.Path)}");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> CleanupBackupsAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        int keep)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        if (keep < 1)
+        {
+            Console.Error.WriteLine("Error: --keep must be at least 1");
+            return 1;
+        }
+
+        var backupService = serviceProvider.GetRequiredService<IBackupService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        try
+        {
+            var backupsBefore = await backupService.GetBackupsAsync(appSettingsPath);
+            var countBefore = backupsBefore.Count;
+
+            await backupService.CleanupOldBackupsAsync(appSettingsPath, keep);
+
+            var backupsAfter = await backupService.GetBackupsAsync(appSettingsPath);
+            var deleted = countBefore - backupsAfter.Count;
+
+            if (!quiet)
+            {
+                if (deleted > 0)
+                {
+                    Console.WriteLine($"Deleted {deleted} old backup(s)");
+                    Console.WriteLine($"Remaining: {backupsAfter.Count} backup(s)");
+                }
+                else
+                {
+                    Console.WriteLine("No backups to delete");
+                    Console.WriteLine($"Current count: {countBefore} (keeping {keep})");
+                }
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static string FormatFileSize(long bytes)
+    {
+        string[] sizes = ["B", "KB", "MB", "GB"];
+        var order = 0;
+        double size = bytes;
+
+        while (size >= 1024 && order < sizes.Length - 1)
+        {
+            order++;
+            size /= 1024;
+        }
+
+        return $"{size:0.##} {sizes[order]}";
+    }
+
+    private static async Task<string?> GetConfigFolderAsync(IServiceProvider serviceProvider, string? configPath)
+    {
+        if (!string.IsNullOrEmpty(configPath))
+        {
+            if (Directory.Exists(configPath))
+                return configPath;
+            return null;
+        }
+
+        var autoDiscoveryService = serviceProvider.GetRequiredService<IAutoDiscoveryService>();
+        return await autoDiscoveryService.FindConfigFolderAsync();
+    }
+}

NEW/src/Utils/JdeScoping.ConfigManager.Cli/Commands/ConfigCommands.cs

@@ -0,0 +1,435 @@
+using System.CommandLine;
+using System.Text.Json;
+using JdeScoping.ConfigManager.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JdeScoping.ConfigManager.Cli.Commands;
+
+/// <summary>
+/// Configuration viewing command implementations.
+/// </summary>
+public static class ConfigCommands
+{
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = true,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+    };
+
+    /// <summary>
+    /// Creates the config show command with section subcommands.
+    /// </summary>
+    public static Command CreateShowCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("show", "View configuration settings");
+
+        var jsonOption = new Option<bool>(
+            aliases: ["--json", "-j"],
+            description: "Output in JSON format");
+
+        command.AddOption(jsonOption);
+
+        // Add section subcommands
+        command.AddCommand(CreateSectionCommand("datasync", "Show DataSync configuration",
+            serviceProvider, configPathOption, verboseOption, quietOption, jsonOption,
+            config => config.DataSync, FormatDataSync));
+
+        command.AddCommand(CreateSectionCommand("dataaccess", "Show DataAccess configuration",
+            serviceProvider, configPathOption, verboseOption, quietOption, jsonOption,
+            config => config.DataAccess, FormatDataAccess));
+
+        command.AddCommand(CreateSectionCommand("auth", "Show Auth configuration",
+            serviceProvider, configPathOption, verboseOption, quietOption, jsonOption,
+            config => config.Auth, FormatAuth));
+
+        command.AddCommand(CreateSectionCommand("ldap", "Show LDAP configuration",
+            serviceProvider, configPathOption, verboseOption, quietOption, jsonOption,
+            config => config.Ldap, FormatLdap));
+
+        command.AddCommand(CreateSectionCommand("search", "Show Search configuration",
+            serviceProvider, configPathOption, verboseOption, quietOption, jsonOption,
+            config => config.Search, FormatSearch));
+
+        command.AddCommand(CreateSectionCommand("excelexport", "Show ExcelExport configuration",
+            serviceProvider, configPathOption, verboseOption, quietOption, jsonOption,
+            config => config.ExcelExport, FormatExcelExport));
+
+        command.AddCommand(CreateSectionCommand("securestore", "Show SecureStore configuration",
+            serviceProvider, configPathOption, verboseOption, quietOption, jsonOption,
+            config => config.SecureStore, FormatSecureStore));
+
+        command.AddCommand(CreateConnectionsCommand(serviceProvider, configPathOption, verboseOption, quietOption, jsonOption));
+        command.AddCommand(CreateAllCommand(serviceProvider, configPathOption, verboseOption, quietOption, jsonOption));
+
+        return command;
+    }
+
+    private static Command CreateSectionCommand<T>(
+        string name,
+        string description,
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption,
+        Option<bool> jsonOption,
+        Func<Core.Models.ConfigModel, T> selector,
+        Action<T, bool> formatter)
+    {
+        var command = new Command(name, description);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, bool json) =>
+        {
+            var exitCode = await ShowSectionAsync(serviceProvider, configPath, verbose, quiet, json, name, selector, formatter);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, jsonOption);
+
+        return command;
+    }
+
+    private static Command CreateConnectionsCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption,
+        Option<bool> jsonOption)
+    {
+        var command = new Command("connections", "Show connection names (no secrets)");
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, bool json) =>
+        {
+            var exitCode = await ShowConnectionsAsync(serviceProvider, configPath, verbose, quiet, json);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, jsonOption);
+
+        return command;
+    }
+
+    private static Command CreateAllCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption,
+        Option<bool> jsonOption)
+    {
+        var command = new Command("all", "Show all configuration sections");
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, bool json) =>
+        {
+            var exitCode = await ShowAllAsync(serviceProvider, configPath, verbose, quiet, json);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, jsonOption);
+
+        return command;
+    }
+
+    private static async Task<int> ShowSectionAsync<T>(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        bool json,
+        string sectionName,
+        Func<Core.Models.ConfigModel, T> selector,
+        Action<T, bool> formatter)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        if (!File.Exists(appSettingsPath))
+        {
+            Console.Error.WriteLine($"Error: appsettings.json not found at {appSettingsPath}");
+            return 1;
+        }
+
+        try
+        {
+            var config = await configFileService.LoadAppSettingsAsync(appSettingsPath);
+            var section = selector(config);
+
+            if (json)
+            {
+                Console.WriteLine(JsonSerializer.Serialize(section, JsonOptions));
+            }
+            else
+            {
+                if (!quiet)
+                {
+                    Console.WriteLine($"=== {sectionName} ===");
+                }
+                formatter(section, verbose);
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> ShowConnectionsAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        bool json)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        if (!File.Exists(appSettingsPath))
+        {
+            Console.Error.WriteLine($"Error: appsettings.json not found at {appSettingsPath}");
+            return 1;
+        }
+
+        try
+        {
+            var config = await configFileService.LoadAppSettingsAsync(appSettingsPath);
+
+            if (json)
+            {
+                // Output only names and providers, no secrets
+                var safeConnections = config.ConnectionStrings.Entries.Select(e => new
+                {
+                    e.Name,
+                    Provider = e.Provider.ToString()
+                });
+                Console.WriteLine(JsonSerializer.Serialize(safeConnections, JsonOptions));
+            }
+            else
+            {
+                if (!quiet)
+                {
+                    Console.WriteLine($"=== Connections ({config.ConnectionStrings.Entries.Count}) ===");
+                    Console.WriteLine($"{"Name",-25} {"Provider",-15}");
+                    Console.WriteLine(new string('-', 40));
+                }
+
+                foreach (var entry in config.ConnectionStrings.Entries.OrderBy(e => e.Name))
+                {
+                    Console.WriteLine($"{entry.Name,-25} {entry.Provider,-15}");
+                }
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> ShowAllAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        bool json)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        if (!File.Exists(appSettingsPath))
+        {
+            Console.Error.WriteLine($"Error: appsettings.json not found at {appSettingsPath}");
+            return 1;
+        }
+
+        try
+        {
+            var config = await configFileService.LoadAppSettingsAsync(appSettingsPath);
+
+            if (json)
+            {
+                // Sanitize passwords before outputting
+                var sanitizedConfig = new
+                {
+                    config.DataSync,
+                    config.DataAccess,
+                    config.Auth,
+                    config.Ldap,
+                    config.Search,
+                    config.ExcelExport,
+                    config.SecureStore,
+                    config.Pipelines,
+                    Connections = config.ConnectionStrings.Entries.Select(e => new
+                    {
+                        e.Name,
+                        Provider = e.Provider.ToString()
+                    })
+                };
+                Console.WriteLine(JsonSerializer.Serialize(sanitizedConfig, JsonOptions));
+            }
+            else
+            {
+                Console.WriteLine("=== DataSync ===");
+                FormatDataSync(config.DataSync, verbose);
+                Console.WriteLine();
+
+                Console.WriteLine("=== DataAccess ===");
+                FormatDataAccess(config.DataAccess, verbose);
+                Console.WriteLine();
+
+                Console.WriteLine("=== Auth ===");
+                FormatAuth(config.Auth, verbose);
+                Console.WriteLine();
+
+                Console.WriteLine("=== LDAP ===");
+                FormatLdap(config.Ldap, verbose);
+                Console.WriteLine();
+
+                Console.WriteLine("=== Search ===");
+                FormatSearch(config.Search, verbose);
+                Console.WriteLine();
+
+                Console.WriteLine("=== ExcelExport ===");
+                FormatExcelExport(config.ExcelExport, verbose);
+                Console.WriteLine();
+
+                Console.WriteLine("=== SecureStore ===");
+                FormatSecureStore(config.SecureStore, verbose);
+                Console.WriteLine();
+
+                Console.WriteLine($"=== Connections ({config.ConnectionStrings.Entries.Count}) ===");
+                Console.WriteLine($"{"Name",-25} {"Provider",-15}");
+                Console.WriteLine(new string('-', 40));
+                foreach (var entry in config.ConnectionStrings.Entries.OrderBy(e => e.Name))
+                {
+                    Console.WriteLine($"{entry.Name,-25} {entry.Provider,-15}");
+                }
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static void FormatDataSync(Core.Models.DataSyncSection section, bool verbose)
+    {
+        Console.WriteLine($"Enabled: {section.Enabled}");
+        Console.WriteLine($"CheckInterval: {section.CheckInterval}");
+        Console.WriteLine($"MaxDegreeOfParallelism: {section.MaxDegreeOfParallelism}");
+        Console.WriteLine($"BatchSize: {section.BatchSize}");
+        Console.WriteLine($"BulkCopyBatchSize: {section.BulkCopyBatchSize}");
+
+        if (verbose)
+        {
+            Console.WriteLine($"LookbackMultiplier: {section.LookbackMultiplier}");
+            Console.WriteLine($"PurgeRetentionDays: {section.PurgeRetentionDays}");
+            Console.WriteLine($"SyncTimeoutSeconds: {section.SyncTimeoutSeconds}");
+        }
+    }
+
+    private static void FormatDataAccess(Core.Models.DataAccessSection section, bool verbose)
+    {
+        Console.WriteLine($"DefaultTimeoutSeconds: {section.DefaultTimeoutSeconds}");
+        Console.WriteLine($"LotUsageTimeoutSeconds: {section.LotUsageTimeoutSeconds}");
+        Console.WriteLine($"MisDataTimeoutSeconds: {section.MisDataTimeoutSeconds}");
+        Console.WriteLine($"EnableDetailedLogging: {section.EnableDetailedLogging}");
+
+        if (verbose)
+        {
+            Console.WriteLine($"ProductionSchema: {section.ProductionSchema}");
+            Console.WriteLine($"ArchiveSchema: {section.ArchiveSchema}");
+            Console.WriteLine($"StageSchema: {section.StageSchema}");
+        }
+    }
+
+    private static void FormatAuth(Core.Models.AuthSection section, bool verbose)
+    {
+        Console.WriteLine($"CookieName: {section.CookieName}");
+        Console.WriteLine($"CookieExpirationMinutes: {section.CookieExpirationMinutes}");
+    }
+
+    private static void FormatLdap(Core.Models.LdapSection section, bool verbose)
+    {
+        Console.WriteLine($"UseFakeAuth: {section.UseFakeAuth}");
+        Console.WriteLine($"ConnectionTimeoutSeconds: {section.ConnectionTimeoutSeconds}");
+        Console.WriteLine($"ServerUrls: {(section.ServerUrls.Length > 0 ? string.Join(", ", section.ServerUrls) : "(none)")}");
+        Console.WriteLine($"GroupDn: {(string.IsNullOrEmpty(section.GroupDn) ? "(not set)" : section.GroupDn)}");
+
+        if (verbose)
+        {
+            Console.WriteLine($"SearchBase: {(string.IsNullOrEmpty(section.SearchBase) ? "(not set)" : section.SearchBase)}");
+            Console.WriteLine($"AdminBypassUsers: {(section.AdminBypassUsers.Length > 0 ? string.Join(", ", section.AdminBypassUsers) : "(none)")}");
+        }
+    }
+
+    private static void FormatSearch(Core.Models.SearchSection section, bool verbose)
+    {
+        Console.WriteLine($"MaxResultRows: {section.MaxResultRows}");
+        Console.WriteLine($"TimeoutSeconds: {section.TimeoutSeconds}");
+        Console.WriteLine($"MaxConcurrentSearches: {section.MaxConcurrentSearches}");
+    }
+
+    private static void FormatExcelExport(Core.Models.ExcelExportSection section, bool verbose)
+    {
+        Console.WriteLine($"MaxRowsPerSheet: {section.MaxRowsPerSheet}");
+        Console.WriteLine($"DefaultDateFormat: {section.DefaultDateFormat}");
+        Console.WriteLine($"TimezoneId: {section.TimezoneId}");
+        Console.WriteLine($"TimezoneAbbreviation: {section.TimezoneAbbreviation}");
+        Console.WriteLine($"DebugWriteToFile: {section.DebugWriteToFile}");
+
+        if (verbose && section.DebugWriteToFile)
+        {
+            Console.WriteLine($"DebugOutputDirectory: {section.DebugOutputDirectory}");
+        }
+
+        // Note: passwords are not shown
+        Console.WriteLine("CriteriaSheetPassword: ********");
+        Console.WriteLine("DataSheetPassword: ********");
+    }
+
+    private static void FormatSecureStore(Core.Models.SecureStoreSection section, bool verbose)
+    {
+        Console.WriteLine($"StorePath: {section.StorePath}");
+        Console.WriteLine($"KeyFilePath: {section.KeyFilePath}");
+        Console.WriteLine($"AutoCreateStore: {section.AutoCreateStore}");
+        Console.WriteLine($"RequiredKeys: {(section.RequiredKeys.Count > 0 ? string.Join(", ", section.RequiredKeys) : "(none)")}");
+    }
+
+    private static async Task<string?> GetConfigFolderAsync(IServiceProvider serviceProvider, string? configPath)
+    {
+        if (!string.IsNullOrEmpty(configPath))
+        {
+            if (Directory.Exists(configPath))
+                return configPath;
+            return null;
+        }
+
+        var autoDiscoveryService = serviceProvider.GetRequiredService<IAutoDiscoveryService>();
+        return await autoDiscoveryService.FindConfigFolderAsync();
+    }
+}

NEW/src/Utils/JdeScoping.ConfigManager.Cli/Commands/ConnectionCommands.cs

@@ -0,0 +1,492 @@
+using System.CommandLine;
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JdeScoping.ConfigManager.Cli.Commands;
+
+/// <summary>
+/// Connection string management command implementations.
+/// </summary>
+public static class ConnectionCommands
+{
+    /// <summary>
+    /// Creates the connection list command.
+    /// </summary>
+    public static Command CreateListCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("list", "List all connection names and providers");
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet) =>
+        {
+            var exitCode = await ListConnectionsAsync(serviceProvider, configPath, verbose, quiet);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the connection show command.
+    /// </summary>
+    public static Command CreateShowCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("show", "Show connection details (password masked)");
+
+        var nameArgument = new Argument<string>("name", "The connection name");
+        command.AddArgument(nameArgument);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, string name) =>
+        {
+            var exitCode = await ShowConnectionAsync(serviceProvider, configPath, verbose, quiet, name);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, nameArgument);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the connection add command.
+    /// </summary>
+    public static Command CreateAddCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("add", "Add new connection");
+
+        var nameArgument = new Argument<string>("name", "The connection name");
+        command.AddArgument(nameArgument);
+
+        var providerOption = new Option<ConnectionProvider>(
+            aliases: ["--provider", "-p"],
+            getDefaultValue: () => ConnectionProvider.SqlServer,
+            description: "Database provider (SqlServer, Oracle, Generic)");
+        command.AddOption(providerOption);
+
+        var serverOption = new Option<string?>(
+            aliases: ["--server", "-s"],
+            description: "Server name or host");
+        command.AddOption(serverOption);
+
+        var databaseOption = new Option<string?>(
+            aliases: ["--database", "-d"],
+            description: "Database name");
+        command.AddOption(databaseOption);
+
+        var userOption = new Option<string?>(
+            aliases: ["--user", "-u"],
+            description: "User ID");
+        command.AddOption(userOption);
+
+        var passwordOption = new Option<string?>(
+            aliases: ["--password"],
+            description: "Password (will be stored in config)");
+        command.AddOption(passwordOption);
+
+        var portOption = new Option<int?>(
+            aliases: ["--port"],
+            description: "Port number");
+        command.AddOption(portOption);
+
+        var serviceNameOption = new Option<string?>(
+            aliases: ["--service-name"],
+            description: "Oracle service name");
+        command.AddOption(serviceNameOption);
+
+        var rawOption = new Option<string?>(
+            aliases: ["--raw"],
+            description: "Raw connection string (for Generic provider)");
+        command.AddOption(rawOption);
+
+        command.SetHandler(async (context) =>
+        {
+            var configPath = context.ParseResult.GetValueForOption(configPathOption);
+            var verbose = context.ParseResult.GetValueForOption(verboseOption);
+            var quiet = context.ParseResult.GetValueForOption(quietOption);
+            var name = context.ParseResult.GetValueForArgument(nameArgument);
+            var provider = context.ParseResult.GetValueForOption(providerOption);
+            var server = context.ParseResult.GetValueForOption(serverOption);
+            var database = context.ParseResult.GetValueForOption(databaseOption);
+            var user = context.ParseResult.GetValueForOption(userOption);
+            var password = context.ParseResult.GetValueForOption(passwordOption);
+            var port = context.ParseResult.GetValueForOption(portOption);
+            var serviceName = context.ParseResult.GetValueForOption(serviceNameOption);
+            var raw = context.ParseResult.GetValueForOption(rawOption);
+
+            var exitCode = await AddConnectionAsync(
+                serviceProvider, configPath, verbose, quiet,
+                name, provider, server, database, user, password, port, serviceName, raw);
+            Environment.ExitCode = exitCode;
+        });
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the connection remove command.
+    /// </summary>
+    public static Command CreateRemoveCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("remove", "Remove a connection");
+
+        var nameArgument = new Argument<string>("name", "The connection name to remove");
+        command.AddArgument(nameArgument);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, string name) =>
+        {
+            var exitCode = await RemoveConnectionAsync(serviceProvider, configPath, verbose, quiet, name);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, nameArgument);
+
+        return command;
+    }
+
+    private static async Task<int> ListConnectionsAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        if (!File.Exists(appSettingsPath))
+        {
+            Console.Error.WriteLine($"Error: appsettings.json not found at {appSettingsPath}");
+            return 1;
+        }
+
+        try
+        {
+            var config = await configFileService.LoadAppSettingsAsync(appSettingsPath);
+
+            if (!quiet)
+            {
+                Console.WriteLine($"=== Connections ({config.ConnectionStrings.Entries.Count}) ===");
+                Console.WriteLine($"{"Name",-25} {"Provider",-15} {"Server/Host",-30}");
+                Console.WriteLine(new string('-', 70));
+            }
+
+            foreach (var entry in config.ConnectionStrings.Entries.OrderBy(e => e.Name))
+            {
+                var serverOrHost = entry.Provider switch
+                {
+                    ConnectionProvider.SqlServer => entry.Server ?? "-",
+                    ConnectionProvider.Oracle => entry.Host ?? "-",
+                    ConnectionProvider.Generic => "(raw)",
+                    _ => "-"
+                };
+
+                Console.WriteLine($"{entry.Name,-25} {entry.Provider,-15} {serverOrHost,-30}");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> ShowConnectionAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        string name)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        if (!File.Exists(appSettingsPath))
+        {
+            Console.Error.WriteLine($"Error: appsettings.json not found at {appSettingsPath}");
+            return 1;
+        }
+
+        try
+        {
+            var config = await configFileService.LoadAppSettingsAsync(appSettingsPath);
+            var entry = config.ConnectionStrings.Entries.FirstOrDefault(e =>
+                e.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+
+            if (entry == null)
+            {
+                Console.Error.WriteLine($"Error: Connection '{name}' not found");
+                return 1;
+            }
+
+            if (!quiet)
+            {
+                Console.WriteLine($"=== Connection: {entry.Name} ===");
+            }
+
+            Console.WriteLine($"Name: {entry.Name}");
+            Console.WriteLine($"Provider: {entry.Provider}");
+
+            switch (entry.Provider)
+            {
+                case ConnectionProvider.SqlServer:
+                    Console.WriteLine($"Server: {entry.Server ?? "(not set)"}");
+                    if (entry.SqlServerPort.HasValue)
+                        Console.WriteLine($"Port: {entry.SqlServerPort.Value}");
+                    Console.WriteLine($"Database: {entry.Database ?? "(not set)"}");
+                    Console.WriteLine($"User ID: {entry.UserId ?? "(not set)"}");
+                    Console.WriteLine($"Password: {MaskPassword(entry.Password)}");
+                    Console.WriteLine($"Encrypt: {entry.Encrypt}");
+                    Console.WriteLine($"TrustServerCertificate: {entry.TrustServerCertificate}");
+                    Console.WriteLine($"ConnectionTimeout: {entry.ConnectionTimeout}");
+                    if (!string.IsNullOrEmpty(entry.ApplicationName))
+                        Console.WriteLine($"ApplicationName: {entry.ApplicationName}");
+                    break;
+
+                case ConnectionProvider.Oracle:
+                    Console.WriteLine($"Host: {entry.Host ?? "(not set)"}");
+                    Console.WriteLine($"Port: {entry.Port}");
+                    Console.WriteLine($"ServiceName: {entry.ServiceName ?? "(not set)"}");
+                    Console.WriteLine($"User ID: {entry.UserId ?? "(not set)"}");
+                    Console.WriteLine($"Password: {MaskPassword(entry.Password)}");
+                    break;
+
+                case ConnectionProvider.Generic:
+                    Console.WriteLine($"RawConnectionString: {MaskConnectionString(entry.RawConnectionString)}");
+                    break;
+            }
+
+            if (verbose)
+            {
+                Console.WriteLine();
+                Console.WriteLine("Generated connection string (masked):");
+                Console.WriteLine($"  {MaskConnectionString(entry.GenerateConnectionString())}");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> AddConnectionAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        string name,
+        ConnectionProvider provider,
+        string? server,
+        string? database,
+        string? user,
+        string? password,
+        int? port,
+        string? serviceName,
+        string? raw)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        if (!File.Exists(appSettingsPath))
+        {
+            Console.Error.WriteLine($"Error: appsettings.json not found at {appSettingsPath}");
+            return 1;
+        }
+
+        try
+        {
+            var config = await configFileService.LoadAppSettingsAsync(appSettingsPath);
+
+            // Check if connection already exists
+            if (config.ConnectionStrings.Entries.Any(e =>
+                e.Name.Equals(name, StringComparison.OrdinalIgnoreCase)))
+            {
+                Console.Error.WriteLine($"Error: Connection '{name}' already exists");
+                return 1;
+            }
+
+            // Validate required fields based on provider
+            if (provider == ConnectionProvider.Generic && string.IsNullOrEmpty(raw))
+            {
+                Console.Error.WriteLine("Error: --raw is required for Generic provider");
+                return 1;
+            }
+
+            var entry = new ConnectionStringEntry
+            {
+                Name = name,
+                Provider = provider,
+                Server = server,
+                Database = database,
+                UserId = user,
+                Password = password,
+                Host = server, // For Oracle, use server as host
+                ServiceName = serviceName,
+                RawConnectionString = raw
+            };
+
+            if (port.HasValue)
+            {
+                if (provider == ConnectionProvider.SqlServer)
+                    entry.SqlServerPort = port;
+                else if (provider == ConnectionProvider.Oracle)
+                    entry.Port = port.Value;
+            }
+
+            config.ConnectionStrings.Entries.Add(entry);
+            await configFileService.SaveAppSettingsAsync(appSettingsPath, config);
+
+            if (!quiet)
+            {
+                Console.WriteLine($"Connection '{name}' added successfully");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> RemoveConnectionAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        string name)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var appSettingsPath = Path.Combine(folderPath, "appsettings.json");
+
+        if (!File.Exists(appSettingsPath))
+        {
+            Console.Error.WriteLine($"Error: appsettings.json not found at {appSettingsPath}");
+            return 1;
+        }
+
+        try
+        {
+            var config = await configFileService.LoadAppSettingsAsync(appSettingsPath);
+            var entry = config.ConnectionStrings.Entries.FirstOrDefault(e =>
+                e.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+
+            if (entry == null)
+            {
+                Console.Error.WriteLine($"Error: Connection '{name}' not found");
+                return 1;
+            }
+
+            config.ConnectionStrings.Entries.Remove(entry);
+            await configFileService.SaveAppSettingsAsync(appSettingsPath, config);
+
+            if (!quiet)
+            {
+                Console.WriteLine($"Connection '{name}' removed successfully");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static string MaskPassword(string? password)
+    {
+        if (string.IsNullOrEmpty(password))
+            return "(not set)";
+        return "********";
+    }
+
+    private static string MaskConnectionString(string? connectionString)
+    {
+        if (string.IsNullOrEmpty(connectionString))
+            return "(not set)";
+
+        // Mask password in connection string
+        var result = connectionString;
+
+        // Common patterns for password in connection strings
+        var patterns = new[]
+        {
+            "Password=",
+            "Pwd=",
+            "password="
+        };
+
+        foreach (var pattern in patterns)
+        {
+            var idx = result.IndexOf(pattern, StringComparison.OrdinalIgnoreCase);
+            if (idx >= 0)
+            {
+                var start = idx + pattern.Length;
+                var end = result.IndexOf(';', start);
+                if (end < 0) end = result.Length;
+
+                result = string.Concat(result.AsSpan(0, start), "********", result.AsSpan(end));
+            }
+        }
+
+        return result;
+    }
+
+    private static async Task<string?> GetConfigFolderAsync(IServiceProvider serviceProvider, string? configPath)
+    {
+        if (!string.IsNullOrEmpty(configPath))
+        {
+            if (Directory.Exists(configPath))
+                return configPath;
+            return null;
+        }
+
+        var autoDiscoveryService = serviceProvider.GetRequiredService<IAutoDiscoveryService>();
+        return await autoDiscoveryService.FindConfigFolderAsync();
+    }
+}

NEW/src/Utils/JdeScoping.ConfigManager.Cli/Commands/PipelineCommands.cs

@@ -0,0 +1,487 @@
+using System.CommandLine;
+using JdeScoping.ConfigManager.Core.Services;
+using JdeScoping.DataSync.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JdeScoping.ConfigManager.Cli.Commands;
+
+/// <summary>
+/// Pipeline management command implementations.
+/// </summary>
+public static class PipelineCommands
+{
+    /// <summary>
+    /// Creates the pipeline list command.
+    /// </summary>
+    public static Command CreateListCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("list", "List all pipelines with status");
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet) =>
+        {
+            var exitCode = await ListPipelinesAsync(serviceProvider, configPath, verbose, quiet);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the pipeline show command.
+    /// </summary>
+    public static Command CreateShowCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("show", "Show detailed pipeline configuration");
+
+        var nameArgument = new Argument<string>("name", "The pipeline name");
+        command.AddArgument(nameArgument);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, string name) =>
+        {
+            var exitCode = await ShowPipelineAsync(serviceProvider, configPath, verbose, quiet, name);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, nameArgument);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the pipeline create command.
+    /// </summary>
+    public static Command CreateCreateCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("create", "Create new pipeline with defaults");
+
+        var nameArgument = new Argument<string>("name", "The pipeline name");
+        command.AddArgument(nameArgument);
+
+        var enabledOption = new Option<bool>(
+            aliases: ["--enabled", "-e"],
+            getDefaultValue: () => true,
+            description: "Whether the pipeline is enabled");
+        command.AddOption(enabledOption);
+
+        var manualOnlyOption = new Option<bool>(
+            aliases: ["--manual-only", "-m"],
+            description: "Pipeline can only be triggered manually");
+        command.AddOption(manualOnlyOption);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, string name, bool enabled, bool manualOnly) =>
+        {
+            var exitCode = await CreatePipelineAsync(serviceProvider, configPath, verbose, quiet, name, enabled, manualOnly);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, nameArgument, enabledOption, manualOnlyOption);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the pipeline delete command.
+    /// </summary>
+    public static Command CreateDeleteCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("delete", "Delete a pipeline");
+
+        var nameArgument = new Argument<string>("name", "The pipeline name to delete");
+        command.AddArgument(nameArgument);
+
+        var forceOption = new Option<bool>(
+            aliases: ["--force", "-f"],
+            description: "Skip confirmation prompt");
+        command.AddOption(forceOption);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, string name, bool force) =>
+        {
+            var exitCode = await DeletePipelineAsync(serviceProvider, configPath, verbose, quiet, name, force);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, nameArgument, forceOption);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the pipeline enable command.
+    /// </summary>
+    public static Command CreateEnableCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("enable", "Enable a pipeline");
+
+        var nameArgument = new Argument<string>("name", "The pipeline name to enable");
+        command.AddArgument(nameArgument);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, string name) =>
+        {
+            var exitCode = await SetPipelineEnabledAsync(serviceProvider, configPath, verbose, quiet, name, true);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, nameArgument);
+
+        return command;
+    }
+
+    /// <summary>
+    /// Creates the pipeline disable command.
+    /// </summary>
+    public static Command CreateDisableCommand(
+        IServiceProvider serviceProvider,
+        Option<string?> configPathOption,
+        Option<bool> verboseOption,
+        Option<bool> quietOption)
+    {
+        var command = new Command("disable", "Disable a pipeline");
+
+        var nameArgument = new Argument<string>("name", "The pipeline name to disable");
+        command.AddArgument(nameArgument);
+
+        command.SetHandler(async (string? configPath, bool verbose, bool quiet, string name) =>
+        {
+            var exitCode = await SetPipelineEnabledAsync(serviceProvider, configPath, verbose, quiet, name, false);
+            Environment.ExitCode = exitCode;
+        }, configPathOption, verboseOption, quietOption, nameArgument);
+
+        return command;
+    }
+
+    private static async Task<int> ListPipelinesAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var pipelinesDir = Path.Combine(folderPath, "Pipelines");
+
+        try
+        {
+            var pipelines = await configFileService.LoadAllPipelinesAsync(pipelinesDir);
+
+            if (!quiet)
+            {
+                Console.WriteLine($"=== Pipelines ({pipelines.Count}) ===");
+                Console.WriteLine($"{"Name",-20} {"Enabled",-8} {"Mass",-8} {"Daily",-8} {"Hourly",-8}");
+                Console.WriteLine(new string('-', 52));
+            }
+
+            foreach (var kvp in pipelines.OrderBy(p => p.Key))
+            {
+                var p = kvp.Value;
+                var mass = FormatInterval(p.MassSyncIntervalMinutes);
+                var daily = FormatInterval(p.DailySyncIntervalMinutes);
+                var hourly = FormatInterval(p.HourlySyncIntervalMinutes);
+                var enabled = p.IsEnabled ? "Yes" : "No";
+
+                Console.WriteLine($"{p.Name,-20} {enabled,-8} {mass,-8} {daily,-8} {hourly,-8}");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> ShowPipelineAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        string name)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var pipelinePath = Path.Combine(folderPath, "Pipelines", $"pipeline.{name}.json");
+
+        if (!File.Exists(pipelinePath))
+        {
+            Console.Error.WriteLine($"Error: Pipeline '{name}' not found");
+            return 1;
+        }
+
+        try
+        {
+            var pipeline = await configFileService.LoadPipelineAsync(pipelinePath);
+
+            if (!quiet)
+            {
+                Console.WriteLine($"=== Pipeline: {pipeline.Name} ===");
+            }
+
+            Console.WriteLine($"Name: {pipeline.Name}");
+            Console.WriteLine($"Enabled: {pipeline.IsEnabled}");
+            Console.WriteLine($"Manual Only: {pipeline.IsManualOnly}");
+            Console.WriteLine();
+
+            Console.WriteLine("Sync Intervals:");
+            Console.WriteLine($"  Mass:   {FormatInterval(pipeline.MassSyncIntervalMinutes)}");
+            Console.WriteLine($"  Daily:  {FormatInterval(pipeline.DailySyncIntervalMinutes)}");
+            Console.WriteLine($"  Hourly: {FormatInterval(pipeline.HourlySyncIntervalMinutes)}");
+
+            if (pipeline.Source != null)
+            {
+                Console.WriteLine();
+                Console.WriteLine("Source:");
+                Console.WriteLine($"  Connection: {pipeline.Source.Connection}");
+                if (!string.IsNullOrEmpty(pipeline.Source.Query))
+                    Console.WriteLine($"  Query: {(pipeline.Source.Query.Length > 50 ? pipeline.Source.Query[..50] + "..." : pipeline.Source.Query)}");
+            }
+
+            if (pipeline.Destination != null)
+            {
+                Console.WriteLine();
+                Console.WriteLine("Destination:");
+                Console.WriteLine($"  Table: {pipeline.Destination.Table}");
+                if (pipeline.Destination.MatchColumns.Count > 0)
+                    Console.WriteLine($"  Match Columns: {string.Join(", ", pipeline.Destination.MatchColumns)}");
+            }
+
+            if (verbose)
+            {
+                if (pipeline.PreScripts.Count > 0)
+                {
+                    Console.WriteLine();
+                    Console.WriteLine($"Pre-Scripts: {pipeline.PreScripts.Count}");
+                }
+
+                if (pipeline.Transforms.Count > 0)
+                {
+                    Console.WriteLine();
+                    Console.WriteLine($"Transforms: {pipeline.Transforms.Count}");
+                }
+
+                if (pipeline.PostScripts.Count > 0)
+                {
+                    Console.WriteLine();
+                    Console.WriteLine($"Post-Scripts: {pipeline.PostScripts.Count}");
+                }
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> CreatePipelineAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        string name,
+        bool enabled,
+        bool manualOnly)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var pipelinesDir = Path.Combine(folderPath, "Pipelines");
+        var pipelinePath = Path.Combine(pipelinesDir, $"pipeline.{name}.json");
+
+        if (File.Exists(pipelinePath))
+        {
+            Console.Error.WriteLine($"Error: Pipeline '{name}' already exists");
+            return 1;
+        }
+
+        try
+        {
+            // Create Pipelines directory if it doesn't exist
+            if (!Directory.Exists(pipelinesDir))
+            {
+                Directory.CreateDirectory(pipelinesDir);
+            }
+
+            var pipeline = new EtlPipelineConfig
+            {
+                Name = name,
+                IsEnabled = enabled,
+                IsManualOnly = manualOnly,
+                Source = new SourceElement { Connection = "jde" },
+                Destination = new DestinationElement { Table = name }
+            };
+
+            await configFileService.SavePipelineAsync(pipelinePath, pipeline);
+
+            if (!quiet)
+            {
+                Console.WriteLine($"Pipeline '{name}' created successfully");
+                Console.WriteLine($"File: {pipelinePath}");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> DeletePipelineAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        string name,
+        bool force)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var pipelinePath = Path.Combine(folderPath, "Pipelines", $"pipeline.{name}.json");
+
+        if (!File.Exists(pipelinePath))
+        {
+            Console.Error.WriteLine($"Error: Pipeline '{name}' not found");
+            return 1;
+        }
+
+        if (!force)
+        {
+            Console.Write($"Delete pipeline '{name}'? [y/N] ");
+            var response = Console.ReadLine();
+            if (!string.Equals(response, "y", StringComparison.OrdinalIgnoreCase) &&
+                !string.Equals(response, "yes", StringComparison.OrdinalIgnoreCase))
+            {
+                if (!quiet)
+                    Console.WriteLine("Cancelled");
+                return 0;
+            }
+        }
+
+        try
+        {
+            await configFileService.DeletePipelineFileAsync(pipelinePath);
+
+            if (!quiet)
+            {
+                Console.WriteLine($"Pipeline '{name}' deleted successfully");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static async Task<int> SetPipelineEnabledAsync(
+        IServiceProvider serviceProvider,
+        string? configPath,
+        bool verbose,
+        bool quiet,
+        string name,
+        bool enabled)
+    {
+        var folderPath = await GetConfigFolderAsync(serviceProvider, configPath);
+        if (folderPath == null)
+        {
+            Console.Error.WriteLine("Error: Could not find configuration folder. Use --config-path to specify.");
+            return 1;
+        }
+
+        var configFileService = serviceProvider.GetRequiredService<IConfigFileService>();
+        var pipelinePath = Path.Combine(folderPath, "Pipelines", $"pipeline.{name}.json");
+
+        if (!File.Exists(pipelinePath))
+        {
+            Console.Error.WriteLine($"Error: Pipeline '{name}' not found");
+            return 1;
+        }
+
+        try
+        {
+            var pipeline = await configFileService.LoadPipelineAsync(pipelinePath);
+            pipeline.IsEnabled = enabled;
+            await configFileService.SavePipelineAsync(pipelinePath, pipeline);
+
+            if (!quiet)
+            {
+                var action = enabled ? "enabled" : "disabled";
+                Console.WriteLine($"Pipeline '{name}' {action} successfully");
+            }
+
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static string FormatInterval(int? minutes)
+    {
+        if (!minutes.HasValue)
+            return "-";
+
+        if (minutes.Value >= 10080) // 7 days
+            return $"{minutes.Value / 10080}w";
+        if (minutes.Value >= 1440) // 1 day
+            return $"{minutes.Value / 1440}d";
+        if (minutes.Value >= 60)
+            return $"{minutes.Value / 60}h";
+        return $"{minutes.Value}m";
+    }
+
+    private static async Task<string?> GetConfigFolderAsync(IServiceProvider serviceProvider, string? configPath)
+    {
+        if (!string.IsNullOrEmpty(configPath))
+        {
+            if (Directory.Exists(configPath))
+                return configPath;
+            return null;
+        }
+
+        var autoDiscoveryService = serviceProvider.GetRequiredService<IAutoDiscoveryService>();
+        return await autoDiscoveryService.FindConfigFolderAsync();
+    }
+}

NEW/src/Utils/JdeScoping.ConfigManager.Cli/Program.cs

@@ -68,6 +68,37 @@ public static class Program
         secretCommand.AddCommand(SecretCommands.CreateInitCommand(serviceProvider, configPathOption, verboseOption, quietOption));
         rootCommand.AddCommand(secretCommand);
 
+        // Pipeline command group
+        var pipelineCommand = new Command("pipeline", "Manage ETL pipelines");
+        pipelineCommand.AddCommand(PipelineCommands.CreateListCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        pipelineCommand.AddCommand(PipelineCommands.CreateShowCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        pipelineCommand.AddCommand(PipelineCommands.CreateCreateCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        pipelineCommand.AddCommand(PipelineCommands.CreateDeleteCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        pipelineCommand.AddCommand(PipelineCommands.CreateEnableCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        pipelineCommand.AddCommand(PipelineCommands.CreateDisableCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        rootCommand.AddCommand(pipelineCommand);
+
+        // Config command group
+        var configCommand = new Command("config", "View configuration settings");
+        configCommand.AddCommand(ConfigCommands.CreateShowCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        rootCommand.AddCommand(configCommand);
+
+        // Backup command group
+        var backupCommand = new Command("backup", "Manage configuration backups");
+        backupCommand.AddCommand(BackupCommands.CreateCreateCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        backupCommand.AddCommand(BackupCommands.CreateListCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        backupCommand.AddCommand(BackupCommands.CreateRestoreCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        backupCommand.AddCommand(BackupCommands.CreateCleanupCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        rootCommand.AddCommand(backupCommand);
+
+        // Connection command group
+        var connectionCommand = new Command("connection", "Manage connection strings");
+        connectionCommand.AddCommand(ConnectionCommands.CreateListCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        connectionCommand.AddCommand(ConnectionCommands.CreateShowCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        connectionCommand.AddCommand(ConnectionCommands.CreateAddCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        connectionCommand.AddCommand(ConnectionCommands.CreateRemoveCommand(serviceProvider, configPathOption, verboseOption, quietOption));
+        rootCommand.AddCommand(connectionCommand);
+
         return await rootCommand.InvokeAsync(args);
     }
 

NEW/src/Utils/JdeScoping.ConfigManager.Cli/README.md

@@ -0,0 +1,273 @@
+# JdeScoping ConfigManager CLI
+
+Command-line tool for managing JDE Scoping Tool configuration files, ETL pipelines, connection strings, secrets, and backups.
+
+## Installation
+
+Build the tool from the solution:
+
+```bash
+dotnet build NEW/src/Utils/JdeScoping.ConfigManager.Cli/JdeScoping.ConfigManager.Cli.csproj
+```
+
+The executable is located at:
+- **Windows:** `bin/Debug/net10.0/jdescoping-config.exe`
+- **macOS/Linux:** `bin/Debug/net10.0/jdescoping-config`
+
+## Global Options
+
+These options apply to all commands:
+
+| Option | Alias | Description |
+|--------|-------|-------------|
+| `--config-path` | `-c` | Path to configuration folder (overrides auto-discovery) |
+| `--verbose` | `-v` | Enable verbose output |
+| `--quiet` | `-q` | Suppress non-error output |
+
+## Configuration Discovery
+
+If `--config-path` is not specified, the tool searches for configuration in this order:
+
+1. `JDESCOPING_CONFIG_PATH` environment variable
+2. Same directory as the executable
+3. `../JdeScoping.Host/` relative to executable
+4. User config directory (`~/.jdescoping` on Unix, `%LOCALAPPDATA%\JdeScoping` on Windows)
+
+## Commands Reference
+
+### Validation Commands
+
+Validate configuration files for errors and warnings.
+
+```bash
+# Validate appsettings.json
+jdescoping-config validate appsettings
+
+# Validate all pipeline files
+jdescoping-config validate pipelines
+
+# Validate all configuration files
+jdescoping-config validate all
+
+# Run runtime infrastructure validators
+jdescoping-config validate runtime
+```
+
+### Connection Testing Commands
+
+Test database connections defined in configuration.
+
+```bash
+# Test SQL Server connection
+jdescoping-config test-connection sql
+
+# Test a specific named connection
+jdescoping-config test-connection sql --name SqlServerCache
+
+# Test Oracle connection
+jdescoping-config test-connection oracle
+
+# Test all configured connections
+jdescoping-config test-connection all
+```
+
+### Secret Management Commands
+
+Manage encrypted secrets in SecureStore.
+
+```bash
+# Initialize a new SecureStore
+jdescoping-config secret init
+
+# List all secret keys
+jdescoping-config secret list
+
+# Get a secret value
+jdescoping-config secret get <key>
+
+# Set or update a secret
+jdescoping-config secret set <key> <value>
+
+# Remove a secret
+jdescoping-config secret remove <key>
+```
+
+### Pipeline Management Commands
+
+Manage ETL pipeline configurations.
+
+```bash
+# List all pipelines with status
+jdescoping-config pipeline list
+
+# Example output:
+# === Pipelines (3) ===
+# Name                 Enabled  Mass     Daily    Hourly
+# -------------------- -------- -------- -------- --------
+# WorkOrder_Curr       Yes      1w       1d       1h
+# LotUsage_Curr        Yes      1w       1d       -
+# Item                 No       1w       -        -
+
+# Show detailed pipeline configuration
+jdescoping-config pipeline show <name>
+
+# Create a new pipeline with defaults
+jdescoping-config pipeline create <name>
+jdescoping-config pipeline create <name> --enabled false
+jdescoping-config pipeline create <name> --manual-only
+
+# Delete a pipeline
+jdescoping-config pipeline delete <name>
+jdescoping-config pipeline delete <name> --force  # Skip confirmation
+
+# Enable/disable a pipeline
+jdescoping-config pipeline enable <name>
+jdescoping-config pipeline disable <name>
+```
+
+### Configuration Viewing Commands
+
+View configuration settings (read-only).
+
+```bash
+# Show specific sections
+jdescoping-config config show datasync
+jdescoping-config config show dataaccess
+jdescoping-config config show auth
+jdescoping-config config show ldap
+jdescoping-config config show search
+jdescoping-config config show excelexport
+jdescoping-config config show securestore
+
+# Show connection names (no secrets)
+jdescoping-config config show connections
+
+# Show all configuration sections
+jdescoping-config config show all
+
+# Output as JSON
+jdescoping-config config show datasync --json
+jdescoping-config config show all --json
+```
+
+### Backup Management Commands
+
+Manage configuration file backups.
+
+```bash
+# Create a backup of appsettings.json
+jdescoping-config backup create
+
+# List available backups
+jdescoping-config backup list
+
+# Example output:
+# === Backups (3) ===
+# Timestamp            Size         Path
+# -------------------- ------------ --------------------------------
+# 2026-01-15_120000    1.2 KB       appsettings.2026-01-15_120000.bak
+# 2026-01-14_090000    1.1 KB       appsettings.2026-01-14_090000.bak
+
+# Restore a specific backup
+jdescoping-config backup restore <timestamp>
+jdescoping-config backup restore 2026-01-15_120000
+
+# Remove old backups (keep most recent N)
+jdescoping-config backup cleanup
+jdescoping-config backup cleanup --keep 5
+```
+
+### Connection String Management Commands
+
+Manage database connection strings.
+
+```bash
+# List all connections
+jdescoping-config connection list
+
+# Example output:
+# === Connections (3) ===
+# Name                      Provider        Server/Host
+# ------------------------- --------------- ------------------------------
+# SqlServerCache            SqlServer       localhost
+# JdeOracle                 Oracle          jde-prod-server
+# CmsSybase                 Generic         (raw)
+
+# Show connection details (password masked)
+jdescoping-config connection show <name>
+jdescoping-config connection show SqlServerCache
+
+# Add a new SQL Server connection
+jdescoping-config connection add MyConnection \
+    --provider SqlServer \
+    --server localhost \
+    --database MyDatabase \
+    --user sa \
+    --password secret123 \
+    --port 1434
+
+# Add a new Oracle connection
+jdescoping-config connection add JdeOracle \
+    --provider Oracle \
+    --server oracle-host \
+    --service-name JDEPRD \
+    --port 1521 \
+    --user jdeuser
+
+# Add a Generic connection (raw connection string)
+jdescoping-config connection add CustomDb \
+    --provider Generic \
+    --raw "Driver={...};Server=...;Database=..."
+
+# Remove a connection
+jdescoping-config connection remove <name>
+```
+
+## Exit Codes
+
+| Code | Description |
+|------|-------------|
+| 0 | Success |
+| 1 | Error (validation failure, missing file, operation error) |
+
+## Examples
+
+### Validate and test before deployment
+
+```bash
+# Validate all configuration
+jdescoping-config validate all
+
+# Test all database connections
+jdescoping-config test-connection all
+
+# Create a backup before making changes
+jdescoping-config backup create
+```
+
+### Quick status check
+
+```bash
+# View pipelines
+jdescoping-config pipeline list --quiet
+
+# View connections
+jdescoping-config connection list --quiet
+```
+
+### Scripted configuration
+
+```bash
+# Disable a pipeline for maintenance
+jdescoping-config pipeline disable WorkOrder_Curr
+
+# Re-enable after maintenance
+jdescoping-config pipeline enable WorkOrder_Curr
+```
+
+### Export configuration as JSON
+
+```bash
+# Export all config to JSON for review
+jdescoping-config config show all --json > config-snapshot.json
+```

NEW/tests/Utils/JdeScoping.ConfigManager.Cli.Tests/Commands/BackupCommandsTests.cs

@@ -0,0 +1,298 @@
+using System.CommandLine;
+using JdeScoping.ConfigManager.Cli.Commands;
+using JdeScoping.ConfigManager.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JdeScoping.ConfigManager.Cli.Tests.Commands;
+
+public class BackupCommandsTests
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly IBackupService _backupService;
+    private readonly IAutoDiscoveryService _autoDiscoveryService;
+    private readonly Option<string?> _configPathOption;
+    private readonly Option<bool> _verboseOption;
+    private readonly Option<bool> _quietOption;
+
+    public BackupCommandsTests()
+    {
+        _backupService = Substitute.For<IBackupService>();
+        _autoDiscoveryService = Substitute.For<IAutoDiscoveryService>();
+
+        var services = new ServiceCollection();
+        services.AddSingleton(_backupService);
+        services.AddSingleton(_autoDiscoveryService);
+        _serviceProvider = services.BuildServiceProvider();
+
+        _configPathOption = new Option<string?>(["--config-path", "-c"]);
+        _verboseOption = new Option<bool>(["--verbose", "-v"]);
+        _quietOption = new Option<bool>(["--quiet", "-q"]);
+    }
+
+    [Fact]
+    public void CreateCreateCommand_ReturnsCommand()
+    {
+        // Act
+        var command = BackupCommands.CreateCreateCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("create");
+    }
+
+    [Fact]
+    public void CreateListCommand_ReturnsCommand()
+    {
+        // Act
+        var command = BackupCommands.CreateListCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("list");
+    }
+
+    [Fact]
+    public void CreateRestoreCommand_ReturnsCommandWithTimestampArgument()
+    {
+        // Act
+        var command = BackupCommands.CreateRestoreCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("restore");
+        command.Arguments.ShouldContain(a => a.Name == "timestamp");
+    }
+
+    [Fact]
+    public void CreateCleanupCommand_ReturnsCommandWithKeepOption()
+    {
+        // Act
+        var command = BackupCommands.CreateCleanupCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("cleanup");
+        command.Options.ShouldContain(o => o.Name == "keep");
+    }
+
+    [Fact]
+    public async Task CreateCommand_WithNoConfigFolder_ReturnsError()
+    {
+        // Arrange
+        _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult<string?>(null));
+
+        var command = BackupCommands.CreateCreateCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+        var rootCommand = new RootCommand { command };
+        rootCommand.AddGlobalOption(_configPathOption);
+        rootCommand.AddGlobalOption(_verboseOption);
+        rootCommand.AddGlobalOption(_quietOption);
+
+        // Act
+        var exitCode = await rootCommand.InvokeAsync(["create"]);
+
+        // Assert - command completes without throwing
+        command.ShouldNotBeNull();
+    }
+
+    [Fact]
+    public async Task CreateCommand_WithValidConfig_CreatesBackup()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+        var backupPath = Path.Combine(tempDir, "appsettings.2026-01-15_120000.bak");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            _backupService.CreateBackupAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(backupPath));
+
+            var command = BackupCommands.CreateCreateCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console output
+            var originalOut = Console.Out;
+            using var writer = new StringWriter();
+            Console.SetOut(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["create"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("Backup created successfully");
+                await _backupService.Received(1).CreateBackupAsync(appSettingsPath, Arg.Any<CancellationToken>());
+            }
+            finally
+            {
+                Console.SetOut(originalOut);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void ListCommand_HasCorrectDescription()
+    {
+        // Arrange & Act
+        var command = BackupCommands.CreateListCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.Description.ShouldBe("List available backups");
+    }
+
+    [Fact]
+    public async Task ListCommand_WithNoBackups_ShowsEmptyMessage()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            _backupService.GetBackupsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<IReadOnlyList<BackupInfo>>(new List<BackupInfo>()));
+
+            var command = BackupCommands.CreateListCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console output
+            var originalOut = Console.Out;
+            using var writer = new StringWriter();
+            Console.SetOut(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["list"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("No backups found");
+            }
+            finally
+            {
+                Console.SetOut(originalOut);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public async Task CleanupCommand_CallsCleanupService()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            _backupService.GetBackupsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<IReadOnlyList<BackupInfo>>(new List<BackupInfo>()));
+
+            var command = BackupCommands.CreateCleanupCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Act
+            await rootCommand.InvokeAsync(["cleanup", "--keep", "5"]);
+
+            // Assert
+            await _backupService.Received(1).CleanupOldBackupsAsync(appSettingsPath, 5, Arg.Any<CancellationToken>());
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public async Task RestoreCommand_WithNonExistentBackup_ReturnsError()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            _backupService.GetBackupsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<IReadOnlyList<BackupInfo>>(new List<BackupInfo>()));
+
+            var command = BackupCommands.CreateRestoreCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console error output
+            var originalErr = Console.Error;
+            using var writer = new StringWriter();
+            Console.SetError(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["restore", "2026-01-99_999999"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("not found");
+            }
+            finally
+            {
+                Console.SetError(originalErr);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Cli.Tests/Commands/ConfigCommandsTests.cs

@@ -0,0 +1,183 @@
+using System.CommandLine;
+using JdeScoping.ConfigManager.Cli.Commands;
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JdeScoping.ConfigManager.Cli.Tests.Commands;
+
+public class ConfigCommandsTests
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly IConfigFileService _configFileService;
+    private readonly IAutoDiscoveryService _autoDiscoveryService;
+    private readonly Option<string?> _configPathOption;
+    private readonly Option<bool> _verboseOption;
+    private readonly Option<bool> _quietOption;
+
+    public ConfigCommandsTests()
+    {
+        _configFileService = Substitute.For<IConfigFileService>();
+        _autoDiscoveryService = Substitute.For<IAutoDiscoveryService>();
+
+        var services = new ServiceCollection();
+        services.AddSingleton(_configFileService);
+        services.AddSingleton(_autoDiscoveryService);
+        _serviceProvider = services.BuildServiceProvider();
+
+        _configPathOption = new Option<string?>(["--config-path", "-c"]);
+        _verboseOption = new Option<bool>(["--verbose", "-v"]);
+        _quietOption = new Option<bool>(["--quiet", "-q"]);
+    }
+
+    [Fact]
+    public void CreateShowCommand_ReturnsCommandWithSubcommands()
+    {
+        // Act
+        var command = ConfigCommands.CreateShowCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("show");
+        command.Subcommands.ShouldContain(c => c.Name == "datasync");
+        command.Subcommands.ShouldContain(c => c.Name == "dataaccess");
+        command.Subcommands.ShouldContain(c => c.Name == "auth");
+        command.Subcommands.ShouldContain(c => c.Name == "ldap");
+        command.Subcommands.ShouldContain(c => c.Name == "search");
+        command.Subcommands.ShouldContain(c => c.Name == "excelexport");
+        command.Subcommands.ShouldContain(c => c.Name == "securestore");
+        command.Subcommands.ShouldContain(c => c.Name == "connections");
+        command.Subcommands.ShouldContain(c => c.Name == "all");
+    }
+
+    [Fact]
+    public void CreateShowCommand_HasJsonOption()
+    {
+        // Act
+        var command = ConfigCommands.CreateShowCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.Options.ShouldContain(o => o.Name == "json");
+    }
+
+    [Fact]
+    public async Task ShowDataSyncCommand_WithNoConfigFolder_ReturnsError()
+    {
+        // Arrange
+        _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult<string?>(null));
+
+        var command = ConfigCommands.CreateShowCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+        var rootCommand = new RootCommand { command };
+        rootCommand.AddGlobalOption(_configPathOption);
+        rootCommand.AddGlobalOption(_verboseOption);
+        rootCommand.AddGlobalOption(_quietOption);
+
+        // Act
+        var exitCode = await rootCommand.InvokeAsync(["show", "datasync"]);
+
+        // Assert - command completes without throwing
+        command.ShouldNotBeNull();
+    }
+
+    [Fact]
+    public void DataSyncSubcommand_Exists()
+    {
+        // Arrange
+        var command = ConfigCommands.CreateShowCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Act
+        var datasyncSubcommand = command.Subcommands.FirstOrDefault(c => c.Name == "datasync");
+
+        // Assert
+        datasyncSubcommand.ShouldNotBeNull();
+        datasyncSubcommand.Description.ShouldBe("Show DataSync configuration");
+    }
+
+    [Fact]
+    public async Task ShowConnectionsCommand_MasksNoPasswords()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            var config = new ConfigModel
+            {
+                ConnectionStrings = new ConnectionStringsSection
+                {
+                    Entries =
+                    [
+                        new ConnectionStringEntry
+                        {
+                            Name = "TestConnection",
+                            Provider = ConnectionProvider.SqlServer,
+                            Server = "localhost",
+                            Password = "secret123"
+                        }
+                    ]
+                }
+            };
+
+            _configFileService.LoadAppSettingsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(config));
+
+            var command = ConfigCommands.CreateShowCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console output
+            var originalOut = Console.Out;
+            using var writer = new StringWriter();
+            Console.SetOut(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["show", "connections"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("TestConnection");
+                output.ShouldNotContain("secret123"); // Password should not be visible
+            }
+            finally
+            {
+                Console.SetOut(originalOut);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void AllSubcommand_HasJsonOption()
+    {
+        // Arrange
+        var command = ConfigCommands.CreateShowCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Act
+        var allSubcommand = command.Subcommands.FirstOrDefault(c => c.Name == "all");
+
+        // Assert
+        allSubcommand.ShouldNotBeNull();
+        // The json option is on the parent show command
+        command.Options.ShouldContain(o => o.Name == "json");
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Cli.Tests/Commands/ConnectionCommandsTests.cs

@@ -0,0 +1,419 @@
+using System.CommandLine;
+using JdeScoping.ConfigManager.Cli.Commands;
+using JdeScoping.ConfigManager.Core.Models;
+using JdeScoping.ConfigManager.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JdeScoping.ConfigManager.Cli.Tests.Commands;
+
+public class ConnectionCommandsTests
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly IConfigFileService _configFileService;
+    private readonly IAutoDiscoveryService _autoDiscoveryService;
+    private readonly Option<string?> _configPathOption;
+    private readonly Option<bool> _verboseOption;
+    private readonly Option<bool> _quietOption;
+
+    public ConnectionCommandsTests()
+    {
+        _configFileService = Substitute.For<IConfigFileService>();
+        _autoDiscoveryService = Substitute.For<IAutoDiscoveryService>();
+
+        var services = new ServiceCollection();
+        services.AddSingleton(_configFileService);
+        services.AddSingleton(_autoDiscoveryService);
+        _serviceProvider = services.BuildServiceProvider();
+
+        _configPathOption = new Option<string?>(["--config-path", "-c"]);
+        _verboseOption = new Option<bool>(["--verbose", "-v"]);
+        _quietOption = new Option<bool>(["--quiet", "-q"]);
+    }
+
+    [Fact]
+    public void CreateListCommand_ReturnsCommand()
+    {
+        // Act
+        var command = ConnectionCommands.CreateListCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("list");
+    }
+
+    [Fact]
+    public void CreateShowCommand_ReturnsCommandWithNameArgument()
+    {
+        // Act
+        var command = ConnectionCommands.CreateShowCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("show");
+        command.Arguments.ShouldContain(a => a.Name == "name");
+    }
+
+    [Fact]
+    public void CreateAddCommand_ReturnsCommandWithOptions()
+    {
+        // Act
+        var command = ConnectionCommands.CreateAddCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("add");
+        command.Arguments.ShouldContain(a => a.Name == "name");
+        command.Options.ShouldContain(o => o.Name == "provider");
+        command.Options.ShouldContain(o => o.Name == "server");
+        command.Options.ShouldContain(o => o.Name == "database");
+        command.Options.ShouldContain(o => o.Name == "user");
+        command.Options.ShouldContain(o => o.Name == "password");
+        command.Options.ShouldContain(o => o.Name == "port");
+    }
+
+    [Fact]
+    public void CreateRemoveCommand_ReturnsCommandWithNameArgument()
+    {
+        // Act
+        var command = ConnectionCommands.CreateRemoveCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("remove");
+        command.Arguments.ShouldContain(a => a.Name == "name");
+    }
+
+    [Fact]
+    public async Task ListCommand_WithNoConfigFolder_ReturnsError()
+    {
+        // Arrange
+        _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult<string?>(null));
+
+        var command = ConnectionCommands.CreateListCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+        var rootCommand = new RootCommand { command };
+        rootCommand.AddGlobalOption(_configPathOption);
+        rootCommand.AddGlobalOption(_verboseOption);
+        rootCommand.AddGlobalOption(_quietOption);
+
+        // Act
+        var exitCode = await rootCommand.InvokeAsync(["list"]);
+
+        // Assert - command completes without throwing
+        command.ShouldNotBeNull();
+    }
+
+    [Fact]
+    public void ListCommand_HasCorrectDescription()
+    {
+        // Arrange & Act
+        var command = ConnectionCommands.CreateListCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.Description.ShouldBe("List all connection names and providers");
+    }
+
+    [Fact]
+    public async Task ShowCommand_WithValidConnection_ShowsDetailsWithMaskedPassword()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            var config = new ConfigModel
+            {
+                ConnectionStrings = new ConnectionStringsSection
+                {
+                    Entries =
+                    [
+                        new ConnectionStringEntry
+                        {
+                            Name = "TestConnection",
+                            Provider = ConnectionProvider.SqlServer,
+                            Server = "localhost",
+                            Database = "TestDb",
+                            UserId = "sa",
+                            Password = "SuperSecretPassword123!"
+                        }
+                    ]
+                }
+            };
+
+            _configFileService.LoadAppSettingsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(config));
+
+            var command = ConnectionCommands.CreateShowCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console output
+            var originalOut = Console.Out;
+            using var writer = new StringWriter();
+            Console.SetOut(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["show", "TestConnection"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("TestConnection");
+                output.ShouldContain("SqlServer");
+                output.ShouldContain("localhost");
+                output.ShouldContain("TestDb");
+                output.ShouldContain("********"); // Password should be masked
+                output.ShouldNotContain("SuperSecretPassword123!"); // Actual password should not appear
+            }
+            finally
+            {
+                Console.SetOut(originalOut);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public async Task ShowCommand_WithNonExistentConnection_ReturnsError()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            var config = new ConfigModel();
+
+            _configFileService.LoadAppSettingsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(config));
+
+            var command = ConnectionCommands.CreateShowCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console error output
+            var originalErr = Console.Error;
+            using var writer = new StringWriter();
+            Console.SetError(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["show", "NonExistent"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("not found");
+            }
+            finally
+            {
+                Console.SetError(originalErr);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public async Task AddCommand_WithNewConnection_AddsConnection()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            var config = new ConfigModel();
+
+            _configFileService.LoadAppSettingsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(config));
+
+            var command = ConnectionCommands.CreateAddCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console output
+            var originalOut = Console.Out;
+            using var writer = new StringWriter();
+            Console.SetOut(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["add", "NewConnection", "--server", "localhost", "--database", "TestDb"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("added successfully");
+                await _configFileService.Received(1).SaveAppSettingsAsync(appSettingsPath, Arg.Any<ConfigModel>(), Arg.Any<CancellationToken>());
+            }
+            finally
+            {
+                Console.SetOut(originalOut);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public async Task AddCommand_WithExistingConnection_ReturnsError()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            var config = new ConfigModel
+            {
+                ConnectionStrings = new ConnectionStringsSection
+                {
+                    Entries =
+                    [
+                        new ConnectionStringEntry { Name = "ExistingConnection" }
+                    ]
+                }
+            };
+
+            _configFileService.LoadAppSettingsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(config));
+
+            var command = ConnectionCommands.CreateAddCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console error output
+            var originalErr = Console.Error;
+            using var writer = new StringWriter();
+            Console.SetError(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["add", "ExistingConnection", "--server", "localhost"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("already exists");
+            }
+            finally
+            {
+                Console.SetError(originalErr);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void RemoveCommand_HasCorrectDescription()
+    {
+        // Arrange & Act
+        var command = ConnectionCommands.CreateRemoveCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.Description.ShouldBe("Remove a connection");
+    }
+
+    [Fact]
+    public async Task RemoveCommand_WithNonExistentConnection_ReturnsError()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var appSettingsPath = Path.Combine(tempDir, "appsettings.json");
+        File.WriteAllText(appSettingsPath, "{}");
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            var config = new ConfigModel();
+
+            _configFileService.LoadAppSettingsAsync(appSettingsPath, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(config));
+
+            var command = ConnectionCommands.CreateRemoveCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console error output
+            var originalErr = Console.Error;
+            using var writer = new StringWriter();
+            Console.SetError(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["remove", "NonExistent"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("not found");
+            }
+            finally
+            {
+                Console.SetError(originalErr);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+}

NEW/tests/Utils/JdeScoping.ConfigManager.Cli.Tests/Commands/PipelineCommandsTests.cs

@@ -0,0 +1,193 @@
+using System.CommandLine;
+using JdeScoping.ConfigManager.Cli.Commands;
+using JdeScoping.ConfigManager.Core.Services;
+using JdeScoping.DataSync.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JdeScoping.ConfigManager.Cli.Tests.Commands;
+
+public class PipelineCommandsTests
+{
+    private readonly IServiceProvider _serviceProvider;
+    private readonly IConfigFileService _configFileService;
+    private readonly IAutoDiscoveryService _autoDiscoveryService;
+    private readonly Option<string?> _configPathOption;
+    private readonly Option<bool> _verboseOption;
+    private readonly Option<bool> _quietOption;
+
+    public PipelineCommandsTests()
+    {
+        _configFileService = Substitute.For<IConfigFileService>();
+        _autoDiscoveryService = Substitute.For<IAutoDiscoveryService>();
+
+        var services = new ServiceCollection();
+        services.AddSingleton(_configFileService);
+        services.AddSingleton(_autoDiscoveryService);
+        _serviceProvider = services.BuildServiceProvider();
+
+        _configPathOption = new Option<string?>(["--config-path", "-c"]);
+        _verboseOption = new Option<bool>(["--verbose", "-v"]);
+        _quietOption = new Option<bool>(["--quiet", "-q"]);
+    }
+
+    [Fact]
+    public void CreateListCommand_ReturnsCommand()
+    {
+        // Act
+        var command = PipelineCommands.CreateListCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("list");
+    }
+
+    [Fact]
+    public void CreateShowCommand_ReturnsCommandWithNameArgument()
+    {
+        // Act
+        var command = PipelineCommands.CreateShowCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("show");
+        command.Arguments.ShouldContain(a => a.Name == "name");
+    }
+
+    [Fact]
+    public void CreateCreateCommand_ReturnsCommandWithOptions()
+    {
+        // Act
+        var command = PipelineCommands.CreateCreateCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("create");
+        command.Arguments.ShouldContain(a => a.Name == "name");
+        command.Options.ShouldContain(o => o.Name == "enabled");
+        command.Options.ShouldContain(o => o.Name == "manual-only");
+    }
+
+    [Fact]
+    public void CreateDeleteCommand_ReturnsCommandWithForceOption()
+    {
+        // Act
+        var command = PipelineCommands.CreateDeleteCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("delete");
+        command.Arguments.ShouldContain(a => a.Name == "name");
+        command.Options.ShouldContain(o => o.Name == "force");
+    }
+
+    [Fact]
+    public void CreateEnableCommand_ReturnsCommand()
+    {
+        // Act
+        var command = PipelineCommands.CreateEnableCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("enable");
+        command.Arguments.ShouldContain(a => a.Name == "name");
+    }
+
+    [Fact]
+    public void CreateDisableCommand_ReturnsCommand()
+    {
+        // Act
+        var command = PipelineCommands.CreateDisableCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+
+        // Assert
+        command.ShouldNotBeNull();
+        command.Name.ShouldBe("disable");
+        command.Arguments.ShouldContain(a => a.Name == "name");
+    }
+
+    [Fact]
+    public async Task ListCommand_WithNoConfigFolder_ReturnsError()
+    {
+        // Arrange
+        _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult<string?>(null));
+
+        var command = PipelineCommands.CreateListCommand(
+            _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+        var rootCommand = new RootCommand { command };
+        rootCommand.AddGlobalOption(_configPathOption);
+        rootCommand.AddGlobalOption(_verboseOption);
+        rootCommand.AddGlobalOption(_quietOption);
+
+        // Act
+        var exitCode = await rootCommand.InvokeAsync(["list"]);
+
+        // Assert - exit code is set via Environment.ExitCode
+        // The command should complete without throwing
+        command.ShouldNotBeNull();
+    }
+
+    [Fact]
+    public async Task ListCommand_WithValidPipelines_ReturnsSuccess()
+    {
+        // Arrange
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        var pipelinesDir = Path.Combine(tempDir, "Pipelines");
+        Directory.CreateDirectory(pipelinesDir);
+
+        try
+        {
+            _autoDiscoveryService.FindConfigFolderAsync(Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<string?>(tempDir));
+
+            var pipelines = new Dictionary<string, EtlPipelineConfig>
+            {
+                ["WorkOrder_Curr"] = new EtlPipelineConfig
+                {
+                    Name = "WorkOrder_Curr",
+                    IsEnabled = true,
+                    MassSyncIntervalMinutes = 10080,
+                    DailySyncIntervalMinutes = 1440
+                }
+            };
+
+            _configFileService.LoadAllPipelinesAsync(pipelinesDir, Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(pipelines));
+
+            var command = PipelineCommands.CreateListCommand(
+                _serviceProvider, _configPathOption, _verboseOption, _quietOption);
+            var rootCommand = new RootCommand { command };
+            rootCommand.AddGlobalOption(_configPathOption);
+            rootCommand.AddGlobalOption(_verboseOption);
+            rootCommand.AddGlobalOption(_quietOption);
+
+            // Capture console output
+            var originalOut = Console.Out;
+            using var writer = new StringWriter();
+            Console.SetOut(writer);
+
+            try
+            {
+                // Act
+                await rootCommand.InvokeAsync(["list"]);
+
+                // Assert
+                var output = writer.ToString();
+                output.ShouldContain("WorkOrder_Curr");
+            }
+            finally
+            {
+                Console.SetOut(originalOut);
+            }
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+}