Antigravity KI-Architektur: Ubuntu Server Info Script mit PHP & SQLite

KI & Agenten

#Fehlerbehandlung #Robustheit #Systemtests #Fallback #Protokollierung

🔊

Artikel vorlesen lassen

Realistische Neural Voice (Edge TTS)

Quelle: admin_eintrag_2026-06-13.txt

🚀 Antigravity Execution

Kopiere den generierten Code/Prompt und füge ihn direkt in Antigravity ein.

## 1. Agenten-Identität, Kernziele und System-Prompt Definition für das Ubuntu Projekt

### 1.1 Agenten-Identität: 'UbuntuSysAdminAI'

**Rolle:** Der 'UbuntuSysAdminAI' ist ein spezialisierter KI-Agent, der darauf trainiert ist, die Verwaltung und Überwachung von Ubuntu-Servern zu automatisieren und zu optimieren. Seine Kernkompetenz liegt im Verständnis von Systemkonfigurationen, der Extraktion relevanter Informationen und der Bereitstellung dieser Daten in einem zugänglichen Format. Er agiert als virtueller Systemadministrator mit Fokus auf Effizienz und Präzision.

**Persönlichkeit:** Analytisch, präzise, proaktiv, sicherheitsbewusst. Der Agent kommuniziert klar und strukturiert, vermeidet unnötige Komplexität und liefert direkt umsetzbare Informationen. Er ist darauf bedacht, die Stabilität und Leistung des Systems zu gewährleisten.

### 1.2 Kernziele für das Ubuntu Server Info Script

Das primäre Ziel dieses Projekts ist die Entwicklung eines robusten und effizienten Skripts, das detaillierte Informationen über einen Ubuntu 24.04 Server sammelt und speichert. Die Kernziele sind:

*   **Informationsextraktion:** Zuverlässige Erfassung kritischer Systeminformationen (Hardware, Software, Netzwerk, Dienste, Systemlast etc.).
*   **Datenpersistenz:** Sichere und strukturierte Speicherung der extrahierten Daten in einer SQLite-Datenbank.
*   **Zugänglichkeit:** Bereitstellung der gesammelten Informationen über eine einfach zu bedienende Schnittstelle (implizit durch das Skript bereitgestellt).
*   **Automatisierung:** Ermöglichung der regelmäßigen Ausführung zur kontinuierlichen Überwachung.
*   **Flexibilität:** Unterstützung von PHP 8.3+ für die Skriptlogik und SQLite für die Datenhaltung.
*   **Sicherheit:** Berücksichtigung grundlegender Sicherheitsaspekte bei der Datenerfassung und -speicherung.

### 1.3 System-Prompt Definition für 'UbuntuSysAdminAI'

Der folgende System-Prompt definiert die Aufgaben und Einschränkungen für den 'UbuntuSysAdminAI' im Kontext der Erstellung und Wartung des Ubuntu Server Info Scripts.

```
Du bist der 'UbuntuSysAdminAI', ein spezialisierter KI-Architekt, der die Entwicklung eines serverinfo.php Skripts für Ubuntu 24.04 mit PHP 8.3+ und einer SQLite-Datenbank leitet. Deine Aufgabe ist es, die Architektur, die Datenmodelle und die Logik für dieses Skript zu entwerfen und detailliert zu beschreiben.

WICHTIGE EINSCHRÄNKUNGEN:
1.  Du darfst KEINEN echten Code generieren. Jegliche Stelle, die normalerweise Code enthalten würde, MUSS exakt diesen Text enthalten: [Code-Block - Bitte selbständig passenden Code generieren].
2.  Fokus liegt ausschließlich auf der Beschreibung der Architektur, der Logik, der Datenstrukturen und der Meta-Prompts für die Implementierung.
3.  Erstelle detaillierte Meta-Prompts und Anweisungen für die Implementierung durch einen Entwickler.
4.  Strukturiere deine Antwort klar mit Markdown-Überschriften.
5.  Beginne deine Antwort IMMER mit der exakten Zeile '6.  Beschreibe die erforderlichen PHP-Funktionen und SQL-Abfragen konzeptionell.

DEINE AUFGABEN:
*   Definiere die zu sammelnden Systeminformationen detailliert.
*   Entwerfe das Datenbankschema für die SQLite-Datenbank.
*   Beschreibe die PHP-Logik für die Datenerfassung und -speicherung.
*   Erstelle Meta-Prompts für die Implementierung einzelner Komponenten des Skripts.
*   Sicherstellen, dass die Architektur für die Nutzung von PHP 8.3+ und SQLite optimiert ist.
*   Berücksichtige die Lesbarkeit, Wartbarkeit und Effizienz des entworfenen Systems.
```

## 2. Benötigte Tool-Befehle und Rechte-Management für das Server-Info-Skript

Dieses Kapitel beschreibt die notwendigen Werkzeuge und deren Konfiguration, um ein Server-Info-Skript auf Ubuntu 24.04 mit PHP 8.3+ und einer SQLite-Datenbank zu implementieren. Der Fokus liegt auf den spezifischen Befehlen und den erforderlichen Rechten.

### 2.1 Installation und Konfiguration von PHP 8.3+

Um PHP 8.3 oder höher zu installieren und zu konfigurieren, sind folgende Schritte und Werkzeuge erforderlich:

#### 2.1.1 Installation von PHP und benötigten Erweiterungen

*   **System-Update:** Vor der Installation sollte das Paketverwaltungssystem aktualisiert werden.
    *   Befehl: `apt update && apt upgrade -y`
    *   Rechte: Root-Berechtigungen (sudo) sind erforderlich.
*   **Installation von PHP:** Installation der neuesten stabilen PHP-Version und gängiger Erweiterungen, die für Webanwendungen und die Datenbankanbindung notwendig sind.
    *   Befehl: `apt install php8.3 php8.3-cli php8.3-fpm php8.3-sqlite3 php8.3-curl php8.3-json php8.3-mbstring -y`
    *   Rechte: Root-Berechtigungen (sudo) sind erforderlich.
*   **Überprüfung der PHP-Version:** Nach der Installation sollte die installierte Version verifiziert werden.
    *   Befehl: `php -v`
    *   Rechte: Keine speziellen Rechte erforderlich.

#### 2.1.2 PHP-Konfiguration (php.ini)

Die PHP-Konfiguration beeinflusst das Verhalten von PHP-Skripten. Die relevanteste Datei ist `php.ini`.

*   **Konfigurationsdatei-Pfad:** Der genaue Pfad kann variieren, typischerweise unter `/etc/php/8.3/cli/php.ini` oder `/etc/php/8.3/fpm/php.ini`.
*   **Wichtige Einstellungen (Beispiele):**
    *   `memory_limit`: Begrenzung des Speicherverbrauchs für PHP-Skripte.
    *   `max_execution_time`: Maximale Ausführungszeit für PHP-Skripte.
    *   `date.timezone`: Festlegung der Zeitzone, um korrekte Zeitstempel zu gewährleisten.
*   **Änderung der Konfiguration:** Änderungen erfordern das Bearbeiten der `php.ini`-Datei und den anschließenden Neustart des Webservers oder PHP-FPM-Dienstes.
    *   Bearbeitung: Verwenden Sie einen Texteditor wie `nano` oder `vim`.
        *   Beispiel-Befehl: `sudo nano /etc/php/8.3/cli/php.ini`
    *   Neustart des Dienstes (z.B. PHP-FPM):
        *   Befehl: `sudo systemctl restart php8.3-fpm`
        *   Rechte: Root-Berechtigungen (sudo) sind erforderlich.

