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

package/mcps/davinci-mcp-professional/src/davinci_mcp/tools/__init__.py

@@ -1,146 +0,0 @@
-"""
-MCP tools for DaVinci Resolve integration.
-"""
-
-import mcp.types as types
-
-
-def get_all_tools() -> list[types.Tool]:
-    """Get all available MCP tools."""
-    return [
-        # System tools
-        types.Tool(
-            name="get_version",
-            description="Get DaVinci Resolve version information",
-            inputSchema={"type": "object", "properties": {}, "required": []},
-        ),
-        types.Tool(
-            name="get_current_page",
-            description=(
-                "Get the current page open in DaVinci Resolve"
-                " (Edit, Color, Fusion, etc.)"
-            ),
-            inputSchema={"type": "object", "properties": {}, "required": []},
-        ),
-        types.Tool(
-            name="switch_page",
-            description="Switch to a specific page in DaVinci Resolve",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "page": {
-                        "type": "string",
-                        "description": "The page to switch to",
-                        "enum": [
-                            "media",
-                            "cut",
-                            "edit",
-                            "fusion",
-                            "color",
-                            "fairlight",
-                            "deliver",
-                        ],
-                    }
-                },
-                "required": ["page"],
-            },
-        ),
-        # Project tools
-        types.Tool(
-            name="list_projects",
-            description="List all available projects in the current database",
-            inputSchema={"type": "object", "properties": {}, "required": []},
-        ),
-        types.Tool(
-            name="get_current_project",
-            description="Get the name of the currently open project",
-            inputSchema={"type": "object", "properties": {}, "required": []},
-        ),
-        types.Tool(
-            name="open_project",
-            description="Open a project by name",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "name": {
-                        "type": "string",
-                        "description": "The name of the project to open",
-                    }
-                },
-                "required": ["name"],
-            },
-        ),
-        types.Tool(
-            name="create_project",
-            description="Create a new project with the given name",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "name": {
-                        "type": "string",
-                        "description": "The name for the new project",
-                    }
-                },
-                "required": ["name"],
-            },
-        ),
-        # Timeline tools
-        types.Tool(
-            name="list_timelines",
-            description="List all timelines in the current project",
-            inputSchema={"type": "object", "properties": {}, "required": []},
-        ),
-        types.Tool(
-            name="get_current_timeline",
-            description="Get the name of the current timeline",
-            inputSchema={"type": "object", "properties": {}, "required": []},
-        ),
-        types.Tool(
-            name="create_timeline",
-            description="Create a new timeline with the given name",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "name": {
-                        "type": "string",
-                        "description": "The name for the new timeline",
-                    }
-                },
-                "required": ["name"],
-            },
-        ),
-        types.Tool(
-            name="switch_timeline",
-            description="Switch to a timeline by name",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "name": {
-                        "type": "string",
-                        "description": "The name of the timeline to switch to",
-                    }
-                },
-                "required": ["name"],
-            },
-        ),
-        # Media tools
-        types.Tool(
-            name="list_media_clips",
-            description="List all clips in the media pool",
-            inputSchema={"type": "object", "properties": {}, "required": []},
-        ),
-        types.Tool(
-            name="import_media",
-            description="Import a media file into the media pool",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "file_path": {
-                        "type": "string",
-                        "description": "The path to the media file to import",
-                    }
-                },
-                "required": ["file_path"],
-            },
-        ),
-    ]

package/mcps/davinci-mcp-professional/src/davinci_mcp/types.py

