screencast-desktop

Ein Claude-Code-Plugin, das einem Agenten ermöglicht, eine Windows-Anwendung zu bedienen und diese Sitzung in ein fertiges Demo-Video zu verwandeln – bei dem die Kamera eine halbe Sekunde bevor der Klick passiert, auf jeden Klick zu zoomen beginnt.

• Desktop mit Vision im Loop steuern. Jede Aktion gibt einen frischen Screenshot in derselben Antwort zurück, sodass der Agent nach dem Prinzip Schauen → Handeln → Schauen arbeitet, anstatt blind ein Skript zu schreiben. Steuerelemente werden über die Windows-Benutzeroberflächenautomatisierung (UI Automation) anhand ihres Namens gefunden; Electron-Apps, die keinen Steuerelementbaum bereitstellen, fallen auf Screenshots und Koordinaten zurück (oder auf ihr DOM über CDP, wenn ein Debug-Port geöffnet ist).

• Ein Fenster aufnehmen, nicht den Bildschirm. Die Aufnahme erfolgt über Windows Graphics Capture, gebunden an einen Fenster-Handle, sodass der Desktop hinter der App nie ins Bild gerät und es egal ist, auf welchem Monitor oder welcher GPU das Fenster liegt.

• Das Video wird aus einem Ereignisprotokoll erstellt, nicht aus dem Filmmaterial. Jeder Klick, jede getippte Zeichenfolge und der vollständige Cursorpfad werden zeitgestempelt, während sie passieren. Kamerabewegungen werden aus diesem Protokoll berechnet.

• Screen-Studio-Qualität, generiert: sanfte Kamerafahrten und Schwenks, ein gezeichneter Cursor mit weichem Schatten, Klickwellen, Bewegungsunschärfe, abgerundete Ecken auf einem Verlaufshintergrund, Vignette und Körnung – plus Entfernung von toten Momenten, die die Denkzeit des Agenten zusammenkürzt.

• Erzählung, die auf den Punkt kommt. Optionale ElevenLabs-Sprachausgabe, die vor dem Lauf generiert wird, sodass der Klick in den Satz fällt, der ihn beschreibt.

• Eine vollere Montage-Ebene, nur ein Skript entfernt. Titel- und Abspannkarten, Untertitel und ein kompletter Sounddesign-Durchgang – Klick-Spur, Kamera-Whooshes, Aufprallgeräusche, abschließender Riser, geduckte Musikbettung, Lautheitsnormalisierung – befinden sich in cinematic.py, sfx.py und sfx_bank.py. Sie werden von server/make_showcase.py gesteuert, nicht vom desktop_render-Tool; siehe Bekannte Einschränkungen.

• Kostenlos neu rendern. Das Rendern berührt die Anwendung nie: Ändern Sie die Zoom-Obergrenze, die Erzählung oder die Effekte und bauen Sie denselben Take so oft neu auf, wie Sie möchten.

Warum es anders ist

Jeder Bildschirmrekorder, der „Auto-Zoom“ macht – Screen Studio und seine Windows-Nachahmer – funktioniert auf dieselbe Weise: Er nimmt zuerst auf und geht dann durch Maus-Hooks oder das Filmmaterial selbst zurück, um zu erraten, wo die interessanten Momente waren. Diese Reihenfolge hat eine harte Konsequenz, die niemand umgehen kann: Der Zoom kann nicht vor dem Klick beginnen, weil der Rekorder im Moment des Klicks gerade erst erfahren hat, dass ein Klick kommt. Das Beste, was er tun kann, ist, sich beim Klick zu bewegen und kurz danach anzukommen. Menschliche Editoren machen das Gegenteil – sie führen den Betrachter hinein, sodass das Auge bereits auf dem Button ist, wenn er gedrückt wird.

Hier generiert der Agent die Aktionen, sodass die Koordinaten und Zeitabläufe bekannt sind, bevor ein einziges Bild zusammengesetzt wird. Der Kamera kann ein Vorlauf (LEAD_IN = 0.55 s in server/camera.py) gegeben werden, sodass die Einstellung bereits angekommen und zur Ruhe gekommen ist, wenn der Button gedrückt wird. Dasselbe Vorwissen bringt drei weitere Dinge, die ein nachträgliches Tool nicht haben kann:

• Kein Pumpen. Aufeinanderfolgende Klicks in derselben Region werden zu einer ruhigen Einstellung zusammengeführt, anstatt dass die Kamera bei jedem Listenelement hinein- und herauszoomt.