### 2.2 Installation und Konfiguration von SQLite

SQLite ist eine dateibasierte Datenbank und erfordert keine separaten Serverprozesse.

*   **Installation des SQLite-Pakets:** Auf den meisten modernen Ubuntu-Systemen ist SQLite bereits vorinstalliert. Falls nicht, kann es wie folgt installiert werden:
    *   Befehl: `sudo apt install sqlite3 -y`
    *   Rechte: Root-Berechtigungen (sudo) sind erforderlich.
*   **Überprüfung der SQLite-Installation:**
    *   Befehl: `sqlite3 --version`
    *   Rechte: Keine speziellen Rechte erforderlich.
*   **Datenbankerstellung und -zugriff:**
    *   Um eine neue SQLite-Datenbank zu erstellen oder auf eine bestehende zuzugreifen, kann der `sqlite3`-Befehl verwendet werden.
    *   Beispiel-Befehl zur Erstellung einer Datenbankdatei: `sqlite3 /pfad/zur/datenbank.db`
    *   Innerhalb der SQLite-Shell können SQL-Befehle ausgeführt werden.
    *   Rechte: Das Skript, das auf die Datenbank zugreift, benötigt Lese-/Schreibberechtigungen für die Datenbankdatei und das Verzeichnis, in dem sie sich befindet.

### 2.3 Bash-Werkzeuge und Dateizugriff

Das Skript wird wahrscheinlich auf verschiedene Systeminformationen zugreifen und Konfigurationsdateien lesen müssen.

*   **Standard-Bash-Befehle:**
    *   `cat`: Zum Anzeigen von Dateiinhalten (z.B. `/etc/os-release`, `/proc/meminfo`).
    *   `grep`: Zum Filtern von Textausgaben.
    *   `df`: Zur Anzeige von Festplattenspeicher.
    *   `free`: Zur Anzeige von Arbeitsspeicher.
    *   `uname`: Zur Anzeige von Systeminformationen (Kernel, Architektur).
    *   `lshw`: Zur Anzeige von Hardware-Informationen (kann zusätzliche Installation erfordern: `sudo apt install lshw`).
*   **Dateizugriffsberechtigungen:**
    *   Das ausführende Benutzerkonto des PHP-Skripts (z.B. der Webserver-Benutzer wie `www-data`) benötigt Leseberechtigungen für die Dateien und Verzeichnisse, auf die zugegriffen werden soll.
    *   Wenn das Skript bestimmte Systeminformationen abfragen muss, die normalerweise nur für Root zugänglich sind, muss der Webserver-Benutzer möglicherweise Mitglied einer bestimmten Gruppe werden oder es müssen spezielle Konfigurationen vorgenommen werden (z.B. `sudoers`-Datei, was jedoch mit Vorsicht zu genießen ist).
    *   **Wichtig:** Direkter Root-Zugriff für den Webserver-Benutzer ist ein erhebliches Sicherheitsrisiko und sollte vermieden werden. Wenn unbedingt erforderlich, sollten sehr spezifische Berechtigungen mittels `sudoers` konfiguriert werden.
        *   Beispiel-Syntax in `/etc/sudoers` (nicht direkt bearbeiten, `visudo` verwenden): `www-data ALL=(ALL) NOPASSWD: /pfad/zu/spezifischem/kommando`

### 2.4 Rechte-Management und Sicherheitshinweise

*   **Dateisystemberechtigungen:**
    *   Alle Verzeichnisse und Dateien, die das Skript erstellt oder verwendet (z.B. die SQLite-Datenbankdatei), sollten restriktive Berechtigungen haben, die nur den notwendigen Zugriff erlauben.
    *   Der Webserver-Benutzer (z.B. `www-data`) benötigt in der Regel Schreibzugriff auf das Verzeichnis, in dem die SQLite-Datenbankdatei gespeichert ist, sowie Leseberechtigung für die Datenbankdatei selbst.
    *   Beispiel: Setzen von Eigentümer und Gruppe für die Datenbankdatei: `chown www-data:www-data /pfad/zur/datenbank.db`
    *   Beispiel: Setzen von Dateiberechtigungen: `chmod 640 /pfad/zur/datenbank.db`
*   **PHP-Ausführungskontext:**
    *   Wenn das PHP-Skript über einen Webserver ausgeführt wird, läuft es unter dem Benutzerkonto des Webservers (z.B. `www-data`). Die Berechtigungen müssen für diesen Benutzer konfiguriert werden.
    *   Wenn das Skript als CLI-Skript ausgeführt wird, läuft es unter dem Benutzer, der den Befehl ausführt.
*   **SQLite-Datenbankdatei:** Die SQLite-Datenbankdatei sollte nicht global beschreibbar sein. Idealerweise hat nur der Benutzer, der das PHP-Skript ausführt, Lese-/Schreibzugriff.
*   **Sicherheitsrisiken:**
    *   Vermeiden Sie es, sensible Systeminformationen direkt im Klartext in der Datenbank zu speichern, wenn diese nicht unbedingt erforderlich sind.
    *   Stellen Sie sicher, dass die PHP-Umgebung sicher konfiguriert ist (z.B. deaktivieren Sie `exec()`, `system()` und andere potenziell gefährliche Funktionen, es sei denn, sie sind für das Skript unbedingt notwendig und werden sorgfältig validiert).
    *   Führen Sie keine Befehle aus, deren Eingaben nicht vollständig validiert und bereinigt sind, um Command Injection zu verhindern.

## 3. Schritt-für-Schritt Execution Plan (Phase 1: Setup & DB)

Dieser Plan beschreibt die einzelnen Schritte zur Einrichtung der notwendigen Umgebung für das Server-Info-Skript auf Ubuntu 24.04 mit PHP 8.3+ und einer SQLite-Datenbank.

### 3.1. Systemaktualisierung und Vorbereitung

Bevor wir mit der Installation spezifischer Software beginnen, ist es ratsam, das System auf den neuesten Stand zu bringen und grundlegende Werkzeuge zu installieren.

**Meta-Prompt:** Erstelle eine Liste von Befehlen zur Aktualisierung des Paketindex, zur Aktualisierung installierter Pakete und zur Installation grundlegender Entwicklungswerkzeuge, die für die folgenden Schritte benötigt werden.

**Anweisungen:**
1.  Führe den Befehl zur Aktualisierung des Paketindex aus.
2.  Führe den Befehl zur Durchführung eines vollständigen Systemupgrades aus.
3.  Installiere das Paket `build-essential`, welches grundlegende Compiler und Entwicklungswerkzeuge enthält.
4.  Installiere das Paket `git`, falls es noch nicht vorhanden ist, da es für die Verwaltung von Skripten und Abhängigkeiten nützlich sein kann.
5.  Führe den Befehl aus, um sicherzustellen, dass das System nach der Aktualisierung neu gestartet werden kann, falls dies erforderlich ist (dieser Schritt ist optional, wird aber empfohlen).

```
[Code-Block - Bitte selbständig passenden Code generieren]
```

### 3.2. PHP 8.3+ Installation

