# Big Brother

Tableau de bord web pour gérer et surveiller le VPS : serveur, conteneurs, sites, projets, Caddy et sauvegardes.

- **API** : AdonisJS 7 (`api/`), base SQLite.
- **Interface** : Angular 22 (`web/`), servie par l'API (un seul conteneur, un seul domaine).

> « Big Brother » est un nom provisoire. Pour le changer, il suffit de modifier `container_name` dans le `docker-compose.yml`, le bloc Caddy et `APP_URL`.

## Fonctionnalités

| Page | Contenu |
|---|---|
| Vue d'ensemble | Processeur, mémoire, disque, réseau, charge, durée depuis le démarrage. Graphiques en direct (toutes les 5 s) et historique sur 1 h, 24 h, 7 j et 30 j. État des conteneurs, des sites et des sauvegardes, dernières actions. |
| Conteneurs | Tous les conteneurs avec leur état, CPU et mémoire. Alerte quand un port est publié sur Internet (seul Caddy devrait l'être). Logs en direct (filtre, pause, téléchargement). Démarrer, arrêter, redémarrer. **Édition du `docker-compose.yml`** du conteneur : le fichier est vérifié par `docker compose config` avant d'être écrit, puis appliqué avec `docker compose up -d` si demandé. Si `up` échoue, l'ancienne version est remise en place et relancée. Historique des 30 dernières versions de chaque fichier. Le compose du tableau de bord lui-même reste en lecture seule. |
| Sites | Les domaines du Caddyfile, vérifiés chaque minute : état, temps de réponse, disponibilité sur 24 h et 7 j, expiration du certificat HTTPS, incidents. |
| Projets | Les projets de `/srv` (même organisation que la procédure). Pour chacun : dépôt git (version en ligne, nouveautés), mise à jour (`git pull` puis recréation des conteneurs), retour à un ancien commit, redémarrage, arrêt, mise à jour des images. **Création de projet** Node, Adonis, WordPress ou site statique : dossier, clone, `.env`, base MariaDB dédiée, `docker-compose.yml` (templates de la procédure), démarrage et bloc Caddy. |
| Caddy | Éditeur du Caddyfile. Si Caddy refuse la nouvelle configuration, l'ancien fichier est remis en place automatiquement. Historique des 50 dernières versions, restaurables. |
| Sauvegardes | Export de toutes les bases MariaDB et archive de `/srv` (sans `node_modules`). Sauvegarde automatique quotidienne en option, téléchargement depuis la page. |
| Journal | Toutes les actions et connexions, avec la sortie des commandes. |

## Sécurité

Le conteneur a accès au socket Docker et à `/srv` en écriture : **c'est l'équivalent d'un accès root au serveur**. Les protections en place :

- **Comptes** : aucune page d'inscription. Les comptes se créent uniquement en ligne de commande sur le VPS.
- **Connexion** :
  - mot de passe d'au moins 12 caractères ;
  - code de double authentification (TOTP), refusé s'il a déjà servi ;
  - 5 essais ratés par IP, puis blocage pendant 15 minutes.
- **Session** : cookies `httpOnly`, `Secure` et `SameSite=Strict`, session de 12 h, protection CSRF.
- **En-têtes** : Content-Security-Policy stricte (aucun script externe ni en ligne), HSTS, `X-Frame-Options: DENY`.
- **Réseau** : aucun port publié, l'accès passe uniquement par Caddy. Le secret 2FA est chiffré avec `APP_KEY`.
- **Traçabilité** : chaque action est enregistrée dans le journal (qui, quand, depuis quelle IP, avec la sortie).

## Mise en ligne sur le VPS

Le projet suit la procédure : un dossier contenant `docker-compose.yml`, avec le dépôt cloné dans `project/`.

1. Créer le dépôt sur `git.davor-nucleus.fr` et y pousser ce dossier.

2. Dans la zone DNS de `davor-nucleus.fr` (chez OVH), ajouter un enregistrement `A` : sous-domaine `big-brother`, cible `51.68.230.117`. Sans enregistrement wildcard `*.davor-nucleus.fr`, chaque sous-domaine a besoin du sien, et Caddy ne peut pas obtenir de certificat HTTPS tant qu'il n'existe pas.

3. Sur le VPS :

   ```bash
   mkdir -p /srv/fullstack/big-brother /root/backups
   cd /srv/fullstack/big-brother
   git clone https://git.davor-nucleus.fr/Rutra/big-brother.git project
   cp project/deploy/docker-compose.yml .
   cp project/deploy/.env.example .env
   nano .env
   ```

   Dans `.env`, remplir au minimum :
   - `APP_KEY` : générer la valeur avec `openssl rand -base64 24` ;
   - `APP_URL` ;
   - `BACKUP_DAILY_AT`.

   Vérifier aussi `CADDY_CONTAINER` et `MARIADB_CONTAINER` : ce sont les noms de tes conteneurs Caddy et MariaDB.

4. Construire et lancer :

   ```bash
   docker compose up -d --build
   docker compose logs -f
   ```

5. Créer ton compte. La commande affiche un QR code à scanner avec ton application de double authentification (Aegis, 2FAS, Google Authenticator…) :

   ```bash
   docker exec -it big-brother node ace user:create
   ```

6. Ajouter le bloc à `/srv/caddy/Caddyfile` (voir `deploy/Caddyfile.block`), puis recharger Caddy :

   ```caddyfile
   big-brother.davor-nucleus.fr {
   	reverse_proxy big-brother:3333
   }
   ```

   ```bash
   docker exec caddy caddy reload --config /etc/caddy/Caddyfile
   ```

### Ce que monte le `docker-compose.yml`

| Volume | Rôle |
|---|---|
| `./data:/data` | Base SQLite (comptes, historique, journal) |
| `/var/run/docker.sock` | Conteneurs, logs, actions, rechargement de Caddy, MariaDB |
| `/srv:/srv` | Projets et Caddyfile, **au même chemin** que sur le VPS (nécessaire pour `docker compose`) |
| `/proc:/host/proc:ro` | Métriques du serveur (et pas seulement celles du conteneur) |
| `/root/backups:/backups` | Sauvegardes |

## Mettre à jour Big Brother

Depuis le tableau de bord : **Projets → big-brother → Mettre à jour**. La recréation du conteneur se fait dans un conteneur à part (`docker:cli`) pour ne pas être interrompue par l'arrêt du tableau de bord. La page se reconnecte d'elle-même.

À la main :

```bash
cd /srv/fullstack/big-brother
git -C project pull --ff-only
docker compose up -d --build
```

## Gestion des comptes

```bash
docker exec -it big-brother node ace user:create
docker exec -it big-brother node ace user:password <identifiant>
docker exec -it big-brother node ace user:reset-2fa <identifiant>   # téléphone perdu
```

## Variables d'environnement

| Variable | Rôle |
|---|---|
| `APP_KEY` | Clé secrète (cookies, chiffrement des secrets 2FA). À ne jamais perdre ni partager. |
| `APP_URL` | URL publique du tableau de bord |
| `TZ` | Fuseau horaire (heure de la sauvegarde automatique) |
| `DB_PATH` | Fichier SQLite (`/data/db.sqlite3`) |
| `SRV_ROOT` | Racine des projets (`/srv`) |
| `HOST_PROC` | `/proc` du serveur monté dans le conteneur (`/host/proc`) |
| `DISK_PATH` | Chemin dont le disque est surveillé (`/srv`) |
| `BACKUP_DIR` | Dossier des sauvegardes dans le conteneur (`/backups`) |
| `DOCKER_SOCKET` | Socket Docker |
| `CADDY_CONTAINER` | Nom du conteneur Caddy |
| `CADDYFILE_PATH` | Caddyfile vu par le tableau de bord (`/srv/caddy/Caddyfile`) |
| `CADDY_CONFIG_PATH` | Caddyfile vu depuis le conteneur Caddy (`/etc/caddy/Caddyfile`) |
| `MARIADB_CONTAINER` | Nom du conteneur MariaDB (son mot de passe root est lu dans le conteneur, via `MARIADB_ROOT_PASSWORD`) |
| `BASE_DOMAIN` | Domaine proposé pour les nouveaux projets (`<nom>.<BASE_DOMAIN>`) |
| `BACKUP_DAILY_AT` | Heure de la sauvegarde automatique (`03:00`). Vide = pas de sauvegarde automatique. |
| `BACKUP_KEEP` | Nombre de sauvegardes gardées pour chaque type (7) |

## Développement local

Prérequis : Node 24. Docker Desktop est facultatif : sans lui, les pages Conteneurs et les actions affichent « Docker injoignable ».

```bash
# API (http://localhost:3333)
cd api
npm install
cp .env.example .env
```

Dans `api/.env`, adapter les valeurs pour le local :

- `NODE_ENV=development`, `HOST=localhost`, `APP_KEY` : une valeur quelconque ;
- `SRV_ROOT=../dev-srv` : faux `/srv` fourni pour le développement ;
- `CADDYFILE_PATH=../dev-srv/caddy/Caddyfile` ;
- `BACKUP_DIR=../dev-backups` ;
- supprimer les lignes `DB_PATH`, `HOST_PROC` et `DOCKER_SOCKET`.

Puis :

```bash
node ace migration:run
node ace user:create
npm run dev
```

```bash
# Interface (http://localhost:4200, les appels /api passent par le proxy vers 3333)
cd web
npm install
npm start
```

Pour tester l'interface compilée servie par l'API : `npm run build` dans `web/`, puis copier `web/dist/web/browser/` dans `api/public/`.

## Limites

- **Pas d'alerte** : il faut consulter le tableau de bord.
- **Vérifications depuis le VPS** : elles détectent un conteneur arrêté ou une erreur de configuration, pas une panne complète du serveur (le tableau de bord serait lui aussi hors ligne).
- **Sites statiques** : le build se fait sur le PC puis s'envoie avec `scp` (la page du projet affiche les commandes).
- **Création de projet** : en cas d'échec à une étape, les étapes déjà faites ne sont pas annulées. Le journal indique où ça s'est arrêté.