acdream/src/AcDream.App/Program.cs

using AcDream.App;
using AcDream.App.Configuration;
using AcDream.App.Credentials;
using AcDream.App.Plugins;
using AcDream.App.Platform;
using AcDream.App.Rendering;
using AcDream.Core.Plugins;
using AcDream.Platform;
using Serilog;

GraphicalHostPlatformServices graphicalPlatform =
    GraphicalHostPlatformServices.Resolve();
graphicalPlatform.ConfigureWindowBackend();
ApplicationPathSet applicationPaths = graphicalPlatform.Paths;
IReadOnlyList<string> migratedConfigurationFiles =
    GraphicalLegacyConfigurationMigrator.Migrate(applicationPaths);

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.Console()
    .CreateLogger();
foreach (string migratedConfigurationFile in migratedConfigurationFiles)
{
    Log.Information(
        "migrated legacy graphical configuration to {Path}",
        migratedConfigurationFile);
}
Log.Information(
    "graphical platform {RuntimeIdentifier}; native closure: {NativeDependencies}",
    graphicalPlatform.RuntimeIdentifier,
    string.Join(
        ", ",
        graphicalPlatform.NativeDependencies.Select(
            dependency =>
                $"{dependency.Feature}={dependency.PublishedFileName}")));

// Campaign LA slice LA1: --session-config <path> is purely additive — the
// existing one positional dat-dir argument and every ACDREAM_* env var keep
// working exactly as before when the flag is absent. See
// docs/plans/2026-08-14-launcher-campaign.md LA1.
string? sessionConfigFlagPath = ExtractFlagValue(args, "--session-config");
string[] positionalArgs = WithoutFlagAndValue(args, "--session-config");

var datDirArg = positionalArgs.FirstOrDefault();
var envDatDir = Environment.GetEnvironmentVariable("ACDREAM_DAT_DIR");

// Single read of the startup-time process environment. Every downstream
// consumer (GameWindow + collaborators) reads the typed bundle, not the
// raw env vars. See docs/architecture/code-structure.md §2 Rule 4.
RuntimeOptions runtimeOptions;
if (sessionConfigFlagPath is not null)
{
    SessionConfiguration sessionConfig;
    SessionDescriptor session;
    try
    {
        (sessionConfig, session) = SessionConfigurationLoader.Load(sessionConfigFlagPath);
    }
    catch (Exception error)
        when (error is IOException
            or UnauthorizedAccessException
            or ArgumentException
            or NotSupportedException
            or System.Text.Json.JsonException
            or SessionConfigurationException)
    {
        Log.Error("--session-config invalid: {Error}", error.Message);
        return 2;
    }

    string? resolvedDatDir =
        NullIfEmpty(sessionConfig.Process?.Content?.DatDirectory)
        ?? NullIfEmpty(datDirArg)
        ?? NullIfEmpty(envDatDir);
    if (resolvedDatDir is null)
    {
        Log.Error(
            "usage: AcDream.App <dat-directory>  (or set ACDREAM_DAT_DIR, "
            + "or supply process.content.datDirectory in --session-config)");
        return 2;
    }

    AppCredentialSecret? secret = null;
    try
    {
        var resolver = new AppCredentialResolver(
            Console.In,
            applicationPaths.ConfigDirectory,
            graphicalPlatform.OperatingSystem
                == GraphicalHostOperatingSystem.Linux);
        secret = resolver.Resolve(session.Id, session.Credential);
        runtimeOptions = RuntimeOptions.FromSessionConfig(
            resolvedDatDir,
            Environment.GetEnvironmentVariable,
            sessionConfigFlagPath,
            sessionConfig,
            session,
            secret.Reveal());
    }
    catch (AppCredentialException error)
    {
        Log.Error("--session-config credential unavailable: {Error}", error.Message);
        return 2;
    }
    finally
    {
        secret?.Dispose();
    }

    // Env-var flow untouched when the flag is absent; when both are present
    // the flag wins — this line makes that explicit rather than silent.
    Log.Information(
        "--session-config {Path} present; overriding ACDREAM_LIVE*/ACDREAM_TEST_* "
        + "env-var live-session settings",
        sessionConfigFlagPath);
}
else
{
    var datDir = datDirArg ?? envDatDir;
    if (string.IsNullOrWhiteSpace(datDir))
    {
        Log.Error("usage: AcDream.App <dat-directory>  (or set ACDREAM_DAT_DIR)");
        return 2;
    }
    runtimeOptions = RuntimeOptions.FromEnvironment(datDir);
}

