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

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

@@ -1,75 +0,0 @@
-"""Serialize DaVinci Resolve page switches across threads and processes.
-
-Resolve has a single globally-active page (Edit / Color / Fusion / Fairlight /
-Deliver / Cut). An operation that switches the page, does work there, and reads a
-result is only correct if no other operation flips the page underneath it. With a
-single stdio client that never happens, but the moment two agents (threads, or
-separate server processes) drive one Resolve, concurrent page switches corrupt
-each other. This primitive serializes the critical section, so it must be in
-place before any concurrent-agent feature ships.
-
-- Intra-process: a reentrant lock (nested page_lock() calls are safe).
-- Inter-process: a best-effort advisory file lock around the OUTERMOST section
-  (fcntl). On platforms without fcntl (Windows) the inter-process guard is a
-  no-op and only the intra-process lock applies.
-
-Usage:
-
-    with page_lock():
-        resolve.OpenPage("color")
-        ... do color-page work, read results ...
-"""
-import os
-import tempfile
-import threading
-from contextlib import contextmanager
-
-try:
-    import fcntl  # type: ignore
-    _HAS_FCNTL = True
-except ImportError:  # pragma: no cover - Windows
-    _HAS_FCNTL = False
-
-_INTRA = threading.RLock()
-_LOCKFILE = os.path.join(tempfile.gettempdir(), "davinci_resolve_mcp_page.lock")
-
-# Nesting depth and the held file handle, both guarded by _INTRA. The file lock
-# is taken only at the outermost level — a second fcntl.flock() on a new fd from
-# the same process would block on the first, deadlocking nested page_lock()s.
-_depth = 0
-_fh = None
-
-
-@contextmanager
-def page_lock():
-    """Hold the page-switch lock for the duration of the block (reentrant)."""
-    global _depth, _fh
-    _INTRA.acquire()
-    _depth += 1
-    try:
-        if _depth == 1 and _HAS_FCNTL:
-            try:
-                _fh = open(_LOCKFILE, "w")
-                fcntl.flock(_fh, fcntl.LOCK_EX)
-            except OSError:
-                # Advisory lock is best-effort; never block real work on it.
-                if _fh is not None:
-                    _fh.close()
-                _fh = None
-        yield
-    finally:
-        _depth -= 1
-        if _depth == 0 and _fh is not None:
-            try:
-                fcntl.flock(_fh, fcntl.LOCK_UN)
-            except OSError:
-                pass
-            _fh.close()
-            _fh = None
-        _INTRA.release()
-
-
-def open_page_serialized(resolve, page):
-    """Switch Resolve to `page` under the page lock. Returns OpenPage's result."""
-    with page_lock():
-        return resolve.OpenPage(page)

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

