mitai-jinkendo/SETUP.md

# Mitai Jinkendo – Entwicklungs-Setup

## 1. Gitea Repository anlegen

### Auf dem Pi (Gitea):
```bash
# Im Gitea Web-UI:
# → New Repository: "mitai-jinkendo"
# → Visibility: Private
# → Initialize: Nein (wir pushen bestehenden Code)
```

### Auf deinem Entwicklungsrechner:
```bash
# Einmalig: SSH-Key für Gitea hinterlegen
ssh-keygen -t ed25519 -C "lars-dev"
# Public Key in Gitea: Settings → SSH Keys → Add Key

# Repo klonen / initialisieren
cd /pfad/zum/projekt
git init
git remote add origin git@raspberrypi5:lars/mitai-jinkendo.git

# Ersten Commit
git add .
git commit -m "feat: initial commit v8 – Mitai Jinkendo"
git push -u origin main
```

---

## 2. Gitea Actions einrichten

### Runner auf dem Pi installieren:
```bash
# Gitea Runner installieren (führt die Workflows aus)
wget https://gitea.com/gitea/act_runner/releases/latest/download/act_runner-linux-arm64
chmod +x act_runner-linux-arm64
sudo mv act_runner-linux-arm64 /usr/local/bin/act_runner

# Runner registrieren
# Token findest du in Gitea: Site Admin → Runners → New Runner
act_runner register \
  --instance http://localhost:3000 \
  --token DEIN_TOKEN \
  --name "pi-runner" \
  --labels ubuntu-latest

# Als Service einrichten
sudo nano /etc/systemd/system/gitea-runner.service
```

`/etc/systemd/system/gitea-runner.service`:
```ini
[Unit]
Description=Gitea Act Runner
After=network.target

[Service]
User=lars
WorkingDirectory=/home/lars/gitea-runner
ExecStart=/usr/local/bin/act_runner daemon
Restart=always

[Install]
WantedBy=multi-user.target
```

```bash
sudo systemctl enable --now gitea-runner
```

### Deploy Secrets in Gitea hinterlegen:
```
Gitea → Repository → Settings → Secrets:

DEPLOY_HOST     = 127.0.0.1  (oder raspberrypi5.local)
DEPLOY_USER     = lars
DEPLOY_SSH_KEY  = (privater SSH-Key, der Zugriff auf den Pi hat)
```

---

## 3. Deployment-Verzeichnis auf dem Pi vorbereiten

```bash
# Einmalig auf dem Pi:
cd /home/lars/docker
git clone git@localhost:lars/mitai-jinkendo.git bodytrack
cd bodytrack

# .env anlegen (NICHT committen!)
cp .env.example .env
nano .env  # Werte ausfüllen

# Ersten Start
docker compose up -d
```

---

## 4. Claude Code einrichten

### VS Code Extension:
```
1. VS Code öffnen
2. Extensions → "Claude Code" suchen und installieren
3. Oder direkt: code --install-extension anthropic.claude-code
```

### Projekt öffnen:
```bash
cd /pfad/zu/mitai-jinkendo
code .
```

Claude Code liest automatisch `CLAUDE.md` und kennt damit:
- Den gesamten Tech-Stack
- Was schon implementiert ist
- Was als nächstes kommt (v9)
- Wichtige Hinweise (Ports, bekannte Fallstricke)

### Typischer Workflow:
```
1. Feature im Chat mit Claude besprechen
2. Claude Code schreibt/ändert Dateien direkt
3. git diff prüfen
4. git commit + push
5. Gitea Action deployed automatisch auf den Pi
```

---

## 5. DynDNS + Let's Encrypt Setup

### Fritz!Box MyFRITZ! einrichten:
```
1. Fritz!Box UI → Internet → MyFRITZ!-Konto
2. MyFRITZ!-Adresse notieren: z.B. "xxxx.myfritz.net"
3. Portfreigabe einrichten:
   - Port 80 → Raspberry Pi (für HTTP/Let's Encrypt)
   - Port 443 → Raspberry Pi (für HTTPS)
```

### Strato DNS einrichten:
```
Strato Kundenbereich → Domains → mitai.jinkendo.de → DNS

CNAME body → xxxx.myfritz.net
```
*Alternativ: A-Record + DynDNS-Update-Script*

### nginx auf dem Pi installieren:
```bash
sudo apt install nginx
sudo cp nginx/nginx.conf /etc/nginx/sites-available/jinkendo
sudo ln -s /etc/nginx/sites-available/jinkendo /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```

### Let's Encrypt Zertifikat holen:
```bash
# Sicherstellen dass Port 80 von außen erreichbar ist!
# Dann:
sudo bash nginx/certbot-setup.sh
```

---

## 6. Entwicklungs-Workflow (täglich)

```bash
# Feature entwickeln
git checkout -b feature/v9-auth
# ... Code schreiben ...
git add .
git commit -m "feat(auth): add bcrypt password hashing"

# Lokal testen
docker compose -f docker-compose.yml \
               -f docker-compose.dev.yml up

# Nach Test: merge + deploy
git checkout main
git merge feature/v9-auth
git push  # → Gitea Action startet automatisch → Pi wird updated
```

---

## 7. Nächste Schritte (v9 Roadmap)

### v9a – Security (Prio: 🔴 Kritisch):
- [ ] bcrypt für Passwörter
- [ ] Auth-Middleware auf alle Endpoints
- [ ] CORS einschränken
- [ ] Rate Limiting
- [ ] Login via E-Mail statt Profil-Liste

### v9a – Infrastruktur:
- [ ] PostgreSQL Migration
- [ ] nginx + Let's Encrypt live
- [ ] Gitea Actions deployed

### v9b – Freemium:
- [ ] Tier-System (free/basic/premium)
- [ ] Selbst-Registrierung + E-Mail-Bestätigung
- [ ] Trial (14 Tage)
- [ ] Einladungslinks für Beta
- [ ] Admin-Panel: User + Tiers verwalten

### v9c – Connectoren (Vorbereitung):
- [ ] OAuth2-Grundgerüst
- [ ] Strava Connector
- [ ] Withings Connector (Waage)