Wir stellen sicher, dass eine kompatible PHP-Version installiert ist. Da Ubuntu 24.04 wahrscheinlich PHP 8.3+ standardmäßig mitbringt oder über offizielle Repositories leicht verfügbar macht, konzentrieren wir uns auf die Installation und die notwendigen Erweiterungen.

**Meta-Prompt:** Erstelle eine Anweisung zur Installation von PHP 8.3 und den erforderlichen Erweiterungen für Webanwendungen und die SQLite-Integration.

**Anweisungen:**
1.  Stelle sicher, dass das PPA (Personal Package Archive) für PHP-Updates auf dem System aktiviert ist, falls die Standard-Repositorys nicht die gewünschte Version bereitstellen. (Annahme: Ubuntu 24.04 hat PHP 8.3+ in den Standard-Repositories).
2.  Installiere das Paket `php8.3` oder die entsprechende Version, die auf dem System verfügbar ist.
3.  Installiere die folgenden PHP-Erweiterungen:
    *   `php8.3-sqlite3`: Für die SQLite-Datenbankintegration.
    *   `php8.3-cli`: Um PHP-Skripte über die Kommandozeile auszuführen.
    *   `php8.3-common`: Gemeinsame Dateien für PHP.
    *   `php8.3-mbstring`: Für die Handhabung von Multibyte-Zeichenketten.
    *   `php8.3-xml`: Für die Verarbeitung von XML-Daten.
    *   `php8.3-curl`: Für Netzwerkverbindungen.
    *   `php8.3-json`: Für die Verarbeitung von JSON-Daten.
    *   `php8.3-intl`: Für internationale und Unicode-Zeichenkettenfunktionen.
4.  Überprüfe die installierte PHP-Version mit dem Befehl `php -v`.

```
[Code-Block - Bitte selbständig passenden Code generieren]
```

### 3.3. SQLite Datenbankeinrichtung

SQLite ist eine dateibasierte Datenbank, die keine separate Serverinstallation erfordert. Wir erstellen hier lediglich die notwendige Datenbankdatei und stellen sicher, dass die Berechtigungen korrekt gesetzt sind.

**Meta-Prompt:** Erstelle eine Anweisung zur Erstellung einer SQLite-Datenbankdatei und zur Festlegung der erforderlichen Dateiberechtigungen für den Zugriff durch den Webserver oder das Skript.

**Anweisungen:**
1.  Lege ein Verzeichnis für die Datenbankdateien fest (z. B. `/var/lib/antigravity_server_info/db/`). Erstelle dieses Verzeichnis, falls es noch nicht existiert.
2.  Erstelle die SQLite-Datenbankdatei innerhalb dieses Verzeichnisses (z. B. `server_info.db`).
3.  Lege die Besitzrechte für das Datenbankverzeichnis und die Datenbankdatei so fest, dass der Benutzer, unter dem der Webserver (z. B. Apache, Nginx) läuft, Lese- und Schreibzugriff hat. Falls das Skript auch über die Kommandozeile ausgeführt wird, sollte der ausführende Benutzer ebenfalls Zugriff haben. Ein gängiger Ansatz ist, den Besitzer auf den Webserver-Benutzer (z. B. `www-data`) zu setzen oder einer Gruppe zuzuweisen, der der Webserver-Benutzer und der Skript-Benutzer angehören.
4.  Setze die Dateiberechtigungen, um Schreibzugriff für den Besitzer zu ermöglichen und Lesezugriff für andere, falls erforderlich, aber vermeide zu offene Berechtigungen.

```
[Code-Block - Bitte selbständig passenden Code generieren]
```

## 4. Schritt-für-Schritt Execution Plan (Phase 2: Backend & API)

Dieser Abschnitt beschreibt den schrittweisen Plan für die Implementierung des Backends und der API zur Erstellung eines Server-Info-Skripts für Ubuntu 24.04 mit PHP 8.3+ und einer SQLite-Datenbank.

### 4.1. Vorbereitung und Setup

#### 4.1.1. Entwicklungsumgebung einrichten

**Meta-Prompt:**
Erstelle eine detaillierte Anleitung zur Einrichtung einer lokalen Entwicklungsumgebung für die Backend-Entwicklung des Server-Info-Skripts. Stelle sicher, dass die Anleitung alle notwendigen Schritte für die Installation von PHP 8.3+ und der SQLite-Unterstützung auf einem Linux-basierten System (ähnlich Ubuntu 24.04) enthält. Beschreibe auch die Installation von Composer und optional eines Webservers (wie Nginx oder Apache) für lokale Tests.

**Anweisungen:**
1.  **PHP 8.3+ Installation:**
    *   Beschreibe den Prozess der Hinzufügung eines PPAs (Personal Package Archive) für neuere PHP-Versionen, falls diese nicht in den Standard-Repositories von Ubuntu 24.04 enthalten sind.
    *   Gib die Befehle zur Installation von `php8.3` und den notwendigen Erweiterungen an, insbesondere `php8.3-sqlite3`, `php8.3-mbstring`, `php8.3-xml`, `php8.3-json`, `php8.3-curl`.
    *   Führe einen Befehl zur Überprüfung der installierten PHP-Version an.
2.  **Composer Installation:**
    *   Beschreibe die Schritte zur globalen Installation von Composer.
    *   Gib die Befehle zur Installation und Überprüfung der Composer-Version an.
3.  **Webserver Konfiguration (Optional, aber empfohlen für lokale Tests):**
    *   Beschreibe die Installation von Nginx oder Apache.
    *   Skizziere eine grundlegende virtuelle Host-Konfiguration, die auf das Projektverzeichnis verweist und PHP-Anfragen korrekt an den PHP-FPM-Prozess weiterleitet.
    *   Erkläre, wie man die Konfiguration testet.
4.  **Projektverzeichnis erstellen:**
    *   Gib einen Befehl zur Erstellung eines Hauptverzeichnisses für das Projekt.
    *   Navigiere in dieses Verzeichnis.

#### 4.1.2. Projektstruktur anlegen

**Meta-Prompt:**
Definiere und beschreibe eine klare und skalierbare Projektstruktur für das Backend des Server-Info-Skripts. Stelle sicher, dass die Struktur eine Trennung von Belangen (Separation of Concerns) fördert, z. B. durch Verzeichnisse für Controller, Modelle, Datenbank-Zugriffsschichten, Konfigurationen und öffentliche Assets.

**Anweisungen:**
1.  **Hauptverzeichnis:**
    *   `project-root/`
2.  **Öffentliches Verzeichnis (Web-Root):**
    *   `public/`
        *   `index.php` (Der Einstiegspunkt der Anwendung, der die Anfrage weiterleitet.)
        *   `assets/` (Für statische Assets wie CSS/JS, obwohl für diese spezifische Aufgabe weniger relevant.)
3.  **Anwendungslogik-Verzeichnis:**
    *   `src/`
        *   `Controllers/` (Klassen, die eingehende Anfragen verarbeiten und Antworten generieren.)
        *   `Models/` (Klassen, die Datenstrukturen und Geschäftslogik repräsentieren.)
        *   `Database/` (Klassen für die Datenbankinteraktion, insbesondere für SQLite.)
        *   `Helpers/` (Hilfsfunktionen und -klassen.)
4.  **Konfigurationsverzeichnis:**
    *   `config/`
        *   `database.php` (Einstellungen für die SQLite-Datenbankverbindung.)
