davinci-resolve-mcp 2.103.1 → 2.103.2

package/CHANGELOG.md

@@ -2,6 +2,63 @@
 
 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.103.2
+
+**A Windows setup that failed with nothing to read.** Reported in issue #158 by
+@KMiNT21 on a machine carrying both Python 3.12 and 3.13: `npx davinci-resolve-mcp`
+exited without a traceback, a log line, or an error. Three defects compounded.
+
+The first is the one that mattered. The npm launcher tested for the Windows `py`
+launcher with `py --version`, and that result gated the entire `py -3.12 / -3.11 /
+-3.10` candidate list. `py` does not accept `--version` on every build — it exits
+101 on the ones it does not — so on those machines the probe reported no launcher,
+every version-pinned candidate was discarded, and selection fell through to bare
+`python`: the 3.13 that the candidate ordering exists specifically to avoid. The
+3.13 protections added in v2.26.1 were not wrong; they were being skipped past.
+
+The fix removes the probe rather than correcting its flag. `checkPython()` already
+validates each candidate by running it, so a machine without `py` costs one failed
+spawn. A probe that can produce a false negative earns its place only if something
+downstream cannot do without it, and nothing here needed it.
+
+### Fixed
+
+- `bin/davinci-resolve-mcp.mjs` no longer gates the `py -3.x` candidates behind a
+  `py --version` probe.
+- An access-violation exit is now explained instead of propagated bare. Windows
+  reports `STATUS_ACCESS_VIOLATION` as an exit code (`3221225477`, or `-1073741819`
+  read signed), not as a signal — the interpreter dies inside the native library
+  with no chance to print. Both the launcher and `install.py`'s connection probe now
+  name the code, say why there is no traceback, and give the remedy. Previously the
+  probe could only report `Process exited with code 3221225477`.
+- `scripts/doctor.py` consults the runtime discovery helpers when every candidate
+  path misses, so Resolve installed off the conventional root (the reporter had it
+  on `D:`) is found rather than reported as four FAILs on a machine `install.py` had
+  just configured correctly. Same shape as issue #106.
+- `scripts/doctor.py` no longer reports a client config as `missing` because of path
+  escaping. A Windows path written into JSON comes back with doubled separators, and
+  the literal substring test could never match it — a false negative in the tool
+  whose job is to say whether setup worked.
+
+### Not changed
+
+Python 3.13 is still permitted. The policy set in v2.26.1 is a 3.10 floor with no
+cap — warn, do not block — and issue #158 proposed enforcing 3.10-3.12 on Windows.
+The candidate ordering already prefers the lower-risk interpreters; the bug was that
+ordering being bypassed, which is now fixed.
+
+### Coverage and its limits
+
+`tests/test_windows_python_crash.py` pins the launcher's candidate shape and the
+crash-code translation; `tests/test_doctor_paths.py` gains the discovery and
+path-escaping cases. All were confirmed to fail against the unfixed code.
+
+What is **not** covered, and is not coverable from macOS: whether `py --version`
+actually fails on any given Windows build. That claim comes from the reporter. The
+fix does not rest on it — it removes the probe rather than correcting it, so the
+code no longer has an opinion either way. The access-violation paths are likewise
+tested by injecting the exit code, not by producing a real crash.
+
 ## What's New in v2.103.1
 
 **A loudness measurement could silently become a single frame's reading.**

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.103.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.103.2-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-36%20(353%20full)-blue.svg)](#server-modes)

package/README.zh-CN.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 简体中文
 
-[![Version](https://img.shields.io/badge/version-2.103.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.103.2-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-36%20(353%20full)-blue.svg)](#服务器模式)
@@ -12,7 +12,7 @@
 [![Python](https://img.shields.io/badge/python-3.10+-green.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-> 本翻译对应 v2.103.1 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.103.2 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
 
 一个 Model Context Protocol (MCP) 服务器，让 AI 助手通过官方脚本 API 控制 DaVinci Resolve Studio（达芬奇）。它提供完整的 API 覆盖，外加带护栏的工作流助手，涵盖剪辑、媒体池整理、渲染设置、审阅标记、调色、Fusion、Fairlight、项目生命周期任务、扩展开发，以及不碰源媒体的媒体分析。
 

package/bin/davinci-resolve-mcp.mjs

@@ -179,14 +179,6 @@ function syncManagedInstall(root) {
   return root;
 }
 
-function commandExists(command, args = []) {
-  const result = spawnSync(command, [...args, "--version"], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  return result.status === 0;
-}
-
 function parseExecutable(value) {
   if (!value) {
     return null;
@@ -207,7 +199,14 @@ function pythonCandidates() {
   // Prefer the lowest-ABI-risk interpreters first, then newer ones, then the
   // generic launchers. All 3.10+ are accepted; ordering just picks the safest
   // when several are installed.
-  if (process.platform === "win32" && commandExists("py")) {
+  // No existence probe in front of these. `py --version` is not a reliable
+  // one — the Windows launcher does not accept it on every build, and it
+  // exits 101 on the ones it does not (issue #158). A probe that gets that
+  // wrong discards every version-pinned candidate below and falls through to
+  // bare `python`, which is exactly the 3.13 the ordering exists to avoid.
+  // checkPython() runs each candidate anyway, so a missing `py` costs one
+  // failed spawn and is skipped.
+  if (process.platform === "win32") {
     candidates.push(
       { command: "py", args: ["-3.12"] },
       { command: "py", args: ["-3.11"] },
@@ -317,6 +316,24 @@ function venvPython(root) {
   return info;
 }
 
+// Windows reports a hard access violation as the process exit code, not as a
+// signal and not as a traceback: the interpreter is gone before it can say
+// anything. Loading Resolve's fusionscript under a Python its C ABI does not
+// match is one way to get there, so name that possibility rather than letting
+// the run end in a bare unexplained code (issue #158).
+const WINDOWS_ACCESS_VIOLATION = [3221225477, -1073741819];
+
+function accessViolationNote(code) {
+  return [
+    `The Python process was terminated by an access violation (0x${(code >>> 0).toString(16).toUpperCase()}).`,
+    "It crashed inside a native library before it could report anything, so there is no traceback above.",
+    "The usual cause is Resolve's scripting library being loaded by a Python whose C ABI it was not built",
+    "against. If you are on Python 3.13+, install Python 3.10-3.12 and pin it:",
+    "  DAVINCI_RESOLVE_MCP_PYTHON=C:\\Path\\To\\python3.12.exe",
+    "then re-run setup so the managed venv is rebuilt on that interpreter.",
+  ].join("\n");
+}
+
 function run(command, args, options = {}) {
   const child = spawn(command, args, {
     cwd: options.cwd,
@@ -329,6 +346,9 @@ function run(command, args, options = {}) {
       process.kill(process.pid, signal);
       return;
     }
+    if (WINDOWS_ACCESS_VIOLATION.includes(code)) {
+      console.error(accessViolationNote(code));
+    }
     process.exit(code ?? 1);
   });
   child.on("error", (error) => {

package/docs/install.md

@@ -86,6 +86,7 @@ The installer can automatically configure any of these clients:
 
 | Client | Config Written To |
 |--------|-------------------|
+| Antigravity (Google) | `~/.gemini/antigravity/mcp_config.json` (all platforms) |
 | Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS); `%APPDATA%\Claude\claude_desktop_config.json` (Windows, see MSIX note below) |
 | Claude Code | `.mcp.json` (project root) |
 | Cursor | `~/.cursor/mcp.json` |

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.103.1"
+VERSION = "2.103.2"
 # 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
@@ -1253,6 +1253,54 @@ def install_dependencies(venv_path, project_dir):
 
 # ─── Connection Verification ─────────────────────────────────────────────────
 
+#: Windows surfaces a hard access violation (STATUS_ACCESS_VIOLATION) as a
+#: process exit code. Both spellings appear in the wild: the unsigned value and
+#: the signed reading of the same 32 bits. The interpreter dies inside the
+#: native library, so there is no traceback and no stderr to report — without
+#: this translation the probe can only say "exited with code 3221225477",
+#: which is the shape issue #158 was reported as.
+WINDOWS_ACCESS_VIOLATION_CODES = (3221225477, -1073741819)
+
+
+def _version_parts(version):
+    """A `(major, minor, ...)` int tuple, or None if it cannot be read.
+
+    `is_abi_risk_python_version` unpacks `version[:2]`, so handing it the string
+    "3.13.3" yields `("3", ".")` and a quiet False — the interpreter most likely
+    to have caused the crash would be reported as not at risk. Normalizing here
+    means a caller cannot make that mistake by passing the obvious thing.
+    """
+    if version is None:
+        return None
+    if isinstance(version, str):
+        try:
+            return tuple(int(part) for part in version.split(".")[:3])
+        except ValueError:
+            return None
+    try:
+        return tuple(int(part) for part in tuple(version)[:3])
+    except (TypeError, ValueError):
+        return None
+
+
+def access_violation_message(returncode, version=None):
+    """Explain an access-violation exit, naming the ABI theory when it fits."""
+    text = (
+        "Python crashed with an access violation (0xC0000005) while loading "
+        "Resolve's scripting library — no traceback is possible, the process "
+        "was terminated by the OS."
+    )
+    parts = _version_parts(version)
+    if parts is None or is_abi_risk_python_version(parts):
+        text += (
+            " This is the signature of a C ABI mismatch: recreate the venv on "
+            "Python 3.10-3.12 (e.g. DAVINCI_RESOLVE_MCP_PYTHON=...\\python3.12.exe)."
+        )
+    else:
+        text += " Check that RESOLVE_SCRIPT_LIB names the library from your Resolve install."
+    return text
+
+
 def verify_resolve_connection(python_path, api_path, lib_path):
     """Try to import DaVinciResolveScript and connect."""
     if not api_path:
@@ -1311,6 +1359,12 @@ def verify_resolve_connection(python_path, api_path, lib_path):
         elif output.startswith("IMPORTED_OK:"):
             return True, "API module loaded (Resolve not running)"
         else:
+            if result.returncode in WINDOWS_ACCESS_VIOLATION_CODES:
+                try:
+                    version = _version_for_python(python_path)
+                except Exception:
+                    version = None
+                return False, access_violation_message(result.returncode, version)
             if output:
                 return False, output
             return False, f"Process exited with code {result.returncode}"
@@ -2219,7 +2273,10 @@ def main():
                     "             Point RESOLVE_SCRIPT_LIB at the fusionscript library inside your "
                     "Resolve install, or start Resolve and re-run setup."
                 )
-            if py_abi_risk:
+            if py_abi_risk and "0xC0000005" not in message:
+                # The access-violation message already carries this remedy, and
+                # states it as a diagnosis rather than a maybe. Do not follow it
+                # with a weaker restatement of itself.
                 print(
                     f"             On Python 3.13+ this may be an ABI mismatch with Resolve's "
                     f"scripting library — try Python 3.10-3.12 if it persists."

package/package.json

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

package/scripts/doctor.py

@@ -95,13 +95,64 @@ def _platform_key(platform: str | None = None) -> str:
     return "linux"
 
 
+def _discovered_default(kind: str) -> str | None:
+    """Ask the runtime helpers where Resolve actually is.
+
+    The candidate table above is a table of *conventional* locations. Resolve is
+    routinely installed somewhere else — a second drive is the common case,
+    because the application and its caches are large (issue #158 reported
+    `D:\\Programs\\DaVinci Resolve`). install.py already looks past the table
+    via these helpers; doctor did not, so it reported FAIL on installs the
+    installer had just configured correctly. That disagreement between two tools
+    describing one machine is the same failure shape as issue #106.
+
+    Only consulted when no candidate exists, and only for the two kinds the
+    helpers can answer. `api` has no discovery helper, so a non-default install
+    can still miss there — worth knowing when reading a report.
+    """
+    if str(REPO) not in sys.path:
+        # doctor is run standalone (`python scripts/doctor.py`) as often as it is
+        # run through the launcher, and only the latter puts the repo on the path.
+        sys.path.insert(0, str(REPO))
+
+    if kind == "lib":
+        try:
+            from src.utils.platform import discover_scripting_lib
+        except Exception:
+            return None
+        try:
+            discovered = discover_scripting_lib()
+        except Exception:
+            return None
+        return str(discovered) if discovered and Path(discovered).exists() else None
+
+    if kind == "app":
+        try:
+            from src.utils.resolve_runtime import _executable_from_line, resolve_processes
+        except Exception:
+            return None
+        try:
+            processes = resolve_processes() or []
+        except Exception:
+            return None
+        for line in processes:
+            executable = _executable_from_line(line)
+            if executable and Path(executable).exists():
+                return str(executable)
+    return None
+
+
 def _resolve_default(kind: str, platform: str | None = None) -> str:
-    """First candidate of `kind` that exists, else the first (so the FAIL line
-    names the canonical location rather than an arbitrary miss)."""
+    """First candidate of `kind` that exists, then discovery, else the first
+    candidate (so the FAIL line names the canonical location rather than an
+    arbitrary miss)."""
     candidates = _RESOLVE_PATH_CANDIDATES[_platform_key(platform)][kind]
     for candidate in candidates:
         if Path(candidate).exists():
             return candidate
+    discovered = _discovered_default(kind)
+    if discovered:
+        return discovered
     return candidates[0]
 
 
@@ -170,11 +221,27 @@ def check(results: list[dict[str, str]], status: str, name: str, detail: str) ->
     results.append({"status": status, "name": name, "detail": detail})
 
 
+def _normalize_separators(text: str) -> str:
+    r"""Collapse every run of backslashes to a single forward slash.
+
+    A Windows path does not survive a literal substring test against the file it
+    was written into: JSON escapes `C:\Users\x` as `C:\\Users\\x`, and TOML
+    may keep it single-escaped or write a literal string. doctor compared the
+    unescaped path against the raw file text and so reported the entry missing
+    on configs it had itself just written (issue #158).
+
+    Collapsing runs — rather than only the doubled form — is what makes both
+    spellings compare equal, and normalizing the needle the same way keeps the
+    comparison symmetric.
+    """
+    return re.sub(r"\\+", "/", text)
+
+
 def file_contains(path: Path, needles: list[str]) -> tuple[bool, str]:
     if not path.exists():
         return False, "missing"
-    text = path.read_text(errors="replace")
-    missing = [needle for needle in needles if needle not in text]
+    text = _normalize_separators(path.read_text(errors="replace"))
+    missing = [needle for needle in needles if _normalize_separators(needle) not in text]
     if missing:
         return False, "missing: " + ", ".join(missing)
     return True, "contains davinci-resolve MCP entry"

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.103.1"
+VERSION = "2.103.2"
 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 353-tool granular server instead
 """
 
-VERSION = "2.103.1"
+VERSION = "2.103.2"
 
 import base64
 import os