Keep old pages readable, detect stale settings writes, make backups honest

- Own CSS is parsed on write only. A page whose stored CSS no longer
  passes a stricter rule answers 200 and opens in the editor; that one
  block loses its CSS. A document read several times in one request is
  validated once.
- Settings and theme refuse a write from an outdated form.
- A backup fails when a media file does not arrive completely and
  leaves no half directory behind; rotation counts intact backups only.
- The archive update takes its backup behind the maintenance page.
- A package import puts all media in place before removing the old
  ones, reports honestly when that fails and keeps a maintenance state
  that was already on.
- Restoring replaces the SQLite file in one move and points at pending
  migrations.
- Six irreversible actions ask first, in a dialog of the admin's own.
- Ctrl+S in the editor takes the field being typed in along; Delete
  no longer removes a block while a dialog is open.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

src/Ops/ArchiveUpdate.php

@@ -195,16 +195,7 @@ final class ArchiveUpdate
             return ['ok' => false, 'steps' => $schritte];
         }
 
-        // Erst sichern, dann anfassen. Eine Sicherung nach dem Ersetzen wäre keine.
-        try {
-            $sicherung = $this->backup->create('vor dem Update');
-            $melden($schritte, 'Sicherung', true, sprintf('Datenbank und Medien liegen unter var/backups/%s.', (string) ($sicherung['name'] ?? 'sicherung')));
-            $this->phase('laden', sprintf('Fassung %s wird geladen …', $ziel));
-        } catch (\Throwable $fehler) {
-            $melden($schritte, 'Sicherung', false, 'Die Sicherung ist fehlgeschlagen: '.$fehler->getMessage().' Ohne sie wird nichts ersetzt.');
-
-            return ['ok' => false, 'steps' => $schritte];
-        }
+        $this->phase('laden', sprintf('Fassung %s wird geladen …', $ziel));
 
         $archiv = $arbeit.'/kantsites-'.$ziel.'.zip';
         // Direkt in die Datei, nicht erst als Zeichenkette in den Speicher: ein Archiv von einigen
@@ -250,6 +241,20 @@ final class ArchiveUpdate
         $this->updater->maintenance(true);
         $melden($schritte, 'Wartungszustand', true, 'Die Website antwortet währenddessen mit 503.');
 
+        // Erst sichern, dann anfassen - aber erst jetzt, hinter der Wartungsseite. Vorher entstand
+        // die Sicherung vor dem Laden und Entpacken: Was in diesen Sekunden bis Minuten noch
+        // hereinkam (eine Anfrage über ein Formular, ein gespeicherter Entwurf), fehlte in ihr und
+        // war nach einem Zurückschalten weg.
+        try {
+            $sicherung = $this->backup->create('vor dem Update');
+            $melden($schritte, 'Sicherung', true, sprintf('Datenbank und Medien liegen unter var/backups/%s.', (string) ($sicherung['name'] ?? 'sicherung')));
+        } catch (\Throwable $fehler) {
+            $this->updater->maintenance(false);
+            $melden($schritte, 'Sicherung', false, 'Die Sicherung ist fehlgeschlagen: '.$fehler->getMessage().' Ohne sie wird nichts ersetzt.');
+
+            return ['ok' => false, 'steps' => $schritte];
+        }
+
         $alt = $arbeit.'/alt';
         @mkdir($alt, 0o775, true);
         $ersetzt = 0;

src/Ops/Backup.php

@@ -69,6 +69,21 @@ final class Backup
             throw new InvalidPage(sprintf('Das Verzeichnis %s ließ sich nicht anlegen. Schreibrechte auf var/ prüfen.', $directory));
         }
 
