agenthub/docs/FORGEJO-INSTALL.md

# Installation Forgejo sur 192.168.9.25

Guide complet pour installer Forgejo (Git self-hosted) sur le serveur Coolify.

## Méthode 1: Installation via Coolify (Recommandée)

### Prérequis
- ✅ Base de données PostgreSQL créée (UUID: `rffv6pfwpdftlhunzoishduj`)
- Accès à Coolify: https://coolify.barodine.net

### Étapes

#### 1. Créer le service Forgejo dans Coolify

1. Ouvrir Coolify: https://coolify.barodine.net
2. Aller dans le projet **"Barodine IA"**
3. Cliquer sur **"+ New Resource"** → **"Service"** → **"Docker Image"**

#### 2. Configuration du service

**Informations de base:**
- **Name**: `forgejo`
- **Image**: `codeberg.org/forgejo/forgejo:9`
- **Port**: `3000`

**Domain:**
- **FQDN**: `git.barodine.net` (ou autre domaine souhaité)
- **Enable HTTPS**: ✅ Oui

**Volumes (Storage):**
Ajouter un volume persistant:
- **Source**: `/var/lib/forgejo`
- **Destination**: `/data`

#### 3. Variables d'environnement

Ajouter ces variables dans l'onglet "Environment Variables":

```bash
# Base de données
FORGEJO__database__DB_TYPE=postgres
FORGEJO__database__HOST=rffv6pfwpdftlhunzoishduj:5432
FORGEJO__database__NAME=postgres
FORGEJO__database__USER=postgres
FORGEJO__database__PASSWD=UpW5nyYcNSy88bQiNppIRdFKrtul2Bu4hXzxitzcB4IHU9sAzGc2mkndvKdA1J42

# Configuration serveur
FORGEJO__server__DOMAIN=git.barodine.net
FORGEJO__server__ROOT_URL=https://git.barodine.net
FORGEJO__server__HTTP_PORT=3000
FORGEJO__server__PROTOCOL=http
FORGEJO__server__START_SSH_SERVER=true
FORGEJO__server__SSH_PORT=2222
FORGEJO__server__SSH_LISTEN_PORT=22

# Sécurité
FORGEJO__security__INSTALL_LOCK=false
FORGEJO__security__SECRET_KEY=changeme-generate-random-secret-key-here

# Service
FORGEJO__service__DISABLE_REGISTRATION=false
FORGEJO__service__REQUIRE_SIGNIN_VIEW=false
FORGEJO__service__ENABLE_NOTIFY_MAIL=false

# Session
FORGEJO__session__PROVIDER=memory
```

#### 4. Déployer

1. Cliquer sur **"Deploy"**
2. Attendre que le service démarre (~1-2 minutes)
3. Vérifier les logs dans l'onglet "Logs"

#### 5. Configuration initiale de Forgejo

1. Ouvrir https://git.barodine.net
2. Vous serez redirigé vers la page d'installation
3. Les paramètres DB sont déjà configurés via les env vars
4. Configurer:
   - **Site Title**: Barodine Git
   - **Admin Username**: admin (ou votre choix)
   - **Admin Password**: (choisir un mot de passe fort)
   - **Admin Email**: votre email
5. Cliquer sur **"Install Forgejo"**

#### 6. Activer SSH (optionnel)

Pour cloner/pousser via SSH:

1. Dans Coolify, aller dans **"Forgejo"** → **"Networking"**
2. Ajouter un **"TCP Port Mapping"**:
   - **Host Port**: `2222`
   - **Container Port**: `22`
3. Redémarrer le service

Cloner via SSH deviendra:
```bash
git clone ssh://git@git.barodine.net:2222/username/repo.git
```

---

## Méthode 2: Installation via Docker Compose (Alternative)

Si vous préférez une installation Docker Compose manuelle:

### 1. Se connecter au serveur

```bash
ssh user@192.168.9.25
```

### 2. Créer le répertoire de données

```bash
sudo mkdir -p /var/lib/forgejo
sudo chown -R 1000:1000 /var/lib/forgejo
```

### 3. Créer `docker-compose.yml`

```bash
cat > forgejo-compose.yml <<'EOF'
version: '3'

services:
  forgejo:
    image: codeberg.org/forgejo/forgejo:9
    container_name: forgejo
    restart: unless-stopped
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - FORGEJO__database__DB_TYPE=postgres
      - FORGEJO__database__HOST=rffv6pfwpdftlhunzoishduj:5432
      - FORGEJO__database__NAME=postgres
      - FORGEJO__database__USER=postgres
      - FORGEJO__database__PASSWD=UpW5nyYcNSy88bQiNppIRdFKrtul2Bu4hXzxitzcB4IHU9sAzGc2mkndvKdA1J42
      - FORGEJO__server__DOMAIN=git.barodine.net
      - FORGEJO__server__ROOT_URL=https://git.barodine.net
      - FORGEJO__server__HTTP_PORT=3000
    volumes:
      - /var/lib/forgejo:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2222:22"
    networks:
      - coolify
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.forgejo.rule=Host(\`git.barodine.net\`)"
      - "traefik.http.routers.forgejo.entrypoints=https"
      - "traefik.http.routers.forgejo.tls=true"
      - "traefik.http.routers.forgejo.tls.certresolver=letsencrypt"
      - "traefik.http.services.forgejo.loadbalancer.server.port=3000"

networks:
  coolify:
    external: true
EOF
```

