davinci-resolve-mcp 2.98.1 → 2.98.2

package/CHANGELOG.md

@@ -2,6 +2,71 @@
 
 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

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.98.1-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.1-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.1 版 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.1"
+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.1",
+  "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.1"
+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.1"
+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