+        // Scheitert etwas - typisch: der Speicher ist voll -, bleibt kein halber Ordner liegen. Der
+        // zählte sonst bei der Rotation als eine der neuesten Sicherungen und verdrängte eine
+        // vollständige.
+        try {
+            return $this->write($name, $directory, $reason, $now);
+        } catch (\Throwable $fehler) {
+            $this->remove($directory);
+
+            throw $fehler;
+        }
+    }
+
+    /** @return array{name: string, path: string, manifest: array} */
+    private function write(string $name, string $directory, string $reason, \DateTimeImmutable $now): array
+    {
         $database = $this->copyDatabase($directory);
         $media = $this->copyMedia($directory.'/medien');
         $manifest = [
@@ -88,7 +103,10 @@ final class Backup
             // Not in here, and it is worth saying so where somebody reads it.
             'enthaelt_nicht' => ['.env', '.env.local', 'vendor/', 'Quellcode'],
         ];
-        file_put_contents($directory.'/'.self::MANIFEST, json_encode($manifest, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
+        $text = json_encode($manifest, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
+        if (strlen($text) !== @file_put_contents($directory.'/'.self::MANIFEST, $text)) {
+            throw new InvalidPage('Das Verzeichnis der Sicherung ließ sich nicht vollständig schreiben. Freien Speicherplatz prüfen.');
+        }
 
         return ['name' => $name, 'path' => $directory, 'manifest' => $manifest];
     }
@@ -116,13 +134,23 @@ final class Backup
         return $backups;
     }
 
-    /** Removes the oldest beyond the limit. Returns the names it removed. */
+    /**
+     * Removes the oldest beyond the limit. Returns the names it removed.
+     *
+     * Gezählt werden nur unversehrte Sicherungen: eine beschädigte darf keine vollständige
+     * verdrängen. Beschädigte verschwinden selbst - aber erst nach einer Stunde, denn ein Ordner
+     * ohne Verzeichnis kann auch eine Sicherung sein, die eine andere Anfrage gerade schreibt.
+     */
     public function rotate(int $keep = self::KEEP): array
     {
         $removed = [];
-        foreach (array_slice($this->all(), max(1, $keep)) as $backup) {
-            $this->remove($backup['path']);
-            $removed[] = $backup['name'];
+        $intact = 0;
+        foreach ($this->all() as $backup) {
+            $drop = $backup['intact'] ? ++$intact > max(1, $keep) : (int) @filemtime($backup['path']) < time() - 3600;
+            if ($drop) {
+                $this->remove($backup['path']);
+                $removed[] = $backup['name'];
+            }
         }
 
         return $removed;
@@ -184,7 +212,21 @@ final class Backup
             }
         } else {
             $this->db->close();
-            $copied = @copy($path.'/'.basename($file), $file);
+            // Erst vollständig daneben ablegen, dann in einem Zug an die Stelle setzen: eine halb
+            // geschriebene Datenbank sieht so nie jemand. Journal und WAL der alten Datei müssen
+            // weg - SQLite spielte sie sonst beim nächsten Öffnen in die zurückgeholte Datei ein.
+            $quelle = $path.'/'.basename($file);
+            $neben = $file.'.wiederherstellung';
+            $copied = @copy($quelle, $neben) && filesize($quelle) === filesize($neben);
+            if ($copied) {
+                foreach (['-journal', '-wal', '-shm'] as $rest) {
+                    @unlink($file.$rest);
+                }
+                // Unter Windows scheitert das Umbenennen, solange ein anderer Prozess die Datei
+                // offen hat; dann bleibt der bisherige Weg.
+                $copied = @rename($neben, $file) || @copy($neben, $file);
+            }
+            @unlink($neben);
             if (!$step($steps, 'Datenbank zurückschreiben', $copied, $copied ? basename($file).' ersetzt.' : 'Die Datei ließ sich nicht ersetzen.')) {
                 return ['steps' => $steps, 'ok' => false];
             }
@@ -194,6 +236,12 @@ final class Backup
         // by the very operation that is meant to prevent loss.
         $restored = $this->restoreMedia($path.'/medien');
         $step($steps, 'Medien ergänzen', true, sprintf('%d Datei(en) zurückgeschrieben. Neuere Dateien bleiben erhalten.', $restored));
+        // Eine Sicherung aus einer älteren Fassung bringt deren Datenbankschema mit. Der Code hier
+        // ist neuer und erwartet Spalten, die es dann noch nicht gibt - das muss dastehen, sonst
+        // sucht man die 500er an der falschen Stelle.
+        if (version_compare((string) $manifest['fassung'], $this->version(), '<')) {
+            $step($steps, 'Migrationen', true, sprintf('Die Sicherung stammt aus Fassung %s, installiert ist %s: Jetzt in der Verwaltung unter System „Migrationen ausführen“ – oder: php bin/console doctrine:migrations:migrate.', $manifest['fassung'], $this->version()));
+        }
 
         return ['steps' => $steps, 'ok' => true];
     }
@@ -303,10 +351,17 @@ final class Backup
         $count = 0;
         $bytes = 0;
         foreach (glob($this->mediaDirectory.'/*') ?: [] as $file) {
-            if (is_file($file) && @copy($file, $target.'/'.basename($file))) {
-                ++$count;
-                $bytes += (int) filesize($file);
+            if (!is_file($file)) {
+                continue;
             }
+            $size = (int) filesize($file);
+            // Eine Kopie, die fehlt oder kürzer ist, ist keine: lieber gar keine Sicherung als
+            // eine, die vollständig aussieht und beim Zurückspielen Bilder vermissen lässt.
+            if (!@copy($file, $target.'/'.basename($file)) || $size !== (int) @filesize($target.'/'.basename($file))) {
+                throw new InvalidPage(sprintf('Die Mediendatei %s ließ sich nicht sichern. Freien Speicherplatz und Schreibrechte auf var/backups prüfen.', basename($file)));
+            }
+            ++$count;
+            $bytes += $size;
         }
 
         return ['count' => $count, 'bytes' => $bytes];
@@ -350,7 +405,14 @@ final class Backup
             return false;
         }
 
-        return hash_equals((string) ($manifest['datenbank']['sha256'] ?? ''), (string) hash_file('sha256', $file));
+        if (!hash_equals((string) ($manifest['datenbank']['sha256'] ?? ''), (string) hash_file('sha256', $file))) {
+            return false;
+        }
+        // Auch die Medien gehören dazu: fehlt eine der gezählten Dateien, ist die Sicherung nicht
+        // mehr die, die das Verzeichnis beschreibt.
+        $erwartet = $manifest['medien']['dateien'] ?? null;
+
+        return !is_int($erwartet) || $erwartet <= count(array_filter(glob($path.'/medien/*') ?: [], 'is_file'));
     }
 
     private function size(string $path): int

src/Ops/SitePackage.php

@@ -207,19 +207,34 @@ final class SitePackage
                 return $fail();
             }
 