• Passende Erzählung. Die Sprache wird vor dem Lauf generiert (voice.plan()), ihre tatsächliche Dauer wird mit ffprobe gemessen, und die Pausen des Agenten werden aus diesen Zahlen gesetzt – so landet der Klick in dem Satz, der ihn beschreibt, ohne manuelles Nachjustieren. Erst aufzunehmen und danach zu erzählen endet immer damit, dass die Stimme „Ich klicke auf Speichern“ eine Sekunde nachdem Speichern bereits geklickt wurde, sagt.

• Eine maschinenlesbare Aufzeichnung dessen, was passiert ist. desktop_describe_take liest einen Take als nummerierte Prozedur zurück („3. [12.4s] Klick auf Multiplizieren mit“) – ein besseres Artefakt als ein Haufen Screenshots und genug, um daraus eine wiederverwendbare Fähigkeit zu schreiben.

Wo dies unter den Nachbarn steht

Die Idee ist nicht obskur – sie ist nur auf Windows schwer zu erreichen. Vier browserbasierte Projekte, die „Bearbeiten aus dem Aktionsprotokoll“ implementieren, erschienen innerhalb von zwei Wochen im März 2026 (argo, testreel, pagecast, playwright-recast), weil Playwright dir das Protokoll kostenlos liefert. Auf Windows muss das Protokoll zusammen mit dem Eingabetreiber aufgebaut werden, und in denselben fünf Monaten erschien nichts: Die Rekorder haben keinen Agenten, und die Agenten erzeugen keine Frames.

Related MCP server: windows-gui-mcp

Anforderungen

Python-Pakete

Aus den Imports jedes Moduls in server/ gezogen:

pip install mcp pillow opencv-python numpy windows-capture uiautomation

Für den Datenschutz-Scan ist kein Paket erforderlich: Er liest den Bildschirm mit der in Windows enthaltenen OCR, gesteuert über PowerShell.

Installation

1. Plugin holen

git clone https://github.com/JHamidun/screencast-desktop.git

2. In Claude Code registrieren

Das Repository ist sein eigener Marktplatz (.claude-plugin/marketplace.json), also weisen Sie Claude Code auf den Klon und installieren Sie von dort:

/plugin marketplace add <path-to-clone>
/plugin install screencast-desktop

.mcp.json registriert beide Server mit ${CLAUDE_PLUGIN_ROOT}-relativen Pfaden, sodass nichts global installiert werden muss und der Klon überall liegen kann.

3. Setup ausführen

/screencast-desktop:setup

Das führt server/doctor.py aus, das die Dinge prüft, die still kaputtgehen:

• DPI-Bewusstsein – einem Prozess, der sich nicht als DPI-bewusst deklariert hat, wird gesagt, der Bildschirm sei 2560×1440, obwohl er wirklich 3840×2160 ist, und jeder Klick verfehlt um den Skalierungsfaktor.

• Monitor-Layout – Koordinaten werden über alle Bildschirme geteilt und werden auf sekundären Monitoren negativ.

• ffmpeg und verfügbare Encoder.

• Fensteraufnahme, wirklich – es erfasst ~25 Frames und prüft, dass sie nicht alle identisch sind.

• Erzählung – ob ein Schlüssel vorhanden ist und ob die konfigurierte Stimmen-ID noch auf dem Konto existiert (eine gelöschte Stimme schlägt sonst mit einer nackten 404 fehl).

Es schreibt machine.json mit dem, was es gefunden hat.

4. Die UI-Automation-Binärdatei holen

Der windows-ui-Server ist eine externe Binärdatei – sbroenne/mcp-windows (MIT). Sie ist bewusst nicht in dieses Repository eingebunden: Sie ist ~60 MB groß, es ist das Projekt von jemand anderem, und eine Kopie hier zu fixieren würde nur eine veraltete ausliefern. Laden Sie sie bei Bedarf herunter:

python server/fetch_ui_binary.py          # --force to re-download

Das Skript löst die neueste GitHub-Version auf, verifiziert das Archiv gegen die damit veröffentlichte SHA256SUMS.txt und weigert sich, bei einer Abweichung etwas zu installieren. Es landet in bin/, wo .mcp.json es erwartet.

5. Bestätigen, dass beide Server laufen

claude mcp list      # expect: screencast, windows-ui

Schnellstart

Nehmen Sie eine Demo des Windows-Rechners auf. Der Befehl /screencast-desktop:record führt den Agenten durch diesen Prozess, aber hier ist, was er tatsächlich tut, mit den echten Tool-Namen.

