Fix skyrim start issues

src/Games/NexusMods.Games.BethesdaGameStudios/PluginOrderFile.cs

@@ -146,6 +146,7 @@ public Hash GetFingerprint(ModFilePair self, Plan plan)
                 fingerprinter.Add(f.DataStoreId);
             });
 
+
         return fingerprinter.Digest();
     }
 }

src/Games/NexusMods.Games.BethesdaGameStudios/Services.cs

@@ -15,6 +15,8 @@ public static IServiceCollection AddBethesdaGameStudios(this IServiceCollection
         services.AddAllSingleton<IModInstaller, SkyrimInstaller>();
         services.AddAllSingleton<IGame, SkyrimSpecialEdition>();
         services.AddAllSingleton<IGame, SkyrimLegendaryEdition>();
+        services.AddSingleton<ITool, RunGameTool<SkyrimLegendaryEdition>>();
+        services.AddSingleton<ITool, RunGameTool<SkyrimSpecialEdition>>();
         services.AddAllSingleton<IFileAnalyzer, PluginAnalyzer>();
         services.AddAllSingleton<ITypeFinder, TypeFinder>();
         return services;

src/NexusMods.DataModel/Games/RunGameTool.cs

@@ -1,5 +1,8 @@
 using System.Diagnostics;
+using System.Text;
+using CliWrap;
 using Microsoft.Extensions.Logging;
+using NexusMods.Common;
 using NexusMods.DataModel.Loadouts;
 using NexusMods.Paths;
 
@@ -22,15 +25,17 @@
 {
     private readonly ILogger<RunGameTool<T>> _logger;
     private readonly T _game;
+    private readonly IProcessFactory _processFactory;
 
     /// <summary/>
     /// <param name="logger">The logger used to log execution.</param>
     /// <param name="game">The game to execute.</param>
     /// <remarks>
     ///    This constructor is usually called from DI.
     /// </remarks>
-    public RunGameTool(ILogger<RunGameTool<T>> logger, T game)
+    public RunGameTool(ILogger<RunGameTool<T>> logger, T game, IProcessFactory processFactory)
     {
+        _processFactory = processFactory;
         _game = game;
         _logger = logger;
     }
@@ -47,10 +52,18 @@
         var program = _game.GetPrimaryFile(loadout.Installation.Store).Combine(loadout.Installation.Locations[GameFolderType.Game]);
         _logger.LogInformation("Running {Program}", program);
 
-        // TODO: use IProcessFactory
-        var psi = new ProcessStartInfo(program.ToString());
-        var process = Process.Start(psi);
-        await process!.WaitForExitAsync();
+        var stdOut = new StringBuilder();
+        var stdErr = new StringBuilder();
+        var command = new Command(program.ToString())
+            .WithStandardOutputPipe(PipeTarget.ToStringBuilder(stdOut))
+            .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErr))
+            .WithValidation(CommandResultValidation.None)
+            .WithWorkingDirectory(program.Parent.ToString());
+
+
+        var result = await _processFactory.ExecuteAsync(command);
+        if (result.ExitCode != 0)
+            _logger.LogError("While Running {Filename} : {Error} {Output}", program, stdErr, stdOut);
 
         _logger.LogInformation("Finished running {Program}", program);
     }

src/NexusMods.DataModel/Loadouts/LoadoutManager.cs

@@ -1,18 +1,16 @@
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.IO.Compression;
 using Microsoft.Extensions.Logging;
 using NexusMods.Common;
 using NexusMods.DataModel.Abstractions;
 using NexusMods.DataModel.Abstractions.Ids;
-using NexusMods.DataModel.ArchiveContents;
 using NexusMods.DataModel.Extensions;
 using NexusMods.DataModel.Games;
 using NexusMods.DataModel.Interprocess.Jobs;
-using NexusMods.DataModel.Interprocess.Messages;
 using NexusMods.DataModel.Loadouts.Cursors;
 using NexusMods.DataModel.ModInstallers;
 using NexusMods.DataModel.Loadouts.Markers;
+using NexusMods.DataModel.Loadouts.ModFiles;
 using NexusMods.DataModel.Loadouts.Mods;
 using NexusMods.DataModel.RateLimiting;
 using NexusMods.DataModel.Sorting.Rules;
@@ -131,7 +129,8 @@ public async Task<LoadoutMarker> ManageGameAsync(GameInstallation installation,
             Files = new EntityDictionary<ModFileId, AModFile>(Store),
             Version = installation.Version.ToString(),
             ModCategory = Mod.GameFilesCategory,
-            SortRules = ImmutableList<ISortRule<Mod, ModId>>.Empty.Add(new First<Mod, ModId>())
+            SortRules = ImmutableList<ISortRule<Mod, ModId>>.Empty.Add(new First<Mod, ModId>()),
+            Enabled = true
         }.WithPersist(Store);
 
         var loadoutId = LoadoutId.Create();
