davinci-resolve-mcp 2.69.1 → 2.69.3

package/CHANGELOG.md

@@ -2,6 +2,118 @@
 
 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.69.3
+
+Ships the v2.69.2 bundle, which never reached npm. Same fixes, plus the one that
+stopped it publishing.
+
+### Fixed
+
+- **The offline guard failed the publish workflow instead of guarding it.**
+  `tests/__init__.py` installs the guard before any test module loads, and the
+  guard imports `src.server` — which imports `anyio`. The publish workflow
+  installs only pyflakes, by design: the static drift guards are pure AST
+  readers that deliberately run without the runtime stack. So every module
+  argument raised at import, six of them turned into six `_FailedTest` errors,
+  and the npm publish failed with what looked like six broken guards rather than
+  one missing package.
+
+  This shipped in v2.69.1's tail (the guard moved under `unittest` after that
+  tag was cut), so v2.69.2 was the first release to run it and the first to fail.
+
+  A missing third-party package now skips the swap: if `src.server` cannot be
+  imported there is no live-Resolve entry point to neuter, so the guard is
+  vacuously satisfied. The skip is narrow on purpose — a `ModuleNotFoundError`
+  naming something under `src/`, or any non-import error, still propagates.
+  Swallowing those would leave the static guards silently vacuous, which is a
+  worse failure than the one being fixed since it fails open.
+
+### Added
+
+- `tests/test_offline_guard.py` — five tests, including the two that matter:
+  a broken import inside `src/` must still raise, and a non-import error must
+  never be swallowed. A skip that fails open would be indistinguishable from a
+  passing suite.
+
+### Validation
+
+- Offline suite 2247 → 2252. Reproduced the CI failure locally against an
+  interpreter without `anyio` (six errors before, clean after), rather than
+  inferring it from the workflow log.
+
+## What's New in v2.69.2
+
+Community bug-fix bundle: #100, #101 and #102, plus the installer half of #104.
+The headline is that a fresh clone had stopped working entirely.
+
+### Fixed
+
+- **A fresh install produced a server that could not start** (issue #103, PR
+  #101 by @Mastaish). `install.py` installed `mcp[cli]` with no upper bound, and
+  the MCP Python SDK published 2.0.0 — which restructured the package and
+  dropped `mcp.server.fastmcp`, the module `src/server.py` imports. Every clone
+  after that release died at import, surfacing to the user as nothing more
+  informative than "Server disconnected".
+
+  The contributed fix caps the SDK in `requirements.txt`, which `install.py`
+  installs second. That works, but the unpinned first call still downloads 2.x
+  and its `httpx2` tree before downgrading it, and the fix evaporates silently
+  if the install order ever changes — so the cap is now on the `pip install`
+  call as well. `McpSdkPinTest` guards both sites, reading the actual string
+  literals rather than matching text: `install.py` discusses `mcp[cli]` in prose
+  too, and a first cut of that guard was satisfied by a comment. It is
+  conditional on `server.py` still importing `mcp.server.fastmcp`, so it retires
+  itself when the server is ported to the 2.x layout instead of blocking it.
+
+- **The Advanced (Node) suite was not running at all on Node 20+** (PR #102 by
+  @double2tea). `node --test` resolves a bare directory argument as a module
+  entry point on Node 20 and later, so the suite exited with `MODULE_NOT_FOUND`
+  at 4 failures and 0 passes — a shape that reads more like a broken checkout
+  than 731 skipped tests. Explicit test-file globs restore the full run on 18,
+  20 and 22 alike.
+
+- **`RESOLVE_SCRIPT_API` / `RESOLVE_SCRIPT_LIB` were silently overwritten** (PR
+  #100 by @abbc400). `get_resolve_paths()` returned only platform defaults, and
+  `src/server.py` writes those straight back into `os.environ` — so a client
+  that had correctly pointed at a Resolve installed outside `/Applications` had
+  its setting discarded at import. Every other signal looked healthy (Resolve
+  running, external scripting Local, `fuscript` listening) while `scriptapp()`
+  returned `None`. The override now wins, but only when the path exists, so a
+  stale variable cannot shadow a working default install.
+
+- **The bridge installer wrote to a tree Resolve did not read** (issue #104,
+  reported by @RananjayRaj). Which script tree the free App Store build scans is
+  not decidable from outside Resolve: this installer was measured on a machine
+  where the documented Blackmagic Design tree listed, and #104 reports the exact
+  opposite on the same 21.0.3.7 build — the documented tree listed nothing, not
+  even the Lua canary (which rules out the framework-Python explanation and
+  points at the folder), while the Fusion standalone tree listed everything with
+  no restart.
+
+  Rather than pick a winner from two contradictory measurements, both container
+  trees now receive the files, documented path first. This stays inside the
+  sandbox: outside a container that path really is Fusion's own tree and is
+  still not targeted.
+
+- **`--probe-only` reported success on a machine with no Resolve installed**
+  (also #104). A container outlives the app that created it, and the container's
+  existence is precisely what makes the installer target it — so a stale
+  container from an uninstalled Resolve produced a clean success listing files
+  that had genuinely been written and would never be read. The installer now
+  warns when no app bundle can be found, honoring `RESOLVE_APP` as
+  `scripts/doctor.py` already does. It warns rather than refuses: not every
+  legitimate install location can be enumerated, and refusing wrongly would
+  block a working install.
+
+### Validation
+
+- Offline suite 2237 → 2247 (six new installer-target tests, one pin guard).
+  Advanced Node suite 731 tests / 701 pass on Node 18.
+- The new guards were verified to fail against the pre-fix code, not merely to
+  pass against the fix.
+- No DaVinci Resolve scripting behavior changed; the path-resolution change is
+  env-var-gated with defaults unchanged. Live Resolve validation not required.
+
 ## What's New in v2.69.1
 
 Bug fix. The Studio bridge differential no longer reports the Deliver page its

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.69.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.69.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/install.py

@@ -36,7 +36,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.69.1"
+VERSION = "2.69.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
@@ -796,9 +796,14 @@ def install_dependencies(venv_path, project_dir):
 
     print(f"  Installing dependencies...")
 
-    # Install MCP SDK
+    # Install MCP SDK. The upper bound is load-bearing: SDK 2.0.0 restructured
+    # the package and dropped `mcp.server.fastmcp`, which src/server.py imports.
+    # requirements.txt carries the same constraint, but it is installed second —
+    # pinning here too means we never download 2.x (and its httpx2 tree) only to
+    # downgrade it, and the fix does not depend on install ordering. Lift both
+    # together when server.py is ported to the 2.x layout.
     subprocess.run(
-        [str(pip), "install", "-q", "mcp[cli]"],
+        [str(pip), "install", "-q", "mcp[cli]>=1.29,<2"],
         check=True, capture_output=True
     )
 

package/package.json

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

package/resolve-advanced/package.json

@@ -38,9 +38,9 @@
     "_comment": "audio (split/trim/convert) + conform frame ops need system ffmpeg/ffprobe on PATH (NOT bundled — FFmpeg binaries are GPL; this package stays MIT). Install ffmpeg yourself: brew install ffmpeg."
   },
   "scripts": {
-    "test": "node --test vendor/drp-format/__tests__/ vendor/drt-format/__tests__/ vendor/drx-codec/__tests__/ test/",
-    "test:libs": "node --test vendor/drp-format/__tests__/ vendor/drt-format/__tests__/ vendor/drx-codec/__tests__/",
-    "test:server": "node --test test/"
+    "test": "node --test vendor/drp-format/__tests__/*.test.js vendor/drt-format/__tests__/*.test.js vendor/drx-codec/__tests__/*.test.js test/*.test.mjs",
+    "test:libs": "node --test vendor/drp-format/__tests__/*.test.js vendor/drt-format/__tests__/*.test.js vendor/drx-codec/__tests__/*.test.js",
+    "test:server": "node --test test/*.test.mjs"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/install_resolve_bridge.py

@@ -53,11 +53,26 @@ _SCRIPTS_SUFFIX = "Library/Application Support/Blackmagic Design/DaVinci Resolve
 #: `<container>/Data/Library/Application Support/Fusion/Scripts/Utility` appeared
 #: under Workspace ▸ Scripts, as did one in
 #: `<container>/Data/Documents/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/Utility`.
-#: So Lite scans more locations than the README documents. That changes nothing
-#: about *where to install* — the documented paths work, and each extra target is
-#: another chance for the App Management prompt to stall the copy — but the reason
-#: to prefer them is that they are documented, not that the others are dead.
+#: So Lite scans more locations than the README documents.
+#:
+#: **Second correction (issue #104), same version, opposite result:** on another
+#: free 21.0.3.7 App Store install the documented tree listed *nothing* — not
+#: even the Lua canary, which rules out the Python-detection explanation and
+#: points at the folder — while the Fusion standalone tree listed all four files
+#: with no restart. Two machines, same build, contradictory results.
+#:
+#: We cannot tell them apart from outside Resolve, so we stop trying to pick a
+#: winner and install to BOTH container trees. The documented path stays first
+#: (it is the one Blackmagic commits to), the standalone tree is the fallback
+#: that demonstrably works where the documented one silently does not. The cost
+#: is one extra App Management prompt; the cost of guessing wrong is a bridge
+#: that never appears and gives the user nothing to diagnose.
 _SANDBOX_MARKER = "com.blackmagic-design."
+
+#: Scanned by Lite in addition to `_SCRIPTS_SUFFIX`, inside the container only.
+#: NOT used outside a sandbox: on a normal install this is genuinely Fusion's
+#: own tree and has nothing to do with Resolve.
+_SANDBOX_FALLBACK_SUFFIX = "Library/Application Support/Fusion/Scripts/Utility"
 #: Containers that are not Resolve (RAW Player, Speed Test, the IO XPC helper).
 _NON_RESOLVE_CONTAINERS = ("BlackmagicRaw", "IOXPC")
 
@@ -73,7 +88,9 @@ def script_targets() -> list[Path]:
 
     Sandboxed containers are included because the App Store build cannot see the
     normal per-user path — that isolation is exactly what lets the free edition
-    coexist with a direct-download Studio install.
+    coexist with a direct-download Studio install. Each container contributes
+    TWO targets (see the module comment on issue #104): the documented tree
+    first, then the Fusion standalone tree that Lite also scans.
     """
     home = Path.home()
     candidates = [
@@ -87,6 +104,7 @@ def script_targets() -> list[Path]:
         for entry in sorted(containers.iterdir()):
             if _is_resolve_container(entry) and (entry / "Data").is_dir():
                 sandboxed.append(entry / "Data" / _SCRIPTS_SUFFIX)
+                sandboxed.append(entry / "Data" / _SANDBOX_FALLBACK_SUFFIX)
 
     usable: list[Path] = []
     for path in candidates:
@@ -98,6 +116,51 @@ def script_targets() -> list[Path]:
     return list(dict.fromkeys(usable))
 
 
+#: Where a Resolve app bundle actually lives. The App Store build installs flat
+#: into /Applications; the direct download uses its own folder. RESOLVE_APP
+#: overrides both, matching scripts/doctor.py.
+_APP_BUNDLE_CANDIDATES = (
+    "/Applications/DaVinci Resolve/DaVinci Resolve.app",
+    "/Applications/DaVinci Resolve.app",
+    "/Applications/DaVinci Resolve Studio.app",
+)
+
+
+def installed_app_bundles() -> list[str]:
+    """Resolve app bundles present on this machine."""
+    override = os.environ.get("RESOLVE_APP")
+    candidates = (override,) + _APP_BUNDLE_CANDIDATES if override else _APP_BUNDLE_CANDIDATES
+    return [path for path in candidates if path and Path(path).is_dir()]
+
+
+def stale_container_warning(targets: list[Path]) -> str | None:
+    """Are we about to install into a container left by an *uninstalled* Resolve?
+
+    A container outlives the app that created it — uninstalling Resolve leaves
+    the whole `~/Library/Containers/com.blackmagic-design.*` tree behind. Since
+    a container's existence is what makes us target it, the installer would
+    otherwise report a clean success on a machine with no Resolve at all, and
+    the user would go hunting through the Scripts menu of an app they do not
+    have (issue #104). Warn rather than refuse: we cannot enumerate every place
+    an app bundle might legitimately live, and being wrong in the refusing
+    direction blocks a working install.
+    """
+    if not any("Containers" in str(target) for target in targets):
+        return None
+    if installed_app_bundles():
+        return None
+    return (
+        "Installed into a sandbox container, but no DaVinci Resolve app bundle "
+        "was found on this machine. A container OUTLIVES the app that created "
+        "it, so this is what an uninstalled Resolve looks like — the files were "
+        "written, but nothing will ever read them. Checked: "
+        + ", ".join(_APP_BUNDLE_CANDIDATES)
+        + ". If Resolve is installed somewhere else, re-run with RESOLVE_APP "
+        "set to its .app bundle to silence this. If it is not installed, "
+        "install it first, then re-run."
+    )
+
+
 #: Resolve enumerates `.py` scripts in Workspace > Scripts only when it finds a
 #: **framework** Python. Homebrew/pyenv/conda interpreters are not detected, and
 #: the failure is completely silent: the script sits in the right folder with the
@@ -233,6 +296,8 @@ def install(*, probe_only: bool, port: int, rotate: bool) -> dict:
             launcher_path.write_text(launcher, encoding="utf-8")
             installed.append(str(launcher_path))
     result = {"installed": installed, "probe_only": probe_only, "python": python_preflight()}
+    stale = stale_container_warning(targets)
+    result["warnings"] = [stale] if stale else []
     if not probe_only:
         loaded = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
         result["config"] = {"path": str(CONFIG_PATH),
@@ -258,6 +323,11 @@ def main() -> int:
         print("WARNING: " + result["python"]["advice"])
         print("!" * 72)
         print()
+    for warning in result["warnings"]:
+        print("!" * 72)
+        print("WARNING: " + warning)
+        print("!" * 72)
+        print()
     print("Next:")
     print("  1. Restart DaVinci Resolve so it re-scans the Scripts folders.")
     print("  2. Open a saved project (the Scripts menu is empty in Project Manager).")

package/src/granular/common.py

@@ -85,7 +85,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.69.1"
+VERSION = "2.69.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/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.69.1"
+VERSION = "2.69.3"
 
 import base64
 import os

package/src/utils/platform.py

@@ -55,6 +55,16 @@ def get_resolve_paths():
         lib_path = "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so"
         modules_path = os.path.join(api_path, "Modules")
     
+    # An explicit install location wins over the platform default: Resolve is
+    # not always under /Applications (external volume, custom install dir).
+    env_api = os.environ.get("RESOLVE_SCRIPT_API")
+    if env_api and os.path.isdir(env_api):
+        api_path = env_api
+        modules_path = os.path.join(api_path, "Modules")
+    env_lib = os.environ.get("RESOLVE_SCRIPT_LIB")
+    if env_lib and os.path.isfile(env_lib):
+        lib_path = env_lib
+
     return {
         "api_path": api_path,
         "lib_path": lib_path,