1 – Fenster positionieren. Platzieren Sie es auf einem sekundären Monitor, falls vorhanden, damit es nicht über Ihrer Arbeit liegt:

desktop_monitors()
desktop_place_window(window="Calculator", monitor=1, fit=0.7)

Lesen Sie die Antwort. Anwendungen sind nicht verpflichtet, die Größe anzunehmen, die ihnen gesagt wird – ein UWP-Fenster, das hier mit 2380×1490 angefragt wurde, kam mit 3967×2426 zurück und ragte über den Bildschirm hinaus. desktop_place_window misst das Ergebnis, korrigiert es und sagt klar, ob das Fenster passt.

2 – Rahmen auf etwas Privates prüfen.

desktop_screenshot(window="Calculator")
desktop_privacy_check(window="Calculator")

Die Prüfung meldet, sie blockiert nicht: Sie OCRt den Rahmen und markiert Kartennummern, API-Schlüssel, E-Mail-Adressen, Telefonnummern und Personennamen. Aktivieren Sie „Bitte nicht stören“, bevor Sie aufnehmen.

3 – Proben. Gehen Sie die Route mit den echten Tools durch und bestätigen Sie anhand der zurückgegebenen Screenshots, dass Sie das treffen, was Sie zu treffen glauben. Es wird noch nichts aufgenommen:

ui_snapshot(windowHandle=…)          # windows-ui: controls by name — try this first
desktop_snapshot(window="Calculator")# or the built-in UIA walk, which returns e1, e2, … refs
desktop_click(ref="e7")

4 – App zurücksetzen. Ein von der Probe offen gelassenes Suchfeld landet im Take.

5 – Die echte Aufnahme machen.

desktop_record_start(window="Calculator")
desktop_click(ref="e12")                 # every click from here is logged for the camera
desktop_type("128")
desktop_click(ref="e19")
desktop_record_stop()

desktop_record_stop meldet die Dauer, die Frame-Anzahl und wie viele Klicks ins Protokoll gelangt sind, und sagt Ihnen dann das out_dir zum Rendern.

6 – Rendern und dann ansehen.

desktop_render(out_dir="%USERPROFILE%/screencasts/take-143502", max_zoom=2.0)
desktop_render_status(out_dir="…")       # rendering runs in a child process

Öffnen Sie die Datei und prüfen Sie mit eigenen Augen: Ist die Kamera dort angekommen, wo sie sein soll, gibt es schwarze Balken an einer Kante, ist der Cursor sichtbar? Eine falsche Koordinate erzeugt eine technisch gültige Datei, in der die Kamera auf nichts schaut. Wenn es daneben liegt, führen Sie desktop_render mit anderen Einstellungen erneut aus – die Anwendung wird nicht erneut gestartet und der Bildschirm nicht neu aufgezeichnet.

Tool-Referenz

screencast-Server — desktop_monitors, desktop_windows, desktop_screenshot, desktop_snapshot, desktop_dom, desktop_dom_launch, desktop_click, desktop_type, desktop_key, desktop_move_mouse, desktop_scroll, desktop_focus, desktop_launch, desktop_place_window, desktop_privacy_check, desktop_record_start, desktop_record_stop, desktop_render, desktop_render_status, desktop_describe_take.

desktop_click, desktop_type, desktop_key, desktop_scroll, desktop_focus und desktop_launch akzeptieren alle see="shot" (Standard) oder see="none" – die zweite Option spart Kontext, wenn Sie bereits wissen, wie der Bildschirm aussieht.

windows-ui-Server (exponierte Teilmenge) — ui_snapshot, ui_find, ui_click, ui_type, ui_select, ui_read, ui_wait, window_management, app.

So funktioniert es