@@ -1,157 +0,0 @@
-#!/usr/bin/env python3
-"""
-Platform-specific functionality for DaVinci Resolve MCP Server
-"""
-
-import os
-import sys
-import platform
-
-def get_platform():
-    """Identify the current operating system platform.
-    
-    Returns:
-        str: 'windows', 'darwin' (macOS), or 'linux'
-    """
-    system = platform.system().lower()
-    if system == 'darwin':
-        return 'darwin'
-    elif system == 'windows':
-        return 'windows'
-    elif system == 'linux':
-        return 'linux'
-    return system
-
-def get_resolve_paths():
-    """Get platform-specific paths for DaVinci Resolve scripting API.
-    
-    Returns:
-        dict: Dictionary containing api_path, lib_path, and modules_path
-    """
-    platform_name = get_platform()
-    
-    if platform_name == 'darwin':  # macOS
-        api_path = "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting"
-        lib_path = "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so"
-        modules_path = os.path.join(api_path, "Modules")
-    
-    elif platform_name == 'windows':  # Windows
-        program_files = os.environ.get('PROGRAMDATA', 'C:\\ProgramData')
-        program_files_64 = os.environ.get('PROGRAMFILES', 'C:\\Program Files')
-        
-        api_path = os.path.join(program_files, 'Blackmagic Design', 'DaVinci Resolve', 'Support', 'Developer', 'Scripting')
-        lib_path = os.path.join(program_files_64, 'Blackmagic Design', 'DaVinci Resolve', 'fusionscript.dll')
-        modules_path = os.path.join(api_path, "Modules")
-    
-    elif platform_name == 'linux':  # Linux (not fully implemented)
-        # Default locations for Linux - these may need to be adjusted
-        api_path = "/opt/resolve/Developer/Scripting"
-        lib_path = "/opt/resolve/libs/fusionscript.so"
-        modules_path = os.path.join(api_path, "Modules")
-    
-    else:
-        # Fallback to macOS paths if unknown platform
-        api_path = "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting"
-        lib_path = "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so"
-        modules_path = os.path.join(api_path, "Modules")
-    
-    return {
-        "api_path": api_path,
-        "lib_path": lib_path,
-        "modules_path": modules_path
-    }
-
-def get_resolve_plugin_paths():
-    """Get platform-specific paths for Resolve plugin install dirs.
-
-    Returns:
-        dict: {
-            'fuses_dir':  Fusion Fuses directory,
-            'dctl_dir':   LUT directory (where regular .dctl files live),
-            'aces_idt_dir': ACES IDT transforms (separate scan path; restart
-                            required after install),
-            'aces_odt_dir': ACES ODT transforms (same caveat),
-        }
-    """
-    platform_name = get_platform()
-    home = os.path.expanduser("~")
-
-    # NOTE: The Fuse SDK doc (June 2023) lists Fuses under "Support/Fusion/Fuses"
-    # on macOS, but the directory Resolve actually scans is the sibling
-    # "Fusion/Fuses" (without "Support") — verified live against Resolve Studio
-    # 20.3.2.9 by writing test fuses to both paths and observing which loaded.
-    # Per-platform conventions also differ from the SDK doc; we follow the
-    # canonical Fusion user-data layout where every Fusion user directory
-    # (Macros, Templates, Scripts, Modules, Fuses, ...) lives directly under
-    # the platform's Fusion user root.
-    if platform_name == 'darwin':
-        support = os.path.join(home, "Library", "Application Support",
-                               "Blackmagic Design", "DaVinci Resolve")
-        fuses_dir = os.path.join(support, "Fusion", "Fuses")
-        dctl_dir = os.path.join(support, "LUT")
-        aces_root = os.path.join(support, "ACES Transforms")
-    elif platform_name == 'windows':
-        appdata = os.environ.get('APPDATA', os.path.join(home, 'AppData', 'Roaming'))
-        fuses_dir = os.path.join(appdata, 'Blackmagic Design', 'DaVinci Resolve',
-                                 'Support', 'Fusion', 'Fuses')
-        dctl_dir = os.path.join(appdata, 'Blackmagic Design', 'DaVinci Resolve',
-                                'Support', 'LUT')
-        aces_root = os.path.join(appdata, 'Blackmagic Design', 'DaVinci Resolve',
-                                 'Support', 'ACES Transforms')
-    elif platform_name == 'linux':
-        base = os.path.join(home, '.local', 'share', 'DaVinciResolve')
-        fuses_dir = os.path.join(base, 'Fusion', 'Fuses')
-        dctl_dir = os.path.join(base, 'LUT')
-        aces_root = os.path.join(base, 'ACES Transforms')
-    else:
-        support = os.path.join(home, "Library", "Application Support",
-                               "Blackmagic Design", "DaVinci Resolve")
-        fuses_dir = os.path.join(support, "Fusion", "Fuses")
-        dctl_dir = os.path.join(support, "LUT")
-        aces_root = os.path.join(support, "ACES Transforms")
-
-    # Resolve scans these subdirs of Fusion/Scripts/ at startup and exposes
-    # them in Workspace → Scripts → <category>. Categories per Resolve docs.
-    if platform_name == 'darwin':
-        scripts_root = os.path.join(support, "Fusion", "Scripts")
-    elif platform_name == 'windows':
-        scripts_root = os.path.join(appdata, 'Blackmagic Design', 'DaVinci Resolve',
-                                    'Support', 'Fusion', 'Scripts')
-    elif platform_name == 'linux':
-        scripts_root = os.path.join(base, 'Fusion', 'Scripts')
-    else:
-        scripts_root = os.path.join(support, "Fusion", "Scripts")
-
-    return {
-        "fuses_dir": fuses_dir,
-        "dctl_dir": dctl_dir,
-        "aces_idt_dir": os.path.join(aces_root, "IDT"),
-        "aces_odt_dir": os.path.join(aces_root, "ODT"),
-        "scripts_root": scripts_root,
-        # Category subdirs Resolve actually scans (verified live):
-        "scripts_categories": ("Edit", "Color", "Deliver", "Comp",
-                               "Tool", "Utility", "Views"),
-    }
-
-
-def setup_environment():
-    """Set up environment variables for DaVinci Resolve scripting.
-    
-    Returns:
-        bool: True if setup was successful, False otherwise
-    """
-    try:
-        paths = get_resolve_paths()
-        
-        os.environ["RESOLVE_SCRIPT_API"] = paths["api_path"]
-        os.environ["RESOLVE_SCRIPT_LIB"] = paths["lib_path"]
-        
-        # Add modules path to Python's path if it's not already there
-        if paths["modules_path"] not in sys.path:
-            sys.path.append(paths["modules_path"])
-        
-        return True
-    
-    except Exception as e:
-        print(f"Error setting up environment: {str(e)}")
-        return False 

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

