davinci-resolve-mcp 2.23.0

package/src/utils/fusion_composition_live_probe.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""Live Fusion Composition 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"), "expected_status": expected_status},
+            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", "expected_status": expected_status},
+            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_video(work_dir: Path) -> Path:
+    video = work_dir / "fusion_composition_probe.mov"
+    _run_ffmpeg(
+        [
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc=size=640x360:rate=24:duration=4",
+            "-pix_fmt",
+            "yuv420p",
+            "-c:v",
+            "libx264",
+            "-y",
+            str(video),
+        ]
+    )
+    return video
+
+
+def _first_imported_clip(imported_items):
+    for item in imported_items or []:
+        try:
+            if item.GetUniqueId():
+                return item
+        except Exception:
+            pass
+    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_fusion_composition_probe_"))
+    project_name = f"_mcp_fusion_composition_probe_{int(time.time())}"
+    timeline_name = "Fusion Composition Probe Timeline"
+    recorder = ProbeRecorder()
+    created_project = False
+    delete_result: Optional[Dict[str, Any]] = None
+
+    metadata: Dict[str, Any] = {
+        "title": "Fusion Composition 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"})
+
+        video = _make_synthetic_video(work_dir)
+        metadata["synthetic_media"] = {"video": str(video)}
+        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(video)]) or []
+        clip = _first_imported_clip(imported)
+        if not clip:
+            raise AssertionError("Failed to import synthetic Fusion media")
+        timeline = media_pool.CreateTimelineFromClips(timeline_name, [clip])
+        if not timeline:
+            raise AssertionError("Failed to create Fusion timeline")
+        project.SetCurrentTimeline(timeline)
+        timeline.SetCurrentTimecode("01:00:00:01")
+        print(f"Created timeline: {timeline_name}")
+
+        item_scope = {"track_type": "video", "track_index": 1, "item_index": 0}
+        comp_scope = {"timeline_item": item_scope}
+
+        _record_tool_result(recorder, "timeline_item_fusion", "add_comp", server.timeline_item_fusion("add_comp", item_scope))
+        _record_tool_result(recorder, "timeline_item_fusion", "get_comp_count", server.timeline_item_fusion("get_comp_count", item_scope))
+        _record_tool_result(recorder, "timeline_item_fusion", "get_comp_names", server.timeline_item_fusion("get_comp_names", item_scope))
+
+        _record_tool_result(recorder, "capabilities", "fusion_graph_capabilities", server.fusion_comp("fusion_graph_capabilities", comp_scope))
+        _record_tool_result(
+            recorder,
+            "inspection",
+            "probe_fusion_comp_initial",
+            server.fusion_comp("probe_fusion_comp", {**comp_scope, "include_io": False}),
+        )
+
+        for tool_type, name in (
+            ("Background", "MCP_Background"),
+            ("TextPlus", "MCP_Text"),
+            ("Merge", "MCP_Merge"),
+            ("Transform", "MCP_Transform"),
+            ("Blur", "MCP_Blur"),
+        ):
+            _record_tool_result(
+                recorder,
+                "tools",
+                f"safe_add_{tool_type}",
+                server.fusion_comp("safe_add_tool", {**comp_scope, "tool_type": tool_type, "name": name, "include_io": True}),
+            )
+
+        _record_tool_result(
+            recorder,
+            "inputs",
+            "safe_set_text",
+            server.fusion_comp(
+                "safe_set_inputs",
+                {**comp_scope, "tool_name": "MCP_Text", "inputs": {"StyledText": "MCP Fusion Probe"}, "readback": True},
+            ),
+        )
+        _record_tool_result(
+            recorder,
+            "inputs",
+            "safe_set_background_color",
+            server.fusion_comp(
+                "safe_set_inputs",
+                {
+                    **comp_scope,
+                    "tool_name": "MCP_Background",
+                    "inputs": {
+                        "TopLeftRed": 0.1,
+                        "TopLeftGreen": 0.2,
+                        "TopLeftBlue": 0.7,
+                        "TopLeftAlpha": 1.0,
+                    },
+                    "readback": True,
+                },
+            ),
+        )
+        _record_tool_result(
+            recorder,
+            "inspection",
+            "probe_text_tool",
+            server.fusion_comp("probe_fusion_tool", {**comp_scope, "tool_name": "MCP_Text", "include_io": True}),
+        )
+        _record_tool_result(
+            recorder,
+            "wiring",
+            "safe_connect_text_to_mediaout",
+            server.fusion_comp(
+                "safe_connect_tools",
+                {**comp_scope, "target_tool": "MediaOut1", "input_name": "Input", "source_tool": "MCP_Text"},
+            ),
+        )
+        _record_tool_result(
+            recorder,
+            "bulk",
+            "bulk_set_inputs",
+            server.fusion_comp(
+                "bulk_set_inputs",
+                {
+                    "ops": [
+                        {**comp_scope, "tool_name": "MCP_Text", "input_name": "Size", "value": 0.08},
+                        {**comp_scope, "tool_name": "MCP_Background", "input_name": "GlobalOut", "value": 96},
+                    ]
+                },
+            ),
+        )
+        _record_tool_result(
+            recorder,
+            "composition",
+            "set_frame_range",
+            server.fusion_comp("set_frame_range", {**comp_scope, "start": 0, "end": 96}),
+        )
+        export_path = str(work_dir / "fusion_probe.setting")
+        _record_tool_result(
+            recorder,
+            "timeline_item_fusion",
+            "export_comp",
+            server.timeline_item_fusion("export_comp", {**item_scope, "path": export_path, "index": 1}),
+        )
+        _record_tool_result(
+            recorder,
+            "report",
+            "fusion_boundary_report",
+            server.fusion_comp("fusion_boundary_report", {**comp_scope, "include_io": False}),
+        )
+
+        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 / "fusion-composition-probe.json"),
+            "markdown": str(output_dir / "fusion-composition-probe.md"),
+        },
+    )
+    json_path = output_dir / "fusion-composition-probe.json"
+    markdown_path = output_dir / "fusion-composition-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/layout_presets.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+"""
+DaVinci Resolve MCP Server - Layout Presets Utilities
+
+This module provides functions for working with DaVinci Resolve UI layout presets:
+- Saving layout presets
+- Loading layout presets
+- Exporting/importing preset files
+- Managing layout configurations
+"""
+
+import os
+import json
+import logging
+from typing import Dict, List, Any, Optional, Union
+
+# Configure logging
+logger = logging.getLogger("davinci-resolve-mcp.layout_presets")
+
+
+def _validate_path_within_directory(path: str, allowed_dir: str) -> bool:
+    """Validate that a resolved path is within the allowed directory.
+
+    Prevents path traversal attacks (e.g. preset_name='../../etc/passwd').
+
+    Args:
+        path: The path to validate (will be resolved to absolute).
+        allowed_dir: The directory the path must reside within.
+
+    Returns:
+        True if the path is safely within allowed_dir.
+    """
+    resolved = os.path.realpath(path)
+    allowed = os.path.realpath(allowed_dir)
+    # Ensure the resolved path starts with the allowed directory
+    # (trailing sep prevents '/presets2' matching '/presets')
+    return resolved.startswith(allowed + os.sep) or resolved == allowed
+
+# Default preset locations by platform
+DEFAULT_PRESET_PATHS = {
+    "darwin": "~/Library/Application Support/Blackmagic Design/DaVinci Resolve/Presets/",
+    "win32": "C:\\ProgramData\\Blackmagic Design\\DaVinci Resolve\\Presets\\",
+    "linux": "~/.local/share/DaVinciResolve/Presets/"
+}
+
+def get_layout_preset_path(platform: str = None) -> str:
+    """
+    Get the path to layout presets for the current platform.
+    
+    Args:
+        platform: Override the detected platform (darwin, win32, linux)
+        
+    Returns:
+        Path to the layout presets directory
+    """
+    import platform as platform_module
+    import os
+    
+    # Determine platform if not specified
+    if platform is None:
+        platform = platform_module.system().lower()
+        if platform == "darwin":
+            platform = "darwin"
+        elif platform == "windows":
+            platform = "win32"
+        elif platform == "linux":
+            platform = "linux"
+        else:
+            platform = "darwin"  # Default to macOS if unknown
+    
+    # Get default path for platform
+    preset_path = DEFAULT_PRESET_PATHS.get(platform, DEFAULT_PRESET_PATHS["darwin"])
+    
+    # Expand user directory if needed
+    preset_path = os.path.expanduser(preset_path)
+    
+    # Ensure directory exists
+    if not os.path.exists(preset_path):
+        os.makedirs(preset_path, exist_ok=True)
+    
+    return preset_path
+
+def get_ui_layout_path(preset_path: str = None) -> str:
+    """
+    Get the path to UI layout presets.
+    
+    Args:
+        preset_path: Base preset directory path (determined automatically if None)
+        
+    Returns:
+        Path to the UI layout presets directory
+    """
+    if preset_path is None:
+        preset_path = get_layout_preset_path()
+    
+    # UI layouts are in a specific subdirectory
+    ui_layout_path = os.path.join(preset_path, "UILayouts")
+    
+    # Ensure directory exists
+    if not os.path.exists(ui_layout_path):
+        os.makedirs(ui_layout_path, exist_ok=True)
+    
+    return ui_layout_path
+
+def list_layout_presets(layout_type: str = "ui") -> List[Dict[str, Any]]:
+    """
+    List available layout presets.
+    
+    Args:
+        layout_type: Type of layout presets to list ('ui', 'window', 'workspace')
+        
+    Returns:
+        List of preset information dictionaries
+    """
+    # Get appropriate preset directory
+    if layout_type.lower() == "ui":
+        preset_dir = get_ui_layout_path()
+    else:
+        # Other layout types would be handled here
+        preset_dir = get_ui_layout_path()
+    
+    # List files in the directory
+    if not os.path.exists(preset_dir):
+        return []
+    
+    presets = []
+    for filename in os.listdir(preset_dir):
+        # Only include layout preset files
+        if filename.endswith(".layout"):
+            preset_path = os.path.join(preset_dir, filename)
+            presets.append({
+                "name": os.path.splitext(filename)[0],
+                "path": preset_path,
+                "type": layout_type,
+                "size": os.path.getsize(preset_path)
+            })
+    
+    return presets
+
+def save_layout_preset(resolve_obj, preset_name: str, layout_type: str = "ui") -> bool:
+    """
+    Save the current layout as a preset.
+    
+    Args:
+        resolve_obj: DaVinci Resolve API object
+        preset_name: Name for the saved preset
+        layout_type: Type of layout to save ('ui', 'window', 'workspace')
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Ensure preset name has no spaces or special characters
+        safe_name = preset_name.replace(" ", "_").replace("/", "_").replace("\\", "_")
+        
+        # Different layout types have different save methods
+        if layout_type.lower() == "ui":
+            # For UI layouts, use the UI Manager
+            ui_manager = resolve_obj.GetUIManager()
+            if not ui_manager:
+                logger.error("Failed to get UI Manager")
+                return False
+            
+            # Save the current UI layout
+            return ui_manager.SaveUILayout(safe_name)
+        else:
+            # Other layout types would be handled here
+            logger.error(f"Unsupported layout type: {layout_type}")
+            return False
+    except Exception as e:
+        logger.error(f"Error saving layout preset: {str(e)}")
+        return False
+
+def load_layout_preset(resolve_obj, preset_name: str, layout_type: str = "ui") -> bool:
+    """
+    Load a layout preset.
+    
+    Args:
+        resolve_obj: DaVinci Resolve API object
+        preset_name: Name of the preset to load
+        layout_type: Type of layout to load ('ui', 'window', 'workspace')
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Different layout types have different load methods
+        if layout_type.lower() == "ui":
+            # For UI layouts, use the UI Manager
+            ui_manager = resolve_obj.GetUIManager()
+            if not ui_manager:
+                logger.error("Failed to get UI Manager")
+                return False
+            
+            # Load the specified UI layout
+            return ui_manager.LoadUILayout(preset_name)
+        else:
+            # Other layout types would be handled here
+            logger.error(f"Unsupported layout type: {layout_type}")
+            return False
+    except Exception as e:
+        logger.error(f"Error loading layout preset: {str(e)}")
+        return False
+
+def export_layout_preset(preset_name: str, export_path: str, layout_type: str = "ui") -> bool:
+    """
+    Export a layout preset to a file.
+    
+    Args:
+        preset_name: Name of the preset to export
+        export_path: Path to export the preset file to
+        layout_type: Type of layout to export ('ui', 'window', 'workspace')
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Get the source preset path
+        if layout_type.lower() == "ui":
+            preset_dir = get_ui_layout_path()
+        else:
+            # Other layout types would be handled here
+            preset_dir = get_ui_layout_path()
+        
+        # Construct source path and validate it stays within preset_dir
+        source_path = os.path.join(preset_dir, f"{preset_name}.layout")
+        if not _validate_path_within_directory(source_path, preset_dir):
+            logger.error(f"Path traversal blocked in preset name: {preset_name}")
+            return False
+
+        # Ensure source file exists
+        if not os.path.exists(source_path):
+            logger.error(f"Preset file not found: {source_path}")
+            return False
+
+        # Ensure destination directory exists
+        export_dir = os.path.dirname(export_path)
+        if export_dir and not os.path.exists(export_dir):
+            os.makedirs(export_dir, exist_ok=True)
+
+        # Copy the preset file
+        import shutil
+        shutil.copy2(source_path, export_path)
+        
+        return True
+    except Exception as e:
+        logger.error(f"Error exporting layout preset: {str(e)}")
+        return False
+
+def import_layout_preset(import_path: str, preset_name: str = None, layout_type: str = "ui") -> bool:
+    """
+    Import a layout preset from a file.
+    
+    Args:
+        import_path: Path to the preset file to import
+        preset_name: Name to save the imported preset as (uses filename if None)
+        layout_type: Type of layout to import ('ui', 'window', 'workspace')
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Ensure source file exists
+        if not os.path.exists(import_path):
+            logger.error(f"Import file not found: {import_path}")
+            return False
+        
+        # Get the destination preset path
+        if layout_type.lower() == "ui":
+            preset_dir = get_ui_layout_path()
+        else:
+            # Other layout types would be handled here
+            preset_dir = get_ui_layout_path()
+        
+        # Use filename as preset name if not specified
+        if preset_name is None:
+            preset_name = os.path.splitext(os.path.basename(import_path))[0]
+        
+        # Ensure preset name has no spaces or special characters
+        safe_name = preset_name.replace(" ", "_").replace("/", "_").replace("\\", "_")
+        
+        # Construct destination path and validate it stays within preset_dir
+        dest_path = os.path.join(preset_dir, f"{safe_name}.layout")
+        if not _validate_path_within_directory(dest_path, preset_dir):
+            logger.error(f"Path traversal blocked in preset name: {preset_name}")
+            return False
+
+        # Copy the preset file
+        import shutil
+        shutil.copy2(import_path, dest_path)
+        
+        return True
+    except Exception as e:
+        logger.error(f"Error importing layout preset: {str(e)}")
+        return False
+
+def delete_layout_preset(preset_name: str, layout_type: str = "ui") -> bool:
+    """
+    Delete a layout preset.
+    
+    Args:
+        preset_name: Name of the preset to delete
+        layout_type: Type of layout to delete ('ui', 'window', 'workspace')
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Get the preset path
+        if layout_type.lower() == "ui":
+            preset_dir = get_ui_layout_path()
+        else:
+            # Other layout types would be handled here
+            preset_dir = get_ui_layout_path()
+        
+        # Construct the preset file path and validate it stays within preset_dir
+        preset_path = os.path.join(preset_dir, f"{preset_name}.layout")
+        if not _validate_path_within_directory(preset_path, preset_dir):
+            logger.error(f"Path traversal blocked in preset name: {preset_name}")
+            return False
+
+        # Ensure file exists
+        if not os.path.exists(preset_path):
+            logger.error(f"Preset file not found: {preset_path}")
+            return False
+
+        # Delete the file
+        os.remove(preset_path)
+        
+        return True
+    except Exception as e:
+        logger.error(f"Error deleting layout preset: {str(e)}")
+        return False 

