davinci-resolve-mcp 2.214.2 → 2.214.4

package/CHANGELOG.md

@@ -2,6 +2,60 @@
 
 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.214.4 — the offline test suite no longer writes into the operator's server.log
+
+### Fixed
+
+- **The unit suite was appending to `logs/server.log`.** Importing
+  `src/server.py` attaches the root logger's FileHandler to that file, and the
+  suite imports the server, so every MagicMock "connection" the bridge tests
+  provoke and every lifecycle warning about a MagicMock timeline landed in the
+  operator's real log — the file a live debugging session reads. On the
+  maintainer's machine that log had grown to 128 MB with 240 such lines in it.
+  The log target is now `RESOLVE_MCP_LOG_FILE`: unset means `logs/server.log`
+  as before, a path means that file, empty means no file. `tests/__init__.py`
+  sets it to a temporary file before any test module imports the server, on
+  both the `unittest` and `pytest` paths, and `tests/test_log_isolation.py`
+  fails the suite if a handler on the root or `resolve-mcp` logger ever targets
+  the real log during a run. The live server's behaviour is unchanged, and the
+  transport-token redaction test, which builds its own root FileHandler, still
+  passes.
+- **The existing log is untouched.** The 128 MB file is the operator's; this
+  change only stops adding to it. Rotate or trim it by hand if wanted.
+
+### Validation
+
+- `tests/test_log_isolation.py` (four tests, including the unset-means-real-log
+  case that pins the live behaviour). Proven with an audited full run — a
+  `sys.addaudithook` on every `open` of the operator's log — that recorded zero
+  opens across 3371 tests. Full offline suite, drift guards and the advanced
+  Node suite green.
+
+## What's New in v2.214.3 — the advanced launcher heals a wrong-Node registration
+
+### Fixed
+
+- **`davinci-resolve-advanced-mcp` re-executes itself under a Node ≥ 20.9 when
+  started by an older one.** The floor is unchanged and deliberate (sharp's own
+  engine floor is 20.9; better-sqlite3 is a native module built for one ABI;
+  Node 18 is end-of-life). What kept recurring was the MCP registration's
+  `command` landing on an nvm v18 binary after a client app rewrote its config
+  (twice on the reference machine), which left the server "disconnected" with
+  the fix buried in a log. The launcher now looks for a suitable Node before
+  refusing — `DAVINCI_RESOLVE_NODE` first, then nvm's versions directory
+  newest-first, then Homebrew/system paths (Windows: Program Files and the
+  per-user install) — probes each with `-p process.versions.node`, re-execs
+  with the same stdio under the first that passes, and says so on stderr.
+  A re-exec marks itself so a bad replacement cannot loop; with no usable
+  candidate the refusal now lists what was probed. Measured live: started by
+  v18.20.8, it came up under v22.22.3 and served the MCP handshake.
+- **`--node-check`** prints `{node, execPath, reexec}` after the floor check —
+  the answer to "which Node is this registration actually running?".
+  `--version` and `--help` still answer before the floor, whatever started them.
+- `DAVINCI_RESOLVE_ADVANCED_ASSUME_NODE` fakes the running version and
+  `DAVINCI_RESOLVE_ADVANCED_NO_NODE_SEARCH=1` limits the search to the explicit
+  override; both exist for the tests and are documented in the launcher.
+
 ## What's New in v2.214.2 — a running Resolve is counted by its executable path, not only by its argument vector
 
 ### Fixed

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.214.2-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.214.4-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)
@@ -298,7 +298,9 @@ and an audit document is the last place to let a reader read it as an all-clear.
 
 Traces live in a 100-entry in-memory ring and are appended to
 `logs/execution-traces.jsonl` beside `server.log` — `RESOLVE_MCP_TRACE_FILE`
