devzone 0.0.0-stage → 0.5.1

package/.devcontainer/Dockerfile

@@ -0,0 +1,72 @@
+# Image de base de devzone : outils sans feature officielle, versions figées.
+# Java, Node, Python, Docker, kubectl, helm et gh sont ajoutés par les features
+# de devcontainer.json, par-dessus cette image.
+
+# uv : binaire de l'image officielle (pas de script curl | sh)
+ARG UV_VERSION=0.13.1
+FROM ghcr.io/astral-sh/uv:${UV_VERSION} AS uv
+
+FROM mcr.microsoft.com/devcontainers/base:ubuntu-24.04
+
+# Versions : pour mettre à jour, changer la version ET l'empreinte sha256,
+# puis Rebuild Container
+ARG K9S_VERSION=0.51.0
+ARG ACTIONLINT_VERSION=1.7.12
+ARG GITLEAKS_VERSION=8.30.1
+ARG KIND_VERSION=0.33.0
+ARG RUFF_VERSION=0.17.0
+ARG VULTURE_VERSION=2.16
+# pytest : même version que la CI de repowarden (ci/requirements/e2e-python.in)
+ARG PYTEST_VERSION=9.1.1
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+
+# Contrôles shell de repowarden
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends shellcheck bats \
+    && rm -rf /var/lib/apt/lists/*
+
+# k9s, actionlint (mêmes versions que la CI de repowarden), gitleaks, kind :
+# installer <nom> <url> <sha256> : empreinte vérifiée avant d'installer quoi que ce soit dans /usr/local/bin
+# (kind est un binaire seul, sans archive : installé à part, même vérification)
+RUN set -eu; \
+    arch="$(dpkg --print-architecture)"; \
+    case "$arch" in \
+        arm64) gl_arch=arm64; \
+               k9s_sha=3ee05c82e5f9198928a4e86133608ba6a2c10a2244d6a7789e820f78319d640c; \
+               al_sha=325e971b6ba9bfa504672e29be93c24981eeb1c07576d730e9f7c8805afff0c6; \
+               gl_sha=e4a487ee7ccd7d3a7f7ec08657610aa3606637dab924210b3aee62570fb4b080; \
+               kind_sha=20022bee6cfcd5086cb7234d218e3454e6090022f2a8f55d1fa7fcf42c3867a2 ;; \
+        amd64) gl_arch=x64; \
+               k9s_sha=c3752ad51a5a4015a113819c4eeb6e55a4d0e4b8e652494797532f6fc8161dd7; \
+               al_sha=8aca8db96f1b94770f1b0d72b6dddcb1ebb8123cb3712530b08cc387b349a3d8; \
+               gl_sha=551f6fc83ea457d62a0d98237cbad105af8d557003051f41f3e7ca7b3f2470eb; \
+               kind_sha=aee6151561422756b764a4ae28e7f44cda5af5a9eead3cc9985112b1de8d8e0d ;; \
+        *) echo "Architecture non prise en charge : $arch" >&2; exit 1 ;; \
+    esac; \
+    installer() { \
+        tmp="$(mktemp -d)"; \
+        curl -fsSL "$2" -o "$tmp/a.tar.gz"; \
+        echo "$3  $tmp/a.tar.gz" | sha256sum -c --quiet; \
+        tar -xzf "$tmp/a.tar.gz" -C "$tmp" "$1"; \
+        install -m 0755 "$tmp/$1" /usr/local/bin/"$1"; \
+        rm -rf "$tmp"; \
+    }; \
+    installer k9s "https://github.com/derailed/k9s/releases/download/v${K9S_VERSION}/k9s_Linux_${arch}.tar.gz" "$k9s_sha"; \
+    installer actionlint "https://github.com/rhysd/actionlint/releases/download/v${ACTIONLINT_VERSION}/actionlint_${ACTIONLINT_VERSION}_linux_${arch}.tar.gz" "$al_sha"; \
+    installer gitleaks "https://github.com/gitleaks/gitleaks/releases/download/v${GITLEAKS_VERSION}/gitleaks_${GITLEAKS_VERSION}_linux_${gl_arch}.tar.gz" "$gl_sha"; \
+    curl -fsSL "https://github.com/kubernetes-sigs/kind/releases/download/v${KIND_VERSION}/kind-linux-${arch}" -o /tmp/kind; \
+    echo "$kind_sha  /tmp/kind" | sha256sum -c --quiet; \
+    install -m 0755 /tmp/kind /usr/local/bin/kind; \
+    rm -f /tmp/kind
+
+COPY --from=uv /uv /uvx /usr/local/bin/
+
+# ruff, vulture (repowarden code-mort a besoin des deux) et pytest, installés pour
+# tous les utilisateurs, avec un Python géré par uv hors du home
+# (variables limitées au build : uv tool install reste dans ~/.local pour vscode)
+RUN export UV_TOOL_DIR=/opt/uv/tools UV_TOOL_BIN_DIR=/usr/local/bin \
+        UV_PYTHON_INSTALL_DIR=/opt/uv/python \
+    && uv tool install "ruff==${RUFF_VERSION}" \
+    && uv tool install "vulture==${VULTURE_VERSION}" \
+    && uv tool install "pytest==${PYTEST_VERSION}"

package/.devcontainer/demarrage.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# À chaque démarrage, dans l'ordre : identité git (déduite du compte gh),
+# clusters Kubernetes, puis récapitulatif de ce qui reste à faire (devzone).
+# Séquentiel : le récapitulatif voit l'identité tout juste posée ; l'échec
+# d'une étape n'empêche pas les suivantes.
+ICI="$(dirname "$0")"
+bash "$ICI/git-identite.sh" || echo "démarrage : identité git non traitée (bash $ICI/git-identite.sh)"
+bash "$ICI/kube-config.sh" || echo "démarrage : clusters non traités (bash $ICI/kube-config.sh)"
+echo
+bash "$ICI/devzone"

package/.devcontainer/devcontainer-lock.json

@@ -0,0 +1,34 @@
+{
+  "features": {
+    "ghcr.io/devcontainers/features/docker-in-docker:2": {
+      "version": "2.17.0",
+      "resolved": "ghcr.io/devcontainers/features/docker-in-docker@sha256:25b9f05705ffba7dbe503230ac76081419306f8c8bc88e0ce78c4ecd99a0c78c",
+      "integrity": "sha256:25b9f05705ffba7dbe503230ac76081419306f8c8bc88e0ce78c4ecd99a0c78c"
+    },
+    "ghcr.io/devcontainers/features/github-cli:1": {
+      "version": "1.1.3",
+      "resolved": "ghcr.io/devcontainers/features/github-cli@sha256:bd7ab48a832228f633239277552c30b353867fef2e5b037e064b4e64f0b843f2",
+      "integrity": "sha256:bd7ab48a832228f633239277552c30b353867fef2e5b037e064b4e64f0b843f2"
+    },
+    "ghcr.io/devcontainers/features/java:1": {
+      "version": "1.8.3",
+      "resolved": "ghcr.io/devcontainers/features/java@sha256:61a839211feda1e2a1f10646648a948e733e4d98d770f3a4b6698a3c5fc92abe",
+      "integrity": "sha256:61a839211feda1e2a1f10646648a948e733e4d98d770f3a4b6698a3c5fc92abe"
+    },
+    "ghcr.io/devcontainers/features/kubectl-helm-minikube:1": {
+      "version": "1.3.1",
+      "resolved": "ghcr.io/devcontainers/features/kubectl-helm-minikube@sha256:bbe8adf6b37fff8c67412ab0a4579f4c2f30bbaba1d9a5cebd9e38bade54025b",
+      "integrity": "sha256:bbe8adf6b37fff8c67412ab0a4579f4c2f30bbaba1d9a5cebd9e38bade54025b"
+    },
+    "ghcr.io/devcontainers/features/node:1": {
+      "version": "1.7.1",
+      "resolved": "ghcr.io/devcontainers/features/node@sha256:8c0de46939b61958041700ee89e3493f3b2e4131a06dc46b4d9423427d06e5f6",
+      "integrity": "sha256:8c0de46939b61958041700ee89e3493f3b2e4131a06dc46b4d9423427d06e5f6"
+    },
+    "ghcr.io/devcontainers/features/python:1": {
+      "version": "1.8.0",
+      "resolved": "ghcr.io/devcontainers/features/python@sha256:fbcad6955caeecc5ad3f7886baf652e25cba5225a6c4c2287c536de2e5607511",
+      "integrity": "sha256:fbcad6955caeecc5ad3f7886baf652e25cba5225a6c4c2287c536de2e5607511"
+    }
+  }
+}

package/.devcontainer/devcontainer.json

@@ -0,0 +1,91 @@
+{
+  "name": "devzone",
+  // Image de base + outils figés (k9s, uv, actionlint, gitleaks…) : voir Dockerfile
+  "build": { "dockerfile": "Dockerfile" },
+
+  "features": {
+    "ghcr.io/devcontainers/features/java:1": {
+      "version": "21",
+      "jdkDistro": "tem",
+      "installMaven": true
+    },
+    "ghcr.io/devcontainers/features/node:1": {
+      "version": "lts",
+      "pnpmVersion": "latest"
+    },
+    "ghcr.io/devcontainers/features/python:1": {
+      "version": "3.12",
+      // Pas d'outils pipx : leur lanceur « python -E » ignore PYTHONPATH et
+      // PYTHONPYCACHEPREFIX, dont repowarden a besoin pour lancer les tests
+      // (ruff, vulture et pytest viennent du Dockerfile, par uv)
+      "installTools": false
+    },
+    "ghcr.io/devcontainers/features/docker-in-docker:2": {},
+    "ghcr.io/devcontainers/features/kubectl-helm-minikube:1": {
+      "minikube": "none"
+    },
+    // gh : tickets, PR, protection (repowarden)
+    "ghcr.io/devcontainers/features/github-cli:1": {}
+  },
+
+  // Toujours /workspaces/devzone, quel que soit le nom du dossier sur l'hôte
+  // (npx devzone <dossier>) : scripts et chemins du conteneur en dépendent
+  "workspaceMount": "source=${localWorkspaceFolder},target=/workspaces/devzone,type=bind,consistency=cached",
+  "workspaceFolder": "/workspaces/devzone",
+
+  // Caches persistants : survivent aux rebuilds du conteneur. Préfixe des
+  // volumes : devzone, ou DEVZONE_VOLUMES (tests fonctionnels, isolés)
+  "mounts": [
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-m2,target=/home/vscode/.m2,type=volume",
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-pnpm,target=/home/vscode/.local/share/pnpm,type=volume",
+    // Assistants IA : connexion et réglages gardés d'un rebuild à l'autre
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-claude,target=/home/vscode/.claude,type=volume",
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-opencode-config,target=/home/vscode/.config/opencode,type=volume",
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-opencode-data,target=/home/vscode/.local/share/opencode,type=volume",
+    // Connexion gh et identité git (~/.config/git/config, lu par git comme
+    // config globale) : le conteneur reconstruit peut commiter et pousser
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-gh,target=/home/vscode/.config/gh,type=volume",
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-git,target=/home/vscode/.config/git,type=volume",
+    // Modules activés (devzone activer|desactiver), propres à chaque utilisateur
+    "source=${localEnv:DEVZONE_VOLUMES:devzone}-config,target=/home/vscode/.config/devzone,type=volume"
+  ],
+
+  "runArgs": [
+    // Cluster Kubernetes de l'hôte : sa config en lecture seule, adaptée au
+    // conteneur par kube-config.sh. HOME (Mac, Linux) ou USERPROFILE (Windows) ;
+    // -v plutôt que mounts : crée ~/.kube s'il manque au lieu d'échouer
+    "-v", "${localEnv:HOME}${localEnv:USERPROFILE}/.kube:/home/vscode/.kube-host:ro",
+    // host.docker.internal existe d'office avec Docker Desktop, pas sous Linux
+    "--add-host=host.docker.internal:host-gateway"
+  ],
+
+  "postCreateCommand": "bash .devcontainer/post-create.sh",
+  // Identité git, clusters, puis récapitulatif de ce qui reste à faire
+  "postStartCommand": "bash .devcontainer/demarrage.sh",
+  // Clusters kind du conteneur (config) + cluster de l'hôte (hote.config,
+  // refait à chaque démarrage par kube-config.sh)
+  "remoteEnv": {
+    "KUBECONFIG": "/home/vscode/.kube/config:/home/vscode/.kube/hote.config",
+    // Claude Code range aussi .claude.json (connexion, réglages) dans ce
+    // dossier, donc dans son volume, au lieu de ~/.claude.json
+    "CLAUDE_CONFIG_DIR": "/home/vscode/.claude"
+  },
+  "remoteUser": "vscode",
+
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "vscjava.vscode-java-pack",
+        "vmware.vscode-boot-dev-pack",
+        "dbaeumer.vscode-eslint",
+        "esbenp.prettier-vscode",
+        "bradlc.vscode-tailwindcss",
+        "ms-python.python",
+        "charliermarsh.ruff",
+        "ms-azuretools.vscode-docker",
+        "ms-kubernetes-tools.vscode-kubernetes-tools",
+        "redhat.vscode-yaml"
+      ]
+    }
+  }
+}

package/.devcontainer/devzone

@@ -0,0 +1,138 @@
+#!/usr/bin/env bash
+# Modules facultatifs de devzone, activés à la demande, sans rebuild :
+#   devzone                          état des modules
+#   devzone activer <module>         active et applique tout de suite
+#   devzone desactiver <module>      désactive et applique tout de suite
+#   devzone appliquer                installe ce qui est actif (post-create.sh)
+#   devzone actif <module>           code 0 si actif (scripts de démarrage)
+# État propre à chaque utilisateur : ~/.config/devzone/modules (volume
+# devzone-config, survit aux rebuilds), une ligne « module=on|off ».
+set -euo pipefail
+
+ETAT="${DEVZONE_ETAT:-$HOME/.config/devzone/modules}"
+ICI="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" && pwd)"
+MODULES=(ia kubernetes)
+
+# Assistants IA, versions figées : mettre à jour ici, puis devzone appliquer
+# (ou Rebuild Container)
+IA_PAQUETS=(@anthropic-ai/claude-code@2.1.286 opencode-ai@1.18.34)
+IA_NOMS=(@anthropic-ai/claude-code opencode-ai)
+
+description() {
+    case "$1" in
+        ia) echo "assistants IA : Claude Code, opencode" ;;
+        kubernetes) echo "connexion au cluster de l'hôte et metrics-server au démarrage" ;;
+    esac
+}
+
+connu() {
+    local m
+    for m in "${MODULES[@]}"; do [ "$m" = "$1" ] && return 0; done
+    return 1
+}
+
+# Premier démarrage (aucun état) : tout désactivé, sauf ia si une connexion
+# existe déjà dans les volumes (pas de régression pour qui s'en servait)
+initialiser() {
+    [ -f "$ETAT" ] && return 0
+    mkdir -p "$(dirname "$ETAT")"
+    local ia=off
+    if [ -f "$HOME/.claude/.credentials.json" ] || [ -f "$HOME/.local/share/opencode/auth.json" ]; then
+        ia=on
+        # stderr : initialiser est aussi appelé dans $(valeur …)
+        echo "devzone : connexion d'un assistant IA trouvée, module ia activé (devzone desactiver ia pour le retirer)" >&2
+    fi
+    printf 'ia=%s\nkubernetes=off\n' "$ia" >"$ETAT"
+}
+
+valeur() {
+    initialiser
+    local v
+    v="$(grep -E "^$1=" "$ETAT" | tail -1 | cut -d= -f2 || true)"
+    [ "$v" = on ] && echo on || echo off
+}
+
+ecrire() {
+    initialiser
+    local tmp
+    tmp="$(mktemp)"
+    grep -vE "^$1=" "$ETAT" >"$tmp" || true
+    echo "$1=$2" >>"$tmp"
+    mv "$tmp" "$ETAT"
+}
+
+appliquer_ia() {
+    if [ "$1" = on ]; then
+        npm install -g --no-fund --no-audit --loglevel=error "${IA_PAQUETS[@]}" >/dev/null
+        echo "devzone : ia actif : claude (puis /login), opencode auth login"
+    else
+        npm uninstall -g "${IA_NOMS[@]}" >/dev/null 2>&1 || true
+        echo "devzone : ia désactivé (connexions gardées dans leurs volumes)"
+    fi
+}
+
+appliquer_kubernetes() {
+    if [ "$1" = on ]; then
+        bash "$ICI/kube-config.sh"
+    else
+        rm -f "$HOME/.kube/hote.config"
+        echo "devzone : kubernetes désactivé (metrics-server reste installé sur les clusters où il l'a été)"
+    fi
+}
+
+# État complet : ✔ prêt, ✖ nécessaire, ○ facultatif, ⚠ à corriger ; chaque
+# point à faire avec sa commande (affiché à chaque démarrage)
+etat() {
+    local nom email statut m
+    echo "devzone : état (devzone pour le réafficher)"
+    nom="$(git config --get user.name || true)"
+    email="$(git config --get user.email || true)"
+    if [ -n "$nom" ] && [ -n "$email" ]; then
+        echo "  ✔ identité git    $nom <$email>"
+    else
+        echo "  ✖ identité git    nécessaire pour commiter : gh auth login -s workflow (automatique),"
+        echo "                    ou git config --file ~/.config/git/config user.name \"<nom>\" et user.email \"<email>\""
+    fi
+    if ! statut="$(gh auth status 2>&1)"; then
+        echo "  ○ GitHub          facultatif (push et PR, tickets repowarden) : gh auth login -s workflow"
+    elif grep -q "Token scopes:" <<<"$statut" && ! grep -q "'workflow'" <<<"$statut"; then
+        echo "  ⚠ GitHub          connecté, sans permission workflow (push de .github/workflows/ refusé) : gh auth refresh -h github.com -s workflow"
+    else
+        echo "  ✔ GitHub          connecté"
+    fi
+    for m in "${MODULES[@]}"; do
+        if [ "$(valeur "$m")" = on ]; then
+            printf '  ✔ module %-10s actif : %s\n' "$m" "$(description "$m")"
+        else
+            printf '  ○ module %-10s facultatif, %s : devzone activer %s\n' "$m" "$(description "$m")" "$m"
+        fi
+    done
+}
+
+changer() {
+    local m="${2:-}"
+    if [ -z "$m" ] || ! connu "$m"; then
+        echo "devzone : module inconnu : ${m:-(aucun)} ; modules : ${MODULES[*]}" >&2
+        exit 1
+    fi
+    ecrire "$m" "$1"
+    "appliquer_$m" "$1"
+}
+
+case "${1:-}" in
+    "" | etat | modules) etat ;;
+    activer) changer on "${2:-}" ;;
+    desactiver) changer off "${2:-}" ;;
+    appliquer)
+        [ "$(valeur ia)" = off ] || appliquer_ia on
+        ;;
+    actif)
+        connu "${2:-}" || { echo "devzone : module inconnu : ${2:-(aucun)}" >&2; exit 2; }
+        [ "$(valeur "$2")" = on ]
+        ;;
+    -h | --help | aide) sed -n '2,8p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//' ;;
+    *)
+        echo "devzone : commande inconnue : $1 (devzone --help)" >&2
+        exit 1
+        ;;
+esac

package/.devcontainer/git-identite.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Identité git, à chaque démarrage tant qu'elle manque : déduite du compte gh
+# (propre à chaque utilisateur, connexion gardée dans son volume) et écrite dans
+# ~/.config/git/config (volume devzone-git, survit aux rebuilds).
+# Une identité déjà définie (à la main, ou recopiée par VS Code dans
+# ~/.gitconfig) n'est jamais remplacée. Email noreply de GitHub : les commits
+# sont rattachés au compte sans exposer l'email personnel.
+set -euo pipefail
+
+CONFIG="$HOME/.config/git/config"
+nom_git="$(git config --get user.name || true)"
+email_git="$(git config --get user.email || true)"
+
+[ -n "$nom_git" ] && [ -n "$email_git" ] && exit 0
+
+# Sans gh : rien à déduire ; le récapitulatif de devzone le signale
+gh auth status >/dev/null 2>&1 || exit 0
+
+id="" login="" nom=""
+IFS=$'\t' read -r id login nom < <(gh api user --jq '[.id, .login, (.name // "")] | @tsv' 2>/dev/null || true)
+if [ -z "$id" ] || [ -z "$login" ]; then
+    echo "git-identite : compte GitHub illisible (réseau ?) ; relancer : bash .devcontainer/git-identite.sh"
+    exit 0
+fi
+
+[ -n "$nom_git" ] || git config --file "$CONFIG" user.name "${nom:-$login}"
+[ -n "$email_git" ] || git config --file "$CONFIG" user.email "${id}+${login}@users.noreply.github.com"
+echo "git-identite : $(git config --get user.name) <$(git config --get user.email)>"

package/.devcontainer/kube-config.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# Clusters Kubernetes du conteneur, à chaque démarrage (le port du cluster de
+# l'hôte peut changer) :
+# - ~/.kube/hote.config : copie du ~/.kube de l'hôte (monté en lecture seule) où
+#   127.0.0.1/localhost deviennent host.docker.internal, l'hôte vu du conteneur ;
+#   tls-server-name garde le nom attendu par le certificat
+# - ~/.kube/config : clusters kind du conteneur, jamais touché ici
+# KUBECONFIG (devcontainer.json) combine les deux.
+# Module kubernetes (devzone activer kubernetes) : connexion au cluster de
+# l'hôte et metrics-server seulement s'il est actif ; les contextes kind sont
+# toujours remis (un cluster créé à la main reste utilisable).
+set -euo pipefail
+
+ICI="$(dirname "$0")"
+module=off
+bash "$ICI/devzone" actif kubernetes && module=on
+
+# DEVZONE_KUBE_SOURCE : tests fonctionnels (jamais le cluster de l'hôte)
+SOURCE="${DEVZONE_KUBE_SOURCE:-$HOME/.kube-host/config}"
+HOTE="$HOME/.kube/hote.config"
+
+mkdir -p "$HOME/.kube"
+rm -f "$HOTE"
+# Doit exister : sinon kind écrit dans hote.config, effacé au prochain démarrage
+[ -f "$HOME/.kube/config" ] || install -m 600 /dev/null "$HOME/.kube/config"
+
+if [ "$module" = on ] && [ -f "$SOURCE" ]; then
+    install -m 600 "$SOURCE" "$HOTE"
+    KUBECONFIG="$HOTE" kubectl config view \
+        -o jsonpath='{range .clusters[*]}{.name}{"\t"}{.cluster.server}{"\n"}{end}' |
+        while IFS=$'\t' read -r nom serveur; do
+            case "$serveur" in
+                https://127.0.0.1:* | https://localhost:*) ;;
+                *) continue ;;
+            esac
+            hote="${serveur#https://}"
+            hote="${hote%%:*}"
+            KUBECONFIG="$HOTE" kubectl config set-cluster "$nom" \
+                --server="https://host.docker.internal:${serveur##*:}" \
+                --tls-server-name="$hote" >/dev/null
+        done
+fi
+
+# Clusters kind qui ont survécu au redémarrage : contexte remis dans ~/.kube/config
+# (le Docker interne peut mettre quelques secondes à démarrer)
+for _ in 1 2 3 4 5 6 7 8 9 10; do docker info >/dev/null 2>&1 && break; sleep 1; done
+choix="$(KUBECONFIG="$HOME/.kube/config" kubectl config current-context 2>/dev/null || true)"
+for cluster in $(kind get clusters 2>/dev/null); do
+    kind export kubeconfig --name "$cluster" --kubeconfig "$HOME/.kube/config" >/dev/null 2>&1 || true
+done
+
+# Cluster actif : celui choisi avant (kubectl config use-context), sinon celui
+# de l'hôte s'il en a un (current-context de hote.config), sinon kind
+export KUBECONFIG="$HOME/.kube/config:$HOTE"
+if [ -n "$choix" ] && kubectl config use-context "$choix" >/dev/null 2>&1; then
+    :
+elif [ -f "$HOTE" ] && [ -n "$(KUBECONFIG="$HOTE" kubectl config current-context 2>/dev/null)" ]; then
+    KUBECONFIG="$HOME/.kube/config" kubectl config unset current-context >/dev/null
+fi
+
+# Clusters joignables, parmi ceux de l'hôte et ceux de kind
+joignables=0
+for contexte in $(kubectl config get-contexts -o name 2>/dev/null); do
+    if kubectl --context "$contexte" --request-timeout=3s get --raw /readyz >/dev/null 2>&1; then
+        echo "kube-config : cluster joignable : $contexte"
+        joignables=$((joignables + 1))
+    elif [[ "$contexte" == kind-* ]]; then
+        echo "kube-config : cluster kind en cours de démarrage : $contexte"
+        joignables=$((joignables + 1))
+    fi
+done
+# Module désactivé : le récapitulatif de devzone le signale
+[ "$module" = on ] || exit 0
+echo "kube-config : cluster actif : $(kubectl config current-context 2>/dev/null || echo aucun)"
+if [ "$joignables" -eq 0 ]; then
+    echo "kube-config : aucun cluster joignable ; en créer un dans le conteneur : kind create cluster"
+fi
+
+# CPU/RAM dans k9s : metrics-server sur les clusters joignables qui ne l'ont pas
+bash "$ICI/metrics-server.sh" || true

package/.devcontainer/metrics-server.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# Installe metrics-server (CPU/RAM dans k9s, kubectl top) sur les clusters qui
+# n'ont pas d'API Metrics. Docker Desktop et kind ne l'ont pas d'office.
+# Usage : metrics-server.sh [contexte...] (défaut : clusters locaux joignables)
+# --kubelet-insecure-tls : le kubelet de Docker Desktop et de kind a un
+# certificat auto-signé, sans cette option le pod ne devient jamais Ready.
+# Sortie en erreur si un contexte demandé est inconnu ou injoignable, ou si
+# une installation échoue (kube-config.sh l'appelle avec || true).
+set -euo pipefail
+
+VERSION=v0.9.0
+MANIFESTE="https://github.com/kubernetes-sigs/metrics-server/releases/download/${VERSION}/components.yaml"
+
+mapfile -t connus < <(kubectl config get-contexts -o name 2>/dev/null || true)
+demandes=$#
+if [ "$demandes" -eq 0 ]; then
+    # Clusters locaux seulement : jamais d'install automatique sur un cluster
+    # distant de l'hôte (prod, staging…) ; pour un autre, le nommer en argument
+    mapfile -t contextes < <(printf '%s\n' ${connus[@]+"${connus[@]}"} |
+        grep -E '^(kind-.*|docker-desktop|rancher-desktop|orbstack|minikube)$' || true)
+    set -- ${contextes[@]+"${contextes[@]}"}
+fi
+
+code=0
+joignables=0
+for contexte in "$@"; do
+    if [ "$demandes" -gt 0 ] && ! printf '%s\n' ${connus[@]+"${connus[@]}"} | grep -qxF -- "$contexte"; then
+        echo "metrics-server : contexte inconnu : $contexte (voir kubectl config get-contexts)" >&2
+        code=1
+        continue
+    fi
+    k=(kubectl --context "$contexte" --request-timeout=5s)
+    if ! "${k[@]}" get --raw /readyz >/dev/null 2>&1; then
+        # Sans argument : kind peut être en cours de démarrage, ignoré
+        if [ "$demandes" -gt 0 ]; then
+            echo "metrics-server : cluster injoignable : $contexte" >&2
+            code=1
+        fi
+        continue
+    fi
+    joignables=$((joignables + 1))
+    if "${k[@]}" get apiservice v1beta1.metrics.k8s.io >/dev/null 2>&1; then
+        echo "metrics-server : déjà présent : $contexte"
+        continue
+    fi
+    if "${k[@]}" apply -f "$MANIFESTE" >/dev/null &&
+        "${k[@]}" -n kube-system patch deployment metrics-server --type=json \
+            -p '[{"op":"add","path":"/spec/template/spec/containers/0/args/-","value":"--kubelet-insecure-tls"}]' >/dev/null &&
+        # Marque : make desinstaller ne retire que ce que devzone a installé
+        "${k[@]}" -n kube-system label deployment metrics-server devzone=installe --overwrite >/dev/null; then
+        echo "metrics-server : installé ($VERSION) : $contexte (métriques dans ~1 min)"
+    else
+        echo "metrics-server : échec de l'installation : $contexte" >&2
+        code=1
+    fi
+done
+
+if [ "$demandes" -eq 0 ] && [ "$joignables" -eq 0 ]; then
+    echo "metrics-server : aucun cluster local joignable ; après kind create cluster : bash .devcontainer/metrics-server.sh"
+fi
+exit "$code"

package/.devcontainer/post-create.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# Étapes qui ne peuvent pas être dans l'image (Dockerfile) :
+# - volumes montés au démarrage seulement
+# - npm fourni par la feature node, ajoutée après le Dockerfile
+set -euo pipefail
+
+# Volumes nommés créés en root → rendre au user vscode
+# (et ~/.config, créé par Docker pour monter ~/.config/opencode)
+sudo chown -R vscode:vscode /home/vscode/.m2 /home/vscode/.local /home/vscode/.claude \
+    /home/vscode/.config/opencode /home/vscode/.config/gh /home/vscode/.config/git \
+    /home/vscode/.config/devzone
+sudo chown vscode:vscode /home/vscode/.config
+
+# Git : dépôts du conteneur déclarés sûrs (leur propriétaire peut différer de
+# l'utilisateur qui lance git : volumes, Docker Desktop, outils lancés à part),
+# et accès à GitHub par le jeton de gh, conservé dans son volume (https, même
+# pour les remotes en git@github.com:, sans clé ssh à recopier)
+# Réglages de la machine dans ~/.gitconfig du conteneur (recréé à chaque
+# rebuild) : sans ce fichier, git config --global (et repowarden install)
+# écriraient dans ~/.config/git/config, le volume de l'identité, où ils
+# s'accumuleraient d'un rebuild à l'autre
+touch "$HOME/.gitconfig"
+# Volume touché par une version antérieure : seuls ces réglages en sont
+# retirés, l'identité et tout autre réglage sont conservés
+volume="$HOME/.config/git/config"
+if [ -f "$volume" ]; then
+    retirer() { git config --file "$volume" --unset-all "$@" 2>/dev/null || true; }
+    retirer safe.directory '^/workspaces/devzone'
+    retirer credential.https://github.com.helper
+    retirer url.https://github.com/.insteadOf
+    retirer core.hooksPath 'repowarden'
+    retirer alias.cc 'repowarden'
+    retirer repowarden.lang
+fi
+git config --global --add safe.directory /workspaces/devzone
+git config --global --add safe.directory '/workspaces/devzone/workspace/*'
+git config --global --replace-all credential.https://github.com.helper ''
+git config --global --add credential.https://github.com.helper '!gh auth git-credential'
+git config --global url.https://github.com/.insteadOf git@github.com:
+
+# repowarden, version figée (il installe des hooks git globaux) ; mettre à jour
+# en changeant la version ici, puis Rebuild Container
+npm install -g repowarden@4.9.1
+repowarden install --global --lang fr
+
+# Modules facultatifs (assistants IA, Kubernetes) : commande devzone, état
+# gardé dans le volume devzone-config ; installe ce qui est actif
+sudo ln -sf /workspaces/devzone/.devcontainer/devzone /usr/local/bin/devzone
+devzone appliquer
+
+# Ce qui reste à faire (identité git, GitHub, modules) : récapitulatif de
+# devzone, affiché à chaque démarrage (demarrage.sh)
+
+recap="java $(java -version 2>&1 | head -1 | cut -d'"' -f2), node $(node -v), python $(python3 --version | cut -d' ' -f2), repowarden $(repowarden --version)"
+! command -v claude >/dev/null || recap+=", claude $(claude --version | cut -d' ' -f1)"
+! command -v opencode >/dev/null || recap+=", opencode $(opencode --version)"
+echo "devzone prêt : $recap"

package/.gitattributes

@@ -0,0 +1,5 @@
+# Scripts lancés dans le conteneur Linux : fins de ligne LF même sur un
+# checkout Windows (bash échoue sur les CRLF)
+*.sh        text eol=lf
+Dockerfile  text eol=lf
+Makefile    text eol=lf