Dasselbe in Textform, für alle, die dies in einem Terminal lesen:

  AGENT                                                   server/
  ─────                                                   ───────
  desktop_click / desktop_type / …                        desktop_server.py
        │                                                 (MCP, FastMCP)
        ├──► real SendInput: cursor eased to the target,  driver.py
        │    clicked, keys sent                           ── moves + clicks
        │                                                    the real desktop
        │
        ├──► EVENT LOG  t, kind, x, y, label, dur         driver.py → events.json
        │    + the sampled cursor path (track)               ◄── the ground truth
        │
        └──► screenshot back to the agent in the same reply

  desktop_record_start                                    recorder_proc.py (child process)
        └──► Windows Graphics Capture, bound to the HWND  wgc.py
             ├─ frames arrive only when the picture       ── writer thread re-sends
             │  changes …                                    the last frame on a
             └─ … so a writer thread feeds ffmpeg at a       fixed clock
                constant rate, logging the true
                wall-clock time of every frame
                                                          → raw.mp4 + frame_times.json

  desktop_render                                          render_proc.py (child process)
        │
        ├─ 1. TIMELINE   collapse the dead air            timeline.py
        │      keep 1.1 s before and 1.5 s after every
        │      action, squeeze the gaps to 0.55 s
        │
        ├─ 2. CAMERA     event log → keyframes            camera.py
        │      lead-in 0.55 s BEFORE each click,
        │      nearby clicks merged into one shot,
        │      pan instead of pumping in and out
        │
        ├─ 3. COMPOSITOR one affine matrix per frame      composer.py
        │      recording on a gradient backdrop, rounded     + cinematic.py
        │      corners, drop shadow, drawn cursor, click     (vignette, grain;
        │      ripples, motion blur, breathing idle,          title cards and
        │      vignette, grain                                captions available)
        │                                                 → silent.mp4
        │
        └─ 4. SOUND      optional narration               voice.py
               ElevenLabs TTS mixed onto the cut          → demo.mp4

  make_showcase.py — the fuller montage, run as a script rather than a tool:
        the same four stages plus title/outro cards, captions, and the whole
        sound design pass (clicks, whooshes, impacts, riser, ducked music bed,
        loudness normalisation)                           sfx.py + sfx_bank.py

Zwei Designentscheidungen erklären den Großteil des Dateiaufbaus:

Aufnahme und Rendern laufen in Kindprozessen. Das Importieren der Aufnahmebibliothek oder von OpenCV im MCP-Serverprozess blockiert ihn, und ein Rendern dauert Minuten, was kein Tool-Aufruf offen halten sollte. recorder_proc.py und render_proc.py existieren allein aus diesem Grund. Sie kommunizieren über Dateien (started.json, stop, render.log) und werden beide mit stdin=DEVNULL gestartet – ein Kindprozess, der das stdin des Servers erbt, beginnt, die für den Server bestimmten JSON-RPC-Anfragen zu verarbeiten.

Frames werden über Zeitstempel abgeglichen, nicht über Indizes. Wenn die Maschine zurückfällt, liegt Quellframe N nicht bei N/fps. frame_times.json enthält die echte Aufnahmezeit jedes Frames, und der Compositor sucht Frames darüber nach – das hält die Kamera auf den Klicks, wenn die Maschine stottert.

Konfiguration

Rendern

desktop_render(out_dir, name="demo.mp4", max_zoom=2.0, narration="") – narration akzeptiert eine JSON-Liste von {"text": …, "at": Sekunden}.

Alles andere ist eine Modulkonstante, die direkt bearbeitet wird:

desktop_record_start(window, out_dir="", fps=30) verwendet standardmäßig ~/screencasts/take-HHMMSS.

Wenn max_zoom nicht angegeben ist, wählt camera.build() selbst eine Obergrenze, sodass mindestens 70 % der Fensterhöhe im Bild bleiben – ein hohes schmales Fenster, das in ein 16:9-Bild passt, ist bereits klein, und ein erzwungenes 2× schneidet dort den Teil ab, der der Aktion ihre Bedeutung verleiht. (Beim Taschenrechner hat es das Display abgeschnitten, das das Ergebnis zeigte.)

Erzählung

Setzen Sie ELEVENLABS_API_KEY in der Umgebung oder in einer .env-Datei im Plugin-Root (KEY=value, eine pro Zeile – die Datei ist git-ignoriert). Optional können Sie eine Stimme mit ELEVENLABS_VOICE_ID festlegen; wenn keine gesetzt ist, wird die erste Stimme des Kontos verwendet. Modell: eleven_multilingual_v2. Weisen Sie SCREENCAST_ENV_FILE woanders hin, wenn Sie Ihre Schlüssel woanders aufbewahren.

voice.resolve_voice() prüft konfigurierte IDs gegen die tatsächliche Stimmliste des Kontos, bevor eine verwendet wird, da eine gelöschte Stimme sonst mit einem unerklärlichen 404 fehlschlägt.

Ohne einen Schlüssel bricht nichts. doctor.py meldet es als Warnung, nicht als Fehler, und desktop_render erzeugt ein stummes Video – was es auch mit einem Schlüssel erzeugt, wenn kein narration-Argument übergeben wird.

