First Commit 2nd run

.idea/.idea.TinfoilVibeServer/.idea/vcs.xml

@@ -2,5 +2,6 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/libhac" vcs="Git" />
   </component>
 </project>

TinfoilVibeServer.sln

@@ -7,6 +7,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TinfoilVibeServer", "TinfoilVibeServer\TinfoilVibeServer.csproj", "{DE992FDB-6D13-4152-925D-29D39A23FB75}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TinfoilVibeServerTests", "TinfoilVibeServerTests\TinfoilVibeServerTests.csproj", "{EB041FA0-F87C-4F24-9E39-9BAF3D3776D8}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -17,5 +19,9 @@ Global
 		{DE992FDB-6D13-4152-925D-29D39A23FB75}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{DE992FDB-6D13-4152-925D-29D39A23FB75}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{DE992FDB-6D13-4152-925D-29D39A23FB75}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EB041FA0-F87C-4F24-9E39-9BAF3D3776D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EB041FA0-F87C-4F24-9E39-9BAF3D3776D8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EB041FA0-F87C-4F24-9E39-9BAF3D3776D8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EB041FA0-F87C-4F24-9E39-9BAF3D3776D8}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

TinfoilVibeServer.sln.DotSettings.user

@@ -1,3 +1,8 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/AddReferences/RecentPaths/=D_003A_005CCloud_005CGit_005CLibHac_005Csrc_005CLibHac_005Cbin_005CRelease_005Cnet8_002E0_005CLibHac_002Edll/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/AddReferences/RecentPaths/=D_003A_005CCloud_005CGit_005CTinfoilVibeServer_005CTinfoilVibeServer_005Clibhac_005Csrc_005CLibHac_005Cbin_005CRelease_005Cnet8_002E0_005CLibHac_002Edll/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/AddReferences/RecentPaths/=D_003A_005CCloud_005CGit_005CTinfoilVibeServer_005CTinfoilVibeServer_005Clibhac_005Csrc_005CLibHac_005Cbin_005CRelease_005Cnet8_002E0_005CLibHac_002Edll/@EntryIndexedValue">True</s:Boolean>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AContains_002Ecs_002Fl_003AC_0021_003FUsers_003Fecens_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003F67987bd98adb31db56e1521f051c645ef14c5c8767f3826e274fb9087354cee_003FContains_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AContentMetaType_002Ecs_002Fl_003AC_0021_003FUsers_003Fecens_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F7df76fe8248d4d00bc92ef3a1d9ce9a0189a00_003F0e_003Fde2efd6d_003FContentMetaType_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AHashAlgorithm_002Ecs_002Fl_003AC_0021_003FUsers_003Fecens_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003Fce7580e8e0f6a2637f8ec8ab41c5fd2f845ad94ea18c76d554db62248d8954_003FHashAlgorithm_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AResult_002Ecs_002Fl_003AC_0021_003FUsers_003Fecens_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F77078e9a1d254191bb508f54a277fc6e1c2e00_003F13_003Faf246217_003FResult_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ASafeFileHandle_002EWindows_002Ecs_002Fl_003AC_0021_003FUsers_003Fecens_003FAppData_003FRoaming_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003F6ef8e7d549f6bfb5b9eafaaa0ff48d8cbfc564f32be26323b5f60e63aef4dd1_003FSafeFileHandle_002EWindows_002Ecs/@EntryIndexedValue">ForceIncluded</s:String></wpf:ResourceDictionary>

TinfoilVibeServer/Config/GameDirectoryOptions.cs

@@ -0,0 +1,11 @@
+// File: TinfoilVibeServer/Config/GameDirectoriesOptions.cs
+
+namespace TinfoilVibeServer.Config;
+
+public sealed class GameDirectoriesOptions
+{
+    /// <summary>
+    /// Paths to scan for Switch ROMs and archives.  Values may change at runtime.
+    /// </summary>
+    public IList<string> Paths { get; set; } = new List<string>();
+}

TinfoilVibeServer/ConfigManager.cs

@@ -1,70 +0,0 @@
-
-using System.Text.Json;
-
-namespace TinfoilVibeServer;
-
-/// <summary>
-/// Reads the JSON config file and raises an event whenever it changes.
-/// </summary>
-public sealed class ConfigManager : IDisposable
-{
-    private readonly string _configPath;
-    private readonly FileSystemWatcher _watcher;
-    private readonly object _sync = new();
-
-    public AppSettings Settings { get; private set; }
-
-    public event Action<AppSettings>? OnChange;
-
-    public ConfigManager(string configPath)
-    {
-        _configPath = configPath;
-        Settings = Load();
-
-        _watcher = new FileSystemWatcher
-        {
-            Path = Path.GetDirectoryName(_configPath)!,
-            Filter = Path.GetFileName(_configPath),
-            NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size | NotifyFilters.Attributes,
-            EnableRaisingEvents = true
-        };
-
-        _watcher.Changed += (_, _) => Reload();
-    }
-
-    private AppSettings Load()
-    {
-        var json = File.ReadAllText(_configPath);
-        return JsonSerializer.Deserialize<AppSettings>(json, new JsonSerializerOptions { PropertyNameCaseInsensitive = true })!;
-    }
-
-    private void Reload()
-    {
-        lock (_sync)
-        {
-            try
-            {
-                Settings = Load();
-                OnChange?.Invoke(Settings);
-            }
-            catch (Exception ex)
-            {
-                Console.Error.WriteLine($"Failed to reload config: {ex.Message}");
-            }
-        }
-    }
-
-    public void Dispose() => _watcher.Dispose();
-}
-
-/// <summary>
-/// POCO that matches appsettings.json.
-/// </summary>
-public sealed record AppSettings(
-    string[] RootDirectories,
-    string[] WhitelistExtensions,
-    string[] RomExtensions,
-    string SnapshotFile,
-    string SnapshotBackupFile,
-    int ArchiveBufferSize
-);

TinfoilVibeServer/Configuration/AppSettings.cs

@@ -0,0 +1,10 @@
+// Configuration/AppSettings.cs
+namespace TinfoilVibeServer.Configuration
+{
+    public class AppSettings
+    {
+        public List<string> GameDirectories { get; set; } = new();
+        public List<string> ValidExtensions { get; set; } = new() { ".nsp", ".xci", ".zip", ".rar", ".7z" };
+        public string SnapshotPath { get; set; } = "snapshot.json";
+    }
+}

TinfoilVibeServer/Middleware/BasicAuthMiddleware.cs

