davinci-resolve-mcp 2.97.5 → 2.97.7

package/CHANGELOG.md

@@ -2,6 +2,109 @@
 
 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.97.7
+
+**`grab_and_export` deleted files it never created.** Reported in
+[#151](https://github.com/samuelgursky/davinci-resolve-mcp/issues/151).
+
+### Fixed
+
+- **The cleanup step removed a directory diff, not the export.** It listed the
+  caller's folder before the export and again after, and treated the difference
+  as "what this call produced" — so anything that appeared in that window was
+  attributed to the call, inlined into the response, and deleted: a background
+  render, a file copy, a cloud sync, or a second `grab_and_export`. It then
+  finished with `os.rmdir(folder_path)`, removing a directory the caller had
+  chosen and this server had not created.
+
+  `_resolve_safe_dir` made the overlap concrete rather than theoretical. Every
+  sandbox/temp path is redirected to one shared `~/Documents/resolve-stills`,
+  which is also the folder the documented `/tmp/...` examples land in, so two
+  calls aimed at different temp folders arrived in the same place and each swept
+  up the other's output.
+
+  The export now goes to a private staging directory created inside
+  `folder_path` for that one call, so what it produced is known by construction
+  instead of inferred. Cleanup removes that directory and nothing else;
+  `folder_path` is removed only when this call created it and left it empty. A
+  folder the caller already had is theirs, empty or not. With `cleanup: false`
+  the files move up into `folder_path` under a non-colliding name rather than
+  overwriting a still already sitting there — Resolve numbers stills per export,
+  so a second call collides with the first by default.
+
+  Deletion is now confined to one helper that refuses any path it did not name,
+  which is the property that was missing: the old code path could be handed the
+  caller's folder and delete its contents.
+
+  The inlining half matters too. A file that was never ours was read into the
+  response, so an unrelated document sitting in the export folder could reach an
+  assistant's context. Only staged files are read now.
+
+### Added
+
+- `tests.test_gallery_still_export_cleanup` runs the action against a real temp
+  filesystem with a fake album that writes the way Resolve does, because the
+  defect was in what the filesystem looked like afterwards, not in any return
+  value: a bystander file written *during* the export must survive and must not
+  appear inlined; a pre-existing folder must not be removed; a folder the call
+  created must still be cleaned up; `cleanup: false` must not overwrite; and no
+  staging directory may survive any exit path, including the two early error
+  returns. All fail on 2.97.6.
+
+## What's New in v2.97.6
+
+**On Windows the server could not see the Resolve it was driving.** Reported in
+[#150](https://github.com/samuelgursky/davinci-resolve-mcp/issues/150) with the
+root cause traced, the fix proposed, and a case table — all of it correct.
+
+### Fixed
+
+- **`runtime_mode` reported `running: false, instances: 0` on every stock
+  Windows install.** WMIC wraps a command line in double quotes when the
+  executable path contains spaces, which the default install path always does
+  (`"C:\Program Files\Blackmagic Design\DaVinci Resolve\Resolve.exe"`). The
+  line therefore *ends* with `"`, and `_is_resolve_command()` required it to end
+  with `Resolve.exe`. The trailing-flag stripper above the test did not help: it
+  removes ` -flag` tokens and leaves the closing quote as the final character.
+  A leading quote is now read for what it is — the executable is what sits
+  inside the first quoted span, and everything after the closing quote is
+  arguments. That also tightens rejection: `"…\cmd.exe" /c start … Resolve.exe`
+  is a launcher, not an instance.
+
+  The reading was the visible half. The consequential half is that
+  `get_resolve()` asks this same question before auto-launching, precisely so a
+  failed connect to a live Resolve does not open a second application — the
+  guard whose comment records being "reported three times before it was
+  traced". On Windows its input was a permanent `False`, so the path it exists
+  to block was open: connect fails (modal dialog, mid-launch, scripting toggled
+  off) → "nothing is running" → launch a second Resolve. `_not_connected_error()`
+  reads the same signal, so a Windows user whose Resolve *was* running got the
+  "not running, auto-launch failed, check your Studio install" text instead of
+  the preference or bridge fix that actually applied. `headless` was
+  unreachable too — it is only computed once something is found running, so
+  `-nogui` instances were indistinguishable on Windows.
+
+- **A successful install ended in a traceback under a redirected stdout.** The
+  installer prints box-drawing and check-mark glyphs. A Windows console carries
+  them, but redirecting stdout falls back to the locale code page — cp1252 by
+  default — and `print(f"  {'─' * 50}")` in the summary raised
+  `UnicodeEncodeError` after every client had already been configured, so a
+  working run looked like a failed one
+  (`npx davinci-resolve-mcp setup --clients manual 2>&1 | tail`). Streams that
+  cannot encode those glyphs are now reconfigured to UTF-8 with
+  `errors="replace"`; a console that can already carry them is left alone
+  rather than re-encoded underneath the user.
+
+### Added
+
+- `tests.test_headless_runtime` covers the quoted Windows command line —
+  bare, trailing-whitespace (what WMIC actually prints), and `-nogui` — plus
+  the quoted-launcher line that must still be rejected, so the fix cannot
+  become a substring test by another route. `tests.test_cdl_and_install_config`
+  gains `ConsoleEncodingTests`, including a child interpreter run with
+  `PYTHONIOENCODING=cp1252` and a piped stdout: the exact shape of the reported
+  failure. Both suites fail on the pre-fix code.
+
 ## What's New in v2.97.5
 
 **`npm ci` was failing outright, and nothing in the release path noticed.**

package/README.md

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

package/docs/SKILL.md

@@ -1637,6 +1637,11 @@ Key actions:
   Returns `{files, format, folder, cleaned_up}` where each file entry includes
   `data_base64` for image files and `data` (text) for `.drx` grade files.
   `cleanup` defaults to `true` — files are deleted from disk after being inlined.
+  Only files this call produced are removed: the export goes to a private
+  staging directory inside `folder_path`, so anything else written there
+  meanwhile is untouched, and `folder_path` itself is removed only if the call
+  created it and left it empty. With `cleanup: false` the files are moved up
+  into `folder_path` without overwriting anything already there.
   Requires Color page with Gallery panel visible.
 - `delete_stills(still_indices)`
 

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.97.5"
+VERSION = "2.97.7"
 # 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
@@ -46,6 +46,42 @@ VERSION = "2.97.5"
 SUPPORTED_PYTHON_MIN = (3, 10)
 PYTHON_ABI_RISK_MIN = (3, 13)
 
+# ─── Console encoding ─────────────────────────────────────────────────────────
+# This installer prints box-drawing and check-mark glyphs. On Windows a console
+# stdout carries them fine, but a *redirected* stdout falls back to the locale
+# code page — cp1252 on a default Windows install — and the first '─' raises
+# UnicodeEncodeError. It fires at the summary, after every client is already
+# configured, so a successful install ends in a traceback and reads as a failed
+# run. Reported in #150 against
+# `npx davinci-resolve-mcp setup --clients manual 2>&1 | tail`.
+#
+# Only streams that cannot already carry the glyphs are touched, so a correctly
+# configured console keeps its own encoding. 'replace' is belt-and-braces: no
+# output path is worth a traceback.
+
+_GLYPH_PROBE = "─→✓⊘•"
+
+def _ensure_glyph_capable_stdio():
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        encoding = getattr(stream, "encoding", None)
+        if reconfigure is None or not encoding:
+            continue
+        try:
+            _GLYPH_PROBE.encode(encoding)
+            continue
+        except (LookupError, UnicodeEncodeError):
+            pass
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            try:
+                reconfigure(errors="replace")
+            except Exception:
+                pass
+
+_ensure_glyph_capable_stdio()
+
 # ─── Colors (disabled on Windows cmd without ANSI support) ────────────────────
 
 def _supports_color():

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.97.5",
+  "version": "2.97.7",
   "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.97.5"
+VERSION = "2.97.7"
 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.97.5"
+VERSION = "2.97.7"
 
 import base64
 import os
@@ -1289,6 +1289,50 @@ def _resolve_safe_dir(path):
         return os.path.join(os.path.expanduser("~"), "Documents", "resolve-stills")
     return path
 
+#: Prefix of the private per-call directory `gallery_stills(grab_and_export)`
+#: exports into. Named so that the only thing this server ever deletes is a
+#: directory it created itself, in this call, for this purpose. Deliberately not
+#: a dot-directory: Resolve's still exporter is particular about where it will
+#: write (see `_resolve_safe_dir`, which exists because it fails silently into
+#: sandbox paths), and an ordinary subdirectory is the least exotic thing to
+#: hand it.
+STILL_STAGING_PREFIX = "resolve-mcp-still-"
+
+
+def _discard_still_staging(staging: str) -> None:
+    """Remove a still-export staging directory, and refuse anything else.
+
+    The name check is not ceremony. The step it replaces removed whatever the
+    before/after diff of the caller's folder happened to show, and then removed
+    the folder itself — so this helper is the one place a delete can happen, and
+    it declines any path that is not a directory this server named. See #151.
+    """
+    if not staging or not os.path.basename(staging).startswith(STILL_STAGING_PREFIX):
+        return
+    if not os.path.isdir(staging):
+        return
+    shutil.rmtree(staging, ignore_errors=True)
+
+
+def _unused_path(path: str) -> str:
+    """`path`, or the first `name_1.ext`, `name_2.ext`… that does not exist yet.
+
+    Used when moving exported stills into the caller's folder: a still named
+    like one already sitting there is a collision to step around, not a file to
+    overwrite.
+    """
+    import uuid
+
+    if not os.path.exists(path):
+        return path
+    stem, ext = os.path.splitext(path)
+    for n in range(1, 1000):
+        candidate = f"{stem}_{n}{ext}"
+        if not os.path.exists(candidate):
+            return candidate
+    return f"{stem}_{uuid.uuid4().hex}{ext}"
+
+
 # Error envelope categories (agentic-flow improvements A1/D1) — see the retryable
 # default policy. Lock these names; downstream agents and tests route on them.
 ERROR_CATEGORIES = (
@@ -25253,7 +25297,12 @@ def gallery_stills(action: str, params: Optional[Dict[str, Any]] = None) -> Dict
     keeping the live GalleryStill reference (more reliable than separate grab + export).
     Requires Color page. Automatically produces a companion .drx grade file.
     File data is inlined in the response (DRX as text, images as base64).
-    cleanup (default true) deletes exported files from disk after inlining.
+    cleanup (default true) deletes the exported files after inlining. Only files
+    this call produced are ever removed: the export goes to a private staging
+    directory inside folder_path, so anything else written there meanwhile is
+    untouched, and folder_path itself is removed only if this call created it
+    and left it empty. With cleanup false the files are moved up into
+    folder_path without overwriting anything already there.
     """
     p = _params(params)
     _, proj, err = _check()
@@ -25302,31 +25351,53 @@ def gallery_stills(action: str, params: Optional[Dict[str, Any]] = None) -> Dict
             return _err("No stills to export")
         return {"success": bool(album.ExportStills(stills, p["folder_path"], p.get("prefix", "still"), p.get("format", "dpx")))}
     elif action == "grab_and_export":
-        import time, os
+        import time, os, shutil, uuid
         folder_path = p.get("folder_path")
         if not folder_path:
             return _err("folder_path is required")
         prefix = p.get("prefix", "still")
         fmt = p.get("format", "dpx")
         delete_after = p.get("delete_after", True)
+        cleanup = p.get("cleanup", True)
         # Redirect sandbox/temp paths that Resolve can't access
         folder_path = _resolve_safe_dir(folder_path)
+        folder_pre_existed = os.path.isdir(folder_path)
         os.makedirs(folder_path, exist_ok=True)
-        # Snapshot directory before export
-        before = set(os.listdir(folder_path))
+        # Export into a private staging directory instead of straight into
+        # folder_path, so "what this call produced" is known by construction.
+        #
+        # It used to be a before/after diff of folder_path, which is not the
+        # same question: anything that appeared in that folder during the export
+        # window — a background render, a copy, a cloud sync, a second
+        # grab_and_export — was attributed to this call, inlined into the
+        # response, and then deleted by the cleanup step. `_resolve_safe_dir`
+        # makes that concrete rather than theoretical: every sandbox/temp path
+        # is redirected to the one shared ~/Documents/resolve-stills folder, so
+        # two overlapping calls each swept up the other's output. The old
+        # cleanup also finished with `os.rmdir(folder_path)`, removing a
+        # directory the caller had chosen and this server did not create.
+        # Reported in #151.
+        #
+        # A staging directory is inside folder_path on purpose: same volume and
+        # same permissions, so if Resolve can export to folder_path it can
+        # export here, and the finished files move up with a rename.
+        staging = os.path.join(folder_path, f"{STILL_STAGING_PREFIX}{uuid.uuid4().hex}")
+        os.makedirs(staging)
         # Grab still — requires Color page with a clip under the playhead
         _, tl, err2 = _get_tl()
         if err2:
+            _discard_still_staging(staging)
             return err2
         still = tl.GrabStill()
         if not still:
+            _discard_still_staging(staging)
             return _err("GrabStill failed — ensure Color page is active with a clip under the playhead")
         time.sleep(0.5)
         # Export using the live still reference with format fallback chain
         export_ok = False
         used_format = fmt
         for try_fmt in [fmt, "tif", "dpx"]:
-            result = album.ExportStills([still], folder_path, prefix, try_fmt)
+            result = album.ExportStills([still], staging, prefix, try_fmt)
             if result:
                 export_ok = True
                 used_format = try_fmt
@@ -25336,15 +25407,19 @@ def gallery_stills(action: str, params: Optional[Dict[str, Any]] = None) -> Dict
         if delete_after:
             album.DeleteStills([still])
         if not export_ok:
+            _discard_still_staging(staging)
             return _err("ExportStills failed — ensure the Gallery panel is open on the Color page (Workspace > Gallery)")
         # Wait for filesystem
         time.sleep(0.3)
-        # Find new files
-        after = set(os.listdir(folder_path))
-        new_files = sorted(after - before)
+        try:
+            exported = sorted(os.listdir(staging))
+        except OSError:
+            exported = []
         file_details = []
-        for f in new_files:
-            fpath = os.path.join(folder_path, f)
+        for f in exported:
+            fpath = os.path.join(staging, f)
+            if not os.path.isfile(fpath):
+                continue
             entry = {"name": f, "path": fpath, "size": os.path.getsize(fpath)}
             # Inline file data so cleanup can safely remove files
             try:
@@ -25361,20 +25436,30 @@ def gallery_stills(action: str, params: Optional[Dict[str, Any]] = None) -> Dict
             except OSError:
                 pass
             file_details.append(entry)
-        # Cleanup: remove exported files now that data is inlined (default: True)
-        cleanup = p.get("cleanup", True)
         if cleanup:
-            for f in file_details:
+            # Only the staging directory is removed, and only ever the files
+            # this call put in it. folder_path is left alone unless this call
+            # created it and it is still empty — a folder the caller already had
+            # is theirs, empty or not.
+            _discard_still_staging(staging)
+            if not folder_pre_existed:
                 try:
-                    os.remove(f["path"])
+                    if os.path.isdir(folder_path) and not os.listdir(folder_path):
+                        os.rmdir(folder_path)
                 except OSError:
                     pass
-            # Remove the directory if empty
-            try:
-                if os.path.isdir(folder_path) and not os.listdir(folder_path):
-                    os.rmdir(folder_path)
-            except OSError:
-                pass
+        else:
+            # Keeping the files: move them up into the folder the caller asked
+            # for, never overwriting something already there.
+            for entry in file_details:
+                dest = _unused_path(os.path.join(folder_path, entry["name"]))
+                try:
+                    shutil.move(entry["path"], dest)
+                except OSError:
+                    continue
+                entry["name"] = os.path.basename(dest)
+                entry["path"] = dest
+            _discard_still_staging(staging)
         return {"files": file_details, "format": used_format, "folder": folder_path, "cleaned_up": cleanup}
     elif action == "delete_stills":
         stills = album.GetStills() or []

package/src/utils/resolve_runtime.py

@@ -83,8 +83,13 @@ def _process_lines() -> Optional[List[str]]:
         return None
 
 
+def _matches_pattern(executable: str) -> bool:
+    """Does this bare executable path name a Resolve application?"""
+    return any(executable.endswith(pattern) for pattern in RESOLVE_PROCESS_PATTERNS)
+
+
 def _is_resolve_command(line: str) -> bool:
-    """Is this command line a Resolve *executable*, not merely a mention of one?
+    r"""Is this command line a Resolve *executable*, not merely a mention of one?
 
     A plain substring test matches any process whose command line happens to
     contain the path — including a shell running a script that references it.
@@ -96,8 +101,22 @@ def _is_resolve_command(line: str) -> bool:
     flags. So strip trailing flag tokens and require what remains to *end* with
     the pattern. That survives the spaces in "DaVinci Resolve.app" (no splitting
     on whitespace) while rejecting a path buried mid-command.
+
+    Windows quotes that path. WMIC prints the executable wrapped in double
+    quotes whenever it contains spaces, which the default install path always
+    does (`"C:\Program Files\Blackmagic Design\DaVinci Resolve\Resolve.exe"`),
+    so the line ends in `"` and `endswith("Resolve.exe")` was false on every
+    stock Windows machine — `runtime_mode` reported nothing running while the
+    same server was driving that very instance, and the second-instance guard
+    in `get_resolve()` lost its input. Reported in #150. A leading quote means
+    the executable is exactly what sits inside the first quoted span; anything
+    after the closing quote is arguments, and the flag loop never sees it.
     """
     text = line.strip()
+    if text.startswith('"'):
+        close = text.find('"', 1)
+        if close > 1:
+            return _matches_pattern(text[1:close])
     while True:
         stripped = text.rstrip()
         cut = stripped.rfind(" -")
@@ -109,7 +128,7 @@ def _is_resolve_command(line: str) -> bool:
         if not candidate:
             break
         text = candidate
-    return any(text.endswith(pattern) for pattern in RESOLVE_PROCESS_PATTERNS)
+    return _matches_pattern(text)
 
 
 def resolve_processes() -> Optional[List[str]]: