$ErrorActionPreference = 'Stop'
$VendooDir = Split-Path -Parent $MyInvocation.MyCommand.Path
$Version = '1.41.2'
$Port = 8124
$InstallModeFile = Join-Path $VendooDir '.vendoo-install-mode'

try {
    $utf8NoBom = New-Object System.Text.UTF8Encoding($false)
    [Console]::InputEncoding = $utf8NoBom
    [Console]::OutputEncoding = $utf8NoBom
    $OutputEncoding = $utf8NoBom
} catch {}


function Write-Utf8NoBomFile([string]$Path, [string]$Content) {
    $utf8 = New-Object System.Text.UTF8Encoding($false)
    [System.IO.File]::WriteAllText($Path, $Content, $utf8)
}

function Write-Header {
    Clear-Host
    Write-Host ''
    Write-Host '  ╔══════════════════════════════════════╗' -ForegroundColor DarkGreen
    Write-Host '  ║                                      ║' -ForegroundColor DarkGreen
    Write-Host '  ║     V E N D O O   S E T U P          ║' -ForegroundColor Green
    Write-Host '  ║     Listing-Generator v'$Version'        ║' -ForegroundColor DarkGreen
    Write-Host '  ║                                      ║' -ForegroundColor DarkGreen
    Write-Host '  ╚══════════════════════════════════════╝' -ForegroundColor DarkGreen
    Write-Host ''
}

function Write-Step($step, $text) {
    Write-Host "  [$step] " -ForegroundColor Cyan -NoNewline
    Write-Host $text
}

function Write-OK($text) {
    Write-Host "  [OK] " -ForegroundColor Green -NoNewline
    Write-Host $text
}

function Write-Warn($text) {
    Write-Host "  [!] " -ForegroundColor Yellow -NoNewline
    Write-Host $text
}

function Write-Err($text) {
    Write-Host "  [X] " -ForegroundColor Red -NoNewline
    Write-Host $text
}

