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

package/mcps/davinci-resolve-mcp/src/utils/layout_presets.py

@@ -1,333 +0,0 @@
-#!/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/mcps/davinci-resolve-mcp/src/utils/mcp_stdio.py

@@ -1,32 +0,0 @@
-"""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))

package/mcps/davinci-resolve-mcp/src/utils/mcp_transport.py

@@ -1,128 +0,0 @@
-"""Networked transport for the MCP server (opt-in via --transport).
-
-stdio remains the default. The `sse` and `streamable-http` modes bind to
-loopback (127.0.0.1) by default and REQUIRE a bearer token on every request, so
-turning networking on never silently exposes Resolve. The token comes from
-``$DAVINCI_MCP_TOKEN`` or is generated and logged at startup. A small state file
-lets the control panel show the live connection URL + token.
-
-Security posture:
-- Default host is loopback; a non-loopback bind logs a loud warning.
-- Every HTTP request must carry ``Authorization: Bearer <token>`` (constant-time
-  compared); otherwise 401.
-- stdio (the default transport) is unaffected by anything here.
-"""
-import json
-import logging
-import os
-import secrets
-import tempfile
-import time
-
-logger = logging.getLogger("davinci-resolve-mcp")
-
-TRANSPORT_STATE_PATH = os.path.join(
-    tempfile.gettempdir(), "davinci_resolve_mcp_transport.json"
-)
-LOOPBACK_HOSTS = {"127.0.0.1", "localhost", "::1"}
-
-
-def resolve_token():
-    """Return (token, was_generated). Honors $DAVINCI_MCP_TOKEN."""
-    tok = os.environ.get("DAVINCI_MCP_TOKEN")
-    if tok:
-        return tok, False
-    return secrets.token_urlsafe(24), True
-
-
-def _auth_middleware_cls(token):
-    from starlette.middleware.base import BaseHTTPMiddleware
-    from starlette.responses import JSONResponse
-
-    expected = f"Bearer {token}"
-
-    class BearerAuth(BaseHTTPMiddleware):
-        async def dispatch(self, request, call_next):
-            provided = request.headers.get("authorization", "")
-            if not secrets.compare_digest(provided, expected):
-                return JSONResponse(
-                    {"error": "unauthorized: Authorization: Bearer <token> required"},
-                    status_code=401,
-                )
-            return await call_next(request)
-
-    return BearerAuth
-
-
-def write_transport_state(transport, host, port, token):
-    try:
-        with open(TRANSPORT_STATE_PATH, "w", encoding="utf-8") as fh:
-            json.dump({
-                "transport": transport,
-                "host": host,
-                "port": port,
-                "url": f"http://{host}:{port}",
-                "token": token,
-                "loopback": host in LOOPBACK_HOSTS,
-                "pid": os.getpid(),
-                "started_at": time.time(),
-            }, fh)
-    except OSError as exc:
-        logger.warning("could not write transport state: %s", exc)
-
-
-def clear_transport_state():
-    try:
-        os.remove(TRANSPORT_STATE_PATH)
-    except OSError:
-        pass
-
-
-def read_transport_state():
-    """Return the live transport state dict, or None if no networked instance.
-
-    Treats a state file whose pid is no longer alive as stale (returns None).
-    """
-    try:
-        with open(TRANSPORT_STATE_PATH, encoding="utf-8") as fh:
-            state = json.load(fh)
-    except (OSError, ValueError):
-        return None
-    pid = state.get("pid")
-    if isinstance(pid, int):
-        try:
-            os.kill(pid, 0)
-        except (OSError, ProcessLookupError):
-            return None
-    return state
-
-
-def run_networked(mcp, transport):
-    """Serve `mcp` over an authenticated HTTP transport ('sse'|'streamable-http')."""
-    import uvicorn
-
-    host = os.environ.get("DAVINCI_MCP_HOST") or mcp.settings.host or "127.0.0.1"
-    port = int(os.environ.get("DAVINCI_MCP_PORT") or mcp.settings.port or 8000)
-    mcp.settings.host = host
-    mcp.settings.port = port
-    token, generated = resolve_token()
-
-    app = mcp.sse_app() if transport == "sse" else mcp.streamable_http_app()
-    app.add_middleware(_auth_middleware_cls(token))
-
-    if host not in LOOPBACK_HOSTS:
-        logger.warning(
-            "SECURITY: MCP %s transport bound to NON-loopback host %r — Resolve "
-            "control is exposed on the network. Ensure this is intended.",
-            transport, host,
-        )
-    logger.info("MCP %s transport: http://%s:%s (bearer token required)",
-                transport, host, port)
-    if generated:
-        logger.info("Generated bearer token (set $DAVINCI_MCP_TOKEN to pin it): %s", token)
-
-    write_transport_state(transport, host, port, token)
-    try:
-        uvicorn.run(app, host=host, port=port, log_level="warning")
-    finally:
-        clear_transport_state()