# Memento - Guide de deploiement complet

## Table des matieres
1. [Architecture](#architecture)
2. [Setup du serveur 192.168.1.190](#setup-serveur)
3. [Installation de Gitea Runner](#gitea-runner)
4. [CI/CD automatique](#cicd)
5. [Nginx reverse proxy](#nginx)
6. [Checklist](#checklist)

---

## Architecture

```
Internet/LAN
     |
  [Nginx] ── port 80/443 ── notes.parsanet.org
     |
     ├── / ──► [memento-web] ── port 3000 ── Next.js App
     |
     └── /mcp ──► [memento-mcp] ── port 3001 ── MCP Server (SSE)
                     |
                  [postgres] ── port 5432 (127.0.0.1 seulement)

=== Machine 192.168.1.190 ===
  - Docker + Docker Compose (les 3 conteneurs)
  - act_runner (Gitea Runner) --> build + deploy en local
  - Nginx reverse proxy

=== Serveur Gitea (gitea.parsanet.org) ===
  - Gitea seulement (pas de runner)
  - Envoie les events push au runner via API
```

Le Runner est installe sur **192.168.1.190** directement. Pas besoin de SSH.

---

## Setup serveur

### 1. Creer l'utilisateur de deploiement

```bash
# Sur 192.168.1.190, en root :
useradd -m -s /bin/bash memento-deploy
usermod -aG docker memento-deploy
mkdir -p /opt/memento
chown memento-deploy:memento-deploy /opt/memento
```

### 2. Cloner le repo

```bash
su - memento-deploy
cd /opt/memento
git clone https://gitea.parsanet.org/sepehr/Momento.git .
git config credential.helper store
# Le premier pull demandera les identifiants Gitea
```

### 3. Generer le .env.docker

```bash
cd /opt/memento
bash scripts/deploy.sh --full
```

Le script demande interactivement :
- URL (mettre `http://192.168.1.190` ou `http://notes.parsanet.org`)
- Provider AI + cle API
- Email (optionnel)

Il genere automatiquement NEXTAUTH_SECRET et POSTGRES_PASSWORD.

### 4. Premier deploiement

```bash
cd /opt/memento
bash scripts/deploy.sh --build
docker compose ps
# Les 3 conteneurs doivent etre "healthy"
```

### 5. Creer le premier admin

```bash
# S'inscrire sur http://192.168.1.190/register
# Puis promouvoir en admin :
docker compose exec -T postgres psql -U memento -d memento \
  -c "UPDATE \"User\" SET role='ADMIN' WHERE email='VOTRE_EMAIL';"
```

---

## Gitea Runner

### 1. Activer Actions dans Gitea

Dans `app.ini` du serveur Gitea :

```ini
[actions]
ENABLED = true
```

Redemarrer Gitea.

### 2. Recuperer le token d'enregistrement

Aller sur : **gitea.parsanet.org > Momento > Settings > Actions > Runners > "New Runner"**
Copier le token affiche.

### 3. Installer act_runner sur 192.168.1.190

```bash
# Sur 192.168.1.190, en root :

# Telecharger
wget https://gitea.com/gitea/act_runner/releases/latest/download/act_runner-linux-amd64
chmod +x act_runner-linux-amd64
mv act_runner-linux-amd64 /usr/local/bin/act_runner

# Verifier
act_runner --version

# Generer la config
mkdir -p /etc/act_runner
act_runner generate-config > /etc/act_runner/config.yaml
```

### 4. Enregistrer le runner

```bash
act_runner register \
  --no-interactive \
  --instance https://gitea.parsanet.org \
  --token VOTRE_TOKEN_ICI \
  --name memento-deploy \
  --labels "ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest,docker-host:host"
```

Les labels sont importants :
- `ubuntu-latest` : pour les jobs dans un conteneur Docker (checkout, etc.)
- `docker-host` : pour les jobs directement sur la machine (acces Docker)

### 5. Creer le service systemd

```bash
cat > /etc/systemd/system/gitea-runner.service << 'EOF'
[Unit]
Description=Gitea Actions Runner
After=network.target docker.service
Requires=docker.service

[Service]
Type=simple
User=memento-deploy
WorkingDirectory=/home/memento-deploy
ExecStart=/usr/local/bin/act_runner daemon --config /etc/act_runner/config.yaml
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable gitea-runner
systemctl start gitea-runner
systemctl status gitea-runner
```

### 6. Verifier

```bash
systemctl status gitea-runner
# Doit etre "active (running)"

# Sur gitea.parsanet.org > Momento > Settings > Actions > Runners
# Le runner "memento-deploy" doit apparaitre avec le label "docker-host"
```

---

## CI/CD

Le workflow est dans `.gitea/workflows/deploy.yaml`.

### Ce qui se passe a chaque push sur `main` :

1. Gitea notifie le Runner sur 192.168.1.190
2. Le Runner checkout le code
3. `rsync` vers `/opt/memento/` (exclut node_modules, .git, .next)
4. `docker compose build --parallel`
5. `docker compose up -d --remove-orphans`
6. Attend que les 3 conteneurs soient healthy
7. Nettoie les vieilles images

### Pas de secrets a configurer

Le `.env.docker` est deja sur le serveur. Le workflow n'a pas besoin de secrets SSH
puisque tout se passe en local sur 192.168.1.190.

### Tester le CI/CD

```bash
# Faire un push test depuis votre machine :
echo "# test" >> README.md
git add README.md
git commit -m "test: CI/CD deploy"
git push origin main

# Verifier sur gitea.parsanet.org > Momento > Actions
# Le job doit apparaitre et se terminer en succes
```

---

## Nginx

### Installation

```bash
apt install -y nginx
```

### Configuration

```bash
cat > /etc/nginx/sites-available/memento << 'EOF'
server {
    listen 80;
    server_name notes.parsanet.org 192.168.1.190;

    # Next.js app
    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400;
    }

    # MCP Server (SSE - long-lived connections)
    location /mcp {
        proxy_pass http://127.0.0.1:3001/mcp;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400;
        proxy_buffering off;
        proxy_cache off;
    }
}
EOF

ln -sf /etc/nginx/sites-available/memento /etc/nginx/sites-enabled/memento
rm -f /etc/nginx/sites-enabled/default
nginx -t && systemctl reload nginx
```

### HTTPS (plus tard)

```bash
apt install -y certbot python3-certbot-nginx
certbot --nginx -d notes.parsanet.org

# Puis mettre a jour NEXTAUTH_URL :
cd /opt/memento
nano .env.docker
# Changer : NEXTAUTH_URL="https://notes.parsanet.org"
docker compose restart memento-note
```

---

## Checklist

### Premier deploiement

- [ ] Creer `memento-deploy` sur 192.168.1.190
- [ ] Cloner le repo dans `/opt/memento`
- [ ] `bash scripts/deploy.sh --full`
- [ ] 3 conteneurs healthy
- [ ] S'inscrire, puis promouvoir en ADMIN via SQL
- [ ] Configurer Nginx

### CI/CD (une seule fois)

- [ ] Activer Actions dans Gitea (`app.ini`)
- [ ] Installer `act_runner` sur 192.168.1.190
- [ ] Enregistrer avec le token Gitea
- [ ] Creer le service systemd
- [ ] Verifier le runner apparait dans Gitea
- [ ] Push test > verifier dans Actions

### Apres chaque push sur main (automatique)

- [ ] Le Runner detecte le push
- [ ] rsync vers /opt/memento
- [ ] docker compose build + up
- [ ] Conteneurs healthy