Merge remote-tracking branch 'origin/main' into arcodange/mirror-depots-perso

# Conflicts:
#	ansible/arcodange/factory/inventory/group_vars/all/gitea.yml

ansible/arcodange/factory/roles/ci_base_image/defaults/main.yml

@@ -0,0 +1,62 @@
+---
+# Image de base des jobs CI lourds (Node + Bun + Chromium), construite SUR CHAQUE
+# machine qui héberge un runner Gitea.
+#
+# POURQUOI CONSTRUIRE PLUTÔT QUE POUSSER (mesuré le 2026-07-29, kadans#224/#225) :
+# une image Node + Playwright + Chromium pèse 3,81 Go, avec une couche unique de
+# 1,36 Go. Son `docker push` vers gitea.arcodange.lab casse en
+# « connection reset by peer » : 7 couches passent, 3 sont réinitialisées et
+# retentées 50 fois avant abandon. À titre de comparaison,
+# `runner-images:ubuntu-latest-ca` (534,7 Mo, plus grosse couche 261 Mo) passe
+# sans problème — la limite est donc entre 261 Mo et ~500 Mo par couche.
+#
+# Construire localement supprime le problème : aucune couche ne traverse le
+# réseau. Et comme `capacity: 1` par runner (03_cicd.yml), le parallélisme vient
+# de PLUSIEURS machines — l'image doit donc exister sur CHACUNE d'elles, ce que
+# ce rôle garantit.
+
+# On hérite de l'image de runner maison : elle porte DÉJÀ le certificat de la CA
+# interne (step-ca). Repartir de `node:20-bookworm` obligerait à réinjecter le CA
+# à la main, et un job qui parle à gitea.arcodange.lab échouerait en TLS.
+ci_base_image_from: gitea.arcodange.lab/arcodange-org/runner-images:ubuntu-latest-ca
+
+ci_base_image_name: ci-node-playwright
+ci_base_image_tag: latest
+
+# ⚠ Ces versions doivent suivre le `bun.lock` du dépôt kadans. Le dépôt s'en
+# protège : l'image écrit ce qu'elle a cuit dans /etc/ci-base.versions, et la CI
+# de kadans CONFRONTE ce fichier à son lockfile pour échouer FORT plutôt que de
+# dériver en silence (des navigateurs qui ne correspondent plus au client
+# Playwright donnent « Executable doesn't exist », loin de la cause).
+ci_base_image_bun_version: '1.3.14'
+ci_base_image_playwright_version: '1.61.1'
+
+# ⚠ NODE 20 EST OBLIGATOIRE, ET CE N'EST PAS UN CONFORT.
+# `runner-images:ubuntu-latest-ca` livre Node **18** (v18.20.8, constaté en
+# lançant l'image). Or `nuxi` importe `node:util.styleText`, absent de Node 18 :
+# c'est la raison d'être du `container: node:20-bookworm` que portait la CI de
+# kadans, et que son CLAUDE.md interdit de retirer. Sans cette surcharge, tout
+# job Nuxt basculé sur cette image casse au premier build, sur un message qui
+# parle d'un import introuvable et jamais d'une version de Node.
+ci_base_image_node_major: 20
+
+# Épinglage par conteneur factice — remède décrit par
+# docs/adr/20260407-docker-storage-gitea-runner.md §1, jusqu'ici resté à l'état
+# de proposition (system_docker.yml n'applique que le data-root et les log-opts).
+# Sans lui, le ramasse-miettes de Docker supprime l'image dès que le disque se
+# remplit, et la CI casse sur une image manquante — panne déjà constatée sur les
+# images de runner elles-mêmes.
+ci_base_image_pin: true
+
+# Où le contexte de build est déposé SUR LA MACHINE CIBLE. `docker_image_build`
+# s'exécute sur la cible : son `path:` est un chemin de la cible, jamais du
+# contrôleur. (Première version : `{{ role_path }}/files/` → le playbook mourait
+# sur « is not an existing directory », sur les deux hôtes.)
+ci_base_image_contexte: /tmp/ci-base-image
+
+# Reconstruire même si l'image existe déjà. ⚠ Inutile pour un simple changement
+# du Dockerfile : le rôle le détecte et reconstruit tout seul (voir tasks/).
+# Ce drapeau sert aux cas que le Dockerfile ne montre pas — une montée de
+# `bun.lock` côté kadans, par exemple, qui change les VERSIONS attendues sans
+# changer le fichier.
+ci_base_image_force_rebuild: false

