davinci-resolve-mcp 2.62.1 → 2.62.3

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 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.62.3
+
+A single grading fix (PR #90, by @Mldphotohraphie), extended and hardened. No
+new tool surface.
+
+### Fixed
+
+- **`graph set_lut` now applies LUTs/DCTLs installed by the `dctl` tool** —
+  the `dctl` tool installs into Resolve's per-user LUT directory, but
+  `Graph.SetLUT()` resolves LUT paths (relative names *and* absolute paths)
+  only against the master (system) LUT directory. A freshly installed LUT could
+  therefore never be applied, and `set_lut` always returned
+  `{"success": false}`. Verified live on Resolve Studio 21: `SetLUT` fails for a
+  user-dir LUT even after `RefreshLUTList()` and even via an absolute user-dir
+  path, so relocation into the master dir is genuinely required. On a `SetLUT`
+  failure the server now locates the LUT, stages it under a namespaced
+  `MCP/` subfolder of the master LUT dir (avoiding basename collisions with
+  stock/vendor LUTs), calls `RefreshLUTList()`, and retries. No behavior change
+  when `SetLUT` already succeeds. Applied to both `graph set_lut` (`src/server.py`)
+  and the granular `graph_set_lut` (`src/granular/graph.py`) via a shared
+  `src/utils/lut_paths.py` helper, with offline coverage in
+  `tests/test_lut_paths.py`.
+
+## What's New in v2.62.2
+
+A single cross-platform launcher fix. No new tool surface; default behavior is
+unchanged on macOS/Linux.
+
+### Fixed
+
+- **Advanced server launcher no longer crashes on Windows** —
+  `bin/davinci-resolve-advanced-mcp.mjs` resolved the server entry to an
+  absolute filesystem path and passed it straight to dynamic `import()`. On
+  Windows that path (e.g. `C:\...\resolve-advanced\server\index.mjs`) is parsed
+  by Node's ESM loader as a URL whose drive letter reads as the protocol, so the
+  launcher died on arrival with
+  `ERR_UNSUPPORTED_ESM_URL_SCHEME` ("Received protocol 'c:'"). The path is now
+  converted with `pathToFileURL()` before importing — the canonical
+  cross-platform way to hand an absolute path to `import()`. macOS/Linux behavior
+  is unchanged, and paths containing spaces or special characters are now handled
+  correctly on every platform. Thanks to Ryan Saunders (@Alpha7449) for the
+  report and fix.
+
+### Validation
+
+- Static checks and `node --check` on the modified launcher run. This is the only
+  dynamic `import()` call site in the repo receiving an absolute filesystem path;
+  the fix touches the Node advanced launcher only and changes no Resolve
+  scripting behavior, so a live Resolve run is not required.
+
 ## What's New in v2.62.1
 
 Two correctness fixes for real-world project/DRP layouts. No new tool surface;

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.62.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.62.3-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-34%20(341%20full)-blue.svg)](#server-modes)

package/bin/davinci-resolve-advanced-mcp.mjs

@@ -10,11 +10,11 @@
  * the repo root for the published package.)
  */
 
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import path from 'node:path';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const serverEntry = path.resolve(__dirname, '..', 'resolve-advanced', 'server', 'index.mjs');
 
-const { startServer } = await import(serverEntry);
+const { startServer } = await import(pathToFileURL(serverEntry).href);
 await startServer();

package/install.py

@@ -35,7 +35,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.62.1"
+VERSION = "2.62.3"
 # 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.62.1",
+  "version": "2.62.3",
   "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.62.1"
+VERSION = "2.62.3"
 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/granular/graph.py

@@ -1,6 +1,7 @@
 """Color page graph, LUT, and color-group tools."""
 
 from src.granular.common import *  # noqa: F401,F403
+from src.utils.lut_paths import ensure_lut_in_master
 
 resolve = ResolveProxy()
 