+            // Eine Wartung, die schon vorher an war, hat jemand mit Absicht eingeschaltet - die
+            // hebt ein Import nicht auf.
+            $inWartung = is_file($this->root.'/'.Updater::MAINTENANCE_FILE);
             $this->updater->maintenance(true);
             try {
-                $media = $this->extractMedia($zip);
-                $this->write($tables, $withUsers);
-                $step('Inhalte ersetzen', true, $this->summary($tables, $withUsers));
-                $moved = $this->replaceMedia($media);
-                $step('Medien ersetzen', true, sprintf('%d Datei(en) übernommen.', $moved));
-            } catch (\Throwable $e) {
-                $step('Inhalte ersetzen', false, $e->getMessage().' Die Datenbank blieb unverändert; die Sicherung liegt bereit.');
+                try {
+                    $media = $this->extractMedia($zip);
+                    $this->write($tables, $withUsers);
+                } catch (\Throwable $e) {
+                    $step('Inhalte ersetzen', false, $e->getMessage().' Die Datenbank blieb unverändert; die Sicherung liegt bereit.');
 
-                return $fail();
+                    return $fail();
+                }
+                $step('Inhalte ersetzen', true, $this->summary($tables, $withUsers));
+                // Ab hier ist die Datenbank die des Pakets. Scheitern die Medien, sagt die Meldung
+                // genau das - und nennt die Sicherung, mit der sich beides zurücknehmen lässt.
+                try {
+                    $moved = $this->replaceMedia($media);
+                } catch (\Throwable $e) {
+                    $step('Medien ersetzen', false, sprintf('%s Die Inhalte sind bereits die des Pakets, die Medien nicht vollständig. Zurück auf den Stand vorher: cms:restore %s.', $e->getMessage(), $safety['name']));
+
+                    return $fail();
+                }
+                $step('Medien ersetzen', true, sprintf('%d Datei(en) übernommen.', $moved));
             } finally {
-                $this->updater->maintenance(false);
+                if (!$inWartung) {
+                    $this->updater->maintenance(false);
+                }
                 if (isset($media)) {
                     $this->remove($media);
                 }
@@ -435,25 +450,45 @@ final class SitePackage
         return $target;
     }
 
