Add client/server CLI on shared Plugin Manager infrastructure

.github/workflows/ci.yml

@@ -8,6 +8,7 @@ on:
     branches:
         - 'main'
         - 'series/*'
+        - 'feature/dll-validation'
 
 env:
   DOTNET_VERSION: '10.x'
@@ -56,6 +57,21 @@ jobs:
     - name: Run Scanner Configuration Tests
       run: dotnet test -c ${{ matrix.configuration }} .\UnchainedLauncher.PakScannerApp.Tests --logger:"console;verbosity=detailed"
 
+    - name: Run CLI Tests
+      run: dotnet test -c ${{ matrix.configuration }} .\UnchainedLauncher.CLI.Tests --logger:"console;verbosity=detailed"
+
+    - name: Run Plugin Manager Tests
+      run: dotnet test -c ${{ matrix.configuration }} .\UnchainedLauncher.GUI.Tests.Unit --logger:"console;verbosity=detailed"
+
+    - name: Package CLI binaries
+      run: dotnet publish UnchainedLauncher.CLI -c ${{ matrix.configuration }} -r win-x64 --self-contained true -o out-cli/
+
+    - name: Upload CLI Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: UnchainedLauncher_CLI_${{ matrix.configuration }}_${{ github.sha }}
+        path: out-cli
+
     - name: Package ${{ matrix.configuration }} binaries
       run: dotnet publish UnchainedLauncher.GUI -c ${{ matrix.configuration}} -o out/
 

README.md

