Installable Modelibr: tray host app + desktop client (Windows, macOS, Linux)

README.md

@@ -8,6 +8,8 @@
 
 Modelibr is a self-hosted game asset library. It keeps **models**, **texture sets**, **environment maps**, **sprites**, and **sounds** in one place, lets you preview them in the browser, and helps you organize them into **projects** and reusable **packs**.
 
+Native installers for Windows, macOS, and Linux are published in the GitHub Releases page. They bundle the local web UI, WebApi, asset processor, and PostgreSQL so non-technical users can run Modelibr without setting up Docker.
+
 **[Main Site](https://papyszoo.github.io/Modelibr/)** | **[Documentation](https://papyszoo.github.io/Modelibr/docs)** | **[Live Demo](https://papyszoo.github.io/Modelibr/demo/)** | **[Discord](https://discord.gg/KgwgTDVP3F)** | **[GitHub Issues](https://github.com/Papyszoo/Modelibr/issues)**
 
 The live demo stores its data in your browser, so what you add there is visible only to you.
@@ -33,6 +35,17 @@ The live demo stores its data in your browser, so what you add there is visible
 
 ## Quick start
 
+### Native installers
+
+Download the installer for your platform from the GitHub Releases page and run it. Two installers are published:
+
+- **Modelibr** (host) — the full self-contained app for users who can't run the Docker stack. It bundles the database, WebApi, and worker runtime and runs from a tray / menu-bar icon. Open its **Show Status** window for live service health, the frontend URL, and a **Configuration** panel (app port, worker process count, jobs per worker, GPU acceleration). The host checks GitHub Releases for newer versions and surfaces an update prompt in the tray and status window.
+- **Modelibr Client** (optional) — a thin desktop window that opens a running host in its own app frame instead of a browser tab. Point it at the host URL shown in the host's status window.
+
+The app and WebDAV are exposed on the same local configurable port.
+
+### Docker
+
 ```bash
 git clone https://github.com/Papyszoo/Modelibr.git
 cd Modelibr
@@ -48,6 +61,7 @@ Open **https://localhost:3010** in your browser. The first visit uses a self-sig
 
 - WebDAV gives Modelibr a more file-browser style workflow, which is useful when you want the library to sit closer to art-pipeline tools.
 - Environment maps are exposed through WebDAV globally and inside packs/projects, alongside the rest of the library.
+- Native installers expose WebDAV through the local launcher port by default.
 - Blender-related flows are part of the repository, and Blender CLI can be downloaded at runtime from the Settings page when you want that workflow.
 - If you want more detail, start with the [main site](https://papyszoo.github.io/Modelibr/) and the [documentation](https://papyszoo.github.io/Modelibr/docs).
 

docs/docs/features/webdav.md

@@ -53,7 +53,9 @@ Each environment map directory exposes:
 
 ## Notes
 
-- Availability depends on your local deployment configuration and network access - you can change ports in .env file.
+- Native installers expose WebDAV on the same local port as the app by default. Change that port in the host status window's **Configuration** panel and restart Modelibr.
+- Docker deployments still use `.env` for WebDAV port configuration.
+- Availability depends on your local deployment configuration and network access.
 
 :::note Video placeholder
 The walkthrough video for this page will be added later.

docs/docs/intro.md

@@ -19,9 +19,24 @@ Modelibr is a self-hosted game asset library that helps you keep models, texture
 
 ## Quick Start
 
+### Option A: Native installer
+
+If you want the simplest local setup, download the **Modelibr** (host) installer for your platform from the GitHub Releases page. It targets users who can't run the Docker stack.
+
+- Windows, macOS, and Linux installers bundle the frontend, WebApi, asset processor, and PostgreSQL.
+- The host runs from a tray / menu-bar icon. Use its **Show Status** window for live service health (backend, database, asset processor) and the frontend URL.
+- The application and WebDAV are exposed on the same local configurable port.
+- Worker process count, jobs per worker, GPU acceleration, and the app port are configured in the host status window's **Configuration** panel.
+- The host checks GitHub Releases for newer versions and shows an update prompt in the tray and status window.
+- An optional **Modelibr Client** installer opens a running host in its own desktop window instead of a browser tab.
+
+Native installs store data in your operating system's application data folder instead of the repository `data` directory.
+
+### Option B: Docker
+
 ### 1. Prerequisites
 
-Modelibr runs on Docker. This ensures it works on any system without polluting your computer with dependencies.
+Modelibr runs on Docker. This remains the most transparent source-based setup and keeps all runtime data in the repository folder.
 
 <details>
 <summary>**How to install Docker**</summary>
@@ -124,6 +139,8 @@ All your uploaded assets, generated thumbnails, and database files are stored in
 Back up the `data` folder regularly to keep your library safe!
 :::
 
+For native installs, the same data lives in the host-managed application data directory. Open it from the host tray menu's **Open Data Folder** action (or the **Data folder** button in the status window).
+
 ## Next Steps
 
 - [Model Management](/docs/features/models) - Learn about versions and organization

package.json

@@ -12,7 +12,9 @@
         "test:frontend": "cd src/frontend && npm test",
         "test:e2e": "cd tests/e2e && npm test",
         "test:e2e:demo": "cd tests/e2e && npm run test:demo",
-        "build:frontend": "cd src/frontend && npm run build"
+        "build:frontend": "cd src/frontend && npm run build",
+        "stage:desktop": "cd src/desktop && npm run stage",
+        "build:desktop": "cd src/desktop && npm run dist"
     },
     "repository": {
         "type": "git",

src/Application/Abstractions/Repositories/IThumbnailJobRepository.cs

@@ -62,6 +62,14 @@ public interface IThumbnailJobRepository
     /// </summary>
     Task<ThumbnailJob?> GetNextPendingJobAsync(CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Atomically claims a still-pending job for a worker via a single conditional
+    /// UPDATE (WHERE Status = Pending). Returns true only for the worker whose
+    /// update actually changed the row, so multiple worker processes can never
+    /// claim the same job. Returns false if another worker already claimed it.
+    /// </summary>
+    Task<bool> TryClaimPendingJobAsync(int jobId, string workerId, DateTime claimedAtUtc, CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Gets all jobs with expired locks.
     /// </summary>

src/Infrastructure/Extensions/DatabaseExtensions.cs

@@ -17,18 +17,15 @@ public static async Task InitializeDatabaseAsync(this WebApplication app)
         try
         {
             logger.LogInformation("Attempting database initialization...");
-
-            // Test basic connectivity first
-            var canConnect = await context.Database.CanConnectAsync();
-            if (!canConnect)
-            {
-                logger.LogWarning("Database is not available. Application will start without database connectivity.");
-                return;
-            }
-
-            // Apply pending migrations to ensure database is up to date
+
+            // MigrateAsync creates the database if it doesn't exist yet and then
+            // applies pending migrations. Do NOT gate this on CanConnectAsync:
+            // that returns false when the database itself is missing (e.g. the
+            // native installer's embedded server, where nothing pre-creates the
+            // "Modelibr" database the way the Docker image's POSTGRES_DB does),
+            // which would skip the very migration meant to create it.
             await context.Database.MigrateAsync();
-            
+
             logger.LogInformation("Database initialization completed successfully");
         }
         catch (Exception ex)

src/Infrastructure/Repositories/ThumbnailJobRepository.cs

@@ -106,7 +106,7 @@
             var job = await _context.ThumbnailJobs
                 .Include(tj => tj.Model)
                 .Include(tj => tj.ModelVersion)
                     .ThenInclude(mv => mv.TextureMappings)
                 .Include(tj => tj.EnvironmentMap)
                 .Include(tj => tj.EnvironmentMapVariant)
                 .Where(tj => tj.Status == ThumbnailJobStatus.Pending || 
@@ -133,6 +133,26 @@
         }
     }
 
+    public async Task<bool> TryClaimPendingJobAsync(int jobId, string workerId, DateTime claimedAtUtc, CancellationToken cancellationToken = default)
+    {
+        // Single atomic statement: UPDATE ... WHERE Id = @id AND Status = Pending.
+        // PostgreSQL row-locks the matching row, so when several workers race only
+        // the first commit changes the row; the rest re-evaluate the predicate
+        // against the now-Processing row and update zero rows. This mirrors the
+        // domain TryClaim transition (status/lock/attempt/timestamp).
+        var rowsAffected = await _context.ThumbnailJobs
+            .Where(tj => tj.Id == jobId && tj.Status == ThumbnailJobStatus.Pending)
+            .ExecuteUpdateAsync(setters => setters
+                .SetProperty(tj => tj.Status, ThumbnailJobStatus.Processing)
+                .SetProperty(tj => tj.LockedBy, workerId)
+                .SetProperty(tj => tj.LockedAt, claimedAtUtc)
+                .SetProperty(tj => tj.AttemptCount, tj => tj.AttemptCount + 1)
+                .SetProperty(tj => tj.UpdatedAt, claimedAtUtc),
+                cancellationToken);
+
+        return rowsAffected == 1;
+    }
+
     public async Task<IEnumerable<ThumbnailJob>> GetJobsWithExpiredLocksAsync(CancellationToken cancellationToken = default)
     {
         var currentTime = DateTime.UtcNow;

src/Infrastructure/Services/ThumbnailQueue.cs

@@ -202,16 +202,24 @@
             return null;
         }
 
-        var claimSuccessful = job.TryClaim(workerId, DateTime.UtcNow);
-        if (!claimSuccessful)
+        // Atomically claim the job so multiple worker processes can't both pick it
+        // up. The conditional UPDATE (WHERE Status = Pending) is resolved by the
+        // database under row locking: exactly one worker's claim changes the row;
+        // any that lose the race affect zero rows and simply poll again.
+        var claimedAt = DateTime.UtcNow;
+        var claimed = await _thumbnailJobRepository.TryClaimPendingJobAsync(job.Id, workerId, claimedAt, cancellationToken);
+        if (!claimed)
         {
-            _logger.LogWarning("Failed to claim job {JobId} for worker {WorkerId}", job.Id, workerId);
+            _logger.LogDebug("Worker {WorkerId} lost the claim race for job {JobId}; will poll again", workerId, job.Id);
             return null;
         }
 
-        await _thumbnailJobRepository.UpdateAsync(job, cancellationToken);
+        // Reflect the persisted claim on the entity returned to the worker (the
+        // atomic UPDATE bypassed the change tracker, so the in-memory copy would
+        // otherwise still look pending). This sets the same fields the UPDATE did.
+        job.TryClaim(workerId, claimedAt);
 
-        _logger.LogInformation("Worker {WorkerId} claimed thumbnail job {JobId} for model {ModelId} version {ModelVersionId} (attempt {AttemptCount})", 
+        _logger.LogInformation("Worker {WorkerId} claimed thumbnail job {JobId} for model {ModelId} version {ModelVersionId} (attempt {AttemptCount})",
             workerId, job.Id, job.ModelId, job.ModelVersionId, job.AttemptCount);
 
         // Notify other workers about job status change for coordination

src/WebApi/Endpoints/SettingsEndpoints.cs

@@ -244,9 +244,15 @@ public static void MapSettingsEndpoints(this IEndpointRouteBuilder app)
 
             try
             {
-                // Probe through the internal nginx HTTP server to validate the full
-                // nginx → webapi chain without TLS certificate issues.
-                var probeUrl = new Uri(new Uri("http://nginx:80"), new Uri(url).PathAndQuery);
+                // Probe through the locally configured edge server so the full
+                // public request chain is validated in both Docker and native mode.
+                var probeBaseUrl = Environment.GetEnvironmentVariable("WEBDAV_PROBE_BASE_URL")?.Trim();
+                if (string.IsNullOrWhiteSpace(probeBaseUrl))
+                {
+                    probeBaseUrl = "http://nginx:80";
+                }
+
+                var probeUrl = new Uri(new Uri(probeBaseUrl), new Uri(url).PathAndQuery);
 
                 var httpClient = httpClientFactory.CreateClient("WebDavProbe");
                 var request = new HttpRequestMessage(new HttpMethod("PROPFIND"), probeUrl);

src/WebApi/Program.cs

@@ -33,22 +33,39 @@ await RestoreOnBootProcessor.RunAsync(builder.Configuration,
             // Allow uploads up to 1 GB (Kestrel + form options)
             const long maxFileSize = 1L * 1024 * 1024 * 1024; // 1 GB
 
-            // Generate a self-signed certificate once in memory for HTTPS
-            var selfSignedCert = GenerateSelfSignedCertificate();
+            var disableHttpsListener = builder.Configuration.GetValue<bool>("DISABLE_HTTPS_LISTENER");
+            var httpPort = builder.Configuration.GetValue<int?>("HTTP_PORT");
+
+            X509Certificate2? selfSignedCert = null;
+            if (!disableHttpsListener)
+            {
+                // Generate a self-signed certificate once in memory for HTTPS
+                selfSignedCert = GenerateSelfSignedCertificate();
+            }
 
             builder.WebHost.ConfigureKestrel(options =>
             {
                 options.Limits.MaxRequestBodySize = maxFileSize;
 
+                if (httpPort is > 0)
+                {
+                    options.ListenAnyIP(httpPort.Value);
+                }
+
+                if (disableHttpsListener)
+                {
+                    return;
+                }
+
                 var httpsPort = builder.Configuration.GetValue<int>("HTTPS_PORT", 8443);
                 options.ListenAnyIP(httpsPort, listenOptions =>
-                    listenOptions.UseHttps(selfSignedCert));
+                    listenOptions.UseHttps(selfSignedCert!));
 
                 var expose443 = builder.Configuration.GetValue<bool>("EXPOSE_443_PORT", true);
                 if (expose443 && httpsPort != 443)
                 {
                     options.ListenAnyIP(443, listenOptions =>
-                        listenOptions.UseHttps(selfSignedCert));
+                        listenOptions.UseHttps(selfSignedCert!));
                 }
             });
             builder.Services.Configure<FormOptions>(options =>
@@ -113,7 +130,7 @@ await RestoreOnBootProcessor.RunAsync(builder.Configuration,
             // Only use HTTPS redirection when not running in a container
             // This prevents certificate issues with internal Docker communication
             var disableHttpsRedirection = builder.Configuration.GetValue<bool>("DisableHttpsRedirection");
-            if (!disableHttpsRedirection)
+            if (!disableHttpsRedirection && !disableHttpsListener)
             {
                 app.UseHttpsRedirection();
             }

src/asset-processor/config.js

@@ -27,6 +27,7 @@ export const config = {
     backgroundColor: process.env.RENDER_BACKGROUND || 'transparent',
     cameraDistance: parseFloat(process.env.CAMERA_DISTANCE) || 5,
     enableAntialiasing: process.env.ENABLE_ANTIALIASING !== 'false',
+    useHardwareAcceleration: process.env.ENABLE_GPU_RENDERING === 'true',
   },
 
   // Orbit animation settings