@hybridlabor-api/aos 4.4.1 → 4.4.2-beta.0

package/mcps/davinci-resolve-mcp/src/granular/project.py

@@ -1,1654 +0,0 @@
-"""Project, render, cache, cloud, and project-property tools."""
-
-from src.granular.common import *  # noqa: F401,F403
-
-resolve = ResolveProxy()
-
-@mcp.resource("resolve://projects")
-def list_projects() -> List[str]:
-    """List all available projects in the current database."""
-    project_manager = get_project_manager()
-    if not project_manager:
-        return ["Error: Failed to get Project Manager"]
-    
-    projects = project_manager.GetProjectListInCurrentFolder()
-    
-    # Filter out any empty strings that might be in the list
-    return [p for p in projects if p]
-
-
-@mcp.resource("resolve://current-project")
-def get_current_project_name() -> str:
-    """Get the name of the currently open project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "No project currently open"
-    
-    return current_project.GetName()
-
-
-@mcp.resource("resolve://project-settings")
-def get_project_settings() -> Dict[str, Any]:
-    """Get all project settings from the current project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    try:
-        # Get all settings
-        return current_project.GetSetting('')
-    except Exception as e:
-        return {"error": f"Failed to get project settings: {str(e)}"}
-
-
-@mcp.resource("resolve://project-setting/{setting_name}")
-def get_project_setting(setting_name: str) -> Dict[str, Any]:
-    """Get a specific project setting by name.
-    
-    Args:
-        setting_name: The specific setting to retrieve.
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    try:
-        # Get specific setting
-        value = current_project.GetSetting(setting_name)
-        return {setting_name: value}
-    except Exception as e:
-        return {"error": f"Failed to get project setting '{setting_name}': {str(e)}"}
-
-
-@mcp.tool(annotations=DESTRUCTIVE_TOOL)
-def set_project_setting(setting_name: str, setting_value: Any) -> str:
-    """Set a project setting to the specified value.
-    
-    Args:
-        setting_name: The name of the setting to change
-        setting_value: The new value for the setting (can be string, integer, float, or boolean)
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    try:
-        # Convert setting_value to string if it's not already
-        if not isinstance(setting_value, str):
-            setting_value = str(setting_value)
-            
-        # Try to determine if this should be a numeric value
-        # DaVinci Resolve sometimes expects numeric values for certain settings
-        try:
-            # Check if it's a number in string form
-            if setting_value.isdigit() or (setting_value.startswith('-') and setting_value[1:].isdigit()):
-                # It's an integer
-                numeric_value = int(setting_value)
-                # Try with numeric value first
-                if current_project.SetSetting(setting_name, numeric_value):
-                    return f"Successfully set project setting '{setting_name}' to numeric value {numeric_value}"
-            elif '.' in setting_value and setting_value.replace('.', '', 1).replace('-', '', 1).isdigit():
-                # It's a float
-                numeric_value = float(setting_value)
-                # Try with float value
-                if current_project.SetSetting(setting_name, numeric_value):
-                    return f"Successfully set project setting '{setting_name}' to numeric value {numeric_value}"
-        except (ValueError, TypeError):
-            # Not a number or conversion failed, continue with string value
-            pass
-            
-        # Fall back to string value if numeric didn't work or wasn't applicable
-        result = current_project.SetSetting(setting_name, setting_value)
-        if result:
-            return f"Successfully set project setting '{setting_name}' to '{setting_value}'"
-        else:
-            return f"Failed to set project setting '{setting_name}'"
-    except Exception as e:
-        return f"Error setting project setting: {str(e)}"
-
-
-@mcp.tool()
-def open_project(name: str) -> str:
-    """Open a project by name.
-    
-    Args:
-        name: The name of the project to open
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return "Error: Not connected to DaVinci Resolve"
-    
-    if not name:
-        return "Error: Project name cannot be empty"
-    
-    project_manager = resolve.GetProjectManager()
-    if not project_manager:
-        return "Error: Failed to get Project Manager"
-    
-    # Check if project exists
-    projects = project_manager.GetProjectListInCurrentFolder()
-    if name not in projects:
-        return f"Error: Project '{name}' not found. Available projects: {', '.join(projects)}"
-    
-    result = project_manager.LoadProject(name)
-    if result:
-        return f"Successfully opened project '{name}'"
-    else:
-        return f"Failed to open project '{name}'"
-
-
-@mcp.tool()
-def create_project(name: str, media_location_path: str = None) -> str:
-    """Create a new project with the given name.
-    
-    Args:
-        name: The name for the new project
-        media_location_path: Optional project media location path (Resolve 20.2.2+).
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return "Error: Not connected to DaVinci Resolve"
-    
-    if not name:
-        return "Error: Project name cannot be empty"
-    
-    project_manager = resolve.GetProjectManager()
-    if not project_manager:
-        return "Error: Failed to get Project Manager"
-    
-    # Check if project already exists
-    projects = project_manager.GetProjectListInCurrentFolder()
-    if name in projects:
-        return f"Error: Project '{name}' already exists"
-    
-    if media_location_path:
-        version = resolve.GetVersion() or [0]
-        if version[0] < 20 or (version[0] == 20 and len(version) > 2 and (version[1], version[2]) < (2, 2)):
-            return "Error: ProjectManager.CreateProject media_location_path requires DaVinci Resolve 20.2.2+"
-        result = project_manager.CreateProject(name, media_location_path)
-    else:
-        result = project_manager.CreateProject(name)
-    if result:
-        return f"Successfully created project '{name}'"
-    else:
-        return f"Failed to create project '{name}'"
-
-
-@mcp.tool()
-def save_project() -> str:
-    """Save the current project.
-    
-    Note that DaVinci Resolve typically auto-saves projects, so this may not be necessary.
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    project_name = current_project.GetName()
-    success = False
-    error_message = None
-    
-    # Try multiple approaches to save the project
-    try:
-        # Method 1: Try direct save method if available
-        try:
-            if hasattr(current_project, "SaveProject"):
-                result = current_project.SaveProject()
-                if result:
-                    logger.info(f"Project '{project_name}' saved using SaveProject method")
-                    success = True
-        except Exception as e:
-            logger.error(f"Error in SaveProject method: {str(e)}")
-            error_message = str(e)
-            
-        # Method 2: Try project manager save method
-        if not success:
-            try:
-                if hasattr(project_manager, "SaveProject"):
-                    result = project_manager.SaveProject()
-                    if result:
-                        logger.info(f"Project '{project_name}' saved using ProjectManager.SaveProject method")
-                        success = True
-            except Exception as e:
-                logger.error(f"Error in ProjectManager.SaveProject method: {str(e)}")
-                if not error_message:
-                    error_message = str(e)
-        
-        # Method 3: Try the export method as a backup approach
-        if not success:
-            try:
-                # Get a temporary file path that Resolve can access
-                temp_dir = _resolve_safe_dir(tempfile.gettempdir())
-                os.makedirs(temp_dir, exist_ok=True)
-                temp_file = os.path.join(temp_dir, f"{project_name}_temp.drp")
-                
-                # Try to export the project, which should trigger a save
-                result = project_manager.ExportProject(project_name, temp_file)
-                if result:
-                    logger.info(f"Project '{project_name}' saved via temporary export to {temp_file}")
-                    # Try to clean up temp file
-                    try:
-                        if os.path.exists(temp_file):
-                            os.remove(temp_file)
-                    except OSError:
-                        logger.debug("Could not remove temporary project export %s", temp_file, exc_info=True)
-                    success = True
-            except Exception as e:
-                logger.error(f"Error in export method: {str(e)}")
-                if not error_message:
-                    error_message = str(e)
-                    
-        # If all else fails, rely on auto-save
-        if not success:
-            return f"Automatic save likely in effect for project '{project_name}'. Manual save attempts failed: {error_message if error_message else 'Unknown error'}"
-        else:
-            return f"Successfully saved project '{project_name}'"
-            
-    except Exception as e:
-        logger.error(f"Error saving project: {str(e)}")
-        return f"Error saving project: {str(e)}"
-
-
-@mcp.tool()
-def close_project() -> str:
-    """Close the current project.
-    
-    This closes the current project without saving. If you need to save, use the save_project function first.
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    project_name = current_project.GetName()
-    
-    # Close the project
-    try:
-        result = project_manager.CloseProject(current_project)
-        if result:
-            logger.info(f"Project '{project_name}' closed successfully")
-            return f"Successfully closed project '{project_name}'"
-        else:
-            logger.error(f"Failed to close project '{project_name}'")
-            return f"Failed to close project '{project_name}'"
-    except Exception as e:
-        logger.error(f"Error closing project: {str(e)}")
-        return f"Error closing project: {str(e)}"
-
-
-@mcp.resource("resolve://cache/settings")
-def get_cache_settings() -> Dict[str, Any]:
-    """Get current cache settings from the project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    try:
-        # Get all cache-related settings
-        settings = {}
-        cache_keys = [
-            "CacheMode", 
-            "CacheClipMode",
-            "OptimizedMediaMode",
-            "ProxyMode", 
-            "ProxyQuality",
-            "TimelineCacheMode",
-            "LocalCachePath",
-            "NetworkCachePath"
-        ]
-        
-        for key in cache_keys:
-            value = current_project.GetSetting(key)
-            settings[key] = value
-            
-        return settings
-    except Exception as e:
-        return {"error": f"Failed to get cache settings: {str(e)}"}
-
-
-@mcp.tool()
-def set_cache_mode(mode: str) -> str:
-    """Set cache mode for the current project.
-    
-    Args:
-        mode: Cache mode to set. Options: 'auto', 'on', 'off'
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    # Validate mode
-    valid_modes = ["auto", "on", "off"]
-    mode = mode.lower()
-    if mode not in valid_modes:
-        return f"Error: Invalid cache mode. Must be one of: {', '.join(valid_modes)}"
-    
-    # Convert mode to API value
-    mode_map = {
-        "auto": "0",
-        "on": "1",
-        "off": "2"
-    }
-    
-    try:
-        result = current_project.SetSetting("CacheMode", mode_map[mode])
-        if result:
-            return f"Successfully set cache mode to '{mode}'"
-        else:
-            return f"Failed to set cache mode to '{mode}'"
-    except Exception as e:
-        return f"Error setting cache mode: {str(e)}"
-
-
-@mcp.tool()
-def set_optimized_media_mode(mode: str) -> str:
-    """Set optimized media mode for the current project.
-    
-    Args:
-        mode: Optimized media mode to set. Options: 'auto', 'on', 'off'
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    # Validate mode
-    valid_modes = ["auto", "on", "off"]
-    mode = mode.lower()
-    if mode not in valid_modes:
-        return f"Error: Invalid optimized media mode. Must be one of: {', '.join(valid_modes)}"
-    
-    # Convert mode to API value
-    mode_map = {
-        "auto": "0",
-        "on": "1",
-        "off": "2"
-    }
-    
-    try:
-        result = current_project.SetSetting("OptimizedMediaMode", mode_map[mode])
-        if result:
-            return f"Successfully set optimized media mode to '{mode}'"
-        else:
-            return f"Failed to set optimized media mode to '{mode}'"
-    except Exception as e:
-        return f"Error setting optimized media mode: {str(e)}"
-
-
-@mcp.tool()
-def set_proxy_mode(mode: str) -> str:
-    """Set proxy media mode for the current project.
-    
-    Args:
-        mode: Proxy mode to set. Options: 'auto', 'on', 'off'
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    # Validate mode
-    valid_modes = ["auto", "on", "off"]
-    mode = mode.lower()
-    if mode not in valid_modes:
-        return f"Error: Invalid proxy mode. Must be one of: {', '.join(valid_modes)}"
-    
-    # Convert mode to API value
-    mode_map = {
-        "auto": "0",
-        "on": "1",
-        "off": "2"
-    }
-    
-    try:
-        result = current_project.SetSetting("ProxyMode", mode_map[mode])
-        if result:
-            return f"Successfully set proxy mode to '{mode}'"
-        else:
-            return f"Failed to set proxy mode to '{mode}'"
-    except Exception as e:
-        return f"Error setting proxy mode: {str(e)}"
-
-
-@mcp.tool()
-def set_proxy_quality(quality: str) -> str:
-    """Set proxy media quality for the current project.
-    
-    Args:
-        quality: Proxy quality to set. Options: 'quarter', 'half', 'threeQuarter', 'full'
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    # Validate quality
-    valid_qualities = ["quarter", "half", "threeQuarter", "full"]
-    if quality not in valid_qualities:
-        return f"Error: Invalid proxy quality. Must be one of: {', '.join(valid_qualities)}"
-    
-    # Convert quality to API value
-    quality_map = {
-        "quarter": "0",
-        "half": "1",
-        "threeQuarter": "2",
-        "full": "3"
-    }
-    
-    try:
-        result = current_project.SetSetting("ProxyQuality", quality_map[quality])
-        if result:
-            return f"Successfully set proxy quality to '{quality}'"
-        else:
-            return f"Failed to set proxy quality to '{quality}'"
-    except Exception as e:
-        return f"Error setting proxy quality: {str(e)}"
-
-
-@mcp.tool()
-def set_cache_path(path_type: str, path: str) -> str:
-    """Set cache file path for the current project.
-    
-    Args:
-        path_type: Type of cache path to set. Options: 'local', 'network'
-        path: File system path for the cache
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    # Validate path_type
-    valid_path_types = ["local", "network"]
-    path_type = path_type.lower()
-    if path_type not in valid_path_types:
-        return f"Error: Invalid path type. Must be one of: {', '.join(valid_path_types)}"
-    
-    # Check if directory exists
-    if not os.path.exists(path):
-        return f"Error: Path '{path}' does not exist"
-    
-    setting_key = "LocalCachePath" if path_type == "local" else "NetworkCachePath"
-    
-    try:
-        result = current_project.SetSetting(setting_key, path)
-        if result:
-            return f"Successfully set {path_type} cache path to '{path}'"
-        else:
-            return f"Failed to set {path_type} cache path to '{path}'"
-    except Exception as e:
-        return f"Error setting cache path: {str(e)}"
-
-
-
-@mcp.tool()
-def create_cloud_project_tool(
-    project_name: Optional[str] = None,
-    project_media_path: Optional[str] = None,
-    is_collab: Optional[bool] = None,
-    sync_mode: Optional[str] = None,
-    is_camera_access: Optional[bool] = None,
-) -> Dict[str, Any]:
-    """Create a new cloud project.
-
-    Mirrors ProjectManager.CreateCloudProject({cloudSettings}) per docs lines 138, 576-594.
-
-    Args:
-        project_name: maps to resolve.CLOUD_SETTING_PROJECT_NAME (required for create).
-        project_media_path: maps to resolve.CLOUD_SETTING_PROJECT_MEDIA_PATH (required for create).
-        is_collab: maps to resolve.CLOUD_SETTING_IS_COLLAB.
-        sync_mode: 'none', 'proxy_only' (default), or 'proxy_and_orig' — maps to resolve.CLOUD_SYNC_*.
-        is_camera_access: maps to resolve.CLOUD_SETTING_IS_CAMERA_ACCESS.
-    """
-    return create_cloud_project(get_resolve(), project_name=project_name,
-                                project_media_path=project_media_path, is_collab=is_collab,
-                                sync_mode=sync_mode, is_camera_access=is_camera_access)
-
-
-@mcp.tool()
-def load_cloud_project_tool(
-    project_name: Optional[str] = None,
-    project_media_path: Optional[str] = None,
-    sync_mode: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Load a cloud project.
-
-    Mirrors ProjectManager.LoadCloudProject({cloudSettings}). Per docs line 585,
-    only project_name, project_media_path, and sync_mode are honoured.
-
-    Args:
-        project_name: required.
-        project_media_path: required.
-        sync_mode: 'none', 'proxy_only', or 'proxy_and_orig'.
-    """
-    return load_cloud_project(get_resolve(), project_name=project_name,
-                              project_media_path=project_media_path, sync_mode=sync_mode)
-
-
-@mcp.tool()
-def import_cloud_project_tool(
-    file_path: str,
-    project_name: Optional[str] = None,
-    project_media_path: Optional[str] = None,
-    is_collab: Optional[bool] = None,
-    sync_mode: Optional[str] = None,
-    is_camera_access: Optional[bool] = None,
-) -> Dict[str, Any]:
-    """Import a cloud project from a file.
-
-    Mirrors ProjectManager.ImportCloudProject(filePath, {cloudSettings}).
-
-    Args:
-        file_path: absolute path to the cloud project file (required).
-        project_name, project_media_path, is_collab, sync_mode, is_camera_access:
-            cloudSettings dict keys; same semantics as create_cloud_project_tool.
-    """
-    return import_cloud_project(get_resolve(), file_path=file_path,
-                                project_name=project_name, project_media_path=project_media_path,
-                                is_collab=is_collab, sync_mode=sync_mode,
-                                is_camera_access=is_camera_access)
-
-
-@mcp.tool()
-def restore_cloud_project_tool(
-    folder_path: str,
-    project_name: Optional[str] = None,
-    project_media_path: Optional[str] = None,
-    is_collab: Optional[bool] = None,
-    sync_mode: Optional[str] = None,
-    is_camera_access: Optional[bool] = None,
-) -> Dict[str, Any]:
-    """Restore a cloud project from a folder.
-
-    Mirrors ProjectManager.RestoreCloudProject(folderPath, {cloudSettings}).
-
-    Args:
-        folder_path: absolute path to the cloud project folder (required).
-        project_name, project_media_path, is_collab, sync_mode, is_camera_access:
-            cloudSettings dict keys; same semantics as create_cloud_project_tool.
-    """
-    return restore_cloud_project(get_resolve(), folder_path=folder_path,
-                                 project_name=project_name, project_media_path=project_media_path,
-                                 is_collab=is_collab, sync_mode=sync_mode,
-                                 is_camera_access=is_camera_access)
-
-
-@mcp.resource("resolve://project/properties")
-def get_project_properties_endpoint() -> Dict[str, Any]:
-    """Get all project properties for the current project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    return get_all_project_properties(current_project)
-
-
-@mcp.resource("resolve://project/property/{property_name}")
-def get_project_property_endpoint(property_name: str) -> Dict[str, Any]:
-    """Get a specific project property value.
-    
-    Args:
-        property_name: Name of the property to get
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    value = get_project_property(current_project, property_name)
-    return {property_name: value}
-
-
-@mcp.tool()
-def set_project_property_tool(property_name: str, property_value: Any) -> str:
-    """Set a project property value.
-    
-    Args:
-        property_name: Name of the property to set
-        property_value: Value to set for the property
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    result = set_project_property(current_project, property_name, property_value)
-    
-    if result:
-        return f"Successfully set project property '{property_name}' to '{property_value}'"
-    else:
-        return f"Failed to set project property '{property_name}'"
-
-
-@mcp.resource("resolve://project/timeline-format")
-def get_timeline_format() -> Dict[str, Any]:
-    """Get timeline format settings for the current project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    return get_timeline_format_settings(current_project)
-
-
-@mcp.tool()
-def set_timeline_format_tool(width: int, height: int, frame_rate: float, interlaced: bool = False) -> str:
-    """Set timeline format (resolution and frame rate).
-    
-    Args:
-        width: Timeline width in pixels
-        height: Timeline height in pixels
-        frame_rate: Timeline frame rate
-        interlaced: Whether the timeline should use interlaced processing
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    result = set_timeline_format(current_project, width, height, frame_rate, interlaced)
-    
-    if result:
-        interlace_status = "interlaced" if interlaced else "progressive"
-        return f"Successfully set timeline format to {width}x{height} at {frame_rate} fps ({interlace_status})"
-    else:
-        return "Failed to set timeline format"
-
-
-@mcp.resource("resolve://project/superscale")
-def get_superscale_settings_endpoint() -> Dict[str, Any]:
-    """Get SuperScale settings for the current project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    return get_superscale_settings(current_project)
-
-
-@mcp.tool()
-def set_superscale_settings_tool(enabled: bool, quality: int = 0) -> str:
-    """Set SuperScale settings for the current project.
-    
-    Args:
-        enabled: Whether SuperScale is enabled
-        quality: SuperScale quality (0=Auto, 1=Better Quality, 2=Smoother)
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    quality_names = {
-        0: "Auto",
-        1: "Better Quality",
-        2: "Smoother"
-    }
-    
-    result = set_superscale_settings(current_project, enabled, quality)
-    
-    if result:
-        status = "enabled" if enabled else "disabled"
-        quality_name = quality_names.get(quality, "Unknown")
-        return f"Successfully {status} SuperScale with quality set to {quality_name}"
-    else:
-        return "Failed to set SuperScale settings"
-
-
-@mcp.resource("resolve://project/color-settings")
-def get_color_settings_endpoint() -> Dict[str, Any]:
-    """Get color science and color space settings for the current project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    return get_color_settings(current_project)
-
-
-@mcp.tool()
-def set_color_science_mode_tool(mode: str) -> str:
-    """Set color science mode for the current project.
-    
-    Args:
-        mode: Color science mode ('YRGB', 'YRGB Color Managed', 'ACEScct', or numeric value)
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    result = set_color_science_mode(current_project, mode)
-    
-    if result:
-        return f"Successfully set color science mode to '{mode}'"
-    else:
-        return f"Failed to set color science mode to '{mode}'"
-
-
-@mcp.tool()
-def set_color_space_tool(color_space: str, gamma: str = None) -> str:
-    """Set timeline color space and gamma.
-    
-    Args:
-        color_space: Timeline color space (e.g., 'Rec.709', 'DCI-P3 D65', 'Rec.2020')
-        gamma: Timeline gamma (e.g., 'Rec.709 Gamma', 'Gamma 2.4')
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return "Error: No project currently open"
-    
-    result = set_color_space(current_project, color_space, gamma)
-    
-    if result:
-        if gamma:
-            return f"Successfully set timeline color space to '{color_space}' with gamma '{gamma}'"
-        else:
-            return f"Successfully set timeline color space to '{color_space}'"
-    else:
-        return "Failed to set timeline color space"
-
-
-@mcp.resource("resolve://project/metadata")
-def get_project_metadata_endpoint() -> Dict[str, Any]:
-    """Get metadata for the current project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    return get_project_metadata(current_project)
-
-
-@mcp.resource("resolve://project/info")
-def get_project_info_endpoint() -> Dict[str, Any]:
-    """Get comprehensive information about the current project."""
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    
-    return get_project_info(current_project)
-
-
-@mcp.tool()
-def archive_project(project_name: str, archive_path: str, archive_src_media: bool = True, archive_render_cache: bool = True, archive_proxy_media: bool = False) -> Dict[str, Any]:
-    """Archive a project to a file with optional media.
-
-    Args:
-        project_name: Name of the project to archive.
-        archive_path: Absolute path for the archive file (.dra).
-        archive_src_media: Include source media in archive. Default: True.
-        archive_render_cache: Include render cache. Default: True.
-        archive_proxy_media: Include proxy media. Default: False.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.ArchiveProject(project_name, archive_path, archive_src_media, archive_render_cache, archive_proxy_media)
-    return {"success": bool(result), "project_name": project_name, "archive_path": archive_path}
-
-
-@mcp.tool()
-def delete_project(project_name: str) -> Dict[str, Any]:
-    """Delete a project from the current database. WARNING: This is irreversible.
-
-    Args:
-        project_name: Name of the project to delete.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    # DeleteProject is flaky (silently returns False when the target is/was
-    # current, transient first-attempt failures); route through the retry+switch
-    # guard (#19).
-    from src.utils.project_cleanup import delete_project_safely
-    deleted = delete_project_safely(pm, project_name)
-    return {"success": bool(deleted.get("success")), "project_name": project_name, "delete_detail": deleted}
-
-
-@mcp.tool()
-def create_project_folder(folder_name: str) -> Dict[str, Any]:
-    """Create a new folder in the current project folder location.
-
-    Args:
-        folder_name: Name of the folder to create.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.CreateFolder(folder_name)
-    return {"success": bool(result), "folder_name": folder_name}
-
-
-@mcp.tool()
-def delete_project_folder(folder_name: str) -> Dict[str, Any]:
-    """Delete a folder from the current project folder location.
-
-    Args:
-        folder_name: Name of the folder to delete.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.DeleteFolder(folder_name)
-    return {"success": bool(result), "folder_name": folder_name}
-
-
-@mcp.tool()
-def get_project_folder_list() -> Dict[str, Any]:
-    """Get list of folders in the current project folder location."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    folders = pm.GetFolderListInCurrentFolder()
-    return {"folders": folders if folders else []}
-
-
-@mcp.tool()
-def goto_root_project_folder() -> Dict[str, Any]:
-    """Navigate to the root project folder."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.GotoRootFolder()
-    return {"success": bool(result)}
-
-
-@mcp.tool()
-def goto_parent_project_folder() -> Dict[str, Any]:
-    """Navigate up one level in the project folder hierarchy."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.GotoParentFolder()
-    return {"success": bool(result)}
-
-
-@mcp.tool()
-def get_current_project_folder() -> Dict[str, Any]:
-    """Get the name of the current project folder."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    folder = pm.GetCurrentFolder()
-    return {"current_folder": folder}
-
-
-@mcp.tool()
-def open_project_folder(folder_name: str) -> Dict[str, Any]:
-    """Open/navigate into a project folder.
-
-    Args:
-        folder_name: Name of the folder to open.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.OpenFolder(folder_name)
-    return {"success": bool(result), "folder_name": folder_name}
-
-
-@mcp.tool()
-def import_project_from_file(file_path: str) -> Dict[str, Any]:
-    """Import a project from a .drp file.
-
-    Args:
-        file_path: Absolute path to the .drp project file.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.ImportProject(file_path)
-    return {"success": bool(result), "file_path": file_path}
-
-
-@mcp.tool()
-def export_project_to_file(project_name: str, file_path: str, with_stills_and_luts: bool = True) -> Dict[str, Any]:
-    """Export a project to a .drp file.
-
-    Args:
-        project_name: Name of the project to export.
-        file_path: Absolute path for the exported .drp file.
-        with_stills_and_luts: Include stills and LUTs in export. Default: True.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.ExportProject(project_name, file_path, with_stills_and_luts)
-    return {"success": bool(result), "project_name": project_name, "file_path": file_path}
-
-
-@mcp.tool()
-def restore_project(file_path: str) -> Dict[str, Any]:
-    """Restore a project from an archive (.dra) file.
-
-    Args:
-        file_path: Absolute path to the .dra archive file.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.RestoreProject(file_path)
-    return {"success": bool(result), "file_path": file_path}
-
-
-@mcp.tool()
-def get_current_database() -> Dict[str, Any]:
-    """Get information about the current database."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    db = pm.GetCurrentDatabase()
-    return db if db else {"error": "Failed to get current database"}
-
-
-@mcp.tool()
-def get_database_list() -> Dict[str, Any]:
-    """Get list of all available databases."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    dbs = pm.GetDatabaseList()
-    return {"databases": dbs if dbs else []}
-
-
-@mcp.tool()
-def set_current_database(db_info: Dict[str, str]) -> Dict[str, Any]:
-    """Switch to a different database.
-
-    Args:
-        db_info: Database info dict with keys 'DbType' and 'DbName'. Example: {"DbType": "Disk", "DbName": "Local Database"}
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    result = pm.SetCurrentDatabase(db_info)
-    return {"success": bool(result), "database": db_info}
-
-
-@mcp.tool()
-def set_project_name(name: str) -> Dict[str, Any]:
-    """Rename the current project.
-
-    Args:
-        name: New name for the project.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.SetName(name)
-    return {"success": bool(result), "name": name}
-
-
-@mcp.tool()
-def get_timeline_by_index(index: int) -> Dict[str, Any]:
-    """Get a timeline by its 1-based index.
-
-    Args:
-        index: 1-based timeline index.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    tl = project.GetTimelineByIndex(index)
-    if tl:
-        return {"name": tl.GetName(), "start_frame": tl.GetStartFrame(), "end_frame": tl.GetEndFrame(), "unique_id": tl.GetUniqueId()}
-    return {"error": f"No timeline at index {index}"}
-
-
-@mcp.tool()
-def get_project_preset_list() -> Dict[str, Any]:
-    """Get list of available project presets."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    presets = project.GetPresetList()
-    return {"presets": presets if presets else []}
-
-
-@mcp.tool()
-def set_project_preset(preset_name: str) -> Dict[str, Any]:
-    """Apply a project preset to the current project.
-
-    Args:
-        preset_name: Name of the preset to apply.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.SetPreset(preset_name)
-    return {"success": bool(result), "preset_name": preset_name}
-
-
-@mcp.tool()
-def delete_render_job(job_id: str) -> Dict[str, Any]:
-    """Delete a specific render job by its ID.
-
-    Args:
-        job_id: The unique ID of the render job to delete.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.DeleteRenderJob(job_id)
-    return {"success": bool(result), "job_id": job_id}
-
-
-@mcp.tool()
-def get_render_job_list() -> Dict[str, Any]:
-    """Get list of all render jobs in the queue."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    jobs = project.GetRenderJobList()
-    return {"render_jobs": jobs if jobs else []}
-
-
-@mcp.tool()
-def start_rendering_jobs(job_ids: Optional[List[str]] = None, is_interactive_mode: bool = False) -> Dict[str, Any]:
-    """Start rendering jobs. If no job IDs specified, renders all queued jobs.
-
-    Args:
-        job_ids: Optional list of job IDs to render. If None, renders all.
-        is_interactive_mode: If True, enables interactive rendering mode.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    if job_ids:
-        result = project.StartRendering(job_ids, is_interactive_mode)
-    else:
-        result = project.StartRendering(is_interactive_mode)
-    return {"success": bool(result)}
-
-
-@mcp.tool()
-def stop_rendering() -> Dict[str, Any]:
-    """Stop the current rendering process."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    project.StopRendering()
-    return {"success": True}
-
-
-@mcp.tool()
-def is_rendering_in_progress() -> Dict[str, Any]:
-    """Check if rendering is currently in progress."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.IsRenderingInProgress()
-    return {"is_rendering": bool(result)}
-
-
-@mcp.tool()
-def load_render_preset(preset_name: str) -> Dict[str, Any]:
-    """Load a render preset by name.
-
-    Args:
-        preset_name: Name of the render preset to load.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.LoadRenderPreset(preset_name)
-    return {"success": bool(result), "preset_name": preset_name}
-
-
-@mcp.tool()
-def save_as_new_render_preset(preset_name: str) -> Dict[str, Any]:
-    """Save current render settings as a new preset.
-
-    Args:
-        preset_name: Name for the new render preset.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.SaveAsNewRenderPreset(preset_name)
-    return {"success": bool(result), "preset_name": preset_name}
-
-
-@mcp.tool()
-def delete_render_preset(preset_name: str) -> Dict[str, Any]:
-    """Delete a render preset.
-
-    Args:
-        preset_name: Name of the render preset to delete.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.DeleteRenderPreset(preset_name)
-    return {"success": bool(result), "preset_name": preset_name}
-
-
-@mcp.tool()
-def set_render_settings(settings: Dict[str, Any]) -> Dict[str, Any]:
-    """Set render settings for the current project.
-
-    Mirrors Project.SetRenderSettings({settings}) per docs lines 765-799.
-
-    Args:
-        settings: Dict of render settings. All documented keys are forwarded:
-            SelectAllFrames (bool), MarkIn (int), MarkOut (int),
-            TargetDir (str), CustomName (str), UniqueFilenameStyle (0=Prefix/1=Suffix),
-            ExportVideo (bool), ExportAudio (bool), FormatWidth (int),
-            FormatHeight (int), FrameRate (float), PixelAspectRatio (float),
-            VideoQuality (int/str), AudioCodec (str), AudioBitDepth (int),
-            AudioSampleRate (int), ColorSpaceTag (str), GammaTag (str),
-            ExportAlpha (bool), EncodingProfile (str), MultiPassEncode (bool),
-            AlphaMode (int), NetworkOptimization (bool), ClipStartFrame (int),
-            TimelineStartTimecode (str), ReplaceExistingFilesInPlace (bool),
-            ExportSubtitle (bool), SubtitleFormat ("BurnIn", "EmbeddedCaptions", "SeparateFile").
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.SetRenderSettings(settings)
-    return {"success": bool(result)}
-
-
-@mcp.tool()
-def get_render_job_status(job_id: str) -> Dict[str, Any]:
-    """Get the status of a specific render job.
-
-    Args:
-        job_id: The unique ID of the render job.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    status = project.GetRenderJobStatus(job_id)
-    return status if status else {"error": f"No render job with ID {job_id}"}
-
-
-@mcp.tool()
-def get_render_formats() -> Dict[str, Any]:
-    """Get all available render formats."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    formats = project.GetRenderFormats()
-    return {"formats": formats if formats else {}}
-
-
-@mcp.tool()
-def get_render_codecs(format_name: str) -> Dict[str, Any]:
-    """Get available codecs for a given render format.
-
-    Args:
-        format_name: Render format name (e.g. 'mp4', 'mov', 'avi').
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    codecs = project.GetRenderCodecs(format_name)
-    return {"format": format_name, "codecs": codecs if codecs else {}}
-
-
-@mcp.tool()
-def get_current_render_format_and_codec() -> Dict[str, Any]:
-    """Get the current render format and codec setting."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.GetCurrentRenderFormatAndCodec()
-    return result if result else {"error": "Failed to get render format and codec"}
-
-
-@mcp.tool()
-def set_current_render_format_and_codec(format_name: str, codec_name: str) -> Dict[str, Any]:
-    """Set the render format and codec.
-
-    Args:
-        format_name: Render format (e.g. 'mp4', 'mov').
-        codec_name: Codec name (e.g. 'H264', 'H265', 'ProRes422HQ').
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.SetCurrentRenderFormatAndCodec(format_name, codec_name)
-    return {"success": bool(result), "format": format_name, "codec": codec_name}
-
-
-@mcp.tool()
-def get_current_render_mode() -> Dict[str, Any]:
-    """Get the current render mode (0=Individual Clips, 1=Single Clip)."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    mode = project.GetCurrentRenderMode()
-    return {"render_mode": mode, "mode_name": "Individual Clips" if mode == 0 else "Single Clip"}
-
-
-@mcp.tool()
-def set_current_render_mode(mode: int) -> Dict[str, Any]:
-    """Set the render mode.
-
-    Args:
-        mode: 0 for Individual Clips, 1 for Single Clip.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.SetCurrentRenderMode(mode)
-    return {"success": bool(result), "render_mode": mode}
-
-
-@mcp.tool()
-def get_render_resolutions(format_name: str, codec_name: str) -> Dict[str, Any]:
-    """Get available render resolutions for a format/codec combination.
-
-    Args:
-        format_name: Render format (e.g. 'mp4').
-        codec_name: Codec name (e.g. 'H264').
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    resolutions = project.GetRenderResolutions(format_name, codec_name)
-    return {"format": format_name, "codec": codec_name, "resolutions": resolutions if resolutions else []}
-
-
-@mcp.tool()
-def refresh_lut_list() -> Dict[str, Any]:
-    """Refresh the LUT list in the project. Call after adding new LUT files."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.RefreshLUTList()
-    return {"success": bool(result)}
-
-
-@mcp.tool()
-def get_project_unique_id() -> Dict[str, Any]:
-    """Get the unique ID of the current project."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    uid = project.GetUniqueId()
-    return {"unique_id": uid}
-
-
-@mcp.tool()
-def insert_audio_to_current_track(file_path: str) -> Dict[str, Any]:
-    """Insert audio file to current track at playhead position.
-
-    Args:
-        file_path: Absolute path to the audio file.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.InsertAudioToCurrentTrackAtPlayhead(file_path)
-    return {"success": bool(result), "file_path": file_path}
-
-
-@mcp.tool()
-def load_burn_in_preset(preset_name: str) -> Dict[str, Any]:
-    """Load a burn-in preset by name for the project.
-
-    Args:
-        preset_name: Name of the burn-in preset to load.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.LoadBurnInPreset(preset_name)
-    return {"success": bool(result), "preset_name": preset_name}
-
-
-@mcp.tool()
-def export_current_frame_as_still(file_path: str) -> Dict[str, Any]:
-    """Export the current frame as a still image.
-
-    Args:
-        file_path: Absolute path for the exported still image.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.ExportCurrentFrameAsStill(file_path)
-    return {"success": bool(result), "file_path": file_path}
-
-
-@mcp.tool()
-def get_color_groups_list() -> Dict[str, Any]:
-    """Get list of all color groups in the current project."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    groups = project.GetColorGroupsList()
-    if groups:
-        return {"color_groups": [{"name": g.GetName()} for g in groups]}
-    return {"color_groups": []}
-
-
-@mcp.tool()
-def add_color_group(group_name: str) -> Dict[str, Any]:
-    """Create a new color group in the current project.
-
-    Args:
-        group_name: Name for the new color group.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    result = project.AddColorGroup(group_name)
-    return {"success": bool(result), "group_name": group_name}
-
-
-@mcp.tool()
-def delete_color_group(group_name: str) -> Dict[str, Any]:
-    """Delete a color group from the current project.
-
-    Args:
-        group_name: Name of the color group to delete.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    # Find the group by name
-    groups = project.GetColorGroupsList()
-    target = None
-    if groups:
-        for g in groups:
-            if g.GetName() == group_name:
-                target = g
-                break
-    if not target:
-        return {"error": f"Color group '{group_name}' not found"}
-    result = project.DeleteColorGroup(target)
-    return {"success": bool(result), "group_name": group_name}
-
-
-@mcp.tool()
-def rename_color_group(group_name: str, new_name: str) -> Dict[str, Any]:
-    """Rename a color group.
-
-    Mirrors ColorGroup.SetName(groupName).
-
-    Args:
-        group_name: Current name of the color group.
-        new_name: New name to assign.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    groups = project.GetColorGroupsList() or []
-    target = next((g for g in groups if g.GetName() == group_name), None)
-    if not target:
-        return {"error": f"Color group '{group_name}' not found"}
-    return {"success": bool(target.SetName(new_name)), "old_name": group_name, "new_name": new_name}
-
-
-@mcp.tool()
-def apply_fairlight_preset_to_current_timeline(preset_name: str) -> Dict[str, Any]:
-    """Apply a Fairlight preset to the current timeline.
-
-    Args:
-        preset_name: Name of the Fairlight preset to apply.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    missing = _requires_method(project, "ApplyFairlightPresetToCurrentTimeline", "20.2.2")
-    if missing:
-        return missing
-    result = project.ApplyFairlightPresetToCurrentTimeline(preset_name)
-    return {"success": bool(result), "preset_name": preset_name}
-
-
-@mcp.tool()
-def get_quick_export_render_presets() -> Dict[str, Any]:
-    """Get list of available quick export render presets."""
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    presets = project.GetQuickExportRenderPresets()
-    return {"presets": presets if presets else []}
-
-
-@mcp.tool()
-def render_with_quick_export(
-    preset_name: str,
-    target_dir: Optional[str] = None,
-    custom_name: Optional[str] = None,
-    video_quality: Optional[Any] = None,
-    enable_upload: Optional[bool] = None,
-) -> Dict[str, Any]:
-    """Render the current timeline using a Quick Export preset.
-
-    Mirrors Project.RenderWithQuickExport(preset_name, {param_dict}) per docs line 179.
-
-    Args:
-        preset_name: Name of the Quick Export preset (from get_quick_export_render_presets).
-        target_dir: Output directory; maps to TargetDir in param_dict.
-        custom_name: Output filename; maps to CustomName.
-        video_quality: Video quality setting (int or string per render-settings spec); maps to VideoQuality.
-        enable_upload: Enable direct upload for supported web presets; maps to EnableUpload.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    param_dict: Dict[str, Any] = {}
-    if target_dir is not None:
-        param_dict["TargetDir"] = target_dir
-    if custom_name is not None:
-        param_dict["CustomName"] = custom_name
-    if video_quality is not None:
-        param_dict["VideoQuality"] = video_quality
-    if enable_upload is not None:
-        param_dict["EnableUpload"] = bool(enable_upload)
-    if param_dict:
-        result = project.RenderWithQuickExport(preset_name, param_dict)
-    else:
-        result = project.RenderWithQuickExport(preset_name)
-    if not result:
-        return {"success": False, "preset_name": preset_name, "error": "RenderWithQuickExport returned no status"}
-    if isinstance(result, str):
-        return {"success": False, "preset_name": preset_name, "error": result}
-    return {"success": True, "preset_name": preset_name, "status": result}
-
-
-@mcp.tool()
-def add_render_job() -> Dict[str, Any]:
-    """Add a render job based on current render settings to the render queue.
-
-    Returns the unique job ID string for the new render job.
-    Configure render settings first with set_render_settings, set_render_format_and_codec, etc.
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    project = resolve.GetProjectManager().GetCurrentProject()
-    if not project:
-        return {"error": "No project currently open"}
-    job_id = project.AddRenderJob()
-    if job_id:
-        return {"success": True, "job_id": job_id}
-    return {"success": False, "error": "Failed to add render job. Check render settings are configured."}
-
-
-@mcp.tool()
-def load_cloud_project(project_name: str, project_media_path: str, sync_mode: str = "proxy") -> Dict[str, Any]:
-    """Load a cloud project from DaVinci Resolve cloud.
-
-    Args:
-        project_name: Name of the cloud project to load.
-        project_media_path: Local path for project media cache.
-        sync_mode: Sync mode - 'proxy' or 'full' (default: 'proxy').
-    """
-    resolve = get_resolve()
-    if resolve is None:
-        return {"error": "Not connected to DaVinci Resolve"}
-    pm = resolve.GetProjectManager()
-    if not pm:
-        return {"error": "Failed to get ProjectManager"}
-    cloud_settings = {
-        resolve.CLOUD_SETTING_PROJECT_NAME: project_name,
-        resolve.CLOUD_SETTING_PROJECT_MEDIA_PATH: project_media_path,
-        resolve.CLOUD_SETTING_SYNC_MODE: sync_mode,
-    }
-    project = pm.LoadCloudProject(cloud_settings)
-    if project:
-        return {"success": True, "project_name": project.GetName()}
-    return {"success": False, "error": "Failed to load cloud project. Check cloud settings and connectivity."}
-
-
-@mcp.tool()
-def generate_speech(text_input: str, voice_model: str = "", timecode: str = "",
-                    add_to_timeline: bool = False, audio_track: Optional[int] = None,
-                    custom_voice_file: str = "", speed: Optional[int] = None,
-                    variation: Optional[int] = None, pitch: Optional[int] = None,
-                    generation_id: Optional[int] = None, filename: str = "") -> Dict[str, Any]:
-    """Generate AI text-to-speech audio and add it to the media pool (Resolve 21+).
-
-    Requires the AI Speech Generator Extra. Creates a NEW audio MediaPoolItem; if
-    add_to_timeline is True it is placed on the timeline at the given timecode.
-
-    Args:
-        text_input: Text to synthesize (required).
-        voice_model: Voice model name (e.g. "Female 1", "Male 1", "Custom Voice").
-        timecode: Timeline timecode to place the clip at when add_to_timeline is True.
-        add_to_timeline: Whether to add the generated clip to the timeline.
-        audio_track: Audio track index for timeline placement.
-        custom_voice_file: Full path to a custom voice file (for "Custom Voice").
-        speed: Speech speed.
-        variation: Voice variation.
-        pitch: Voice pitch.
-        generation_id: Generation ID.
-        filename: Output filename.
-    """
-    pm, current_project = get_current_project()
-    if not current_project:
-        return {"error": "No project currently open"}
-    if not hasattr(current_project, "GenerateSpeech"):
-        return {"error": "GenerateSpeech requires DaVinci Resolve 21+ and the AI Speech Generator Extra"}
-    if not text_input:
-        return {"error": "text_input is required"}
-    settings: Dict[str, Any] = {"TextInput": text_input}
-    if voice_model:
-        settings["VoiceModel"] = voice_model
-    if custom_voice_file:
-        settings["CustomVoiceFile"] = custom_voice_file
-    if speed is not None:
-        settings["Speed"] = speed
-    if variation is not None:
-        settings["Variation"] = variation
-    if pitch is not None:
-        settings["Pitch"] = pitch
-    if generation_id is not None:
-        settings["GenerationID"] = generation_id
-    if filename:
-        settings["Filename"] = filename
-    if add_to_timeline:
-        settings["AddToTimeline"] = True
-        if audio_track is not None:
-            settings["AudioTrack"] = audio_track
-    new_item = current_project.GenerateSpeech(settings, timecode or "")
-    if not new_item:
-        return {"success": False, "error": "GenerateSpeech returned no media item"}
-    return {"success": True, "new": new_item.GetName(), "new_id": new_item.GetUniqueId()}