function Remove-LegacyTryOnComponents {
    $migrationMarker = Join-Path $VendooDir '.migration-image-stack-cleanup-1.20.0'
    if (Test-Path -LiteralPath $migrationMarker) { return }

    $legacyRoot = Join-Path $VendooDir 'local-ai\fashn-vton'
    $legacyUploadRoot = Join-Path $VendooDir 'uploads\vto-models'
    $legacyArchiveRoot = Join-Path $VendooDir 'uploads\ai-generated\legacy-models'
    $hasLegacyRuntime = (Test-Path -LiteralPath $legacyRoot) -or (Test-Path -LiteralPath $legacyUploadRoot)
    if ($hasLegacyRuntime) {
        Write-Host ''
        Write-Step 'Cleanup' 'Entferne den aufgegebenen lokalen Try-on-Stack. Eigene Bilder bleiben erhalten ...'
    }

    try {
        Get-CimInstance Win32_Process -ErrorAction SilentlyContinue |
            Where-Object { $_.CommandLine -match 'fashn-vton|local-vto|service\.py.+8190' } |
            ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }
    } catch {}
    try { & schtasks.exe /Delete /F /TN 'Vendoo FASHN VTON' 2>$null | Out-Null } catch {}
    try { Remove-ItemProperty -Path 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Run' -Name 'VendooFashnVton' -ErrorAction SilentlyContinue } catch {}
    try {
        $startup = [Environment]::GetFolderPath('Startup')
        if ($startup) { Remove-Item -LiteralPath (Join-Path $startup 'Vendoo-FASHN-VTON.cmd') -Force -ErrorAction SilentlyContinue }
    } catch {}

    if (Test-Path -LiteralPath $legacyUploadRoot) {
        Get-ChildItem -LiteralPath $legacyUploadRoot -File -Recurse -ErrorAction SilentlyContinue | ForEach-Object {
            $relative = $_.FullName.Substring($legacyUploadRoot.Length).TrimStart('\')
            $target = Join-Path $legacyArchiveRoot $relative
            New-Item -ItemType Directory -Force -Path (Split-Path -Parent $target) | Out-Null
            if (-not (Test-Path -LiteralPath $target)) { Move-Item -LiteralPath $_.FullName -Destination $target -Force -ErrorAction SilentlyContinue }
        }
        Remove-Item -LiteralPath $legacyUploadRoot -Recurse -Force -ErrorAction SilentlyContinue
    }

    if (Test-Path -LiteralPath $legacyRoot) {
        Write-Step 'Cleanup' 'Entferne alte Python-, Modell- und Dienstdateien ...'
        Remove-Item -LiteralPath $legacyRoot -Recurse -Force -ErrorAction SilentlyContinue
    }
    @(
        'scripts\install-local-vto.ps1','scripts\uninstall-local-vto.ps1',
        'lib\ai-vto-bfl.mjs','lib\ai-vto-local.mjs','lib\ai-vto-model-jobs.mjs','lib\ai-vto-model-prompts.mjs',
        'local-ai\workflows\vendoo_flux_tryon_api.json'
    ) | ForEach-Object { Remove-Item -LiteralPath (Join-Path $VendooDir $_) -Force -ErrorAction SilentlyContinue }
    Get-ChildItem -LiteralPath (Join-Path $VendooDir 'logs') -Filter 'local-vto*' -File -ErrorAction SilentlyContinue |
        Remove-Item -Force -ErrorAction SilentlyContinue

    $legacyEnv = Join-Path $VendooDir 'local-ai\.env.local-flux'
    if (Test-Path -LiteralPath $legacyEnv) {
        $cleanLines = Get-Content -LiteralPath $legacyEnv -ErrorAction SilentlyContinue | Where-Object { $_ -notmatch '^LOCAL_IMAGE_TRYON_WORKFLOW_PATH=' }
        Write-Utf8NoBomFile -Path $legacyEnv -Content (($cleanLines -join [Environment]::NewLine) + [Environment]::NewLine)
    }

    $rootEnv = Join-Path $VendooDir '.env'
    if (Test-Path -LiteralPath $rootEnv) {
        $cleanRootEnv = Get-Content -LiteralPath $rootEnv -ErrorAction SilentlyContinue | Where-Object {
            $_ -notmatch '^(BFL_API_KEY|LOCAL_IMAGE_TRYON_WORKFLOW_PATH|VENDOO_VTO_URL|VENDOO_VTO_TOKEN)='
        }
        Write-Utf8NoBomFile -Path $rootEnv -Content (($cleanRootEnv -join [Environment]::NewLine) + [Environment]::NewLine)
    }

    $legacyDocs = @(
        'SLICE_24_VIRTUAL_TRYON_PROMPT_POPUP.md','SLICE_24_1_TRYON_WORKFLOW_SELF_HEAL.md',
        'SLICE_25_PRODUCTIVE_VIRTUAL_TRYON.md','SLICE_25_SHA256.json','SLICE_25_VERIFICATION.json',
        'SLICE_26_LOCAL_FASHN_VTON_FLUX_PROMPT.md','SLICE_26_SHA256.json','SLICE_26_VERIFICATION.json',
        'SLICE_26_1_PYTHON_INSTALLER_LIVE_STATUS.md','SLICE_26_1_SHA256.json','SLICE_26_1_VERIFICATION.json',
        'SLICE_26_2_INSTALLER_ENCODING_PYTHON_DETECTION.md','SLICE_26_2_SHA256.json','SLICE_26_2_VERIFICATION.json',
        'SLICE_26_3_PORTABLE_PYTHON_RUNTIME.md','SLICE_26_3_SHA256.json','SLICE_26_3_VERIFICATION.json',
        'SLICE_26_4_UV_PYTHON_DETECTION.md','SLICE_26_4_SHA256.json','SLICE_26_4_VERIFICATION.json',
        'SLICE_26_5_NATIVE_PROCESS_RUNNER.md','SLICE_26_5_VERIFICATION.json',
        'SLICE_26_6_VTO_PIP_BOOTSTRAP_STATUS.md','SLICE_26_6_VERIFICATION.json',
        'SLICE_26_7_NPM_PUBLIC_REGISTRY_ATOMIC_REPAIR.md','SLICE_26_7_VERIFICATION.json',
        'SLICE_26_8_VTO_DEPENDENCY_INSTALLER.md','SLICE_26_8_VERIFICATION.json',
        'SLICE_26_9_VTO_UTF8_PARSER_AUTOSTART.md','SLICE_27_FLUX_MODEL_STUDIO_LIBRARY.md','SLICE_27_VERIFICATION.json'
    )
    foreach ($doc in $legacyDocs) { Remove-Item -LiteralPath (Join-Path $VendooDir ('docs\' + $doc)) -Force -ErrorAction SilentlyContinue }

    Write-Utf8NoBomFile -Path $migrationMarker -Content "Vendoo 1.20.0 image-stack cleanup completed."
    if ($hasLegacyRuntime) { Write-OK 'Alter Try-on-Stack wurde entfernt; FLUX bleibt vollständig erhalten.' }
}


function Test-VendooPowerShellFiles {
    $relativeFiles = @(
        'scripts\install-local-flux.ps1',
        'scripts\uninstall-local-flux.ps1',
        'setup-gui.ps1'
    )
    $failed = $false
    foreach ($relative in $relativeFiles) {
        $path = Join-Path $VendooDir $relative
        if (-not (Test-Path -LiteralPath $path)) {
            Write-Err ("Pflichtskript fehlt: {0}" -f $relative)
            $failed = $true
            continue
        }
        $tokens = $null
        $errors = $null
        [System.Management.Automation.Language.Parser]::ParseFile($path, [ref]$tokens, [ref]$errors) | Out-Null
        if ($errors.Count -gt 0) {
            Write-Err ("PowerShell-Syntaxfehler in {0}" -f $relative)
            foreach ($parseError in $errors) {
                Write-Host ("      Zeile {0}: {1}" -f $parseError.Extent.StartLineNumber, $parseError.Message) -ForegroundColor Red
            }
            $failed = $true
        }
    }
    return (-not $failed)
}

function Test-NodeInstalled {
    try {
        $v = & node --version 2>$null
        if ($v -match '^v(\d+)') {
            $major = [int]$Matches[1]
            return @{ Installed = $true; Version = $v; Major = $major }
        }
    } catch {}
    return @{ Installed = $false; Version = $null; Major = 0 }
}

function Test-NpmInstalled {
    try {
        $v = & npm --version 2>$null
        if ($v) { return $true }
    } catch {}
    return $false
}

function Get-VendooInstallState {
    $nodeModules = Test-Path (Join-Path $VendooDir 'node_modules')
    $envFile = Test-Path (Join-Path $VendooDir '.env')
    $dbFile = Test-Path (Join-Path $VendooDir 'db\vendoo.db')
    $state = 'not-installed'
    if ($nodeModules -and $envFile) { $state = 'installed' }
    elseif ($nodeModules -or $envFile -or $dbFile) { $state = 'partial' }
    return @{ State = $state; NodeModules = $nodeModules; EnvFile = $envFile; DbFile = $dbFile }
}

function Get-LocalFluxScriptPath {
    return Join-Path $VendooDir 'scripts\install-local-flux.ps1'
}


function Stop-VendooNodeProcesses {
    $stopped = 0
    try {
        $escapedDir = [regex]::Escape($VendooDir)
        $processes = Get-CimInstance Win32_Process -Filter "Name='node.exe'" -ErrorAction SilentlyContinue |
            Where-Object { $_.CommandLine -and $_.CommandLine -match $escapedDir }
        foreach ($process in $processes) {
            try {
                Stop-Process -Id $process.ProcessId -Force -ErrorAction Stop
                $stopped++
            } catch {}
        }
    } catch {}
    if ($stopped -gt 0) {
        Write-Warn "$stopped laufende Vendoo-Node-Prozess(e) beendet"
        Start-Sleep -Milliseconds 750
    }
}

function Remove-NodeModulesSafe {
    $nm = Join-Path $VendooDir 'node_modules'
    if (-not (Test-Path $nm)) { return $true }

    Stop-VendooNodeProcesses
    Write-Step '...' 'Unvollstaendige node_modules werden bereinigt...'

    try {
        Remove-Item $nm -Recurse -Force -Confirm:$false -ErrorAction Stop
    } catch {
        try {
            & cmd.exe /d /c "rmdir /s /q `"$nm`"" | Out-Null
        } catch {}
    }

    if (Test-Path $nm) {
        Write-Err 'node_modules konnte nicht vollstaendig entfernt werden.'
        Write-Host '  Ursache ist meist ein noch laufender Node-Prozess, Virenscanner oder Explorer-Zugriff.' -ForegroundColor Yellow
        Write-Host '  Bitte alle Vendoo-/Node-Fenster schliessen, notfalls Windows neu starten und Reparieren erneut ausfuehren.' -ForegroundColor Yellow
        return $false
    }
    return $true
}

function Repair-VendooNpmRegistryConfiguration {
    $lockFile = Join-Path $VendooDir 'package-lock.json'
    $npmrcFile = Join-Path $VendooDir '.npmrc'
    $publicRegistry = 'https://registry.npmjs.org/'

    $npmrcContent = @(
        'registry=https://registry.npmjs.org/',
        'audit=false',
        'fund=false',
        'strict-ssl=true',
        'prefer-offline=true',
        'fetch-retries=5',
        'fetch-retry-factor=2',
        'fetch-retry-mintimeout=10000',
        'fetch-retry-maxtimeout=120000'
    ) -join [Environment]::NewLine
    Write-Utf8NoBomFile -Path $npmrcFile -Content ($npmrcContent + [Environment]::NewLine)

    if (-not (Test-Path -LiteralPath $lockFile)) { return $true }
    try {
        $raw = [System.IO.File]::ReadAllText($lockFile)
        $original = $raw
        $raw = [regex]::Replace(
            $raw,
            'https://packages\.applied-caas-gateway\d+\.internal\.api\.openai\.org/artifactory/api/npm/npm-public/',
            $publicRegistry,
            [System.Text.RegularExpressions.RegexOptions]::IgnoreCase
        )
        if ($raw -match '(?i)internal\.api\.openai\.org|applied-caas-gateway|/artifactory/api/npm/') {
            Write-Err 'package-lock.json enthält weiterhin eine nicht öffentliche Registry-URL.'
            Write-Host '  Das Paket wurde aus einer Build-Umgebung verunreinigt. npm ci wird aus Sicherheitsgründen nicht gestartet.' -ForegroundColor Yellow
            return $false
        }
        if ($raw -ne $original) {
            Write-Warn 'Interne Build-Registry im package-lock.json wurde automatisch auf registry.npmjs.org korrigiert.'
            Write-Utf8NoBomFile -Path $lockFile -Content $raw
        }
        return $true
    } catch {
        Write-Err ("package-lock.json konnte nicht geprüft werden: {0}" -f $_.Exception.Message)
        return $false
    }
}

function Get-VendooNodeModulesBackupPath {
    return (Join-Path $VendooDir 'node_modules.vendoo-backup')
}

function Restore-VendooNodeModulesBackup {
    $nodeModules = Join-Path $VendooDir 'node_modules'
    $backup = Get-VendooNodeModulesBackupPath
    if (-not (Test-Path -LiteralPath $backup)) { return }
    try {
        if (Test-Path -LiteralPath $nodeModules) {
            Remove-Item -LiteralPath $nodeModules -Recurse -Force -ErrorAction SilentlyContinue
        }
        Move-Item -LiteralPath $backup -Destination $nodeModules -Force -ErrorAction Stop
        Write-Warn 'Vorherige node_modules wurden nach dem fehlgeschlagenen npm-Lauf wiederhergestellt.'
    } catch {
        Write-Warn ("node_modules-Sicherung konnte nicht automatisch wiederhergestellt werden: {0}" -f $_.Exception.Message)
    }
}

function Prepare-VendooNodeModulesBackup {
    $nodeModules = Join-Path $VendooDir 'node_modules'
    $backup = Get-VendooNodeModulesBackupPath
    Stop-VendooNodeProcesses

    if ((Test-Path -LiteralPath $backup) -and -not (Test-Path -LiteralPath $nodeModules)) {
        try { Move-Item -LiteralPath $backup -Destination $nodeModules -Force -ErrorAction Stop } catch {}
    }
    if (Test-Path -LiteralPath $backup) {
        try { Remove-Item -LiteralPath $backup -Recurse -Force -ErrorAction Stop } catch {
            Write-Err 'Alte node_modules-Sicherung konnte nicht entfernt werden.'
            return $false
        }
    }
    if (Test-Path -LiteralPath $nodeModules) {
        try {
            Move-Item -LiteralPath $nodeModules -Destination $backup -Force -ErrorAction Stop
            Write-Step '...' 'Bestehende node_modules wurden vorübergehend gesichert.'
        } catch {
            Write-Warn 'node_modules konnten nicht atomar gesichert werden. Vendoo versucht die robuste Bereinigung.'
            if (-not (Remove-NodeModulesSafe)) { return $false }
        }
    }
    return $true
}

function Remove-VendooNodeModulesBackup {
    $backup = Get-VendooNodeModulesBackupPath
    if (Test-Path -LiteralPath $backup) {
        try { Remove-Item -LiteralPath $backup -Recurse -Force -ErrorAction Stop } catch {
            Write-Warn 'Die alte node_modules-Sicherung konnte nicht gelöscht werden und kann später manuell entfernt werden.'
        }
    }
}

function Invoke-VendooNpmInstall([switch]$ForceClean) {
    $logDir = Join-Path $VendooDir 'logs'
    if (-not (Test-Path $logDir)) { New-Item -ItemType Directory -Path $logDir -Force | Out-Null }
    $logFile = Join-Path $logDir 'last-npm-install.log'
    $lockFile = Join-Path $VendooDir 'package-lock.json'
    $command = if (Test-Path $lockFile) { 'ci' } else { 'install' }

    if (-not (Repair-VendooNpmRegistryConfiguration)) { return $false }
    if (-not (Prepare-VendooNodeModulesBackup)) { return $false }

    $npmCommand = $null
    try { $npmCommand = (Get-Command 'npm.cmd' -ErrorAction Stop).Source } catch {}
    if ([string]::IsNullOrWhiteSpace([string]$npmCommand)) {
        Restore-VendooNodeModulesBackup
        Write-Err 'npm.cmd wurde nicht gefunden.'
        return $false
    }

    $attempt = 1
    $maxAttempts = 3
    while ($attempt -le $maxAttempts) {
        $stdoutFile = Join-Path $logDir ('npm-install-{0}.stdout.log' -f $attempt)
        $stderrFile = Join-Path $logDir ('npm-install-{0}.stderr.log' -f $attempt)
        $runnerFile = Join-Path $logDir ('npm-install-{0}.cmd' -f $attempt)
        Remove-Item -LiteralPath $stdoutFile,$stderrFile,$runnerFile -Force -ErrorAction SilentlyContinue

        $runnerContent = @(
            '@echo off',
            ('cd /d "{0}"' -f $VendooDir),
            ('call "{0}" {1} --registry=https://registry.npmjs.org/ --no-audit --no-fund --loglevel=warn' -f $npmCommand, $command),
            'set "VENDOO_NPM_EXIT=%ERRORLEVEL%"',
            'exit /b %VENDOO_NPM_EXIT%'
        ) -join "`r`n"
        [System.IO.File]::WriteAllText($runnerFile, $runnerContent + "`r`n", [System.Text.Encoding]::ASCII)

        $process = $null
        $output = @()
        $exitCode = 1
        $npmTimedOut = $false
        try {
            $cmdArguments = ('/d /s /c ""{0}""' -f $runnerFile)
            $process = Start-Process -FilePath $env:ComSpec -ArgumentList $cmdArguments -WorkingDirectory $VendooDir -PassThru -WindowStyle Hidden -RedirectStandardOutput $stdoutFile -RedirectStandardError $stderrFile
            $started = Get-Date
            $lastShown = -1
            $npmTimeoutSeconds = 1800
            while (-not $process.HasExited) {
                Start-Sleep -Seconds 1
                $process.Refresh()
                $elapsed = [int]((Get-Date) - $started).TotalSeconds
                if ($elapsed -ge $npmTimeoutSeconds) {
                    $npmTimedOut = $true
                    try { $process.Kill() } catch {}
                    break
                }
                if ($elapsed -ge 2 -and [Math]::Floor($elapsed / 2) -gt $lastShown) {
                    $lastShown = [Math]::Floor($elapsed / 2)
                    $consoleWidth = 118
                    try { if ($Host.UI.RawUI.WindowSize.Width -gt 20) { $consoleWidth = [Math]::Max(40, $Host.UI.RawUI.WindowSize.Width - 1) } } catch {}
                    $statusText = ("  npm $command läuft seit ${elapsed}s (Versuch $attempt/$maxAttempts)")
                    if ($statusText.Length -gt $consoleWidth) { $statusText = $statusText.Substring(0, $consoleWidth) }
                    Write-Host ("`r" + $statusText.PadRight($consoleWidth)) -NoNewline -ForegroundColor DarkGray
                }
            }
            $process.WaitForExit()
            $process.Refresh()
            $consoleWidth = 118
            try { if ($Host.UI.RawUI.WindowSize.Width -gt 20) { $consoleWidth = [Math]::Max(40, $Host.UI.RawUI.WindowSize.Width - 1) } } catch {}
            Write-Host ("`r" + (' ' * $consoleWidth) + "`r") -NoNewline
            $exitCode = if ($npmTimedOut) { -2 } else { [int]$process.ExitCode }

            $stdoutLines = if (Test-Path -LiteralPath $stdoutFile) { @(Get-Content -LiteralPath $stdoutFile -ErrorAction SilentlyContinue) } else { @() }
            $stderrLines = if (Test-Path -LiteralPath $stderrFile) { @(Get-Content -LiteralPath $stderrFile -ErrorAction SilentlyContinue) } else { @() }
            $output = @($stdoutLines + $stderrLines)
            if ($npmTimedOut) { $output += 'Vendoo hat npm nach 30 Minuten ohne Abschluss beendet.' }

            # Zweite Sicherheitsstufe: Ein echter npm-Fehler darf niemals als Exit-Code 0 durchrutschen.
            $fatalOutput = @($output | Where-Object { ([string]$_) -match '(?i)^\s*npm\s+(error|ERR!)\b' })
            if ($exitCode -eq 0 -and $fatalOutput.Count -gt 0) {
                $exitCode = 1
                $output += 'Vendoo-Sicherheitsprüfung: npm meldete Fehlertext trotz Exit-Code 0. Lauf wird als fehlgeschlagen gewertet.'
            }
        } catch {
            $output = @($_.Exception.Message)
            $exitCode = 1
        }

        $header = @(
            ('Zeit: {0}' -f (Get-Date -Format 'yyyy-MM-dd HH:mm:ss')),
            ('Befehl: npm {0} --registry=https://registry.npmjs.org/ --no-audit --no-fund --loglevel=warn' -f $command),
            ('Arbeitsordner: {0}' -f $VendooDir),
            ('Versuch: {0}/{1}' -f $attempt, $maxAttempts),
            ('Exit-Code: {0}' -f $exitCode),
            ''
        )
        Write-Utf8NoBomFile -Path $logFile -Content ((@($header + $output) -join [Environment]::NewLine) + [Environment]::NewLine)

        Remove-Item -LiteralPath $stdoutFile,$stderrFile,$runnerFile -Force -ErrorAction SilentlyContinue

        if ($exitCode -eq 0) {
            $warnings = @($output | Where-Object { ([string]$_) -match '(?i)^npm\s+warn|deprecated' })
            if ($warnings.Count -gt 0) {
                Write-Warn ("npm $command war erfolgreich, meldete aber $($warnings.Count) Warnung(en). Details: $logFile")
            }
            Remove-VendooNodeModulesBackup
            Write-OK "Dependencies mit npm $command installiert"
            return $true
        }

        $text = ($output | Out-String)
        $isNetworkError = $text -match '(?i)ETIMEDOUT|ECONNRESET|ENOTFOUND|EAI_AGAIN|ECONNREFUSED|network request|502 Bad Gateway|503 Service Unavailable'
        if ($attempt -lt $maxAttempts -and $isNetworkError) {
            $waitSeconds = if ($attempt -eq 1) { 5 } else { 15 }
            Write-Warn ("npm-Netzwerkfehler. Neuer Versuch in $waitSeconds Sekunden über registry.npmjs.org.")
            if (Test-Path -LiteralPath (Join-Path $VendooDir 'node_modules')) {
                Remove-Item -LiteralPath (Join-Path $VendooDir 'node_modules') -Recurse -Force -ErrorAction SilentlyContinue
            }
            Start-Sleep -Seconds $waitSeconds
            $attempt++
            continue
        }

        Write-Err "npm $command fehlgeschlagen (Exit-Code $exitCode)"
        Write-Host "  Vollständiges Protokoll: $logFile" -ForegroundColor Yellow
        $lastLines = @($output | Where-Object { -not [string]::IsNullOrWhiteSpace([string]$_) } | Select-Object -Last 20)
        foreach ($line in $lastLines) { Write-Host "  $line" -ForegroundColor DarkYellow }
        Restore-VendooNodeModulesBackup
        return $false
    }

    Restore-VendooNodeModulesBackup
    return $false
}


function Get-VendooInstallMode {
    if (Test-Path -LiteralPath $InstallModeFile) {
        try {
            $mode = (Get-Content -LiteralPath $InstallModeFile -Raw).Trim().ToLowerInvariant()
            if (@('windows-local', 'docker') -contains $mode) { return $mode }
        } catch {}
    }
    if (Test-Path -LiteralPath (Join-Path $VendooDir 'node_modules')) { return 'windows-local' }
    return 'windows-local'
}

function Set-VendooInstallMode([string]$Mode) {
    Write-Utf8NoBomFile -Path $InstallModeFile -Content ($Mode.Trim().ToLowerInvariant() + "`n")
}

function Test-DockerAvailable {
    try {
        $version = & docker version --format '{{.Server.Version}}' 2>$null
        if (-not $version) { return @{ Available = $false; Reason = 'Docker Engine ist nicht erreichbar.' } }
        & docker compose version 1>$null 2>$null
        if ($LASTEXITCODE -ne 0) { return @{ Available = $false; Reason = 'Das Docker-Compose-Plugin fehlt.' } }
        return @{ Available = $true; Version = $version; Reason = '' }
    } catch {
        return @{ Available = $false; Reason = 'Docker Desktop bzw. Docker Engine wurde nicht gefunden.' }
    }
}

function Get-SecureSetupToken {
    $bytes = New-Object byte[] 32
    $rng = [System.Security.Cryptography.RandomNumberGenerator]::Create()
    try { $rng.GetBytes($bytes) } finally { $rng.Dispose() }
    return (($bytes | ForEach-Object { $_.ToString('x2') }) -join '')
}

function Set-VendooEnvValue([string]$Key, [string]$Value) {
    $envFile = Join-Path $VendooDir '.env'
    if (-not (Test-Path -LiteralPath $envFile)) { return }
    $content = Get-Content -LiteralPath $envFile -Raw
    $escaped = [regex]::Escape($Key)
    if ($content -match "(?m)^$escaped=") {
        $content = [regex]::Replace($content, "(?m)^$escaped=.*$", "$Key=$Value")
    } else {
        $content = $content.TrimEnd() + "`r`n$Key=$Value`r`n"
    }
    Write-Utf8NoBomFile -Path $envFile -Content $content
}

function Get-VendooEnvValue([string]$Key) {
    $envFile = Join-Path $VendooDir '.env'
    if (-not (Test-Path -LiteralPath $envFile)) { return '' }
    $line = Get-Content -LiteralPath $envFile | Where-Object { $_ -match ('^' + [regex]::Escape($Key) + '=') } | Select-Object -Last 1
    if (-not $line) { return '' }
    return ($line -replace ('^' + [regex]::Escape($Key) + '='), '').Trim()
}

function Initialize-VendooEnvironment([string]$Mode = 'docker') {
    $envFile = Join-Path $VendooDir '.env'
    $envExample = Join-Path $VendooDir '.env.example'
    if (-not (Test-Path -LiteralPath $envFile)) {
        if (-not (Test-Path -LiteralPath $envExample)) { throw '.env.example fehlt.' }
        Copy-Item -LiteralPath $envExample -Destination $envFile
        Write-OK '.env aus sicherer Vorlage erstellt'
    }
    if ([string]::IsNullOrWhiteSpace((Get-VendooEnvValue 'VENDOO_SETUP_TOKEN'))) {
        $token = Get-SecureSetupToken
        Set-VendooEnvValue 'VENDOO_SETUP_TOKEN' $token
        Write-Host ''
        Write-Host '  ERST-ADMIN-SETUP-CODE:' -ForegroundColor Yellow
        Write-Host "  $token" -ForegroundColor White
        Write-Warn 'Diesen Code jetzt sicher notieren. Er wird bei der ersten Einrichtung benötigt.'
    }
    if ($Mode -eq 'docker') {
        if ([string]::IsNullOrWhiteSpace((Get-VendooEnvValue 'VENDOO_PUBLISH_ADDRESS'))) { Set-VendooEnvValue 'VENDOO_PUBLISH_ADDRESS' '127.0.0.1' }
        Set-VendooEnvValue 'VENDOO_BIND_HOST' '0.0.0.0'
        Set-VendooEnvValue 'LOCAL_IMAGE_URL' 'http://host.docker.internal:8188'
    } else {
        if ([string]::IsNullOrWhiteSpace((Get-VendooEnvValue 'VENDOO_BIND_HOST'))) { Set-VendooEnvValue 'VENDOO_BIND_HOST' '127.0.0.1' }
        Set-VendooEnvValue 'LOCAL_IMAGE_URL' 'http://127.0.0.1:8188'
    }
    Set-VendooEnvValue 'VENDOO_COOKIE_SECURE' 'auto'
    Set-VendooEnvValue 'VENDOO_REQUIRE_SETUP_TOKEN' 'true'
}

function Invoke-VendooDockerCompose([string[]]$Arguments) {
    Push-Location $VendooDir
    try {
        $composeArgs = @('compose', '-f', (Join-Path $VendooDir 'compose.yaml')) + $Arguments
        & docker @composeArgs
        return $LASTEXITCODE
    } finally { Pop-Location }
}

function Install-VendooDocker {
    Write-Header
    Write-Host '  Docker-Installation auf diesem Windows-PC ...' -ForegroundColor White
    Write-Host ''
    $docker = Test-DockerAvailable
    if (-not $docker.Available) {
        Write-Err $docker.Reason
        Write-Host '  Installiere bzw. starte Docker Desktop und führe den Installer erneut aus.' -ForegroundColor Yellow
        Write-Host '  Docker Desktop enthält Docker Engine, CLI und Docker Compose.' -ForegroundColor DarkGray
        return
    }
    Write-OK "Docker Engine $($docker.Version) erreichbar"
    Initialize-VendooEnvironment -Mode 'docker'
    Set-VendooInstallMode 'docker'
    Write-Step '1/3' 'Compose-Konfiguration prüfen ...'
    if ((Invoke-VendooDockerCompose @('config')) -ne 0) { Write-Err 'Compose-Konfiguration ist ungültig.'; return }
    Write-Step '2/3' 'Vendoo-Container bauen ...'
    if ((Invoke-VendooDockerCompose @('build', '--pull')) -ne 0) { Write-Err 'Docker-Build fehlgeschlagen.'; return }
    Write-Step '3/3' 'Vendoo starten ...'
    if ((Invoke-VendooDockerCompose @('up', '-d', '--remove-orphans')) -ne 0) { Write-Err 'Containerstart fehlgeschlagen.'; return }
    Write-OK 'Vendoo läuft im Docker-Modus.'
    Write-Host "  Readiness: http://127.0.0.1:$Port/readyz" -ForegroundColor Cyan
    Start-Process "http://127.0.0.1:$Port/login.html"
}

function Show-VendooRemoteDeploymentGuide([string]$Target) {
    Write-Header
    Write-Host "  $Target-Installation" -ForegroundColor White
    Write-Host ''
    Write-Host '  Ein VPS oder NAS wird nicht unsicher vom Windows-PC ferninstalliert.' -ForegroundColor Yellow
    Write-Host '  Kopiere den Vendoo-Ordner auf das Zielsystem und starte dort:' -ForegroundColor White
    Write-Host ''
    Write-Host '    chmod +x setup.sh' -ForegroundColor Cyan
    Write-Host '    ./setup.sh' -ForegroundColor Cyan
    Write-Host ''
    Write-Host '  Der Linux-Assistent bietet Docker, NAS/Portainer und VPS hinter HTTPS-Reverse-Proxy an.' -ForegroundColor DarkGray
    Write-Host '  Datenbank, Uploads, .env, Backups und Operations bleiben persistent und werden nicht gelöscht.' -ForegroundColor DarkGray
}

function Configure-VendooConsole {
    Write-Header
    Write-Host '  Geführte Konfiguration – keine Datei muss manuell bearbeitet werden.' -ForegroundColor White
    Write-Host ''
    $mode = Get-VendooInstallMode
    $portInput = Read-Host "  Port [$Port]"
    if (-not [string]::IsNullOrWhiteSpace($portInput)) {
        $parsed = 0
        if (-not [int]::TryParse($portInput, [ref]$parsed) -or $parsed -lt 1024 -or $parsed -gt 65535) { Write-Err 'Port muss zwischen 1024 und 65535 liegen.'; return }
        $script:Port = $parsed
    }
    Initialize-VendooEnvironment -Mode ($(if ($mode -eq 'docker') { 'docker' } else { 'windows-local' }))
    Set-VendooEnvValue 'PORT' ([string]$Port)
    Set-VendooEnvValue 'VENDOO_HOST_PORT' ([string]$Port)
    $lan = Read-Host '  Zugriff im privaten LAN erlauben? (ja/nein)'
    if ($mode -eq 'docker') {
        Set-VendooEnvValue 'VENDOO_PUBLISH_ADDRESS' ($(if ($lan -eq 'ja') { '0.0.0.0' } else { '127.0.0.1' }))
    } else {
        Set-VendooEnvValue 'VENDOO_BIND_HOST' ($(if ($lan -eq 'ja') { '0.0.0.0' } else { '127.0.0.1' }))
    }
    if ($lan -eq 'ja') {
        $baseUrl = Read-Host '  LAN-Basisadresse für QR-Uploads (optional, z. B. http://192.168.1.20:8124)'
        if (-not [string]::IsNullOrWhiteSpace($baseUrl)) {
            if ($baseUrl -notmatch '^https?://') { Write-Err 'Adresse muss mit http:// oder https:// beginnen.'; return }
            Set-VendooEnvValue 'PUBLIC_BASE_URL' $baseUrl.Trim().TrimEnd('/')
        }
    }
    $flux = Read-Host '  Lokales FLUX aktivieren? (ja/nein)'
    Set-VendooEnvValue 'LOCAL_IMAGE_ENABLED' ($(if ($flux -eq 'ja') { 'true' } else { 'false' }))
    $token = Get-VendooEnvValue 'VENDOO_SETUP_TOKEN'
    try { Set-Clipboard -Value $token -ErrorAction Stop; Write-OK 'Erst-Admin-Code wurde in die Zwischenablage kopiert.' } catch {}
    Write-OK 'Konfiguration gespeichert.'
    Write-Host '  AI- und Marktplatz-Schlüssel werden später in Vendoo → Einstellungen gepflegt.' -ForegroundColor DarkGray
}

function Install-Vendoo {
    Write-Header
    Write-Host '  Wo soll Vendoo betrieben werden?' -ForegroundColor White
    Write-Host ''
    Write-Host '    1  Lokal auf diesem Windows-PC (Node.js)' -ForegroundColor Cyan
    Write-Host '    2  Docker Desktop auf diesem Windows-PC' -ForegroundColor Cyan
    Write-Host '    3  NAS / Portainer / Docker-Server' -ForegroundColor Cyan
    Write-Host '    4  VPS / öffentlicher Linux-Server' -ForegroundColor Cyan
    Write-Host '    0  Abbrechen' -ForegroundColor DarkGray
    Write-Host ''
    $choice = Read-Host '  Installationsziel'
    switch ($choice) {
        '1' { Set-VendooInstallMode 'windows-local'; Install-VendooLocal }
        '2' { Install-VendooDocker }
        '3' { Show-VendooRemoteDeploymentGuide 'NAS / Portainer' }
        '4' { Show-VendooRemoteDeploymentGuide 'VPS / Linux' }
        '0' { return }
        default { Write-Warn 'Ungültiges Installationsziel.' }
    }
}

function Start-Vendoo {
    if ((Get-VendooInstallMode) -eq 'docker') {
        $docker = Test-DockerAvailable
        if (-not $docker.Available) { Write-Err $docker.Reason; return }
        if ((Invoke-VendooDockerCompose @('up', '-d')) -eq 0) {
            Write-OK 'Vendoo-Container gestartet.'
            Start-Process "http://127.0.0.1:$Port/"
        }
        return
    }
    Start-VendooLocal
}

function Update-Vendoo {
    if ((Get-VendooInstallMode) -eq 'docker') {
        $docker = Test-DockerAvailable
        if (-not $docker.Available) { Write-Err $docker.Reason; return }
        Initialize-VendooEnvironment -Mode 'docker'
        if ((Invoke-VendooDockerCompose @('config')) -ne 0) { Write-Err 'Compose-Konfiguration ist ungültig.'; return }
        if ((Invoke-VendooDockerCompose @('build', '--pull')) -ne 0) { Write-Err 'Docker-Update-Build fehlgeschlagen.'; return }
        if ((Invoke-VendooDockerCompose @('up', '-d', '--remove-orphans')) -ne 0) { Write-Err 'Docker-Update konnte nicht gestartet werden.'; return }
        Write-OK 'Docker-Update abgeschlossen.'
        return
    }
    Update-VendooLocal
}

function Repair-Vendoo {
    if ((Get-VendooInstallMode) -eq 'docker') {
        $docker = Test-DockerAvailable
        if (-not $docker.Available) { Write-Err $docker.Reason; return }
        if ((Invoke-VendooDockerCompose @('config')) -ne 0) { Write-Err 'Compose-Konfiguration ist ungültig.'; return }
        if ((Invoke-VendooDockerCompose @('build', '--no-cache')) -ne 0) { Write-Err 'Docker-Reparatur-Build fehlgeschlagen.'; return }
        if ((Invoke-VendooDockerCompose @('up', '-d', '--force-recreate', '--remove-orphans')) -ne 0) { Write-Err 'Docker-Reparaturstart fehlgeschlagen.'; return }
        Write-OK 'Docker-Container neu gebaut und gestartet.'
        return
    }
    Repair-VendooLocal
}

function Install-VendooLocal {
    Write-Header
    Write-Host '  Installation starten...' -ForegroundColor White
    Write-Host ''

    $installState = Get-VendooInstallState
    if ($installState.State -eq 'installed') {
        Write-Warn 'Vendoo scheint bereits installiert zu sein.'
        Write-Host '  Statt versehentlich neu zu installieren, nutze besser Starten, Update oder Reparieren.' -ForegroundColor Yellow
        $choice = Read-Host '  Aktion: [S]tarten / [U]pdate / [R]eparieren / [N]eu installieren / [A]bbrechen'
        if ([string]::IsNullOrWhiteSpace($choice)) {
            $choice = ''
        }
        $choice = $choice.ToLowerInvariant()
        switch ($choice) {
            's' { Start-VendooLocal; return }
            'u' { Update-VendooLocal; return }
            'r' { Repair-VendooLocal; return }
            'a' { return }
            'n' { Write-Host '  Vollständige Neuinstallation wird fortgesetzt...' -ForegroundColor DarkGray }
            default {
                Write-Warn 'Keine gültige Aktion gewählt. Installation wurde abgebrochen.'
                return
            }
        }
    }

    # 1. Node.js pruefen
    Write-Step '1/5' 'Node.js pruefen...'
    $node = Test-NodeInstalled
    if (-not $node.Installed) {
        Write-Err 'Node.js ist nicht installiert!'
        Write-Host ''
        Write-Host '  Node.js wird benoetigt (mindestens v18).' -ForegroundColor Yellow
        Write-Host '  Download: https://nodejs.org/' -ForegroundColor Cyan
        Write-Host ''
        $dl = Read-Host '  Node.js jetzt automatisch installieren? (j/n)'
        if ($dl -eq 'j') {
            Write-Step '...' 'Lade Node.js Installer herunter...'
            $installerUrl = 'https://nodejs.org/dist/v22.16.0/node-v22.16.0-x64.msi'
            $installerPath = Join-Path $env:TEMP 'node-installer.msi'
            try {
                [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
                Invoke-WebRequest -Uri $installerUrl -OutFile $installerPath -UseBasicParsing
                Write-Step '...' 'Installiere Node.js...'
                Start-Process msiexec.exe -ArgumentList "/i `"$installerPath`" /qn" -Wait -NoNewWindow
                $env:Path = [System.Environment]::GetEnvironmentVariable('Path', 'Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path', 'User')
                Start-Sleep -Seconds 2
                $node = Test-NodeInstalled
                if ($node.Installed) {
                    Write-OK "Node.js $($node.Version) installiert"
                } else {
                    Write-Err 'Installation fehlgeschlagen. Bitte manuell installieren.'
                    return
                }
            } catch {
                Write-Err "Download fehlgeschlagen: $_"
                Write-Host '  Bitte installiere Node.js manuell: https://nodejs.org/' -ForegroundColor Yellow
                return
            }
        } else {
            Write-Host '  Installation abgebrochen.' -ForegroundColor Yellow
            return
        }
    } elseif ($node.Major -lt 18) {
        Write-Warn "Node.js $($node.Version) ist zu alt. Mindestens v18 erforderlich."
        Write-Host '  Update: https://nodejs.org/' -ForegroundColor Cyan
        return
    } else {
        Write-OK "Node.js $($node.Version) gefunden"
    }

    # 2. npm pruefen
    Write-Step '2/5' 'npm pruefen...'
    if (Test-NpmInstalled) {
        $npmV = & npm --version 2>$null
        Write-OK "npm v$npmV gefunden"
    } else {
        Write-Err 'npm nicht gefunden. Wird mit Node.js mitgeliefert.'
        return
    }

    # 3. Dependencies reproduzierbar installieren
    Write-Step '3/5' 'Dependencies installieren (npm ci)...'
    if (-not (Invoke-VendooNpmInstall)) { return }

    # 4. Sichere Konfiguration erzeugen bzw. übernehmen
    Write-Step '4/5' 'Sichere Konfiguration prüfen...'
    Initialize-VendooEnvironment -Mode 'windows-local'
    Write-OK 'Konfiguration ist vollständig; keine manuelle Dateibearbeitung erforderlich'

    # 5. Ordner pruefen
    Write-Step '5/5' 'Verzeichnisse pruefen...'
    $dirs = @('uploads', 'db')
    foreach ($d in $dirs) {
        $p = Join-Path $VendooDir $d
        if (-not (Test-Path $p)) {
            New-Item -ItemType Directory -Path $p -Force | Out-Null
        }
    }
    Write-OK 'Verzeichnisse OK'

    Write-Host ''
    Write-Host '  ========================================' -ForegroundColor Green
    Write-Host '  Installation abgeschlossen!' -ForegroundColor Green
    Write-Host '  ========================================' -ForegroundColor Green
    Write-Host ''
    Write-Host "  Starte Vendoo mit:  " -NoNewline
    Write-Host 'npm start' -ForegroundColor Cyan
    Write-Host "  Oder im Dev-Modus:  " -NoNewline
    Write-Host 'npm run dev' -ForegroundColor Cyan
    Write-Host "  Dann oeffne:        " -NoNewline
    Write-Host "http://localhost:$Port" -ForegroundColor Cyan
    Write-Host ''

    if ($script:AutoStartAfterInstall) {
        Start-VendooLocalDetached
        return
    }
    $start = Read-Host '  Vendoo jetzt starten? (j/n)'
    if ($start -eq 'j') {
        Start-VendooLocal
    }
}

function Start-VendooLocalDetached {
    Write-Step '...' 'Starte Vendoo im eigenen Prozess ...'
    Start-Process -FilePath 'node.exe' -ArgumentList @('bootstrap.mjs') -WorkingDirectory $VendooDir -WindowStyle Minimized
    Start-Sleep -Seconds 2
    Write-OK 'Vendoo wurde gestartet.'
}

function Start-VendooLocal {
    Write-Host ''
    Write-Step '...' 'Starte Vendoo-Server...'
    Push-Location $VendooDir
    Start-Process "http://localhost:$Port/?build=1.41.2"
    & node bootstrap.mjs
    Pop-Location
}

function Update-VendooLocal {
    Write-Header
    Write-Host '  Update durchfuehren...' -ForegroundColor White
    Write-Host ''

    # Dependencies reproduzierbar aktualisieren
    Write-Step '1/2' 'Dependencies aktualisieren...'
    if (-not (Invoke-VendooNpmInstall)) { return }

    # Neue .env Eintraege pruefen
    Write-Step '2/2' '.env pruefen...'
    $envFile = Join-Path $VendooDir '.env'
    $envExample = Join-Path $VendooDir '.env.example'
    if ((Test-Path $envFile) -and (Test-Path $envExample)) {
        $current = Get-Content $envFile -Raw
        $example = Get-Content $envExample
        $added = 0
        foreach ($line in $example) {
            if ($line -match '^([A-Z_]+)=' -and $current -notmatch "(?m)^$($Matches[1])=") {
                Add-Content $envFile "`n$line"
                $added++
            }
        }
        if ($added -gt 0) {
            Write-OK "$added neue Konfigurationseintraege hinzugefuegt"
        } else {
            Write-OK '.env ist aktuell'
        }
    }

    Write-Host ''
    Write-Host '  Update abgeschlossen!' -ForegroundColor Green
    Write-Host ''
}

function Repair-VendooLocal {
    Write-Header
    Write-Host '  Reparatur durchfuehren...' -ForegroundColor White
    Write-Host ''

    # 1. node_modules robust loeschen und reproduzierbar neu installieren
    Write-Step '1/3' 'node_modules neu installieren...'
    if (-not (Invoke-VendooNpmInstall -ForceClean)) { return }

    # 2. .env pruefen
    Write-Step '2/3' '.env pruefen...'
    $envFile = Join-Path $VendooDir '.env'
    if (-not (Test-Path $envFile)) {
        $envExample = Join-Path $VendooDir '.env.example'
        if (Test-Path $envExample) { Copy-Item $envExample $envFile }
        Write-Warn '.env fehlte und wurde neu erstellt'
    } else {
        Write-OK '.env vorhanden'
    }

    # 3. Ordner pruefen
    Write-Step '3/3' 'Verzeichnisse pruefen...'
    foreach ($d in @('uploads', 'db')) {
        $p = Join-Path $VendooDir $d
        if (-not (Test-Path $p)) { New-Item -ItemType Directory -Path $p -Force | Out-Null }
    }
    Write-OK 'Verzeichnisse OK'

    Write-Host ''
    Write-Host '  Reparatur abgeschlossen!' -ForegroundColor Green
    Write-Host ''
}

function Uninstall-VendooLocal {
    Write-Header
    Write-Host '  Vendoo deinstallieren' -ForegroundColor Red
    Write-Host ''
    Write-Warn 'Dies entfernt node_modules und optionale Daten.'
    Write-Host ''

    $confirm = Read-Host '  Wirklich deinstallieren? (ja/nein)'
    if ($confirm -ne 'ja') {
        Write-Host '  Abgebrochen.' -ForegroundColor Yellow
        return
    }

    $keepData = Read-Host '  Datenbank und Uploads behalten? (j/n)'

    Write-Step '1/2' 'node_modules entfernen...'
    $nm = Join-Path $VendooDir 'node_modules'
    if (Test-Path $nm) {
        Remove-Item $nm -Recurse -Force -Confirm:$false
        Write-OK 'node_modules entfernt'
    } else {
        Write-OK 'node_modules nicht vorhanden'
    }

    if ($keepData -ne 'j') {
        Write-Step '2/2' 'Daten entfernen...'
        $dbDir = Join-Path $VendooDir 'db'
        $uploadsDir = Join-Path $VendooDir 'uploads'
        if (Test-Path $dbDir) {
            Remove-Item (Join-Path $dbDir '*.db'), (Join-Path $dbDir '*.db-shm'), (Join-Path $dbDir '*.db-wal') -Force -ErrorAction SilentlyContinue
            Write-OK 'Datenbank entfernt'
        }
        if (Test-Path $uploadsDir) {
            Get-ChildItem $uploadsDir -File | Remove-Item -Force -Confirm:$false
            Write-OK 'Uploads entfernt'
        }
        $envFile = Join-Path $VendooDir '.env'
        if (Test-Path $envFile) {
            Remove-Item $envFile -Force -Confirm:$false
            Write-OK '.env entfernt'
        }
    } else {
        Write-OK 'Datenbank und Uploads beibehalten'
    }

    Write-Host ''
    Write-Host '  Vendoo wurde deinstalliert.' -ForegroundColor Green
    Write-Host '  Die Projektdateien bleiben erhalten.' -ForegroundColor DarkGray
    Write-Host '  Zum erneuten Installieren: setup.bat ausfuehren.' -ForegroundColor DarkGray
    Write-Host ''
}

function Install-LocalFlux {
    Write-Header
    Write-Host '  Lokales FLUX / ComfyUI installieren' -ForegroundColor White
    Write-Host ''
    $script = Get-LocalFluxScriptPath
    if (-not (Test-Path $script)) {
        Write-Err 'Installationsskript fuer lokales FLUX wurde nicht gefunden.'
        return
    }

    $stateFile = Join-Path $VendooDir 'local-ai\install-state.json'
    $existingInstall = Test-Path (Join-Path $VendooDir 'local-ai\comfyui\ComfyUI_windows_portable\ComfyUI\main.py')
    if ($existingInstall) {
        Write-OK 'ComfyUI ist bereits installiert.'
        $existingChoice = Read-Host '  [S]tatus / [U]pdate / [M]odell nachinstallieren / [N]eu installieren / [A]bbrechen'
        if ([string]::IsNullOrWhiteSpace($existingChoice)) { return }
        $existingChoice = $existingChoice.ToLowerInvariant()
        switch ($existingChoice) {
            's' { Show-LocalFluxStatus; return }
            'u' {
                & powershell.exe -NoProfile -ExecutionPolicy Bypass -File $script -UpdateOnly -StartNow
                return
            }
            'm' {
                & powershell.exe -NoProfile -ExecutionPolicy Bypass -File $script -InstallModel -StartNow
                return
            }
            'n' { }
            default { return }
        }
    }

    Write-Host '  Hinweis: Das FLUX-Modell ist sehr gross und kann lange herunterladen.' -ForegroundColor Yellow
    $modelChoice = Read-Host '  FLUX.1-schnell FP8 direkt mitinstallieren? (j/n)'
    $autoChoice = Read-Host '  Lokalen Bildserver bei Windows-Anmeldung automatisch starten? (j/n)'
    $startChoice = Read-Host '  Nach Installation sofort starten? (j/n)'

    $arguments = @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', $script)
    if ($modelChoice -eq 'j') { $arguments += '-InstallModel' }
    if ($autoChoice -eq 'j') { $arguments += '-EnableAutostart' }
    if ($startChoice -eq 'j') { $arguments += '-StartNow' }
    if ($existingInstall) { $arguments += '-Force' }

    Write-Step '1/1' 'Starte automatischen lokalen FLUX-Installer...'
    & powershell.exe @arguments
    if ($LASTEXITCODE -eq 0) {
        Write-OK 'Lokales FLUX / ComfyUI wurde eingerichtet.'
    } else {
        Write-Err 'Lokale FLUX-Installation ist fehlgeschlagen.'
        if (Test-Path -LiteralPath $stateFile) {
            try {
                $failedState = Get-Content -LiteralPath $stateFile -Raw | ConvertFrom-Json
                Write-Host "  Phase: $($failedState.phase)" -ForegroundColor Yellow
                Write-Host "  Fortschritt: $($failedState.progress)%" -ForegroundColor Yellow
                Write-Host "  Fehler: $($failedState.message)" -ForegroundColor Red
            } catch {}
            Write-Host "  Statusdatei: $stateFile" -ForegroundColor Yellow
        }
        Write-Host "  Log: $(Join-Path $VendooDir 'logs\local-flux-install.log')" -ForegroundColor Yellow
        Write-Host '  Option 7 kann nach dem Fix erneut ausgeführt werden; vorhandene vollständige Downloads werden weiterverwendet.' -ForegroundColor DarkGray
    }
    Write-Host ''
}


function Get-LocalFluxStartupRecovery {
    $stateFile = Join-Path $VendooDir 'local-ai\install-state.json'
    $extractRoot = Join-Path $VendooDir 'local-ai\extract-temp'
    $stdoutFile = Join-Path $VendooDir 'logs\local-flux-7zip-output.log'
    $stderrFile = Join-Path $VendooDir 'logs\local-flux-7zip-error.log'
    $portableRoot = Join-Path $VendooDir 'local-ai\comfyui\ComfyUI_windows_portable'
    $finalMain = Join-Path $portableRoot 'ComfyUI\main.py'
    $embeddedPython = Join-Path $portableRoot 'python_embeded\python.exe'
    $modelPath = Join-Path $portableRoot 'ComfyUI\models\checkpoints\flux1-schnell-fp8.safetensors'
    $partialModel = "$modelPath.part"

    if (-not (Test-Path -LiteralPath $stateFile)) { return $null }

    try {
        $state = Get-Content -LiteralPath $stateFile -Raw | ConvertFrom-Json
    } catch {
        return $null
    }

    try {
        $active = @(Get-CimInstance Win32_Process -ErrorAction SilentlyContinue |
            Where-Object {
                $_.CommandLine -and
                $_.CommandLine -match [regex]::Escape($VendooDir) -and
                ($_.Name -match '^(7z|7zG|powershell)\.exe$') -and
                $_.CommandLine -match 'install-local-flux|extract-temp|ComfyUI_windows_portable|flux1-schnell'
            })
        if ($active.Count -gt 0) { return $null }
    } catch {}

    # Bekannter Slice-22-Fehlalarm nach erfolgreicher 7-Zip-Entpackung.
    if ((Test-Path -LiteralPath $extractRoot) -and -not (Test-Path -LiteralPath $finalMain)) {
        $knownFalseFailure = (
            $state.status -eq 'failed' -and
            [bool]$state.can_resume -and
            [string]$state.message -match '7-Zip Exit-Code\s*\)' -and
            [string]$state.message -match 'Everything is Ok'
        )

        if ($knownFalseFailure) {
            $stderrText = ''
            if (Test-Path -LiteralPath $stderrFile) {
                try { $stderrText = (Get-Content -LiteralPath $stderrFile -Raw -ErrorAction Stop).Trim() } catch {}
            }

            $stdoutText = ''
            if (Test-Path -LiteralPath $stdoutFile) {
                try { $stdoutText = Get-Content -LiteralPath $stdoutFile -Raw -ErrorAction Stop } catch {}
            }

            if ([string]::IsNullOrWhiteSpace($stderrText) -and $stdoutText -match '(?im)^Everything is Ok\s*$') {
                $portable = Get-ChildItem -LiteralPath $extractRoot -Directory -Recurse -ErrorAction SilentlyContinue |
                    Where-Object {
                        $_.Name -match '^ComfyUI_windows_portable' -and
                        (Test-Path -LiteralPath (Join-Path $_.FullName 'ComfyUI\main.py')) -and
                        (Test-Path -LiteralPath (Join-Path $_.FullName 'python_embeded\python.exe'))
                    } |
                    Select-Object -First 1

                if ($portable) {
                    return @{
                        Mode = 'extract'
                        State = $state
                        PortablePath = $portable.FullName
                        ExtractRoot = $extractRoot
                    }
                }
            }
        }
    }

    # Unterbrochener oder scheinbar hängender Modell-Download.
    $comfyReady = (Test-Path -LiteralPath $finalMain) -and (Test-Path -LiteralPath $embeddedPython)
    $modelReady = $false
    if (Test-Path -LiteralPath $modelPath) {
        try { $modelReady = (Get-Item -LiteralPath $modelPath).Length -ge 1GB } catch {}
    }

    $partialBytes = 0L
    if (Test-Path -LiteralPath $partialModel) {
        try { $partialBytes = [long](Get-Item -LiteralPath $partialModel).Length } catch {}
    }

    $downloadState = ([string]$state.phase -eq 'download-model') -and ([string]$state.status -in @('running','failed'))
    if ($comfyReady -and -not $modelReady -and ($downloadState -or $partialBytes -gt 0)) {
        return @{
            Mode = 'model-download'
            State = $state
            PartialPath = $partialModel
            PartialBytes = $partialBytes
        }
    }

    return $null
}

function Invoke-LocalFluxStartupRecovery {
    $recovery = Get-LocalFluxStartupRecovery
    if (-not $recovery) { return }

    Write-Header
    Write-Host '  Automatische FLUX-Wiederaufnahme' -ForegroundColor White
    Write-Host '  ────────────────────────────────────' -ForegroundColor DarkGray
    Write-Host ''

    if ($recovery.Mode -eq 'extract') {
        Write-OK 'Das ComfyUI-Archiv wurde bereits vollständig und fehlerfrei entpackt.'
        Write-Warn 'Der frühere Installer hat den erfolgreichen 7-Zip-Lauf falsch bewertet.'
        Write-Host '  Der vorhandene Entpackstand wird übernommen; nichts wird neu entpackt.' -ForegroundColor Green
    } elseif ($recovery.Mode -eq 'model-download') {
        $partialMb = [math]::Round(([long]$recovery.PartialBytes) / 1MB, 1)
        Write-Warn 'Ein unterbrochener oder nicht sichtbar fortschreitender FLUX-Download wurde erkannt.'
        if ($partialMb -gt 0) {
            Write-OK "Bereits geladene Daten bleiben erhalten: $partialMb MB."
        }
        Write-Host '  Der Download wird mit sichtbarem Fortschritt automatisch fortgesetzt.' -ForegroundColor Green
        Write-Host '  Anzeige: Prozent · geladene MB · Gesamtgröße · Geschwindigkeit · Restzeit' -ForegroundColor DarkGray
    }

    Write-Host ''
    Write-Step 'AUTO' 'Fortsetzung startet automatisch...'
    Start-Sleep -Seconds 2

    $script = Get-LocalFluxScriptPath
    if (-not (Test-Path -LiteralPath $script)) {
        Write-Err 'FLUX-Installationsskript fehlt. Automatische Fortsetzung ist nicht möglich.'
        return
    }

    $logDir = Join-Path $VendooDir 'logs'
    if (-not (Test-Path -LiteralPath $logDir)) {
        New-Item -ItemType Directory -Path $logDir -Force | Out-Null
    }
    $selfHealLog = Join-Path $logDir 'setup-self-heal.log'
    "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') [INFO] Automatische FLUX-Wiederaufnahme gestartet. Modus: $($recovery.Mode)." |
        Add-Content -LiteralPath $selfHealLog -Encoding utf8

    & powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File $script -InstallModel -StartNow
    $exitCode = $LASTEXITCODE

    if ($exitCode -eq 0) {
        "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') [OK] Automatische FLUX-Wiederaufnahme erfolgreich abgeschlossen." |
            Add-Content -LiteralPath $selfHealLog -Encoding utf8
        Write-OK 'ComfyUI und FLUX wurden automatisch fertig eingerichtet.'
        Write-Host ''
        Show-LocalFluxStatus
    } else {
        "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') [ERROR] Automatische FLUX-Wiederaufnahme fehlgeschlagen. Exit-Code $exitCode." |
            Add-Content -LiteralPath $selfHealLog -Encoding utf8
        Write-Err "Automatische Fortsetzung ist fehlgeschlagen (Exit-Code $exitCode)."
        Write-Host "  Diagnose: $selfHealLog" -ForegroundColor Yellow
        Write-Host "  Installer-Log: $(Join-Path $VendooDir 'logs\local-flux-install.log')" -ForegroundColor Yellow
    }

    Write-Host ''
}

function Start-LocalFlux {
    $script = Join-Path $VendooDir 'local-ai\start-local-flux.ps1'
    if (-not (Test-Path $script)) {
        Write-Warn 'Startskript fehlt. Bitte lokales FLUX zuerst installieren.'
        return
    }
    & powershell.exe -NoProfile -ExecutionPolicy Bypass -File $script
    Start-Sleep -Seconds 3
    Show-LocalFluxStatus
}

function Stop-LocalFlux {
    $script = Join-Path $VendooDir 'local-ai\stop-local-flux.ps1'
    if (-not (Test-Path $script)) {
        Write-Warn 'Stoppskript fehlt.'
        return
    }
    & powershell.exe -NoProfile -ExecutionPolicy Bypass -File $script
    Write-OK 'Lokaler FLUX / ComfyUI-Prozess wurde beendet.'
}

function Show-LocalFluxStatus {
    Write-Header
    Write-Host '  Lokales FLUX / ComfyUI Status' -ForegroundColor White
    Write-Host '  ────────────────────────────────────' -ForegroundColor DarkGray

    $localRoot = Join-Path $VendooDir 'local-ai'
    $stateFile = Join-Path $localRoot 'install-state.json'
    $logFile = Join-Path $VendooDir 'logs\local-flux-install.log'
    $portableRoot = Join-Path $localRoot 'comfyui\ComfyUI_windows_portable'
    $pythonPath = Join-Path $portableRoot 'python_embeded\python.exe'
    $comfyMain = Join-Path $portableRoot 'ComfyUI\main.py'
    $modelPath = Join-Path $portableRoot 'ComfyUI\models\checkpoints\flux1-schnell-fp8.safetensors'
    $workflowPath = Join-Path $localRoot 'workflows\vendoo_flux_schnell_api.json'
    $startScript = Join-Path $localRoot 'start-local-flux.ps1'
    $stopScript = Join-Path $localRoot 'stop-local-flux.ps1'

    $state = $null
    if (Test-Path -LiteralPath $stateFile) {
        try { $state = Get-Content -LiteralPath $stateFile -Raw | ConvertFrom-Json } catch {}
    }

    if ($state) {
        $statusColor = 'Yellow'
        if ($state.status -eq 'completed') { $statusColor = 'Green' }
        elseif ($state.status -eq 'failed') { $statusColor = 'Red' }
        $heartbeatAge = $null
        try {
            $heartbeatTime = [DateTime]::Parse([string]$(if ($state.heartbeat_at) { $state.heartbeat_at } else { $state.updated_at }))
            $heartbeatAge = [math]::Round(((Get-Date) - $heartbeatTime).TotalSeconds)
        } catch {}
        $staleThreshold = if ($state.phase -eq 'extract-comfyui') { 20 } else { 120 }
        if ($state.status -eq 'running' -and $heartbeatAge -ne $null -and $heartbeatAge -gt $staleThreshold) {
            $statusColor = 'Red'
            Write-Host '  Status:      HÄNGT / keine Aktualisierung' -ForegroundColor $statusColor
        } else {
            Write-Host "  Status:      $($state.status)" -ForegroundColor $statusColor
        }
        Write-Host "  Phase:       $($state.phase)" -ForegroundColor DarkGray
        Write-Host "  Fortschritt: $($state.progress)%" -ForegroundColor DarkGray
        Write-Host "  Meldung:     $($state.message)" -ForegroundColor DarkGray
        if ($state.elapsed_seconds -ne $null) { Write-Host "  Laufzeit:    $($state.elapsed_seconds) Sekunden" -ForegroundColor DarkGray }
        if ($state.extract_files -ne $null) { Write-Host "  Entpackt:    $($state.extract_files) Dateien / $($state.extract_mb) MB" -ForegroundColor DarkGray }
        if ($heartbeatAge -ne $null) { Write-Host "  Heartbeat:   vor $heartbeatAge Sekunden" -ForegroundColor DarkGray }
        Write-Host "  Aktualisiert:$($state.updated_at)" -ForegroundColor DarkGray
    } else {
        Write-Warn 'Noch keine Installationsstatusdatei vorhanden.'
    }

    Write-Host ''
    if (Test-Path -LiteralPath "$env:ProgramFiles\7-Zip\7z.exe") { Write-OK '7-Zip       Vorhanden' }
    else { Write-Warn '7-Zip       Nicht im Standardpfad gefunden' }
    if (Test-Path -LiteralPath $pythonPath) { Write-OK 'Python       Vorhanden' }
    else { Write-Warn 'Python       Fehlt' }
    if (Test-Path -LiteralPath $comfyMain) { Write-OK 'ComfyUI      Installiert' }
    else { Write-Warn 'ComfyUI      Noch nicht vollständig installiert' }
    if (Test-Path -LiteralPath $workflowPath) { Write-OK 'Workflow     Vorhanden' }
    else { Write-Warn 'Workflow     Fehlt' }
    if (Test-Path -LiteralPath $modelPath) {
        $modelSize = [math]::Round((Get-Item -LiteralPath $modelPath).Length / 1GB, 2)
        Write-OK "FLUX-Modell  Vorhanden ($modelSize GB)"
    } else { Write-Warn 'FLUX-Modell  Fehlt' }
    if (Test-Path -LiteralPath $startScript) { Write-OK 'Startskript  Vorhanden' }
    else { Write-Warn 'Startskript  Fehlt' }
    if (Test-Path -LiteralPath $stopScript) { Write-OK 'Stoppskript  Vorhanden' }
    else { Write-Warn 'Stoppskript  Fehlt' }

    $envFile = Join-Path $VendooDir '.env'
    $url = 'http://127.0.0.1:8188'
    if (Test-Path -LiteralPath $envFile) {
        $envContent = Get-Content -LiteralPath $envFile -Raw
        if ($envContent -match '(?m)^LOCAL_IMAGE_URL=(.+)$') { $url = $Matches[1].Trim() }
    }
    $serverReachable = $false
    try {
        $resp = Invoke-WebRequest -UseBasicParsing -Uri ($url.TrimEnd('/') + '/system_stats') -TimeoutSec 5
        if ($resp.StatusCode -ge 200 -and $resp.StatusCode -lt 300) {
            $serverReachable = $true
            Write-OK 'Server       Erreichbar'
        } else { Write-Warn "Server       HTTP $($resp.StatusCode)" }
    } catch {
        Write-Warn 'Server       Nicht erreichbar'
    }

    if (-not $serverReachable) {
        $runtimeStateFile = Join-Path $VendooDir 'logs\local-flux-runtime-state.json'
        if (Test-Path -LiteralPath $runtimeStateFile) {
            try {
                $runtimeState = Get-Content -LiteralPath $runtimeStateFile -Raw | ConvertFrom-Json
                Write-Host "  Runtime:     $($runtimeState.status)" -ForegroundColor $(if ($runtimeState.status -eq 'failed') { 'Red' } elseif ($runtimeState.status -eq 'starting') { 'Yellow' } else { 'DarkGray' })
                Write-Host "  Startinfo:   $($runtimeState.message)" -ForegroundColor DarkGray
                if ($runtimeState.error) { Write-Host "  Fehler:      $($runtimeState.error)" -ForegroundColor Red }
            } catch {}
        }
        foreach ($runtimeLog in @(
            (Join-Path $VendooDir 'logs\local-flux-runtime-error.log'),
            (Join-Path $VendooDir 'logs\local-flux-runtime.log')
        )) {
            if (Test-Path -LiteralPath $runtimeLog) {
                $runtimeLines = @(Get-Content -LiteralPath $runtimeLog -Tail 8 -ErrorAction SilentlyContinue)
                if ($runtimeLines.Count -gt 0) {
                    Write-Host "  Runtime-Log: $runtimeLog" -ForegroundColor White
                    $runtimeLines | ForEach-Object {
                        $clean = [regex]::Replace([string]$_, ([string][char]27) + '\[[0-?]*[ -/]*[@-~]', '')
                        Write-Host "  $clean" -ForegroundColor DarkGray
                    }
                }
            }
        }
    }

    if (Test-Path -LiteralPath $logFile) {
        Write-Host ''
        Write-Host '  Letzte Installationsmeldungen:' -ForegroundColor White
        Get-Content -LiteralPath $logFile -Tail 12 | ForEach-Object { Write-Host "  $_" -ForegroundColor DarkGray }
    }
    $sevenZipError = Join-Path $VendooDir 'logs\local-flux-7zip-error.log'
    if (Test-Path -LiteralPath $sevenZipError) {
        $sevenZipLines = @(Get-Content -LiteralPath $sevenZipError -Tail 8 -ErrorAction SilentlyContinue)
        if ($sevenZipLines.Count -gt 0) {
            Write-Host ''
            Write-Host '  Letzte 7-Zip-Fehlerausgabe:' -ForegroundColor White
            $sevenZipLines | ForEach-Object { Write-Host "  $_" -ForegroundColor Yellow }
        }
    }
    Write-Host ''
}


function Show-StatusLocal {
    Write-Header
    Write-Host '  Systemstatus' -ForegroundColor White
    Write-Host '  ────────────────────────────────────' -ForegroundColor DarkGray

    $node = Test-NodeInstalled
    if ($node.Installed) { Write-OK "Node.js      $($node.Version)" }
    else { Write-Err 'Node.js      Nicht installiert' }

    if (Test-NpmInstalled) {
        $npmV = & npm --version 2>$null
        Write-OK "npm          v$npmV"
    } else { Write-Err 'npm          Nicht gefunden' }

    $nm = Join-Path $VendooDir 'node_modules'
    if (Test-Path $nm) { Write-OK 'Dependencies Installiert' }
    else { Write-Warn 'Dependencies Nicht installiert' }

    $envFile = Join-Path $VendooDir '.env'
    if (Test-Path $envFile) { Write-OK '.env         Vorhanden' }
    else { Write-Warn '.env         Fehlt' }

    $dbFile = Join-Path $VendooDir 'db' 'vendoo.db'
    if (Test-Path $dbFile) {
        $size = (Get-Item $dbFile).Length
        $sizeStr = if ($size -gt 1MB) { "{0:N1} MB" -f ($size / 1MB) } else { "{0:N0} KB" -f ($size / 1KB) }
        Write-OK "Datenbank    $sizeStr"
    } else { Write-Warn 'Datenbank    Noch nicht erstellt (wird beim ersten Start angelegt)' }

    $uploadsDir = Join-Path $VendooDir 'uploads'
    if (Test-Path $uploadsDir) {
        $fileCount = (Get-ChildItem $uploadsDir -File -ErrorAction SilentlyContinue).Count
        Write-OK "Uploads      $fileCount Dateien"
    }

    Write-Host ''
    Write-Host "  Port:        $Port" -ForegroundColor DarkGray
    Write-Host "  Verzeichnis: $VendooDir" -ForegroundColor DarkGray
    Write-Host ''
}


function Show-Status {
    if ((Get-VendooInstallMode) -eq 'docker') {
        Write-Header
        Write-Host '  Docker-Systemstatus' -ForegroundColor White
        Write-Host ''
        $docker = Test-DockerAvailable
        if (-not $docker.Available) { Write-Err $docker.Reason; return }
        Write-OK "Docker Engine $($docker.Version)"
        Invoke-VendooDockerCompose @('ps') | Out-Null
        try {
            $response = Invoke-WebRequest -Uri "http://127.0.0.1:$Port/readyz" -UseBasicParsing -TimeoutSec 5
            if ($response.StatusCode -eq 200) { Write-OK 'Readiness    Bereit' }
            else { Write-Warn "Readiness    HTTP $($response.StatusCode)" }
        } catch { Write-Warn 'Readiness    Nicht erreichbar' }
        Write-Host ''
        Write-Host "  Installationsmodus: Docker Desktop" -ForegroundColor DarkGray
        return
    }
    Show-StatusLocal
}

function Uninstall-Vendoo {
    if ((Get-VendooInstallMode) -eq 'docker') {
        Write-Header
        Write-Host '  Vendoo-Dockerbereitstellung entfernen' -ForegroundColor Red
        Write-Host ''
        Write-Warn 'Container werden gestoppt. Persistente Volumes bleiben standardmäßig erhalten.'
        $confirm = Read-Host '  Container wirklich entfernen? (ja/nein)'
        if ($confirm -ne 'ja') { Write-Host '  Abgebrochen.' -ForegroundColor Yellow; return }
        $docker = Test-DockerAvailable
        if (-not $docker.Available) { Write-Err $docker.Reason; return }
        Invoke-VendooDockerCompose @('down') | Out-Null
        Write-OK 'Container und Netzwerk entfernt. Datenvolumes wurden beibehalten.'
        $deleteVolumes = Read-Host '  Persistente Docker-Volumes ebenfalls endgültig löschen? Tippe dafür exakt DATEN LOESCHEN'
        if ($deleteVolumes -eq 'DATEN LOESCHEN') {
            Invoke-VendooDockerCompose @('down', '-v') | Out-Null
            Write-Warn 'Persistente Docker-Volumes wurden gelöscht.'
        }
        return
    }
    Uninstall-VendooLocal
}


# ── Vendoo Operations Center 1.30.0 ──
function Get-VendooOperationsDir { return (Join-Path $VendooDir 'operations') }
function Get-VendooPendingOperationFile { return (Join-Path (Get-VendooOperationsDir) 'pending-operation.json') }
function Get-VendooLastOperationFile { return (Join-Path (Get-VendooOperationsDir) 'last-operation.json') }

function Test-VendooServerStopped {
    try {
        $listeners = @(Get-NetTCPConnection -LocalPort $Port -State Listen -ErrorAction SilentlyContinue)
        if ($listeners.Count -gt 0) {
            Write-Err "Vendoo lauscht noch auf Port $Port. Bitte das Serverfenster zuerst schliessen."
            return $false
        }
    } catch {
        try {
            $client = New-Object System.Net.Sockets.TcpClient
            $async = $client.BeginConnect('127.0.0.1', $Port, $null, $null)
            if ($async.AsyncWaitHandle.WaitOne(350, $false) -and $client.Connected) {
                $client.Close()
                Write-Err "Vendoo ist noch aktiv. Bitte das Serverfenster zuerst schliessen."
                return $false
            }
            $client.Close()
        } catch {}
    }
    return $true
}

function Copy-VendooCodeSnapshot([string]$Target) {
    New-Item -ItemType Directory -Path $Target -Force | Out-Null
    $rootFiles = @('.env.example','.gitignore','.npmrc','CHANGELOG.md','CLAUDE.md','FEATURES.md','README.md','SECURITY.md','THIRD_PARTY_NOTICES.md','package.json','package-lock.json','server.mjs','setup.bat','setup.ps1','update-manifest.json')
    foreach ($name in $rootFiles) {
        $source = Join-Path $VendooDir $name
        if (Test-Path -LiteralPath $source) { Copy-Item -LiteralPath $source -Destination (Join-Path $Target $name) -Force }
    }
    foreach ($name in @('public','lib','platforms','scripts','tools','docs','extensions','extension','MockupDesign')) {
        $source = Join-Path $VendooDir $name
        if (Test-Path -LiteralPath $source) { Copy-Item -LiteralPath $source -Destination (Join-Path $Target $name) -Recurse -Force }
    }
    $localAiTarget = Join-Path $Target 'local-ai'
    New-Item -ItemType Directory -Path $localAiTarget -Force | Out-Null
    foreach ($name in @('start-local-flux.ps1','stop-local-flux.ps1')) {
        $source = Join-Path $VendooDir ('local-ai\' + $name)
        if (Test-Path -LiteralPath $source) { Copy-Item -LiteralPath $source -Destination (Join-Path $localAiTarget $name) -Force }
    }
    $workflowSource = Join-Path $VendooDir 'local-ai\workflows'
    if (Test-Path -LiteralPath $workflowSource) { Copy-Item -LiteralPath $workflowSource -Destination (Join-Path $localAiTarget 'workflows') -Recurse -Force }
    $schemaSource = Join-Path $VendooDir 'db\schema.sql'
    if (Test-Path -LiteralPath $schemaSource) {
        New-Item -ItemType Directory -Path (Join-Path $Target 'db') -Force | Out-Null
        Copy-Item -LiteralPath $schemaSource -Destination (Join-Path $Target 'db\schema.sql') -Force
    }
}

function Copy-VendooRuntimeSnapshot([string]$Target) {
    New-Item -ItemType Directory -Path $Target -Force | Out-Null
    $dbFile = Join-Path $VendooDir 'db\vendoo.db'
    if (Test-Path -LiteralPath $dbFile) {
        New-Item -ItemType Directory -Path (Join-Path $Target 'db') -Force | Out-Null
        Copy-Item -LiteralPath $dbFile -Destination (Join-Path $Target 'db\vendoo.db') -Force
    }
    foreach ($name in @('uploads','config','modules')) {
        $source = Join-Path $VendooDir $name
        if (Test-Path -LiteralPath $source) {
            Copy-Item -LiteralPath $source -Destination (Join-Path $Target $name) -Recurse -Force
        }
    }
    $envFile = Join-Path $VendooDir '.env'
    if (Test-Path -LiteralPath $envFile) { Copy-Item -LiteralPath $envFile -Destination (Join-Path $Target '.env') -Force }
}

function Copy-VendooTree([string]$Source, [string]$Target) {
    if (-not (Test-Path -LiteralPath $Source)) { throw "Quellverzeichnis fehlt: $Source" }
    New-Item -ItemType Directory -Path $Target -Force | Out-Null
    $null = & robocopy.exe $Source $Target /E /COPY:DAT /DCOPY:DAT /R:2 /W:1 /NFL /NDL /NJH /NJS /NP
    $code = $LASTEXITCODE
    if ($code -gt 7) { throw "Robocopy fehlgeschlagen (Exit-Code $code): $Source -> $Target" }
}

function Restore-VendooCodeSnapshot([string]$Source) {
    if (-not (Test-Path -LiteralPath $Source)) { throw "Rollback-Snapshot fehlt: $Source" }
    Copy-VendooTree -Source $Source -Target $VendooDir
}

function Restore-VendooRuntimeSnapshot([string]$Source) {
    if (-not (Test-Path -LiteralPath $Source)) { return }
    $dbSource = Join-Path $Source 'db\vendoo.db'
    if (Test-Path -LiteralPath $dbSource) {
        New-Item -ItemType Directory -Path (Join-Path $VendooDir 'db') -Force | Out-Null
        Remove-Item -LiteralPath (Join-Path $VendooDir 'db\vendoo.db-wal') -Force -ErrorAction SilentlyContinue
        Remove-Item -LiteralPath (Join-Path $VendooDir 'db\vendoo.db-shm') -Force -ErrorAction SilentlyContinue
        Copy-Item -LiteralPath $dbSource -Destination (Join-Path $VendooDir 'db\vendoo.db') -Force
    }
    foreach ($name in @('uploads','config','modules')) {
        $sourcePath = Join-Path $Source $name
        if (Test-Path -LiteralPath $sourcePath) {
            $targetPath = Join-Path $VendooDir $name
            if (Test-Path -LiteralPath $targetPath) { Remove-Item -LiteralPath $targetPath -Recurse -Force }
            Copy-Item -LiteralPath $sourcePath -Destination $targetPath -Recurse -Force
        }
    }
    $envSource = Join-Path $Source '.env'
    if (Test-Path -LiteralPath $envSource) { Copy-Item -LiteralPath $envSource -Destination (Join-Path $VendooDir '.env') -Force }
}

function Find-VendooUpdateRoot([string]$ExtractRoot) {
    $packages = @(Get-ChildItem -LiteralPath $ExtractRoot -Filter 'package.json' -File -Recurse -ErrorAction SilentlyContinue)
    foreach ($package in $packages) {
        try {
            $json = Get-Content -LiteralPath $package.FullName -Raw | ConvertFrom-Json
            if ($json.name -eq 'vendoo' -and (Test-Path -LiteralPath (Join-Path $package.Directory.FullName 'server.mjs'))) { return $package.Directory.FullName }
        } catch {}
    }
    return $null
}

function Apply-VendooPendingOperation {
    Write-Header
    Write-Host '  Vorbereitete Systemoperation anwenden' -ForegroundColor White
    Write-Host ''
    $pendingFile = Get-VendooPendingOperationFile
    if (-not (Test-Path -LiteralPath $pendingFile)) { Write-Warn 'Keine vorbereitete Operation vorhanden.'; return }
    if (-not (Test-VendooServerStopped)) { return }

    try { $operation = Get-Content -LiteralPath $pendingFile -Raw | ConvertFrom-Json }
    catch { Write-Err 'pending-operation.json ist ungueltig.'; return }
    if (-not $operation.verified) { Write-Err 'Die Operation wurde nicht als verifiziert markiert.'; return }
    if (-not (Test-Path -LiteralPath $operation.archive_path)) { Write-Err "Archiv fehlt: $($operation.archive_path)"; return }

    Write-Host "  Typ:       $($operation.type)" -ForegroundColor DarkGray
    if ($operation.version_to) { Write-Host "  Version:   $($operation.version_from) -> $($operation.version_to)" -ForegroundColor DarkGray }
    Write-Host "  Archiv:    $($operation.archive_path)" -ForegroundColor DarkGray
    Write-Host ''
    $confirm = Read-Host '  Jetzt anwenden? (ja/nein)'
    if ($confirm -ne 'ja') { Write-Warn 'Operation abgebrochen.'; return }

    $stamp = Get-Date -Format 'yyyyMMdd-HHmmss'
    $rollbackRoot = Join-Path (Get-VendooOperationsDir) ("rollback\" + $stamp)
    $codeRollback = Join-Path $rollbackRoot 'code'
    $runtimeRollback = Join-Path $rollbackRoot 'runtime'
    $extractRoot = Join-Path (Get-VendooOperationsDir) ("apply-" + $stamp)
    New-Item -ItemType Directory -Path $extractRoot -Force | Out-Null

    try {
        Write-Step '1/5' 'Rollback-Snapshot erstellen...'
        Copy-VendooCodeSnapshot -Target $codeRollback
        Copy-VendooRuntimeSnapshot -Target $runtimeRollback
        Write-OK 'Rollback-Snapshot erstellt'

        Write-Step '2/5' 'Archiv entpacken...'
        Expand-Archive -LiteralPath $operation.archive_path -DestinationPath $extractRoot -Force
        Write-OK 'Archiv entpackt'

        if ($operation.type -eq 'update') {
            Write-Step '3/5' 'Vendoo-Programmdateien aktualisieren...'
            $sourceRoot = Find-VendooUpdateRoot -ExtractRoot $extractRoot
            if (-not $sourceRoot) { throw 'Vendoo-Quellordner wurde im Update nicht gefunden.' }
            Copy-VendooTree -Source $sourceRoot -Target $VendooDir
            Write-OK 'Programmdateien aktualisiert'
            Write-Step '4/5' 'Dependencies und Konfiguration aktualisieren...'
            Update-Vendoo
            & node --check (Join-Path $VendooDir 'server.mjs')
            if ($LASTEXITCODE -ne 0) { throw 'server.mjs ist nach dem Update syntaktisch ungueltig.' }
            if (-not (Test-Path -LiteralPath (Join-Path $VendooDir 'node_modules'))) { throw 'node_modules fehlt nach dem Update.' }
        }
        elseif ($operation.type -eq 'restore') {
            Write-Step '3/5' 'Datenbank wiederherstellen...'
            $dbSource = Join-Path $extractRoot 'db\vendoo.db'
            if (-not (Test-Path -LiteralPath $dbSource)) { throw 'Datenbank fehlt im Backup.' }
            New-Item -ItemType Directory -Path (Join-Path $VendooDir 'db') -Force | Out-Null
            Remove-Item -LiteralPath (Join-Path $VendooDir 'db\vendoo.db-wal') -Force -ErrorAction SilentlyContinue
            Remove-Item -LiteralPath (Join-Path $VendooDir 'db\vendoo.db-shm') -Force -ErrorAction SilentlyContinue
            Copy-Item -LiteralPath $dbSource -Destination (Join-Path $VendooDir 'db\vendoo.db') -Force
            Write-OK 'Datenbank wiederhergestellt'
            Write-Step '4/5' 'Uploads und Konfiguration wiederherstellen...'
            $backupManifest = $null
            $manifestPath = Join-Path $extractRoot 'backup-manifest.json'
            if (Test-Path -LiteralPath $manifestPath) {
                try { $backupManifest = Get-Content -LiteralPath $manifestPath -Raw | ConvertFrom-Json } catch {}
            }
            $uploadsSource = Join-Path $extractRoot 'uploads'
            if ($backupManifest -and $backupManifest.include_uploads) {
                $uploadsTarget = Join-Path $VendooDir 'uploads'
                if (Test-Path -LiteralPath $uploadsTarget) { Remove-Item -LiteralPath $uploadsTarget -Recurse -Force }
                if (Test-Path -LiteralPath $uploadsSource) { Copy-Item -LiteralPath $uploadsSource -Destination $uploadsTarget -Recurse -Force }
                else { New-Item -ItemType Directory -Path $uploadsTarget -Force | Out-Null }
            }
            $configSource = Join-Path $extractRoot 'config'
            if (Test-Path -LiteralPath $configSource) {
                $configTarget = Join-Path $VendooDir 'config'
                if (Test-Path -LiteralPath $configTarget) { Remove-Item -LiteralPath $configTarget -Recurse -Force }
                Copy-Item -LiteralPath $configSource -Destination $configTarget -Recurse -Force
            }
            $modulesSource = Join-Path $extractRoot 'modules'
            if (Test-Path -LiteralPath $modulesSource) {
                $modulesTarget = Join-Path $VendooDir 'modules'
                if (Test-Path -LiteralPath $modulesTarget) { Remove-Item -LiteralPath $modulesTarget -Recurse -Force }
                Copy-Item -LiteralPath $modulesSource -Destination $modulesTarget -Recurse -Force
            }
            $moduleStateSource = Join-Path $extractRoot 'module-state\modules-state.json'
            if (Test-Path -LiteralPath $moduleStateSource) {
                $configTarget = Join-Path $VendooDir 'config'
                New-Item -ItemType Directory -Path $configTarget -Force | Out-Null
                Copy-Item -LiteralPath $moduleStateSource -Destination (Join-Path $configTarget 'modules-state.json') -Force
            }
            $envSource = Join-Path $extractRoot 'config\.env'
            if (Test-Path -LiteralPath $envSource) { Copy-Item -LiteralPath $envSource -Destination (Join-Path $VendooDir '.env') -Force }
            Write-OK 'Uploads, Konfiguration, Modulpakete und Modulzustand wiederhergestellt'
        }
        else { throw "Unbekannter Operationstyp: $($operation.type)" }

        Write-Step '5/5' 'Operation abschliessen...'
        $last = [ordered]@{
            id = [string]$operation.id
            type = [string]$operation.type
            status = 'applied'
            version_from = [string]$operation.version_from
            version_to = [string]$operation.version_to
            rollback_path = $rollbackRoot
            applied_at = (Get-Date).ToString('o')
        }
        $last | ConvertTo-Json -Depth 6 | Set-Content -LiteralPath (Get-VendooLastOperationFile) -Encoding UTF8
        Remove-Item -LiteralPath $pendingFile -Force
        Remove-Item -LiteralPath $extractRoot -Recurse -Force -ErrorAction SilentlyContinue
        Write-OK 'Operation erfolgreich abgeschlossen'
        Write-Host ''
        Write-Host '  Starte Vendoo jetzt ueber Menuepunkt 2 und pruefe Admin > System.' -ForegroundColor Green
    } catch {
        Write-Err ("Operation fehlgeschlagen: " + $_.Exception.Message)
        Write-Warn 'Der vorherige Stand wird aus dem gerade erstellten Snapshot wiederhergestellt.'
        try {
            Restore-VendooCodeSnapshot -Source $codeRollback
            Restore-VendooRuntimeSnapshot -Source $runtimeRollback
            Write-OK 'Vorheriger Stand wiederhergestellt'
        } catch { Write-Err ("Automatischer Rollback fehlgeschlagen: " + $_.Exception.Message) }
    } finally {
        Remove-Item -LiteralPath $extractRoot -Recurse -Force -ErrorAction SilentlyContinue
    }
}

function Invoke-VendooRollback {
    Write-Header
    Write-Host '  Letzte Systemoperation zuruecksetzen' -ForegroundColor White
    Write-Host ''
    if (-not (Test-VendooServerStopped)) { return }
    $lastFile = Get-VendooLastOperationFile
    if (-not (Test-Path -LiteralPath $lastFile)) { Write-Warn 'Kein Rollback-Snapshot vorhanden.'; return }
    try { $last = Get-Content -LiteralPath $lastFile -Raw | ConvertFrom-Json }
    catch { Write-Err 'last-operation.json ist ungueltig.'; return }
    if (-not $last.rollback_path -or -not (Test-Path -LiteralPath $last.rollback_path)) { Write-Err 'Rollback-Verzeichnis wurde nicht gefunden.'; return }
    Write-Host "  Letzte Operation: $($last.type)" -ForegroundColor DarkGray
    Write-Host "  Zeitpunkt:         $($last.applied_at)" -ForegroundColor DarkGray
    Write-Host ''
    if ((Read-Host '  Vorherigen Stand wiederherstellen? (ja/nein)') -ne 'ja') { Write-Warn 'Rollback abgebrochen.'; return }
    try {
        Restore-VendooCodeSnapshot -Source (Join-Path $last.rollback_path 'code')
        Restore-VendooRuntimeSnapshot -Source (Join-Path $last.rollback_path 'runtime')
        $last.status = 'rolled_back'
        $last | Add-Member -NotePropertyName rolled_back_at -NotePropertyValue (Get-Date).ToString('o') -Force
        $last | ConvertTo-Json -Depth 6 | Set-Content -LiteralPath $lastFile -Encoding UTF8
        Write-OK 'Vorheriger Vendoo-Stand wurde wiederhergestellt.'
        Write-Warn 'Fuehre bei Bedarf danach Menuepunkt 3 – Update aus.'
    } catch { Write-Err ("Rollback fehlgeschlagen: " + $_.Exception.Message) }
}

# ── Main Menu ──
function Show-Menu {
    while ($true) {
        Write-Header
        Write-Host '  Waehle eine Option:' -ForegroundColor White
        Write-Host ''
        Write-Host '    1  Installieren / Installationsziel wählen' -ForegroundColor Cyan
        Write-Host '    2  Starten' -ForegroundColor Cyan
        Write-Host '    3  Update' -ForegroundColor Cyan
        Write-Host '    4  Reparieren' -ForegroundColor Cyan
        Write-Host '    5  Deinstallieren' -ForegroundColor Cyan
        Write-Host '    6  Status anzeigen' -ForegroundColor Cyan
        Write-Host '   13  Konfiguration ändern (Assistent)' -ForegroundColor Cyan
        Write-Host '    7  Lokales FLUX / ComfyUI installieren oder aktualisieren' -ForegroundColor Cyan
        Write-Host '    8  Lokales FLUX / ComfyUI Status' -ForegroundColor Cyan
        Write-Host '    9  Lokales FLUX / ComfyUI starten' -ForegroundColor Cyan
        Write-Host '   10  Lokales FLUX / ComfyUI stoppen' -ForegroundColor Cyan
        Write-Host '   11  Vorbereitete Operation anwenden' -ForegroundColor Cyan
        Write-Host '   12  Letzte Operation zuruecksetzen' -ForegroundColor Cyan
        Write-Host '    0  Beenden' -ForegroundColor DarkGray
        Write-Host ''
        $choice = Read-Host '  Auswahl'

        switch ($choice) {
            '1' { Install-Vendoo }
            '2' { Start-Vendoo }
            '3' { Update-Vendoo }
            '4' { Repair-Vendoo }
            '5' { Uninstall-Vendoo }
            '6' { Show-Status }
            '7' { Install-LocalFlux }
            '8' { Show-LocalFluxStatus }
            '9' { Start-LocalFlux }
            '10' { Stop-LocalFlux }
            '11' { Apply-VendooPendingOperation }
            '12' { Invoke-VendooRollback }
            '13' { Configure-VendooConsole }
            '0' { Write-Host '  Auf Wiedersehen!' -ForegroundColor Green; return }
            default { Write-Warn 'Ungueltige Auswahl' }
        }
        Write-Host ''
        Read-Host '  Druecke Enter um fortzufahren'
    }
}

Remove-LegacyTryOnComponents

if (-not (Test-VendooPowerShellFiles)) {
    Write-Host ''
    Write-Err 'Vendoo Setup wurde wegen fehlerhafter oder fehlender Pflichtskripte beendet.'
    exit 12
}

# Automatische Wiederaufnahme des exakt bestätigten Slice-22-Fehlzustands.
# Direkte CLI-Kommandos bleiben davon unberührt.
if ($args.Count -eq 0) {
    Invoke-LocalFluxStartupRecovery
}

# Handle CLI arguments for direct commands
if ($args.Count -gt 0) {
    switch ($args[0]) {
        'install'   { Install-Vendoo }
        'install-local' { $script:AutoStartAfterInstall = $true; Set-VendooInstallMode 'windows-local'; Install-VendooLocal }
        'install-docker' { Install-VendooDocker }
        'configure' { Configure-VendooConsole }
        'menu' { Show-Menu }
        'start'     { Start-Vendoo }
        'update'    { Update-Vendoo }
        'repair'    { Repair-Vendoo }
        'uninstall' { Uninstall-Vendoo }
        'status'    { Show-Status }
        'install-local-flux' { Install-LocalFlux }
        'flux-status' { Show-LocalFluxStatus }
        'flux-start' { Start-LocalFlux }
        'flux-stop' { Stop-LocalFlux }
        'apply-operation' { Apply-VendooPendingOperation }
        'rollback' { Invoke-VendooRollback }
        default     { Show-Menu }
    }
} else {
    Show-Menu
}