Die Sounddesign-Ebene degradiert ohne Schlüssel, statt zu sterben: sfx_bank.build() benötigt ElevenLabs, um die Palette zu erzeugen, aber sfx_bank.build_synthetic() synthetisiert dieselben Familien offline mit numpy (die Dateien *_syn1.wav / *_syn2.wav), und sfx.click_samples() fällt auf synth_click() zurück, wenn keine Sample-Assets gefunden werden. Eine Offline-Maschine erhält also weiterhin Klicks, Whooshes und Impacts – sie verliert nur die Stimme.

Bekannte Einschränkungen

Ehrliche Liste. Diese sind real, derzeit wahr und meist Dinge, auf die man während der Entwicklung gestoßen ist. Was dazu geplant ist, in Prioritätsreihenfolge mit den Messungen hinter jedem Punkt, steht in ROADMAP.md.

• Das desktop_render-Tool rendert weniger, als die Codebasis kann. Es ruft composer.compose() ohne intro, outro oder captions auf und mischt nur die Erzählung – keine Klick-Spur, keine Whooshes, kein Musikbett. Alles andere ist implementiert und funktioniert, aber derzeit nur über server/make_showcase.py erreichbar, ein Skript mit eigenem fest codierten Aufnahmepfad und Beat-Liste. Diese Parameter durch das Tool zu verdrahten ist die offensichtlichste offene Aufgabe in diesem Repository.

• Kein Ziehen. Es gibt kein Zieh- oder Drag-and-Drop-Werkzeug. Maus-nach-unten und Maus-nach-oben werden immer an derselben Position ausgegeben, sodass alles, was eine Drücken-Bewegen-Loslassen-Geste erfordert – Schieberegler, Neuanordnen, Zeichnen auf der Leinwand, Größenänderung per Griff – unerreichbar ist.

• Tastendrücke werden nicht in das Ereignisprotokoll geschrieben. desktop_key sendet den Tastendruck, protokolliert ihn aber nicht, sodass die Kamera nie auf reine Tastatur-Schritte reagiert und diese nicht in desktop_describe_take erscheinen. Klicks und getippter Text (desktop_type) werden protokolliert; einzelne Tastendrücke nicht.

• UWP-Fenster müssen über ihr Rahmenfenster angesprochen werden. Windows Graphics Capture benötigt einen Handle des obersten Fensters. Für eine UWP-/Store-App ist das das sichtbare ApplicationFrameWindow – das innere CoreWindow ist kein brauchbares Aufnahmeziel. In der Praxis: Lösen Sie die App über ihren sichtbaren Fenstertitel auf (das tun die Werkzeuge) und versuchen Sie nicht, darüber hinauszugreifen.

• desktop_screenshot ist ein Ausschnitt des Bildschirms, keine Fensteraufnahme. Es erfasst den Bildschirmbereich, den das Fenster belegt. Alles, was das Fenster überlappt – ein anderes Fenster, eine Benachrichtigungs-Toast, ein Tooltip – erscheint im Screenshot. (Die Aufnahme hat dieses Problem nicht: WGC erfasst das Fenster selbst.) Stellen Sie sicher, dass das Zielfenster im Vordergrund ist, bevor Sie einem Screenshot vertrauen.

• Electron-Apps legen fast nichts für UI Automation offen. Gemessen unter Windows 11: Eine typische Electron-App gibt 2 bis 6 benannte Elemente zurück – Fenster-Wrapper, keine Schnittstellen. Fallen Sie auf Screenshots und Koordinaten zurück oder verwenden Sie desktop_dom, wenn ein Debug-Port verfügbar ist. desktop_dom_launch öffnet eine zweite Kopie der App mit einem separaten Profil, das nicht angemeldet ist.

• NVENC ist praktisch erforderlich. Sowohl wgc.WindowRecorder als auch composer.compose() verwenden standardmäßig h264_nvenc. libx264-Pfade sind implementiert und doctor.py erkennt den richtigen Encoder in machine.json, aber nichts verdrahtet diese Wahl bisher automatisch. Auf einem Rechner ohne NVENC müssen Sie den Encoder selbst übergeben.

• Große Dateien. Filmkorn wird pro Bild angewendet, was die Inter-Frame-Kompression zunichtemacht – eine kurze Demo ist schwerer als dasselbe Material ohne Korn. Setzen Sie grain_amount=0, wenn die Größe wichtiger ist als das Aussehen.

• Ein Take ist auf 15 Minuten begrenzt. recorder_proc.py stoppt sich selbst, sodass eine vergessene Aufnahme nicht ewig laufen kann.

