davinci-resolve-mcp 2.34.0 → 2.34.1

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 Release history for the DaVinci Resolve MCP Server. The latest release is summarized in the root README; older entries live here to keep the README focused.
 
+## What's New in v2.34.1
+
+Page-switch serialization — the concurrency primitive for safe multi-agent use.
+
+- **Added** `src/utils/page_lock.py` — Resolve has a single globally-active page,
+  so two agents that flip pages concurrently corrupt each other. `page_lock()`
+  serializes page switches: a reentrant intra-process lock plus a best-effort
+  inter-process advisory file lock around the outermost section. The `open_page`
+  action now routes through it. This must be in place before any concurrent-agent
+  feature ships.
+- Networked transport, sandboxed scripting, and capability/role scoping (the rest
+  of the safe remote/multi-user design) are security-critical and remain a
+  separate, sign-off-gated phase — they are intentionally not shipped here.
+
 ## What's New in v2.34.0
 
 First phase of transcript-driven editing: a Cut intermediate representation and a

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.34.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.34.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-32%20(341%20full)-blue.svg)](#server-modes)

package/install.py

@@ -35,7 +35,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.34.0"
+VERSION = "2.34.1"
 # Only hard floor: mcp[cli] requires Python 3.10+. There is no upper bound —
 # Resolve's scripting bridge loads into newer interpreters on recent builds
 # (Python 3.14 verified against Resolve Studio 20.3.2). Older Resolve builds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.34.0",
+  "version": "2.34.1",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/src/granular/common.py

@@ -80,7 +80,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.34.0"
+VERSION = "2.34.1"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.34.0"
+VERSION = "2.34.1"
 
 import base64
 import os
@@ -46,6 +46,7 @@ from src.utils.mcp_stdio import run_fastmcp_stdio
 from src.utils.api_truth import lookup_api_truth, VERIFIED_ON as _API_TRUTH_VERIFIED_ON
 from src.utils.contracts import validate as _validate_params
 from src.utils.cut_ir import build_cut_list as _build_cut_list
+from src.utils.page_lock import open_page_serialized as _open_page_serialized
 from src.utils.proc import safe_run
 from src.utils.readback import verify_by_readback
 from src.utils.update_check import (
@@ -10672,7 +10673,9 @@ def resolve_control(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
         valid_pages = ["media", "cut", "edit", "color", "fusion", "fairlight", "deliver"]
         if p["page"] not in valid_pages:
             return _err(f"Invalid page '{p['page']}'. Valid pages: {', '.join(valid_pages)}")
-        return {"success": bool(r.OpenPage(p["page"]))}
+        # Serialize page switches so concurrent agents can't flip the single
+        # globally-active page underneath each other.
+        return {"success": bool(_open_page_serialized(r, p["page"]))}
     elif action == "get_keyframe_mode":
         return {"mode": r.GetKeyframeMode()}
     elif action == "set_keyframe_mode":

package/src/utils/page_lock.py

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