### 4. Démarrer Forgejo

```bash
docker compose -f forgejo-compose.yml up -d
```

### 5. Vérifier les logs

```bash
docker logs -f forgejo
```

---

## Post-Installation

### 1. Créer le premier repository (AgentHub)

1. Se connecter à Forgejo: https://git.barodine.net
2. Cliquer sur **"+"** → **"New Repository"**
3. Configurer:
   - **Owner**: Votre username
   - **Repository Name**: `agenthub`
   - **Visibility**: Private (ou Public selon besoin)
   - **Initialize Repository**: ❌ Non (on va pusher le code existant)
4. Cliquer sur **"Create Repository"**

### 2. Configurer le remote Git local

```bash
cd /home/alexandre/.paperclip/instances/default/workspaces/8780faf8-03bb-45e9-989e-167eeb438b58/agenthub

# Supprimer l'ancien remote GitHub
git remote remove origin

# Ajouter le remote Forgejo
git remote add origin https://git.barodine.net/username/agenthub.git

# Pousser le code
git push -u origin main
```

### 3. Configurer Coolify pour déployer depuis Forgejo

1. Dans Coolify, créer une nouvelle **Application**
2. **Source**: Git Repository
3. **Git URL**: `https://git.barodine.net/username/agenthub.git`
4. **Branch**: `main`
5. **Build Pack**: Dockerfile
6. Configurer les variables d'environnement (voir section suivante)

---

## Configuration AgentHub sur Coolify

### Variables d'environnement

```bash
NODE_ENV=production
HOST=0.0.0.0
PORT=3000
LOG_LEVEL=info

# PostgreSQL (créer une nouvelle DB pour AgentHub)
POSTGRES_HOST=<db_uuid_here>
POSTGRES_PORT=5432
POSTGRES_USER=postgres
POSTGRES_PASSWORD=<db_password_here>
POSTGRES_DB=postgres

# Sécurité
JWT_SECRET=<générer_un_secret_32_chars>
ALLOWED_ORIGINS=https://agenthub.barodine.net
ENABLE_HSTS=true

# Features
FEATURE_MESSAGING_ENABLED=true
```

### Créer la base de données AgentHub

```bash
curl -X POST "$COOLIFY_API_URL/api/v1/databases/postgresql" \
  -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "server_uuid": "gw9o6m2ftfvx7g5guf82nkiq",
    "project_uuid": "x9fenmiro11hv1uqij88z88a",
    "environment_name": "production",
    "name": "agenthub-db",
    "description": "PostgreSQL database for AgentHub",
    "image": "postgres:16-alpine",
    "instant_deploy": true
  }'
```

---

## Webhooks et CI/CD

### Activer les webhooks Forgejo → Coolify

1. Dans Forgejo, aller dans le repo **agenthub** → **Settings** → **Webhooks**
2. Cliquer sur **"Add Webhook"** → **"Forgejo"**
3. Configurer:
   - **URL**: URL du webhook Coolify (voir dans l'app Coolify)
   - **HTTP Method**: POST
   - **Content Type**: application/json
   - **Trigger On**: Push events
4. Sauvegarder

Maintenant, chaque `git push` déclenchera un rebuild automatique dans Coolify!

---

## Résumé des URLs

| Service | URL | Port |
|---------|-----|------|
| Forgejo Web | https://git.barodine.net | 443 |
| Forgejo SSH | git.barodine.net | 2222 |
| AgentHub | https://agenthub.barodine.net | 443 |
| AgentHub Metrics | https://agenthub.barodine.net/metrics | 443 |
| Coolify | https://coolify.barodine.net | 443 |

---

## Troubleshooting

### Forgejo ne démarre pas

```bash
# Vérifier les logs
docker logs forgejo

# Vérifier la connexion DB
docker exec -it forgejo sh
psql "postgres://postgres:PASSWORD@rffv6pfwpdftlhunzoishduj:5432/postgres"
```

### Erreur "database is locked"

- Forgejo utilise SQLite par défaut si la config DB échoue
- Vérifier que toutes les env vars `FORGEJO__database__*` sont correctes
- Redémarrer le service

### SSH ne fonctionne pas

1. Vérifier que le port 2222 est mappé dans Coolify
2. Vérifier que le firewall autorise le port 2222:
   ```bash
   sudo ufw allow 2222/tcp
   ```

---

## Prochaines étapes

1. ✅ Installer Forgejo via Coolify (Méthode 1)
2. ✅ Créer le repository AgentHub
3. ✅ Pousser le code depuis le workspace local
4. ⏳ Créer la DB PostgreSQL pour AgentHub
5. ⏳ Créer l'application AgentHub dans Coolify
6. ⏳ Déployer et tester l'endpoint `/metrics`
7. ⏳ Configurer Prometheus et Grafana