@@ -1,125 +0,0 @@
-"""
-Type definitions for DaVinci Resolve API.
-
-This module provides Protocol definitions for the DaVinci Resolve API
-to improve type safety while working with the external scripting interface.
-"""
-
-from typing import Any, Protocol, runtime_checkable
-
-
-@runtime_checkable
-class DaVinciProject(Protocol):
-    """Protocol for DaVinci Resolve Project objects."""
-
-    def GetName(self) -> str:
-        """Get the project name."""
-        ...
-
-    def GetTimelines(self) -> list[Any]:
-        """Get all timelines in the project."""
-        ...
-
-    def GetCurrentTimeline(self) -> Any | None:
-        """Get the currently active timeline."""
-        ...
-
-    def AddTimeline(self, name: str) -> Any | None:
-        """Add a new timeline with the given name."""
-        ...
-
-    def GetMediaPool(self) -> Any:
-        """Get the media pool for this project."""
-        ...
-
-
-@runtime_checkable
-class DaVinciTimeline(Protocol):
-    """Protocol for DaVinci Resolve Timeline objects."""
-
-    def GetName(self) -> str:
-        """Get the timeline name."""
-        ...
-
-    def GetTrackCount(self, track_type: str) -> int:
-        """Get the number of tracks of the specified type."""
-        ...
-
-
-@runtime_checkable
-class DaVinciMediaPool(Protocol):
-    """Protocol for DaVinci Resolve MediaPool objects."""
-
-    def GetClips(self) -> list[Any]:
-        """Get all clips in the media pool."""
-        ...
-
-    def ImportMedia(self, file_path: str) -> bool:
-        """Import media from the specified file path."""
-        ...
-
-
-@runtime_checkable
-class DaVinciProjectManager(Protocol):
-    """Protocol for DaVinci Resolve ProjectManager objects."""
-
-    def GetCurrentProject(self) -> DaVinciProject | None:
-        """Get the currently open project."""
-        ...
-
-    def GetProjectsInDatabase(self) -> list[dict[str, Any]]:
-        """Get all projects in the current database."""
-        ...
-
-    def GetProjectListInCurrentFolder(self) -> list[str]:
-        """Get project list in current folder."""
-        ...
-
-    def CreateProject(self, name: str) -> DaVinciProject | None:
-        """Create a new project with the given name."""
-        ...
-
-    def LoadProject(self, name: str) -> DaVinciProject | None:
-        """Load an existing project by name."""
-        ...
-
-
-@runtime_checkable
-class DaVinciResolveApp(Protocol):
-    """Protocol for the main DaVinci Resolve application object."""
-
-    def GetVersion(self) -> list[str]:
-        """Get the DaVinci Resolve version information."""
-        ...
-
-    def GetProductName(self) -> str:
-        """Get the product name."""
-        ...
-
-    def GetVersionString(self) -> str:
-        """Get the version as a string."""
-        ...
-
-    def GetProjectManager(self) -> DaVinciProjectManager:
-        """Get the project manager."""
-        ...
-
-    def GetCurrentPage(self) -> str:
-        """Get the currently active page."""
-        ...
-
-    def OpenPage(self, page: str) -> bool:
-        """Open a specific page."""
-        ...
-
-    def GetCurrentProject(self) -> DaVinciProject | None:
-        """Get the currently active project."""
-        ...
-
-
-# Type aliases for common return types
-ResolveVersion = list[str]
-ProjectName = str
-TimelineName = str
-PageName = str
-MediaClipInfo = dict[str, Any]

package/mcps/davinci-mcp-professional/src/davinci_mcp/utils/__init__.py

@@ -1,19 +0,0 @@
-"""Utility modules for DaVinci MCP."""
-
-from .platform import (
-    check_python_runtime_compatibility,
-    check_resolve_installation,
-    check_resolve_running,
-    get_platform,
-    get_resolve_paths,
-    setup_resolve_environment,
-)
-
-__all__ = [
-    "get_platform",
-    "get_resolve_paths",
-    "setup_resolve_environment",
-    "check_resolve_installation",
-    "check_resolve_running",
-    "check_python_runtime_compatibility",
-]

package/mcps/davinci-mcp-professional/src/davinci_mcp/utils/platform.py