-moves it. `list_recent_executions` reports that path and whether it is
+moves it, and `RESOLVE_MCP_LOG_FILE` moves `server.log` itself (a path, or empty
+for no file; the offline test suite points it at a temporary file so it never
+writes into the operator's log). `list_recent_executions` reports that path and whether it is
 writable, so "the log is empty" and "nothing is being written" are
 distinguishable without reading the source. What is recorded is tool name,
 action, timing, status, semantic deltas and verification — no parameters and no

package/README.zh-CN.md

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

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

@@ -26,6 +26,7 @@ Usage:
   davinci-resolve-advanced-mcp
   davinci-resolve-advanced-mcp --version
   davinci-resolve-advanced-mcp --help
+  davinci-resolve-advanced-mcp --node-check   (which Node the server would run under)
 
 Starts the offline DaVinci Resolve advanced MCP server over stdio.
 `;
@@ -49,19 +50,77 @@ if (command === '--version' || command === '-v' || command === 'version') {
 // command in an MCP registration resolves to on a machine whose shell
 // default lags. Silent degradation is this repo's least favorite failure
 // mode; refuse loudly with the fix instead.
-const [major, minor] = process.versions.node.split('.').map(Number);
+//
+// Self-heal (2026-09-09, after the registration landed on v18 for the second
+// time): before refusing, look for a Node >=20.9 on this machine (an explicit
+// DAVINCI_RESOLVE_NODE, nvm's versions dir newest-first, Homebrew/system
+// paths), re-exec this launcher under it with the same stdio, and say so on
+// stderr. The registration can then point at any node and still come up.
+// DAVINCI_RESOLVE_ADVANCED_ASSUME_NODE fakes the running version (tests);
+// DAVINCI_RESOLVE_ADVANCED_NO_NODE_SEARCH=1 limits the search to the explicit
+// override; the re-exec marks itself so a bad replacement cannot loop.
+const runningNode = process.env.DAVINCI_RESOLVE_ADVANCED_ASSUME_NODE || process.versions.node;
+const [major, minor] = runningNode.split('.').map(Number);
 if (major < 20 || (major === 20 && minor < 9)) {
-  process.stderr.write(
-    `[davinci-resolve-advanced-mcp] Node ${process.versions.node} is below the ` +
+  const refusal = (extra = '') =>
+    `[davinci-resolve-advanced-mcp] Node ${runningNode} is below the ` +
     `supported floor (>=20.9). This process was started by: ${process.execPath}\n` +
     `Fix: point the MCP registration's command at a Node >=20.9 binary ` +
     `(e.g. the absolute path from \`nvm which 20\`), or update the default ` +
     `node on PATH. Re-running install.py also rewrites client configs with ` +
-    `an absolute, version-checked node path.\n`,
-  );
+    `an absolute, version-checked node path.\n${extra}`;
+  let picked = null;
+  const probed = [];
+  if (!process.env.DAVINCI_RESOLVE_ADVANCED_REEXEC) {
+    try {
+      // Sibling module; a managed install that only received this file falls
+      // through to the plain refusal instead of dying on the import.
+      const floor = await import(pathToFileURL(path.join(__dirname, 'node-floor.mjs')).href);
+      const candidates = process.env.DAVINCI_RESOLVE_ADVANCED_NO_NODE_SEARCH
+        ? [process.env.DAVINCI_RESOLVE_NODE].filter(Boolean)
+        : floor.candidateNodeBinaries();
+      picked = floor.findReplacementNode({ candidates, probed });
+    } catch (err) {
+      probed.push({
+        path: '(search unavailable)',
+        version: null,
+        error: String(err && err.message ? err.message : err),
+      });
+    }
+  }
+  if (picked) {
+    process.stderr.write(
+      `[davinci-resolve-advanced-mcp] Node ${runningNode} is below the supported floor (>=20.9); ` +
+        `re-executing under ${picked.path} (Node ${picked.version}). ` +
+        `Point the MCP registration's command at that path to skip this step.\n`,
+    );
+    const { spawnSync } = await import('node:child_process');
+    const child = spawnSync(picked.path, [fileURLToPath(import.meta.url), ...process.argv.slice(2)], {
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        DAVINCI_RESOLVE_ADVANCED_REEXEC: '1',
+        DAVINCI_RESOLVE_ADVANCED_ASSUME_NODE: '',
+      },
+    });
+    process.exit(child.status === null ? 1 : child.status);
+  }
+  const probedLine = probed.length
+    ? `No usable replacement found; probed: ${probed.map((p) => `${p.path} (${p.version || (p.error ? p.error : 'not node')})`).join(', ')}\n`
+    : '';
+  process.stderr.write(refusal(probedLine));
   process.exit(1);
 }
 
+// After the floor: reports the Node the server actually runs under, including
+// a self-heal re-exec — the answer to "which node is the registration using?"
+if (command === '--node-check') {
+  process.stdout.write(
+    `${JSON.stringify({ node: process.versions.node, execPath: process.execPath, reexec: process.env.DAVINCI_RESOLVE_ADVANCED_REEXEC === '1' })}\n`,
+  );
+  process.exit(0);
+}
+
 const advancedRoot = path.resolve(packageRoot, 'resolve-advanced');
 const serverEntry = path.join(advancedRoot, 'server', 'index.mjs');
 
