server/docs/setup/lokal.md

# Oppsett: Lokalt Utviklingsmiljø (WSL2)
**Filsti:** `docs/setup/lokal.md`

Denne oppskriften setter opp en lokal utviklingsreplika av Sidelinja i WSL2. Målet er at all utvikling og testing skjer her — aldri på produksjonsserveren.

## 0. Forutsetninger
- Windows 11 med WSL2 (Ubuntu 24.04 LTS)
- Docker Desktop for Windows med WSL2-integrasjon aktivert
- Node.js 20+ (via nvm i WSL2)
- Rust toolchain (via rustup i WSL2)
- Git konfigurert med SSH-nøkkel mot produksjons-Forgejo

## 1. Installer verktøy i WSL2

```bash
# Node.js via nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install 20
nvm use 20

# Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# tea CLI (Forgejo)
# Installer fra: https://gitea.com/gitea/tea/releases
```

## 2. Klon prosjektet

```bash
mkdir -p ~/server
cd ~/server
git clone ssh://git@sidelinja.no:222/sidelinja/sidelinja.git .
# Eller om repo allerede finnes lokalt, sett opp remote:
git remote add forgejo ssh://git@sidelinja.no:222/sidelinja/sidelinja.git
```

## 3. Lokal mappestruktur

```bash
# Docker-volumer for databaser (flyktige, ikke backupes)
mkdir -p .docker-data/{postgres,spacetimedb}
mkdir -p .docker-data/media/podcast
mkdir -p .docker-data/logs/caddy
```

## 4. Miljøvariabler (.env.local)

```bash
cat > .env.local << 'EOF'
# === Lokalt utviklingsmiljø ===
DOMAIN=localhost
COMPOSE_PROJECT_NAME=sidelinja-dev

# === PostgreSQL (lokale verdier, ikke hemmelige) ===
POSTGRES_USER=sidelinja
POSTGRES_PASSWORD=localdev
POSTGRES_DB=sidelinja

# === SpacetimeDB ===
# Lokale defaults

# === LiveKit (lokale test-nøkler) ===
LIVEKIT_API_KEY=devkey
LIVEKIT_API_SECRET=devsecret

# === OpenRouter (bruk egen nøkkel for AI-testing) ===
OPENROUTER_API_KEY=<din personlige nøkkel>
EOF
```

## 5. docker-compose.dev.yml

Spinner opp kun infrastruktur-tjenestene. SvelteKit kjøres utenfor Docker for HMR.

```yaml
# Fullstendig docker-compose.dev.yml bygges ut ved implementering.
# Struktur:

services:
  postgres:
    image: postgres:16
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - ./.docker-data/postgres:/var/lib/postgresql/data
    ports:
      - "127.0.0.1:5432:5432"  # KUN localhost, aldri 0.0.0.0
    networks:
      - sidelinja-dev

  spacetimedb:
    image: clockworklabs/spacetimedb
    volumes:
      - ./.docker-data/spacetimedb:/var/lib/spacetimedb
    ports:
      - "127.0.0.1:3001:3000"  # KUN localhost
    networks:
      - sidelinja-dev

  livekit:
    image: livekit/livekit-server
    ports:
      - "127.0.0.1:7880:7880"  # KUN localhost
    networks:
      - sidelinja-dev

  caddy:
    image: caddy:2
    ports:
      - "127.0.0.1:443:443"
      - "127.0.0.1:80:80"
    volumes:
      - ./config/caddy/Caddyfile.dev:/etc/caddy/Caddyfile
      - ./.docker-data/logs/caddy:/var/log/caddy
      - ./.docker-data/media:/srv/media
    networks:
      - sidelinja-dev

networks:
  sidelinja-dev:
    driver: bridge
```

## 6. Start infrastruktur

```bash
# Start Docker-tjenestene
docker compose -f docker-compose.dev.yml --env-file .env.local up -d

# Verifiser
docker compose -f docker-compose.dev.yml ps
docker compose -f docker-compose.dev.yml exec postgres pg_isready
```

## 7. Start SvelteKit (utenfor Docker, for HMR)

```bash
cd sveltekit/  # eller der SvelteKit-prosjektet lever
npm install
npm run dev -- --host  # Tilgjengelig på https://localhost:5173
```

## 8. Start Rust Workers (under utvikling)

```bash
cd workers/  # eller der Rust worker-prosjektet lever
cargo run --bin sidelinja-worker
```

## 9. Database-seeding (valgfritt)

```bash
# Kjør SQL-seed mot lokal PostgreSQL for testdata
psql -h localhost -U sidelinja -d sidelinja -f db/seed.sql
```

## 10. Lokal Caddy (HTTPS for WebRTC)

WebRTC krever sikker kontekst. Lokal Caddy genererer self-signed cert:

```caddyfile
# config/caddy/Caddyfile.dev
{
    local_certs
}

localhost {
    # SvelteKit dev server
    reverse_proxy host.docker.internal:5173

    # SpacetimeDB
    handle_path /spacetime/* {
        reverse_proxy spacetimedb:3000
    }

    # LiveKit
    handle_path /livekit/* {
        reverse_proxy livekit:7880
    }

    # Media
    handle_path /media/* {
        root * /srv/media
        file_server
    }
}
```

## 11. Daglig utviklingsflyt

```bash
# 1. Start infrastruktur (om ikke allerede kjørende)
docker compose -f docker-compose.dev.yml --env-file .env.local up -d

# 2. Start SvelteKit
cd sveltekit && npm run dev

# 3. Gjør endringer, test lokalt

# 4. Commit og push til Forgejo
git add <filer>
git commit -m "beskrivelse"
git push forgejo main

# 5. Deploy til prod (via SSH)
ssh sidelinja@<server-ip> "cd /srv/sidelinja && git pull && docker compose up -d --build"
```

## 12. Forskjeller fra produksjon

| Aspekt | Lokalt | Produksjon |
|---|---|---|
| SvelteKit | `npm run dev` (HMR) | Docker container (bygget) |
| Porter | Localhost-bundet (`127.0.0.1`) | Kun 80/443 via Caddy |
| HTTPS | Self-signed (Caddy `local_certs`) | Let's Encrypt |
| Forgejo | Ikke installert, push direkte til prod | Docker container |
| Authentik | Ikke installert (bypass auth lokalt) | Docker container |
| DB-data | Flyktig (`.docker-data/`, gitignored) | Persistent (`/srv/sidelinja/data/`) |
| Whisper | Valgfritt, kan mockes | Alltid tilgjengelig |