5.  **Abhängigkeitsmanagement:**
    *   `vendor/` (Wird von Composer verwaltet.)
    *   `composer.json` (Definiert Projektmetadaten und Abhängigkeiten.)
    *   `composer.lock` (Speichert die exakten Versionen der installierten Abhängigkeiten.)
6.  **Skripte:**
    *   `bin/` (Für ausführbare Skripte, z. B. zur Datenbankinitialisierung.)

#### 4.1.3. Composer initialisieren und Abhängigkeiten definieren

**Meta-Prompt:**
Beschreibe den Prozess der Initialisierung von Composer für das Projekt und die Definition der notwendigen Abhängigkeiten, insbesondere für das Erstellen einer `composer.json`-Datei. Skizziere die notwendigen Felder und gibt an, welche Pakete benötigt werden könnten, auch wenn sie für dieses einfache Skript minimal sind.

**Anweisungen:**
1.  **`composer.json` erstellen:**
    *   Erkläre, wie man den Befehl `composer init` ausführt und welche Informationen abgefragt werden (Paketname, Beschreibung, Autor, Stabilität etc.).
    *   Beschreibe die Struktur einer grundlegenden `composer.json`-Datei.
2.  **Abhängigkeiten definieren:**
    *   Für dieses spezifische Projekt werden wahrscheinlich keine externen PHP-Bibliotheken von Drittanbietern zwingend benötigt, da die Funktionalität mit der Standardbibliothek abgedeckt werden kann. Erkläre trotzdem, wie man eine Abhängigkeit hinzufügt.
    *   Beispiel für eine hypothetische Abhängigkeit (wenn benötigt): `"monolog/monolog": "^2.0"`
    *   Füge die PSR-4 Autoloader-Konfiguration hinzu, um das automatische Laden von Klassen im `src/` Verzeichnis zu ermöglichen.
    *   Beispielhafte `autoload`-Sektion in `composer.json`:
        ```json
        "autoload": {
            "psr-4": {
                "App\\": "src/"
            }
        }
        ```
3.  **Abhängigkeiten installieren:**
    *   Gib den Befehl `composer install` an, um die Abhängigkeiten aus der `composer.json`-Datei herunterzuladen und den Autoloader zu generieren.
    *   Erkläre, dass dies das `vendor/` Verzeichnis und die `vendor/autoload.php`-Datei erstellt.

### 4.2. Datenbankdesign und -implementierung

#### 4.2.1. SQLite Datenbankdatei erstellen und Struktur definieren

**Meta-Prompt:**
Beschreibe die Erstellung einer SQLite-Datenbankdatei und die Definition der notwendigen Tabellenstruktur, um Server-Informationen zu speichern. Erkläre, welche Spalten für jede Tabelle relevant sind und welche Datentypen verwendet werden sollen.

**Anweisungen:**
1.  **Datenbankdatei erstellen:**
    *   Skizziere ein PHP-Skript (z. B. `bin/setup_database.php`) oder einen manuellen Befehl, der eine SQLite-Datei erstellt, falls sie noch nicht existiert.
    *   Beispielhaftes SQL für die Tabellenerstellung:
        ```sql
        CREATE TABLE IF NOT EXISTS server_info (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            key TEXT NOT NULL UNIQUE,
            value TEXT,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
        );
        ```
    *   Erkläre die Bedeutung der Spalten: `key` (eindeutiger Bezeichner für die Information, z.B. "hostname", "cpu_cores"), `value` (der tatsächliche Wert der Information), `created_at`, `updated_at`.
    *   Erkläre, wie die Datenbankdatei (`database.sqlite`) im Projektverzeichnis oder einem separaten `data/` Verzeichnis gespeichert werden könnte.

#### 4.2.2. Datenbankzugriffslogik implementieren

**Meta-Prompt:**
Entwickle die Klassen und Methoden innerhalb des `src/Database/` Verzeichnisses, die für die Interaktion mit der SQLite-Datenbank zuständig sind. Dies umfasst die Herstellung der Verbindung, das Abrufen von Daten und das Speichern/Aktualisieren von Informationen. Vermeide die Erzeugung von konkretem Code, beschreibe stattdessen die Logik und die Schnittstellen.

**Anweisungen:**
1.  **Datenbankverbindungs-Manager:**
    *   Beschreibe eine Klasse (`DatabaseManager` oder ähnlich) im `src/Database/` Verzeichnis.
    *   Diese Klasse soll für die sichere Herstellung und Verwaltung der PDO-Verbindung zur SQLite-Datenbank verantwortlich sein.
    *   Sie sollte eine Methode zur Abfrage (ReadOnly) und eine Methode für schreibende Operationen (Read/Write) bereitstellen, um Transaktionen zu handhaben.
    *   Die Datenbankkonfiguration (Dateipfad) sollte aus einer Konfigurationsdatei geladen werden.
2.  **Repository-Pattern (für Datenzugriff):**
    *   Beschreibe eine `ServerInfoRepository`-Klasse, die das Repository-Pattern implementiert.
    *   Diese Klasse nutzt die Datenbankverbindung vom `DatabaseManager`.
    *   Sie sollte Methoden für folgende Operationen definieren:
        *   `get(string $key): ?string` (Ruft den Wert für einen bestimmten Schlüssel ab.)
        *   `set(string $key, string $value): bool` (Speichert oder aktualisiert einen Wert für einen Schlüssel.)
        *   `getAll(): array` (Ruft alle Schlüssel-Wert-Paare ab.)
        *   `delete(string $key): bool` (Löscht einen Schlüssel-Wert-Eintrag.)
        *   `exists(string $key): bool` (Prüft, ob ein Schlüssel existiert.)
    *   Beschreibe die interne Logik, wie diese Methoden SQL-Abfragen auf der SQLite-Datenbank ausführen, z. B. `SELECT key, value FROM server_info WHERE key = ?` oder `INSERT OR REPLACE INTO server_info (key, value) VALUES (?, ?)`.

### 4.3. Server-Informationen sammeln und speichern

#### 4.3.1. Logik zur Informationsbeschaffung entwickeln

**Meta-Prompt:**
Entwickle die Klassen und Methoden im `src/` Verzeichnis, die für die Sammlung verschiedener Server-Informationen auf einem Ubuntu 24.04-System verantwortlich sind. Beschreibe, wie auf Systembefehle zugegriffen wird und wie die Ausgabe verarbeitet wird, um strukturierte Daten zu erhalten. Gib Beispiele für die Arten von Informationen, die gesammelt werden können.

**Anweisungen:**
1.  **Informationssammler-Basisklasse/Interface:**
    *   Beschreibe ein Interface (`InformationCollectorInterface`) oder eine abstrakte Basisklasse (`AbstractInformationCollector`), das/die eine Methode `collect(): array` definiert. Diese Methode soll die gesammelten Informationen als assoziatives Array zurückgeben.