ansible/arcodange/factory/roles/ci_base_image/files/Dockerfile

@@ -0,0 +1,101 @@
+# Image de base des jobs CI lourds — construite SUR CHAQUE machine à runner.
+#
+# Elle cuit une fois pour toutes ce que chaque exécution de CI réinstallait.
+# Mesures du dépôt kadans (run 628, 2026-07-29, runner ARM64 2 vCPU / 3 Gio) :
+#
+#   npm install -g bun                          →    8,6 s par run
+#   playwright install --with-deps chromium     →  104,0 s par run  (apt-get)
+#                                                  ────────
+#                                                   112,6 s jetées à CHAQUE run,
+#                                                   sur le job du chemin critique
+#
+# Le cache `actions/cache` ne peut rien contre ces 104 s : il couvre le
+# NAVIGATEUR (299 Mo déjà mis en cache), pas ses dépendances SYSTÈME —
+# `--with-deps` relance `apt-get` quoi qu'il arrive.
+#
+# ⚠ ON HÉRITE DE L'IMAGE DE RUNNER MAISON, ET C'EST ESSENTIEL : elle porte le
+# certificat de la CA interne (step-ca). Une image repartant de `node:20-bookworm`
+# ne ferait pas confiance à gitea.arcodange.lab, et tout job qui lui parle
+# échouerait en TLS.
+ARG CI_BASE_FROM=gitea.arcodange.lab/arcodange-org/runner-images:ubuntu-latest-ca
+FROM ${CI_BASE_FROM}
+
+ARG BUN_VERSION=1.3.14
+ARG PLAYWRIGHT_VERSION=1.61.1
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Chemin des navigateurs, figé et hors du HOME : un job qui tourne sous un autre
+# utilisateur doit les retrouver.
+ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+
+# ══════════════════════════════════════════════════════════════════════════
+# ⚠ TROIS `RUN` SÉPARÉS, ET C'EST LE POINT DE CONCEPTION DE CE FICHIER.
+#
+# La première version faisait `npm i -g bun` puis `playwright install --with-deps`
+# en deux couches, dont une de 1,36 Go — irrecevable par le registre. Ici, même
+# si l'on décidait un jour de pousser cette image, chaque couche reste du même
+# ordre de grandeur que celles qui passent déjà (261 Mo pour la plus grosse de
+# `runner-images:ubuntu-latest-ca`).
+#
+# Ne pas fusionner ces `RUN` pour « gagner une couche » : le gain serait nul et
+# la couche redeviendrait impossible à transporter.
+# ══════════════════════════════════════════════════════════════════════════
+
+# 0. NODE 20, ET C'EST OBLIGATOIRE — pas une préférence.
+#
+# ⚠ `runner-images:ubuntu-latest-ca` livre **Node 18** (v18.20.8, vérifié en le
+# lançant). Or `nuxi` importe `node:util.styleText`, ABSENT de Node 18 : c'est la
+# raison d'être du `container: node:20-bookworm` que la CI de kadans portait, et
+# que son `CLAUDE.md` interdit explicitement de retirer.
+#
+# Sans cette couche, une CI qui bascule sur cette image casse au premier `nuxt
+# build` — et le message parle d'un import introuvable, pas d'une version de Node.
+# Le défaut a été trouvé en CONSTRUISANT l'image puis en lançant `node --version`
+# dedans ; aucune lecture du Dockerfile ne l'aurait montré.
+# ⚠⚠ ET INSTALLER NE SUFFIT PAS — il faut aussi que `node` RÉSOLVE vers le bon.
+# Constaté en lançant l'image : après l'installation de Node 20 par apt,
+# `node --version` rendait toujours **v18.20.8**, parce que l'image de base
+# précuit un node pour le toolcache d'act et le met EN TÊTE du PATH :
+#
+#   which node → /opt/acttoolcache/node/18.20.8/arm64/bin/node
+#   PATH       → /opt/acttoolcache/node/18.20.8/arm64/bin:/usr/local/sbin:/usr/bin:…
+#   /usr/bin/node --version → v20.20.2   ← le bon, mais il PERD
+#
+# On retire donc l'entrée 18 du toolcache : le segment de PATH devient inexistant
+# (inoffensif) et la résolution retombe sur /usr/bin/node, en 20.
+# ⚠ Conséquence assumée : `actions/setup-node` ne trouvera plus de Node 18
+# préinstallé dans cette image. Aucun workflow de kadans ne l'utilise, et l'image
+# n'est servie qu'aux jobs qui DEMANDENT le label `ci-node-playwright`.
+ARG NODE_MAJOR=20
+RUN curl -fsSL "https://deb.nodesource.com/setup_${NODE_MAJOR}.x" -o /tmp/nodesource.sh \
+    && bash /tmp/nodesource.sh \
+    && apt-get install -y --no-install-recommends nodejs \
+    && rm -f /tmp/nodesource.sh \
+    && rm -rf /var/lib/apt/lists/* \
+    && rm -rf /opt/acttoolcache/node \
+    && echo "node résolu : $(which node) $(node --version)" \
+    && node --version | grep -q "^v${NODE_MAJOR}\."
+
+# 1. Bun (~180 Mo) — installé APRÈS Node 20, pour que son npm global soit celui
+#    de Node 20 et non celui de Node 18.
+RUN npm install -g "bun@${BUN_VERSION}" \
+    && npm cache clean --force
+
+# 2. Les dépendances SYSTÈME de Chromium — c'est CETTE couche qui rachète les
+#    104 s d'apt-get de chaque run.
+RUN npx --yes "playwright@${PLAYWRIGHT_VERSION}" install-deps chromium \
+    && rm -rf /var/lib/apt/lists/*
+
+# 3. Le navigateur lui-même, séparé de ses dépendances système : les deux ne
+#    bougent pas au même rythme, et Docker ne réinvalide alors que la bonne.
+RUN npx --yes "playwright@${PLAYWRIGHT_VERSION}" install chromium
+
+# La trace opposable de ce qui est réellement cuit ici. La CI de kadans la LIT et
+# la confronte à son `bun.lock` : une dérive de version doit échouer FORT, avec sa
+# cause, plutôt que de se manifester par un « Executable doesn't exist » à
+# vingt minutes de là.
+RUN printf 'node=%s\nbun=%s\nplaywright=%s\n' \
+      "$(node --version)" "$(bun --version)" "${PLAYWRIGHT_VERSION}" \
+      > /etc/ci-base.versions \
+    && cat /etc/ci-base.versions

ansible/arcodange/factory/roles/ci_base_image/tasks/main.yml

@@ -0,0 +1,93 @@
+---
+# Construit l'image de base des jobs CI sur la machine courante, puis l'épingle.
+#
+# À exécuter sur les MÊMES hôtes que le runner Gitea (03_cicd.yml) : comme
+# `capacity: 1`, le parallélisme vient de plusieurs machines, et un job qui
+# atterrit sur une machine sans l'image échouerait AVANT sa première étape —
+# `runs-on`/`container:` est résolu par le runner, pas par le workflow.
+
+# ══════════════════════════════════════════════════════════════════════════
+# ⚠ LE CONTEXTE DE BUILD DOIT ÊTRE SUR LA MACHINE, PAS SUR LE CONTRÔLEUR.
+#
+# `docker_image_build` s'exécute SUR LA CIBLE : son `path:` est un chemin de la
+# cible. La première version passait `{{ role_path }}/files/` — un chemin du
+# CONTRÔLEUR — et le playbook mourait sur les deux hôtes :
+#
+#   "/Users/…/roles/ci_base_image/files/" is not an existing directory
+#
+# Le motif venait du rôle `playwright`, qui l'utilise LÉGITIMEMENT parce qu'il
+# construit en local ; recopié tel quel pour un build distant, il ne peut pas
+# marcher. On copie donc le contexte d'abord.
+# ══════════════════════════════════════════════════════════════════════════
+- name: Créer le répertoire de contexte de build sur la machine
+  ansible.builtin.file:
+    path: '{{ ci_base_image_contexte }}'
+    state: directory
+    mode: '0755'
+
+- name: Déposer le Dockerfile sur la machine
+  ansible.builtin.copy:
+    src: Dockerfile
+    dest: '{{ ci_base_image_contexte }}/Dockerfile'
+    mode: '0644'
+  register: ci_base_image_dockerfile
+
+- name: Construire {{ ci_base_image_name }}:{{ ci_base_image_tag }}
+  community.docker.docker_image_build:
+    name: '{{ ci_base_image_name }}'
+    tag: '{{ ci_base_image_tag }}'
+    path: '{{ ci_base_image_contexte }}'
+    # RECONSTRUCTION CONDITIONNELLE : `never` en régime normal (le playbook ne
+    # rebâtit pas 3,3 Go à chaque passage), mais `always` dès que le Dockerfile
+    # a CHANGÉ sur la machine — c'est ce qui rend l'ajout d'une bibliothèque
+    # effectif sans avoir à penser à un drapeau.
+    rebuild: >-
+      {{ "always"
+         if (ci_base_image_force_rebuild or ci_base_image_dockerfile is changed)
+         else "never" }}
+    args:
+      CI_BASE_FROM: '{{ ci_base_image_from }}'
+      NODE_MAJOR: '{{ ci_base_image_node_major }}'
+      BUN_VERSION: '{{ ci_base_image_bun_version }}'
+      PLAYWRIGHT_VERSION: '{{ ci_base_image_playwright_version }}'
+  register: ci_base_image_build
+
+# ⚠ CE CONTENEUR NE TOURNE JAMAIS — il ne sert qu'à référencer l'image.
+# Remède décrit par docs/adr/20260407-docker-storage-gitea-runner.md §1, resté
+# jusqu'ici à l'état de proposition : `system_docker.yml` n'applique que le
+# data-root sur disque externe et les log-opts. Sans épinglage, le ramasse-miettes
+# de Docker supprime l'image dès que le disque se remplit — panne DÉJÀ constatée
+# sur les images de runner elles-mêmes, et qui casse la CI de tous les dépôts.
+#
+# `state: present` (et non `started`) : Docker considère l'image comme utilisée
+# tant qu'un conteneur la référence, même à l'arrêt. Aucun CPU, aucune mémoire.
+- name: Épingler {{ ci_base_image_name }} contre le ramasse-miettes Docker
+  community.docker.docker_container:
+    name: 'pin-{{ ci_base_image_name }}'
+    image: '{{ ci_base_image_name }}:{{ ci_base_image_tag }}'
+    state: present
+    command: ['sh', '-c', 'sleep infinity']
+    auto_remove: false
+    restart_policy: 'no'
+  when: ci_base_image_pin
+
+# Contrôle de sortie : on VÉRIFIE que l'image répond, plutôt que de supposer que
+# le build a suffi. Une image construite mais dont `bun` n'est pas dans le PATH
+# passerait le build et casserait tous les jobs.
+- name: Vérifier que l'image livre bien Node {{ ci_base_image_node_major }}, bun et chromium
+  ansible.builtin.command:
+    cmd: >-
+      docker run --rm {{ ci_base_image_name }}:{{ ci_base_image_tag }}
+      sh -c "node --version && bun --version && ls /ms-playwright && cat /etc/ci-base.versions"
+  register: ci_base_image_check
+  changed_when: false
+  # ⚠ La version de Node est VÉRIFIÉE, pas supposée : l'image de base en livre
+  # une trop ancienne (18), et une régression silencieuse ici casserait tout job
+  # Nuxt sur un message qui ne nomme pas la cause.
+  failed_when: >-
+    ci_base_image_check.rc != 0
+    or ('v' ~ ci_base_image_node_major ~ '.') not in ci_base_image_check.stdout
+
+- name: Ce que l'image contient réellement
+  ansible.builtin.debug:
+    var: ci_base_image_check.stdout_lines