davinci-resolve-mcp 2.23.0

package/src/utils/platform.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""
+Platform-specific functionality for DaVinci Resolve MCP Server
+"""
+
+import os
+import sys
+import platform
+
+def get_platform():
+    """Identify the current operating system platform.
+    
+    Returns:
+        str: 'windows', 'darwin' (macOS), or 'linux'
+    """
+    system = platform.system().lower()
+    if system == 'darwin':
+        return 'darwin'
+    elif system == 'windows':
+        return 'windows'
+    elif system == 'linux':
+        return 'linux'
+    return system
+
+def get_resolve_paths():
+    """Get platform-specific paths for DaVinci Resolve scripting API.
+    
+    Returns:
+        dict: Dictionary containing api_path, lib_path, and modules_path
+    """
+    platform_name = get_platform()
+    
+    if platform_name == 'darwin':  # macOS
+        api_path = "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting"
+        lib_path = "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so"
+        modules_path = os.path.join(api_path, "Modules")
+    
+    elif platform_name == 'windows':  # Windows
+        program_files = os.environ.get('PROGRAMDATA', 'C:\\ProgramData')
+        program_files_64 = os.environ.get('PROGRAMFILES', 'C:\\Program Files')
+        
+        api_path = os.path.join(program_files, 'Blackmagic Design', 'DaVinci Resolve', 'Support', 'Developer', 'Scripting')
+        lib_path = os.path.join(program_files_64, 'Blackmagic Design', 'DaVinci Resolve', 'fusionscript.dll')
+        modules_path = os.path.join(api_path, "Modules")
+    
+    elif platform_name == 'linux':  # Linux (not fully implemented)
+        # Default locations for Linux - these may need to be adjusted
+        api_path = "/opt/resolve/Developer/Scripting"
+        lib_path = "/opt/resolve/libs/fusionscript.so"
+        modules_path = os.path.join(api_path, "Modules")
+    
+    else:
+        # Fallback to macOS paths if unknown platform
+        api_path = "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting"
+        lib_path = "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so"
+        modules_path = os.path.join(api_path, "Modules")
+    
+    return {
+        "api_path": api_path,
+        "lib_path": lib_path,
+        "modules_path": modules_path
+    }
+
+def get_resolve_plugin_paths():
+    """Get platform-specific paths for Resolve plugin install dirs.
+
+    Returns:
+        dict: {
+            'fuses_dir':  Fusion Fuses directory,
+            'dctl_dir':   LUT directory (where regular .dctl files live),
+            'aces_idt_dir': ACES IDT transforms (separate scan path; restart
+                            required after install),
+            'aces_odt_dir': ACES ODT transforms (same caveat),
+        }
+    """
+    platform_name = get_platform()
+    home = os.path.expanduser("~")
+
+    # NOTE: The Fuse SDK doc (June 2023) lists Fuses under "Support/Fusion/Fuses"
+    # on macOS, but the directory Resolve actually scans is the sibling
+    # "Fusion/Fuses" (without "Support") — verified live against Resolve Studio
+    # 20.3.2.9 by writing test fuses to both paths and observing which loaded.
+    # Per-platform conventions also differ from the SDK doc; we follow the
+    # canonical Fusion user-data layout where every Fusion user directory
+    # (Macros, Templates, Scripts, Modules, Fuses, ...) lives directly under
+    # the platform's Fusion user root.
+    if platform_name == 'darwin':
+        support = os.path.join(home, "Library", "Application Support",
+                               "Blackmagic Design", "DaVinci Resolve")
+        fuses_dir = os.path.join(support, "Fusion", "Fuses")
+        dctl_dir = os.path.join(support, "LUT")
+        aces_root = os.path.join(support, "ACES Transforms")
+    elif platform_name == 'windows':
+        appdata = os.environ.get('APPDATA', os.path.join(home, 'AppData', 'Roaming'))
+        fuses_dir = os.path.join(appdata, 'Blackmagic Design', 'DaVinci Resolve',
+                                 'Support', 'Fusion', 'Fuses')
+        dctl_dir = os.path.join(appdata, 'Blackmagic Design', 'DaVinci Resolve',
+                                'Support', 'LUT')
+        aces_root = os.path.join(appdata, 'Blackmagic Design', 'DaVinci Resolve',
+                                 'Support', 'ACES Transforms')
+    elif platform_name == 'linux':
+        base = os.path.join(home, '.local', 'share', 'DaVinciResolve')
+        fuses_dir = os.path.join(base, 'Fusion', 'Fuses')
+        dctl_dir = os.path.join(base, 'LUT')
+        aces_root = os.path.join(base, 'ACES Transforms')
+    else:
+        support = os.path.join(home, "Library", "Application Support",
+                               "Blackmagic Design", "DaVinci Resolve")
+        fuses_dir = os.path.join(support, "Fusion", "Fuses")
+        dctl_dir = os.path.join(support, "LUT")
+        aces_root = os.path.join(support, "ACES Transforms")
+
+    # Resolve scans these subdirs of Fusion/Scripts/ at startup and exposes
+    # them in Workspace → Scripts → <category>. Categories per Resolve docs.
+    if platform_name == 'darwin':
+        scripts_root = os.path.join(support, "Fusion", "Scripts")
+    elif platform_name == 'windows':
+        scripts_root = os.path.join(appdata, 'Blackmagic Design', 'DaVinci Resolve',
+                                    'Support', 'Fusion', 'Scripts')
+    elif platform_name == 'linux':
+        scripts_root = os.path.join(base, 'Fusion', 'Scripts')
+    else:
+        scripts_root = os.path.join(support, "Fusion", "Scripts")
+
+    return {
+        "fuses_dir": fuses_dir,
+        "dctl_dir": dctl_dir,
+        "aces_idt_dir": os.path.join(aces_root, "IDT"),
+        "aces_odt_dir": os.path.join(aces_root, "ODT"),
+        "scripts_root": scripts_root,
+        # Category subdirs Resolve actually scans (verified live):
+        "scripts_categories": ("Edit", "Color", "Deliver", "Comp",
+                               "Tool", "Utility", "Views"),
+    }
+
+
+def setup_environment():
+    """Set up environment variables for DaVinci Resolve scripting.
+    
+    Returns:
+        bool: True if setup was successful, False otherwise
+    """
+    try:
+        paths = get_resolve_paths()
+        
+        os.environ["RESOLVE_SCRIPT_API"] = paths["api_path"]
+        os.environ["RESOLVE_SCRIPT_LIB"] = paths["lib_path"]
+        
+        # Add modules path to Python's path if it's not already there
+        if paths["modules_path"] not in sys.path:
+            sys.path.append(paths["modules_path"])
+        
+        return True
+    
+    except Exception as e:
+        print(f"Error setting up environment: {str(e)}")
+        return False 

package/src/utils/project_lifecycle_live_probe.py

@@ -0,0 +1,376 @@
+#!/usr/bin/env python3
+"""Live Project / Database / Archive boundary probe."""
+
+from __future__ import annotations
+
+import json
+import platform
+import shutil
+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 _delete_disposable_project(server, name: str) -> Dict[str, Any]:
+    result = server.project_manager(
+        "safe_project_delete",
+        {"name": name, "close_current": True, "save_current": True},
+    )
+    if result.get("error") and "currently open" in result.get("error", ""):
+        result = server.project_manager("safe_project_delete", {"name": name})
+    return result
+
+
+def _first_setting_value(snapshot: Dict[str, Any], keys: list[str]) -> Optional[Dict[str, Any]]:
+    settings = snapshot.get("settings")
+    if not isinstance(settings, dict):
+        return None
+    for key in keys:
+        value = settings.get(key)
+        if value not in (None, ""):
+            return {key: value}
+    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_project_lifecycle_probe_"))
+    timestamp = int(time.time())
+    project_name = f"_mcp_project_lifecycle_probe_{timestamp}"
+    imported_name = f"_mcp_project_lifecycle_import_{timestamp}"
+    restored_name = f"_mcp_project_lifecycle_restore_{timestamp}"
+    archive_restored_name = f"_mcp_project_lifecycle_archive_restore_{timestamp}"
+    timeline_name = "Project Lifecycle Probe Timeline"
+    folder_name = f"_mcp_project_folder_{timestamp}"
+    layout_name = f"_mcp_layout_probe_{timestamp}"
+    layout_import_name = f"_mcp_layout_import_{timestamp}"
+    cleanup_projects: list[str] = []
+    cleanup_layouts: list[str] = []
+    delete_results: Dict[str, Any] = {}
+    recorder = ProbeRecorder()
+
+    metadata: Dict[str, Any] = {
+        "title": "Project / Database / Archive Kernel Capability Probe",
+        "timestamp_utc": utc_timestamp(),
+        "python": sys.version,
+        "platform": platform.platform(),
+        "output_dir": str(output_dir),
+        "work_dir": str(work_dir),
+        "project_name": project_name,
+        "imported_project_name": imported_name,
+        "restored_project_name": restored_name,
+        "archive_restored_project_name": archive_restored_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']}")
+
+        _record_tool_result(recorder, "capabilities", "project_capabilities_pre_create", server.project_manager("project_capabilities"))
+        _record_tool_result(recorder, "database", "database_capabilities_pre_create", server.project_manager("database_capabilities"))
+        db_caps = server.project_manager("database_capabilities")
+        if isinstance(db_caps, dict) and db_caps.get("current"):
+            _record_tool_result(
+                recorder,
+                "database",
+                "safe_set_current_database_dry_run",
+                server.project_manager("safe_set_current_database", {"db_info": db_caps["current"]}),
+            )
+
+        create_result = server.project_manager("safe_project_create", {"name": project_name})
+        _require_success("project_manager.safe_project_create", create_result)
+        cleanup_projects.append(project_name)
+        print(f"Created disposable project: {project_name}")
+
+        _record_tool_result(recorder, "lifecycle", "safe_project_create", create_result)
+        _record_tool_result(recorder, "lifecycle", "get_current", server.project_manager("get_current"))
+        _record_tool_result(recorder, "lifecycle", "create_empty_timeline", server.media_pool("create_timeline", {"name": timeline_name}))
+        _record_tool_result(recorder, "lifecycle", "save_project_before_export", server.project_manager("save"))
+        _record_tool_result(recorder, "lifecycle", "probe_project_lifecycle", server.project_manager("probe_project_lifecycle"))
+        _record_tool_result(recorder, "settings", "project_settings_snapshot", server.project_manager("project_settings_snapshot"))
+
+        snapshot = server.project_manager("project_settings_snapshot")
+        setting_payload = _first_setting_value(
+            snapshot if isinstance(snapshot, dict) else {},
+            ["timelineResolutionWidth", "timelineResolutionHeight", "timelineFrameRate"],
+        )
+        if setting_payload:
+            _record_tool_result(
+                recorder,
+                "settings",
+                "safe_set_project_settings_same_value_restore",
+                server.project_manager("safe_set_project_settings", {"settings": setting_payload, "restore": True}),
+            )
+        else:
+            recorder.record(
+                "settings",
+                "safe_set_project_settings_same_value_restore",
+                "not_applicable",
+                details={"reason": "No non-empty candidate project setting was readable"},
+                evidence=snapshot,
+            )
+
+        _record_tool_result(
+            recorder,
+            "settings",
+            "probe_project_settings_try_write_dry_run",
+            server.project_manager("probe_project_settings", {"try_write": True, "dry_run": True}),
+        )
+        _record_tool_result(recorder, "presets", "preset_lifecycle_probe", server.project_manager("preset_lifecycle_probe"))
+
+        drp_path = work_dir / "project-lifecycle-export.drp"
+        archive_path = work_dir / "project-lifecycle-archive.dra"
+        archive_folder_path = work_dir / "project-lifecycle-archive-folder"
+        _record_tool_result(
+            recorder,
+            "lifecycle",
+            "safe_project_export",
+            server.project_manager("safe_project_export", {"name": project_name, "path": str(drp_path)}),
+        )
+        if drp_path.exists():
+            import_result = server.project_manager("safe_project_import", {"name": imported_name, "path": str(drp_path)})
+            if import_result.get("success"):
+                cleanup_projects.append(imported_name)
+            _record_tool_result(recorder, "lifecycle", "safe_project_import", import_result)
+
+            restore_result = server.project_manager("safe_project_restore", {"name": restored_name, "path": str(drp_path)})
+            if restore_result.get("success"):
+                cleanup_projects.append(restored_name)
+            _record_tool_result(recorder, "lifecycle", "safe_project_restore_from_drp", restore_result)
+        else:
+            recorder.record(
+                "lifecycle",
+                "safe_project_import",
+                "not_applicable",
+                details={"reason": "DRP export path was not created"},
+            )
+            recorder.record(
+                "lifecycle",
+                "safe_project_restore_from_drp",
+                "not_applicable",
+                details={"reason": "DRP export path was not created"},
+            )
+
+        archive_file_result = server.project_manager(
+            "safe_project_archive",
+            {
+                "name": project_name,
+                "path": str(archive_path),
+                "src_media": False,
+                "render_cache": False,
+                "proxy_media": False,
+            },
+        )
+        _record_tool_result(
+            recorder,
+            "archive",
+            "safe_project_archive_no_media_dra_path",
+            archive_file_result,
+            expected_status=None if archive_file_result.get("success") else "partially_supported",
+        )
+        archive_folder_result = server.project_manager(
+            "safe_project_archive",
+            {
+                "name": project_name,
+                "path": str(archive_folder_path),
+                "src_media": False,
+                "render_cache": False,
+                "proxy_media": False,
+            },
+        )
+        _record_tool_result(
+            recorder,
+            "archive",
+            "safe_project_archive_no_media_folder_path",
+            archive_folder_result,
+            expected_status=None if archive_folder_result.get("success") else "partially_supported",
+        )
+        archive_restore_source = archive_path if archive_file_result.get("success") else archive_folder_path
+        if archive_file_result.get("success") or archive_folder_result.get("success"):
+            archive_restore = server.project_manager(
+                "safe_project_restore",
+                {"name": archive_restored_name, "path": str(archive_restore_source)},
+            )
+            if archive_restore.get("success"):
+                cleanup_projects.append(archive_restored_name)
+            _record_tool_result(
+                recorder,
+                "archive",
+                "safe_project_restore_from_archive",
+                archive_restore,
+                expected_status=None if archive_restore.get("success") else "partially_supported",
+            )
+        else:
+            recorder.record(
+                "archive",
+                "safe_project_restore_from_archive",
+                "not_applicable",
+                details={"reason": "No archive path was created successfully"},
+            )
+        _record_tool_result(
+            recorder,
+            "archive",
+            "safe_project_archive_rejects_media_flags",
+            server.project_manager(
+                "safe_project_archive",
+                {"name": project_name, "path": str(work_dir / "reject.dra"), "src_media": True, "dry_run": True},
+            ),
+            expected_status="unsupported",
+        )
+
+        _record_tool_result(recorder, "folders", "folder_list_before", server.project_manager_folders("list"))
+        _record_tool_result(recorder, "folders", "folder_create", server.project_manager_folders("create", {"name": folder_name}))
+        _record_tool_result(recorder, "folders", "folder_open", server.project_manager_folders("open", {"name": folder_name}))
+        _record_tool_result(recorder, "folders", "folder_get_current", server.project_manager_folders("get_current"))
+        _record_tool_result(recorder, "folders", "folder_goto_parent", server.project_manager_folders("goto_parent"))
+        _record_tool_result(recorder, "folders", "folder_delete", server.project_manager_folders("delete", {"name": folder_name}))
+
+        for page in ["media", "cut", "edit", "fusion", "color", "fairlight", "deliver"]:
+            _record_tool_result(
+                recorder,
+                "app_state",
+                f"open_page_{page}",
+                server.resolve_control("open_page", {"page": page}),
+                expected_status=None,
+            )
+        _record_tool_result(recorder, "app_state", "get_page", server.resolve_control("get_page"))
+        keyframe_mode = server.resolve_control("get_keyframe_mode")
+        _record_tool_result(recorder, "app_state", "get_keyframe_mode", keyframe_mode)
+        if isinstance(keyframe_mode, dict) and "mode" in keyframe_mode:
+            _record_tool_result(
+                recorder,
+                "app_state",
+                "set_keyframe_mode_same_value",
+                server.resolve_control("set_keyframe_mode", {"mode": keyframe_mode["mode"]}),
+            )
+
+        layout_path = work_dir / "layout-preset.layout"
+        layout_save = server.layout_presets("save", {"name": layout_name})
+        if layout_save.get("success"):
+            cleanup_layouts.append(layout_name)
+        _record_tool_result(recorder, "presets", "layout_save", layout_save)
+        _record_tool_result(recorder, "presets", "layout_update", server.layout_presets("update", {"name": layout_name}))
+        _record_tool_result(recorder, "presets", "layout_load", server.layout_presets("load", {"name": layout_name}))
+        _record_tool_result(recorder, "presets", "layout_export", server.layout_presets("export", {"name": layout_name, "path": str(layout_path)}))
+        if layout_path.exists():
+            layout_import = server.layout_presets("import_preset", {"name": layout_import_name, "path": str(layout_path)})
+            if layout_import.get("success"):
+                cleanup_layouts.append(layout_import_name)
+            _record_tool_result(recorder, "presets", "layout_import", layout_import)
+        else:
+            recorder.record(
+                "presets",
+                "layout_import",
+                "not_applicable",
+                details={"reason": "layout export path was not created"},
+            )
+
+        preset_probe = server.project_manager("preset_lifecycle_probe")
+        render_presets = []
+        if isinstance(preset_probe, dict):
+            render_presets = preset_probe.get("render_presets", {}).get("items", []) or []
+        if render_presets:
+            render_preset_name = render_presets[0].get("Name") if isinstance(render_presets[0], dict) else render_presets[0]
+            if render_preset_name:
+                _record_tool_result(
+                    recorder,
+                    "presets",
+                    "render_preset_export",
+                    server.render_presets("export_render", {"name": render_preset_name, "path": str(work_dir / "render-preset.xml")}),
+                    expected_status=None,
+                )
+        else:
+            recorder.record(
+                "presets",
+                "render_preset_export",
+                "not_applicable",
+                details={"reason": "No render presets were listed"},
+                evidence=preset_probe,
+            )
+
+        _record_tool_result(recorder, "report", "project_boundary_report", server.project_manager("project_boundary_report"))
+
+        if keep_open:
+            server.project_manager("save")
+            print(f"LEFT PROJECTS OPEN FOR INSPECTION: {cleanup_projects}")
+            cleanup_projects = []
+
+    finally:
+        for layout_name_to_delete in reversed(cleanup_layouts):
+            delete_results[f"layout:{layout_name_to_delete}"] = server.layout_presets("delete", {"name": layout_name_to_delete})
+            print(f"Deleted layout preset {layout_name_to_delete}: {delete_results[f'layout:{layout_name_to_delete}']}")
+        if not keep_open:
+            for disposable_project in reversed(cleanup_projects):
+                delete_results[f"project:{disposable_project}"] = _delete_disposable_project(server, disposable_project)
+                print(f"Deleted disposable project {disposable_project}: {delete_results[f'project:{disposable_project}']}")
+
+    metadata["cleanup"] = delete_results
+    report = recorder.to_report(
+        metadata,
+        {
+            "json": str(output_dir / "project-lifecycle-probe.json"),
+            "markdown": str(output_dir / "project-lifecycle-probe.md"),
+        },
+    )
+    json_path = output_dir / "project-lifecycle-probe.json"
+    markdown_path = output_dir / "project-lifecycle-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 project lifecycle work directory: {work_dir}")
+
+    failed_cleanup = {key: value for key, value in delete_results.items() if value.get("success") is not True and not value.get("error", "").startswith("No ")}
+    if failed_cleanup:
+        raise AssertionError(f"Cleanup failed: {failed_cleanup!r}")
+    return report