@@ -206,7 +205,16 @@ private async Task IndexAndAddGameFiles(GameInstallation installation,
         }
 
         managementJob.Progress = new Percent(0.5);
-        gameFiles.AddRange(installation.Game.GetGameFiles(installation, Store));
+        var generatedFiles = installation.Game.GetGameFiles(installation, Store).ToArray();
+
+        // Generated files should override any existing files that were indexed
+        var byTo = gameFiles.OfType<IToFile>().ToLookup(l => l.To);
+        foreach (var generatedFile in generatedFiles.OfType<IToFile>())
+        {
+            foreach (var conflict in byTo[generatedFile.To])
+                gameFiles.Remove((AModFile)conflict);
+        }
+        gameFiles.AddRange(generatedFiles);
 
         Registry.Alter(loadout.LoadoutId, mod.Id, "Add game files",
             m => m! with

src/NexusMods.DataModel/Loadouts/LoadoutSyncronizer.cs

@@ -91,10 +91,15 @@ public LoadoutSynchronizer(ILogger<LoadoutSynchronizer> logger,
     /// <returns></returns>
     public async Task<IEnumerable<Mod>> SortMods(Loadout loadout)
     {
-        var modRules = await loadout.Mods.Values
+        var mods = loadout.Mods.Values.Where(mod => mod.Enabled).ToList();
+        _logger.LogInformation("Sorting {ModCount} mods in loadout {LoadoutName}", mods.Count, loadout.Name);
+        var modRules = await mods
             .SelectAsync(async mod => (mod.Id, await ModSortRules(loadout, mod).ToListAsync()))
             .ToDictionaryAsync(r => r.Id, r => r.Item2);
-        var sorted = Sorter.Sort<Mod, ModId>(loadout.Mods.Values.ToList(), m => m.Id, m => modRules[m.Id]);
+        if (modRules.Count == 0)
+            return Array.Empty<Mod>();
+
+        var sorted = Sorter.Sort<Mod, ModId>(mods, m => m.Id, m => modRules[m.Id]);
         return sorted;
     }
 
@@ -288,20 +293,6 @@ private async ValueTask EmitReplacePlan(List<IApplyStep> plan, HashedEntry exist
         await EmitCreatePlan(plan, pair, tmpPlan, existing.Path);
     }
 
-    /// <summary>
-    /// Gets the metadata for the given file, if the file is from an archive then the metadata is returned
-    /// </summary>
-    /// <param name="file"></param>
-    /// <param name="path"></param>
-    /// <returns></returns>
-    /// <exception cref="NotImplementedException"></exception>
-    public ValueTask<FileMetaData?> GetMetaData(AModFile file, AbsolutePath path)
-    {
-        if (file is IFromArchive fa)
-            return ValueTask.FromResult<FileMetaData?>(new FileMetaData(path, fa.Hash, fa.Size));
-        throw new NotImplementedException();
-    }
-
     /// <summary>
     /// Compares the game folders to the loadout and returns a plan of what needs to be done to make the loadout match the game folders
     /// </summary>
@@ -327,11 +318,12 @@ public async ValueTask<IngestPlan> MakeIngestPlan(Loadout loadout, Func<Absolute
 
             if (flattenedLoadout.TryGetValue(gamePath, out var planFile))
             {
-                var planMetadata = await GetMetaData(planFile.File, existing.Path);
-                if (planMetadata == null || planMetadata.Hash != existing.Hash || planMetadata.Size != existing.Size)
+                if (planFile.File is IFromArchive fa && (fa.Hash != existing.Hash || fa.Size != existing.Size))
                 {
                     await EmitIngestReplacePlan(plan, planFile, existing);
                 }
+                // TODO: Fix this, it doesn't contain support for IGeneratedFile, 
+                // once we re-design apply/ingest this should be implemented
                 continue;
             }
 

src/NexusMods.DataModel/NxArchiveManager.cs

@@ -88,14 +88,18 @@ private unsafe void UpdateIndexes(NxUnpacker unpacker, (IStreamFactory, Hash, Si
         AbsolutePath finalPath)
     {
         Span<byte> buffer = stackalloc byte[sizeof(NativeFileEntryV1)];
+
+        var paths = unpacker.GetPathedFileEntries();
+
         foreach (var entry in unpacker.GetFileEntriesRaw())
         {
             fixed (byte* ptr = buffer)
             {
                 var writer = new LittleEndianWriter(ptr);
                 entry.WriteAsV1(ref writer);
-
-                var dbId = IdFor((Hash)entry.Hash, guid);
+
+                var hash = Hash.FromHex(paths[entry.FilePathIndex].FileName);
+                var dbId = IdFor(hash, guid);
                 var dbEntry = new ArchivedFiles
                 {
                     File = finalPath.FileName,
@@ -136,13 +140,21 @@ public async Task ExtractFiles(IEnumerable<(Hash Src, AbsolutePath Dest)> files,
             await using var file = group.Key.Read();
             var provider = new FromStreamProvider(file);
             var unpacker = new NxUnpacker(provider);
-            
+
             var toExtract = group
                 .Select(entry =>
                     (IOutputDataProvider)new OutputFileProvider(entry.Dest.Parent.GetFullPath(), entry.Dest.FileName, entry.FileEntry))
                 .ToArray();
 
-            unpacker.ExtractFiles(toExtract, settings);
+            try
+            {
+                unpacker.ExtractFiles(toExtract, settings);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e);
+                throw;
+            }
 
             foreach (var toDispose in toExtract)
             {

src/NexusMods.DataModel/Services.cs

@@ -51,7 +51,7 @@ IDataModelSettings Settings(IServiceProvider provider)
         coll.AddSingleton(typeof(EntityLinkConverter<>));
 
         coll.AddSingleton<IDataStore, SqliteDataStore>();
-        coll.AddAllSingleton<IArchiveManager, NxArchiveManager>();
+        coll.AddAllSingleton<IArchiveManager, ZipArchiveManager>();
         coll.AddAllSingleton<IResource, IResource<FileHashCache, Size>>(s =>
             new Resource<FileHashCache, Size>("File Hashing",
                 Settings(s).MaxHashingJobs,

src/NexusMods.DataModel/ToolManager.cs

@@ -69,7 +69,12 @@ public async Task<Loadout> RunTool(ITool tool, Loadout loadout, ModId? generated
             generatedFilesMod = mod.Id;
         }
 
-        var ingestPlan = await _loadoutSynchronizer.MakeIngestPlan(loadout, _ => generatedFilesMod.Value, token);
-        return await _loadoutSynchronizer.Ingest(ingestPlan, $"Updating {tool.Name} Generated Files"); 
+        // We don't yet properly support ingesting data. The issue is if a bad apply occurs, the ingest can 
+        // delete files we don't yet have a way of recreating. Also we have no way to create branches, roll back the 
+        // ingest, etc. in the loadout. So for now we just don't ingest.
+
+        //var ingestPlan = await _loadoutSynchronizer.MakeIngestPlan(loadout, _ => generatedFilesMod.Value, token);
+        //return await _loadoutSynchronizer.Ingest(ingestPlan, $"Updating {tool.Name} Generated Files");
+        return loadout;
     }
 }

tests/Games/NexusMods.Games.BethesdaGameStudios.Tests/Assets/DownloadableMods/PluginTest/manifest.json

@@ -0,0 +1,5 @@
+{
+  "FilePath": "plugin_test.7z",
+  "Source": "RealFileSystem",
+  "Name": "Plugin Test"
+}

tests/Games/NexusMods.Games.BethesdaGameStudios.Tests/Assets/DownloadableMods/SkyrimBase/manifest.json

@@ -0,0 +1,5 @@
+{
+  "FilePath": "Skyrim.7z",
+  "Source": "RealFileSystem",
+  "Name": "Skyrim Base"
+}

tests/Games/NexusMods.Games.BethesdaGameStudios.Tests/NexusMods.Games.BethesdaGameStudios.Tests.csproj

@@ -14,5 +14,11 @@
         <None Update="Assets\**">
             <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
         </None>
+        <None Update="Assets\DownloadableMods\PluginTest\manifest.json">
+          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </None>
+        <None Update="Assets\DownloadableMods\SkyrimBase\manifest.json">
+          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </None>
     </ItemGroup>
 </Project>

tests/Games/NexusMods.Games.BethesdaGameStudios.Tests/SkyrimSpecialEditionTests/SkyrimSpecialEditionTests.cs

@@ -2,25 +2,32 @@
 using System.Text;
 using System.Text.Json;
 using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
 using NexusMods.DataModel.Abstractions;
+using NexusMods.DataModel.Extensions;
 using NexusMods.DataModel.Loadouts;
+using NexusMods.DataModel.Loadouts.LoadoutSynchronizerDTOs;
 using NexusMods.DataModel.Loadouts.ModFiles;
 using NexusMods.DataModel.Loadouts.Mods;
 using NexusMods.Games.TestFramework;
 using NexusMods.Hashing.xxHash64;
 using NexusMods.Paths;
 using NexusMods.Paths.Extensions;
+using Noggog;
 
 namespace NexusMods.Games.BethesdaGameStudios.Tests.SkyrimSpecialEditionTests;
 
 public class SkyrimSpecialEditionTests : AGameTest<SkyrimSpecialEdition>
 {
+    private readonly TestModDownloader _downloader;
+
     /// <summary>
     /// DI Constructor
     /// </summary>
     /// <param name="serviceProvider"></param>
     public SkyrimSpecialEditionTests(IServiceProvider serviceProvider) : base(serviceProvider)
     {
+        _downloader = serviceProvider.GetRequiredService<TestModDownloader>();
 
     }
 
@@ -195,4 +202,87 @@ public async Task CanGeneratePluginsFile()
                     opt => opt.WithStrictOrdering());
         }
     }
+
+    [Fact]
+    public async Task EnablingAndDisablingModsModifiesThePluginsFile()
+    {
+        var loadout = await CreateLoadout(indexGameFiles: false);
+
+        var pluginFile = (from mod in loadout.Value.Mods.Values
+                            from file in mod.Files.Values
+                            where file is PluginOrderFile
+                            select file)
+            .OfType<PluginOrderFile>()
+            .First();
+
+
+        var pluginFilePath = pluginFile.To.CombineChecked(loadout.Value.Installation);
+
+        var path = BethesdaTestHelpers.GetDownloadableModFolder(FileSystem, "SkyrimBase");
+        var downloaded = await _downloader.DownloadFromManifestAsync(path, FileSystem);
+
+        var skyrimBase = await InstallModFromArchiveIntoLoadout(
+            loadout,
+            downloaded.Path,
+            downloaded.Manifest.Name);
+
+        await Apply(loadout.Value);
+
+        pluginFilePath.FileExists.Should().BeTrue("the loadout is applied");
+
+
+        var text = await GetPluginOrder(pluginFilePath);
+
+        text.Should().Contain("Skyrim.esm");
+        text.Should().NotContain("plugin_test.esp", "plugin_test.esp is not installed");
+
+        path = BethesdaTestHelpers.GetDownloadableModFolder(FileSystem, "PluginTest");
+        downloaded = await _downloader.DownloadFromManifestAsync(path, FileSystem);
+        var pluginTest = await InstallModFromArchiveIntoLoadout(
+            loadout,
+            downloaded.Path,
+            downloaded.Manifest.Name);
+
+        await Apply(loadout.Value);
+
+        pluginFilePath.FileExists.Should().BeTrue("the loadout is applied");
+        text = await GetPluginOrder(pluginFilePath);
+
+        text.Should().Contain("Skyrim.esm");
+        text.Should().Contain("plugin_test.esp", "plugin_test.esp is installed");
+
+        LoadoutRegistry.Alter(loadout.Value.LoadoutId, pluginTest.Id, "disable plugin",  
+            mod => mod with {Enabled  = false});
+
+        text = await GetPluginOrder(pluginFilePath);
+
+        text.Should().Contain("Skyrim.esm");
+        text.Should().Contain("plugin_test.esp", "new loadout has not been applied yet");
+
+        await Apply(loadout.Value);
+
+        text = await GetPluginOrder(pluginFilePath);
+
+        text.Should().Contain("Skyrim.esm");
+        text.Should().NotContain("plugin_test.esp", "plugin_test.esp is disabled");
+
+        LoadoutRegistry.Alter(loadout.Value.LoadoutId, pluginTest.Id, "enable plugin",  
+            mod => mod with {Enabled  = true});
+
+        await Apply(loadout.Value);
+
+        text = await GetPluginOrder(pluginFilePath);
+
+        text.Should().Contain("Skyrim.esm");
+        text.Should().Contain("plugin_test.esp", "plugin_test.esp is enabled again");
+
+    }
+
+    private static async Task<string[]> GetPluginOrder(AbsolutePath pluginFilePath)
+    {
+        return (await pluginFilePath.ReadAllTextAsync())
+            .Split(new []{"\r","\n"}, StringSplitOptions.RemoveEmptyEntries)
+            .Select(p => p.TrimStart("*"))
+            .ToArray();
+    }
 }

tests/Games/NexusMods.Games.TestFramework/AGameTest.cs

@@ -273,4 +273,14 @@ protected async Task<TemporaryPath> CreateTestFile(byte[] contents, Extension? e
 
     protected Task<TemporaryPath> CreateTestFile(string contents, Extension? extension, Encoding? encoding = null)
         => CreateTestFile((encoding ?? Encoding.UTF8).GetBytes(contents), extension);
+
+    /// <summary>
+    /// Helper method to create create a apply plan and apply it.
+    /// </summary>
+    /// <param name="loadout"></param>
+    protected async Task Apply(Loadout loadout)
+    {
+        var plan = await LoadoutSynchronizer.MakeApplySteps(loadout);
+        await LoadoutSynchronizer.Apply(plan);
+    }
 }