2.  **Spezifische Sammler-Klassen:**
    *   Erstelle (beschreibe) spezifische Sammler-Klassen für verschiedene Informationskategorien, die von den jeweiligen Systembefehlen und PHP-Funktionen abhängen. Beispiele:
        *   `HostnameCollector`: Sammelt den Hostnamen über `gethostname()` oder den Befehl `hostname`.
        *   `CpuCollector`: Sammelt Informationen zur CPU-Auslastung und Anzahl der Kerne (z.B. über `lscpu` oder `/proc/stat`).
        *   `MemoryCollector`: Sammelt Informationen zum Arbeitsspeicher (verfügbar, gesamt) über `free -m` oder `/proc/meminfo`.
        *   `DiskCollector`: Sammelt Informationen zur Festplattennutzung über `df -h`.
        *   `NetworkCollector`: Sammelt Netzwerkschnittstellen und IP-Adressen über `ip addr` oder `ifconfig`.
        *   `OsCollector`: Sammelt Betriebssysteminformationen (Name, Version) über `lsb_release -a` oder `/etc/os-release`.
        *   `PhpVersionCollector`: Sammelt die PHP-Version mit `php -v`.
        *   `DatabaseVersionCollector`: Sammelt die SQLite-Version mit `SELECT sqlite_version();`.
    *   Beschreibe für jede Sammler-Klasse, wie sie externe Befehle ausführt (z.B. mittels `exec()`, `shell_exec()`, `proc_open()`) und wie die Rohausgabe geparst wird, um die gewünschten Daten zu extrahieren und in ein strukturiertes Format (z.B. assoziatives Array) zu bringen.
    *   Betone die Bedeutung der Fehlerbehandlung und der Bereinigung der Ausgabe.

#### 4.3.2. Orchestrierung der Datensammlung und Speicherung

**Meta-Prompt:**
Entwickle eine zentrale Klasse oder Funktion, die die Ausführung der verschiedenen Informationssammler orchestriert, die gesammelten Daten validiert und sie dann mithilfe des `ServerInfoRepository` in der SQLite-Datenbank speichert.

**Anweisungen:**
1.  **Orchestrator-Klasse/Service:**
    *   Beschreibe eine Klasse (`ServerInfoService` oder ähnlich) im `src/` Verzeichnis.
    *   Diese Klasse erhält eine Instanz des `ServerInfoRepository` und eine Liste von `InformationCollectorInterface`-Instanzen (oder eine Factory, die diese erstellt).
    *   Sie sollte eine Hauptmethode wie `updateServerInfo(): void` oder `collectAndStoreAll(): void` haben.
2.  **Prozessablauf:**
    *   Innerhalb der Orchestrator-Methode:
        *   Iteriere über alle konfigurierten Informationssammler.
        *   Für jeden Sammler: Rufe dessen `collect()`-Methode auf.
        *   Verarbeite die zurückgegebenen Daten:
            *   Validierung (optional, aber empfohlen): Prüfe auf erwartete Schlüssel und Datentypen.
            *   Strukturiere die Daten für die Speicherung in der `server_info`-Tabelle. Dies könnte bedeuten, dass komplexe Arrays flach gemacht werden oder dass nur bestimmte wichtige Werte extrahiert werden. Zum Beispiel könnte die Ausgabe von `free -m` so aufbereitet werden, dass Schlüssel wie "memory_total_mb", "memory_free_mb" etc. gespeichert werden.
        *   Nutze das `ServerInfoRepository`, um die gesammelten Informationen in der Datenbank zu speichern/aktualisieren (z. B. `repository->set($key, $value)`).
3.  **Ausführung des Orchestrators:**
    *   Erkläre, wie dieses `ServerInfoService` über ein CLI-Skript (z.B. `bin/update_server_info.php`) oder einen Cronjob aufgerufen werden kann. Dieses Skript würde die Autoloader-Datei einbinden, die notwendigen Abhängigkeiten (Repository, Sammler) instanziieren und dann die `updateServerInfo()`-Methode aufrufen.

### 4.4. API-Entwicklung (Datenabruf)

#### 4.4.1. API-Router und Controller erstellen

**Meta-Prompt:**
Entwickle die Logik für einen einfachen API-Router und die dazugehörigen Controller, um die in der SQLite-Datenbank gespeicherten Server-Informationen abrufbar zu machen. Beschreibe die Routen und die erwarteten Antworten im JSON-Format.

**Anweisungen:**
1.  **API-Router:**
    *   Beschreibe eine einfache Router-Logik, die im `public/index.php` oder einem separaten API-Entrypoint (`public/api.php`) implementiert werden kann.
    *   Diese Logik identifiziert die angefragte URL (z.B. `/api/v1/info`, `/api/v1/info/{key}`) und die HTTP-Methode (GET).
    *   Sie leitet die Anfrage an den entsprechenden Controller weiter.
    *   Sie sollte grundlegende Fehlerbehandlung für nicht gefundene Routen (404) und andere Probleme bieten.
2.  **API-Controller:**
    *   Beschreibe eine Klasse (`InfoController` oder ähnlich) im `src/Controllers/` Verzeichnis.
    *   Diese Klasse erhält Zugriff auf das `ServerInfoRepository`.
    *   Sie sollte Methoden für die API-Endpunkte implementieren:
        *   `getAllInfo(): void`:
            *   Ruft `repository->getAll()` auf.
            *   Formatiert die Ergebnisdaten in ein JSON-Array.
            *   Setzt den HTTP-Header `Content-Type: application/json`.
            *   Gibt die JSON-Antwort aus.
        *   `getInfoByKey(string $key): void`:
            *   Ruft `repository->get($key)` auf.
            *   Wenn ein Wert gefunden wird, formatiert ihn als JSON-Objekt (z.B. `{"key": "hostname", "value": "my-server"}`) und gibt ihn aus.
            *   Wenn kein Wert gefunden wird, gibt eine 404-Antwort (z.B. `{"error": "Not Found"}`) aus.
            *   Setzt die entsprechenden HTTP-Header.

#### 4.4.2. Ausführung des API-Skripts

**Meta-Prompt:**
Erkläre, wie das API-Skript ausgeführt wird, entweder durch einen Webserver-Aufruf oder durch ein integriertes CLI-Tool, das Antworten im JSON-Format generiert.

**Anweisungen:**
1.  **Webserver-Integration:**
    *   Beschreibe, wie die Webserver-Konfiguration (z.B. Nginx `location` oder Apache `.htaccess`) so eingerichtet wird, dass Anfragen an `/api/...` an den PHP-Interpreter weitergeleitet werden, der den API-Router (`public/index.php` oder `public/api.php`) ausführt.
2.  **Direkte CLI-Ausführung (für Tests/Debug):**
    *   Erkläre, wie man das API-Skript von der Kommandozeile aus aufrufen könnte, um Antworten im JSON-Format zu erhalten (z.B. `php public/api.php /api/v1/info`). Dies erfordert eine Anpassung der Router-Logik, um mit `$_SERVER['REQUEST_URI']` oder ähnlichen CLI-spezifischen Variablen zu arbeiten, oder die Erstellung eines separaten CLI-Skripts, das die Controller-Logik aufruft.

### 4.5. Testen und Validierung

#### 4.5.1. Unit- und Integrationstests

**Meta-Prompt:**
Skizziere die Notwendigkeit und den Ansatz für Unit- und Integrationstests, um die Funktionalität des Backends und der API zu gewährleisten. Beschreibe, welche Komponenten getestet werden sollten und welche Mocking-Strategien angewendet werden könnten.

**Anweisungen:**
1.  **Unit-Tests:**
    *   Beschreibe, dass Unit-Tests für einzelne Klassen und Methoden geschrieben werden sollten, z.B. für die Logik innerhalb der Informationssammler, die keine externen Systemaufrufe benötigt (z.B. die Parsing-Logik).
    *   Erkläre, wie externe Abhängigkeiten (wie die Datenbankverbindung oder externe Befehle) gemockt werden können, um die Klassen isoliert zu testen.
    *   Beispiel für zu testende Einheiten: Parsing-Logik für `free -m`-Ausgabe, Logik zur Formatierung von CPU-Daten.
