HexaHost-Web-Prod/scripts/publish-to-main.ps1

#Requires -Version 5.1
<#
.SYNOPSIS
  Erstellt einen Production-Build und veröffentlicht ihn auf den Branch main.

.DESCRIPTION
  1. Wechselt auf main und setzt ihn auf den Stand von dev
  2. Entfernt Kommentare, minifiziert CSS, obfuskiert JavaScript
  3. Committet und pusht main (optional)
  4. Wechselt zurück auf dev (Quellcode bleibt unverändert)

.PARAMETER Push
  Pusht main nach origin (Standard: nur lokaler Commit)

.PARAMETER DryRun
  Führt Git-Schritte nur simuliert aus (Build wird trotzdem erstellt)

.PARAMETER Message
  Commit-Nachricht für den Production-Build

.EXAMPLE
  .\scripts\publish-to-main.ps1

.EXAMPLE
  .\scripts\publish-to-main.ps1 -Push
#>
[CmdletBinding()]
param(
    [switch]$Push,
    [switch]$DryRun,
    [switch]$AllowDirty,
    [string]$Message = ""
)

$ErrorActionPreference = "Stop"
$Root = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
$BuildDir = Join-Path $Root "scripts\build"
$OriginalBranch = ""

function Write-Step([string]$Text) {
    Write-Host ""
    Write-Host "==> $Text" -ForegroundColor Cyan
}

function Ensure-GitClean {
    $status = git -C $Root status --porcelain
    if ($status) {
        throw "Uncommittete Änderungen im Repository. Bitte zuerst committen oder stashen."
    }
}

function Resolve-NodeTool([string]$ToolName) {
    $command = Get-Command $ToolName -ErrorAction SilentlyContinue
    if ($command) {
        return $command.Source
    }

    $candidates = @(
        (Join-Path $env:ProgramFiles "nodejs\$ToolName.cmd"),
        (Join-Path ${env:ProgramFiles(x86)} "nodejs\$ToolName.cmd"),
        (Join-Path $env:LOCALAPPDATA "Programs\nodejs\$ToolName.cmd"),
        "c:\Program Files\cursor\resources\app\resources\helpers\node.exe"
    )

    foreach ($candidate in $candidates) {
        if ($ToolName -eq "node" -and (Test-Path $candidate)) {
            return $candidate
        }
        if ($ToolName -ne "node" -and (Test-Path $candidate)) {
            return $candidate
        }
    }

    return $null
}

function Ensure-Node {
    $script:NodeExe = Resolve-NodeTool "node"
    $script:NpmExe = Resolve-NodeTool "npm"

    if (-not $script:NodeExe) {
        throw "Node.js ist nicht installiert. Bitte Node.js 18+ installieren: https://nodejs.org/"
    }
    if (-not $script:NpmExe) {
        throw "npm wurde nicht gefunden. Bitte Node.js inkl. npm installieren und PATH setzen."
    }
}

try {
    Set-Location $Root
    Ensure-Node
    if (-not $AllowDirty) {
        Ensure-GitClean
    } else {
        Write-Warning "AllowDirty aktiv – uncommittete Änderungen werden mit veröffentlicht."
    }

    $OriginalBranch = (git branch --show-current).Trim()
    if ($OriginalBranch -ne "dev") {
        Write-Warning "Empfohlen: Auf Branch 'dev' starten (aktuell: $OriginalBranch)"
    }

    if ([string]::IsNullOrWhiteSpace($Message)) {
        $Message = "chore(release): production build $(Get-Date -Format 'yyyy-MM-dd HH:mm')"
    }

    Write-Step "Installiere Build-Abhängigkeiten"
    Set-Location $BuildDir
    if (-not $DryRun) {
        & $NpmExe ci --no-fund --no-audit
        if ($LASTEXITCODE -ne 0) { throw "npm ci fehlgeschlagen" }
    }

    Write-Step "Wechsle auf main und synchronisiere mit dev"
    Set-Location $Root
    if ($DryRun) {
        Write-Host "[DryRun] git checkout main"
        Write-Host "[DryRun] git reset --hard dev"
    } else {
        git checkout main
        git reset --hard dev
    }

    Write-Step "Production-Build (Kommentare entfernen, JS obfuscaten)"
    Set-Location $BuildDir
    if ($DryRun) {
        Write-Host "[DryRun] npm run build:in-place"
    } else {
        & $NpmExe run build:in-place
        if ($LASTEXITCODE -ne 0) { throw "Production-Build fehlgeschlagen" }
    }

    Write-Step "Production-Build committen"
    Set-Location $Root
    if ($DryRun) {
        Write-Host "[DryRun] git add -A"
        Write-Host "[DryRun] git commit -m `"$Message`""
    } else {
        git add -A
        $null = git diff --cached --quiet
        if ($LASTEXITCODE -eq 0) {
            Write-Warning "Keine Build-Änderungen – nichts zu committen."
        } else {
            git commit -m $Message
        }
    }

    if ($Push) {
        Write-Step "Push nach origin/main"
        if ($DryRun) {
            Write-Host "[DryRun] git push origin main"
        } else {
            git push origin main
        }
    } else {
        Write-Host "Hinweis: Ohne -Push wurde nur lokal auf main gebaut." -ForegroundColor Yellow
    }

    Write-Step "Zurück auf $OriginalBranch"
    if (-not $DryRun) {
        if ([string]::IsNullOrWhiteSpace($OriginalBranch)) {
            git checkout dev
        } else {
            git checkout $OriginalBranch
        }
    }

    Write-Host ""
    Write-Host "Production-Release abgeschlossen." -ForegroundColor Green
    if (-not $Push -and -not $DryRun) {
        Write-Host "Zum Veröffentlichen: git push origin main" -ForegroundColor Yellow
    }
}
catch {
    Write-Host ""
    Write-Host "FEHLER: $($_.Exception.Message)" -ForegroundColor Red
    Set-Location $Root
    if ($OriginalBranch -and -not $DryRun) {
        git checkout $OriginalBranch 2>$null
    }
    exit 1
}