if (runtimeOptions.DevTools)
{
    Log.Information(
        "ACDREAM_DEVTOOLS=1: the ImGui developer UI was removed at Campaign V " +
        "slice V11 along with the OpenGL backend it required; this flag now " +
        "only selects the optional Vulkan validation/debug-utils extensions.");
}

var worldGameState = new AcDream.Core.Plugins.WorldGameState();
var worldEvents = new AcDream.Core.Plugins.WorldEvents();
var uiRegistry = new AcDream.App.Plugins.BufferedUiRegistry();
using var window = new GameWindow(
    runtimeOptions,
    worldGameState,
    worldEvents,
    uiRegistry,
    graphicalPlatform);
var host = new AppPluginHost(
    new SerilogAdapter(Log.Logger),
    worldGameState,
    worldEvents,
    window.Selection,
    uiRegistry);

var loaded = new List<LoadedPlugin>();
var loadedPluginIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
StringComparer pathComparer =
    graphicalPlatform.OperatingSystem
        == GraphicalHostOperatingSystem.Windows
        ? StringComparer.OrdinalIgnoreCase
        : StringComparer.Ordinal;
string[] pluginRoots =
[
    .. new[]
    {
        Path.Combine(AppContext.BaseDirectory, "plugins"),
        applicationPaths.PluginsDirectory,
    }.Distinct(pathComparer),
];

foreach (string pluginsDir in pluginRoots)
{
    Log.Information("scanning plugins in {PluginsDir}", pluginsDir);
    foreach (var result in PluginDiscovery.Scan(pluginsDir))
    {
        if (!result.Success)
        {
            Log.Warning(
                "plugin discovery failed for {Dir}: {Error}",
                result.PluginDirectory,
                result.Error);
            continue;
        }

        if (loadedPluginIds.Contains(result.Manifest!.Id))
        {
            Log.Warning(
                "skipping duplicate plugin id {Id} from {Dir}",
                result.Manifest.Id,
                result.PluginDirectory);
            continue;
        }

        var loadResult = PluginLoader.Load(
            result.PluginDirectory,
            result.Manifest,
            host);
        if (!loadResult.Success)
        {
            Log.Warning(
                "plugin load failed for {Id}: {Error}",
                result.Manifest.Id,
                loadResult.Error);
            continue;
        }

        loadedPluginIds.Add(result.Manifest.Id);
        loaded.Add(loadResult);
        Log.Information(
            "loaded plugin {Id} ({DisplayName})",
            result.Manifest.Id,
            result.Manifest.DisplayName);
    }
}

try
{
    foreach (var plugin in loaded)
    {
        try { plugin.Plugin!.Enable(); }
        catch (Exception ex) { Log.Error(ex, "plugin enable failed: {Id}", plugin.Manifest.Id); }
    }

    try
    {
        window.Run();
    }
    catch (NotSupportedException error)
    {
        Log.Error("{GraphicalStartupFailure}", error.Message);
        return 4;
    }
}
finally
{
    foreach (var plugin in loaded)
    {
        try { plugin.Plugin!.Disable(); }
        catch (Exception ex) { Log.Error(ex, "plugin disable failed: {Id}", plugin.Manifest.Id); }
    }
    Log.CloseAndFlush();
}

return 0;

// Campaign LA slice LA1: --session-config <path> parsing helpers. Kept
// local/minimal rather than a general-purpose CLI parser — App has exactly
// one optional flag-with-value today; the positional dat-dir argument must
// stay untouched by its presence (see the comment above the flag parse).
static string? ExtractFlagValue(string[] arguments, string flag)
{
    for (int i = 0; i < arguments.Length - 1; i++)
    {
        if (string.Equals(arguments[i], flag, StringComparison.Ordinal))
            return arguments[i + 1];
    }
    return null;
}

static string[] WithoutFlagAndValue(string[] arguments, string flag)
{
    var result = new List<string>(arguments.Length);
    for (int i = 0; i < arguments.Length; i++)
    {
        if (string.Equals(arguments[i], flag, StringComparison.Ordinal))
        {
            i++; // also skip the flag's value
            continue;
        }
        result.Add(arguments[i]);
    }
    return [.. result];
}

static string? NullIfEmpty(string? value) =>
    string.IsNullOrWhiteSpace(value) ? null : value;