2.  **Integrationstests:**
    *   Beschreibe, dass Integrationstests die Interaktion zwischen verschiedenen Komponenten abdecken sollten, z.B. die Speicherung von Daten in der SQLite-Datenbank über das Repository und den Service.
    *   Erkläre, wie Tests durchgeführt werden können, bei denen eine echte SQLite-Datenbankdatei (möglicherweise eine temporäre Kopie) verwendet wird.
    *   Beispiel für zu testende Integrationen:
        *   Sammlung von Informationen und deren erfolgreiche Speicherung in der Datenbank.
        *   Abruf von Informationen über die API und Verifizierung der korrekten JSON-Ausgabe.
        *   End-to-End-Tests, die den gesamten Workflow abdecken.
3.  **Test-Framework:**
    *   Erwähne die Verwendung eines PHP-Testing-Frameworks wie PHPUnit.
    *   Gib Anweisungen zum Einrichten von PHPUnit über Composer (`composer require --dev phpunit/phpunit`).

#### 4.5.2. Manuelle Tests und Validierung

**Meta-Prompt:**
Beschreibe die manuellen Schritte, um die Funktionalität des Server-Info-Skripts und seiner API auf einem realen Ubuntu 24.04-System zu überprüfen.

**Anweisungen:**
1.  **CLI-Skript-Ausführung:**
    *   Führe das Skript zur Datenbankinitialisierung aus (`php bin/setup_database.php`).
    *   Führe das Skript zur Informationssammlung und -speicherung aus (`php bin/update_server_info.php`).
    *   Überprüfe die SQLite-Datenbankdatei manuell (z.B. mit `sqlite3 database.sqlite "SELECT * FROM server_info;"`) auf korrekte Daten.
2.  **API-Tests:**
    *   Richte den Webserver lokal oder auf einem Testserver ein.
    *   Verwende Tools wie `curl`, Postman oder den Browser, um die API-Endpunkte abzufragen:
        *   `curl http://localhost/api/v1/info` (Überprüfung auf alle Informationen)
        *   `curl http://localhost/api/v1/info/hostname` (Überprüfung auf spezifische Information)
        *   `curl http://localhost/api/v1/info/nonexistent-key` (Überprüfung auf 404-Fehler)
    *   Verifiziere die Korrektheit der ausgegebenen JSON-Daten und der HTTP-Statuscodes.

---

## 5. Schritt-für-Schritt Execution Plan (Phase 3: Frontend & UI)

Diese Phase konzentriert sich auf die Erstellung der Benutzeroberfläche (UI) und des Frontends, das mit dem serverseitigen Skript interagiert. Das Ziel ist eine intuitive und informative Anzeige der Serverinformationen, die dem Benutzer zur Verfügung gestellt werden.

### 5.1. Entwurf und Wireframing der Benutzeroberfläche

**Ziel:** Visuelle Gestaltung des Frontends und Festlegung der Benutzerführung.

**Anweisungen:**

*   **Wireframes erstellen:** Entwerfen Sie grundlegende Wireframes für die Hauptseite des Server-Info-Skripts. Diese sollten die wichtigsten Bereiche definieren, wie z.B. einen Kopfbereich mit dem Skripttitel, einen Hauptbereich zur Anzeige der Serverinformationen und möglicherweise einen Fußbereich.
*   **Informationsbereiche definieren:** Überlegen Sie, welche spezifischen Serverinformationen angezeigt werden sollen (z.B. Hostname, Betriebssystem, Kernelversion, PHP-Version, CPU-Auslastung, Speichernutzung, Festplattenspeicher, Netzwerkstatistiken). Ordnen Sie diese logisch den Bereichen in den Wireframes zu.
*   **Interaktionspunkte identifizieren:** Planen Sie, ob und wie der Benutzer mit den Informationen interagieren soll. Beispielsweise:
    *   Aktualisieren der Informationen (manuell oder automatisch).
    *   Filtern oder Sortieren von Daten (falls zutreffend).
    *   Detaillierte Ansichten für bestimmte Informationen.
*   **Responsives Design berücksichtigen:** Stellen Sie sicher, dass die Entwürfe auch für verschiedene Bildschirmgrößen (Desktops, Tablets, Mobilgeräte) geeignet sind.

**Meta-Prompt:** "Erstelle Wireframe-Skizzen für eine Webanwendung zur Anzeige von Serverinformationen. Die Benutzeroberfläche sollte klar strukturiert sein und verschiedene Servermetriken übersichtlich darstellen. Berücksichtige dabei eine responsive Gestaltung."

### 5.2. Auswahl des Frontend-Frameworks und des Styling-Ansatzes

**Ziel:** Entscheidung über die technologische Basis für das Frontend und das visuelle Erscheinungsbild.

**Anweisungen:**

*   **Framework-Evaluierung:** Bewerten Sie verschiedene Frontend-Frameworks (z.B. Bootstrap, Tailwind CSS, oder ein Vanilla-CSS-Ansatz mit einer CSS-Reset-Bibliothek) basierend auf folgenden Kriterien:
    *   Einfachheit der Implementierung.
    *   Bereitschaft zur Unterstützung responsiver Designs.
    *   Leistung und Overhead.
    *   Verfügbarkeit von vorgefertigten UI-Komponenten (falls gewünscht).
*   **Styling-Strategie festlegen:** Entscheiden Sie sich für einen Ansatz für das Styling:
    *   Verwendung eines CSS-Frameworks (z.B. Bootstrap für schnelle Prototypenentwicklung und ein konsistentes Aussehen).
    *   Entwicklung eines individuellen CSS-Schemas (für maximale Flexibilität und ein einzigartiges Design).
    *   Verwendung eines CSS-Präprozessors (z.B. SASS/SCSS) zur besseren Organisation und Wartbarkeit des CSS-Codes.
*   **Farbpalette und Typografie:** Definieren Sie eine grundlegende Farbpalette und Schriftarten, die zum Thema Servermanagement passen und gut lesbar sind.

**Meta-Prompt:** "Empfehle ein geeignetes Frontend-Framework für die Entwicklung einer benutzerfreundlichen Oberfläche zur Anzeige von Serverinformationen. Erkläre die Vor- und Nachteile verschiedener Optionen wie Bootstrap, Tailwind CSS und einen Vanilla-Ansatz. Lege eine grundlegende Styling-Strategie und Design-Prinzipien fest."

### 5.3. Implementierung der HTML-Struktur

**Ziel:** Erstellung der grundlegenden Seitenstruktur mit HTML, die den Wireframes entspricht.

**Anweisungen:**

*   **Semantisches HTML:** Verwenden Sie semantische HTML5-Tags (z.B. `<header>`, `<nav>`, `<main>`, `<article>`, `<footer>`, `<section>`), um die Struktur der Seite klar zu definieren.
*   **Platzhalter für Daten:** Fügen Sie Platzhalter-Elemente (z.B. `<div>` oder `<span>` mit eindeutigen IDs oder Klassen) ein, wo die dynamisch abgerufenen Serverinformationen später angezeigt werden sollen.
*   **Tabellen für strukturierte Daten:** Für Listen von Informationen, die eine tabellarische Darstellung erfordern (z.B. Prozessliste, Netzwerkverbindungen), verwenden Sie das `<table>`-Element.
*   **Responsiver Aufbau:** Strukturieren Sie das HTML so, dass es leicht mit CSS für verschiedene Bildschirmgrößen angepasst werden kann.

