davinci-resolve-mcp 2.23.0

package/src/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+DaVinci Resolve MCP Utilities Package
+""" 

package/src/utils/app_control.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+"""
+DaVinci Resolve MCP Server - Application Control Utilities
+
+This module provides functions for controlling DaVinci Resolve application:
+- Quitting the application
+- Checking application state
+- Handling basic application functions
+"""
+
+import os
+import logging
+import time
+import sys
+import platform
+import subprocess
+from typing import Dict, Any, Optional, Union, List
+
+# Configure logging
+logger = logging.getLogger("davinci-resolve-mcp.app_control")
+APP_CONTROL_TIMEOUT_SECONDS = 10
+
+
+def _run_app_command(
+    cmd: List[str],
+    description: str,
+    timeout: int = APP_CONTROL_TIMEOUT_SECONDS,
+) -> bool:
+    """Run a platform app-control command with a bounded wait."""
+    try:
+        result = subprocess.run(
+            cmd,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        logger.error("%s timed out after %ss: %s", description, timeout, cmd)
+        return False
+    except OSError as exc:
+        logger.error("%s failed to launch: %s", description, exc)
+        return False
+
+    if result.returncode != 0:
+        stderr = (result.stderr or "").strip()
+        logger.warning(
+            "%s exited with code %s%s",
+            description,
+            result.returncode,
+            f": {stderr}" if stderr else "",
+        )
+        return False
+    return True
+
+
+def quit_resolve_app(resolve_obj, force: bool = False, save_project: bool = True) -> bool:
+    """
+    Quit DaVinci Resolve application.
+    
+    Args:
+        resolve_obj: DaVinci Resolve API object
+        force: Whether to force quit even if unsaved changes (potentially dangerous)
+        save_project: Whether to save the project before quitting
+        
+    Returns:
+        True if the quit command was sent successfully
+    """
+    try:
+        logger.info("Attempting to quit DaVinci Resolve")
+        
+        # Check if a project is open
+        pm = resolve_obj.GetProjectManager()
+        if pm:
+            project = pm.GetCurrentProject()
+            if project and save_project:
+                logger.info("Saving project before quitting")
+                # Try to save the project
+                try:
+                    project.SaveProject()
+                except Exception as e:
+                    logger.error(f"Failed to save project: {str(e)}")
+                    if not force:
+                        logger.error("Aborting quit due to save failure")
+                        return False
+        
+        # Attempt to quit using the API
+        if hasattr(resolve_obj, 'Quit') and callable(getattr(resolve_obj, 'Quit')):
+            logger.info("Using Resolve.Quit() API")
+            resolve_obj.Quit()
+            return True
+        
+        # If Quit method isn't available or fails, use platform-specific methods
+        sys_platform = platform.system().lower()
+        
+        if sys_platform == 'darwin':
+            # macOS - use AppleScript
+            logger.info("Using AppleScript to quit Resolve on macOS")
+            cmd = [
+                'osascript',
+                '-e', 'tell application "DaVinci Resolve" to quit'
+            ]
+            if force:
+                # Add force option if requested
+                cmd = [
+                    'osascript',
+                    '-e', 'tell application "DaVinci Resolve" to quit with saving'
+                ]
+            
+            return _run_app_command(cmd, "macOS Resolve quit command")
+            
+        elif sys_platform == 'windows':
+            # Windows - use taskkill
+            logger.info("Using taskkill to quit Resolve on Windows")
+            if force:
+                return _run_app_command(
+                    ['taskkill', '/F', '/IM', 'Resolve.exe'],
+                    "Windows Resolve force-quit command",
+                )
+            else:
+                return _run_app_command(
+                    ['taskkill', '/IM', 'Resolve.exe'],
+                    "Windows Resolve quit command",
+                )
+            
+        elif sys_platform == 'linux':
+            # Linux - use pkill
+            logger.info("Using pkill to quit Resolve on Linux")
+            if force:
+                return _run_app_command(
+                    ['pkill', '-9', 'resolve'],
+                    "Linux Resolve force-quit command",
+                )
+            else:
+                return _run_app_command(
+                    ['pkill', 'resolve'],
+                    "Linux Resolve quit command",
+                )
+            
+        # If all methods fail, return False
+        logger.error("Failed to quit Resolve via any method")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error quitting DaVinci Resolve: {str(e)}")
+        return False
+
+def get_app_state(resolve_obj) -> Dict[str, Any]:
+    """
+    Get DaVinci Resolve application state information.
+    
+    Args:
+        resolve_obj: DaVinci Resolve API object
+        
+    Returns:
+        Dictionary with application state information
+    """
+    state = {
+        "connected": resolve_obj is not None,
+        "version": "Unknown",
+        "product_name": "Unknown",
+        "platform": platform.system(),
+        "python_version": sys.version,
+    }
+    
+    if resolve_obj:
+        try:
+            state["version"] = resolve_obj.GetVersionString()
+        except Exception:
+            logger.debug("Could not read Resolve version string", exc_info=True)
+            
+        try:
+            state["product_name"] = resolve_obj.GetProductName()
+        except Exception:
+            logger.debug("Could not read Resolve product name", exc_info=True)
+            
+        try:
+            state["current_page"] = resolve_obj.GetCurrentPage()
+        except Exception:
+            logger.debug("Could not read Resolve current page", exc_info=True)
+            state["current_page"] = "Unknown"
+            
+        # Get project manager and project information
+        try:
+            pm = resolve_obj.GetProjectManager()
+            if pm:
+                state["project_manager_available"] = True
+                
+                current_project = pm.GetCurrentProject()
+                if current_project:
+                    state["project_open"] = True
+                    state["project_name"] = current_project.GetName()
+                    
+                    # Check if timeline is open
+                    current_timeline = current_project.GetCurrentTimeline()
+                    if current_timeline:
+                        state["timeline_open"] = True
+                        state["timeline_name"] = current_timeline.GetName()
+                    else:
+                        state["timeline_open"] = False
+                else:
+                    state["project_open"] = False
+            else:
+                state["project_manager_available"] = False
+        except Exception as e:
+            state["project_error"] = str(e)
+    
+    return state
+
+def restart_resolve_app(resolve_obj, wait_seconds: int = 5) -> bool:
+    """
+    Restart DaVinci Resolve application.
+    
+    Args:
+        resolve_obj: DaVinci Resolve API object
+        wait_seconds: Seconds to wait between quit and restart
+        
+    Returns:
+        True if restart was initiated successfully
+    """
+    try:
+        # Get Resolve executable path for restart
+        if platform.system().lower() == 'darwin':
+            resolve_path = '/Applications/DaVinci Resolve/DaVinci Resolve.app'
+        elif platform.system().lower() == 'windows':
+            # Default path, may need to be customized
+            resolve_path = r'C:\Program Files\Blackmagic Design\DaVinci Resolve\Resolve.exe'
+        elif platform.system().lower() == 'linux':
+            # Default path, may need to be customized
+            resolve_path = '/opt/resolve/bin/resolve'
+        else:
+            return False
+        
+        # Quit Resolve
+        if not quit_resolve_app(resolve_obj, force=False, save_project=True):
+            logger.error("Failed to quit Resolve for restart")
+            return False
+        
+        # Wait for the app to close
+        logger.info(f"Waiting {wait_seconds} seconds for Resolve to close")
+        time.sleep(wait_seconds)
+        
+        # Start Resolve again
+        logger.info("Attempting to start Resolve")
+        
+        if platform.system().lower() == 'darwin':
+            subprocess.Popen(['open', resolve_path])
+        elif platform.system().lower() == 'windows':
+            subprocess.Popen([resolve_path])
+        elif platform.system().lower() == 'linux':
+            subprocess.Popen([resolve_path])
+        
+        return True
+    except Exception as e:
+        logger.error(f"Error restarting DaVinci Resolve: {str(e)}")
+        return False
+
+def open_project_settings(resolve_obj) -> bool:
+    """
+    Open the Project Settings dialog in DaVinci Resolve.
+    
+    Args:
+        resolve_obj: DaVinci Resolve API object
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Check if UI Manager is available
+        ui_manager = resolve_obj.GetUIManager()
+        if not ui_manager:
+            logger.error("Failed to get UI Manager")
+            return False
+        
+        # Open Project Settings dialog
+        if hasattr(ui_manager, 'OpenProjectSettings') and callable(getattr(ui_manager, 'OpenProjectSettings')):
+            ui_manager.OpenProjectSettings()
+            return True
+        
+        # Alternative method - send keyboard shortcut based on platform
+        current_page = resolve_obj.GetCurrentPage()
+        
+        # Ensure we're on a page that supports project settings
+        if current_page not in ['media', 'cut', 'edit', 'fusion', 'color', 'fairlight', 'deliver']:
+            logger.error(f"Can't open settings from page: {current_page}")
+            return False
+        
+        return False  # Keyboard shortcuts not implemented yet
+    except Exception as e:
+        logger.error(f"Error opening project settings: {str(e)}")
+        return False
+
+def open_preferences(resolve_obj) -> bool:
+    """
+    Open the Preferences dialog in DaVinci Resolve.
+    
+    Args:
+        resolve_obj: DaVinci Resolve API object
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Check if UI Manager is available
+        ui_manager = resolve_obj.GetUIManager()
+        if not ui_manager:
+            logger.error("Failed to get UI Manager")
+            return False
+        
+        # Open Preferences dialog
+        if hasattr(ui_manager, 'OpenPreferences') and callable(getattr(ui_manager, 'OpenPreferences')):
+            ui_manager.OpenPreferences()
+            return True
+        
+        # Alternative method - send keyboard shortcut based on platform
+        return False  # Keyboard shortcuts not implemented yet
+    except Exception as e:
+        logger.error(f"Error opening preferences: {str(e)}")
+        return False

package/src/utils/audio_fairlight_live_probe.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""Live Audio / Fairlight boundary probe."""
+
+from __future__ import annotations
+
+import json
+import platform
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
+
+
+def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
+    if not isinstance(result, dict):
+        raise AssertionError(f"{label}: expected dict, got {result!r}")
+    if result.get("error"):
+        raise AssertionError(f"{label}: {result['error']}")
+    if "success" in result and result["success"] is not True:
+        raise AssertionError(f"{label}: expected success=True, got {result!r}")
+    return result
+
+
+def _record_tool_result(
+    recorder: ProbeRecorder,
+    category: str,
+    name: str,
+    result: Dict[str, Any],
+    *,
+    expected_status: Optional[str] = None,
+) -> None:
+    if not isinstance(result, dict):
+        recorder.record(category, name, "error", details={"reason": "non-dict result", "result": repr(result)})
+        return
+    if result.get("error"):
+        recorder.record(category, name, expected_status or "error", details={"reason": result.get("error")}, evidence=result)
+        return
+    if "success" in result and result["success"] is not True:
+        recorder.record(category, name, expected_status or "partially_supported", details={"reason": "success returned false"}, evidence=result)
+        return
+    recorder.record(category, name, expected_status or "supported", evidence=result)
+
+
+def _run_ffmpeg(args: list[str]) -> None:
+    subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True)
+
+
+def _make_synthetic_media(work_dir: Path) -> Dict[str, Path]:
+    video = work_dir / "audio_fairlight_video.mov"
+    audio = work_dir / "audio_fairlight_audio.wav"
+    _run_ffmpeg(
+        [
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc2=size=640x360:rate=24:duration=3",
+            "-f",
+            "lavfi",
+            "-i",
+            "sine=frequency=440:sample_rate=48000:duration=3",
+            "-shortest",
+            "-pix_fmt",
+            "yuv420p",
+            "-c:v",
+            "libx264",
+            "-c:a",
+            "aac",
+            "-y",
+            str(video),
+        ]
+    )
+    _run_ffmpeg(["-f", "lavfi", "-i", "sine=frequency=440:sample_rate=48000:duration=3", "-y", str(audio)])
+    return {"video": video, "audio": audio}
+
+
+def _first_imported(imported_items):
+    for item in imported_items or []:
+        try:
+            if item.GetUniqueId():
+                return item
+        except Exception:
+            pass
+    return None
+
+
+def _clip_id(clip) -> Optional[str]:
+    try:
+        return str(clip.GetUniqueId())
+    except Exception:
+        return None
+
+
+def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, Any]:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    work_dir = Path(tempfile.mkdtemp(prefix="mcp_audio_fairlight_probe_"))
+    project_name = f"_mcp_audio_fairlight_probe_{int(time.time())}"
+    timeline_name = "Audio Fairlight Probe"
+    recorder = ProbeRecorder()
+    created_project = False
+    delete_result: Optional[Dict[str, Any]] = None
+
+    metadata: Dict[str, Any] = {
+        "title": "Audio / Fairlight Kernel Capability Probe",
+        "timestamp_utc": utc_timestamp(),
+        "python": sys.version,
+        "platform": platform.platform(),
+        "output_dir": str(output_dir),
+        "project_name": project_name,
+    }
+
+    try:
+        version = _require_success("resolve_control.get_version", server.resolve_control("get_version"))
+        metadata.update(
+            {
+                "product": version.get("product"),
+                "version": version.get("version"),
+                "version_string": version.get("version_string"),
+            }
+        )
+        print(f"Connected to {metadata['product']} {metadata['version_string']}")
+
+        _require_success("project_manager.create", server.project_manager("create", {"name": project_name}))
+        created_project = True
+        print(f"Created disposable project: {project_name}")
+        server.resolve_control("open_page", {"page": "edit"})
+
+        assets = _make_synthetic_media(work_dir)
+        metadata["synthetic_media"] = {key: str(value) for key, value in assets.items()}
+        print(f"Generated synthetic media under: {work_dir}")
+
+        resolve = server.get_resolve()
+        project = resolve.GetProjectManager().GetCurrentProject()
+        media_pool = project.GetMediaPool()
+        imported = media_pool.ImportMedia([str(assets["video"]), str(assets["audio"])]) or []
+        if len(imported) < 2:
+            raise AssertionError("Failed to import synthetic audio media")
+        video_clip = _first_imported([imported[0]])
+        audio_clip = _first_imported([imported[1]])
+        if not video_clip or not audio_clip:
+            raise AssertionError("Failed to resolve imported audio MediaPoolItems")
+        timeline = media_pool.CreateTimelineFromClips(timeline_name, [video_clip])
+        if not timeline:
+            raise AssertionError("Failed to create audio timeline")
+        project.SetCurrentTimeline(timeline)
+        print(f"Created timeline: {timeline_name}")
+
+        video_clip_id = _clip_id(video_clip)
+        audio_clip_id = _clip_id(audio_clip)
+        clip_ids = [clip_id for clip_id in (video_clip_id, audio_clip_id) if clip_id]
+
+        _record_tool_result(recorder, "capabilities", "audio_capabilities", server.timeline("audio_capabilities"))
+        _record_tool_result(recorder, "track", "probe_audio_track", server.timeline("probe_audio_track", {"track_index": 1}))
+        _record_tool_result(recorder, "item", "probe_audio_item", server.timeline("probe_audio_item", {"track_type": "audio", "track_index": 1, "item_index": 0}))
+        _record_tool_result(
+            recorder,
+            "item",
+            "safe_set_audio_properties_dry_run",
+            server.timeline("safe_set_audio_properties", {"track_type": "audio", "track_index": 1, "item_index": 0, "properties": {"Volume": -3}, "dry_run": True}),
+        )
+        _record_tool_result(
+            recorder,
+            "item",
+            "safe_set_audio_properties_restore",
+            server.timeline("safe_set_audio_properties", {"track_type": "audio", "track_index": 1, "item_index": 0, "properties": {"Volume": -3}, "restore": True}),
+        )
+        _record_tool_result(recorder, "voice", "voice_isolation_capabilities", server.timeline("voice_isolation_capabilities", {"track_index": 1, "track_type": "audio"}))
+        _record_tool_result(recorder, "mapping", "audio_mapping_report", server.timeline("audio_mapping_report", {"clip_ids": clip_ids}))
+        _record_tool_result(
+            recorder,
+            "sync",
+            "safe_auto_sync_audio_dry_run",
+            server.timeline("safe_auto_sync_audio", {"clip_ids": clip_ids, "settings": {"syncBy": "waveform", "channel": "auto"}, "dry_run": True}),
+        )
+        auto_sync = server.timeline("safe_auto_sync_audio", {"clip_ids": clip_ids, "settings": {"syncBy": "waveform", "channel": "auto"}, "dry_run": False})
+        _record_tool_result(
+            recorder,
+            "sync",
+            "safe_auto_sync_audio_execute",
+            auto_sync,
+            expected_status=None if auto_sync.get("success") else "partially_supported",
+        )
+        _record_tool_result(recorder, "transcription", "transcription_capabilities", server.timeline("transcription_capabilities", {"clip_ids": clip_ids}))
+
+        if video_clip_id:
+            transcribe = server.media_pool_item("transcribe_audio", {"clip_id": video_clip_id})
+            _record_tool_result(
+                recorder,
+                "transcription",
+                "media_pool_item_transcribe_audio",
+                transcribe,
+                expected_status=None if transcribe.get("success") else "version_or_page_dependent",
+            )
+            clear = server.media_pool_item("clear_transcription", {"clip_id": video_clip_id})
+            _record_tool_result(
+                recorder,
+                "transcription",
+                "media_pool_item_clear_transcription",
+                clear,
+                expected_status=None if clear.get("success") else "version_or_page_dependent",
+            )
+
+        subtitles = server.timeline("subtitle_generation_probe", {"settings": {}, "allow_generate": True})
+        _record_tool_result(
+            recorder,
+            "subtitles",
+            "subtitle_generation_probe_execute",
+            subtitles,
+            expected_status=None if subtitles.get("success") else "version_or_page_dependent",
+        )
+
+        _record_tool_result(
+            recorder,
+            "fairlight",
+            "get_fairlight_presets",
+            server.resolve_control("get_fairlight_presets"),
+            expected_status=None,
+        )
+        _record_tool_result(
+            recorder,
+            "fairlight",
+            "insert_audio",
+            server.project_settings("insert_audio", {"media_path": str(assets["audio"]), "start_offset": 0, "duration": 24}),
+        )
+        _record_tool_result(recorder, "report", "fairlight_boundary_report", server.timeline("fairlight_boundary_report", {"clip_ids": clip_ids}))
+
+        if keep_open:
+            server.project_manager("save")
+            print(f"LEFT PROJECT OPEN FOR INSPECTION: {project_name}")
+            created_project = False
+
+    finally:
+        if created_project:
+            server.project_manager("save")
+            server.project_manager("close")
+            delete_result = server.project_manager("delete", {"name": project_name})
+            print(f"Deleted disposable project: {delete_result}")
+
+    report = recorder.to_report(
+        metadata,
+        {
+            "json": str(output_dir / "audio-fairlight-probe.json"),
+            "markdown": str(output_dir / "audio-fairlight-probe.md"),
+        },
+    )
+    json_path = output_dir / "audio-fairlight-probe.json"
+    markdown_path = output_dir / "audio-fairlight-probe.md"
+    json_path.write_text(json.dumps(report, indent=2, sort_keys=True), encoding="utf-8")
+    markdown_path.write_text(render_markdown_report(report), encoding="utf-8")
+    print(f"Wrote JSON report: {json_path}")
+    print(f"Wrote Markdown report: {markdown_path}")
+    print(f"Counts: {json.dumps(report['counts'], sort_keys=True)}")
+    if not keep_open:
+        shutil.rmtree(work_dir, ignore_errors=True)
+        print(f"Removed synthetic media directory: {work_dir}")
+
+    if delete_result and delete_result.get("success") is not True:
+        raise AssertionError(f"Cleanup failed for {project_name}: {delete_result!r}")
+    return report

package/src/utils/cdl.py

@@ -0,0 +1,20 @@
+"""CDL normalization helpers shared by compound and granular servers."""
+
+from typing import Any, Dict
+
+
+def normalize_cdl_payload(cdl: Any) -> Any:
+    """Resolve's SetCDL expects strings like ``"1.0 1.0 1.0"`` instead of arrays."""
+    if not isinstance(cdl, dict):
+        return cdl
+    out: Dict[str, Any] = {}
+    for key, value in cdl.items():
+        if isinstance(value, (list, tuple)):
+            out[key] = " ".join(str(item) for item in value)
+        elif isinstance(value, bool):
+            out[key] = str(value)
+        elif isinstance(value, (int, float)):
+            out[key] = str(value)
+        else:
+            out[key] = value
+    return out