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

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

@@ -1,342 +0,0 @@
-"""
-DaVinci Resolve client wrapper.
-
-Provides a clean interface to the DaVinci Resolve API with proper error handling
-and logging.
-"""
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    # Import for type checking only to avoid runtime import issues
-    from .types import DaVinciProject, DaVinciProjectManager, DaVinciResolveApp
-
-from .utils.platform import (
-    check_python_runtime_compatibility,
-    check_resolve_running,
-    setup_resolve_environment,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class DaVinciResolveError(Exception):
-    """Base exception for DaVinci Resolve related errors."""
-
-    pass
-
-
-class DaVinciResolveNotRunningError(DaVinciResolveError):
-    """Raised when DaVinci Resolve is not running."""
-
-    pass
-
-
-class DaVinciResolveConnectionError(DaVinciResolveError):
-    """Raised when connection to DaVinci Resolve fails."""
-
-    pass
-
-
-class DaVinciResolveClient:
-    """
-    A clean interface to the DaVinci Resolve API.
-
-    This class handles the connection to DaVinci Resolve and provides
-    organized methods for interacting with projects, timelines, media, etc.
-    """
-
-    def __init__(self) -> None:
-        self._resolve: DaVinciResolveApp | None = None
-        self._project_manager: DaVinciProjectManager | None = None
-        self._current_project: DaVinciProject | None = None
-        self._is_connected = False
-
-    def connect(self) -> None:
-        """Connect to DaVinci Resolve."""
-        # Check if Resolve is running
-        if not check_resolve_running():
-            raise DaVinciResolveNotRunningError(
-                "DaVinci Resolve is not running. Please start DaVinci Resolve first."
-            )
-
-        # Set up environment (env vars, sys.path, DLL search dirs)
-        if not setup_resolve_environment():
-            raise DaVinciResolveConnectionError(
-                "Failed to set up DaVinci Resolve environment variables."
-            )
-
-        # On Windows, fusionscript.dll discovers Python via the Windows
-        # registry and loads python3.dll by full path.  If the running
-        # Python is a different installation (e.g. uv-managed), two
-        # runtimes end up in the same process and it crashes.
-        compat_ok, compat_msg = check_python_runtime_compatibility()
-        if not compat_ok:
-            raise DaVinciResolveConnectionError(compat_msg)
-
-        try:
-            # Import and connect to Resolve
-            import DaVinciResolveScript as dvr_script  # type: ignore[reportMissingImports]
-
-            self._resolve = dvr_script.scriptapp("Resolve")  # type: ignore[reportUnknownMemberType]
-
-            if self._resolve is None:
-                raise DaVinciResolveConnectionError(
-                    "Failed to get Resolve object. "
-                    "Check that DaVinci Resolve is running."
-                )  # type: ignore[reportUnknownMemberType]
-
-            # Get project manager
-            self._project_manager = self._resolve.GetProjectManager()  # type: ignore[reportUnknownMemberType]
-            if self._project_manager is None:
-                raise DaVinciResolveConnectionError("Failed to get Project Manager.")
-
-            # Get current project if one is open
-            self._current_project = self._project_manager.GetCurrentProject()  # type: ignore[reportUnknownMemberType]
-
-            self._is_connected = True
-            logger.info(f"Connected to {self.get_version()}")
-
-        except SystemError as e:
-            raise DaVinciResolveConnectionError(
-                f"fusionscript.dll initialization failed: {e}. "
-                "Check that DaVinci Resolve Studio is running with "
-                "external scripting enabled in Preferences."
-            )
-        except ImportError as e:
-            raise DaVinciResolveConnectionError(
-                f"Failed to import DaVinciResolveScript: {e}. "
-                "Check environment variables and DaVinci Resolve installation."
-            )
-        except DaVinciResolveConnectionError:
-            raise
-        except Exception as e:
-            raise DaVinciResolveConnectionError(f"Unexpected error connecting: {e}")
-
-    def disconnect(self) -> None:
-        """Disconnect from DaVinci Resolve."""
-        self._resolve = None
-        self._project_manager = None
-        self._current_project = None
-        self._is_connected = False
-        logger.info("Disconnected from DaVinci Resolve")
-
-    def is_connected(self) -> bool:
-        """Check if connected to DaVinci Resolve."""
-        return self._is_connected
-
-    def _ensure_connected(self) -> None:
-        """Ensure we're connected to Resolve."""
-        if not self._is_connected:
-            raise DaVinciResolveConnectionError("Not connected to DaVinci Resolve")
-
-    def _ensure_project(self) -> Any:
-        """Ensure we have a current project."""
-        self._ensure_connected()
-
-        # Refresh current project
-        if self._project_manager:
-            self._current_project = self._project_manager.GetCurrentProject()
-
-        if self._current_project is None:
-            raise DaVinciResolveError("No project is currently open")
-
-        return self._current_project
-
-    # System Information
-    def get_version(self) -> str:
-        """Get DaVinci Resolve version."""
-        self._ensure_connected()
-        if self._resolve:
-            return (
-                f"{self._resolve.GetProductName()} {self._resolve.GetVersionString()}"
-            )
-        return "Unknown"
-
-    def get_current_page(self) -> str:
-        """Get the current page (Edit, Color, Fusion, etc.)."""
-        self._ensure_connected()
-        if self._resolve:
-            return self._resolve.GetCurrentPage()
-        return "Unknown"
-
-    def switch_page(self, page: str) -> bool:
-        """Switch to a specific page."""
-        self._ensure_connected()
-
-        valid_pages = [
-            "media",
-            "cut",
-            "edit",
-            "fusion",
-            "color",
-            "fairlight",
-            "deliver",
-        ]
-        if page.lower() not in valid_pages:
-            raise ValueError(f"Invalid page. Must be one of: {', '.join(valid_pages)}")
-
-        if self._resolve:
-            return bool(self._resolve.OpenPage(page.lower()))
-        return False
-
-    # Project Management
-    def list_projects(self) -> list[str]:
-        """List all projects in the current database."""
-        self._ensure_connected()
-
-        if self._project_manager:
-            projects = self._project_manager.GetProjectListInCurrentFolder()
-            return [p for p in projects if p]  # Filter out empty strings
-        return []
-
-    def get_current_project_name(self) -> str | None:
-        """Get the name of the currently open project."""
-        try:
-            project = self._ensure_project()
-            return project.GetName()
-        except DaVinciResolveError:
-            return None
-
-    def open_project(self, name: str) -> bool:
-        """Open a project by name."""
-        self._ensure_connected()
-
-        if not self._project_manager:
-            return False
-
-        # Check if project exists
-        projects = self.list_projects()
-        if name not in projects:
-            raise ValueError(
-                f"Project '{name}' not found. Available: {', '.join(projects)}"
-            )
-
-        result = self._project_manager.LoadProject(name)
-        if result:
-            self._current_project = self._project_manager.GetCurrentProject()
-            logger.info(f"Opened project: {name}")
-
-        return bool(result)
-
-    def create_project(self, name: str) -> bool:
-        """Create a new project."""
-        self._ensure_connected()
-
-        if not self._project_manager:
-            return False
-
-        # Check if project already exists
-        projects = self.list_projects()
-        if name in projects:
-            raise ValueError(f"Project '{name}' already exists")
-
-        result = self._project_manager.CreateProject(name)
-        if result:
-            self._current_project = self._project_manager.GetCurrentProject()
-            logger.info(f"Created project: {name}")
-
-        return bool(result)
-
-    # Timeline Management
-    def list_timelines(self) -> list[str]:
-        """List all timelines in the current project."""
-        project = self._ensure_project()
-
-        timeline_count = project.GetTimelineCount()
-        timelines: list[str] = []
-
-        for i in range(1, timeline_count + 1):
-            timeline = project.GetTimelineByIndex(i)
-            if timeline:
-                name = timeline.GetName()
-                if isinstance(name, str):
-                    timelines.append(name)
-
-        return timelines
-
-    def get_current_timeline_name(self) -> str | None:
-        """Get the name of the current timeline."""
-        try:
-            project = self._ensure_project()
-            current_timeline = project.GetCurrentTimeline()
-            return current_timeline.GetName() if current_timeline else None
-        except DaVinciResolveError:
-            return None
-
-    def create_timeline(self, name: str) -> bool:
-        """Create a new timeline."""
-        project = self._ensure_project()
-
-        media_pool = project.GetMediaPool()
-        if not media_pool:
-            raise DaVinciResolveError("Failed to get Media Pool")
-
-        timeline = media_pool.CreateEmptyTimeline(name)
-        if timeline:
-            logger.info(f"Created timeline: {name}")
-            return True
-
-        return False
-
-    def switch_timeline(self, name: str) -> bool:
-        """Switch to a timeline by name."""
-        project = self._ensure_project()
-
-        # Find timeline by name
-        timeline_count = project.GetTimelineCount()
-        for i in range(1, timeline_count + 1):
-            timeline = project.GetTimelineByIndex(i)
-            if timeline and timeline.GetName() == name:
-                result = project.SetCurrentTimeline(timeline)
-                if result:
-                    logger.info(f"Switched to timeline: {name}")
-                return bool(result)
-
-        raise ValueError(f"Timeline '{name}' not found")
-
-    # Media Pool Management
-    def list_media_clips(self) -> list[dict[str, Any]]:
-        """List all clips in the media pool root folder."""
-        project = self._ensure_project()
-
-        media_pool = project.GetMediaPool()
-        if not media_pool:
-            raise DaVinciResolveError("Failed to get Media Pool")
-
-        root_folder = media_pool.GetRootFolder()
-        if not root_folder:
-            raise DaVinciResolveError("Failed to get root folder")
-
-        clips = root_folder.GetClipList()
-        if not clips:
-            return []
-
-        result: list[dict[str, Any]] = []
-        for clip in clips:
-            clip_info = {
-                "name": clip.GetName(),
-                "duration": clip.GetDuration(),
-                "fps": clip.GetClipProperty("FPS") or "Unknown",
-            }
-            result.append(clip_info)
-
-        return result
-
-    def import_media(self, file_path: str) -> bool:
-        """Import a media file into the media pool."""
-        project = self._ensure_project()
-
-        media_pool = project.GetMediaPool()
-        if not media_pool:
-            raise DaVinciResolveError("Failed to get Media Pool")
-
-        # Import the media file
-        imported_clips = media_pool.ImportMedia([file_path])
-
-        if imported_clips:
-            logger.info(f"Imported media: {file_path}")
-            return True
-
-        return False

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

@@ -1,60 +0,0 @@
-"""
-MCP resources for DaVinci Resolve integration.
-"""
-
-from typing import cast
-
-import mcp.types as types
-from pydantic import AnyUrl
-
-
-def get_all_resources() -> list[types.Resource]:
-    """Get all available MCP resources."""
-    return [
-        # System resources
-        types.Resource(
-            uri=cast(AnyUrl, "resolve://version"),
-            name="DaVinci Resolve Version",
-            description="Current version of DaVinci Resolve",
-            mimeType="text/plain",
-        ),
-        types.Resource(
-            uri=cast(AnyUrl, "resolve://current-page"),
-            name="Current Page",
-            description="The currently active page in DaVinci Resolve",
-            mimeType="text/plain",
-        ),
-        # Project resources
-        types.Resource(
-            uri=cast(AnyUrl, "resolve://projects"),
-            name="Available Projects",
-            description="List of all available projects in the current database",
-            mimeType="application/json",
-        ),
-        types.Resource(
-            uri=cast(AnyUrl, "resolve://current-project"),
-            name="Current Project",
-            description="Name of the currently open project",
-            mimeType="text/plain",
-        ),
-        # Timeline resources
-        types.Resource(
-            uri=cast(AnyUrl, "resolve://timelines"),
-            name="Available Timelines",
-            description="List of all timelines in the current project",
-            mimeType="application/json",
-        ),
-        types.Resource(
-            uri=cast(AnyUrl, "resolve://current-timeline"),
-            name="Current Timeline",
-            description="Name of the current timeline",
-            mimeType="text/plain",
-        ),
-        # Media resources
-        types.Resource(
-            uri=cast(AnyUrl, "resolve://media-clips"),
-            name="Media Pool Clips",
-            description="List of all clips in the media pool",
-            mimeType="application/json",
-        ),
-    ]

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

@@ -1,185 +0,0 @@
-"""
-DaVinci Resolve MCP Server.
-
-A clean, modern implementation of the Model Context Protocol server
-for DaVinci Resolve integration.
-"""
-
-import logging
-from typing import Any
-
-import mcp.server.stdio
-import mcp.types as types
-from mcp.server import NotificationOptions, Server
-from mcp.server.models import InitializationOptions
-from pydantic import AnyUrl
-
-from . import __version__
-from .resolve_client import DaVinciResolveClient, DaVinciResolveError
-from .resources import get_all_resources
-from .tools import get_all_tools
-
-logger = logging.getLogger(__name__)
-
-
-class DaVinciMCPServer:
-    """
-    DaVinci Resolve MCP Server.
-
-    Provides a clean interface between MCP clients and DaVinci Resolve
-    through organized tools and resources.
-    """
-
-    def __init__(self) -> None:
-        self.server = Server("davinci-resolve-mcp")
-        self.resolve_client = DaVinciResolveClient()
-        self._register_handlers()
-
-    def _register_handlers(self) -> None:
-        """Register MCP server handlers."""
-
-        @self.server.list_tools()
-        async def handle_list_tools() -> list[types.Tool]:  # type: ignore[reportUnusedFunction]
-            return get_all_tools()
-
-        @self.server.call_tool()
-        async def handle_call_tool(  # type: ignore[reportUnusedFunction]
-            name: str, arguments: dict[str, Any] | None = None
-        ) -> list[types.TextContent]:
-            if arguments is None:
-                arguments = {}
-            try:
-                if not self.resolve_client.is_connected():
-                    self.resolve_client.connect()
-                result = await self._call_tool(name, arguments)
-                return [types.TextContent(type="text", text=str(result))]
-            except DaVinciResolveError as e:
-                error_msg = f"DaVinci Resolve error: {e}"
-                logger.exception(error_msg)
-                return [types.TextContent(type="text", text=error_msg)]
-            except Exception as e:
-                error_msg = f"Unexpected error: {e}"
-                logger.exception(error_msg)
-                return [types.TextContent(type="text", text=error_msg)]
-
-        @self.server.list_resources()
-        async def handle_list_resources() -> list[types.Resource]:  # type: ignore[reportUnusedFunction]
-            return get_all_resources()
-
-        @self.server.read_resource()
-        async def handle_read_resource(  # type: ignore[reportUnusedFunction]
-            uri: AnyUrl,
-        ) -> str:
-            try:
-                if not self.resolve_client.is_connected():
-                    self.resolve_client.connect()
-                result = await self._read_resource(str(uri))
-                return str(result)
-            except DaVinciResolveError as e:
-                error_msg = f"DaVinci Resolve error: {e}"
-                logger.exception(error_msg)
-                return error_msg
-            except Exception as e:
-                error_msg = f"Unexpected error: {e}"
-                logger.exception(error_msg)
-                return error_msg
-
-    async def _call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
-        """Dispatch a tool call to the resolve client."""
-        if name == "get_version":
-            return self.resolve_client.get_version()
-        elif name == "get_current_page":
-            return self.resolve_client.get_current_page()
-        elif name == "switch_page":
-            return self.resolve_client.switch_page(arguments.get("page", ""))
-        elif name == "list_projects":
-            return self.resolve_client.list_projects()
-        elif name == "get_current_project":
-            return self.resolve_client.get_current_project_name()
-        elif name == "open_project":
-            name_arg = arguments.get("name", "")
-            result = self.resolve_client.open_project(name_arg)
-            return (
-                f"Successfully opened project '{name_arg}'"
-                if result
-                else f"Failed to open project '{name_arg}'"
-            )
-        elif name == "create_project":
-            name_arg = arguments.get("name", "")
-            result = self.resolve_client.create_project(name_arg)
-            return (
-                f"Successfully created project '{name_arg}'"
-                if result
-                else f"Failed to create project '{name_arg}'"
-            )
-        elif name == "list_timelines":
-            return self.resolve_client.list_timelines()
-        elif name == "get_current_timeline":
-            return self.resolve_client.get_current_timeline_name()
-        elif name == "create_timeline":
-            name_arg = arguments.get("name", "")
-            result = self.resolve_client.create_timeline(name_arg)
-            return (
-                f"Successfully created timeline '{name_arg}'"
-                if result
-                else f"Failed to create timeline '{name_arg}'"
-            )
-        elif name == "switch_timeline":
-            name_arg = arguments.get("name", "")
-            result = self.resolve_client.switch_timeline(name_arg)
-            return (
-                f"Successfully switched to timeline '{name_arg}'"
-                if result
-                else f"Failed to switch to timeline '{name_arg}'"
-            )
-        elif name == "list_media_clips":
-            return self.resolve_client.list_media_clips()
-        elif name == "import_media":
-            file_path = arguments.get("file_path", "")
-            result = self.resolve_client.import_media(file_path)
-            return (
-                f"Successfully imported media '{file_path}'"
-                if result
-                else f"Failed to import media '{file_path}'"
-            )
-        else:
-            raise ValueError(f"Unknown tool: {name}")
-
-    async def _read_resource(self, uri: str) -> Any:
-        """Dispatch a resource read to the resolve client."""
-        if uri == "resolve://version":
-            return self.resolve_client.get_version()
-        elif uri == "resolve://current-page":
-            return self.resolve_client.get_current_page()
-        elif uri == "resolve://projects":
-            return self.resolve_client.list_projects()
-        elif uri == "resolve://current-project":
-            name = self.resolve_client.get_current_project_name()
-            return name if name else "No project open"
-        elif uri == "resolve://timelines":
-            return self.resolve_client.list_timelines()
-        elif uri == "resolve://current-timeline":
-            name = self.resolve_client.get_current_timeline_name()
-            return name if name else "No timeline active"
-        elif uri == "resolve://media-clips":
-            return self.resolve_client.list_media_clips()
-        else:
-            raise ValueError(f"Unknown resource: {uri}")
-
-    async def run(self) -> None:
-        """Run the MCP server."""
-        logger.info("Starting DaVinci Resolve MCP Server...")
-
-        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-            await self.server.run(
-                read_stream,
-                write_stream,
-                InitializationOptions(
-                    server_name="davinci-mcp-professional",
-                    server_version=__version__,
-                    capabilities=self.server.get_capabilities(
-                        notification_options=NotificationOptions(),
-                        experimental_capabilities={},
-                    ),
-                ),
-            )