@@ -1,26 +0,0 @@
-"""Subprocess helpers that are safe to call while the MCP stdio server is live.
-
-The server owns the JSON-RPC stdin/stdout while serving over stdio. A child
-process that inherits stdin can race-read bytes off the protocol stream and
-corrupt it; ``capture_output`` only redirects stdout/stderr. These wrappers
-default ``stdin`` to ``DEVNULL`` so subprocess hygiene is centralized rather
-than re-applied at every call site.
-"""
-import subprocess
-from typing import Any
-
-
-def safe_run(*args: Any, **kwargs: Any) -> "subprocess.CompletedProcess":
-    """subprocess.run with stdin defaulted to DEVNULL (override by passing stdin).
-
-    If ``input`` is given, stdin is left alone — subprocess forbids passing both.
-    """
-    if "input" not in kwargs:
-        kwargs.setdefault("stdin", subprocess.DEVNULL)
-    return subprocess.run(*args, **kwargs)
-
-
-def safe_popen(*args: Any, **kwargs: Any) -> "subprocess.Popen":
-    """subprocess.Popen with stdin defaulted to DEVNULL (override by passing stdin)."""
-    kwargs.setdefault("stdin", subprocess.DEVNULL)
-    return subprocess.Popen(*args, **kwargs)

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

@@ -1,73 +0,0 @@
-"""Best-effort deletion of disposable Resolve projects.
-
-DeleteProject is flaky on some Resolve builds: it silently returns False when
-the target is (or was very recently) the current project, and occasionally on
-the first attempt even when it isn't. Disposable test projects then linger in
-the project library. This helper centralizes the mitigation so every
-disposable-project flow gets it for free:
-
-1. make sure the target is not the current project (load a fallback project,
-   or close the target if no fallback is available),
-2. retry the delete once after a short pause,
-3. report the leftover by name when it still fails, so callers can surface it
-   instead of silently leaking.
-"""
-
-import time
-from typing import Any, Dict, Optional
-
-
-def delete_project_safely(
-    pm: Any,
-    name: str,
-    *,
-    switch_to: Optional[str] = None,
-    retries: int = 1,
-    delay_seconds: float = 1.0,
-) -> Dict[str, Any]:
-    """Delete project `name` via project-manager handle `pm`, working around
-    DeleteProject flakiness. Returns {success, attempts, leftover, detail}.
-
-    `switch_to`: project to load first when `name` is current (e.g. the
-    project that was open before the disposable one was created). Without it,
-    the current project is closed instead.
-    """
-    attempts = 0
-    detail = ""
-    try:
-        current = None
-        try:
-            project = pm.GetCurrentProject()
-            current = project.GetName() if project else None
-        except Exception:
-            current = None
-        if current == name:
-            switched = False
-            if switch_to and switch_to != name:
-                try:
-                    switched = bool(pm.LoadProject(switch_to))
-                except Exception:
-                    switched = False
-            if not switched:
-                try:
-                    project = pm.GetCurrentProject()
-                    if project is not None:
-                        pm.CloseProject(project)
-                except Exception:
-                    pass
-
-        last_error = None
-        for attempt in range(1 + max(0, int(retries))):
-            attempts = attempt + 1
-            try:
-                if bool(pm.DeleteProject(name)):
-                    return {"success": True, "attempts": attempts, "leftover": None, "detail": ""}
-                last_error = "DeleteProject returned False"
-            except Exception as exc:
-                last_error = str(exc)
-            if attempt < retries:
-                time.sleep(max(0.0, delay_seconds))
-        detail = last_error or "DeleteProject failed"
-    except Exception as exc:
-        detail = str(exc)
-    return {"success": False, "attempts": attempts, "leftover": name, "detail": detail}