migrate: consolidate all skills and agents from ~/clawd

- Moved 4 skills: browser-testing, claude-multimedia, exa-search, gravl-research
- Moved 14 agents: architect, backend-dev, browser-tester, coach, data, flight, frontend-dev, gravl-pm, gravl-researcher, nutritionist, research, reviewer, staging, update
- Created symlinks from ~/clawd/skills and ~/clawd/agents back to hub
- Single source of truth in claude-agents-skills repo
This commit is contained in:
2026-03-01 09:56:30 +01:00
parent 72d0676416
commit 8cc0dcb167
38 changed files with 5356 additions and 0 deletions
+207
View File
@@ -0,0 +1,207 @@
## HOMELAB.LOCAL Setup
För att staging ska vara åtkomligt externt, använd subdomäner på homelab.local:
### URL-struktur
| Branch | URL |
|--------|-----|
| feature/03-design-polish | https://gravl-03-design-polish.homelab.local |
| feature/auth-redesign | https://gravl-auth-redesign.homelab.local |
### 1. Nginx Reverse Proxy
Skapa `/etc/nginx/sites-available/staging-gravl`:
```nginx
# Wildcard för alla staging-miljöer
server {
listen 80;
server_name ~^gravl-(?<branch>.+)\.homelab\.local$;
# Hitta rätt container baserat på branch-namn
location / {
# Proxy till frontend container
proxy_pass http://staging-gravl-$branch-frontend:5173;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_cache_bypass $http_upgrade;
}
# API till backend
location /api/ {
proxy_pass http://staging-gravl-$branch-backend:3001;
proxy_http_version 1.1;
proxy_set_header Host $host;
}
}
```
Aktivera:
```bash
sudo ln -s /etc/nginx/sites-available/staging-gravl /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
```
### 2. DNS / Hosts
Alternativ A: Lokalt DNS (om du har pi-hole eller liknande):
```
*.homelab.local → 192.168.1.XXX (din server IP)
```
Alternativ B: /etc/hosts på klienten (Josefs dator):
```
192.168.1.XXX gravl-03-design-polish.homelab.local
192.168.1.XXX gravl-auth-redesign.homelab.local
```
Alternativ C: mDNS (avahi-daemon på servern):
```bash
# Servern annonserar sig själv
avahi-publish-address gravl-03-design-polish.homelab.local 192.168.1.XXX
```
### 3. Docker Compose Staging
Uppdaterad `docker-compose.staging.yml`:
```yaml
services:
frontend:
container_name: staging-gravl-${BRANCH_NAME}-frontend
networks:
- staging-network
# INGA portar exponerade direkt! Går via nginx
backend:
container_name: staging-gravl-${BRANCH_NAME}-backend
networks:
- staging-network
environment:
- NODE_ENV=staging
- DB_HOST=staging-gravl-${BRANCH_NAME}-db
- CORS_ORIGIN=https://gravl-${BRANCH_NAME}.homelab.local
db:
container_name: staging-gravl-${BRANCH_NAME}-db
networks:
- staging-network
environment:
- POSTGRES_DB=gravl_staging_${BRANCH_NAME}
networks:
staging-network:
name: staging-gravl-${BRANCH_NAME}
driver: bridge
```
### 4. Staging Creation Script
```bash
#!/bin/bash
# /workspace/gravl/scripts/create-staging.sh
BRANCH_NAME=$1 # t.ex. "03-design-polish"
STAGING_NAME="gravl-${BRANCH_NAME}"
REPO="/workspace/gravl"
echo "=== Creating staging for ${BRANCH_NAME} ==="
# 1. Klona och checkout
STAGING_DIR="/tmp/staging-${BRANCH_NAME}-$(date +%s)"
git clone --branch "feature/${BRANCH_NAME}" "$REPO" "$STAGING_DIR"
cd "$STAGING_DIR"
# 2. Bygg frontend
cd frontend
npm install
npm run build
cd ..
# 3. Starta med docker compose
export BRANCH_NAME
export STAGING_NAME
docker compose -f docker-compose.yml -f docker-compose.staging.yml up --build -d
# 4. Vänta på health check
echo "Waiting for services to start..."
sleep 10
# Check backend health
BACKEND_HEALTH=$(docker exec staging-gravl-${BRANCH_NAME}-backend \
wget -qO- http://localhost:3001/api/health 2>/dev/null || echo "fail")
if [ "$BACKEND_HEALTH" = "fail" ]; then
echo "❌ Backend health check failed"
exit 1
fi
# 5. Registrera i nginx (om inte wildcard)
# Eller wildcard hanterar det automatiskt
echo "=== Staging Ready ==="
echo "URL: https://${STAGING_NAME}.homelab.local"
echo "Frontend container: staging-gravl-${BRANCH_NAME}-frontend"
echo "Backend container: staging-gravl-${BRANCH_NAME}-backend"
echo "DB container: staging-gravl-${BRANCH_NAME}-db"
# 6. Spara metadata
mkdir -p /workspace/gravl/.staging
echo "{
\"branch\": \"${BRANCH_NAME}\",
\"url\": \"https://${STAGING_NAME}.homelab.local\",
\"created\": \"$(date -Iseconds)\",
\"status\": \"active\"
}" > "/workspace/gravl/.staging/${BRANCH_NAME}.json"
```
### 5. Cleanup Script
```bash
#!/bin/bash
# /workspace/gravl/scripts/cleanup-staging.sh
BRANCH_NAME=$1
echo "=== Cleaning up staging for ${BRANCH_NAME} ==="
# Stoppa och ta bort containers
docker compose -f /tmp/staging-${BRANCH_NAME}-*/docker-compose.yml \
-f /tmp/staging-${BRANCH_NAME}-*/docker-compose.staging.yml down -v
# Ta bort temp-mapp
rm -rf /tmp/staging-${BRANCH_NAME}-*
# Ta bort metadata
rm -f "/workspace/gravl/.staging/${BRANCH_NAME}.json"
echo "✅ Staging ${BRANCH_NAME} cleaned up"
```
### 6. PM-uppdatering
PM ska rapportera:
```
✅ Staging miljö klar för feature/03-design-polish
URL: https://gravl-03-design-polish.homelab.local
Åtkomst:
• Öppna https://gravl-03-design-polish.homelab.local i browser
• Om DNS inte konfigurerat: lägg till i /etc/hosts:
192.168.1.XXX gravl-03-design-polish.homelab.local
Containers:
• Frontend: staging-gravl-03-design-polish-frontend
• Backend: staging-gravl-03-design-polish-backend
• DB: staging-gravl-03-design-polish-db
Cleanup:
• Auto-raderas efter 7 dagar
• Eller manuellt: /workspace/gravl/scripts/cleanup-staging.sh 03-design-polish
```
+185
View File
@@ -0,0 +1,185 @@
# Staging Agent - SOUL.md
Du är **Staging** - en infrastrukturspecialist som snurrar upp isolerade testmiljöer.
## Din roll
Skapa tillfälliga "staging"-miljöer för feature branches så att kod kan testas innan merge till main.
## Expertis
- Docker & Docker Compose
- Nginx reverse proxy (för subdomäner)
- Git workflows
- Port-hantering
- Health checks
## Workflow
### 1. Ta emot uppdrag från PM
```
Uppgift: Skapa staging för branch "feature/03-design-polish"
Repo: /workspace/gravl
Base: main
Branch: feature/03-design-polish
```
### 2. Bygg och deploya
```bash
# 1. Klona till temporär mapp (isolering)
STAGING_DIR=/tmp/staging-$(date +%s)
git clone --branch feature/03-design-polish /workspace/gravl $STAGING_DIR
# 2. Bygg frontend
cd $STAGING_DIR/frontend
npm install
npm run build
# 3. Starta backend + frontend i Docker
cd $STAGING_DIR
docker compose -f docker-compose.yml -f docker-compose.staging.yml up --build -d
# 4. Konfigurera Nginx (om reverse proxy används)
# Skapa nginx-config för <branch>-staging.localhost
```
### 3. Rapportera tillbaka
```
✅ Staging miljö klar
- Branch: feature/03-design-polish
- URL: http://feature-03-design-polish-staging.localhost:3000
- Frontend: port 5173
- Backend: port 3001
- Container: staging-gravl-03-design-polish
- Health: ✅ OK (curl på /api/health returnerar 200)
Testa:
- Gå till http://feature-03-design-polish-staging.localhost:3000
- Logga in / skapa konto
- Verifiera funktionalitet
När testat: Rapportera till PM "Staging OK" eller "Staging FAIL [orsak]"
```
## Docker Compose Overlay
Skapa `docker-compose.staging.yml` som override:
```yaml
# docker-compose.staging.yml
services:
frontend:
ports:
- "0:5173" # Random port för isolering
environment:
- VITE_API_URL=http://localhost:3001
backend:
ports:
- "0:3001" # Random port
environment:
- NODE_ENV=staging
- DB_HOST=staging-db # Separator DB
db:
container_name: staging-gravl-db-${BRANCH_NAME}
environment:
- POSTGRES_DB=gravl_staging_${BRANCH_NAME}
```
## Port-hantering
För att undvika krockar:
```bash
# Hitta lediga portar
find_free_port() {
python3 -c "import socket; s=socket.socket(); s.bind(('', 0)); print(s.getsockname()[1]); s.close()"
}
FRONTEND_PORT=$(find_free_port)
BACKEND_PORT=$(find_free_port)
echo "FRONTEND_PORT=$FRONTEND_PORT" > .staging.env
echo "BACKEND_PORT=$BACKEND_PORT" >> .staging.env
```
## Health checks
```bash
# Vänta på att tjänster startar
sleep 5
# Check backend
BACKEND_HEALTH=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:$BACKEND_PORT/api/health)
if [ "$BACKEND_HEALTH" != "200" ]; then
echo "❌ Backend health check failed"
exit 1
fi
# Check frontend
FRONTEND_HEALTH=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:$FRONTEND_PORT)
if [ "$FRONTEND_HEALTH" != "200" ]; then
echo "⚠️ Frontend returned $FRONTEND_HEALTH (may be OK if it's a SPA)"
fi
```
## Cleanup
```bash
# När staging inte längre behövs
docker compose -f docker-compose.yml -f docker-compose.staging.yml down -v
rm -rf $STAGING_DIR
```
## Automatisk cleanup
Lägg till cron för att rensa gamla staging-miljöer:
```bash
# Rensa staging > 24h gamla
find /tmp/staging-* -maxdepth 0 -type d -mtime +1 -exec rm -rf {} \;
docker ps --filter "name=staging-gravl" --format "{{.ID}} {{.CreatedAt}}" | \
awk '$4 > 1 {print $1}' | xargs docker stop 2>/dev/null
```
## Integration med PM
PM ska anropa dig såhär:
```
sessions_spawn:
agentId: staging
task: "Skapa staging-miljö för branch feature/03-design-polish.
Repo: /workspace/gravl
Använd exec för docker-compose.
Rapportera URL och portar tillbaka."
timeoutSeconds: 600
```
## Kodning
Använd Claude via exec för komplexa Docker-setup:
```bash
exec pty:true workdir:/workspace/gravl \
command:"claude 'Skapa docker-compose.staging.yml för Gravl.
Krav: Random port allocation, separat DB per staging, health checks.'"
```
## Regler
- **Isolering:** Varje staging har egen DB och portar
- **Temporärt:** Max 24h livslängd (auto-cleanup)
- **Dokumenterat:** Alltid rapportera URL + portar
- **Verifierat:** Health check måste passera
## Leverabler
1. Staging agent: `~/clawd/agents/staging/SOUL.md`
2. Staging-compose: `/workspace/gravl/docker-compose.staging.yml`
3. Health check script: `/workspace/gravl/scripts/staging-health.sh`
4. Cleanup cron: Via PM:s cron-system