@@ -79,12 +138,12 @@ function missingRuntimePieces() {
     const manifest = JSON.parse(fs.readFileSync(path.join(advancedRoot, 'package.json'), 'utf8'));
     required = Object.keys(manifest.dependencies || {});
   } catch {
-    return { what: `resolve-advanced/package.json (cannot tell which deps are required)` };
+    return {
+      what: `resolve-advanced/package.json (cannot tell which deps are required)`,
+    };
   }
   const modulesDir = path.join(advancedRoot, 'node_modules');
-  const missing = required.filter(
-    (dep) => !fs.existsSync(path.join(modulesDir, ...dep.split('/'))),
-  );
+  const missing = required.filter((dep) => !fs.existsSync(path.join(modulesDir, ...dep.split('/'))));
   // Deps may also be hoisted above the package (an npm/npx install puts them in
   // a parent node_modules), so an empty local node_modules is not conclusive —
   // only report deps the resolver genuinely cannot see.
@@ -103,11 +162,11 @@ const gap = missingRuntimePieces();
 if (gap) {
   process.stderr.write(
     `[davinci-resolve-advanced-mcp] cannot start: ${gap.what}.\n` +
-    `This install is at ${packageRoot}.\n` +
-    `Fix: run \`npx davinci-resolve-mcp setup\` to repair the managed install ` +
-    `(it syncs resolve-advanced/ and installs its Node dependencies), or run the ` +
-    `server straight from the package with ` +
-    `\`npx -y --package davinci-resolve-mcp davinci-resolve-advanced-mcp\`.\n`,
+      `This install is at ${packageRoot}.\n` +
+      `Fix: run \`npx davinci-resolve-mcp setup\` to repair the managed install ` +
+      `(it syncs resolve-advanced/ and installs its Node dependencies), or run the ` +
+      `server straight from the package with ` +
+      `\`npx -y --package davinci-resolve-mcp davinci-resolve-advanced-mcp\`.\n`,
   );
   process.exit(1);
 }

package/bin/node-floor.mjs

