diff --git a/backend/app/config/settings.py b/backend/app/config/settings.py
index 6ca2f865..043e1c30 100644
--- a/backend/app/config/settings.py
+++ b/backend/app/config/settings.py
@@ -220,20 +220,4 @@ def create_simple_ssl_cert():
         return None
     except Exception as e:
         print(f"Fehler beim Erstellen der SSL-Zertifikate: {e}")
-        return None
-
-# Debug-Informationen für Pfad-Überprüfung
-if __name__ == "__main__":
-    print("=== Pfad-Konfiguration ===")
-    print(f"BASE_DIR: {BASE_DIR}")
-    print(f"PROJECT_ROOT: {PROJECT_ROOT}")
-    print(f"DATABASE_PATH: {DATABASE_PATH}")
-    print(f"LOG_DIR: {LOG_DIR}")
-    print(f"SSL_CERT_PATH: {SSL_CERT_PATH}")
-    print(f"SSL_KEY_PATH: {SSL_KEY_PATH}")
-    print()
-    print("=== Pfad-Existenz ===")
-    print(f"Datenbank existiert: {os.path.exists(DATABASE_PATH)}")
-    print(f"Log-Verzeichnis existiert: {os.path.exists(LOG_DIR)}")
-    print(f"SSL-Zertifikat existiert: {os.path.exists(SSL_CERT_PATH)}")
-    print(f"SSL-Schlüssel existiert: {os.path.exists(SSL_KEY_PATH)}") 
\ No newline at end of file
+        return None
\ No newline at end of file
diff --git a/backend/app/test_paths.py b/backend/app/test_paths.py
deleted file mode 100644
index 34cec6db..00000000
--- a/backend/app/test_paths.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/env python3
-"""Test-Skript für Pfad-Überprüfung"""
-
-import os
-import sys
-
-# Aktuelles Verzeichnis hinzufügen
-sys.path.append('.')
-
-try:
-    from config.settings import (
-        BASE_DIR, PROJECT_ROOT, DATABASE_PATH, 
-        LOG_DIR, SSL_CERT_PATH, SSL_KEY_PATH
-    )
-    
-    print("=== Pfad-Konfiguration ===")
-    print(f"BASE_DIR: {BASE_DIR}")
-    print(f"PROJECT_ROOT: {PROJECT_ROOT}")
-    print(f"DATABASE_PATH: {DATABASE_PATH}")
-    print(f"LOG_DIR: {LOG_DIR}")
-    print(f"SSL_CERT_PATH: {SSL_CERT_PATH}")
-    print(f"SSL_KEY_PATH: {SSL_KEY_PATH}")
-    print()
-    
-    print("=== Pfad-Existenz ===")
-    print(f"Datenbank existiert: {os.path.exists(DATABASE_PATH)}")
-    print(f"Log-Verzeichnis existiert: {os.path.exists(LOG_DIR)}")
-    print(f"SSL-Zertifikat existiert: {os.path.exists(SSL_CERT_PATH)}")
-    print(f"SSL-Schlüssel existiert: {os.path.exists(SSL_KEY_PATH)}")
-    print()
-    
-    print("=== Absolute Pfade ===")
-    print(f"DATABASE_PATH absolut: {os.path.abspath(DATABASE_PATH)}")
-    print(f"LOG_DIR absolut: {os.path.abspath(LOG_DIR)}")
-    print(f"SSL_CERT_PATH absolut: {os.path.abspath(SSL_CERT_PATH)}")
-    
-except ImportError as e:
-    print(f"Import-Fehler: {e}")
-except Exception as e:
-    print(f"Fehler: {e}") 
\ No newline at end of file
diff --git a/frontend/cleanup.sh b/frontend/cleanup.sh
deleted file mode 100644
index e2f5d3b9..00000000
--- a/frontend/cleanup.sh
+++ /dev/null
@@ -1,245 +0,0 @@
-#!/bin/bash
-
-# Raspberry Pi Bereinigungsskript für MYP-Projekt Frontend
-# Dieses Skript bereinigt alte Docker-Installationen und installiert alle erforderlichen Abhängigkeiten
-
-# Farbcodes für Ausgabe
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Funktion zur Ausgabe mit Zeitstempel
-log() {
-    echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
-}
-
-error_log() {
-  echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
-}
-
-# Prüfen, ob das Skript mit Root-Rechten ausgeführt wird
-if [ "$EUID" -ne 0 ]; then
-  error_log "Dieses Skript muss mit Root-Rechten ausgeführt werden (sudo)."
-  exit 1
-fi
-
-log "${YELLOW}=== MYP Frontend Raspberry Pi Bereinigung und Setup ===${NC}"
-log "Dieses Skript wird alle alten Docker-Installationen entfernen und die erforderlichen Abhängigkeiten neu installieren."
-
-# Sicherstellen, dass apt funktioniert
-log "Aktualisiere apt-Paketindex..."
-apt-get update || {
-  error_log "Konnte apt-Paketindex nicht aktualisieren."
-  exit 1
-}
-
-# Installiere grundlegende Abhängigkeiten
-log "Installiere grundlegende Abhängigkeiten..."
-apt-get install -y \
-  apt-transport-https \
-  ca-certificates \
-  curl \
-  gnupg \
-  lsb-release \
-  wget \
-  git \
-  jq \
-  || {
-  error_log "Konnte grundlegende Abhängigkeiten nicht installieren."
-  exit 1
-}
-
-# Stoppe alle laufenden Docker-Container
-log "${YELLOW}Stoppe alle laufenden Docker-Container...${NC}"
-if command -v docker &> /dev/null; then
-  docker stop $(docker ps -aq) 2>/dev/null || true
-  log "Alle Docker-Container gestoppt."
-else
-  log "Docker ist nicht installiert, keine Container zu stoppen."
-fi
-
-# Entferne alte Docker-Installation
-log "${YELLOW}Entferne alte Docker-Installation...${NC}"
-apt-get remove -y docker docker-engine docker.io containerd runc docker-ce docker-ce-cli containerd.io docker-compose-plugin docker-compose || true
-apt-get autoremove -y || true
-rm -rf /var/lib/docker /var/lib/containerd /var/run/docker.sock /etc/docker /usr/local/bin/docker-compose 2>/dev/null || true
-log "${GREEN}Alte Docker-Installation entfernt.${NC}"
-
-# Entferne alte Projektcontainer und -Dateien
-log "${YELLOW}Entferne alte MYP-Projektcontainer und -Dateien...${NC}"
-if command -v docker &> /dev/null; then
-  # Entferne Container
-  docker rm -f myp-frontend myp-backend 2>/dev/null || true
-  # Entferne Images
-  docker rmi -f myp-frontend myp-backend 2>/dev/null || true
-  # Entferne unbenutzte Volumes und Netzwerke
-  docker system prune -af --volumes 2>/dev/null || true
-fi
-
-# Erkennen der Raspberry Pi-Architektur
-log "Erkenne Systemarchitektur..."
-ARCH=$(dpkg --print-architecture)
-log "Erkannte Architektur: ${ARCH}"
-
-# Installiere Docker mit dem offiziellen Convenience-Skript
-log "${YELLOW}Installiere Docker mit dem offiziellen Convenience-Skript...${NC}"
-curl -fsSL https://get.docker.com -o get-docker.sh
-sh get-docker.sh --channel stable
-
-# Überprüfen, ob Docker erfolgreich installiert wurde
-if ! command -v docker &> /dev/null; then
-  error_log "Docker-Installation fehlgeschlagen!"
-  exit 1
-fi
-
-log "${GREEN}Docker erfolgreich installiert!${NC}"
-
-# Füge den aktuellen Benutzer zur Docker-Gruppe hinzu
-if [ "$SUDO_USER" ]; then
-  log "Füge Benutzer $SUDO_USER zur Docker-Gruppe hinzu..."
-  usermod -aG docker $SUDO_USER
-  log "${YELLOW}Hinweis: Eine Neuanmeldung ist erforderlich, damit die Gruppenänderung wirksam wird.${NC}"
-fi
-
-# Konfiguriere Docker mit DNS-Servern für bessere Netzwerkkompatibilität
-log "Konfiguriere Docker mit Google DNS..."
-mkdir -p /etc/docker
-cat > /etc/docker/daemon.json << EOL
-{
-  "dns": ["8.8.8.8", "8.8.4.4"]
-}
-EOL
-
-# Starte Docker-Dienst neu
-log "Starte Docker-Dienst neu..."
-systemctl restart docker
-systemctl enable docker
-log "${GREEN}Docker-Dienst neu gestartet und für den Autostart aktiviert.${NC}"
-
-# Installiere Docker Compose v2
-log "${YELLOW}Installiere Docker Compose...${NC}"
-
-# Bestimme die passende Docker Compose-Version für die Architektur
-if [ "$ARCH" = "armhf" ]; then
-  log "Installiere Docker Compose für armhf (32-bit)..."
-  curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-linux-armv7" -o /usr/local/bin/docker-compose
-elif [ "$ARCH" = "arm64" ]; then
-  log "Installiere Docker Compose für arm64 (64-bit)..."
-  curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-linux-aarch64" -o /usr/local/bin/docker-compose
-else
-  log "Unbekannte Architektur, verwende automatische Erkennung..."
-  curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
-fi
-
-chmod +x /usr/local/bin/docker-compose
-
-# Überprüfe, ob Docker Compose installiert wurde
-if ! command -v docker-compose &> /dev/null; then
-  error_log "Docker Compose-Installation fehlgeschlagen!"
-  exit 1
-fi
-
-# Installiere Docker Compose Plugin (neuere Methode)
-log "Installiere Docker Compose Plugin..."
-apt-get update
-apt-get install -y docker-compose-plugin
-
-log "${GREEN}Docker Compose erfolgreich installiert!${NC}"
-docker compose version || docker-compose --version
-
-# Installiere zusätzliche Abhängigkeiten für das Frontend
-log "${YELLOW}Installiere zusätzliche Frontend-Abhängigkeiten...${NC}"
-apt-get install -y \
-  nodejs \
-  npm \
-  || {
-  error_log "Konnte zusätzliche Frontend-Abhängigkeiten nicht installieren."
-  exit 1
-}
-
-# Installiere Node.js LTS-Version über NodeSource
-log "${YELLOW}Installiere aktuelle Node.js LTS-Version...${NC}"
-curl -fsSL https://deb.nodesource.com/setup_18.x | bash -
-apt-get install -y nodejs
-
-# Überprüfe Node.js-Installation
-NODE_VERSION=$(node -v)
-log "${GREEN}Node.js $NODE_VERSION erfolgreich installiert!${NC}"
-
-# Installiere pnpm
-log "${YELLOW}Installiere pnpm Paketmanager...${NC}"
-npm install -g pnpm
-log "${GREEN}pnpm $(pnpm --version) erfolgreich installiert!${NC}"
-
-# Optimieren des Raspberry Pi für Docker-Workloads
-log "${YELLOW}Optimiere Raspberry Pi für Docker-Workloads...${NC}"
-
-# Swap erhöhen für bessere Performance bei begrenztem RAM
-log "Konfiguriere Swap-Größe..."
-CURRENT_SWAP=$(grep "CONF_SWAPSIZE" /etc/dphys-swapfile | cut -d= -f2)
-log "Aktuelle Swap-Größe: ${CURRENT_SWAP}"
-
-# Erhöhe Swap auf 2GB, wenn weniger
-if [ "$CURRENT_SWAP" -lt 2048 ]; then
-  sed -i 's/^CONF_SWAPSIZE=.*/CONF_SWAPSIZE=2048/' /etc/dphys-swapfile
-  log "Swap-Größe auf 2048MB erhöht, Neustart des Swap-Dienstes erforderlich."
-  
-  # Neustart des Swap-Dienstes
-  /etc/init.d/dphys-swapfile restart
-else
-  log "Swap-Größe ist bereits ausreichend."
-fi
-
-# Konfiguriere cgroup für Docker
-if ! grep -q "cgroup_enable=memory" /boot/cmdline.txt; then
-  log "Konfiguriere cgroup für Docker..."
-  CMDLINE=$(cat /boot/cmdline.txt)
-  echo "$CMDLINE cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1" > /boot/cmdline.txt
-  log "${YELLOW}WICHTIG: Ein Systemneustart ist erforderlich, damit die cgroup-Änderungen wirksam werden.${NC}"
-fi
-
-# Erstelle Datenbankverzeichnis für Frontend
-log "Erstelle Datenbankverzeichnis für Frontend..."
-mkdir -p /srv/MYP-DB
-chmod 777 /srv/MYP-DB
-
-# Erstelle Umgebungsvariablen-Verzeichnis
-log "Erstelle Umgebungsvariablen-Verzeichnis..."
-mkdir -p /srv/myp-env
-cat > /srv/myp-env/github.env << EOL
-# OAuth-Konfiguration für Frontend
-OAUTH_CLIENT_ID=client_id
-OAUTH_CLIENT_SECRET=client_secret
-NEXT_PUBLIC_API_URL=http://192.168.0.105:5000
-EOL
-chmod 600 /srv/myp-env/github.env
-
-# Prüfe, ob Frontend-Installationsdateien vorhanden sind
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-FRONTEND_DIR="$SCRIPT_DIR"
-
-if [ -f "$FRONTEND_DIR/package.json" ]; then
-  log "${GREEN}Frontend-Projektdateien gefunden in $FRONTEND_DIR${NC}"
-else
-  log "${YELLOW}Warnung: Frontend-Projektdateien nicht gefunden in $FRONTEND_DIR${NC}"
-fi
-
-# Abschlussmeldung
-log "${GREEN}=== Bereinigung und Setup abgeschlossen ===${NC}"
-log "${YELLOW}WICHTIGE HINWEISE:${NC}"
-log "1. Ein ${RED}SYSTEMNEUSTART${NC} ist ${RED}DRINGEND ERFORDERLICH${NC}, damit alle Änderungen wirksam werden."
-log "2. Nach dem Neustart können Sie das Frontend-Installationsskript ausführen:"
-log "   cd $FRONTEND_DIR && ./install.sh"
-log "3. Bei Problemen mit Docker-Berechtigungen stellen Sie sicher, dass Sie sich neu angemeldet haben."
-log "4. Sie müssen noch die OAuth-Konfiguration in /srv/myp-env/github.env anpassen."
-
-echo ""
-read -p "Möchten Sie das System jetzt neu starten? (j/n): " REBOOT_CHOICE
-if [[ "$REBOOT_CHOICE" == "j" ]]; then
-  log "System wird neu gestartet..."
-  reboot
-else
-  log "Bitte starten Sie das System manuell neu, bevor Sie die Installationsskripte ausführen."
-fi 
\ No newline at end of file
diff --git a/frontend/docker/build.sh b/frontend/docker/build.sh
deleted file mode 100644
index 8b04b01b..00000000
--- a/frontend/docker/build.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-
-# Define image name
-MYP_RP_IMAGE_NAME="myp-rp"
-
-# Function to build Docker image
-build_image() {
-    local image_name=$1
-    local dockerfile=$2
-    local platform=$3
-
-    echo "Building $image_name Docker image for $platform..."
-
-    docker buildx build --platform $platform -t ${image_name}:latest -f $dockerfile --load .
-    if [ $? -eq 0 ]; then
-        echo "$image_name Docker image built successfully"
-    else
-        echo "Error occurred while building $image_name Docker image"
-        exit 1
-    fi
-}
-
-# Create and use a builder instance (if not already created)
-BUILDER_NAME="myp-rp-arm64-builder"
-docker buildx create --name $BUILDER_NAME --use || docker buildx use $BUILDER_NAME
-
-# Build myp-rp image
-build_image "$MYP_RP_IMAGE_NAME" "$PWD/Dockerfile" "linux/arm64"
-
-# Remove the builder instance
-docker buildx rm $BUILDER_NAME
diff --git a/frontend/docker/save.sh b/frontend/docker/save.sh
deleted file mode 100644
index 2ce2712e..00000000
--- a/frontend/docker/save.sh
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/bin/bash
-
-# Get image name as argument
-IMAGE_NAME=$1
-PLATFORM="linux/arm64"
-
-# Define paths
-IMAGE_DIR="docker/images"
-IMAGE_FILE="${IMAGE_DIR}/${IMAGE_NAME//[:\/]/_}.tar"
-COMPRESSED_FILE="${IMAGE_FILE}.xz"
-
-# Function to pull the image
-pull_image() {
-    local image=$1
-    if [[ $image == arm64v8/* ]]; then
-        echo "Pulling image $image without platform specification..."
-        docker pull $image
-    else
-        echo "Pulling image $image for platform $PLATFORM..."
-        docker pull --platform $PLATFORM $image
-    fi
-    return $?
-}
-
-# Pull the image if it is not available locally
-if ! docker image inspect ${IMAGE_NAME} &>/dev/null; then
-    if pull_image ${IMAGE_NAME}; then
-        echo "Image $IMAGE_NAME pulled successfully."
-    else
-        echo "Error occurred while pulling $IMAGE_NAME for platform $PLATFORM"
-        echo "Trying to pull $IMAGE_NAME without platform specification..."
-
-        # Attempt to pull again without platform
-        if pull_image ${IMAGE_NAME}; then
-            echo "Image $IMAGE_NAME pulled successfully without platform."
-        else
-            echo "Error occurred while pulling $IMAGE_NAME without platform."
-            echo "Trying to pull arm64v8/${IMAGE_NAME} instead..."
-
-            # Construct new image name
-            NEW_IMAGE_NAME="arm64v8/${IMAGE_NAME}"
-            if pull_image ${NEW_IMAGE_NAME}; then
-                echo "Image $NEW_IMAGE_NAME pulled successfully."
-                IMAGE_NAME=${NEW_IMAGE_NAME}  # Update IMAGE_NAME to use the new one
-            else
-                echo "Error occurred while pulling $NEW_IMAGE_NAME"
-                exit 1
-            fi
-        fi
-    fi
-else
-    echo "Image $IMAGE_NAME found locally. Skipping pull."
-fi
-
-# Save the Docker image
-echo "Saving $IMAGE_NAME Docker image..."
-docker save ${IMAGE_NAME} > $IMAGE_FILE
-
-# Compress the Docker image (overwriting if file exists)
-echo "Compressing $IMAGE_FILE..."
-xz -z --force $IMAGE_FILE
-
-if [ $? -eq 0 ]; then
-    echo "$IMAGE_NAME Docker image saved and compressed successfully as $COMPRESSED_FILE"
-else
-    echo "Error occurred while compressing $IMAGE_NAME Docker image"
-    exit 1
-fi
diff --git a/frontend/https-setup.sh b/frontend/https-setup.sh
deleted file mode 100644
index 4e4065c2..00000000
--- a/frontend/https-setup.sh
+++ /dev/null
@@ -1,376 +0,0 @@
-#!/bin/bash
-
-# HTTPS-Setup-Skript für das MYP-Projekt
-# Konfiguriert einen Raspberry Pi mit einer dual-network-Konfiguration
-# - LAN (eth0): Firmennetzwerk mit Zugang zu Internet und unter https://m040tbaraspi001.de040.corpintra.net/ erreichbar
-# - WLAN (wlan0): Verbindung zum Offline-Netzwerk, wo der Backend-Host erreichbar ist
-
-# Farbcodes für Ausgabe
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-BLUE='\033[0;34m'
-CYAN='\033[0;36m'
-NC='\033[0m' # No Color
-
-# Funktion zur Ausgabe mit Zeitstempel
-log() {
-  echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
-}
-
-error_log() {
-  echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
-}
-
-success_log() {
-  echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] ERFOLG:${NC} $1"
-}
-
-header() {
-  echo ""
-  echo -e "${CYAN}===== $1 =====${NC}"
-  echo ""
-}
-
-# Prüfen, ob das Skript als Root ausgeführt wird
-if [ "$EUID" -ne 0 ]; then
-  error_log "Dieses Skript muss als Root ausgeführt werden."
-  error_log "Bitte führen Sie es mit 'sudo' aus."
-  exit 1
-fi
-
-# Konfigurationswerte
-FIRMENNETZWERK_HOSTNAME="m040tbaraspi001.de040.corpintra.net"
-BACKEND_HOST="192.168.0.105"  # Backend-IP im Offline-Netzwerk
-BACKEND_PORT="5000"           # Backend-Port
-OFFLINE_NETWORK_SSID="MYP-Net"
-OFFLINE_NETWORK_PASSWORD="myp-password"
-CADDY_VERSION="2.7.6"
-
-header "MYP-Netzwerk und HTTPS-Setup"
-log "Dieses Skript konfiguriert Ihren Raspberry Pi für:"
-log "1. Firmennetzwerk über LAN (eth0) mit Internet-Zugang"
-log "2. Offline-Netzwerk über WLAN (wlan0) für Backend-Kommunikation"
-log "3. HTTPS mit selbstsigniertem Zertifikat für ${FIRMENNETZWERK_HOSTNAME}"
-
-# Netzwerkkonfiguration
-setup_network() {
-  header "Netzwerkkonfiguration"
-  
-  # Sichern der aktuellen Netzwerkkonfiguration
-  log "Sichere aktuelle Netzwerkkonfiguration..."
-  if [ -f /etc/dhcpcd.conf ]; then
-    cp /etc/dhcpcd.conf /etc/dhcpcd.conf.bak
-    success_log "Aktuelle Netzwerkkonfiguration gesichert in /etc/dhcpcd.conf.bak"
-  fi
-  
-  # Konfigurieren von dhcpcd.conf für statische Routing
-  log "Konfiguriere Routing für duale Netzwerke..."
-  cat > /etc/dhcpcd.conf << EOL
-# MYP Dual-Network Configuration
-# eth0: Firmennetzwerk mit Internet
-# wlan0: Offline-Netzwerk für Backend
-
-# Allow dhcpcd to manage all interfaces
-allowinterfaces eth0 wlan0
-
-# eth0 configuration (Firmennetzwerk)
-interface eth0
-# DHCP for eth0, all default routes go through eth0
-metric 100
-
-# wlan0 configuration (Offline Network)
-interface wlan0
-# Static IP for wlan0
-metric 200
-# Add specific route to backend via wlan0
-EOL
-  
-  # Konfigurieren von wpa_supplicant für WLAN-Verbindung
-  log "Konfiguriere WLAN-Verbindung für Offline-Netzwerk..."
-  cat > /etc/wpa_supplicant/wpa_supplicant.conf << EOL
-ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
-update_config=1
-country=DE
-
-network={
-    ssid="${OFFLINE_NETWORK_SSID}"
-    psk="${OFFLINE_NETWORK_PASSWORD}"
-    priority=1
-}
-EOL
-  
-  chmod 600 /etc/wpa_supplicant/wpa_supplicant.conf
-  
-  # Routing-Tabelle konfigurieren
-  log "Konfiguriere spezifisches Routing zum Backend..."
-  if ! grep -q "${BACKEND_HOST}" /etc/iproute2/rt_tables; then
-    echo "200 backend" >> /etc/iproute2/rt_tables
-  fi
-  
-  # Routing-Regeln in /etc/network/if-up.d/ hinzufügen
-  cat > /etc/network/if-up.d/route-backend << EOL
-#!/bin/bash
-# Routing-Regeln für Backend-Host über WLAN
-
-# Wenn wlan0 hochgefahren wird
-if [ "\$IFACE" = "wlan0" ]; then
-  # Spezifische Route zum Backend über wlan0
-  /sbin/ip route add ${BACKEND_HOST}/32 dev wlan0
-fi
-EOL
-  
-  chmod +x /etc/network/if-up.d/route-backend
-  
-  success_log "Netzwerkkonfiguration abgeschlossen"
-}
-
-# Installation von Caddy als Reverse-Proxy
-install_caddy() {
-  header "Installation von Caddy als Reverse-Proxy"
-  
-  log "Überprüfe, ob Caddy bereits installiert ist..."
-  if command -v caddy &> /dev/null; then
-    success_log "Caddy ist bereits installiert"
-  else
-    log "Installiere Caddy ${CADDY_VERSION}..."
-    
-    # Download und Installation von Caddy
-    wget -O /tmp/caddy.tar.gz "https://github.com/caddyserver/caddy/releases/download/v${CADDY_VERSION}/caddy_${CADDY_VERSION}_linux_armv7.tar.gz"
-    
-    if [ $? -ne 0 ]; then
-      error_log "Fehler beim Herunterladen von Caddy"
-      return 1
-    fi
-    
-    tar -xzf /tmp/caddy.tar.gz -C /tmp
-    mv /tmp/caddy /usr/local/bin/
-    chmod +x /usr/local/bin/caddy
-    
-    # Benutzer und Gruppe für Caddy erstellen
-    if ! id -u caddy &>/dev/null; then
-      useradd --system --home /var/lib/caddy --shell /usr/sbin/nologin caddy
-    fi
-    
-    # Verzeichnisse für Caddy erstellen
-    mkdir -p /etc/caddy /var/lib/caddy /var/log/caddy
-    chown -R caddy:caddy /var/lib/caddy /var/log/caddy
-    
-    # Systemd-Service für Caddy einrichten
-    cat > /etc/systemd/system/caddy.service << EOL
-[Unit]
-Description=Caddy Web Server
-Documentation=https://caddyserver.com/docs/
-After=network.target network-online.target
-Requires=network-online.target
-
-[Service]
-User=caddy
-Group=caddy
-ExecStart=/usr/local/bin/caddy run --config /etc/caddy/Caddyfile
-ExecReload=/usr/local/bin/caddy reload --config /etc/caddy/Caddyfile
-TimeoutStopSec=5s
-LimitNOFILE=1048576
-LimitNPROC=512
-PrivateTmp=true
-ProtectSystem=full
-AmbientCapabilities=CAP_NET_BIND_SERVICE
-
-[Install]
-WantedBy=multi-user.target
-EOL
-    
-    success_log "Caddy wurde installiert"
-  fi
-  
-  # Caddyfile für HTTPS mit selbstsigniertem Zertifikat konfigurieren
-  log "Konfiguriere Caddy für HTTPS mit selbstsigniertem Zertifikat..."
-  cat > /etc/caddy/Caddyfile << EOL
-{
-    # Globale Optionen
-    admin off
-    auto_https disable_redirects
-    
-    # Selbstsigniertes Zertifikat verwenden
-    local_certs
-    default_sni ${FIRMENNETZWERK_HOSTNAME}
-}
-
-# HTTPS-Konfiguration für den Firmennetzwerk-Hostnamen
-${FIRMENNETZWERK_HOSTNAME} {
-    # TLS mit selbstsigniertem Zertifikat
-    tls internal {
-        on_demand
-    }
-    
-    # Reverse-Proxy zum Next.js-Frontend
-    reverse_proxy localhost:3000 {
-        # Zeitüberschreitungen für langsame Raspberry Pi-Verbindungen erhöhen
-        timeouts 5m
-    }
-    
-    # Logging
-    log {
-        output file /var/log/caddy/access.log
-        format console
-    }
-}
-
-# HTTP-Konfiguration für lokalen Zugriff
-:80 {
-    # Weiterleitung zu HTTPS
-    redir https://${FIRMENNETZWERK_HOSTNAME}{uri} permanent
-}
-
-# Zusätzlicher Server für Backend-Proxy (API-Anfragen weiterleiten)
-localhost:8000 {
-    reverse_proxy ${BACKEND_HOST}:${BACKEND_PORT} {
-        # Headers für CORS anpassen
-        header_up Host ${BACKEND_HOST}:${BACKEND_PORT}
-        header_up X-Forwarded-Host ${FIRMENNETZWERK_HOSTNAME}
-        header_up X-Forwarded-Proto https
-        
-        # Zeitüberschreitungen für API-Anfragen erhöhen
-        timeouts 1m
-    }
-    
-    # Logging
-    log {
-        output file /var/log/caddy/backend-access.log
-        format console
-    }
-}
-EOL
-  
-  # Caddy-Service neu laden und starten
-  log "Starte Caddy-Service..."
-  systemctl daemon-reload
-  systemctl enable caddy
-  systemctl restart caddy
-  
-  # Überprüfen, ob Caddy läuft
-  if systemctl is-active --quiet caddy; then
-    success_log "Caddy-Service wurde gestartet und ist aktiv"
-  else
-    error_log "Fehler beim Starten des Caddy-Services"
-    return 1
-  fi
-  
-  return 0
-}
-
-# Next.js Frontend-Konfiguration für HTTPS und Backend-Proxy
-configure_frontend() {
-  header "Frontend-Konfiguration für HTTPS"
-  
-  # Verzeichnis für das Frontend
-  FRONTEND_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-  
-  # Prüfen, ob das Frontend-Verzeichnis existiert
-  if [ ! -d "$FRONTEND_DIR" ]; then
-    error_log "Frontend-Verzeichnis nicht gefunden: $FRONTEND_DIR"
-    return 1
-  fi
-  
-  log "Konfiguriere Frontend für HTTPS und Backend-Proxy..."
-  
-  # .env.local-Datei für das Frontend erstellen
-  cat > "$FRONTEND_DIR/.env.local" << EOL
-# Backend API Konfiguration (über lokalen Proxy zu Backend)
-NEXT_PUBLIC_API_URL=http://localhost:8000
-
-# Frontend-URL für OAuth Callback (HTTPS)
-NEXT_PUBLIC_FRONTEND_URL=https://${FIRMENNETZWERK_HOSTNAME}
-
-# Explizite OAuth Callback URL für GitHub
-NEXT_PUBLIC_OAUTH_CALLBACK_URL=https://${FIRMENNETZWERK_HOSTNAME}/auth/login/callback
-EOL
-  
-  # Berechtigungen setzen
-  chown -R $(stat -c '%U:%G' "$FRONTEND_DIR") "$FRONTEND_DIR/.env.local"
-  chmod 600 "$FRONTEND_DIR/.env.local"
-  
-  success_log "Frontend wurde für HTTPS und Backend-Proxy konfiguriert"
-  
-  # Hinweis zur Installation und zum Start des Frontends
-  log "${YELLOW}Hinweis: Führen Sie nun das Frontend-Installationsskript aus:${NC}"
-  log "cd $FRONTEND_DIR && ./install.sh"
-  
-  return 0
-}
-
-# Hostname setzen
-set_hostname() {
-  header "Hostname konfigurieren"
-  
-  log "Aktueller Hostname: $(hostname)"
-  log "Setze Hostname auf ${FIRMENNETZWERK_HOSTNAME}..."
-  
-  # Hostname in /etc/hostname setzen
-  echo "${FIRMENNETZWERK_HOSTNAME}" > /etc/hostname
-  
-  # Hostname in /etc/hosts aktualisieren
-  if grep -q "$(hostname)" /etc/hosts; then
-    sed -i "s/$(hostname)/${FIRMENNETZWERK_HOSTNAME}/g" /etc/hosts
-  else
-    echo "127.0.1.1       ${FIRMENNETZWERK_HOSTNAME}" >> /etc/hosts
-  fi
-  
-  # Aktualisieren des Hostnamens ohne Neustart
-  hostname "${FIRMENNETZWERK_HOSTNAME}"
-  
-  success_log "Hostname wurde auf ${FIRMENNETZWERK_HOSTNAME} gesetzt"
-  log "${YELLOW}Hinweis: Ein Neustart wird empfohlen, um sicherzustellen, dass der neue Hostname vollständig übernommen wurde.${NC}"
-  
-  return 0
-}
-
-# Hauptfunktion
-main() {
-  # Begrüßung und Bestätigung
-  header "MYP HTTPS und Dual-Network Setup"
-  log "Dieses Skript richtet Ihren Raspberry Pi für das MYP-Projekt ein:"
-  log "- Setzt den Hostname auf: ${FIRMENNETZWERK_HOSTNAME}"
-  log "- Konfiguriert das duale Netzwerk (LAN für Internet, WLAN für Backend)"
-  log "- Installiert Caddy als Reverse-Proxy mit selbstsigniertem HTTPS"
-  log "- Konfiguriert das Frontend für die Kommunikation mit dem Backend"
-  echo ""
-  log "${YELLOW}WICHTIG: Diese Konfiguration kann bestehende Netzwerk- und HTTPS-Einstellungen überschreiben.${NC}"
-  read -p "Möchten Sie fortfahren? (j/n): " confirm
-  
-  if [[ "$confirm" != "j" ]]; then
-    log "Setup abgebrochen."
-    exit 0
-  fi
-  
-  # Schritte ausführen
-  set_hostname || { error_log "Fehler beim Setzen des Hostnamens"; exit 1; }
-  setup_network || { error_log "Fehler bei der Netzwerkkonfiguration"; exit 1; }
-  install_caddy || { error_log "Fehler bei der Caddy-Installation"; exit 1; }
-  configure_frontend || { error_log "Fehler bei der Frontend-Konfiguration"; exit 1; }
-  
-  # Abschlussmeldung
-  header "Setup abgeschlossen"
-  success_log "MYP HTTPS und Dual-Network Setup erfolgreich!"
-  log "Ihr Raspberry Pi ist nun wie folgt konfiguriert:"
-  log "- Hostname: ${FIRMENNETZWERK_HOSTNAME}"
-  log "- HTTPS mit selbstsigniertem Zertifikat über Caddy"
-  log "- Duale Netzwerkkonfiguration:"
-  log "  * eth0: Firmennetzwerk mit Internet-Zugang"
-  log "  * wlan0: Verbindung zum Offline-Netzwerk (${OFFLINE_NETWORK_SSID})"
-  log "- Frontend-URL: https://${FIRMENNETZWERK_HOSTNAME}"
-  log "- Backend-Kommunikation über lokalen Proxy: http://localhost:8000 -> ${BACKEND_HOST}:${BACKEND_PORT}"
-  echo ""
-  log "${YELLOW}Wichtige nächste Schritte:${NC}"
-  log "1. Starten Sie das Frontend mit dem Installationsskript:"
-  log "   cd $FRONTEND_DIR && ./install.sh"
-  log "2. Neustart des Raspberry Pi empfohlen:"
-  log "   sudo reboot"
-  echo ""
-  log "${YELLOW}Hinweis zum selbstsignierten Zertifikat:${NC}"
-  log "Bei Zugriff auf https://${FIRMENNETZWERK_HOSTNAME} erhalten Sie eine Zertifikatswarnung im Browser."
-  log "Dies ist normal für selbstsignierte Zertifikate. Sie können die Warnung in Ihrem Browser bestätigen."
-}
-
-# Skript starten
-main 
\ No newline at end of file
diff --git a/frontend/install.sh b/frontend/install.sh
deleted file mode 100644
index c33611c7..00000000
--- a/frontend/install.sh
+++ /dev/null
@@ -1,570 +0,0 @@
-#!/bin/bash
-
-# MYP Frontend Installations-Skript
-# Dieses Skript installiert das Frontend mit Docker und Host-Netzwerkanbindung
-
-# Farbcodes für Ausgabe
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-BLUE='\033[0;34m'
-CYAN='\033[0;36m'
-NC='\033[0m' # No Color
-
-# Funktion zur Ausgabe mit Zeitstempel
-log() {
-  echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
-}
-
-error_log() {
-  echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
-}
-
-success_log() {
-  echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] ERFOLG:${NC} $1"
-}
-
-header() {
-  echo ""
-  echo -e "${CYAN}===== $1 =====${NC}"
-  echo ""
-}
-
-# Variablen definieren
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-FRONTEND_DIR="$SCRIPT_DIR"
-DOCKER_DIR="$FRONTEND_DIR/docker"
-DEFAULT_BACKEND_URL="http://192.168.0.105:5000"
-IMAGE_NAME="myp-rp:latest"
-CONTAINER_NAME="myp-rp"
-DB_VOLUME_DIR="/srv/MYP-DB"
-ENV_FILE_PATH="/srv/myp-env/github.env"
-
-# Prüfen, ob wir im Frontend-Verzeichnis sind
-if [ ! -f "$FRONTEND_DIR/package.json" ]; then
-  error_log "Dieses Skript muss im Frontend-Verzeichnis ausgeführt werden."
-  error_log "Bitte wechseln Sie in das Frontend-Verzeichnis."
-  exit 1
-fi
-
-# Prüfen, ob Docker installiert ist
-if ! command -v docker &> /dev/null; then
-  error_log "Docker ist nicht installiert. Bitte installieren Sie Docker zuerst."
-  exit 1
-fi
-
-# Prüfen, ob Docker läuft
-if ! docker info &> /dev/null; then
-  error_log "Docker-Daemon läuft nicht. Bitte starten Sie Docker mit 'sudo systemctl start docker'."
-  exit 1
-fi
-
-# Prüfen, ob der Benutzer in der Docker-Gruppe ist
-if ! groups | grep -q '\bdocker\b'; then
-  error_log "Aktueller Benutzer hat keine Docker-Berechtigungen."
-  error_log "Bitte führen Sie das Skript mit 'sudo' aus oder fügen Sie den Benutzer zur Docker-Gruppe hinzu:"
-  error_log "sudo usermod -aG docker $USER && newgrp docker"
-  exit 1
-fi
-
-# Erstelle Datenbank-Verzeichnis, falls nicht vorhanden
-if [ ! -d "$DB_VOLUME_DIR" ]; then
-  log "Erstelle Datenbankverzeichnis: $DB_VOLUME_DIR"
-  if ! mkdir -p "$DB_VOLUME_DIR"; then
-    if ! sudo mkdir -p "$DB_VOLUME_DIR"; then
-      error_log "Konnte Datenbankverzeichnis nicht erstellen. Bitte erstellen Sie es manuell:"
-      error_log "sudo mkdir -p $DB_VOLUME_DIR && sudo chown $USER:$USER $DB_VOLUME_DIR"
-      exit 1
-    fi
-    sudo chown $USER:$USER "$DB_VOLUME_DIR"
-  fi
-else
-  log "Datenbankverzeichnis existiert bereits: $DB_VOLUME_DIR"
-fi
-
-# Funktion zum Laden der Umgebungsvariablen aus /srv/myp-env/github.env
-load_env_from_srv() {
-  if [ -f "$ENV_FILE_PATH" ]; then
-    log "Lade Umgebungsvariablen aus $ENV_FILE_PATH"
-    
-    # Versuche, die Variablen aus der Datei zu laden
-    OAUTH_CLIENT_ID=$(grep -oP 'OAUTH_CLIENT_ID=\K.*' "$ENV_FILE_PATH" 2>/dev/null || echo "client_id")
-    OAUTH_CLIENT_SECRET=$(grep -oP 'OAUTH_CLIENT_SECRET=\K.*' "$ENV_FILE_PATH" 2>/dev/null || echo "client_secret")
-    
-    # Prüfe, ob die Backend-URL in der Datei definiert ist
-    BACKEND_URL_FROM_FILE=$(grep -oP 'NEXT_PUBLIC_API_URL=\K.*' "$ENV_FILE_PATH" 2>/dev/null)
-    if [ -n "$BACKEND_URL_FROM_FILE" ]; then
-      log "Backend-URL aus $ENV_FILE_PATH geladen: $BACKEND_URL_FROM_FILE"
-      DEFAULT_BACKEND_URL="$BACKEND_URL_FROM_FILE"
-    fi
-    
-    success_log "OAuth-Konfiguration aus $ENV_FILE_PATH geladen."
-  else
-    log "${YELLOW}Warnung: $ENV_FILE_PATH nicht gefunden. Verwende Standard-Konfiguration.${NC}"
-    OAUTH_CLIENT_ID="client_id"
-    OAUTH_CLIENT_SECRET="client_secret"
-  fi
-}
-
-# Funktion zum Konfigurieren der Backend-URL
-configure_backend_url() {
-  local backend_url="${1:-$DEFAULT_BACKEND_URL}"
-  
-  header "Backend-URL konfigurieren"
-  log "Konfiguriere Backend-URL für Frontend: $backend_url"
-  
-  # Lade OAuth-Konfiguration aus /srv
-  load_env_from_srv
-  
-  # Prüfen, ob setup-backend-url.sh existiert
-  if [ -f "$FRONTEND_DIR/setup-backend-url.sh" ]; then
-    chmod +x "$FRONTEND_DIR/setup-backend-url.sh"
-    if ! "$FRONTEND_DIR/setup-backend-url.sh" "$backend_url"; then
-      error_log "Fehler beim Konfigurieren der Backend-URL."
-      return 1
-    fi
-  else
-    # Bestimme den Hostnamen für OAuth
-    HOSTNAME=$(hostname)
-    if [[ "$HOSTNAME" == *"m040tbaraspi001"* ]] || [[ "$HOSTNAME" == *"corpintra"* ]]; then
-      FRONTEND_HOSTNAME="m040tbaraspi001.de040.corpintra.net"
-      OAUTH_URL="http://m040tbaraspi001.de040.corpintra.net/auth/login/callback"
-      log "Erkannt: Unternehmens-Hostname: $FRONTEND_HOSTNAME"
-    else
-      FRONTEND_HOSTNAME="$HOSTNAME"
-      OAUTH_URL="http://$HOSTNAME:3000/auth/login/callback"
-      log "Lokaler Hostname: $FRONTEND_HOSTNAME"
-    fi
-
-    # Erstelle .env.local-Datei manuell
-    log "Erstelle .env.local-Datei manuell..."
-    cat > "$FRONTEND_DIR/.env.local" << EOL
-# Backend API Konfiguration
-NEXT_PUBLIC_API_URL=${backend_url}
-
-# Frontend-URL für OAuth Callback
-NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME}
-
-# Explizite OAuth Callback URL für GitHub
-NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL}
-
-# OAuth Konfiguration aus /srv/myp-env/github.env
-OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID}
-OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET}
-EOL
-
-    if [ ! -f "$FRONTEND_DIR/.env.local" ]; then
-      error_log "Konnte .env.local-Datei nicht erstellen."
-      return 1
-    fi
-    
-    chmod 600 "$FRONTEND_DIR/.env.local"
-  fi
-  
-  success_log "Backend-URL erfolgreich konfiguriert: $backend_url"
-  return 0
-}
-
-# Funktion zum Bauen des Images
-build_image() {
-  header "Docker-Image bauen"
-  log "Baue Docker-Image: $IMAGE_NAME"
-  
-  if [ ! -f "$FRONTEND_DIR/Dockerfile" ]; then
-    error_log "Dockerfile nicht gefunden in $FRONTEND_DIR"
-    return 1
-  fi
-  
-  cd "$FRONTEND_DIR" || return 1
-  
-  # Vorhandenes Image entfernen, falls gewünscht
-  if docker image inspect "$IMAGE_NAME" &>/dev/null; then
-    log "Image $IMAGE_NAME existiert bereits."
-    read -p "Möchten Sie das existierende Image überschreiben? (j/n): " rebuild_choice
-    if [[ "$rebuild_choice" == "j" ]]; then
-      log "Entferne existierendes Image..."
-      docker rmi "$IMAGE_NAME" &>/dev/null || true
-    else
-      log "Behalte existierendes Image."
-      return 0
-    fi
-  fi
-  
-  # Baue das Image
-  log "${YELLOW}Baue Docker-Image... (Dies kann auf einem Raspberry Pi mehrere Minuten dauern)${NC}"
-  if ! docker build -t "$IMAGE_NAME" .; then
-    error_log "Fehler beim Bauen des Docker-Images."
-    return 1
-  fi
-  
-  success_log "Docker-Image erfolgreich gebaut: $IMAGE_NAME"
-  return 0
-}
-
-# Funktion zum Speichern des Images
-save_image() {
-  header "Docker-Image speichern"
-  local save_dir="${1:-$DOCKER_DIR/images}"
-  local save_file="$save_dir/myp-frontend.tar"
-  
-  # Prüfen, ob das Image existiert
-  if ! docker image inspect "$IMAGE_NAME" &>/dev/null; then
-    error_log "Image $IMAGE_NAME existiert nicht. Bitte bauen Sie es zuerst."
-    return 1
-  fi
-  
-  # Verzeichnis erstellen, falls es nicht existiert
-  mkdir -p "$save_dir"
-  
-  log "Speichere Docker-Image in: $save_file"
-  log "${YELLOW}Dies kann einige Minuten dauern...${NC}"
-  
-  if ! docker save -o "$save_file" "$IMAGE_NAME"; then
-    error_log "Fehler beim Speichern des Docker-Images."
-    return 1
-  fi
-  
-  # Prüfe, ob die Datei erstellt wurde
-  if [ ! -f "$save_file" ]; then
-    error_log "Konnte Docker-Image nicht speichern."
-    return 1
-  fi
-  
-  # Prüfe Dateigröße
-  local filesize=$(stat -c%s "$save_file")
-  if [ "$filesize" -lt 1000000 ]; then  # Kleiner als 1MB ist verdächtig
-    error_log "Gespeichertes Image ist ungewöhnlich klein ($filesize Bytes). Möglicherweise ist etwas schief gelaufen."
-    return 1
-  fi
-  
-  success_log "Docker-Image erfolgreich gespeichert: $save_file (Größe: $(du -h "$save_file" | cut -f1))"
-  return 0
-}
-
-# Funktion zum Laden des Images
-load_image() {
-  header "Docker-Image laden"
-  local load_dir="${1:-$DOCKER_DIR/images}"
-  local load_file="$load_dir/myp-frontend.tar"
-  
-  # Prüfen, ob die Datei existiert
-  if [ ! -f "$load_file" ]; then
-    error_log "Image-Datei nicht gefunden: $load_file"
-    return 1
-  fi
-  
-  # Prüfe Dateigröße
-  local filesize=$(stat -c%s "$load_file")
-  if [ "$filesize" -lt 1000000 ]; then  # Kleiner als 1MB ist verdächtig
-    error_log "Image-Datei ist ungewöhnlich klein ($filesize Bytes). Möglicherweise ist sie beschädigt."
-    return 1
-  fi
-  
-  log "Lade Docker-Image aus: $load_file"
-  log "${YELLOW}Dies kann einige Minuten dauern...${NC}"
-  
-  if ! docker load -i "$load_file"; then
-    error_log "Fehler beim Laden des Docker-Images. Die Datei könnte beschädigt sein."
-    return 1
-  fi
-  
-  success_log "Docker-Image erfolgreich geladen."
-  return 0
-}
-
-# Funktion zum Starten des Containers mit Docker Compose
-start_container_compose() {
-  header "Container mit Docker Compose starten"
-  
-  # Erstellen der vereinfachten docker-compose.yml-Datei
-  local compose_file="$DOCKER_DIR/compose.simple.yml"
-  
-  # Lade OAuth-Konfiguration aus /srv, falls noch nicht geschehen
-  if [ -z "$OAUTH_CLIENT_ID" ]; then
-    load_env_from_srv
-  fi
-  
-  # Docker-Verzeichnis erstellen, falls nicht vorhanden
-  mkdir -p "$DOCKER_DIR"
-  
-  log "Erstelle vereinfachte Docker-Compose-Datei: $compose_file"
-  cat > "$compose_file" << EOL
-services:
-  myp-rp:
-    image: ${IMAGE_NAME}
-    container_name: ${CONTAINER_NAME}
-    environment:
-      - NEXT_PUBLIC_API_URL=${BACKEND_URL}
-      - NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME}
-      - NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL}
-      - OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID}
-      - OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET}
-    env_file: "${ENV_FILE_PATH}"
-    ports:
-      - "3000:3000"
-    volumes:
-      - ${DB_VOLUME_DIR}:/app/db
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "wget", "--spider", "http://localhost:3000"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s
-EOL
-
-  # Prüfen, ob die Datei erstellt wurde
-  if [ ! -f "$compose_file" ]; then
-    error_log "Konnte Docker-Compose-Datei nicht erstellen."
-    return 1
-  fi
-  
-  # Stoppen des vorhandenen Containers
-  if docker ps -a | grep -q "$CONTAINER_NAME"; then
-    log "Stoppe und entferne existierenden Container..."
-    docker stop "$CONTAINER_NAME" &>/dev/null || true
-    docker rm "$CONTAINER_NAME" &>/dev/null || true
-  fi
-  
-  # Container starten
-  log "Starte Container..."
-  cd "$DOCKER_DIR" || return 1
-  
-  if ! docker compose -f "$(basename "$compose_file")" up -d; then
-    # Versuche mit docker-compose, falls docker compose nicht funktioniert
-    if ! docker-compose -f "$(basename "$compose_file")" up -d; then
-      error_log "Fehler beim Starten des Containers."
-      return 1
-    fi
-  fi
-  
-  success_log "Container erfolgreich gestartet: $CONTAINER_NAME"
-  return 0
-}
-
-# Funktion zum Starten des Containers mit Docker Run
-start_container_run() {
-  header "Container direkt starten"
-  
-  # Stoppen des vorhandenen Containers
-  if docker ps -a | grep -q "$CONTAINER_NAME"; then
-    log "Stoppe und entferne existierenden Container..."
-    docker stop "$CONTAINER_NAME" &>/dev/null || true
-    docker rm "$CONTAINER_NAME" &>/dev/null || true
-  fi
-  
-  # Lade OAuth-Konfiguration aus /srv, falls noch nicht geschehen
-  if [ -z "$OAUTH_CLIENT_ID" ]; then
-    load_env_from_srv
-  fi
-  
-  # Container starten
-  log "Starte Container mit 'docker run'..."
-  
-  if ! docker run -d --name "$CONTAINER_NAME" \
-     -p 3000:3000 \
-     -e "NEXT_PUBLIC_API_URL=$BACKEND_URL" \
-     -e "NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME}" \
-     -e "NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL}" \
-     -e "OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID}" \
-     -e "OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET}" \
-     --env-file "$ENV_FILE_PATH" \
-     -v "$DB_VOLUME_DIR:/app/db" \
-     --restart unless-stopped \
-     "$IMAGE_NAME"; then
-    error_log "Fehler beim Starten des Containers."
-    return 1
-  fi
-  
-  success_log "Container erfolgreich gestartet: $CONTAINER_NAME"
-  return 0
-}
-
-# Funktion zum Starten der Anwendung ohne Docker
-start_without_docker() {
-  header "Anwendung ohne Docker starten"
-  
-  cd "$FRONTEND_DIR" || return 1
-  
-  # Prüfen, ob Node.js und pnpm installiert sind
-  if ! command -v node &> /dev/null; then
-    error_log "Node.js ist nicht installiert. Bitte installieren Sie Node.js zuerst."
-    return 1
-  fi
-  
-  if ! command -v pnpm &> /dev/null; then
-    log "pnpm ist nicht installiert. Installiere pnpm..."
-    npm install -g pnpm
-    if [ $? -ne 0 ]; then
-      error_log "Fehler beim Installieren von pnpm."
-      return 1
-    fi
-  fi
-  
-  # Installiere Abhängigkeiten
-  log "Installiere Abhängigkeiten..."
-  if ! pnpm install; then
-    error_log "Fehler beim Installieren der Abhängigkeiten."
-    return 1
-  fi
-  
-  # Lade OAuth-Konfiguration aus /srv und konfiguriere die Backend-URL
-  load_env_from_srv
-  if ! configure_backend_url "$BACKEND_URL"; then
-    error_log "Fehler beim Konfigurieren der Backend-URL."
-    return 1
-  fi
-  
-  # Baue und starte die Anwendung
-  log "Baue und starte die Anwendung..."
-  if ! pnpm build; then
-    log "${YELLOW}Warnung: Build fehlgeschlagen. Versuche, im Dev-Modus zu starten...${NC}"
-  fi
-  
-  # Starte im Screen-Session, damit die Anwendung im Hintergrund läuft
-  if command -v screen &> /dev/null; then
-    log "Starte Anwendung in Screen-Session..."
-    screen -dmS myp-frontend bash -c "cd $FRONTEND_DIR && \
-      NEXT_PUBLIC_API_URL=$BACKEND_URL \
-      NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME} \
-      NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL} \
-      OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID} \
-      OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET} \
-      pnpm start || \
-      NEXT_PUBLIC_API_URL=$BACKEND_URL \
-      NEXT_PUBLIC_FRONTEND_URL=http://${FRONTEND_HOSTNAME} \
-      NEXT_PUBLIC_OAUTH_CALLBACK_URL=${OAUTH_URL} \
-      OAUTH_CLIENT_ID=${OAUTH_CLIENT_ID} \
-      OAUTH_CLIENT_SECRET=${OAUTH_CLIENT_SECRET} \
-      pnpm dev"
-    success_log "Anwendung im Hintergrund gestartet. Verbinden mit: screen -r myp-frontend"
-  else
-    log "${YELLOW}Screen ist nicht installiert. Starte Anwendung im Vordergrund...${NC}"
-    log "${YELLOW}Beenden mit Strg+C. Die Anwendung wird dann beendet.${NC}"
-    sleep 3
-    export NEXT_PUBLIC_API_URL="$BACKEND_URL"
-    export NEXT_PUBLIC_FRONTEND_URL="http://${FRONTEND_HOSTNAME}"
-    export NEXT_PUBLIC_OAUTH_CALLBACK_URL="${OAUTH_URL}"
-    export OAUTH_CLIENT_ID="${OAUTH_CLIENT_ID}"
-    export OAUTH_CLIENT_SECRET="${OAUTH_CLIENT_SECRET}"
-    pnpm start || pnpm dev
-  fi
-  
-  return 0
-}
-
-# Funktion für das Hauptmenü
-main_menu() {
-  local choice
-  header "MYP Frontend Deployment"
-  echo "Bitte wählen Sie eine Option:"
-  echo ""
-  echo "1) Alles automatisch (Build, Deploy, Starten)"
-  echo "2) Docker-Image bauen"
-  echo "3) Docker-Image speichern"
-  echo "4) Docker-Image laden"
-  echo "5) Container mit Docker Compose starten"
-  echo "6) Container direkt mit Docker Run starten"
-  echo "7) Anwendung ohne Docker starten"
-  echo "8) Nur Backend-URL konfigurieren"
-  echo "9) Beenden"
-  echo ""
-  read -p "Ihre Wahl (1-9): " choice
-  
-  case $choice in
-    1) auto_deploy ;;
-    2) build_image ;;
-    3) save_image ;;
-    4) load_image ;;
-    5) configure_backend_url && start_container_compose ;;
-    6) configure_backend_url && start_container_run ;;
-    7) start_without_docker ;;
-    8) configure_backend_url ;;
-    9) log "Beende das Programm." && exit 0 ;;
-    *) error_log "Ungültige Auswahl. Bitte versuchen Sie es erneut." && main_menu ;;
-  esac
-  
-  # Zurück zum Hauptmenü, es sei denn, der Benutzer hat das Programm beendet
-  if [ $choice -ne 9 ]; then
-    read -p "Drücken Sie Enter, um zum Hauptmenü zurückzukehren..."
-    main_menu
-  fi
-}
-
-# Automatischer Deployment-Workflow
-auto_deploy() {
-  header "Automatisches Deployment"
-  log "Starte automatischen Deployment-Workflow..."
-  
-  # Konfiguriere Backend-URL
-  if ! configure_backend_url; then
-    error_log "Fehler beim Konfigurieren der Backend-URL."
-    return 1
-  fi
-  
-  # Versuche zunächst, das Image zu laden
-  local load_dir="$DOCKER_DIR/images"
-  local load_file="$load_dir/myp-frontend.tar"
-  
-  if [ -f "$load_file" ]; then
-    log "Image-Datei gefunden. Versuche zu laden..."
-    if load_image; then
-      log "Image erfolgreich geladen. Überspringe Bauen."
-    else
-      log "Konnte Image nicht laden. Versuche zu bauen..."
-      if ! build_image; then
-        error_log "Automatisches Deployment fehlgeschlagen beim Bauen des Images."
-        return 1
-      fi
-    fi
-  else
-    log "Keine Image-Datei gefunden. Baue neues Image..."
-    if ! build_image; then
-      error_log "Automatisches Deployment fehlgeschlagen beim Bauen des Images."
-      return 1
-    fi
-  fi
-  
-  # Speichere das Image für zukünftige Verwendung
-  log "Speichere Image für zukünftige Verwendung..."
-  save_image
-  
-  # Starte den Container
-  log "Starte Container..."
-  if ! start_container_compose; then
-    error_log "Konnte Container nicht mit Docker Compose starten. Versuche direkten Start..."
-    if ! start_container_run; then
-      error_log "Automatisches Deployment fehlgeschlagen beim Starten des Containers."
-      return 1
-    fi
-  fi
-  
-  success_log "Automatisches Deployment erfolgreich abgeschlossen!"
-  log "Frontend ist unter http://localhost:3000 erreichbar"
-  log "API-Kommunikation mit Backend: $BACKEND_URL"
-  
-  return 0
-}
-
-# Hauptanwendung
-# Zuerst nach Backend-URL fragen
-header "Backend-URL Konfiguration"
-log "Standard-Backend-URL: $DEFAULT_BACKEND_URL"
-read -p "Möchten Sie eine andere Backend-URL verwenden? (j/n): " change_url_choice
-
-if [[ "$change_url_choice" == "j" ]]; then
-  read -p "Geben Sie die neue Backend-URL ein (z.B. http://192.168.0.105:5000): " custom_url
-  if [ -n "$custom_url" ]; then
-    BACKEND_URL="$custom_url"
-    log "Verwende benutzerdefinierte Backend-URL: $BACKEND_URL"
-  else
-    BACKEND_URL="$DEFAULT_BACKEND_URL"
-    log "Leere Eingabe. Verwende Standard-Backend-URL: $BACKEND_URL"
-  fi
-else
-  BACKEND_URL="$DEFAULT_BACKEND_URL"
-  log "Verwende Standard-Backend-URL: $BACKEND_URL"
-fi
-
-# Anzeigen des Hauptmenüs
-main_menu 
\ No newline at end of file
diff --git a/frontend/start-debug-server.sh b/frontend/start-debug-server.sh
deleted file mode 100644
index fec4eba0..00000000
--- a/frontend/start-debug-server.sh
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/bin/bash
-
-# Farbcodes für Ausgabe
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Funktion zur Ausgabe mit Zeitstempel
-log() {
-  echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
-}
-
-error_log() {
-  echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
-}
-
-# Pfad zum Debug-Server
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-DEBUG_SERVER_DIR="$SCRIPT_DIR/debug-server"
-
-# Prüfe, ob das Debug-Server-Verzeichnis existiert
-if [ ! -d "$DEBUG_SERVER_DIR" ]; then
-  error_log "Debug-Server-Verzeichnis nicht gefunden: $DEBUG_SERVER_DIR"
-  exit 1
-fi
-
-# Prüfe, ob Node.js installiert ist
-if ! command -v node &> /dev/null; then
-  error_log "Node.js nicht gefunden. Bitte installieren Sie Node.js."
-  exit 1
-fi
-
-# Prüfe, ob npm installiert ist
-if ! command -v npm &> /dev/null; then
-  error_log "npm nicht gefunden. Bitte installieren Sie npm."
-  exit 1
-fi
-
-# Wechsle ins Debug-Server-Verzeichnis
-cd "$DEBUG_SERVER_DIR" || exit 1
-
-# Installiere Abhängigkeiten, falls nötig
-if [ -f "package.json" ]; then
-  log "Installiere Abhängigkeiten..."
-  npm install
-fi
-
-# Erstelle benötigte Verzeichnisse, falls sie nicht existieren
-mkdir -p public/views
-
-# Starte den Debug-Server
-log "Starte Frontend-Debug-Server..."
-node src/app.js 
\ No newline at end of file
diff --git a/frontend/start-frontend-server.sh b/frontend/start-frontend-server.sh
deleted file mode 100644
index 1d5b9be3..00000000
--- a/frontend/start-frontend-server.sh
+++ /dev/null
@@ -1,162 +0,0 @@
-#!/bin/bash
-
-# 🎨 MYP Frontend - Standalone Server Start
-# Startet den Frontend-Server vollständig unabhängig vom Backend
-
-set -e
-
-echo "🎨 MYP Frontend - Standalone Server wird gestartet..."
-
-# Farben für Terminal-Ausgabe
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Funktionen
-log_info() {
-    echo -e "${BLUE}[INFO]${NC} $1"
-}
-
-log_success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $1"
-}
-
-log_warning() {
-    echo -e "${YELLOW}[WARNING]${NC} $1"
-}
-
-log_error() {
-    echo -e "${RED}[ERROR]${NC} $1"
-}
-
-# Arbeitsverzeichnis setzen
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR"
-
-log_info "Arbeitsverzeichnis: $SCRIPT_DIR"
-
-# Umgebungsvariablen laden
-if [ -f ".env.frontend" ]; then
-    log_info "Lade Frontend-Umgebungsvariablen..."
-    export $(cat .env.frontend | grep -v '^#' | xargs)
-fi
-
-# Prüfe Docker-Installation
-if ! command -v docker &> /dev/null; then
-    log_error "Docker ist nicht installiert!"
-    exit 1
-fi
-
-if ! command -v docker-compose &> /dev/null; then
-    log_error "Docker Compose ist nicht installiert!"
-    exit 1
-fi
-
-log_success "Docker-Installation verifiziert"
-
-# Backend-Verfügbarkeit prüfen
-BACKEND_URL=${BACKEND_API_URL:-http://localhost:5000}
-log_info "Prüfe Backend-Verfügbarkeit: $BACKEND_URL"
-
-if ! curl -f "$BACKEND_URL/health" >/dev/null 2>&1; then
-    log_warning "Backend-Server ist nicht verfügbar!"
-    log_warning "Stellen Sie sicher, dass der Backend-Server läuft:"
-    log_warning "cd ../backend && ./start-backend-server.sh"
-    
-    read -p "Möchten Sie trotzdem fortfahren? [y/N]: " -n 1 -r
-    echo
-    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-        log_info "Abgebrochen."
-        exit 1
-    fi
-fi
-
-# Alte Container stoppen und entfernen
-log_info "Stoppe eventuell laufende Frontend-Container..."
-docker-compose -f docker-compose.frontend.yml down --remove-orphans 2>/dev/null || true
-
-# Images aufräumen (optional)
-if [ "$1" = "--clean" ]; then
-    log_info "Räume alte Frontend-Images auf..."
-    docker-compose -f docker-compose.frontend.yml down --rmi all --volumes 2>/dev/null || true
-    docker system prune -f
-fi
-
-# Notwendige Verzeichnisse erstellen
-log_info "Erstelle notwendige Verzeichnisse..."
-mkdir -p .next public/uploads
-
-# Node.js Dependencies prüfen
-if [ ! -d "node_modules" ] || [ ! -f "package-lock.json" ]; then
-    log_info "Installiere Node.js Dependencies..."
-    if command -v pnpm &> /dev/null; then
-        pnpm install
-    elif command -v npm &> /dev/null; then
-        npm install
-    else
-        log_warning "Weder pnpm noch npm gefunden. Dependencies werden im Container installiert."
-    fi
-fi
-
-# Frontend-Container builden und starten
-log_info "Frontend-Container werden gebaut und gestartet..."
-docker-compose -f docker-compose.frontend.yml up --build -d
-
-# Warten auf Frontend-Start
-log_info "Warte auf Frontend-Service..."
-timeout=120
-counter=0
-
-while [ $counter -lt $timeout ]; do
-    if curl -f http://localhost:3000/health >/dev/null 2>&1; then
-        log_success "Frontend-Server ist bereit!"
-        break
-    fi
-    
-    # Fallback: Prüfe, ob der Container läuft
-    if [ $counter -gt 30 ] && curl -f http://localhost:3000 >/dev/null 2>&1; then
-        log_success "Frontend-Server ist bereit!"
-        break
-    fi
-    
-    if [ $((counter % 10)) -eq 0 ]; then
-        log_info "Warte auf Frontend-Service... ($counter/$timeout Sekunden)"
-    fi
-    
-    sleep 1
-    counter=$((counter + 1))
-done
-
-if [ $counter -eq $timeout ]; then
-    log_error "Frontend-Service konnte nicht gestartet werden!"
-    log_info "Zeige Frontend-Logs:"
-    docker-compose -f docker-compose.frontend.yml logs frontend
-    exit 1
-fi
-
-# Service-Status anzeigen
-log_info "Frontend-Service Status:"
-docker-compose -f docker-compose.frontend.yml ps
-
-# URLs anzeigen
-echo ""
-log_success "🎉 Frontend-Server erfolgreich gestartet!"
-echo ""
-echo "🌐 Frontend-App: http://localhost:3000"
-echo "🔧 Frontend-Health: http://localhost:3000/health"
-echo "📦 CDN-Assets: http://localhost:8080"
-echo "⚡ Frontend-Cache: localhost:6380"
-echo ""
-echo "🔗 Verbindet sich mit Backend: ${BACKEND_API_URL:-http://localhost:5000}"
-echo ""
-
-# Logs anzeigen (optional)
-if [ "$1" = "--logs" ] || [ "$2" = "--logs" ]; then
-    log_info "Zeige Frontend-Logs (Strg+C zum Beenden):"
-    docker-compose -f docker-compose.frontend.yml logs -f
-fi
-
-log_info "Verwende 'docker-compose -f docker-compose.frontend.yml logs -f' um Logs zu verfolgen"
-log_info "Verwende 'docker-compose -f docker-compose.frontend.yml down' um den Server zu stoppen" 
\ No newline at end of file
diff --git a/myp_installer.sh b/myp_installer.sh
index a8428470..35cfec6e 100644
--- a/myp_installer.sh
+++ b/myp_installer.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
-# MYP Installer Control Center für Linux/Unix-Systeme
-# Konsolidiertes Installationsskript für die MYP-Plattform
-# Version 2.0
+# MYP Installer Control Center - Vollständige Linux/Unix-Installation
+# Zentrale Installationskonsole für die MYP-Plattform
+# Version 3.0 - Konsolidiert alle Setup-Funktionen
 
 # Farbdefinitionen
 RED='\033[0;31m'
@@ -24,6 +24,7 @@ show_header() {
   clear
   echo -e "${CYAN}=============================================================${NC}"
   echo -e "${CYAN}              MYP INSTALLER CONTROL CENTER                  ${NC}"
+  echo -e "${CYAN}                    Version 3.0                            ${NC}"
   echo -e "${CYAN}=============================================================${NC}"
   echo -e "${CYAN} $title${NC}"
   echo -e "${CYAN}=============================================================${NC}"
@@ -67,6 +68,8 @@ get_local_ip() {
 }
 
 test_dependencies() {
+  show_header "Systemvoraussetzungen prüfen"
+  
   echo -e "${BLUE}Prüfe Abhängigkeiten...${NC}"
   
   local all_installed=1
@@ -74,8 +77,12 @@ test_dependencies() {
   # Python
   if check_command python3; then
     echo -e "${GREEN}✓ Python 3 gefunden${NC}"
+    python_version=$(python3 --version 2>&1)
+    echo -e "${WHITE}  Version: $python_version${NC}"
   elif check_command python; then
     echo -e "${GREEN}✓ Python gefunden${NC}"
+    python_version=$(python --version 2>&1)
+    echo -e "${WHITE}  Version: $python_version${NC}"
   else
     echo -e "${RED}✗ Python nicht gefunden${NC}"
     all_installed=0
@@ -94,6 +101,8 @@ test_dependencies() {
   # Docker
   if check_command docker; then
     echo -e "${GREEN}✓ Docker gefunden${NC}"
+    docker_version=$(docker --version 2>&1)
+    echo -e "${WHITE}  Version: $docker_version${NC}"
   else
     echo -e "${RED}✗ Docker nicht gefunden${NC}"
     all_installed=0
@@ -110,6 +119,8 @@ test_dependencies() {
   # Node.js
   if check_command node; then
     echo -e "${GREEN}✓ Node.js gefunden${NC}"
+    node_version=$(node --version 2>&1)
+    echo -e "${WHITE}  Version: $node_version${NC}"
   else
     echo -e "${RED}✗ Node.js nicht gefunden${NC}"
     all_installed=0
@@ -131,7 +142,23 @@ test_dependencies() {
     all_installed=0
   fi
   
-  return $all_installed
+  # Git
+  if check_command git; then
+    echo -e "${GREEN}✓ Git gefunden${NC}"
+  else
+    echo -e "${RED}✗ Git nicht gefunden${NC}"
+    all_installed=0
+  fi
+  
+  echo ""
+  if [ $all_installed -eq 1 ]; then
+    echo -e "${GREEN}✓ Alle Abhängigkeiten sind installiert!${NC}"
+  else
+    echo -e "${YELLOW}⚠ Einige Abhängigkeiten fehlen. Bitte installieren Sie diese vor der Verwendung.${NC}"
+  fi
+  
+  echo ""
+  read -p "Drücken Sie ENTER, um fortzufahren..."
 }
 
 setup_hosts() {
@@ -217,6 +244,10 @@ create_ssl_certificates() {
       backend_hostname="raspberrypi"
       frontend_hostname="m040tbaraspi001.de040.corpintra.net"
       ;;
+    *)
+      backend_hostname="localhost"
+      frontend_hostname="localhost"
+      ;;
   esac
   
   echo -e "${BLUE}Backend-Hostname: $backend_hostname${NC}"
@@ -232,35 +263,52 @@ create_ssl_certificates() {
   # SSL-Zertifikate mit Python und cryptography erstellen
   echo -e "${BLUE}Erstelle SSL-Zertifikate mit Python...${NC}"
   
-  if check_command python3 || check_command python; then
-    # Überprüfen, ob cryptography installiert ist
+  # Überprüfen, ob Python verfügbar ist
+  python_cmd=""
+  if check_command python3; then
     python_cmd="python3"
-    if ! check_command python3; then
-      python_cmd="python"
+  elif check_command python; then
+    python_cmd="python"
+  else
+    echo -e "${RED}Python nicht gefunden. SSL-Zertifikate können nicht erstellt werden.${NC}"
+    read -p "Drücken Sie ENTER, um fortzufahren..."
+    return 1
+  fi
+  
+  # Überprüfen, ob cryptography installiert ist
+  cryptography_installed=$($python_cmd -c "try: import cryptography; print('True'); except ImportError: print('False')" 2>/dev/null)
+  
+  if [ "$cryptography_installed" != "True" ]; then
+    echo -e "${YELLOW}Installiere Python-Abhängigkeit 'cryptography'...${NC}"
+    if check_command pip3; then
+      exec_command "pip3 install cryptography" "Installiere cryptography-Paket"
+    elif check_command pip; then
+      exec_command "pip install cryptography" "Installiere cryptography-Paket"
+    else
+      echo -e "${RED}pip nicht gefunden. Kann cryptography nicht installieren.${NC}"
+      read -p "Drücken Sie ENTER, um fortzufahren..."
+      return 1
     fi
-    
-    cryptography_installed=$($python_cmd -c "try: import cryptography; print('True'); except ImportError: print('False')" 2>/dev/null)
-    
-    if [ "$cryptography_installed" != "True" ]; then
-      echo -e "${YELLOW}Installiere Python-Abhängigkeit 'cryptography'...${NC}"
-      if check_command pip3; then
-        exec_command "pip3 install cryptography" "Installiere cryptography-Paket"
-      else
-        exec_command "pip install cryptography" "Installiere cryptography-Paket"
-      fi
-    fi
-    
-    # Python-Skript zur Zertifikatserstellung
-    cat > temp_cert_script.py << EOF
+  fi
+  
+  # Python-Skript zur Zertifikatserstellung erstellen
+  cat > temp_cert_script.py << EOL
 #!/usr/bin/env python3
 import os
 import datetime
 import sys
-from cryptography import x509
-from cryptography.x509.oid import NameOID
-from cryptography.hazmat.primitives import hashes
-from cryptography.hazmat.primitives.asymmetric import rsa
-from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, NoEncryption
+
+try:
+    from cryptography import x509
+    from cryptography.x509.oid import NameOID
+    from cryptography.hazmat.primitives import hashes
+    from cryptography.hazmat.primitives.asymmetric import rsa
+    from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, NoEncryption
+    import ipaddress
+except ImportError as e:
+    print(f"Fehler: Paket nicht gefunden: {e}")
+    print("Bitte installieren Sie es mit: pip install cryptography")
+    sys.exit(1)
 
 def create_self_signed_cert(cert_path, key_path, hostname="localhost"):
     # Verzeichnis erstellen, falls es nicht existiert
@@ -312,7 +360,8 @@ def create_self_signed_cert(cert_path, key_path, hostname="localhost"):
     ).add_extension(
         x509.SubjectAlternativeName([
             x509.DNSName(hostname), 
-            x509.DNSName("localhost")
+            x509.DNSName("localhost"),
+            x509.IPAddress(ipaddress.IPv4Address("127.0.0.1"))
         ]),
         critical=False,
     ).add_extension(
@@ -350,23 +399,20 @@ create_self_signed_cert('$backend_cert_file', '$backend_key_file', '$backend_hos
 
 # Frontend-Zertifikat erstellen
 create_self_signed_cert('$frontend_cert_file', '$frontend_key_file', '$frontend_hostname')
-EOF
-    
-    # Python-Skript ausführbar machen und ausführen
-    chmod +x temp_cert_script.py
-    
-    if $python_cmd temp_cert_script.py; then
-      echo -e "${GREEN}SSL-Zertifikate erfolgreich erstellt!${NC}"
-    else
-      echo -e "${RED}Fehler beim Erstellen der SSL-Zertifikate.${NC}"
-    fi
-    
-    # Temporäres Skript löschen
-    rm temp_cert_script.py
+EOL
+  
+  # Python-Skript ausführbar machen und ausführen
+  chmod +x temp_cert_script.py
+  
+  if $python_cmd temp_cert_script.py; then
+    echo -e "${GREEN}SSL-Zertifikate erfolgreich erstellt!${NC}"
   else
-    echo -e "${RED}Python nicht gefunden. SSL-Zertifikate können nicht erstellt werden.${NC}"
+    echo -e "${RED}Fehler beim Erstellen der SSL-Zertifikate.${NC}"
   fi
   
+  # Temporäres Skript löschen
+  rm -f temp_cert_script.py
+  
   # Zertifikate im System installieren (optional)
   if [ $is_root -eq 1 ]; then
     read -p "Möchten Sie die Zertifikate im System installieren? (j/n, Standard: n): " install_certs
@@ -375,19 +421,28 @@ EOF
       if [ -f "$backend_cert_file" ]; then
         echo -e "${BLUE}Installiere Backend-Zertifikat im System...${NC}"
         
-        # Für verschiedene Linux-Distributionen
+        # Debian/Ubuntu/Raspberry Pi OS
         if [ -d "/usr/local/share/ca-certificates" ]; then
-          # Debian/Ubuntu/Raspberry Pi OS
-          cp "$backend_cert_file" /usr/local/share/ca-certificates/myp.crt
+          cp "$backend_cert_file" /usr/local/share/ca-certificates/myp-backend.crt
           update-ca-certificates
-          echo -e "${GREEN}Zertifikat installiert (Debian/Ubuntu)${NC}"
+        # RHEL/CentOS/Fedora
         elif [ -d "/etc/pki/ca-trust/source/anchors" ]; then
-          # RHEL/CentOS/Fedora
-          cp "$backend_cert_file" /etc/pki/ca-trust/source/anchors/myp.crt
+          cp "$backend_cert_file" /etc/pki/ca-trust/source/anchors/myp-backend.crt
+          update-ca-trust extract
+        fi
+      fi
+      
+      if [ -f "$frontend_cert_file" ]; then
+        echo -e "${BLUE}Installiere Frontend-Zertifikat im System...${NC}"
+        
+        # Debian/Ubuntu/Raspberry Pi OS
+        if [ -d "/usr/local/share/ca-certificates" ]; then
+          cp "$frontend_cert_file" /usr/local/share/ca-certificates/myp-frontend.crt
+          update-ca-certificates
+        # RHEL/CentOS/Fedora
+        elif [ -d "/etc/pki/ca-trust/source/anchors" ]; then
+          cp "$frontend_cert_file" /etc/pki/ca-trust/source/anchors/myp-frontend.crt
           update-ca-trust extract
-          echo -e "${GREEN}Zertifikat installiert (RHEL/CentOS/Fedora)${NC}"
-        else
-          echo -e "${YELLOW}Unbekanntes System. Zertifikatinstallation übersprungen.${NC}"
         fi
       fi
     fi
@@ -404,50 +459,53 @@ EOF
     
     # Kopiere Zertifikate ins Frontend-Verzeichnis
     frontend_ssl_dir="./frontend/ssl"
-    if [ ! -d "$frontend_ssl_dir" ]; then
-      mkdir -p "$frontend_ssl_dir"
+    mkdir -p "$frontend_ssl_dir"
+    
+    if [ -f "$backend_cert_file" ]; then
+      cp "$backend_cert_file" "$frontend_ssl_dir/myp.crt"
     fi
     
-    cp "$backend_cert_file" "$frontend_ssl_dir/myp.crt"
-    cp "$backend_key_file" "$frontend_ssl_dir/myp.key"
+    if [ -f "$backend_key_file" ]; then
+      cp "$backend_key_file" "$frontend_ssl_dir/myp.key"
+    fi
     
     echo -e "${GREEN}Zertifikate ins Frontend-Verzeichnis kopiert.${NC}"
     
-    # Prüfen, ob .env.local existiert und aktualisieren
+    # .env.local aktualisieren
     env_local_path="./frontend/.env.local"
     
     if [ -f "$env_local_path" ]; then
-      # Datei existiert, mache Backup
-      cp "$env_local_path" "${env_local_path}.bak"
+      env_content=$(cat "$env_local_path")
     else
-      # Datei erstellen
-      echo "# MYP Frontend Umgebungsvariablen" > "$env_local_path"
+      env_content="# MYP Frontend Umgebungsvariablen"
     fi
     
-    # SSL-Konfigurationen hinzufügen/aktualisieren
-    declare -a ssl_configs=(
+    # SSL-Konfigurationen
+    ssl_configs=(
       "NODE_TLS_REJECT_UNAUTHORIZED=0"
       "HTTPS=true"
       "SSL_CRT_FILE=./ssl/myp.crt"
       "SSL_KEY_FILE=./ssl/myp.key"
-      "NEXT_PUBLIC_API_URL=https://${backend_hostname}"
-      "NEXT_PUBLIC_BACKEND_HOST=${backend_hostname}"
+      "NEXT_PUBLIC_API_URL=https://$backend_hostname"
+      "NEXT_PUBLIC_BACKEND_HOST=$backend_hostname"
       "NEXT_PUBLIC_BACKEND_PROTOCOL=https"
     )
     
+    # Existierende Konfigurationen aktualisieren
     for config in "${ssl_configs[@]}"; do
       key=$(echo "$config" | cut -d'=' -f1)
       
-      # Prüfen, ob die Konfiguration bereits existiert
-      if grep -q "^${key}=" "$env_local_path"; then
-        # Existierende Konfiguration aktualisieren
-        sed -i "s|^${key}=.*|${config}|" "$env_local_path"
+      if echo "$env_content" | grep -q "^$key="; then
+        # Update existierende Konfiguration
+        env_content=$(echo "$env_content" | sed "s/^$key=.*/$config/")
       else
         # Neue Konfiguration hinzufügen
-        echo "$config" >> "$env_local_path"
+        env_content="$env_content\n$config"
       fi
     done
     
+    # Speichern der aktualisierten Umgebungsvariablen
+    echo -e "$env_content" > "$env_local_path"
     echo -e "${GREEN}.env.local Datei mit SSL-Konfigurationen aktualisiert.${NC}"
   fi
   
@@ -464,27 +522,27 @@ setup_environment() {
   show_header "Umgebungs-Setup"
   
   # Prüfen, ob Python und pip installiert sind
-  python_cmd="python3"
-  pip_cmd="pip3"
+  python_cmd=""
+  pip_cmd=""
   
-  if ! check_command python3; then
-    if check_command python; then
-      python_cmd="python"
-    else
-      echo -e "${RED}Python ist nicht installiert.${NC}"
-      read -p "Drücken Sie ENTER, um fortzufahren..."
-      return 1
-    fi
+  if check_command python3; then
+    python_cmd="python3"
+  elif check_command python; then
+    python_cmd="python"
+  else
+    echo -e "${RED}Python ist nicht installiert. Bitte installieren Sie Python 3.6+ und versuchen Sie es erneut.${NC}"
+    read -p "Drücken Sie ENTER, um fortzufahren..."
+    return 1
   fi
   
-  if ! check_command pip3; then
-    if check_command pip; then
-      pip_cmd="pip"
-    else
-      echo -e "${RED}pip ist nicht installiert.${NC}"
-      read -p "Drücken Sie ENTER, um fortzufahren..."
-      return 1
-    fi
+  if check_command pip3; then
+    pip_cmd="pip3"
+  elif check_command pip; then
+    pip_cmd="pip"
+  else
+    echo -e "${RED}pip ist nicht installiert. Bitte installieren Sie pip und versuchen Sie es erneut.${NC}"
+    read -p "Drücken Sie ENTER, um fortzufahren..."
+    return 1
   fi
   
   # Python-Abhängigkeiten installieren
@@ -516,6 +574,12 @@ setup_environment() {
     fi
   fi
   
+  # Datenbank initialisieren
+  echo -e "${BLUE}Initialisiere Datenbank...${NC}"
+  if [ -f "backend/app/models.py" ]; then
+    exec_command "cd backend && $python_cmd -c 'from app.models import init_db, create_initial_admin; init_db(); create_initial_admin()'" "Initialisiere Datenbank und Admin-Benutzer"
+  fi
+  
   echo ""
   echo -e "${GREEN}Umgebungs-Setup abgeschlossen!${NC}"
   
@@ -529,54 +593,60 @@ start_application() {
   echo -e "${BLUE}Wie möchten Sie die Anwendung starten?${NC}"
   echo -e "${WHITE}1. Backend-Server starten (Python)${NC}"
   echo -e "${WHITE}2. Frontend-Server starten (Node.js)${NC}"
-  echo -e "${WHITE}3. Beide Server starten${NC}"
+  echo -e "${WHITE}3. Beide Server starten (in separaten Terminals)${NC}"
   echo -e "${WHITE}4. Mit Docker Compose starten${NC}"
-  echo -e "${WHITE}5. Zurück zum Hauptmenü${NC}"
+  echo -e "${WHITE}5. Vollständige Installation und Start${NC}"
+  echo -e "${WHITE}6. Zurück zum Hauptmenü${NC}"
   
-  read -p "Wählen Sie eine Option (1-5): " choice
+  read -p "Wählen Sie eine Option (1-6): " choice
   
   case $choice in
     1)
       echo -e "${BLUE}Starte Backend-Server...${NC}"
-      python_cmd="python3"
-      if ! check_command python3; then
+      python_cmd=""
+      if check_command python3; then
+        python_cmd="python3"
+      elif check_command python; then
         python_cmd="python"
       fi
-      $python_cmd backend/app/app.py &
-      echo -e "${GREEN}Backend-Server läuft jetzt im Hintergrund.${NC}"
-      echo -e "${YELLOW}PID: $!${NC}"
+      
+      if [ -n "$python_cmd" ]; then
+        $python_cmd backend/app/app.py &
+        echo -e "${GREEN}Backend-Server läuft jetzt im Hintergrund.${NC}"
+      else
+        echo -e "${RED}Python nicht gefunden.${NC}"
+      fi
       ;;
     2)
       echo -e "${BLUE}Starte Frontend-Server...${NC}"
       if check_command npm; then
         (cd frontend && npm run dev) &
         echo -e "${GREEN}Frontend-Server läuft jetzt im Hintergrund.${NC}"
-        echo -e "${YELLOW}PID: $!${NC}"
       else
-        echo -e "${RED}npm ist nicht installiert.${NC}"
+        echo -e "${RED}npm nicht gefunden.${NC}"
       fi
       ;;
     3)
       echo -e "${BLUE}Starte Backend-Server...${NC}"
-      python_cmd="python3"
-      if ! check_command python3; then
+      python_cmd=""
+      if check_command python3; then
+        python_cmd="python3"
+      elif check_command python; then
         python_cmd="python"
       fi
-      $python_cmd backend/app/app.py &
-      backend_pid=$!
+      
+      if [ -n "$python_cmd" ]; then
+        $python_cmd backend/app/app.py &
+        echo -e "${GREEN}Backend-Server gestartet.${NC}"
+      fi
       
       echo -e "${BLUE}Starte Frontend-Server...${NC}"
       if check_command npm; then
         (cd frontend && npm run dev) &
-        frontend_pid=$!
-        
-        echo -e "${GREEN}Beide Server laufen jetzt im Hintergrund.${NC}"
-        echo -e "${YELLOW}Backend PID: $backend_pid${NC}"
-        echo -e "${YELLOW}Frontend PID: $frontend_pid${NC}"
-      else
-        echo -e "${RED}npm ist nicht installiert. Nur Backend wurde gestartet.${NC}"
-        echo -e "${YELLOW}Backend PID: $backend_pid${NC}"
+        echo -e "${GREEN}Frontend-Server gestartet.${NC}"
       fi
+      
+      echo -e "${GREEN}Beide Server laufen jetzt im Hintergrund.${NC}"
       ;;
     4)
       if check_command docker && check_command docker-compose; then
@@ -588,6 +658,29 @@ start_application() {
       fi
       ;;
     5)
+      echo -e "${BLUE}Führe vollständige Installation durch...${NC}"
+      setup_environment
+      create_ssl_certificates
+      echo -e "${BLUE}Starte Anwendung...${NC}"
+      
+      python_cmd=""
+      if check_command python3; then
+        python_cmd="python3"
+      elif check_command python; then
+        python_cmd="python"
+      fi
+      
+      if [ -n "$python_cmd" ]; then
+        $python_cmd backend/app/app.py &
+      fi
+      
+      if check_command npm; then
+        (cd frontend && npm run dev) &
+      fi
+      
+      echo -e "${GREEN}Vollständige Installation und Start abgeschlossen!${NC}"
+      ;;
+    6)
       return
       ;;
     *)