@@ -39,8 +40,25 @@ def graph_set_lut(node_index: int, lut_path: str, item_index: int = 0, track_typ
     graph = item.GetNodeGraph()
     if not graph:
         return {"error": "No node graph available"}
-    result = graph.SetLUT(node_index, lut_path)
-    return {"success": bool(result)}
+    ok = bool(graph.SetLUT(node_index, lut_path))
+    if not ok:
+        # SetLUT resolves LUTs only against the master LUT dir, not the per-user
+        # dir dctl installs to. Relocate into the master dir and retry.
+        relocated = ensure_lut_in_master(lut_path)
+        if relocated:
+            try:
+                project = resolve.GetProjectManager().GetCurrentProject()
+                if project:
+                    project.RefreshLUTList()
+            except Exception:
+                pass
+            ok = bool(graph.SetLUT(node_index, relocated))
+            if ok:
+                return {"success": True, "resolved_lut": relocated,
+                        "note": "LUT staged under the master LUT dir "
+                                "(MCP/ subfolder) and applied; SetLUT does "
+                                "not resolve the user LUT dir."}
+    return {"success": ok}
 
 
 @mcp.tool()

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.62.1"
+VERSION = "2.62.3"
 
 import base64
 import os
@@ -97,6 +97,7 @@ from src.utils.media_analysis_jobs import (
     run_batch_job_slice as run_media_analysis_batch_job_slice,
 )
 from src.utils.platform import get_resolve_paths, get_resolve_plugin_paths
+from src.utils.lut_paths import master_lut_dir, ensure_lut_in_master
 from src.utils import fuse_templates, dctl_templates, script_templates
 from src.utils.timeline_title_text import (
     candidate_title_property_keys as _candidate_title_property_keys,
@@ -22070,7 +22071,27 @@ def graph(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any
     elif action == "get_lut":
         return {"lut": g.GetLUT(p["node_index"])}
     elif action == "set_lut":
-        return {"success": bool(g.SetLUT(p["node_index"], p["lut_path"]))}
+        node_index = p["node_index"]
+        lut_path = p["lut_path"]
+        ok = bool(g.SetLUT(node_index, lut_path))
+        if not ok:
+            # Resolve resolves LUTs for SetLUT only against the master LUT dir,
+            # not the per-user dir that dctl install writes to. Relocate and retry.
+            relocated = _ensure_lut_in_master(lut_path)
+            if relocated:
+                try:
+                    _, proj, _lut_err = _check()
+                    if proj:
+                        proj.RefreshLUTList()
+                except Exception:
+                    pass
+                ok = bool(g.SetLUT(node_index, relocated))
+                if ok:
+                    return {"success": True, "resolved_lut": relocated,
+                            "note": "LUT staged under the master LUT dir "
+                                    "(MCP/ subfolder) and applied; SetLUT does "
+                                    "not resolve the user LUT dir."}
+        return {"success": ok}
     elif action == "get_node_cache":
         return {"cache": g.GetNodeCacheMode(p["node_index"])}
     elif action == "set_node_cache":
@@ -23771,6 +23792,13 @@ def _dctl_dir(category: str = "lut") -> str:
                      "Valid: lut, aces_idt, aces_odt")
 
 
+# LUT relocation for Graph.SetLUT lives in src.utils.lut_paths so server.py and
+# src/granular/graph.py share one implementation (see the module docstring for
+# the live-verified behavior). Thin aliases keep the existing call sites stable.
+_master_lut_dir = master_lut_dir
+_ensure_lut_in_master = ensure_lut_in_master
+
+
 def _validate_dctl_name(name: str) -> Optional[Dict[str, Any]]:
     if not name or not _DCTL_NAME_RE.match(name):
         return _err(f"Invalid DCTL name '{name}'. "

package/src/utils/lut_paths.py

@@ -0,0 +1,80 @@
+"""Master LUT directory resolution for Graph.SetLUT().
+
+Resolve's Graph.SetLUT() resolves relative LUT names -- and even absolute
+paths -- ONLY against the master (system) LUT root, NOT the per-user LUT dir
+that the dctl tool installs into. Verified live on Resolve Studio 21: SetLUT
+succeeds for a LUT in the master dir (by relative or subfolder path) and
+returns False for the same file in the user dir, even after RefreshLUTList and
+even via an absolute user-dir path. These helpers relocate a user-dir LUT into
+a namespaced subfolder of the master dir so SetLUT can resolve it.
+"""
+
+import os
+import platform
+import shutil
+from typing import List, Optional
+
+from src.utils.platform import get_resolve_plugin_paths
+
+# Subfolder under the master LUT root where relocated LUTs are staged. SetLUT
+# resolves relative paths against the master root, so a subfolder path like
+# "MCP/Foo.cube" works AND avoids clobbering stock/vendor LUTs that share a
+# basename (e.g. InstantC.cube). Verified live on Resolve Studio 21.
+MASTER_LUT_RELOCATE_SUBDIR = "MCP"
+
+
+def master_lut_dir() -> str:
+    """Return Resolve's master (system) LUT directory for this platform."""
+    plat = platform.system().lower()
+    if plat == "windows":
+        programdata = os.environ.get("PROGRAMDATA", r"C:\ProgramData")
+        return os.path.join(programdata, "Blackmagic Design",
+                            "DaVinci Resolve", "Support", "LUT")
+    if plat == "linux":
+        for cand in ("/opt/resolve/LUT", "/home/resolve/LUT"):
+            if os.path.isdir(cand):
+                return cand
+        return "/opt/resolve/LUT"
+    # darwin / default
+    return "/Library/Application Support/Blackmagic Design/DaVinci Resolve/LUT"
+
+
+def _user_lut_dir() -> Optional[str]:
+    """Return the per-user LUT dir (where dctl install writes), or None."""
+    try:
+        return get_resolve_plugin_paths()["dctl_dir"]
+    except Exception:
+        return None
+
+
+def ensure_lut_in_master(lut_path: str) -> Optional[str]:
+    """Make a LUT resolvable by Graph.SetLUT().
+
+    Locates the file named by lut_path (absolute, user LUT dir, or already in
+    the master dir), copies it into a namespaced subfolder of the master LUT
+    dir when needed, and returns the master-relative path (forward slashes, as
+    GetLUT reports) to hand back to SetLUT. Returns None if the source cannot
+    be found or the master dir is not writable.
+    """
+    master = master_lut_dir()
+    base = os.path.basename(lut_path)
+    candidates: List[str] = []
+    if os.path.isabs(lut_path):
+        candidates.append(lut_path)
+    else:
+        user_dir = _user_lut_dir()
+        if user_dir:
+            candidates.append(os.path.join(user_dir, lut_path))
+        candidates.append(os.path.join(master, lut_path))
+    src = next((c for c in candidates if os.path.isfile(c)), None)
+    if not src:
+        return None
+    dst_dir = os.path.join(master, MASTER_LUT_RELOCATE_SUBDIR)
+    dst = os.path.join(dst_dir, base)
+    if os.path.abspath(src) != os.path.abspath(dst):
+        try:
+            os.makedirs(dst_dir, exist_ok=True)
+            shutil.copy2(src, dst)
+        except Exception:
+            return None
+    return f"{MASTER_LUT_RELOCATE_SUBDIR}/{base}"