@@ -1,239 +0,0 @@
-"""
-Platform detection and environment setup utilities.
-"""
-
-import os
-import platform
-import sys
-from pathlib import Path
-
-
-def get_platform() -> str:
-    """Get the current platform name."""
-    system = platform.system().lower()
-    if system == "darwin":
-        return "macos"
-    elif system == "windows":
-        return "windows"
-    elif system == "linux":
-        return "linux"
-    else:
-        return system
-
-
-def get_resolve_paths() -> dict[str, Path]:
-    """Get platform-specific paths for DaVinci Resolve scripting API."""
-    current_platform = get_platform()
-
-    if current_platform == "macos":
-        api_path = Path(
-            "/Library/Application Support/Blackmagic Design"
-            "/DaVinci Resolve/Developer/Scripting"
-        )
-        lib_path = Path(
-            "/Applications/DaVinci Resolve/DaVinci Resolve.app"
-            "/Contents/Libraries/Fusion/fusionscript.so"
-        )
-
-    elif current_platform == "windows":
-        program_data = Path(os.environ.get("PROGRAMDATA", "C:\\ProgramData"))
-        program_files = Path(os.environ.get("PROGRAMFILES", "C:\\Program Files"))
-
-        api_path = (
-            program_data
-            / "Blackmagic Design"
-            / "DaVinci Resolve"
-            / "Support"
-            / "Developer"
-            / "Scripting"
-        )
-        lib_path = (
-            program_files / "Blackmagic Design" / "DaVinci Resolve" / "fusionscript.dll"
-        )
-
-    elif current_platform == "linux":
-        # Default Linux paths - may need adjustment based on installation
-        api_path = Path("/opt/resolve/Developer/Scripting")
-        lib_path = Path("/opt/resolve/libs/fusionscript.so")
-
-    else:
-        raise RuntimeError(f"Unsupported platform: {current_platform}")
-
-    return {
-        "api_path": api_path,
-        "lib_path": lib_path,
-        "modules_path": api_path / "Modules",
-    }
-
-
-def setup_resolve_environment() -> bool:
-    """Set up environment variables for DaVinci Resolve scripting."""
-    try:
-        paths = get_resolve_paths()
-
-        # Set environment variables
-        os.environ["RESOLVE_SCRIPT_API"] = str(paths["api_path"])
-        os.environ["RESOLVE_SCRIPT_LIB"] = str(paths["lib_path"])
-
-        # Add modules path to Python path if not already there
-        modules_path_str = str(paths["modules_path"])
-        if modules_path_str not in sys.path:
-            sys.path.insert(0, modules_path_str)
-
-        # On Windows (Python 3.8+), the default DLL search path excludes
-        # directories formerly found via PATH.  fusionscript.dll depends
-        # on sibling DLLs in the Resolve install directory (lua5.1.dll,
-        # tbbmalloc.dll, etc.) so we must add that directory explicitly.
-        if sys.platform == "win32":
-            lib_dir = paths["lib_path"].parent
-            if lib_dir.exists():
-                os.add_dll_directory(str(lib_dir))
-
-        return True
-    except Exception:
-        return False
-
-
-def check_resolve_installation() -> dict[str, bool]:
-    """Check if DaVinci Resolve is properly installed."""
-    paths = get_resolve_paths()
-
-    return {
-        "api_path_exists": paths["api_path"].exists(),
-        "lib_path_exists": paths["lib_path"].exists(),
-        "modules_path_exists": paths["modules_path"].exists(),
-    }
-
-
-def check_resolve_running() -> bool:
-    """Check if DaVinci Resolve is currently running."""
-    current_platform = get_platform()
-
-    try:
-        if current_platform == "windows":
-            import subprocess
-
-            result = subprocess.run(
-                ["tasklist", "/FI", "IMAGENAME eq Resolve.exe"],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            return "Resolve.exe" in result.stdout
-
-        elif current_platform in ["macos", "linux"]:
-            import subprocess
-
-            result = subprocess.run(
-                ["pgrep", "-f", "DaVinci Resolve"], capture_output=True, check=False
-            )
-            return result.returncode == 0
-
-        return False
-    except Exception:
-        return False
-
-
-def check_python_runtime_compatibility() -> tuple[bool, str]:
-    """
-    Detect whether fusionscript.dll will load a conflicting Python runtime.
-
-    On Windows, DaVinci Resolve's fusionscript.dll discovers the system
-    Python installation via the Windows registry and calls LoadLibrary
-    with a full path to that installation's python3.dll.  If the MCP
-    server is running under a *different* Python installation (e.g. a
-    uv-managed Python), two incompatible Python runtimes end up in the
-    same process and the server crashes with an access violation.
-
-    This function compares the running Python's python3.dll path to the
-    registry-registered Python's install directory.  If they differ, it
-    returns an actionable diagnostic.
-
-    On non-Windows platforms or inside PyInstaller bundles the check is
-    skipped (always returns success).
-    """
-    if sys.platform != "win32":
-        return (True, "")
-
-    if getattr(sys, "frozen", False):
-        return (True, "")
-
-    try:
-        import ctypes
-        import winreg
-
-        # --- Find the registry-registered Python install path ---
-        base_key = r"SOFTWARE\Python\PythonCore"
-        registered_path: str | None = None
-        registered_ver: str | None = None
-
-        try:
-            core_key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, base_key)
-        except FileNotFoundError:
-            # No system Python registered — fusionscript.dll may fail to
-            # find Python at all, but that is a different error path.
-            return (True, "")
-
-        # Pick the highest registered Python 3.x version.
-        i = 0
-        while True:
-            try:
-                ver = winreg.EnumKey(core_key, i)
-                i += 1
-            except OSError:
-                break
-            if not ver.startswith("3"):
-                continue
-            try:
-                ip_key = winreg.OpenKey(core_key, ver + r"\InstallPath")
-                val, _ = winreg.QueryValueEx(ip_key, "")
-                winreg.CloseKey(ip_key)
-                if registered_ver is None or ver > registered_ver:
-                    registered_ver = ver
-                    registered_path = val
-            except (FileNotFoundError, OSError):
-                continue
-        winreg.CloseKey(core_key)
-
-        if not registered_path:
-            return (True, "")
-
-        # --- Find the running Python's python3.dll location ---
-        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
-        GetModuleHandleW = kernel32.GetModuleHandleW
-        GetModuleHandleW.restype = ctypes.c_void_p
-        GetModuleFileNameW = kernel32.GetModuleFileNameW
-
-        handle = GetModuleHandleW("python3.dll")
-        if not handle:
-            return (True, "")
-
-        buf = ctypes.create_unicode_buffer(512)
-        GetModuleFileNameW(ctypes.c_void_p(handle), buf, 512)
-        loaded_python3_path = buf.value
-
-        if not loaded_python3_path:
-            return (True, "")
-
-        # --- Compare directories ---
-        loaded_dir = os.path.normcase(os.path.dirname(loaded_python3_path))
-        registry_dir = os.path.normcase(registered_path.rstrip("\\/"))
-
-        if loaded_dir == registry_dir:
-            return (True, "")
-
-        return (
-            False,
-            f"Python runtime conflict: this process loaded python3.dll "
-            f"from {os.path.dirname(loaded_python3_path)}, but DaVinci "
-            f"Resolve will load Python from the system installation at "
-            f"{registered_path.rstrip(chr(92) + '/')}. Two Python "
-            f"runtimes in one process will crash. Create the virtual "
-            f"environment from the system Python instead:\n"
-            f'  uv venv --python "{registered_path}python.exe"\n'
-            f"  uv sync",
-        )
-
-    except Exception:
-        # If anything goes wrong in detection, don't block startup.
-        return (True, "")