@@ -1,100 +0,0 @@
-
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Logging;
-using System.Text;
-using TinfoilVibeServer.Services;
-
-namespace TinfoilVibeServer.Middleware;
-
-public sealed class BasicAuthMiddleware
-{
-    private readonly RequestDelegate _next;
-    private readonly AuthStore _store;
-    private readonly ILogger<BasicAuthMiddleware> _logger;
-
-    public BasicAuthMiddleware(RequestDelegate next, AuthStore store, ILogger<BasicAuthMiddleware> logger)
-    {
-        _next = next;
-        _store = store;
-        _logger = logger;
-    }
-
-    public async Task InvokeAsync(HttpContext context)
-    {
-        var ip = context.Connection.RemoteIpAddress?.ToString() ?? "unknown";
-
-        // 1) IP blacklist
-        if (_store.IsBlacklisted(ip))
-        {
-            _logger.LogWarning("Blocked request from blacklisted IP {IP}", ip);
-            context.Response.StatusCode = StatusCodes.Status403Forbidden;
-            await context.Response.WriteAsync("Forbidden");
-            return;
-        }
-
-        // 2) Authorization header
-        if (!context.Request.Headers.TryGetValue("Authorization", out var authHeaders))
-        {
-            Challenge(context);
-            return;
-        }
-
-        var authHeader = authHeaders.FirstOrDefault() ?? "";
-        if (!authHeader.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
-        {
-            Challenge(context);
-            return;
-        }
-
-        string decoded;
-        try
-        {
-            var b64 = authHeader[6..].Trim();
-            decoded = Encoding.UTF8.GetString(Convert.FromBase64String(b64));
-        }
-        catch
-        {
-            Challenge(context);
-            return;
-        }
-
-        var parts = decoded.Split(':', 2);
-        if (parts.Length != 2)
-        {
-            Challenge(context);
-            return;
-        }
-
-        var username = parts[0];
-        var password = parts[1];
-
-        // 3) UID header (optional)
-        int? uid = null;
-        if (context.Request.Headers.TryGetValue("UID", out var uidHeader))
-        {
-            if (int.TryParse(uidHeader.ToString(), out var parsedUid))
-                uid = parsedUid;
-        }
-
-        // 4) Validate
-        if (!_store.TryValidate(username, password, uid, ip, out var error))
-        {
-            _logger.LogWarning("Auth failed for user {User} from {IP}: {Error}", username, ip, error);
-            context.Response.StatusCode = StatusCodes.Status401Unauthorized;
-            context.Response.Headers.Add("WWW-Authenticate", "Basic realm=\"FileSnapshot\"");
-            await context.Response.WriteAsync(error ?? "Unauthorized");
-            return;
-        }
-
-        // Authentication succeeded – attach username for downstream handlers if needed
-        context.Items["User"] = username;
-
-        await _next(context);
-    }
-
-    private static void Challenge(HttpContext ctx)
-    {
-        ctx.Response.StatusCode = StatusCodes.Status401Unauthorized;
-        ctx.Response.Headers.Add("WWW-Authenticate", "Basic realm=\"FileSnapshot\"");
-    }
-}

TinfoilVibeServer/Models/FileEntry.cs

@@ -1,11 +0,0 @@
-namespace TinfoilVibeServer.Models;
-
-/// <summary>
-/// One line in the snapshot – the JSON will be an array of these.
-/// </summary>
-public sealed record FileEntry(
-    string Path,
-    long Size,
-    string Hash,          // SHA‑256 hex
-    TitleInfo? Title      // null unless file is an NSP/XCI or an archive containing one
-);

TinfoilVibeServer/Models/GameSnapshot.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace TinfoilVibeServer.Models
+{
+    public class GameSnapshot
+    {
+        public string TitleId { get; set; }            // 16‑hex string
+        public int Version { get; set; }
+        public bool IsApplication { get; set; }
+        public bool IsPatch { get; set; }
+
+        public string FullPath { get; set; }           // Path on disk (file or archive)
+        public string InsidePath { get; set; }         // Path inside an archive (empty if none)
+        public string FirstNcaHash { get; set; }       // SHA‑256 of the first NCA stream
+
+        public DateTime LastModified { get; set; }     // For snapshot refresh logic
+    }
+}

TinfoilVibeServer/Models/TitleInfo.cs

@@ -1,11 +0,0 @@
-namespace TinfoilVibeServer.Models;
-
-/// <summary>
-/// Metadata extracted from a NSP/XCI archive.
-/// </summary>
-public sealed record TitleInfo(
-    string TitleId,       // e.g. 0004000000000000
-    string Name,          // title name
-    string Version,       // e.g. 1.02
-    bool IsApplication    // true for applications, false for patches
-);

TinfoilVibeServer/Persistence/ISnapshotRepository.cs

@@ -0,0 +1,12 @@
+// File: TinfoilVibeServer/Persistence/ISnapshotRepository.cs
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using TinfoilVibeServer.Models;
+
+namespace TinfoilVibeServer.Persistence;
+
+public interface ISnapshotRepository
+{
+    Task<IReadOnlyDictionary<string, SnapshotEntry>> LoadAsync();
+    Task PersistAsync(IReadOnlyDictionary<string, SnapshotEntry> snapshot);
+}

TinfoilVibeServer/Persistence/SnapshotRepository.cs

@@ -0,0 +1,34 @@
+// File: TinfoilVibeServer/Persistence/SnapshotRepository.cs
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using System.Threading.Tasks;
+using TinfoilVibeServer.Models;
+
+namespace TinfoilVibeServer.Persistence;
+
+public sealed class SnapshotRepository : ISnapshotRepository
+{
+    private readonly string _path = "snapshot.json";
+
+    public async Task<IReadOnlyDictionary<string, SnapshotEntry>> LoadAsync()
+    {
+        if (!File.Exists(_path))
+        {
+            return new Dictionary<string, SnapshotEntry>();
+        }
+
+        await using var stream = File.OpenRead(_path);
+        var snapshot = await JsonSerializer.DeserializeAsync<Dictionary<string, SnapshotEntry>>(stream,
+            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
+
+        return snapshot ?? new Dictionary<string, SnapshotEntry>();
+    }
+
+    public async Task PersistAsync(IReadOnlyDictionary<string, SnapshotEntry> snapshot)
+    {
+        await using var stream = File.Create(_path);
+        await JsonSerializer.SerializeAsync(stream, snapshot,
+            new JsonSerializerOptions { WriteIndented = true });
+    }
+}

TinfoilVibeServer/Program.cs

@@ -1,42 +1,53 @@
-using TinfoilVibeServer.Middleware;
+// File: TinfoilVibeServer/Program.cs
+
+using LibHac.Common.Keys;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Configuration;
+using TinfoilVibeServer.Config;
+using TinfoilVibeServer.Models;
 using TinfoilVibeServer.Services;
+using TinfoilVibeServer.Persistence;
 
-var builder = WebApplication.CreateBuilder(args);
+namespace TinfoilVibeServer;
 
-// -----------------------------------------------------
-// 1. Register AuthStore as a singleton
-// -----------------------------------------------------
-builder.Services.AddSingleton<AuthStore>();
-
-// -----------------------------------------------------
-// 2. Snapshot + other services (unchanged)
-// -----------------------------------------------------
-builder.Services.AddSingleton<SnapshotService>();
-// … any other services you already have
-
-var app = builder.Build();
-
-// -----------------------------------------------------
-// 3. Apply authentication middleware *before* the
-//    snapshot endpoints.  This guarantees all routes
-//    are protected.
-// -----------------------------------------------------
-app.UseMiddleware<BasicAuthMiddleware>();
-
-// -----------------------------------------------------
-// 4. Existing endpoints – unchanged
-// -----------------------------------------------------
-app.MapGet("/", () => Results.Redirect("/index.tfl"));
-app.MapGet("/index.tfl", async context =>
+internal static class Program
 {
-    var jsonPath = Path.Combine(AppContext.BaseDirectory, "index.tfl");
-    context.Response.ContentType = "application/json";
-    await context.Response.WriteAsync(await File.ReadAllTextAsync(jsonPath));
-});
-app.MapGet("/debug", () => new SnapshotService(builder.Configuration).GetSnapshot());
-app.MapGet("/stream/{*relativePath}", async context =>
-{
-    // … (unchanged streaming logic – same as before)
-});
+    public static void Main(string[] args)
+    {
+        var host = Host.CreateDefaultBuilder(args)
+            .ConfigureAppConfiguration((ctx, cfg) =>
+            {
+                cfg.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
+                cfg.AddEnvironmentVariables();
+                cfg.AddCommandLine(args);
+            })
+            .ConfigureServices((ctx, services) =>
+            {
+                // Configuration POCO
+                services.Configure<GameDirectoriesOptions>(ctx.Configuration.GetSection("GameDirectories"));
 
-app.Run();
+                // Snapshot persistence
+                services.AddSingleton<ISnapshotRepository, SnapshotRepository>();
+
+                // LibHac parser
+                services.AddSingleton<ILibHacParser, LibHacParser>();
+
+                // Main service
+                services.AddHostedService<GameDirectoryWatcherService>();
+                KeySetHolder.KeySet = ExternalKeyReader.ReadKeyFile(ctx.Configuration.GetSection("KeySet").Get<string>());
+            })
+            .ConfigureLogging((ctx, logging) =>
+            {
+                logging.ClearProviders();
+                logging.AddConsole(options =>
+                {
+                    options.TimestampFormat = "[yyyy-MM-dd HH:mm:ss] ";
+                });
+            })
+            .Build();
+
+        host.Run();
+    }
+}

TinfoilVibeServer/Repositories/SnapshotRepository.cs

@@ -0,0 +1,32 @@
+// Repositories/SnapshotRepository.cs
+using System.IO;
+using System.Text.Json;
+using TinfoilVibeServer.Models;
+
+namespace TinfoilVibeServer.Repositories
+{
+    public class SnapshotRepository
+    {
+        private readonly string _path;
+
+        public SnapshotRepository(string path)
+        {
+            _path = path;
+        }
+
+        public List<SnapshotEntry> Load()
+        {
+            if (!File.Exists(_path))
+                return new();
+
+            var json = File.ReadAllText(_path);
+            return JsonSerializer.Deserialize<List<SnapshotEntry>>(json) ?? new();
+        }
+
+        public void Persist(IEnumerable<SnapshotEntry> entries)
+        {
+            var json = JsonSerializer.Serialize(entries, new JsonSerializerOptions { WriteIndented = true });
+            File.WriteAllText(_path, json);
+        }
+    }
+}

TinfoilVibeServer/Services/ArchiveHandler.cs

@@ -1,127 +0,0 @@
-
-using System.IO.Compression;
-using FileSnapshot;
-using SharpCompress.Archives;
-using SharpCompress.Archives.Zip;
-using SharpCompress.Archives.Rar;
-using SharpCompress.Archives.SevenZip;
-using SharpCompress.Readers;
-using TinfoilVibeServer.Models;
-using ZipArchive = SharpCompress.Archives.Zip.ZipArchive;
-
-namespace TinfoilVibeServer.Services;
-
-/// <summary>
-/// Tries to open a file as an archive and look for an embedded NSP/XCI.
-/// The goal is to be as memory‑friendly as possible – never load a whole archive into RAM.
-/// </summary>
-public sealed class ArchiveHandler
-{
-    /// <summary>
-    /// Return TitleInfo if an embedded Nintendo archive is found; otherwise null.
-    /// </summary>
-    public static TitleInfo? TryExtractTitleInfo(string filePath)
-    {
-        var ext = Path.GetExtension(filePath).ToLowerInvariant();
-
-        try
-        {
-            switch (ext)
-            {
-                case ".zip":
-                    return HandleZip(filePath);
-                case ".7z":
-                    return Handle7z(filePath);
-                case ".rar":
-                    return HandleRar(filePath);
-                default:
-                    return null;
-            }
-        }
-        catch
-        {
-            // Graceful fallback – return null
-            return null;
-        }
-    }
-
-    private static TitleInfo? HandleZip(string path)
-    {
-        using var archive = ZipArchive.Open(path);
-        foreach (var entry in archive.Entries)
-        {
-            if (!entry.IsDirectory && IsRomArchive(entry.Key))
-            {
-                var temp = Path.GetTempFileName();
-                entry.WriteToFile(temp);
-                var title = NSPExtactor.ExtractFromFile(temp);
-                File.Delete(temp);
-                return title;
-            }
-        }
-        return null;
-    }
-
-    private static TitleInfo? Handle7z(string path)
-    {
-        using var archive = SevenZipArchive.Open(path);
-        foreach (var entry in archive.Entries)
-        {
-            if (!entry.IsDirectory && IsRomArchive(entry.Key))
-            {
-                var temp = Path.GetTempFileName();
-                entry.WriteToFile(temp);
-                var title = NSPExtactor.ExtractFromFile(temp);
-                File.Delete(temp);
-                return title;
-            }
-        }
-        return null;
-    }
-
-    private static TitleInfo? HandleRar(string path)
-    {
-        // SharpCompress can handle most RAR5 files – fallback to SharpSevenZip if it fails
-        try
-        {
-            using var archive = RarArchive.Open(path);
-            foreach (var entry in archive.Entries)
-            {
-                if (!entry.IsDirectory && IsRomArchive(entry.Key))
-                {
-                    var temp = Path.GetTempFileName();
-                    entry.WriteToFile(temp);
-                    var title = NSPExtactor.ExtractFromFile(temp);
-                    File.Delete(temp);
-                    return title;
-                }
-            }
-            return null;
-        }
-        catch (SharpCompress.Common.ArchiveException)
-        {
-            // Fallback to SharpSevenZip for RAR5
-            /*using var stream = File.OpenRead(path);
-            Stream outStream = new Mem;
-            using var extractor = SharpSevenZip.SharpSevenZipExtractor.DecompressStream(stream, outStream);
-            while (extractor.MoveToNextEntry())
-            {
-                if (!extractor.IsDirectory && IsRomArchive(extractor.CurrentFileName))
-                {
-                    var temp = Path.GetTempFileName();
-                    extractor.ExtractFile(temp);
-                    var title = NSPExtactor.ExtractFromFile(temp);
-                    File.Delete(temp);
-                    return title;
-                }
-            }*/
-            return null;
-        }
-    }
-
-    private static bool IsRomArchive(string entryName)
-    {
-        var ext = Path.GetExtension(entryName).ToLowerInvariant();
-        return ext is ".xci" or ".nsp" or ".xcz";
-    }
-}

TinfoilVibeServer/Services/AuthStore.cs

@@ -1,211 +0,0 @@
-using System.Collections.Concurrent;
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.Json;
-
-namespace TinfoilVibeServer.Services;
-
-/// <summary>
-/// Configuration section used by the auth system.
-/// </summary>
-public sealed class AuthSettings
-{
-    public string CredentialsFile  { get; init; } = "credentials.json";
-    public string FingerprintsFile { get; init; } = "fingerprints.json";
-    public string BlacklistFile    { get; init; } = "blacklist.json";
-    public int    MaxFailedAttempts { get; init; } = 5;
-}
-
-/// <summary>
-/// One user record – stored in *credentials.json*.
-/// </summary>
-public sealed record Credential(
-    string Username,
-    string PasswordHash,      // SHA‑256 hex
-    int    AllowedUidCount = 1,
-    bool   Verified = true);   // new flag – defaults to true for pre‑existing users
-
-/// <summary>
-/// Thread‑safe singleton that keeps the authentication state in memory
-/// and writes it back to disk whenever it changes.
-/// </summary>
-public sealed class AuthStore
-{
-    private readonly AuthSettings _settings;
-    private readonly object _sync = new();
-
-    // In‑memory state
-    public ConcurrentDictionary<string, Credential> Credentials { get; } = new();
-    public ConcurrentDictionary<string, List<int>> Fingerprints { get; } = new();
-    public ConcurrentDictionary<string, int> FailedAttempts { get; } = new();
-    public HashSet<string> BlacklistIPs { get; } = new();
-
-    public AuthStore(IConfiguration config)
-    {
-        _settings = new AuthSettings
-        {
-            CredentialsFile = config.GetValue<string>("Authentication:CredentialsFile") ?? "credentials.json",
-            FingerprintsFile = config.GetValue<string>("Authentication:FingerprintsFile") ?? "fingerprints.json",
-            BlacklistFile = config.GetValue<string>("Authentication:BlacklistFile") ?? "blacklist.json",
-            MaxFailedAttempts = config.GetValue<int>("Authentication:MaxFailedAttempts", 5)
-        };
-
-        LoadAll();
-    }
-
-    #region Loading / Persisting
-
-    private void LoadAll()
-    {
-        // Load credentials
-        if (File.Exists(_settings.CredentialsFile))
-        {
-            var txt = File.ReadAllText(_settings.CredentialsFile);
-            var dict = JsonSerializer.Deserialize<Dictionary<string, Credential>>(txt)!;
-            foreach (var kv in dict)
-                Credentials[kv.Key] = kv.Value;
-        }
-
-        // Load fingerprints
-        if (File.Exists(_settings.FingerprintsFile))
-        {
-            var txt = File.ReadAllText(_settings.FingerprintsFile);
-            var dict = JsonSerializer.Deserialize<Dictionary<string, List<int>>>(txt)!;
-            foreach (var kv in dict)
-                Fingerprints[kv.Key] = kv.Value;
-        }
-
-        // Load blacklist
-        if (File.Exists(_settings.BlacklistFile))
-        {
-            var txt = File.ReadAllText(_settings.BlacklistFile);
-            var arr = JsonSerializer.Deserialize<string[]>(txt)!;
-            foreach (var ip in arr)
-                BlacklistIPs.Add(ip);
-        }
-    }
-
-    private void PersistCredentials()
-    {
-        var json = JsonSerializer.Serialize(Credentials, new JsonSerializerOptions { WriteIndented = true });
-        File.WriteAllText(_settings.CredentialsFile, json);
-    }
-
-    private void PersistFingerprints()
-    {
-        var json = JsonSerializer.Serialize(Fingerprints, new JsonSerializerOptions { WriteIndented = true });
-        File.WriteAllText(_settings.FingerprintsFile, json);
-    }
-
-    private void PersistBlacklist()
-    {
-        var json = JsonSerializer.Serialize(BlacklistIPs.ToArray(), new JsonSerializerOptions { WriteIndented = true });
-        File.WriteAllText(_settings.BlacklistFile, json);
-    }
-
-    #endregion
-
-    public bool IsBlacklisted(string ip) => BlacklistIPs.Contains(ip);
-
-    /// <summary>
-    /// Validates username/password/UID, updates fingerprints and blacklists as needed.
-    /// </summary>
-    /// <returns>true if the user is authenticated; otherwise false.</returns>
-    public bool TryValidate(string username, string password, int? uid, string ip, out string? error)
-    {
-        error = null;
-        lock (_sync)
-        {
-            // 1) User existence – create on‑the‑fly if missing
-            if (!Credentials.TryGetValue(username, out var cred))
-            {
-                // Create a *new* user that is not yet verified
-                cred = new Credential(username, ComputeHash(password), 1, Verified: false);
-                Credentials[username] = cred;
-                PersistCredentials();
-
-                // Create empty fingerprint list (or pre‑add the first UID)
-                var list = Fingerprints.GetOrAdd(username, _ => new List<int>());
-                if (uid.HasValue && !list.Contains(uid.Value))
-                {
-                    if (list.Count < cred.AllowedUidCount)
-                        list.Add(uid.Value);
-                    PersistFingerprints();
-                }
-
-                error = "User not verified";
-                IncrementFailed(username, ip);
-                return false;
-            }
-
-            // 2) Password check
-            if (!VerifyPasswordHash(password, cred.PasswordHash))
-            {
-                error = "Invalid password";
-                IncrementFailed(username, ip);
-                return false;
-            }
-
-            // 3) Verify flag – only verified users can pass
-            if (!cred.Verified)
-            {
-                error = "User not verified";
-                IncrementFailed(username, ip);
-                return false;
-            }
-
-            // 4) UID handling
-            if (uid.HasValue)
-            {
-                var list = Fingerprints.GetOrAdd(username, _ => new List<int>());
-
-                if (!list.Contains(uid.Value))
-                {
-                    if (list.Count < cred.AllowedUidCount)
-                    {
-                        list.Add(uid.Value);
-                        PersistFingerprints();
-                    }
-                    else
-                    {
-                        error = $"UID limit ({cred.AllowedUidCount}) exceeded";
-                        IncrementFailed(username, ip);
-                        return false;
-                    }
-                }
-            }
-
-            // 5) Success – reset counter
-            FailedAttempts[username] = 0;
-            return true;
-        }
-    }
-
-    private void IncrementFailed(string username, string ip)
-    {
-        var newCount = FailedAttempts.GetOrAdd(username, 0) + 1;
-        FailedAttempts[username] = newCount;
-
-        if (newCount >= _settings.MaxFailedAttempts)
-        {
-            BlacklistIPs.Add(ip);
-            PersistBlacklist();
-            // reset counter for the next session
-            FailedAttempts[username] = 0;
-        }
-    }
-
-    #region Helpers
-
-    public static string ComputeHash(string input)
-    {
-        using var sha = SHA256.Create();
-        var hash = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
-        return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
-    }
-
-    private static bool VerifyPasswordHash(string plain, string storedHash)
-        => string.Equals(ComputeHash(plain), storedHash, StringComparison.OrdinalIgnoreCase);
-
-    #endregion
-}

TinfoilVibeServer/Services/GameDirectoryWatcherService.cs

@@ -0,0 +1,229 @@
+// File: TinfoilVibeServer/Services/GameDirectoryWatcherService.cs
+
+using Microsoft.Extensions.Options;
+using SharpCompress.Archives;
+using TinfoilVibeServer.Config;
+using TinfoilVibeServer.Persistence;
+using TinfoilVibeServer.Models;
+
+namespace TinfoilVibeServer.Services;
+
+/// <summary>
+/// 1. Loads persisted snapshot on start.  
+/// 2. Scans configured directories for Switch ROMs or archives, extracts metadata, and keeps snapshot up‑to‑date.  
+/// 3. Watches directories for changes and updates snapshot incrementally.
+/// </summary>
+public sealed class GameDirectoryWatcherService : BackgroundService
+{
+    private readonly ILogger<GameDirectoryWatcherService> _log;
+    private readonly IOptionsMonitor<GameDirectoriesOptions> _options;
+    private readonly ISnapshotRepository _repo;
+    private readonly ILibHacParser _parser;
+    private readonly Dictionary<string, SnapshotEntry> _snapshot = new();
+    private readonly List<FileSystemWatcher> _watchers = new();
+
+    // Valid extensions for Switch ROMs (case‑insensitive).
+    private static readonly string[] _romExtensions = { ".nsp", ".xci" };
+
+    // Archive extensions that we can open with SharpCompress.
+    private static readonly string[] _archiveExtensions = { ".zip", ".rar", ".7z", ".tar", ".gz" };
+
+    public GameDirectoryWatcherService(
+        ILogger<GameDirectoryWatcherService> log,
+        IOptionsMonitor<GameDirectoriesOptions> options,
+        ISnapshotRepository repo,
+        ILibHacParser parser)
+    {
+        _log = log;
+        _options = options;
+        _repo   = repo;
+        _parser = parser;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        // 1. Load persisted snapshot
+        var persisted = await _repo.LoadAsync();
+        foreach (var kvp in persisted)
+        {
+            _snapshot[kvp.Key] = kvp.Value;
+        }
+
+        // 2. Initial scan
+        await ScanAllDirectoriesAsync(stoppingToken);
+
+        // 3. Setup watchers
+        foreach (var dir in _options.CurrentValue.Paths)
+        {
+            var watcher = new FileSystemWatcher(dir)
+            {
+                IncludeSubdirectories = true,
+                NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite
+            };
+
+            watcher.Created += async (_, e) => await HandleCreatedAsync(e.FullPath, stoppingToken);
+            watcher.Changed += async (_, e) => await HandleChangedAsync(e.FullPath, stoppingToken);
+            watcher.Deleted += (_, e) => HandleDeleted(e.FullPath);
+            watcher.Renamed += async (_, e) => await HandleRenamedAsync(e.OldFullPath, e.FullPath, stoppingToken);
+
+            watcher.EnableRaisingEvents = true;
+            _watchers.Add(watcher);
+        }
+
+        // Keep the service alive until cancellation
+        await Task.Delay(Timeout.Infinite, stoppingToken);
+    }
+
+    private async Task ScanAllDirectoriesAsync(CancellationToken token)
+    {
+        foreach (var dir in _options.CurrentValue.Paths)
+        {
+            if (!Directory.Exists(dir))
+            {
+                _log.LogWarning("Configured directory does not exist: {Dir}", dir);
+                continue;
+            }
+
+            await foreach (var file in Directory.EnumerateFiles(dir, "*.*", SearchOption.AllDirectories).ToAsyncEnumerable().WithCancellation(token))
+            {
+                await ProcessFileAsync(file, token);
+                _log.LogInformation("Processed file: {File}", file);
+            }
+        }
+
+        await PersistSnapshotAsync();
+    }
+
+    private async Task ProcessFileAsync(string fullPath, CancellationToken token)
+    {
+        var ext = Path.GetExtension(fullPath).ToLowerInvariant();
+
+        if (_romExtensions.Contains(ext))
+        {
+            await ProcessRomAsync(fullPath, string.Empty, token);
+        }
+        else if (_archiveExtensions.Contains(ext))
+        {
+            await ProcessArchiveAsync(fullPath, token);
+        }
+    }
+
+    private async Task ProcessRomAsync(string fullPath, string insidePath, CancellationToken token)
+    {
+        try
+        {
+            await using var stream = File.OpenRead(fullPath);
+            var entry = await _parser.ExtractAsync(stream, fullPath, insidePath);
+
+            if (entry == null)
+            {
+                _log.LogDebug("No valid NCA found in {Path}", fullPath);
+                return;
+            }
+
+            await UpsertSnapshotAsync(entry, token);
+        }
+        catch (Exception ex)
+        {
+            _log.LogError(ex, "Failed to process ROM {Path}", fullPath);
+        }
+    }
+
+    private async Task ProcessArchiveAsync(string archivePath, CancellationToken token)
+    {
+        try
+        {
+            using var archive = ArchiveFactory.Open(archivePath);
+            foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
+            {
+                var ext = Path.GetExtension(entry.Key).ToLowerInvariant();
+                if (_romExtensions.Contains(ext))
+                {
+                    await using var entryStream = entry.OpenEntryStream();
+                    await ProcessRomAsync(archivePath, entry.Key, token);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _log.LogWarning(ex, "SharpCompress failed on {Archive}. Trying SharpSevenZip fallback.", archivePath);
+            await ProcessArchiveWithSharpSevenZipAsync(archivePath, token);
+        }
+    }
+
+    private async Task ProcessArchiveWithSharpSevenZipAsync(string archivePath, CancellationToken token)
+    {
+        // Placeholder – actual implementation requires SharpSevenZip integration.
+        // The idea is to open the archive, enumerate entries, and for each ROM
+        // call ProcessRomAsync with the archive path and internal entry path.
+        _log.LogDebug("SharpSevenZip fallback not yet implemented for {Archive}", archivePath);
+    }
+
+    private async Task UpsertSnapshotAsync(SnapshotEntry entry, CancellationToken token)
+    {
+        if (_snapshot.TryGetValue(entry.TitleId, out var existing))
+        {
+            // File exists – compare paths and hashes
+            if (existing.FullPath == entry.FullPath &&
+                existing.Hash.SequenceEqual(entry.Hash))
+            {
+                // No change
+                return;
+            }
+
+            _log.LogInformation("Updating snapshot for TitleId {TitleId} – path change or hash update.", entry.TitleId);
+            _snapshot[entry.TitleId] = entry;
+        }
+        else
+        {
+            _log.LogInformation("Adding new entry to snapshot: {TitleId}", entry.TitleId);
+            _snapshot[entry.TitleId] = entry;
+        }
+
+        await PersistSnapshotAsync();
+    }
+
+    private void HandleDeleted(string fullPath)
+    {
+        var titleId = _snapshot.Values.FirstOrDefault(e => e.FullPath == fullPath)?.TitleId;
+        if (titleId != null)
+        {
+            _log.LogInformation("Removing deleted file from snapshot: {TitleId} ({Path})", titleId, fullPath);
+            _snapshot.Remove(titleId);
+            _repo.PersistAsync(_snapshot).ConfigureAwait(false);
+        }
+    }
+
+    private async Task HandleCreatedAsync(string fullPath, CancellationToken token)
+    {
+        _log.LogInformation("Detected new file: {Path}", fullPath);
+        await ProcessFileAsync(fullPath, token);
+    }
+
+    private async Task HandleChangedAsync(string fullPath, CancellationToken token)
+    {
+        _log.LogInformation("Detected changed file: {Path}", fullPath);
+        await ProcessFileAsync(fullPath, token);
+    }
+
+    private async Task HandleRenamedAsync(string oldFullPath, string newFullPath, CancellationToken token)
+    {
+        _log.LogInformation("Detected renamed file: {Old} → {New}", oldFullPath, newFullPath);
+        // Treat as delete + create
+        HandleDeleted(oldFullPath);
+        await ProcessFileAsync(newFullPath, token);
+    }
+
+    private async Task PersistSnapshotAsync()
+    {
+        try
+        {
+            await _repo.PersistAsync(_snapshot);
+            _log.LogDebug("Snapshot persisted with {Count} entries.", _snapshot.Count);
+        }
+        catch (Exception ex)
+        {
+            _log.LogError(ex, "Failed to persist snapshot");
+        }
+    }
+}

TinfoilVibeServer/Services/ILibHacParser.cs

@@ -0,0 +1,14 @@
+// File: TinfoilVibeServer/Services/ILibHacParser.cs
+using System.IO;
+using System.Threading.Tasks;
+using TinfoilVibeServer.Models;
+
+namespace TinfoilVibeServer.Services;
+
+public interface ILibHacParser
+{
+    /// <summary>
+    /// Reads a ROM stream (NSP/XCI/…​) and extracts metadata.
+    /// </summary>
+    Task<SnapshotEntry?> ExtractAsync(Stream romStream, string fullPath, string insidePath);
+}

TinfoilVibeServer/Services/KeySetHolder.cs

@@ -0,0 +1,8 @@
+using LibHac.Common.Keys;
+
+namespace TinfoilVibeServer.Models;
+
+public class KeySetHolder
+{
+    public static KeySet KeySet { get; set; }
+}

TinfoilVibeServer/Services/LibHacParser.cs

@@ -0,0 +1,59 @@
+// File: TinfoilVibeServer/Services/LibHacParser.cs
+using System;
+using System.IO;
+using System.Linq;
+using System.Buffers;
+using System.Threading.Tasks;
+using LibHac.Fs;
+using LibHac.Fs.Fsa;
+using LibHac.FsSystem;
+using LibHac.Ncm;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using TinfoilVibeServer.Models;
+
+namespace TinfoilVibeServer.Services;
+
+/// <summary>
+/// Implements the LibHac extraction logic copied from the provided NSPExtractor.cs [4].
+/// </summary>
+public sealed class LibHacParser : ILibHacParser
+{
+    private readonly NSPExtactor _nspExtractor;
+
+    public LibHacParser(NSPExtactor nspExtractor)
+    {
+        _nspExtractor = nspExtractor;
+    }
+    /// <summary>
+    /// Reads the stream of a single Switch ROM (NSP or XCI) and returns metadata.
+    /// </summary>
+    public async Task<SnapshotEntry?> ExtractAsync(Stream romStream, string fullPath, string insidePath)
+    {
+        var extractFromStream = _nspExtractor.ExtractFromStream(romStream);
+        // Build snapshot entry
+        if (extractFromStream?.TitleId == null) return null;
+
+        var entry = new SnapshotEntry
+        {
+            TitleId = extractFromStream.TitleId,
+            Version = extractFromStream.Version,
+            IsApp = extractFromStream.ContentMetaType == ContentMetaType.Application,
+            IsPatch = extractFromStream.ContentMetaType == ContentMetaType.Patch,
+            IsDlc = extractFromStream.ContentMetaType == ContentMetaType.AddOnContent,
+            FullPath = fullPath,
+            InsidePath = insidePath,
+            Hash = await ComputeHashAsync(romStream),
+            LastModified = File.GetLastWriteTimeUtc(fullPath)
+        };
+
+        return entry;
+    }
+
+    private static async Task<byte[]> ComputeHashAsync(Stream stream)
+    {
+        stream.Seek(0, SeekOrigin.Begin);
+        using var sha256 = System.Security.Cryptography.SHA256.Create();
+        return await sha256.ComputeHashAsync(stream);
+    }
+}

TinfoilVibeServer/Services/NSPExtractor.cs

@@ -1,65 +1,143 @@
-using System;
-using System.IO;
-using System.Text.Json;
+using LibHac.Common;
+using LibHac.Common.Keys;
 using LibHac.Fs;
+using LibHac.Fs.Fsa;
 using LibHac.FsSystem;
-using LibHac.FsSystem.Impl;
-using LibHac.Util;
-using TinfoilVibeServer.Models;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using LibHac.Ncm;
+using LibHac.Tools.Ncm;
+using Microsoft.Extensions.Options;
 
-namespace FileSnapshot;
-
-/// <summary>
-/// Extracts title information from a Nintendo NSP/XCI file using LibHac 0.20.0.
-/// </summary>
-public sealed class NSPExtactor
+namespace TinfoilVibeServer.Services
 {
     /// <summary>
-    /// Return TitleInfo for the file, or null if the file is not a valid Nintendo archive.
+    /// Extracts the TitleId, version and patch/application flag from an NSP/XCI file.
     /// </summary>
-    public static TitleInfo? ExtractFromFile(string filePath)
+    public sealed class NSPExtactor
     {
-        // LibHac works with byte streams.  We open the file once and hand the stream to RomArchiveReader.
-        try
+        private readonly KeySetProvider _keySetProvider;
+
+        public NSPExtactor(KeySetProvider keySetProvider)
         {
-            using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
-            using var reader = new RomArchiveReader(fs, new RomArchiveSettings { UseCache = false });
+            _keySetProvider = keySetProvider;
+        }
+        public NcaMetadataDto? ExtractFromFile(string filePath)
+        {
+            using var stream = File.OpenRead(filePath);
+            return ExtractFromStream(stream);
+        }
 
-            if (!reader.IsValid)
-                return null;      // Not an NSP/XCI
+        public NcaMetadataDto? ExtractFromStream(Stream stream)
+        {
+            if (!IsPfsFileSystem(stream))
+                return null;
 
-            // The ROM contains one or more NCA headers.  For most cases the first one is the title.
-            // LibHac exposes the *content* list – we pick the first NCA that is a title.
-            foreach (var nca in reader.GetContentInfos())
+            stream.Seek(0, SeekOrigin.Begin);
+
+            // 0‑19.0.0 stream wrapper
+            using var storage = new StreamStorage(stream, false);
+
+            var partition = new PartitionFileSystem();
+            partition.Initialize(storage).ThrowIfFailure();
+
+            // Find the first Meta‑NCA inside the NSP/XCI
+            foreach (var entry in partition.EnumerateEntries("*.nca",
+                         SearchOptions.RecurseSubdirectories)
+                         .Where(e => e.Type == DirectoryEntryType.File))
             {
-                // NcaId.Type gives Application / Patch / DLC etc.
-                // We only care that the type is not null – the NCA itself contains the metadata we need.
-                var meta = nca.GetMetaData();
+                using var fileRef = new UniqueRef<IFile>();
+                partition.OpenFile(ref fileRef.Ref, entry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
+                using var file = fileRef.Release();
+                using var fileStorage = new FileStorage(file);
+                var nca = new Nca(_keySetProvider.Get(), fileStorage);
 
-                // 1) Title ID
-                string titleId = nca.Id.ToString("X16");
-
-                // 2) Name and version
-                // 0.20.x provides a simple string accessor
-                string? titleName  = meta.GetStringValue("title");
-                string? versionStr = meta.GetStringValue("version");
-
-                // 3) Determine if it is an application
-                bool isApp = meta.GetStringValue("content_type") == "Application";
-
-                return new TitleInfo(
-                    titleId,
-                    titleName ?? $"Unknown ({titleId})",
-                    versionStr ?? "0.00",
-                    isApp);
+                // Meta‑NCA contains the TitleId & version
+                if (nca.Header.ContentType == NcaContentType.Meta)
+                {
+                    var titleId = nca.Header.TitleId.ToString("X16");
+                    int    version  = nca.Header.Version;
+                    var contentMetaType = GetMetaDataType(nca);
+                    if (contentMetaType != null) return new NcaMetadataDto(titleId, version, contentMetaType.Value);
+                }
             }
 
-            return null;   // No NCA found
-        }
-        catch
-        {
-            // Any exception (bad file, invalid archive, etc.) -> treat as non‑NXP
             return null;
         }
+
+        private static ContentMetaType? GetMetaDataType(Nca nca)
+        {
+            if (nca.Header.ContentType != NcaContentType.Meta) return null;
+            using var openFileSystem = nca.OpenFileSystem(0, IntegrityCheckLevel.ErrorOnInvalid);
+            foreach (var entry in openFileSystem.EnumerateEntries("*.cnmt", SearchOptions.Default))
+            {
+                using var fileRef = new UniqueRef<IFile>();
+
+                var result = openFileSystem.OpenFile(ref fileRef.Ref, entry.FullPath.ToU8Span(), OpenMode.Read);
+                if (result.IsFailure()) continue;
+                using var nacpFile = fileRef.Release();
+                using var asStream = nacpFile.AsStream();
+
+                var cnmt = new Cnmt(asStream);
+                return cnmt.Type;
+            }
+
+            return null;
+        }
+
+        private static bool IsPfsFileSystem(Stream stream)
+        {
+            try
+            {
+                if (!stream.CanSeek) return false;
+                stream.Seek(0, SeekOrigin.Begin);
+
+                var storage   = new StreamStorage(stream, false);
+                var partition = new PartitionFileSystem();
+                partition.Initialize(storage).ThrowIfFailure();
+
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
     }
+
+    public class KeySetProvider
+    {
+        private readonly KeySet _keySet;
+
+        public KeySetProvider(IOptions<NSPExtractorSettings> nspExtractorSettings)
+        {
+            _keySet = ExternalKeyReader.ReadKeyFile(nspExtractorSettings.Value.KeyFilePath);
+        }
+
+        public KeySet Get() => _keySet;
+    }
+
+    public class NSPExtractorSettings
+    {
+        public string KeyFilePath { get; set; } = string.Empty;
+    }
+
+    /// <summary>
+    /// Simple DTO that matches the information extracted by NSPExtactor.
+    /// </summary>
+    public sealed class NcaMetadataDto
+    {
+        public string TitleId { get; }
+        public int Version { get; }
+        public ContentMetaType ContentMetaType { get; }
+
+        public NcaMetadataDto(string titleId, int version, ContentMetaType contentMetaType)
+        {
+            TitleId = titleId;
+            Version = version;
+            ContentMetaType = contentMetaType;
+        }
+    }
+    
+
 }

TinfoilVibeServer/Services/NcaMetadataDto.cs

@@ -0,0 +1,8 @@
+namespace TinfoilVibeServer.Models;
+
+public class NcaMetadataDto(string titleId, int version, bool isApp)
+{
+    public string TitleId { get; set; } = titleId;
+    public int Version { get; set; } = version;
+    public bool IsApp { get; set; } = isApp;
+}

TinfoilVibeServer/Services/SnapshotService.cs

@@ -1,191 +0,0 @@
-using System.Collections.Concurrent;
-using System.Security.Cryptography;
-using System.Text.Json;
-using FileSnapshot;
-using TinfoilVibeServer.Models;
-
-namespace TinfoilVibeServer.Services;
-
-/// <summary>
-/// Keeps an in‑memory snapshot, watches the filesystem for changes, and
-/// only re‑processes a file if its hash changed.  The snapshot is
-/// automatically re‑generated when the configuration changes.
-/// </summary>
-public sealed class SnapshotService : IDisposable
-{
-    private readonly ConfigManager _config;
-    private readonly string _jsonPath;
-    private readonly string _snapshotPath;
-    private readonly FileSystemWatcher _watcher;
-
-    // path -> CachedFile
-    private readonly ConcurrentDictionary<string, CachedFile> _cache = new();
-
-    private string? _currentSnapshotHash;
-
-    public SnapshotService(ConfigManager config)
-    {
-        _config = config;
-        _jsonPath   = Path.Combine(AppContext.BaseDirectory, config.Settings.SnapshotFile);
-        _snapshotPath = Path.Combine(AppContext.BaseDirectory, config.Settings.SnapshotBackupFile);
-
-        // Initial snapshot
-        BuildSnapshot();
-
-        // Persist a copy for quick load on next run
-        File.WriteAllText(_snapshotPath, JsonSerializer.Serialize(GetSnapshot()));
-
-        // File system watcher
-        _watcher = new FileSystemWatcher
-        {
-            Path = string.Join(Path.PathSeparator, config.Settings.RootDirectories),
-            IncludeSubdirectories = true,
-            NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName |
-                           NotifyFilters.Size | NotifyFilters.LastWrite
-        };
-
-        _watcher.Created += OnChanged;
-        _watcher.Changed += OnChanged;
-        _watcher.Deleted += OnChanged;
-        _watcher.Renamed += OnRenamed;
-        _watcher.EnableRaisingEvents = true;
-
-        // React to config changes
-        _config.OnChange += cfg =>
-        {
-            // Re‑initialise the watcher with the new root directories
-            _watcher.Path = string.Join(Path.PathSeparator, cfg.RootDirectories);
-            _watcher.EnableRaisingEvents = true;
-            BuildSnapshot();   // rebuild everything
-            PersistSnapshot();
-        };
-    }
-
-    private sealed record CachedFile(string Path, string Hash, TitleInfo? Title);
-
-    #region File system change handlers
-
-    private void OnChanged(object? _, FileSystemEventArgs e) =>
-        ThrottleSnapshotUpdate();
-
-    private void OnRenamed(object? _, RenamedEventArgs e)
-    {
-        // Treat rename as delete + create
-        OnChanged(_, new FileSystemEventArgs(WatcherChangeTypes.Deleted, e.OldFullPath, e.OldName));
-        OnChanged(_, new FileSystemEventArgs(WatcherChangeTypes.Created, e.FullPath, e.Name));
-    }
-
-    private void ThrottleSnapshotUpdate()
-    {
-        // Debounce: only trigger once in a short window
-        Task.Run(async () =>
-        {
-            await Task.Delay(250);
-            UpdateSnapshot();
-        });
-    }
-
-    #endregion
-
-    /// <summary>
-    /// Full rebuild – called on start‑up and on config change.
-    /// </summary>
-    private void BuildSnapshot()
-    {
-        var cfg = _config.Settings;
-        var entries = new List<FileEntry>();
-
-        foreach (var dir in cfg.RootDirectories)
-        {
-            foreach (var file in Directory.EnumerateFiles(dir, "*", SearchOption.AllDirectories))
-            {
-                var ext = Path.GetExtension(file).ToLowerInvariant();
-
-                if (!(cfg.WhitelistExtensions.Contains(ext) || cfg.RomExtensions.Contains(ext)))
-                    continue;
-
-                // 1) compute hash
-                var hash = ComputeHash(file);
-
-                // 2) decide if we need to re‑process
-                if (_cache.TryGetValue(file, out var cached) && cached.Hash == hash)
-                {
-                    // nothing changed – use cached title info
-                    entries.Add(new FileEntry(file, new FileInfo(file).Length, hash, cached.Title));
-                    continue;
-                }
-
-                // 3) extract title if applicable
-                TitleInfo? title = null;
-                if (cfg.RomExtensions.Contains(ext))
-                {
-                    title = NSPExtactor.ExtractFromFile(file);
-                }
-                else
-                {
-                    title = ArchiveHandler.TryExtractTitleInfo(file);
-                }
-
-                // 4) update cache
-                _cache[file] = new CachedFile(file, hash, title);
-
-                // 5) add to snapshot
-                entries.Add(new FileEntry(file, new FileInfo(file).Length, hash, title));
-            }
-        }
-
-        // Replace the entire snapshot
-        lock (_cache)
-        {
-            // the snapshot itself is not stored in _cache – it's only used for the JSON
-        }
-        // we keep entries in a local variable for now
-        _currentSnapshotHash = ComputeSnapshotHash(entries);
-        File.WriteAllText(_jsonPath, JsonSerializer.Serialize(entries));
-    }
-
-    private static string ComputeSnapshotHash(IEnumerable<FileEntry> entries)
-    {
-        var json = JsonSerializer.Serialize(entries);
-        using var sha256 = SHA256.Create();
-        return BitConverter.ToString(sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(json))).Replace("-", "").ToLowerInvariant();
-    }
-
-    private void UpdateSnapshot()
-    {
-        BuildSnapshot();
-        PersistSnapshot();
-    }
-
-    private void PersistSnapshot()
-    {
-        var entries = GetSnapshot();
-        var newHash = ComputeSnapshotHash(entries);
-        if (_currentSnapshotHash != newHash)
-        {
-            _currentSnapshotHash = newHash;
-            File.WriteAllText(_jsonPath, JsonSerializer.Serialize(entries));
-            File.WriteAllText(_snapshotPath, JsonSerializer.Serialize(entries));
-        }
-    }
-
-    private static string ComputeHash(string filePath)
-    {
-        using var sha256 = SHA256.Create();
-        using var stream = File.OpenRead(filePath);
-        var hash = sha256.ComputeHash(stream);
-        return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
-    }
-
-    public IReadOnlyList<FileEntry> GetSnapshot()
-    {
-        var json = File.ReadAllText(_jsonPath);
-        return JsonSerializer.Deserialize<IReadOnlyList<FileEntry>>(json)!;
-    }
-
-    public void Dispose()
-    {
-        _watcher.Dispose();
-        _config.Dispose();
-    }
-}

TinfoilVibeServer/TinfoilVibeServer.csproj

@@ -12,7 +12,9 @@
         <PackageReference Include="SharpCompress" Version="0.41.0" />
         <PackageReference Include="SharpSevenZip" Version="2.0.32" />
 
-        <PackageReference Include="LibHac" Version="0.20.0" />
+        <PackageReference Include="LibHac" Version="0.19.0" />
+
+        <PackageReference Include="System.Interactive.Async" Version="6.0.3" />
     </ItemGroup>
 
     <ItemGroup>
@@ -22,6 +24,9 @@
       <Content Update="appsettings.Development.json">
         <DependentUpon>appsettings.json</DependentUpon>
       </Content>
+      <Content Update="appsettings.json">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </Content>
     </ItemGroup>
 
     <ItemGroup>
@@ -36,4 +41,15 @@
       </Reference>
     </ItemGroup>
 
+    <ItemGroup>
+      <Folder Include="Middleware\" />
+      <Folder Include="Utilities\" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <Compile Include="C:\Users\ecens\.nuget\packages\sharpsevenzip\2.0.32\build\x86\Models\SnapshotEntry.cs">
+        <Link>x86\Models\SnapshotEntry.cs</Link>
+      </Compile>
+    </ItemGroup>
+
 </Project>

TinfoilVibeServer/appsettings.json

@@ -1,23 +1,39 @@
 {
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
+  "Serilog": {
+    "Using": [
+      "Serilog.Sinks.Console"
+    ],
+    "MinimumLevel": "Information",
+    "WriteTo": [
+      {
+        "Name": "Console",
+        "Args": {
+          "outputTemplate": "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}"
+        }
+      }
+    ]
   },
   "AllowedHosts": "*",
-
-  "RootDirectories": [
-    "\\\\NAS\\Games",
-    "\\\\NAS\\Backups"
-  ],
+  "GameDirectories": {
+    "Paths": [
+      "\\\\NAS\\Games",
+      "Z:\\imgs\\roms\\Switch"
+    ]
+  },
+  "SnapshotPath": "snapshot.json",
   "WhitelistExtensions": [
-    ".bin", ".jpg", ".png", ".txt"
+    ".bin",
+    ".jpg",
+    ".png",
+    ".txt"
   ],
   "RomExtensions": [
-    ".xci", ".nsp", ".xcz"
+    ".xci",
+    ".nsp",
+    ".xcz"
   ],
   "SnapshotFile": "index.tfl",
   "SnapshotBackupFile": "snapshot.bin",
-  "ArchiveBufferSize": 8192
-}
+  "ArchiveBufferSize": 8192,
+  "KeySet": "prod.keys"
+}

TinfoilVibeServerTests/TinfoilVibeServerTests.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net9.0</TargetFramework>
+        <LangVersion>latest</LangVersion>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="coverlet.collector" Version="6.0.2"/>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0"/>
+        <PackageReference Include="NUnit" Version="4.2.2"/>
+        <PackageReference Include="NUnit.Analyzers" Version="4.4.0"/>
+        <PackageReference Include="NUnit3TestAdapter" Version="4.6.0"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Using Include="NUnit.Framework"/>
+    </ItemGroup>
+
+</Project>