Encrypt uploads in the browser and send them in chunks

A 6 GB upload kept a customer waiting long after its progress bar
reached 100%. The server wrote every upload three times: PHP's
temporary file, Livewire's copy of it ("Processing files...") and the
encrypted file ("Create Share Link"), each a full rewrite of a slow
disk. The unencrypted copy also stayed behind in livewire-tmp.

Now the uploader's browser encrypts each file in 16 MB chunks with
WebCrypto and PUTs them one at a time; the server checks each chunk in
memory and writes it once, already encrypted. Creating the share only
wraps its key and saves the options. A 200 MB upload through the
Docker image took 2.8 s, and its download matched byte for byte.

- SEALCHK2: a 19-byte header (chunk size, 7-byte nonce prefix), then
  ciphertext and tag per chunk. Each nonce holds the chunk index and a
  last-chunk flag (the STREAM construction), so cut or reordered files
  fail to decrypt. SEALCHK1 and the single-block format still read.
- Envelope encryption: one random key per share. With a password it is
  wrapped with Argon2id (sodium, libsodium's interactive limits) in
  shares.wrapped_key, which names its parameters. Password shares from
  before keep their PBKDF2-derived key.
- The upload page registers each selection with FileUploader into a
  pending share of its own, lists the files with their progress, retries
  a failed chunk after 1-16 s, then offers Retry; Remove and Cancel
  abort. UploadChunkController only accepts chunks from the session that
  started the share: a repeat is acknowledged, a skip gets 409 with the
  count stored. Chunks go out as Blobs, which Chromium sends about eight
  times faster than ArrayBuffers.
- Uploads need a secure context: over plain HTTP the page says HTTPS is
  needed and takes no files. The Docker image gains AUTO_HTTPS, which
  serves Let's Encrypt on 443 for SERVER_NAME and redirects 80; without
  it the container stays on HTTP 80 behind a proxy. docker/Caddyfile was
  never loaded and is gone; docker/healthcheck.sh covers both modes.
- "Download all" streams the ZIP with maennchen/zipstream-php (STORE,
  ZIP64) instead of decrypting whole files into memory and writing the
  archive unencrypted to /tmp.
- Pending shares count towards the quota, stay out of the admin
  dashboard and 404 everywhere else. shares:cleanup deletes uploads idle
  for 4 hours and Livewire temporary files older than that.
- PHP's upload limits no longer cap the admin's max file size and
  default to 64M; LIVEWIRE_MAX_UPLOAD_TIME is gone and
  UPLOAD_CHUNK_SIZE_MB is new.
- Tests cover the format, key wrapping, registration limits, the chunk
  endpoint's answers, completing a share, the streamed ZIP, cleanup,
  and in Chromium a real chunked upload and the HTTPS warning; the
  selected-files overflow test runs again. README, website, CHANGELOG
  and .ai/rules follow.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

app/Console/Commands/CleanupExpiredShares.php

@@ -5,12 +5,18 @@ namespace App\Console\Commands;
 use App\Models\Share;
 use App\Services\ShareService;
 use Illuminate\Console\Command;
+use Livewire\Features\SupportFileUploads\FileUploadConfiguration;
 
 class CleanupExpiredShares extends Command
 {
+    /**
+     * How long an upload or a temporary upload file may sit untouched before it is deleted.
+     */
+    private const ABANDONED_AFTER_HOURS = 4;
+
     protected $signature = 'shares:cleanup';
 
-    protected $description = 'Delete expired shares and shares that have reached their download limit';
+    protected $description = 'Delete expired shares, shares that have reached their download limit, abandoned uploads and old temporary uploads';
 
     public function handle(ShareService $shareService): int
     {
@@ -21,14 +27,49 @@ class CleanupExpiredShares extends Command
             })
             ->get();
 
-        $count = $expiredShares->count();
-
         foreach ($expiredShares as $share) {
             $shareService->deleteShare($share);
         }
 
-        $this->info("Cleaned up {$count} expired share(s).");
+        $this->info("Cleaned up {$expiredShares->count()} expired share(s).");
+
+        // A page that stopped sending chunks: closed, crashed or left behind.
+        $abandonedUploads = Share::query()
+            ->whereNull('completed_at')
+            ->where('updated_at', '<', now()->subHours(self::ABANDONED_AFTER_HOURS))
+            ->get();
+
+        foreach ($abandonedUploads as $share) {
+            $shareService->deleteShare($share);
+        }
+
+        $this->info("Cleaned up {$abandonedUploads->count()} abandoned upload(s).");
+        $this->info('Cleaned up '.$this->deleteOldTemporaryUploads().' temporary upload file(s).');
 
         return self::SUCCESS;
     }
+
+    /**
+     * Delete Livewire's temporary uploads past the same age: the admin logo's, and the unencrypted
+     * copies uploads left there before files were encrypted in the browser.
+     */
+    private function deleteOldTemporaryUploads(): int
+    {
+        if (FileUploadConfiguration::isUsingS3()) {
+            return 0;
+        }
+
+        $storage = FileUploadConfiguration::storage();
+        $cutoff = now()->subHours(self::ABANDONED_AFTER_HOURS)->getTimestamp();
+        $deleted = 0;
+
+        foreach ($storage->allFiles(FileUploadConfiguration::path()) as $path) {
+            if ($storage->exists($path) && $storage->lastModified($path) < $cutoff) {
+                $storage->delete($path);
+                $deleted++;
+            }
+        }
+
+        return $deleted;
+    }
 }