• Nur Windows und nur der interaktive Desktop. SendInput, UI Automation, WGC und die WinRT-OCR sind alles Windows-APIs; nichts davon funktioniert über eine unbeaufsichtigte Sitzung, in einem Dienst oder auf einem gesperrten Bildschirm.

• Das Fenster ist eine Live-Anwendung. Der Zustand überlebt zwischen Takes – ein von einer Probe offen gelassenes Suchfeld verwandelte ein getipptes Wort in „githubgithub". Setzen Sie die App vor dem sauberen Take zurück.

• Die Datenschutzprüfung meldet, sie blockiert nicht. Der Abgleich ist wörtlich; ein Name in einem Menü ist kein Leck, und OCR übersieht Dinge. Schauen Sie sich das Bild selbst an, bevor Sie es veröffentlichen.

Danksagungen und Lizenzen

• sbroenne/mcp-windows (MIT) – der windows-ui-MCP-Server, der UI Automation übernimmt. Nicht hier eingecheckt; wird bei Bedarf von server/fetch_ui_binary.py heruntergeladen und gegen die eigene SHA256SUMS.txt der Version per Prüfsumme verifiziert.

• ffmpeg – Aufnahme-Encoding, der Audio-Mix und die ffprobe-Dauermessung. Wird als externes Binärprogramm aufgerufen; nicht gebündelt. Die Lizenzierung hängt von dem Build ab, den Sie installieren (LGPL oder GPL).

• Soundbank. Die .wav-Dateien unter server/sfx_bank/ sind generiert, nicht gesampelt: server/sfx_bank.py erstellt sie einmalig aus Prompt-Rezepten über die ElevenLabs-Soundgenerierungs-API und cached sie, und jeder Kandidat wird per Messung geprüft (ein „Klick", dessen Peak 200 ms drin ist, wird abgelehnt, egal wie gut er klingt). Eine zweite Familie von Dateien – *_syn1.wav, *_syn2.wav – wird vollständig offline in sfx_bank.build_synthetic() mit numpy synthetisiert, sodass eine Maschine ohne API-Schlüssel trotzdem Sounddesign erhält. Hier wird keine Drittanbieter-Sample-Bibliothek weiterverteilt. Weisen Sie SCREENCAST_SFX_DIR auf Ihren eigenen Sample-Ordner, und sfx.py bevorzugt diese Klicks und Musikbetten gegenüber der mitgelieferten Bank; wenn nichts gesetzt ist, verwendet es server/sfx_bank/, und wenn nichts gefunden wird, synthetisiert es. Keine harte Abhängigkeit in beide Richtungen.

• ElevenLabs – optional, für Erzählung und zum Aufbau der Soundbank. Bringen Sie Ihren eigenen Schlüssel mit; das Plugin enthält kein Audio, das aus der Stimme einer Person generiert wurde.

• Schriftarten – Titel und Untertitel verwenden Segoe UI, das mit Windows geliefert wird, mit Arial als Fallback. Es werden keine Schriftdateien weiterverteilt.

• Model Context Protocol Python SDK (MIT) – das Server-Framework.

Der eigene Code des Plugins wird unter der MIT-Lizenz veröffentlicht. Siehe LICENSE.

Mitwirken

Issues and pull requests are welcome. A few things that make review quick:

• Nur Windows. Testen Sie auf einem echten Desktop; es gibt kein CI, das für Sie Schaltflächen klicken kann.

• Führen Sie zuerst den doctor aus (python server/doctor.py) und fügen Sie dessen Ausgabe in einen Fehlerbericht ein — die meisten Probleme hier sind umgebungsbedingt (DPI-Skalierung, Monitoranordnung, fehlender Encoder) und der doctor benennt sie direkt.

• Wenn es stillschweigend kaputtgeht, sagen Sie das in einem Kommentar. Diese Codebasis ist voller Notizen, die erklären, warum eine Zeile so ist, wie sie ist, denn fast jede davon ist ein Fehler, der wie ein Erfolg aussah: identische Frames, die als Aufnahme durchgehen, eine Kamera, die vom Rand abdriftet, ein leeres Ereignisprotokoll, das ein Video ohne jeglichen Zoom erzeugt. Diese Notizen zu behalten ist beabsichtigt.

• Änderungen an Kamera- oder Timeline-Konstanten benötigen einen Vorher/Nachher-Clip. Sie sind Ermessensentscheidungen darüber, wie das Ergebnis aussieht, und kein Test kann sie klären.