-    /** Leert den Medienordner (die Sicherung hat ihn) und legt die Dateien des Pakets hinein. */
+    /**
+     * Legt die Dateien des Pakets in den Medienordner und entfernt danach, was nicht dazugehört.
+     *
+     * In dieser Reihenfolge: Erst wenn jede Datei des Pakets angekommen ist, verschwinden die
+     * alten. Vorher wurde zuerst geleert und dann kopiert, ohne nachzuzählen - bei knappem
+     * Speicher meldete der Import Erfolg, und die Website verwies auf Bilder, die es nicht gab.
+     *
+     * @throws \RuntimeException wenn eine Datei nicht ankommt; der Medienordner hat dann noch alle alten Dateien
+     */
     private function replaceMedia(string $source): int
     {
         if (!is_dir($this->mediaDirectory) && !@mkdir($this->mediaDirectory, 0o775, true)) {
             throw new \RuntimeException('Der Medienordner ließ sich nicht anlegen.');
         }
+        $neu = [];
+        foreach (scandir($source) ?: [] as $name) {
+            if (1 !== preg_match(self::MEDIA_NAME, $name)) {
+                continue;
+            }
+            $size = (int) filesize($source.'/'.$name);
+            $target = $this->mediaDirectory.'/'.$name;
+            // Verschieben braucht keinen zweiten Platz auf der Platte; über Laufwerksgrenzen
+            // hinweg bleibt das Kopieren.
+            if (!@rename($source.'/'.$name, $target) && !@copy($source.'/'.$name, $target)) {
+                throw new \RuntimeException(sprintf('Die Mediendatei %s ließ sich nicht ablegen. Freien Speicherplatz prüfen.', $name));
+            }
+            clearstatcache(true, $target);
+            if ($size !== (int) @filesize($target)) {
+                throw new \RuntimeException(sprintf('Die Mediendatei %s kam unvollständig an. Freien Speicherplatz prüfen.', $name));
+            }
+            $neu[$name] = true;
+        }
         foreach (scandir($this->mediaDirectory) ?: [] as $name) {
-            if (1 === preg_match(self::MEDIA_NAME, $name)) {
+            if (!isset($neu[$name]) && 1 === preg_match(self::MEDIA_NAME, $name)) {
                 @unlink($this->mediaDirectory.'/'.$name);
             }
         }
-        $count = 0;
-        foreach (scandir($source) ?: [] as $name) {
-            if (1 === preg_match(self::MEDIA_NAME, $name) && @copy($source.'/'.$name, $this->mediaDirectory.'/'.$name)) {
-                ++$count;
-            }
-        }
 
-        return $count;
+        return \count($neu);
     }
 
     private function summary(array $tables, bool $withUsers): string