build_webstatic/install.sh

#!/usr/bin/env bash
# GitCover.WebStaticBuilder — Installationsskript
# Installiert das Tool per-user (Default: ~/.local/share/GitCover/webstatic) und
# legt einen ausfuehrbaren Wrapper `webstatic` nach ~/.local/bin. Idempotent.
# Kein sudo noetig (Spiegelbild des hermes-agent-Update-Konzepts: user-owned
# Installationsziel -> `webstatic update` laeuft als normaler User).
#
# Modi (WEBSTATIC_INSTALL_MODE):
#   clone  (Default) — klont das Quell-Repo inkl. .git nach INSTALL_DIR.
#                      Ermoeglicht spaeter `git pull` + lokale Anpassungen stashen/mergen
#                      (Hermes-Update-Konzept). Das Ziel ist ein echtes Git-Repo.
#   copy   — kopiert nur das gebaute Binary + Beispiel + Docs (kein .git).
#
# Umgebungsvariablen (optional):
#   WEBSTATIC_INSTALL_MODE  clone|copy  (Default: clone)
#   WEBSTATIC_INSTALL_DIR   Zielverzeichnis
#                           (Default: $XDG_DATA_HOME/GitCover/webstatic bzw.
#                            ~/.local/share/GitCover/webstatic)
#   WEBSTATIC_BIN_DIR       Verzeichnis fuer den Launcher
#                           (Default: $XDG_BIN_HOME bzw. ~/.local/bin;
#                            nur bei System-Install fallback /usr/local/bin via sudo)
#
# System-weite Installation nach /opt/GitCover/webstatic (root-owned):
#   sudo env PATH="$PATH" \
#     WEBSTATIC_INSTALL_DIR=/opt/GitCover/webstatic \
#     WEBSTATIC_BIN_DIR=/usr/local/bin ./install.sh
set -euo pipefail

INSTALL_MODE="${WEBSTATIC_INSTALL_MODE:-clone}"
INSTALL_DIR="${WEBSTATIC_INSTALL_DIR:-${XDG_DATA_HOME:-$HOME/.local/share}/GitCover/webstatic}"
BIN_DIR="${WEBSTATIC_BIN_DIR:-${XDG_BIN_HOME:-$HOME/.local/bin}}"
BIN_LINK="$BIN_DIR/webstatic"
REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

echo "== GitCover.WebStaticBuilder Installer =="
echo "Modus:        $INSTALL_MODE"
echo "Installationsziel: $INSTALL_DIR"
echo "Launcher:     $BIN_LINK"

# 0) Update-Modus (--update)
if [ "${1:-}" = "--update" ]; then
  echo "== Update =="
  if [ -d "$INSTALL_DIR/.git" ]; then
    cd "$INSTALL_DIR"
    [ -n "$(git status --porcelain)" ] && git stash
    git pull
    { [ -n "$(git stash list)" ] && git stash pop; } || true
    dotnet build "$INSTALL_DIR/GitCover.WebStaticBuilder.csproj" -c Release -v minimal
  else
    dotnet build "$REPO_DIR/GitCover.WebStaticBuilder.csproj" -c Release -v minimal
    rm -rf "$INSTALL_DIR/bin"
    cp -r "$REPO_DIR/bin/Release/net10.0/." "$INSTALL_DIR/"
  fi
  echo "Update abgeschlossen."
  exit 0
fi

# 1) .NET 10 pruefen
if ! command -v dotnet >/dev/null 2>&1; then
  echo "FEHLER: .NET 10 (dotnet) ist nicht installiert." >&2
  echo "Installiere .NET 10 von https://dotnet.microsoft.com/download" >&2
  exit 1
fi
echo "Gefunden: dotnet $(dotnet --version 2>/dev/null || echo unbekannt)"