@@ -49,6 +49,12 @@ Join the [Chivalry 2 Unchained community on Discord](https://discord.gg/chiv2unc
 4. Put the downloaded Unchained `Chivalry2Launcher.exe` in place of the old one.
 5. Launch the game normally (either from your steam library or from Epic Games Store).
 
+## Launcher CLI
+
+`UnchainedLauncher.CLI` launches clients or servers and depends on Core, not WPF.
+See [the CLI guide](UnchainedLauncher.CLI/README.md) for building, launch options,
+registry formats, YAML configuration, and the live server dashboard.
+
 ## License
 
 This project is licensed under the terms of the [LICENSE](LICENSE) file.

StructuredINI/StructuredINIWriter.cs

@@ -8,6 +8,12 @@ public class StructuredINIWriter {
         private readonly List<string> _sectionOrder = new();
         private readonly Dictionary<string, string> _bufferedSections = new(StringComparer.OrdinalIgnoreCase);
 
+        // Buffer only caller-selected keys; WriteOut preserves all other keys.
+        public void BufferSection(string sectionName, IEnumerable<KeyValuePair<string, string>> entries) {
+            if (!_bufferedSections.ContainsKey(sectionName)) _sectionOrder.Add(sectionName);
+            _bufferedSections[sectionName] = $"[{sectionName}]\n" + string.Join("\n", entries.Select(entry => $"{entry.Key}={entry.Value}"));
+        }
+
         public static bool Save<T>(string path, T t) {
             var writer = new StructuredINIWriter();
             return writer.BufferWrite(t) && writer.WriteOut(path);

UnchainedLauncher.CLI.Tests/ArgumentBoundaryTests.cs

@@ -0,0 +1,163 @@
+using System.Diagnostics;
+using System.Text.Json;
+using UnchainedLauncher.Core.Services.Processes;
+using UnchainedLauncher.Core.Services.Processes.Chivalry;
+using UnchainedLauncher.Core.Services.Processes.Chivalry.LaunchPreparers;
+using UnchainedLauncher.Core.Utilities;
+using Xunit;
+using static LanguageExt.Prelude;
+
+namespace UnchainedLauncher.CLI.Tests;
+
+public sealed class ArgumentBoundaryTests : IDisposable {
+    private readonly string _directory = Path.Combine(
+        Environment.GetEnvironmentVariable("TMPDIR") ?? (OperatingSystem.IsLinux() ? "/tmp/opencode" : Path.GetTempPath()), "argument-tests-" + Guid.NewGuid().ToString("N"));
+    private static string Probe => Path.Combine(AppContext.BaseDirectory, "argument-probe",
+        OperatingSystem.IsWindows() ? "ArgumentProbe.exe" : "ArgumentProbe");
+
+    public ArgumentBoundaryTests() => Directory.CreateDirectory(_directory);
+    public void Dispose() => Directory.Delete(_directory, recursive: true);
+
+    public static IEnumerable<object[]> ForwardedArguments() {
+        string[] arguments = ["", "\"", "a\"b", "a\\\"b", "a\\\\\"b", "\\", "tail\\\\", "space tail\\",
+            "-UserDir=C:\\Server Profiles\\", "tab\tvalue", "line\nbreak", "line\r\nbreak", " \t\n ",
+            "--", "-AUTH_PASSWORD=secret \"quoted\"\\", "& echo injected; $(echo injected) | >file"];
+        foreach (var command in new[] { "client", "server" })
+            foreach (var yaml in new[] { false, true })
+                foreach (var argument in arguments)
+                    yield return [command, yaml, argument];
+    }
+
+    [Theory]
+    [MemberData(nameof(ForwardedArguments))]
+    public async Task ForwardingPreservesExactProcessArguments(string command, bool yaml, string argument) {
+        // Repeat the value so YAML exercises both shared and command-specific forwarding.
+        var options = Parse(command, yaml, [argument, argument, "sentinel-after-forwarded"]);
+        var expected = new List<string> { "TBL" };
+        if (command == "server") expected.Add("-server");
+        if (command == "server") expected.AddRange(FirstRunArguments);
+        expected.AddRange([argument, argument, "sentinel-after-forwarded", "-saveddirsuffix=" + options.Shared.SavedDirSuffix, "-unchained"]);
+        if (command == "server") expected.AddRange(DefaultServerArguments());
+        expected.AddRange(["--server-browser-backend", "https://servers.polehammer.net"]);
+
+        // Independent .NET ArgumentList control: no local escaping or parsing is used to form expected argv.
+        Assert.Equal(expected, await CaptureControl(expected));
+        Assert.Equal(expected, await CaptureLaunch(options.ToLaunchOptions()));
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task GeneratedServerValuesAlsoPreserveBoundaries(bool yaml) {
+        const string value = "quoted \"name\"\\\tline\nend\\";
+        var options = Assert.IsType<ServerOptions>(Parse("server", yaml, [], value));
+        var expected = new List<string> { "TBL", "-server" };
+        expected.AddRange(FirstRunArguments);
+        expected.AddRange(["-saveddirsuffix=UnchainedCLI", "-unchained"]);
+        expected.AddRange(DefaultServerArguments(value, value, value));
+        // Password follows the headless/backend flags, before local IP and desync options.
+        expected.Insert(expected.IndexOf("--local-ip"), "ServerPassword=" + value);
+        expected.AddRange(["--server-browser-backend", "https://servers.polehammer.net"]);
+        Assert.Equal(expected, await CaptureControl(expected));
+        Assert.Equal(expected, await CaptureLaunch(options.ToLaunchOptions()));
+    }
+
+    [Fact]
+    public async Task NativePakDirectoryDoesNotRequireAProcessArgument() {
+        var installation = Path.Combine(_directory, "Game With Spaces");
+        var options = CliLaunchOptions.Parse(["server", "--chivalry2-path", installation, "--platform", "Steam", "--local-ip", "127.0.0.1"]);
+        var expected = new List<string> { "TBL", "-server" };
+        expected.AddRange(FirstRunArguments);
+        expected.AddRange(["-saveddirsuffix=UnchainedCLI", "-unchained"]);
+        expected.AddRange(DefaultServerArguments());
+        expected.AddRange(["--server-browser-backend", "https://servers.polehammer.net"]);
+        Assert.Equal(expected, await CaptureLaunch(options.ToLaunchOptions()));
+    }
+
+    [Theory]
+    [InlineData("  SomeStructuredThing(foo, bar, 10, baz, false)  ")]
+    [InlineData("quoted \"value\" and trailing slash\\")]
+    [InlineData("line\nbreak\tand & | > shell text")]
+    public async Task RawIniOverridesPreserveExactContentsAsOneArgument(string value) {
+        var path = Path.Combine(_directory, "raw.yaml");
+        File.WriteAllText(path, $"chiv2-path: {JsonSerializer.Serialize(_directory)}\nplatform: Steam\nserver:\n" +
+            "  local-ip: 127.0.0.1\n  ini:\n    Game:\n      /Script/TBL.TBLGameMode:\n" +
+            $"        Custom: {{type: raw, value: {JsonSerializer.Serialize(value)}}}\n");
+        var options = CliLaunchOptions.Parse(["server", "--config-path", path]);
+        var expected = new List<string> { "TBL", "-server" };
+        expected.AddRange(FirstRunArguments);
+        expected.Add("-ini:Game:[/Script/TBL.TBLGameMode]:Custom=" + value);
+        expected.AddRange(["-saveddirsuffix=UnchainedCLI", "-unchained"]);
+        expected.AddRange(DefaultServerArguments());
+        expected.AddRange(["--server-browser-backend", "https://servers.polehammer.net"]);
+        Assert.Equal(expected, await CaptureControl(expected));
+        Assert.Equal(expected, await CaptureLaunch(options.ToLaunchOptions()));
+    }
+
+    private CliLaunchOptions Parse(string command, bool yaml, string[] arguments, string? serverValue = null) {
+        if (!yaml) return CliLaunchOptions.Parse([command, "--chivalry2-path", _directory, "--platform", "Steam",
+            .. command == "server" ? new[] { "--local-ip", "127.0.0.1" } : [],
+            .. serverValue is null ? System.Array.Empty<string>() : ["--name", serverValue, "--description", serverValue,
+                "--starting-map", serverValue, "--password", serverValue], "--", .. arguments]);
+        var path = Path.Combine(_directory, "launch.yaml");
+        // JSON-quoted strings are YAML scalars; cover both shared and command-specific game-args lists.
+        File.WriteAllText(path, $"chiv2-path: {JsonSerializer.Serialize(_directory)}\nplatform: Steam\n" +
+            $"game-args: {JsonSerializer.Serialize(arguments.Take(1))}\n{command}:\n" +
+            (command == "server" ? "  local-ip: 127.0.0.1\n" : "") +
+            (serverValue is null ? "" : string.Concat(new[] { "name", "description", "starting-map", "password" }
+                .Select(key => $"  {key}: {JsonSerializer.Serialize(serverValue)}\n"))) +
+            $"  game-args: {JsonSerializer.Serialize(arguments.Skip(1))}\n");
+        return CliLaunchOptions.Parse([command, "--config-path", path]);
+    }
+
+    private static readonly string[] FirstRunArguments = [
+        "-ini:Game:[/Script/TBL.TBLTitleScreen]:bSavedHasAgreedToTOS=True",
+        "-ini:Game:[/Script/TBL.TBLGameInstance]:FirstLoadCompleted=True"
+    ];
+
+    private static IEnumerable<string> DefaultServerArguments(string name = "Unchained Server",
+        string description = "", string map = "FFA_Courtyard") => [
+        "-ini:Game:[/Script/TBL.TBLGameMode]:ServerName=" + name, "--next-map-name", map,
+        "Port=7777", "GameServerPingPort=3075", "GameServerQueryPort=7071", "-rcon", "9001",
+        "--server-browser-description", description, "--motd", description, "--censor-mode", "none",
+        "-nullrhi", "-unattended", "-nosound", "--use-backend-banlist", "--local-ip", "127.0.0.1", "--desync-patch"
+    ];
+
+    private async Task<string[]> CaptureLaunch(LaunchOptions options) {
+        var output = Path.Combine(_directory, "launch-result.json");
+        Directory.CreateDirectory(Path.Combine(_directory, FilePaths.BinDir));
+        var preparer = Chivalry2LaunchPreparer.Create<LaunchOptions>(opts => Some(opts with {
+            LaunchArgs = ArgumentEscaper.Escape(output) + " " + opts.LaunchArgs
+        }));
+        // Use the actual Core launcher and ProcessLauncher (not a string-capturing mock).
+        var launcher = new UnchainedChivalry2Launcher(preparer, new ProcessLauncher(Probe),
+            _directory, new NoOpInjector());
+        var result = await launcher.TryLaunch(options);
+        using var process = result.Match(Left: error => throw new InvalidOperationException(error.Message), Right: process => process);
+        return await ReadResult(process, output);
+    }
+
+    private async Task<string[]> CaptureControl(IEnumerable<string> arguments) {
+        var output = Path.Combine(_directory, "control-result.json");
+        var start = new ProcessStartInfo(Probe) { UseShellExecute = false };
+        start.ArgumentList.Add(output);
+        foreach (var argument in arguments) start.ArgumentList.Add(argument);
+        using var process = Process.Start(start)!;
+        return await ReadResult(process, output);
+    }
+
+    private static async Task<string[]> ReadResult(Process process, string output) {
+        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(20));
+        try { await process.WaitForExitAsync(timeout.Token); }
+        catch {
+            if (!process.HasExited) process.Kill(entireProcessTree: true);
+            throw;
+        }
+        Assert.Equal(0, process.ExitCode);
+        return JsonSerializer.Deserialize<string[]>(await File.ReadAllTextAsync(output))!;
+    }
+
+    private sealed class NoOpInjector : IProcessInjector {
+        public bool Inject(Process process) => true;
+    }
+}

UnchainedLauncher.CLI.Tests/ArgumentProbe/.gitignore

@@ -0,0 +1,2 @@
+/bin/
+/obj/

UnchainedLauncher.CLI.Tests/ArgumentProbe/ArgumentProbe.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+</Project>

UnchainedLauncher.CLI.Tests/ArgumentProbe/Program.cs

@@ -0,0 +1,4 @@
+using System.Text.Json;
+
+// The first argument is the result file; all remaining arguments come from the launcher.
+File.WriteAllText(args[0], JsonSerializer.Serialize(args.Skip(1).ToArray()));

UnchainedLauncher.CLI.Tests/CommandLineOptionsTests.cs

@@ -0,0 +1,70 @@
+using Xunit;
+
+namespace UnchainedLauncher.CLI.Tests;
+
+public class CommandLineOptionsTests {
+    [Theory]
+    [InlineData("server")]
+    [InlineData("client")]
+    public void GeneratedHelpIsSpecificToTheCommand(string command) {
+        var options = CliLaunchOptions.Parse([command, "--help"]);
+        Assert.True(options.Help);
+        Assert.Contains("--chivalry2-path", options.HelpText);
+        Assert.Contains("--config-path", options.HelpText);
+        Assert.Equal(command == "server", options.HelpText.Contains("--no-desync-patch"));
+        Assert.Equal(command == "server", options.HelpText.Contains("--discord-bot-token"));
+    }
+
+    [Fact]
+    public void RootHelpListsBothCommands() {
+        var options = CliLaunchOptions.Parse([]);
+        Assert.True(options.Help);
+        Assert.Contains("server", options.HelpText);
+        Assert.Contains("client", options.HelpText);
+    }
+
+    [Theory]
+    [InlineData("--no-desync-patch")]
+    [InlineData("--name=test")]
+    [InlineData("--game-port=7778")]
+    [InlineData("--no-tui")]
+    public void ServerSpecificOptionsAreRejectedByClient(string flag) {
+        Assert.Throws<ArgumentException>(() => CliLaunchOptions.Parse([
+            "client", "--chivalry2-path", ".", "--platform", "Steam", flag
+        ]));
+    }
+
+    [Theory]
+    [InlineData("--no-desync-patch")]
+    [InlineData("--no-plugin-update")]
+    [InlineData("--name=test")]
+    public void SingletonOptionsCannotBeRepeated(string flag) {
+        Assert.Throws<ArgumentException>(() => CliLaunchOptions.Parse([
+            "server", "--chivalry2-path", ".", "--platform", "Steam", flag, flag
+        ]));
+    }
+
+    [Fact]
+    public void HelpAndInvalidCliAlsoUseOneLibraryParse() {
+        foreach (var args in new string[][] { [], ["client", "--help"], ["server", "--platform=Invalid"] }) {
+            var calls = 0;
+            CliCommandOptions Parse() => CommandLineOptions.Parse(args, (root, tokens, configuration) => {
+                calls++;
+                return root.Parse(tokens, configuration);
+            });
+            if (args.Contains("--platform=Invalid")) Assert.Throws<ArgumentException>(Parse);
+            else Assert.True(Parse().Help);
+            Assert.Equal(1, calls);
+        }
+    }
+
+    [Fact]
+    public void GameArgumentsMustFollowSeparatorAndArePreservedExactly() {
+        string[] prefix = ["server", "--chivalry2-path", ".", "--platform", "Steam"];
+        Assert.Throws<ArgumentException>(() => CliLaunchOptions.Parse([.. prefix, "unexpected"]));
+        string[] forwarded = ["--help", "--config-path", "not-a-launcher-config", "-AUTH_PASSWORD=with spaces", "", "@game-file"];
+        var options = CliLaunchOptions.Parse([.. prefix, "--", .. forwarded]);
+        Assert.False(options.Help);
+        Assert.Equal(forwarded, options.GameArguments);
+    }
+}