davinci-resolve-mcp 2.218.0 → 2.218.1

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.218.1 — Windows 11 process detection survives the removal of WMIC
+
+Reported by @Nikibakht (#210), verified on Windows 11 Pro build 26200.
+
+### Fixed
+
+- **Every tool refused with `RESOLVE_NOT_RUNNING` on Windows 11 build 26200+,
+  while Resolve was running in front of the user.** Process detection read the
+  running Resolve's command line through `wmic`, which **Microsoft removed in
+  build 26200** — it is neither on `PATH` nor at `C:\Windows\System32\wbem`.
+  Spawning it raised `FileNotFoundError`, the read returned `None`, and `None`
+  correctly means "cannot determine whether Resolve is running", so the server
+  refused to act and declined to launch. The detection logic was right; the
+  reader it depended on had ceased to exist.
+- Windows now tries a chain of readers — `wmic`, then Windows PowerShell's
+  `Get-CimInstance Win32_Process`, then `pwsh` — and uses the first that
+  answers. `None` is returned only when **no** reader ran; a reader that ran
+  and found nothing still returns an empty list, which is a different answer.
+  Machines that still have WMIC are unaffected, and keeping it first costs
+  nothing, because a missing binary fails instantly rather than burning the
+  ten-second timeout.
+
+### Changed
+
+- The PowerShell reader returns **`ProcessId`, `Name`, `ExecutablePath` and
+  `CommandLine`**, not the command line alone, so Windows now fills the same
+  two-column process table as macOS and Linux. The columns fail independently,
+  and @Nikibakht measured how: querying as an unelevated user on build 26200, a
+  process the caller cannot fully read still returns its row with `ProcessId`
+  and `Name` populated and `CommandLine` NULL — the *column* is
+  access-restricted, not the row. Reading only the command line would turn
+  such an instance into no row at all: an empty list, which does not mean
+  "cannot tell", it means "nothing is running", and that is the answer that
+  launches a second Resolve on top of a live one.
+- `Name` is in that query because of the same measurement. It showed `Name`
+  surviving the access restriction; it did **not** show `ExecutablePath`
+  surviving it, and for a protected process that field is commonly empty too,
+  so the executable column falls back to the bare process name — which the
+  existing match patterns already accept. An instance is counted on either
+  column, and the mode is reported as unknown rather than guessed when the
+  argument vector is unreadable, since `-nogui` is only ever visible there.
+  Windows rows also carry real pids instead of the synthetic negative ones the
+  WMIC branch invents.
+
+### Validation
+
+- Full suite green: 3,446 passed, 1 skipped. Ten new tests cover the reader chain: a machine with no WMIC, `-nogui`
+  surviving the new reader, an unreadable command line still counting as an
+  instance, a row where only the process name survives, WMIC still winning
+  where it exists, an empty answer ending the chain rather than falling
+  through, a broken reader falling through, no reader at all staying
+  undeterminable, and the two parsing edges (a command line containing tabs, a
+  non-numeric pid).
+- **Not verified on Windows hardware by this project — there is none here.**
+  The WMIC absence, the `FileNotFoundError` it raises inside the server's own
+  venv, and the access-restricted row shape were all measured by @Nikibakht on
+  Windows 11 Pro build 26200. The local half is the unit coverage above, run
+  against a faked process spawn.
+- One thing remains **untested by anyone**: an actual Resolve running elevated
+  or under a different Windows account. The reporter runs it as the same
+  unelevated user and said so rather than guessing; the access-restricted row
+  shape above is a proxy measured on other processes in that same access
+  class. The fallback is written so that it costs nothing if that case never
+  arises.
+
 ## What's New in v2.218.0 — native Resolve 21.1 transition creation
 
 Contributed by @legionsound (#209), live-validated on Studio 21.1.0.14.

package/README.md

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

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.218.0"
+VERSION = "2.218.1"
 # 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.218.0",
+  "version": "2.218.1",
   "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.218.0"
+VERSION = "2.218.1"
 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 368-tool granular server instead
 """
 
-VERSION = "2.218.0"
+VERSION = "2.218.1"
 
 import base64
 import os

package/src/utils/resolve_runtime.py

@@ -96,6 +96,91 @@ def _split_pid(line: str, index: int):
     return -(index + 1), line
 
 
+def _windows_wmic_rows(stdout: str) -> List[Dict[str, Optional[str]]]:
+    """WMIC prints one command line per row, under a `CommandLine` header.
+
+    The header row and WMIC's blank padding rows are left in rather than
+    filtered: they are not Resolve command lines, so the executable match
+    drops them, and a second filter here would be a second place for that
+    decision to drift. There is no pid column to read, so pids are synthetic
+    and negative — they exist only to key the row, never to name a process.
+    """
+    return [{"pid": -(index + 1), "comm": None, "args": line}
+            for index, line in enumerate(stdout.splitlines())]
+
+
+def _windows_cim_rows(stdout: str) -> List[Dict[str, Optional[str]]]:
+    """`ProcessId`, `ExecutablePath` and `CommandLine`, tab-separated per row.
+
+    Four columns rather than the command line alone, because they fail
+    independently exactly as they do on POSIX. Measured on build 26200 by the
+    reporter of #210, querying as an unelevated user: for a process the caller
+    cannot fully read, CIM still returns the row with `ProcessId` and `Name`
+    populated and `CommandLine` NULL — the *column* is access-restricted, not
+    the row. Reading only the command line would turn such an instance into no
+    row at all: an empty list, which does not mean "undeterminable", it means
+    "nothing is running", and that is the answer that launches a second
+    Resolve on top of a live one.
+
+    `Name` rather than `ExecutablePath` alone is the reason this holds. That
+    measurement showed `Name` surviving the access restriction; it did not
+    show `ExecutablePath` surviving it, and for a protected process that field
+    is commonly empty too. So the executable column falls back to the bare
+    process name, which `RESOLVE_PROCESS_PATTERNS` already matches — enough to
+    prove an instance is up, while the mode stays honestly unknown, since
+    `-nogui` is only ever visible in the command line.
+
+    Split at most three times: a command line may itself contain tabs, and it
+    is the last field, so everything after the third separator belongs to it.
+    """
+    rows: List[Dict[str, Optional[str]]] = []
+    for index, line in enumerate(stdout.splitlines()):
+        if not line.strip():
+            continue
+        fields = line.split("\t", 3)
+        fields += [""] * (4 - len(fields))
+        try:
+            pid = int(fields[0].strip())
+        except ValueError:
+            pid = -(index + 1)
+        rows.append({"pid": pid,
+                     "comm": fields[2].strip() or fields[1].strip() or None,
+                     "args": fields[3].strip() or None})
+    return rows
+
+
+#: PowerShell equivalent of the WMIC query, emitting the four columns above.
+#: The output encoding is forced because the default console codepage mangles
+#: a non-ASCII install path before Python ever sees it.
+_CIM_COMMAND = (
+    "[Console]::OutputEncoding=[Text.Encoding]::UTF8; "
+    "Get-CimInstance Win32_Process -Filter \"name='Resolve.exe'\" | "
+    "ForEach-Object { \"$($_.ProcessId)`t$($_.Name)`t$($_.ExecutablePath)`t$($_.CommandLine)\" }"
+)
+
+#: Readers for the Windows process table, tried in order until one answers.
+#:
+#: WMIC first, so a machine that still has it behaves exactly as it did before
+#: — but **WMIC was removed in Windows 11 build 26200** and is neither on PATH
+#: nor at its old System32\wbem location, so on current Windows it raises
+#: FileNotFoundError and every tool refused with "Resolve is not running"
+#: while Resolve sat in front of the user (#210). Keeping the old reader first
+#: costs nothing precisely because absence fails instantly rather than burning
+#: the timeout. Windows PowerShell 5.1 ships with Windows; `pwsh` is the
+#: cross-platform 7.x binary, tried last for a machine that has only that one.
+#:
+#: `None` is returned only when NO reader ran. A reader that ran and found
+#: nothing returns an empty list, which is a different answer.
+WINDOWS_PROCESS_READERS = (
+    (["wmic", "process", "where", "name='Resolve.exe'", "get", "CommandLine"],
+     _windows_wmic_rows),
+    (["powershell", "-NoProfile", "-NonInteractive", "-Command", _CIM_COMMAND],
+     _windows_cim_rows),
+    (["pwsh", "-NoProfile", "-NonInteractive", "-Command", _CIM_COMMAND],
+     _windows_cim_rows),
+)
+
+
 def _process_table() -> Optional[List[Dict[str, Optional[str]]]]:
     """One row per process: `{pid, comm, args}`, or None when undeterminable.
 
@@ -113,27 +198,28 @@ def _process_table() -> Optional[List[Dict[str, Optional[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.
+        # The readers below do print it, which is what makes headless
+        # detection possible on Windows at all.
         #
         # 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.
-        try:
-            out = subprocess.run(
-                ["wmic", "process", "where", "name='Resolve.exe'", "get", "CommandLine"],
-                capture_output=True, text=True, encoding="utf-8", errors="replace",
-                timeout=10, check=False,
-            )
-        except Exception:  # pragma: no cover - defensive; an unknown answer is None
-            return None
-        if out.returncode != 0 and not out.stdout:
-            return None
-        return [{"pid": -(i + 1), "comm": None, "args": line}
-                for i, line in enumerate((out.stdout or "").splitlines())]
+        # feeds is unchanged; what these readers emit for a non-ASCII install
+        # path on a non-English Windows is not something we can verify here.
+        for reader, parse in WINDOWS_PROCESS_READERS:
+            try:
+                out = subprocess.run(
+                    reader, capture_output=True, text=True, encoding="utf-8",
+                    errors="replace", timeout=10, check=False,
+                )
+            except Exception:
+                continue  # this reader is unusable here; try the next one
+            if out.returncode != 0 and not (out.stdout or "").strip():
+                continue
+            return parse(out.stdout or "")
+        return None
 
     comm_lines = _run_ps("pid=,comm=")
     args_lines = _run_ps("pid=,args=")