# 2) Quelle beschaffen
if [ "$INSTALL_MODE" = "clone" ]; then
  echo "== Clone-Modus: bereite $INSTALL_DIR vor =="
  mkdir -p "$(dirname "$INSTALL_DIR")"
  if [ -d "$INSTALL_DIR/.git" ]; then
    echo "Bereits ein Git-Repo — ueberspringe Clone (git pull ist beim Update noetig)."
  else
    if [ -e "$INSTALL_DIR" ]; then
      echo "FEHLER: $INSTALL_DIR existiert, ist aber kein Git-Repo." >&2
      echo "Entferne oder verschiebe es manuell, dann erneut ausfuehren." >&2
      exit 1
    fi
    # Lokaler Klon (offline-sicher); Remote wird auf das echte Upstream gesetzt.
    git clone "$REPO_DIR" "$INSTALL_DIR"
    SRC_REMOTE="$(git -C "$REPO_DIR" remote get-url origin 2>/dev/null || true)"
    if [ -n "$SRC_REMOTE" ]; then
      git -C "$INSTALL_DIR" remote set-url origin "$SRC_REMOTE" 2>/dev/null || true
      echo "Remote 'origin' -> $SRC_REMOTE"
    fi
  fi
  BUILD_PROJECT="$INSTALL_DIR/GitCover.WebStaticBuilder.csproj"
  DLL="$INSTALL_DIR/bin/Release/net10.0/webstatic.dll"
else
  echo "== Copy-Modus: baue Release aus $REPO_DIR =="
  dotnet build "$REPO_DIR/GitCover.WebStaticBuilder.csproj" -c Release -v minimal
  echo "== Kopiere nach $INSTALL_DIR =="
  mkdir -p "$INSTALL_DIR"
  rm -rf "$INSTALL_DIR/bin" "$INSTALL_DIR/webstatic.example" 2>/dev/null || true
  cp -r "$REPO_DIR/bin/Release/net10.0/." "$INSTALL_DIR/"
  cp -r "$REPO_DIR/webstatic.example" "$INSTALL_DIR/webstatic.example" 2>/dev/null || true
  for f in LICENSE README.md docs plans AGENTS.md MEMORY.md SKILLS.md; do
    [ -e "$REPO_DIR/$f" ] && cp -r "$REPO_DIR/$f" "$INSTALL_DIR/" 2>/dev/null || true
  done
  BUILD_PROJECT="$REPO_DIR/GitCover.WebStaticBuilder.csproj"
  DLL="$INSTALL_DIR/webstatic.dll"
fi

# 3) Bauen (im Installationsziel bei Clone, sonst im Repo)
echo "== Baue Release =="
dotnet build "$BUILD_PROJECT" -c Release -v minimal

# 4) Ausfuehrbare Wrapper-Datei (kein direkter Symlink auf die .dll —
#    eine .dll ist unter Linux nicht ausfuehrbar; der Wrapper ruft dotnet auf)
mkdir -p "$BIN_DIR" 2>/dev/null || sudo mkdir -p "$BIN_DIR"
echo "== Erzeuge Wrapper $BIN_LINK -> $DLL =="
WRAPPER_CONTENT="#!/usr/bin/env bash
exec dotnet \"$DLL\" \"\$@\"
"
if [ -w "$(dirname "$BIN_LINK")" ]; then
  rm -f "$BIN_LINK"
  printf '%s' "$WRAPPER_CONTENT" > "$BIN_LINK"
  chmod +x "$BIN_LINK"
else
  echo "Hinweis: $BIN_LINK benoetigt Schreibrechte; erstelle via sudo."
  rm -f "$BIN_LINK" 2>/dev/null || sudo rm -f "$BIN_LINK"
  printf '%s' "$WRAPPER_CONTENT" | sudo tee "$BIN_LINK" >/dev/null
  sudo chmod +x "$BIN_LINK"
fi

echo ""
echo "Fertig. Danach verfuegbar ueber: webstatic --help"
echo "Beispiel-Seite erzeugen: webstatic init mysite && cd mysite && webstatic build --env development"
echo "GCBoK bauen:           webstatic build --root www --env development"
echo "Umgebungsvariable (optional): WEBSTATIC_BUILDER=$DLL"
echo ""
echo "Update (Clone-Modus, ohne sudo):  webstatic update"
echo "   (alternativ: cd $INSTALL_DIR && git stash && git pull && git stash pop && dotnet build -c Release)"