@@ -599,45 +692,64 @@ start_application() {
   read -p "Drücken Sie ENTER, um fortzufahren..."
 }
 
-clean_old_scripts() {
-  show_header "Alte Skripte bereinigen"
+show_project_info() {
+  show_header "Projekt-Informationen"
   
-  old_scripts=(
-    "setup_ssl.sh"
-    "setup_hosts.sh"
-    "generate_ssl_certs.sh"
-    "setup_ssl.ps1"
-    "setup_hosts.ps1"
-    "setup_hosts_copy.ps1"
-    "generate_ssl_certs.ps1"
-    "generate_ssl_certs_copy.ps1"
-  )
-  
-  echo -e "${BLUE}Folgende Skripte werden gelöscht:${NC}"
-  for script in "${old_scripts[@]}"; do
-    if [ -f "$script" ]; then
-      echo -e "${WHITE}  - $script${NC}"
-    fi
-  done
+  echo -e "${CYAN}MYP (Mercedes-Benz Yard Printing) Platform${NC}"
+  echo -e "${BLUE}Version 3.0${NC}"
+  echo ""
+  echo -e "${BLUE}Beschreibung:${NC}"
+  echo -e "${WHITE}Eine vollständige 3D-Drucker-Management-Plattform für Mercedes-Benz Werk 040 Berlin.${NC}"
+  echo ""
+  echo -e "${BLUE}Komponenten:${NC}"
+  echo -e "${WHITE}- Backend: Flask-basierte REST API${NC}"
+  echo -e "${WHITE}- Frontend: Next.js React-Anwendung${NC}"
+  echo -e "${WHITE}- Datenbank: SQLite${NC}"
+  echo -e "${WHITE}- Authentifizierung: GitHub OAuth + lokale Benutzer${NC}"
+  echo -e "${WHITE}- SSL/TLS: Selbstsignierte Zertifikate${NC}"
+  echo ""
+  echo -e "${BLUE}Standard-Zugangsdaten:${NC}"
+  echo -e "${WHITE}- Admin E-Mail: admin@mercedes-benz.com${NC}"
+  echo -e "${WHITE}- Admin Passwort: 744563017196A${NC}"
+  echo ""
+  echo -e "${BLUE}URLs:${NC}"
+  echo -e "${WHITE}- Backend: https://localhost:443 oder https://raspberrypi:443${NC}"
+  echo -e "${WHITE}- Frontend: https://localhost:3000${NC}"
+  echo ""
+  echo -e "${YELLOW}Weitere Informationen finden Sie in der CREDENTIALS.md Datei.${NC}"
   
   echo ""
-  read -p "Möchten Sie fortfahren? (j/n, Standard: j): " confirm
+  read -p "Drücken Sie ENTER, um fortzufahren..."
+}
+
+clean_old_files() {
+  show_header "Alte Dateien bereinigen"
   
-  if [ "$confirm" != "n" ]; then
-    for script in "${old_scripts[@]}"; do
-      if [ -f "$script" ]; then
-        if rm "$script"; then
-          echo -e "${GREEN}✓ $script wurde gelöscht.${NC}"
-        else
-          echo -e "${RED}✗ Fehler beim Löschen von $script.${NC}"
-        fi
+  read -p "Möchten Sie alte Skriptdateien und temporäre Dateien löschen? (j/n): " clean_files
+  
+  if [ "$clean_files" = "j" ]; then
+    files_to_delete=(
+      "setup_hosts.sh"
+      "setup_ssl.sh"
+      "generate_ssl_certs.sh"
+      "temp_cert_script.py"
+      "frontend/cleanup.sh"
+      "frontend/install.sh"
+      "frontend/https-setup.sh"
+      "frontend/start-debug-server.sh"
+      "frontend/start-frontend-server.sh"
+    )
+    
+    for file in "${files_to_delete[@]}"; do
+      if [ -f "$file" ]; then
+        rm -f "$file"
+        echo -e "${GREEN}✓ Gelöscht: $file${NC}"
       fi
     done
     
-    echo ""
-    echo -e "${GREEN}Bereinigung abgeschlossen.${NC}"
+    echo -e "${GREEN}Bereinigung abgeschlossen!${NC}"
   else
-    echo -e "${YELLOW}Bereinigung abgebrochen.${NC}"
+    echo -e "${BLUE}Bereinigung übersprungen.${NC}"
   fi
   
   echo ""
@@ -653,17 +765,16 @@ show_main_menu() {
   echo -e "${WHITE}3. SSL-Zertifikate erstellen${NC}"
   echo -e "${WHITE}4. Umgebung einrichten (Abhängigkeiten installieren)${NC}"
   echo -e "${WHITE}5. Anwendung starten${NC}"
-  echo -e "${WHITE}6. Alte Skripte bereinigen${NC}"
-  echo -e "${WHITE}Q. Beenden${NC}"
+  echo -e "${WHITE}6. Projekt-Informationen anzeigen${NC}"
+  echo -e "${WHITE}7. Alte Dateien bereinigen${NC}"
+  echo -e "${WHITE}8. Beenden${NC}"
   echo ""
   
-  read -p "Wählen Sie eine Option (1-6, Q): " choice
+  read -p "Wählen Sie eine Option (1-8): " choice
   
   case $choice in
     1)
       test_dependencies
-      echo ""
-      read -p "Drücken Sie ENTER, um fortzufahren..."
       show_main_menu
       ;;
     2)
@@ -683,10 +794,15 @@ show_main_menu() {
       show_main_menu
       ;;
     6)
-      clean_old_scripts
+      show_project_info
       show_main_menu
       ;;
-    [Qq])
+    7)
+      clean_old_files
+      show_main_menu
+      ;;
+    8)
+      echo -e "${GREEN}Auf Wiedersehen!${NC}"
       exit 0
       ;;
     *)