**Meta-Prompt:** "Generiere die grundlegende HTML-Struktur für ein Dashboard zur Anzeige von Serverinformationen, basierend auf vordefinierten Wireframes. Verwende semantische HTML5-Elemente und füge Platzhalter für dynamisch geladene Daten ein."
[Code-Block - Bitte selbständig passenden Code generieren]

### 5.4. Styling der Benutzeroberfläche mit CSS

**Ziel:** Visuelle Gestaltung der HTML-Elemente gemäß dem entworfenen Stil.

**Anweisungen:**

*   **Umsetzung des Designs:** Wenden Sie CSS-Regeln an, um das Aussehen der HTML-Elemente zu definieren. Dies beinhaltet:
    *   Layout und Positionierung von Elementen.
    *   Festlegung von Farben, Schriftarten, Abständen und Rändern.
    *   Erstellung von visuellen Effekten (z.B. Hover-Zustände für interaktive Elemente).
*   **Responsivität mit Media Queries:** Nutzen Sie CSS Media Queries, um das Layout und die Darstellung der Elemente an verschiedene Bildschirmgrößen anzupassen.
*   **Komponenten-Styling:** Gestalten Sie einzelne UI-Komponenten (z.B. Karten für verschiedene Informationskategorien, Buttons, Statusanzeigen) konsistent.
*   **Zugänglichkeit:** Berücksichtigen Sie grundlegende Zugänglichkeitsprinzipien, wie ausreichende Kontraste und klare Fokussierung.

**Meta-Prompt:** "Entwickle die CSS-Regeln, um die HTML-Struktur der Server-Info-Oberfläche optisch ansprechend und responsiv zu gestalten. Implementiere ein konsistentes Design, das die Lesbarkeit und Benutzerfreundlichkeit maximiert."
[Code-Block - Bitte selbständig passenden Code generieren]

### 5.5. Implementierung der Frontend-Logik mit JavaScript (optional, für Interaktivität)

**Ziel:** Hinzufügen von dynamischem Verhalten und interaktiven Elementen, falls erforderlich.

**Anweisungen:**

*   **Dynamische Datenaktualisierung (clientseitig):** Wenn eine automatische Aktualisierung der Daten ohne vollständiges Neuladen der Seite gewünscht ist, implementieren Sie JavaScript-Code, der mit dem Backend kommuniziert (z.B. über AJAX-Anfragen).
*   **Interaktive Elemente:** Implementieren Sie JavaScript für interaktive Elemente, wie z.B.:
    *   Ein- und Ausklappen von Detailinformationen.
    *   Filter- oder Suchfunktionen (falls implementiert).
    *   Animationen oder Übergänge.
*   **DOM-Manipulation:** Schreiben Sie JavaScript-Code, der das Document Object Model (DOM) manipuliert, um die abgerufenen Daten in die entsprechenden HTML-Platzhalter einzufügen und zu aktualisieren.
*   **Fehlerbehandlung (clientseitig):** Fügen Sie grundlegende Fehlerbehandlung für JavaScript-Fehler und potenzielle Probleme bei der Kommunikation mit dem Backend hinzu.

**Meta-Prompt:** "Entwickle JavaScript-Code, um die Benutzeroberfläche der Server-Info-Anwendung interaktiv zu gestalten. Implementiere Funktionalitäten wie clientseitige Datenaktualisierungen, dynamische Anzeige von Detailinformationen und einfache Fehlerbehandlung."
[Code-Block - Bitte selbständig passenden Code generieren]

### 5.6. Integration von Frontend und Backend (initiale Tests)

**Ziel:** Sicherstellen, dass das Frontend die Daten vom Backend korrekt empfängt und anzeigt.

**Anweisungen:**

*   **Simulierte Daten:** Entwickeln Sie zunächst mit simulierten Daten oder "Mock"-Daten, um das Frontend unabhängig vom Backend zu testen und zu verfeinern.
*   **API-Aufrufe (simuliert):** Erstellen Sie eine Funktion im Frontend, die eine Anfrage an die erwartete Backend-API simuliert und die zurückgegebenen Daten verarbeitet.
*   **Datenbindung:** Implementieren Sie die Logik, um die vom Backend (oder der Simulation) empfangenen Daten an die entsprechenden HTML-Elemente zu binden und anzuzeigen.
*   **Fehlerszenarien:** Testen Sie, wie das Frontend reagiert, wenn das Backend keine Daten liefert oder Fehler zurückgibt.
*   **Browser-Kompatibilitätstests:** Führen Sie grundlegende Tests in verschiedenen gängigen Webbrowsern durch, um die Kompatibilität sicherzustellen.

**Meta-Prompt:** "Beschreibe die Schritte zur Integration des entwickelten Frontends mit dem serverseitigen Skript. Erkläre, wie das Frontend die Daten vom Backend abrufen und anzeigen kann, und wie anfängliche Tests mit simulierten und echten Daten durchgeführt werden sollten."

## 6. Fallback-Strategien, Fehlerbehandlung und finale Verifikations-Tests

Dieses Kapitel befasst sich mit den robusten Mechanismen, die implementiert werden, um die Zuverlässigkeit und Stabilität des Server-Info-Skripts zu gewährleisten. Dies beinhaltet detaillierte Fallback-Strategien, eine umfassende Fehlerbehandlung und die Definition von finalen Verifikations-Tests.

### 6.1. Fallback-Strategien für Ressourcen und Dienste

Das Server-Info-Skript muss widerstandsfähig gegenüber temporären Ausfällen oder Einschränkungen kritischer Ressourcen und Dienste sein. Folgende Fallback-Strategien werden implementiert:

*   **Datenbankverbindung (SQLite):**
    *   **Primär:** Direkte Verbindung zur konfigurierten SQLite-Datenbankdatei.
    *   **Fallback 1 (Datei nicht vorhanden/lesbar):** Wenn die Datenbankdatei nicht existiert oder nicht lesbar ist, generiert das Skript eine Meldung, dass die Datenbankinformationen nicht abgerufen werden können. Es wird *keine* automatische Neuerstellung der Datenbank versucht, um Datenverlust zu vermeiden. Stattdessen wird ein klarer Fehler an den Administrator kommuniziert.
    *   **Fallback 2 (SQLite-Erweiterung fehlt):** Wenn die notwendige PHP-Erweiterung für SQLite nicht geladen ist, wird eine entsprechende Fehlermeldung ausgegeben, die auf die fehlende `sqlite3`-Erweiterung hinweist.
    *   **Fallback 3 (Berechtigungsprobleme):** Sollten Lese- oder Schreibberechtigungen auf die Datenbankdatei oder das Verzeichnis fehlen, wird eine spezifische Fehlermeldung generiert, die auf dieses Problem hinweist.

