name: agency-docs-updater description: End-to-End-Pipeline zur Veröffentlichung von Claude Code Lab Meetings. Akzeptiert optionale Argumente: Datum (YYYYMMDD, "yesterday", "today") und Lab-Nummer (z.B. "04"). Beispiele: "yesterday 04", "20260420 05", "04" (heute, Lab 04), "" (heute, automatische Erkennung).
Agency Docs Updater
Führe ALLE Schritte automatisch in der Reihenfolge aus. Halte nur an, wenn ein Schritt fehlschlägt und nicht wiederhergestellt werden kann. Lies references/learnings.md, bevor du beginnst, um bekannte Fallstricke zu vermeiden.
Konfiguration: Pfade werden aus .env im Skill-Root-Verzeichnis gelesen (siehe .env.example). Die Standardwerte funktionieren für das Standard-Setup. Wichtige Umgebungsvariablen: VAULT_DIR, DOCS_SITE_DIR, YOUTUBE_UPLOADER_DIR, PRESENTATIONS_DIR, SKILLS_REPO_DIR, SKILLS_LOCAL_DIR, ZOOM_CREDENTIALS_DIR, GITHUB_REPO, SITE_DOMAIN.
Abhängigkeiten (überprüfe, dass diese existieren, bevor du fortfährst):
- zoom — Zoom-Aufzeichnungs-Download (
scripts/zoom_meetings.py) - fathom — Fathom-Video-Fallback (
scripts/download_video.py) - nano-banana — Thumbnail-Overlay-Generierung (
scripts/generate_image.sh) - calendar-sync — nur lokal, Kalenderereignis-Sync (
sync.sh) - youtube-uploader — Videoverarbeitung, Upload und YouTube-API-Authentifizierung
Schritt 0: Argumente parsen und Konfiguration laden
Lade .env aus dem Skill-Root-Verzeichnis. Teile dann args durch Leerzeichen:
- 8-stelliges Token (
YYYYMMDD) →DATE - "yesterday" →
DATE = $(date -v-1d +%Y%m%d) - "today" oder fehlend →
DATE = $(date +%Y%m%d) - 2-stelliges Token (
NN) oderlab-NN→LAB_FILTER
Erweitere Umgebungsvariablen für Pfade, die in nachfolgenden Schritten verwendet werden:
VAULT_DIR="${VAULT_DIR:-$HOME/Brains/brain}"
DOCS_SITE_DIR="${DOCS_SITE_DIR:-$HOME/Sites/agency-docs}"
YOUTUBE_UPLOADER_DIR="${YOUTUBE_UPLOADER_DIR:-$HOME/ai_projects/youtube-uploader}"
SKILLS_REPO_DIR="${SKILLS_REPO_DIR:-$HOME/ai_projects/claude-skills}"
SKILLS_LOCAL_DIR="${SKILLS_LOCAL_DIR:-$HOME/.claude/skills}"
ZOOM_CREDENTIALS_DIR="${ZOOM_CREDENTIALS_DIR:-$HOME/.zoom_credentials}"
PRESENTATIONS_DIR="${PRESENTATIONS_DIR:-$HOME/ai_projects/claude-code-lab}"
GITHUB_REPO="${GITHUB_REPO:-glebis/agency-docs}"
SITE_DOMAIN="${SITE_DOMAIN:-agency-lab.glebkalinin.com}"
Schritt 1: Fathom-Transkript finden
Wenn LAB_FILTER gesetzt ist: ${VAULT_DIR}/${DATE}-claude-code-lab-${LAB_FILTER}.md
Wenn leer: Glob ${VAULT_DIR}/${DATE}-claude-code-lab-*.md (wähle das aktuellste nach mtime).
Wenn fehlend: Führe ${SKILLS_LOCAL_DIR}/calendar-sync/sync.sh aus, überprüfe erneut, stoppe, wenn immer noch fehlend.
Extrahiere aus YAML-Frontmatter und speichere:
FATHOM_FILE,SHARE_URL,MEETING_TITLE,DATE,LAB_NUMBERVIDEO_NAME=${DATE}-claude-code-lab-${LAB_NUMBER}TRANSCRIPT_LANG= automatische Erkennung aus den ersten ~50 Zeilen (kyrillischer Anteil > 0.3 →ru, sonsten)
Bestimme MEETING_NUMBER: Überprüfe bestehende MDX-Dateien in ${DOCS_SITE_DIR}/content/docs/claude-code-internal-${LAB_NUMBER}/meetings/ auf einen Platzhalter mit dem heutigen Datum. Wenn gefunden, verwende diese Nummer. Andernfalls überprüfe die Dateigrößen, um den nächsten leeren Slot zu finden. Speichere als zweistellige Zeichenfolge mit führender Null (z.B. 04). Diese Variable wird in den Schritten 3b, 4b, 5, 6 und 8 verwendet.
Schritt 2: Video herunterladen
Überspringe, wenn ${VAULT_DIR}/${VIDEO_NAME}.mp4 existiert und größer als 1 MB ist.
Hinweis: Zoom-Aufzeichnungen können nach einem Meeting bis zu ~15 Minuten zur Verarbeitung benötigen. Wenn die Zoom-API keine Aufzeichnungen zurückgibt, warte und wiederhole den Vorgang, bevor du auf Fathom zurückfällst.
Primär — Zoom:
python3 ${SKILLS_REPO_DIR}/zoom/scripts/zoom_meetings.py recordings \
--start ${DATE:0:4}-${DATE:4:2}-${DATE:6:2} \
--end $(date -j -v+1d -f %Y%m%d ${DATE} +%Y-%m-%d) \
--show-downloads 2>&1
Finde die MP4-URL, dann:
TOK=$(python3 -c "import json,pathlib; print(json.load(open(pathlib.Path('${ZOOM_CREDENTIALS_DIR}')/'oauth_token.json'))['access_token'])")
curl -L -H "Authorization: Bearer ${TOK}" -o ${VAULT_DIR}/${VIDEO_NAME}.mp4 "${MP4_DOWNLOAD_URL}"
Fallback — Fathom (wenn keine Zoom-Aufzeichnung):
cd ${VAULT_DIR} && python3 ${SKILLS_LOCAL_DIR}/fathom/scripts/download_video.py \
"${SHARE_URL}" --output-name "${VIDEO_NAME}"
Schritt 3: Zu YouTube hochladen
cd ${YOUTUBE_UPLOADER_DIR} && \
python3 process_video.py \
--video ${VAULT_DIR}/${VIDEO_NAME}.mp4 \
--fathom-transcript ${FATHOM_FILE} \
--title "${MEETING_TITLE}" \
--upload
Führe mit run_in_background: true aus (10-30 Min.). Bei Fehler: --resume-from upload.
Extrahiere YOUTUBE_URL aus stdout (✓ YouTube video: ...) oder processed/metadata/${VIDEO_NAME}.json.
Extrahiere VIDEO_ID aus der URL (der Teil nach ?v= oder das letzte Pfadsegment).
Schritt 3a: Upload überprüfen (ERFORDERLICH)
Nachdem VIDEO_ID extrahiert wurde, überprüfe, ob das Video tatsächlich auf YouTube existiert, bevor du fortfährst. Videos können während der Verarbeitung stillschweigend fehlschlagen oder von YouTubes Inhaltsprüfung automatisch gelöscht werden.
cd ${YOUTUBE_UPLOADER_DIR} && PYTHONPATH=. python3 -c "
from auth import get_authenticated_service
import sys, time
youtube = get_authenticated_service()
video_id = '${VIDEO_ID}'
# Bis zu 5 Minuten warten, bis das Video verfügbar ist
for attempt in range(10):
resp = youtube.videos().list(part='status,processingDetails', id=video_id).execute()
if not resp['items']:
if attempt < 9:
print(f'Video noch nicht verfügbar (Versuch {attempt+1}/10), warte 30s...')
time.sleep(30)
continue
print(f'FATAL: Video {video_id} nach 5 Minuten nicht gefunden. Upload möglicherweise fehlgeschlagen.')
sys.exit(1)
status = resp['items'][0]['status']
processing = resp['items'][0].get('processingDetails', {})
upload_status = status.get('uploadStatus', 'unknown')
privacy = status.get('privacyStatus', 'unknown')
rejection = status.get('rejectionReason', None)
print(f'Upload-Status: {upload_status}, Privatsphäre: {privacy}')
if rejection:
print(f'ABGELEHNT: {rejection}')
sys.exit(1)
if upload_status in ('processed', 'uploaded'):
print(f'✓ Video {video_id} erfolgreich verifiziert')
sys.exit(0)
if upload_status == 'failed':
print(f'FATAL: Upload fehlgeschlagen - {status.get(\"failureReason\", \"unknown\")}')
sys.exit(1)
print(f'Status: {upload_status}, warte 30s...')
time.sleep(30)
print('FATAL: Video nach 5 Minuten nicht bereit')
sys.exit(1)
"
Wenn die Überprüfung fehlschlägt: Lösche die fehlgeschlagenen Video-Metadaten (rm processed/metadata/${VIDEO_NAME}.json), lade erneut mit --resume-from upload hoch und überprüfe erneut. Fahre NICHT mit den MDX- oder Thumbnail-Schritten fort, wenn VIDEO_ID nicht verifiziert ist.
Starte Schritt 4 parallel — die Zusammenfassung hängt nicht von der YouTube-URL ab.
Schritt 3b: Lab-spezifisches Thumbnail (ERFORDERLICH)
Führe diesen Schritt immer aus — er ersetzt das generische Thumbnail aus process_video.py durch die gebrandete Lab-Vorlage. Das generische Thumbnail ist für die Veröffentlichung NICHT akzeptabel.
Voraussetzungen: VIDEO_ID muss bekannt sein (warte ggf. auf den Abschluss von Schritt 3).
Befolge references/thumbnail-guide.md für den vollständigen Workflow:
- Generiere ein Nano Banana Overlay-Bild (themenspezifischer Prompt aus den Prompt-Mustern des Leitfadens)
- Lies/überprüfe das Rohbild, um die Hintergrundfarbe zu bestätigen, färbe dann Linien in Orange (#e85d04) um
- Schreibe eine temporäre HTML-Datei (z.B.
/tmp/lab-meeting-${MEETING_NUMBER}.html) basierend auf${YOUTUBE_UPLOADER_DIR}/templates/images/lab-meeting.html— aktualisiere Meeting-Nummer, Themen-Haupttext, Aufzählungsbeschreibungen, Datum. Bearbeite die Originalvorlage nicht direkt. - Rendere mit Playwright bei 1280×720 →
${YOUTUBE_UPLOADER_DIR}/processed/thumbnails/${VIDEO_NAME}.jpg - Lies/überprüfe das gerenderte Thumbnail, um das Layout vor dem Hochladen zu verifizieren
- Lade zu YouTube hoch: verwende die aus Schritt 3 extrahierte
VIDEO_ID
Überspringe diesen Schritt NICHT oder verlasse dich nicht auf das Thumbnail von process_video.py.
Schritt 4: Faktengeprüfte Zusammenfassung generieren
Lies ${FATHOM_FILE}. Generiere eine strukturierte Zusammenfassung in ${TRANSCRIPT_LANG}:
##Abschnittsüberschriften, Aufzählungspunkte, Codebeispiele, wo relevant- Technische Begriffe auf Englisch (MCP, Skills, Claude Code, etc.)
- Schließe persönliche Planungsdetails aus
- Bereinige für MDX: maskiere
<,>und bloße{-Zeichen, die die MDX-Kompilierung brechen würden
Überprüfe Behauptungen zu Claude Code Funktionen mit dem claude-code-guide-Subagenten (falls verfügbar; überspringe die Faktenprüfung, wenn der Agent nicht zugänglich ist). Speichere die korrigierte Zusammenfassung im Scratchpad als summary.md.
Schritt 4b: YouTube-Metadaten aktualisieren
Nachdem sowohl Schritt 3 als auch Schritt 4 abgeschlossen sind. VIDEO_ID, MEETING_NUMBER und LAB_NUMBER müssen alle vor diesem Schritt bestimmt sein. Lese references/youtube-api.md für das Beschreibungsformat und API-Ausschnitte.
Generiere die YouTube-Beschreibung aus der Zusammenfassung. Verwende die sprachgerechte Vorlage:
- Wenn
TRANSCRIPT_LANG=en: Englische Bezeichnungen ("In this video:", "Course materials and session notes:") - Wenn
TRANSCRIPT_LANG=ru: Russische Bezeichnungen ("В этом видео:", "Материалы и конспект занятия:")
Mische KEINE Sprachen in einer einzigen Beschreibung.
Meeting-Seiten-URL: https://${SITE_DOMAIN}/claude-code-lab-${LAB_NUMBER}/meetings/${MEETING_NUMBER}
Aktualisiere Titel, Beschreibung, Tags über die YouTube-API und füge dann das Video zur Playlist "Claude Code Lab ${LAB_NUMBER}" hinzu (wird automatisch erstellt, falls sie nicht existiert).
Schritt 5: MDX generieren
python3 ${SKILLS_LOCAL_DIR}/agency-docs-updater/scripts/update_meeting_doc.py \
${FATHOM_FILE} "${YOUTUBE_URL}" ${SCRATCHPAD}/summary.md
Vor der Ausführung: Überprüfe, ob für das heutige Datum bereits ein Platzhalter-MDX existiert (grep -l in meetings/). Wenn ja, verwende -n ${MEETING_NUMBER} --update, um es zu bearbeiten.
Nach der Ausführung:
- Entferne angehängten Marp-Inhalt (alles nach dem schließenden
---der Zusammenfassung vor<!-- _class: lead -->) — MDX bricht bei HTML-Kommentaren (<!-- -->), nicht maskierten<und bloßen{-Zeichen - Suche nach Präsentationsdateien: suche in
${PRESENTATIONS_DIR}/presentations/lab-${LAB_NUMBER}/und${PRESENTATIONS_DIR}/lesson-generator/nach Dateien, die${DATE}entsprechen. Wenn gefunden, kopiere nach${DOCS_SITE_DIR}/public/${DATE}-claude-code-lab-${LAB_NUMBER}.htmlund füge einen Link in MDX hinzu - Ersetze Platzhalter im Frontmatter (
[Название встречи],[Краткое описание встречи],[Дата встречи]) - Wenn
TRANSCRIPT_LANG=en, schreibe das MDX vollständig mit englischen Bezeichnungen um — das Skript standardmäßt auf Russisch und die Übersetzungsfallback erzeugt fehlerhafte gemischte Sprachausgaben - Überprüfe:
cd ${DOCS_SITE_DIR} && npm run build 2>&1 | tail -5
Schritt 6: Committen und Pushen
Staging nur von Pipeline-Dateien — niemals git add .:
cd ${DOCS_SITE_DIR}
git fetch origin main
BEHIND=$(git rev-list --count HEAD..origin/main)
if [ "$BEHIND" -gt 0 ]; then
git stash push -m "agency-docs-updater: temp stash"
git pull --rebase origin main
git stash pop || true
fi
git add content/docs/claude-code-internal-${LAB_NUMBER}/meetings/${MEETING_NUMBER}.mdx
# Nur Präsentations-HTML stagen, wenn es kopiert wurde
[ -f public/${DATE}-claude-code-lab-${LAB_NUMBER}.html ] && git add public/${DATE}-claude-code-lab-${LAB_NUMBER}.html
git commit -m "Füge Lab ${LAB_NUMBER} Meeting ${MEETING_NUMBER} hinzu"
git push
Speichere COMMIT_HASH=$(git rev-parse HEAD) für Schritt 7.
Schritt 7: Auf Vercel-Deploy warten
TIMEOUT=300; ELAPSED=0
until [ "$(gh api repos/${GITHUB_REPO}/commits/${COMMIT_HASH}/status --jq '.state' 2>/dev/null || echo 'pending')" != "pending" ]; do
sleep 15; ELAPSED=$((ELAPSED+15))
[ "$ELAPSED" -ge "$TIMEOUT" ] && echo "Deploy-Zeitüberschreitung nach ${TIMEOUT}s" && break
done
DEPLOY_STATE=$(gh api repos/${GITHUB_REPO}/commits/${COMMIT_HASH}/status --jq '.state')
echo "Deploy-Status: ${DEPLOY_STATE}"
Führe mit run_in_background: true aus. Wenn der Status failure oder error ist: überprüfe Vercel-Logs (vercel logs), korrigiere lokal, pushe erneut, starte diesen Schritt neu.
Schritt 8: Im Browser überprüfen
Öffne https://${SITE_DOMAIN}/claude-code-lab-${LAB_NUMBER}/meetings/${MEETING_NUMBER} in einem Browser (über Chrome-Automatisierungstools oder manuell). Überprüfe, ob das YouTube-Embed sichtbar ist. Wenn nicht: überprüfe VIDEO_ID, warte auf die YouTube-Verarbeitung oder lade erneut hoch.
Pipeline-Bericht
Nach Abschluss berichte: Fathom-Pfad, Videopfad, YouTube-URL, MDX-Pfad, Commit-Hash, Deploy-Status, Embed-Überprüfung.