fix plugin dependencies resolution at runtime

CringePlugins/Loader/PluginsLifetime.cs

@@ -59,6 +59,8 @@ internal class PluginsLifetime(ConfigHandler configHandler, HttpClient client, D
 
         var cacheDir = dir.CreateSubdirectory("cache");
         
+        InitializeSharedStore(ref cacheDir);
+
         var invalidPackages = new List<PackageReference>();
         var packages = await resolver.ResolveAsync(cacheDir, launcherConfig.DisablePluginUpdates, invalidPackages);
 
@@ -149,7 +151,7 @@ internal class PluginsLifetime(ConfigHandler configHandler, HttpClient client, D
 
         foreach (var package in packages)
         {
-            if (builtInPackages.ContainsKey(package.Package.Id)) continue;
+            if (builtInPackages.ContainsKey(package.Package.Id) || package.Entry.PackageTypes is not ["CringePlugin"]) continue;
 
             var packageClient = await sourceMapping.GetClientAsync(package.Package.Id);
 
@@ -219,4 +221,23 @@ internal class PluginsLifetime(ConfigHandler configHandler, HttpClient client, D
             Log.Error(e, "Failed to load plugin {PluginPath}", path);
         }
     }
+
+    // initializes dotnet shared store for plugin resolver to look for dependencies
+    private void InitializeSharedStore(ref DirectoryInfo cacheDir)
+    {
+        const string envVar = "DOTNET_SHARED_STORE";
+        
+        string[] paths = [];
+        if (Environment.GetEnvironmentVariable(envVar) is { } value)
+        {
+            paths = value.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);
+        }
+
+        paths = [cacheDir.FullName, ..paths];
+        
+        Environment.SetEnvironmentVariable(envVar, string.Join(Path.PathSeparator, paths));
+
+        cacheDir = cacheDir.CreateSubdirectory("x64"); // todo change this to automatic if we ever get to aarch64
+        cacheDir = cacheDir.CreateSubdirectory(new NuGetFramework(_runtimeFramework.Framework.Framework, _runtimeFramework.Framework.Version).GetShortFolderName());
+    }
 }

NuGet/Deps/DependenciesManifest.cs

@@ -84,21 +84,25 @@ public class DependencyManifestBuilder(DirectoryInfo cacheDirectory, PackageSour
         var runtimeTarget = new RuntimeTarget(targetFramework);
 
         var targets = ImmutableDictionary<ManifestPackageKey, DependencyTarget>.Empty.ToBuilder();
+        var libraries = ImmutableDictionary<ManifestPackageKey, DependencyLibrary>.Empty.ToBuilder();
 
-        await MapCatalogEntryAsync(catalogEntry, targetFramework, targets);
+        await MapCatalogEntryAsync(catalogEntry, targetFramework, targets, libraries);
 
         var manifest = new DependenciesManifest(runtimeTarget, ImmutableDictionary<NuGetRuntimeFramework, string>.Empty,
             ImmutableDictionary<NuGetRuntimeFramework, ImmutableDictionary<ManifestPackageKey, DependencyTarget>>.Empty
                 .Add(targetFramework, targets.ToImmutable()),
-            ImmutableDictionary<ManifestPackageKey, DependencyLibrary>.Empty);
+            libraries.ToImmutable());
 
         await DependencyManifestSerializer.SerializeAsync(stream, manifest);
     }
 
     private async Task MapCatalogEntryAsync(CatalogEntry catalogEntry, NuGetRuntimeFramework targetFramework,
-        ImmutableDictionary<ManifestPackageKey, DependencyTarget>.Builder targets)
+        ImmutableDictionary<ManifestPackageKey, DependencyTarget>.Builder targets,
+        ImmutableDictionary<ManifestPackageKey, DependencyLibrary>.Builder libraries)
     {
-        if (targets.ContainsKey(new(catalogEntry.Id, catalogEntry.Version)) || !catalogEntry.DependencyGroups.HasValue)
+        var packageKey = new ManifestPackageKey(catalogEntry.Id, catalogEntry.Version);
+        
+        if (targets.ContainsKey(packageKey) || !catalogEntry.DependencyGroups.HasValue)
             return;
 
         // TODO take into account the target framework runtime identifier
@@ -108,15 +112,18 @@ public class DependencyManifestBuilder(DirectoryInfo cacheDirectory, PackageSour
         if (nearest is null)
             return;
 
-        targets.Add(new(catalogEntry.Id, catalogEntry.Version),
+        targets.Add(packageKey,
             await MapEntryAsync(catalogEntry, nearest));
 
+        libraries.Add(packageKey,
+            new DependencyLibrary(LibraryType.Package, Serviceable: true, Path: packageKey));
+
         foreach (var entry in (nearest.Dependencies ?? []).Select(catalogEntryResolver))
         {
             if (entry is null)
                 continue;
 
-            await MapCatalogEntryAsync(entry, targetFramework, targets);
+            await MapCatalogEntryAsync(entry, targetFramework, targets, libraries);
         }
     }
 
@@ -127,11 +134,12 @@ public class DependencyManifestBuilder(DirectoryInfo cacheDirectory, PackageSour
         return new(
             group.Dependencies?.ToImmutableDictionary(b => b.Id, b => catalogEntryResolver(b)!.Version) ??
             ImmutableDictionary<string, NuGetVersion>.Empty,
-            packageEntries.Where(b => b.FullName.StartsWith($"lib/{group.TargetFramework.GetShortFolderName()}/"))
+            packageEntries.Where(b => b.FullName.StartsWith($@"lib\{group.TargetFramework.GetShortFolderName()}\") && 
-                .ToImmutableDictionary(b => b.FullName, _ => new RuntimeDependency()),
+                                      Path.GetExtension(b.FullName.AsSpan()) is ".dll")
+                .ToImmutableDictionary(b => b.FullName.Replace('\\', '/'), _ => new RuntimeDependency()),
             packageEntries.Where(b =>
-                    b.FullName.StartsWith($"runtimes/{RuntimeInformation.RuntimeIdentifier}/native/"))
+                    b.FullName.StartsWith($@"runtimes\{RuntimeInformation.RuntimeIdentifier}\native\"))
-                .ToImmutableDictionary(b => b.FullName, _ => new Dependency()));
+                .ToImmutableDictionary(b => b.FullName.Replace('\\', '/'), _ => new Dependency()));
     }
 
     private async Task<ImmutableArray<CatalogPackageEntry>> GetPackageContent(CatalogEntry entry)
@@ -145,7 +153,7 @@ public class DependencyManifestBuilder(DirectoryInfo cacheDirectory, PackageSour
                 return
                 [
                     ..dir.EnumerateFiles("*", SearchOption.AllDirectories)
-                        .Select(b => new CatalogPackageEntry(b.Name, b.FullName, b.Length, b.Length))
+                        .Select(b => new CatalogPackageEntry(b.Name, Path.GetRelativePath(dir.FullName, b.FullName), b.Length, b.Length))
                 ];
             }
 

NuGet/Models/NuGetRuntimeFramework.cs

@@ -22,6 +22,6 @@ public record NuGetRuntimeFramework(NuGetFramework Framework, string? RuntimeIde
 
     public override string ToString()
     {
-        return string.IsNullOrEmpty(RuntimeIdentifier) ? Framework.ToString() : $"{Framework}/{RuntimeIdentifier}";
+        return string.IsNullOrEmpty(RuntimeIdentifier) ? Framework.DotNetFrameworkName : $"{Framework.DotNetFrameworkName}/{RuntimeIdentifier}";
     }
 }