package/src/utils/mcp_stdio.py

@@ -0,0 +1,32 @@
+"""FastMCP stdio helpers with strict LF line endings across platforms."""
+
+from __future__ import annotations
+
+import sys
+from io import TextIOWrapper
+
+import anyio
+from mcp.server.stdio import stdio_server
+
+
+def create_text_stdio():
+    """Wrap stdio in UTF-8 text mode without platform newline translation."""
+    stdin = anyio.wrap_file(TextIOWrapper(sys.stdin.buffer, encoding="utf-8", newline=""))
+    stdout = anyio.wrap_file(TextIOWrapper(sys.stdout.buffer, encoding="utf-8", newline=""))
+    return stdin, stdout
+
+
+async def run_fastmcp_stdio_async(fastmcp):
+    """Run a FastMCP server over stdio using strict LF-delimited JSON."""
+    stdin, stdout = create_text_stdio()
+    async with stdio_server(stdin=stdin, stdout=stdout) as (read_stream, write_stream):
+        await fastmcp._mcp_server.run(  # noqa: SLF001 - no public injection point exists yet
+            read_stream,
+            write_stream,
+            fastmcp._mcp_server.create_initialization_options(),
+        )
+
+
+def run_fastmcp_stdio(fastmcp):
+    """Synchronous entrypoint for strict-LF FastMCP stdio."""
+    anyio.run(lambda: run_fastmcp_stdio_async(fastmcp))