davinci-resolve-mcp 2.98.0 → 2.98.2

package/CHANGELOG.md

@@ -2,6 +2,120 @@
 
 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.98.2
+
+**A tool installed next to the server was invisible to it.** Reported in
+[#153](https://github.com/samuelgursky/davinci-resolve-mcp/issues/153) by
+@7daysdedicated as an encoding fault in the whisper probe. The probe turned out
+not to be the cause, and the encoding fault turned out to be real somewhere
+else, so both are fixed here.
+
+### Fixed
+
+- **The server's own virtualenv was not searched for command-line tools.**
+  `pip install openai-whisper` writes a `whisper` executable into
+  `venv/Scripts` on Windows and `venv/bin` elsewhere, and that directory is on
+  PATH only while the environment is *activated* — which nothing does, since the
+  client launches `venv/python server.py` directly. So `shutil.which("whisper")`
+  returned None and `capabilities` reported `whisper_cli.available: false` for a
+  tool sitting beside the interpreter looking for it, with nothing in the
+  response to say why. The interpreter's script directory now leads the PATH
+  augmentation that already covered Homebrew and `/usr/local`. Not
+  Windows-specific: the same gap existed on macOS and Linux.
+
+- **Text-mode reads of a child process decoded with the locale codec.** Nineteen
+  `subprocess.run(..., text=True)` calls across the server, panel, and utils had
+  no `encoding=`, so Python used the platform locale — cp1252 on a default
+  Windows install, a codec with no mapping for most of what a media tool prints.
+  A clip name in Japanese from the advanced-server bridge, a localized WMIC
+  banner, or a user script's output was then a `UnicodeDecodeError` raised
+  inside a call whose job was to answer a yes/no question. All nineteen now read
+  UTF-8 with `errors="replace"`, so the answer can be wrong in the last
+  character but never an exception. The WMIC read matters most: it feeds the
+  second-instance guard fixed in v2.97.6, and it must fail to "cannot tell".
+
+- **Child Python processes are handed `PYTHONIOENCODING=utf-8`.** A script run
+  through `resolve_control` writes into a pipe, where Python picks the locale
+  codepage rather than the console's, so printing a non-Latin-1 character killed
+  the script with `UnicodeEncodeError` — and the failure read as the script's
+  fault rather than the pipe's. The transcription path already did this; the
+  script-runner did not.
+
+### Added
+
+- **`tests.test_child_process_text_encoding`** — a static walk over `src/` that
+  fails on any text-mode child read without an explicit `encoding=`. Static
+  because the exception needs a non-UTF-8 locale to reproduce and no machine in
+  this suite has one: the missing argument is visible in the source, the
+  `UnicodeDecodeError` is only visible in Tokyo. The walk carries a test that it
+  can still see an offender, since a guard that quietly matches nothing passes
+  forever. Also covers the venv script directory being on PATH, first, and
+  idempotently.
+
+### Note on the report
+
+The diagnosis in #153 named `whisper --help` as the probe. That string is
+display text in the install-guidance table and is never executed — detection is
+`shutil.which("whisper")` — and the transcription path already decoded UTF-8 and
+already set `PYTHONIOENCODING`. The cause was the PATH gap the report mentioned
+last, in passing, as an aside about `pip`. Worth stating plainly, because the
+reporter's `whisper.cmd` workaround set the encoding *and* put a `whisper` on
+PATH, and only the second half was doing the work.
+
+### Changed
+
+- `docs/install.md` says which environment optional packages have to be
+  installed into, which is the part that was undocumented.
+
+## What's New in v2.98.1
+
+**The Bash guard could be walked past with a newline.** Reported and fixed in
+[#152](https://github.com/samuelgursky/davinci-resolve-mcp/pull/152) by
+@fitfam, who found both holes by executing payloads against the hook rather
+than reading it.
+
+### Fixed
+
+- **`split_commands()` did not split on newlines.** It knew `&&`, `||`, `;` and
+  `|`, so a multi-line block was a single segment: `argv0` came from the first
+  line, and a non-mutating first line returned before anything under it was
+  looked at. `mkdir -p footage/_superseded` then a newline then
+  `mv footage/clip.mp4 footage/_superseded/` passed, while the same two commands
+  joined by `;` denied. Either answer is defensible on its own; giving two
+  different answers to what a shell treats as the same command is what made the
+  guard trainable around.
+
+- **The ffmpeg branch exempted an output that equalled an input.** The output
+  operand was dropped when it matched a `-i` value — which is exactly
+  `ffmpeg -i master.mp4 master.mp4`, the in-place overwrite the hook's own deny
+  message calls unrecoverable. Independent of the first hole: the single-line
+  form was allowed too.
+
+### Changed
+
+- The trailing operand is no longer read as an output when it is the value of a
+  `-i` immediately before it. `ffmpeg -i master.mov` prints stream info and
+  writes nothing, and denying a read is how a guard teaches an agent to route
+  around it. `ffmpeg -i x.mp4 x.mp4` still denies — the token there is not
+  preceded by `-i`.
+
+### Added
+
+- **`tests.test_source_media_guard`** — the hook had no tests, which is why two
+  holes in it needed a payload matrix to find. It runs the hook the way the
+  harness does, a PreToolUse payload on stdin and a decision on stdout, and
+  fails on exactly the four rows this release fixes. The newline/`;` pair is
+  asserted as a pair: not that either answer is right, but that the guard cannot
+  give two.
+
+### Note
+
+- Splitting on newlines means multi-line text carried *inside* a command — a
+  heredoc body, a commit message — is now read as commands too, so text that
+  merely quotes `rm camera.mov` is denied. That is the right way round for a
+  tripwire; write the text to a file first. #152 was itself blocked this way on
+  its first attempt, by the fix it was proposing.
+
 ## What's New in v2.98.0
 
 **The control panel could be driven by any web page you visited.** Reported
@@ -117,6 +231,13 @@ state file and panel pidfile move out of shared locations at the same time.
   response, so an unrelated document sitting in the export folder could reach an
   assistant's context. Only staged files are read now.
 
+  Live-verified after release on Studio 19.1.3.7 (macOS, Color page, Gallery
+  panel open): Resolve's `ExportStills` writes into the staging subdirectory — a
+  257 KB JPEG and its 28 KB `.drx` came back inlined — a bystander file in the
+  same folder survived untouched, the folder itself was kept, and
+  `cleanup: false` moved both files up into it. That subdirectory write was the
+  one claim the offline fixtures could not make.
+
 ### Added
 
 - `tests.test_gallery_still_export_cleanup` runs the action against a real temp

package/README.md

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

package/docs/install.md

@@ -35,6 +35,14 @@ rather than guessing** if it is absent:
 `python scripts/doctor.py` reports which are present. `media_analysis`
 `capabilities` covers the analysis stack in more detail.
 
+**Install them into the environment the server runs from.** A managed install
+uses its own virtualenv, and `pip install` from an unrelated shell puts the
+package somewhere that interpreter never looks. Use the venv's own pip —
+`<install>/venv/bin/pip` (`venv\Scripts\pip.exe` on Windows) — or activate it
+first. Command-line tools that come with a package (`openai-whisper` installs a
+`whisper` executable) are found in that venv's script directory automatically
+since v2.98.2; before that they had to be on PATH by hand.
+
 Model weights carry their own licences, separate from the code that loads them.
 
 > **Python 3.13 / 3.14:** these are **allowed** — setup will use them and warn.

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.98.0"
+VERSION = "2.98.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

package/package.json

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

package/src/analysis_dashboard.py

@@ -14569,7 +14569,8 @@ def _launch_claude_code_terminal() -> Dict[str, Any]:
     try:
         check = subprocess.run(
             ["osascript", "-e", 'application "iTerm" is running'],
-            capture_output=True, text=True, timeout=8,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=8,
         )
         iterm_running = (check.stdout or "").strip().lower() == "true"
     except Exception:
@@ -14592,7 +14593,8 @@ def _launch_claude_code_terminal() -> Dict[str, Any]:
     try:
         proc = subprocess.run(
             ["osascript", "-e", script],
-            capture_output=True, text=True, timeout=15,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=15,
         )
         if proc.returncode != 0:
             return {"success": False, "error": (proc.stderr or "").strip() or "osascript failed"}
@@ -14623,7 +14625,8 @@ def _native_directory_picker(initial: Optional[str] = None) -> Dict[str, Any]:
             import subprocess
             proc = subprocess.run(
                 ["osascript", "-e", script],
-                capture_output=True, text=True, timeout=120,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=120,
             )
             if proc.returncode != 0:
                 stderr = (proc.stderr or "").strip()
@@ -15194,7 +15197,11 @@ def _run_advanced_bridge(surface: str, op: str, args: Optional[Dict[str, Any]] =
         # stdin=DEVNULL: never let a child race-read a protocol/stdin stream (api_truth).
         proc = subprocess.run(
             [node, bridge, str(surface), str(op), json.dumps(args or {})],
-            capture_output=True, text=True, timeout=timeout,
+            # The bridge answers in JSON that carries clip and project names;
+            # decoding those with the locale codepage is how a non-ASCII name
+            # turns a working panel call into a UnicodeDecodeError (#153).
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=timeout,
             stdin=subprocess.DEVNULL, cwd=_advanced_root(),
         )
     except subprocess.TimeoutExpired:

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.98.0"
+VERSION = "2.98.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.98.0"
+VERSION = "2.98.2"
 
 import base64
 import os
@@ -1724,8 +1724,8 @@ def _activate_resolve_window() -> Dict[str, Any]:
             import subprocess
             proc = subprocess.run(
                 ["osascript", "-e", 'tell application "DaVinci Resolve" to activate'],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1738,8 +1738,8 @@ def _activate_resolve_window() -> Dict[str, Any]:
                 ["powershell", "-NoProfile", "-Command",
                  "$s = New-Object -ComObject WScript.Shell; "
                  "$null = $s.AppActivate('DaVinci Resolve')"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1751,8 +1751,8 @@ def _activate_resolve_window() -> Dict[str, Any]:
         if shutil.which("wmctrl"):
             proc = subprocess.run(
                 ["wmctrl", "-a", "DaVinci Resolve"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1762,8 +1762,8 @@ def _activate_resolve_window() -> Dict[str, Any]:
         if shutil.which("xdotool"):
             proc = subprocess.run(
                 ["xdotool", "search", "--name", "DaVinci Resolve", "windowactivate"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1794,8 +1794,8 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
             )
             proc = subprocess.run(
                 ["osascript", "-e", script],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "sent": proc.returncode == 0,
@@ -1810,8 +1810,8 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
                  "Add-Type -AssemblyName System.Windows.Forms; "
                  "Start-Sleep -Milliseconds 150; "
                  "[System.Windows.Forms.SendKeys]::SendWait('+i')"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "sent": proc.returncode == 0,
@@ -1824,8 +1824,8 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
         if shutil.which("xdotool"):
             proc = subprocess.run(
                 ["xdotool", "search", "--name", "DaVinci Resolve", "key", "--window", "%@", "shift+i"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {"sent": proc.returncode == 0, "platform": "linux", "tool": "xdotool", "shortcut": "Shift+I"}
         return {"sent": False, "platform": sys.platform, "note": "no key-send tool found"}
@@ -15286,7 +15286,8 @@ def _port_owner_pid(host: str, port: int) -> Optional[int]:
     try:
         result = subprocess.run(
             ["lsof", "-nP", "-iTCP:" + str(port), "-sTCP:LISTEN", "-t"],
-            capture_output=True, timeout=3, text=True, check=False,
+            capture_output=True, timeout=3, text=True, encoding="utf-8",
+            errors="replace", check=False,
             stdin=subprocess.DEVNULL,
         )
     except (OSError, subprocess.TimeoutExpired):
@@ -16561,6 +16562,8 @@ def _make_spec_hook_runner(timeout: float = 120.0):
                 stdin=subprocess.DEVNULL,
                 capture_output=True,
                 text=True,
+                encoding="utf-8",
+                errors="replace",
             )
             return proc.returncode == 0
         except Exception as exc:
@@ -27141,7 +27144,8 @@ def _validate_lua_syntax(source: str) -> Dict[str, Any]:
         f.write(source)
         tmp = f.name
     try:
-        result = subprocess.run([luac, "-p", tmp], capture_output=True, text=True, timeout=10,
+        result = subprocess.run([luac, "-p", tmp], capture_output=True, text=True,
+                                encoding="utf-8", errors="replace", timeout=10,
                                 stdin=subprocess.DEVNULL)
         if result.returncode == 0:
             return {"valid": True, "errors": None, "checker": luac}
@@ -27694,6 +27698,12 @@ def _python_env_for_resolve() -> Dict[str, str]:
     env = os.environ.copy()
     env["RESOLVE_SCRIPT_API"] = RESOLVE_API_PATH
     env["RESOLVE_SCRIPT_LIB"] = RESOLVE_LIB_PATH
+    # The child writes its stdout into a pipe, so Python picks the locale
+    # codepage rather than the console's — cp1252 on a default Windows install.
+    # A script that prints a non-Latin-1 character then dies with
+    # UnicodeEncodeError instead of returning its output, and the failure is
+    # attributed to the script rather than to the pipe it was handed (#153).
+    env["PYTHONIOENCODING"] = "utf-8"
     pp = env.get("PYTHONPATH", "")
     if RESOLVE_MODULES_PATH not in pp:
         env["PYTHONPATH"] = (RESOLVE_MODULES_PATH +
@@ -27741,7 +27751,8 @@ def _execute_python_script(path: str, args: List[str],
     cmd = [sys.executable, "-c", _PY_SCRIPT_EXIT_GUARD, path] + [str(a) for a in args]
     try:
         result = safe_run(cmd, env=_python_env_for_resolve(),
-                          capture_output=True, text=True, timeout=timeout)
+                          capture_output=True, text=True, encoding="utf-8",
+                          errors="replace", timeout=timeout)
     except subprocess.TimeoutExpired as e:
         return _err(f"Script timed out after {timeout}s. "
                     f"Partial stdout: {(e.stdout or '')[:1000]}")

package/src/utils/app_control.py

@@ -33,6 +33,8 @@ def _run_app_command(
             check=False,
             capture_output=True,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             timeout=timeout,
         )
     except subprocess.TimeoutExpired:

package/src/utils/image_qc.py

@@ -189,7 +189,8 @@ def _probe_color_transfer(path: str) -> Optional[str]:
         "-show_entries", "stream=color_transfer", "-of", "default=nw=1:nk=1", path,
     ]
     try:
-        proc = subprocess.run(args, capture_output=True, text=True, timeout=30, check=False)
+        proc = subprocess.run(args, capture_output=True, text=True, encoding="utf-8",
+                              errors="replace", timeout=30, check=False)
     except (subprocess.TimeoutExpired, OSError):
         return None
     value = (proc.stdout or "").strip().lower()

package/src/utils/media_analysis.py

@@ -335,8 +335,20 @@ def _ensure_path_includes_standard_tool_dirs() -> None:
     /opt/homebrew/bin/ffprobe. Subprocess calls (subprocess.run(["ffprobe"...]))
     then also fail to find the binary. Prepending the standard tool dirs here
     fixes both detection and execution for every importer of this module.
+
+    The interpreter's own script directory is one of them, and it was missing.
+    A console script installed into the server's virtualenv — `pip install
+    openai-whisper` puts `whisper` in `venv/Scripts` on Windows, `venv/bin`
+    elsewhere — is only on PATH when that environment has been *activated*, and
+    nothing activates it: the client launches `venv/python server.py` directly.
+    So the tool was installed, working, and invisible, and `capabilities`
+    reported `whisper_cli.available: false` with no hint as to why (#153, where
+    the workaround that appeared to fix it was a shim placed on PATH by hand).
     """
     candidates = [
+        # The venv this server is running from, first: a tool installed
+        # deliberately alongside it should win over an older copy elsewhere.
+        os.path.dirname(os.path.abspath(sys.executable)),
         "/opt/homebrew/bin",
         "/opt/homebrew/sbin",
         "/usr/local/bin",

package/src/utils/resolve_bridge.py

@@ -216,7 +216,8 @@ def _process_name(pid: int) -> str:
 
         out = subprocess.run(
             ["ps", "-p", str(pid), "-o", "comm="],
-            capture_output=True, text=True, timeout=5, check=False,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=5, check=False,
         )
         return (out.stdout or "").strip()
     except Exception:  # pragma: no cover - defensive

package/src/utils/resolve_runtime.py

@@ -68,13 +68,23 @@ def _process_lines() -> Optional[List[str]]:
         if platform.system().lower() == "windows":
             # `tasklist` prints no command line, so the flag is invisible there.
             # WMIC does print it and is what makes headless detection possible.
+            #
+            # Decoded explicitly: `text=True` alone decodes with the locale
+            # codepage, which raises UnicodeDecodeError on a byte cp1252 has no
+            # mapping for — and this read is the input to the second-instance
+            # guard, so it must fail to "cannot tell", never to an exception.
+            # ASCII is byte-identical under both codecs, so the matching this
+            # feeds is unchanged; what WMIC emits for a non-ASCII install path
+            # on a non-English Windows is not something we can verify here.
             out = subprocess.run(
                 ["wmic", "process", "where", "name='Resolve.exe'", "get", "CommandLine"],
-                capture_output=True, text=True, timeout=10, check=False,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=10, check=False,
             )
         else:
             out = subprocess.run(
-                ["ps", "-Ao", "command="], capture_output=True, text=True, timeout=10, check=False
+                ["ps", "-Ao", "command="], capture_output=True, text=True,
+                encoding="utf-8", errors="replace", timeout=10, check=False,
             )
         if out.returncode != 0 and not out.stdout:
             return None