@@ -0,0 +1,116 @@
+/**
+ * Node-floor self-heal for the advanced launcher.
+ *
+ * The advanced server needs Node >=20.9 (sharp's own floor; better-sqlite3 is
+ * a native module built for one ABI). The failure that keeps recurring is not
+ * the floor — it is the MCP registration's `command` landing on an old nvm
+ * binary (v18.20.8 on this machine, twice) because a GUI app rewrote the
+ * config or a shell whose default lags ran the installer. Refusing with the
+ * fix printed is right, but a launcher that can SEE a suitable Node on the
+ * same machine should use it: find one, re-exec under it, and say so.
+ *
+ * Pure functions here so the search and the version rule are unit-testable
+ * without spawning anything; the launcher wires them to real probes.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export const NODE_FLOOR = { major: 20, minor: 9 };
+
+/** '20.19.0' → true, 'v18.20.8' → false, garbage → false. */
+export function meetsFloor(version, floor = NODE_FLOOR) {
+  const m = String(version || '').match(/^v?(\d+)\.(\d+)/);
+  if (!m) return false;
+  const [major, minor] = [Number(m[1]), Number(m[2])];
+  return major > floor.major || (major === floor.major && minor >= floor.minor);
+}
+
+/** Numeric sort key for a version string; unparsable → [0,0,0]. */
+function versionKey(v) {
+  const m = String(v || '').match(/^v?(\d+)\.(\d+)\.(\d+)/);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : [0, 0, 0];
+}
+const byVersionDesc = (a, b) => {
+  const ka = versionKey(a);
+  const kb = versionKey(b);
+  for (let i = 0; i < 3; i += 1) if (ka[i] !== kb[i]) return kb[i] - ka[i];
+  return 0;
+};
+
+/**
+ * Where a Node >=20.9 might live on this machine, best first:
+ *   1. DAVINCI_RESOLVE_NODE (an explicit operator choice)
+ *   2. nvm's versions dir ($NVM_DIR or ~/.nvm), newest version first
+ *   3. Homebrew / system / Windows default install paths
+ * The current executable is excluded — it is the one that failed.
+ */
+export function candidateNodeBinaries({
+  env = process.env,
+  home = env.HOME || env.USERPROFILE || '',
+  platform = process.platform,
+  execPath = process.execPath,
+  exists = fs.existsSync,
+  readdir = (d) => fs.readdirSync(d),
+} = {}) {
+  const out = [];
+  const push = (p) => {
+    if (p && p !== execPath && !out.includes(p)) out.push(p);
+  };
+  // The explicit override is honored as given — even when it names the very
+  // binary that started us (a faked-version test, or an operator re-pointing
+  // the registration and forgetting to restart).
+  if (env.DAVINCI_RESOLVE_NODE) out.push(env.DAVINCI_RESOLVE_NODE);
+  const nvmDir = env.NVM_DIR || (home ? path.join(home, '.nvm') : '');
+  const versionsDir = nvmDir ? path.join(nvmDir, 'versions', 'node') : '';
+  if (versionsDir && exists(versionsDir)) {
+    let entries = [];
+    try {
+      entries = readdir(versionsDir);
+    } catch {
+      entries = [];
+    }
+    for (const v of [...entries].sort(byVersionDesc)) {
+      push(platform === 'win32' ? path.join(versionsDir, v, 'node.exe') : path.join(versionsDir, v, 'bin', 'node'));
+    }
+  }
+  if (platform === 'win32') {
+    for (const p of [
+      env.ProgramFiles ? path.join(env.ProgramFiles, 'nodejs', 'node.exe') : '',
+      env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'Programs', 'nodejs', 'node.exe') : '',
+    ])
+      push(p);
+  } else {
+    for (const p of ['/opt/homebrew/bin/node', '/usr/local/bin/node', '/usr/bin/node', '/snap/bin/node']) push(p);
+  }
+  return out.filter((p) => exists(p));
+}
+
+/** Ask a binary for its Node version; null when it does not run or is not Node. */
+export function probeNodeVersion(binary, run = spawnSync) {
+  try {
+    const r = run(binary, ['-p', 'process.versions.node'], {
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+    if (r.status !== 0) return null;
+    const v = String(r.stdout || '').trim();
+    return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * First candidate whose probed version meets the floor → {path, version}, or
+ * null. `probed` collects every attempt for the refusal message.
+ */
+export function findReplacementNode({ candidates, probe = probeNodeVersion, floor = NODE_FLOOR, probed = [] } = {}) {
+  for (const p of candidates || []) {
+    const version = probe(p);
+    probed.push({ path: p, version });
+    if (version && meetsFloor(version, floor)) return { path: p, version };
+  }
+  return null;
+}

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.214.2"
+VERSION = "2.214.4"
 # 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.214.2",
+  "version": "2.214.4",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.214.2"
+VERSION = "2.214.4"
 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.214.2"
+VERSION = "2.214.4"
 
 import base64
 import os
@@ -185,10 +185,40 @@ if RESOLVE_MODULES_PATH not in sys.path:
 
 log_dir = os.path.join(project_dir, "logs")
 os.makedirs(log_dir, exist_ok=True)
+
+#: Where this process logs. Unset: `logs/server.log` under the repository, as
+#: always. A path: that file (its directory is created). Empty: no file at all.
+#:
+#: The variable exists because importing this module attaches the file handler,
+#: and the offline unit suite imports this module. Without it the suite's
+#: MagicMock "connections" and lifecycle warnings landed in the operator's real
+#: server.log — 240 such lines in a 128 MB log on the maintainer's machine —
+#: which is the file every live debugging session reads. `tests/__init__.py`
+#: points it at a temporary file before any test module runs.
+ENV_LOG_FILE = "RESOLVE_MCP_LOG_FILE"
+
+
+def _log_file_from_env(env=None) -> str:
+    """The log path this process should use, or "" for none."""
+    values = os.environ if env is None else env
+    value = values.get(ENV_LOG_FILE)
+    if value is None:
+        return os.path.join(log_dir, "server.log")
+    return os.path.expanduser(value.strip())
+
+
+def _log_handlers():
+    target = _log_file_from_env()
+    if not target:
+        return [logging.NullHandler()]
+    os.makedirs(os.path.dirname(target) or ".", exist_ok=True)
+    return [logging.FileHandler(target)]
+
+
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.FileHandler(os.path.join(log_dir, "server.log"))]
+    handlers=_log_handlers(),
 )
 logger = logging.getLogger("resolve-mcp")