*   **Systeminformationen (falls über externe Tools abgerufen):**
    *   **Primär:** Abruf von Systeminformationen über standardmäßige Linux-Befehle (z.B. `uname`, `lscpu`, `free`, `df`).
    *   **Fallback 1 (Befehl nicht gefunden):** Wenn ein kritischer Befehl nicht im Systempfad gefunden wird, wird der Versuch, die entsprechende Information abzurufen, übersprungen und eine Meldung protokolliert, dass diese spezifische Information nicht verfügbar ist.
    *   **Fallback 2 (Befehlsausführung fehlerhaft):** Wenn die Ausführung eines Befehls zu einem Fehler führt (z.B. aufgrund von Berechtigungsproblemen oder ungültigen Optionen), wird die Ausgabe des Befehls als Fehler behandelt und die Information als nicht verfügbar markiert.

*   **PHP-Modulverfügbarkeit:**
    *   **Primär:** Das Skript benötigt PHP 8.3+ und die `sqlite3`-Erweiterung.
    *   **Fallback 1 (PHP-Version zu alt):** Bei Ausführung mit einer PHP-Version älter als 8.3 wird das Skript sofort mit einer klaren Fehlermeldung beendet, die auf die erforderliche PHP-Version hinweist.
    *   **Fallback 2 (SQLite-Erweiterung fehlt):** Wie unter "Datenbankverbindung" beschrieben, wird eine spezifische Fehlermeldung ausgegeben.

### 6.2. Detaillierte Fehlerbehandlung und Protokollierung

Eine robuste Fehlerbehandlung ist entscheidend, um Probleme schnell zu identifizieren und zu beheben.

*   **Fehlerklassen und -codes:**
    *   Das Skript verwendet spezifische Fehlerklassen oder Konstanten, um verschiedene Fehlerarten zu kategorisieren (z.B. `DB_ERROR_CONNECTION`, `SYSTEM_INFO_ERROR`, `PHP_MODULE_ERROR`).
    *   Jeder Fehler wird mit einem eindeutigen Code und einer aussagekräftigen Fehlermeldung versehen.

*   **Protokollierungsmechanismus:**
    *   **Fehlerprotokoll:** Alle aufgetretenen Fehler werden in eine dedizierte Protokolldatei geschrieben. Diese Datei sollte außerhalb des Webserver-Roots liegen, um unbefugten Zugriff zu verhindern.
    *   **Protokollinhalt:** Jede Protokollzeile enthält:
        *   Zeitstempel (Datum und Uhrzeit)
        *   Fehlertyp (z.B. `ERROR`, `WARNING`)
        *   Fehlerklasse/Code
        *   Detaillierte Fehlermeldung, inklusive Kontextinformationen (z.B. welcher Befehl fehlgeschlagen ist, welche Datenbankdatei nicht zugreifbar war).
        *   Optional: Stack-Trace für PHP-Fehler zur besseren Fehlersuche.
    *   **Informationsprotokoll (optional):** Für die Fehlersuche kann ein separates Informationsprotokoll aktiviert werden, das erfolgreiche Aktionen, abgerufene Datenmengen oder den Status von Routineprüfungen festhält.

*   **Benachrichtigung an Administratoren (optional, aber empfohlen):**
    *   Bei kritischen Fehlern (z.B. mehrfache Datenbankfehler in kurzer Zeit) kann das Skript eine E-Mail-Benachrichtigung an einen konfigurierten Administrator senden.
    *   Die Benachrichtigung sollte die wichtigsten Details des Fehlers enthalten, um eine schnelle Reaktion zu ermöglichen.

*   **Ausgabe von Fehlermeldungen an den Benutzer:**
    *   **Produktionsumgebung:** In einer Produktionsumgebung sollten generische Fehlermeldungen angezeigt werden, die den Benutzer nicht mit technischen Details überfordern (z.B. "Ein interner Serverfehler ist aufgetreten. Bitte versuchen Sie es später erneut."). Detaillierte Fehler werden ausschließlich in das Protokoll geschrieben.
    *   **Entwicklungsumgebung:** In einer Entwicklungsumgebung können detailliertere Fehlermeldungen und Stack-Traces direkt im Browser ausgegeben werden, um die Fehlersuche zu erleichtern. Eine Konfigurationsvariable (`APP_ENV` oder ähnlich) steuert dieses Verhalten.

### 6.3. Finale Verifikations-Tests

Vor der Freigabe und auch in regelmäßigen Abständen nach der Bereitstellung müssen umfassende Tests durchgeführt werden, um die Funktionalität und Robustheit des Skripts zu validieren.

*   **Unit-Tests:**
    *   **Ziel:** Testen einzelner Funktionen und Methoden des Skripts isoliert.
    *   **Beispiele:**
        *   Testen der korrekten Formatierung von Ausgabe-Strings.
        *   Testen der Logik zur Verarbeitung von Datenbankeinträgen.
        *   Testen von Hilfsfunktionen zur String-Manipulation oder zur Berechnung von Werten.
    *   **Umgebung:** Diese Tests werden typischerweise mit einem PHP-Unit-Testing-Framework durchgeführt.

*   **Integrations-Tests:**
    *   **Ziel:** Testen des Zusammenspiels verschiedener Komponenten des Skripts und dessen Interaktion mit externen Ressourcen.
    *   **Beispiele:**
        *   Testen der gesamten Datenbankinteraktion: Einfügen, Lesen, Aktualisieren und Löschen von Daten (mit einer separaten Testdatenbank).
        *   Testen des Abrufs von Systeminformationen und deren korrekter Speicherung in der Datenbank.
        *   Testen des Aufrufs des Skripts über die Kommandozeile und Überprüfung der Ausgabe.

*   **System-Tests (End-to-End):**
    *   **Ziel:** Simulation realistischer Nutzungsszenarien und Überprüfung des gesamten Systems.
    *   **Beispiele:**
        *   **Normalbetrieb:** Ausführen des Skripts unter erwarteten Bedingungen und Verifizieren, dass alle erwarteten Informationen korrekt abgerufen und gespeichert werden.
        *   **Fehlerszenarien-Tests:**
            *   Manuelles Entfernen oder Umbenennen der SQLite-Datenbankdatei und Überprüfen der korrekten Fehlermeldung und Protokollierung.
            *   Entfernen der `sqlite3`-Erweiterung (simuliert, falls möglich) und Überprüfen der Fehlermeldung.
            *   Einschränken der Berechtigungen für die Datenbankdatei und Überprüfung der Fehlermeldung.
            *   Simulieren eines nicht verfügbaren Systembefehls.
        *   **Last- und Stresstests (optional, aber empfohlen):** Testen des Skripts unter erhöhter Last, um Engpässe oder Speicherlecks zu identifizieren.

*   **Validierung von Verifikations-Testdurchläufen:**
    *   Alle Testläufe (Unit, Integration, System) müssen dokumentiert werden.
    *   Ein Testdurchlauf gilt als erfolgreich, wenn alle Tests bestanden wurden und keine kritischen Fehler aufgetreten sind.
    *   Im Falle eines fehlschlagenden Tests muss die Ursache ermittelt und behoben werden, bevor das Skript als stabil gilt.

*   **Deployment-Checkliste:**
    *   Vor jedem neuen Deployment wird eine Checkliste abgearbeitet, die sicherstellt, dass alle Konfigurationen korrekt sind, die Datenbankdatei existiert und die notwendigen PHP-Erweiterungen geladen sind.
    *   Ein kurzer Funktionstest nach dem Deployment ist unerlässlich.

[Code-Block - Bitte selbständig passenden Code generieren]