davinci-resolve-mcp 2.98.2 → 2.98.4

package/CHANGELOG.md

@@ -2,6 +2,132 @@
 
 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.4
+
+**Setup reported success over an install that could never work.** Reported and
+fixed in [#154](https://github.com/samuelgursky/davinci-resolve-mcp/pull/154) by
+@DadManBlues, from a DaVinci Resolve Studio 21.0.4 install on `F:\Blackmagic
+Design\DaVinci Resolve` (Windows 11). The chain: `RESOLVE_PATHS["Windows"]["lib"]`
+held a single hardcoded `C:\Program Files\...` candidate, so `find_resolve_paths()`
+returned `lib_path=None`; `build_server_env()` wrote that out as
+`"RESOLVE_SCRIPT_LIB": ""`, which reads as configured in the config file but is
+falsy to the loader, so it fell back to the same missing path; the connection
+check then failed with `DLL load failed` in the middle of the output, and the
+installer's last line said `Setup complete!`. Every tool afterwards failed with
+`SCRIPTING_UNAVAILABLE`, whose remediation pointed at the Resolve edition and the
+External-scripting preference — both already correct.
+
+### Fixed
+
+- **Resolve is now found outside the default install location.**
+  `resolve_runtime.running_resolve_lib()` derives the scripting library from the
+  running Resolve's own image path, which needs no guessing on any platform, and
+  `platform.discover_scripting_lib()` covers cold installs: `%PROGRAMFILES%` /
+  `%PROGRAMW6432%` / `%PROGRAMFILES(X86)%` plus the existing drive letters on
+  Windows (two fixed paths each, no directory walk), both bundle locations on
+  macOS — the App Store build installs to `/Applications/DaVinci Resolve.app`
+  rather than `/Applications/DaVinci Resolve/DaVinci Resolve.app`, the same class
+  of miss — and the `/opt/resolve` layouts on Linux. Discovery runs only when the
+  platform default is absent and no usable env override exists, and the default
+  is kept when discovery finds nothing, so the error message still names the
+  location people expect.
+- **Empty environment values are omitted rather than written.**
+  `build_server_env()` no longer emits `"RESOLVE_SCRIPT_LIB": ""`.
+- **A failed verification is no longer reported as success.** The `Library: Not
+  found (optional — API path is sufficient)` line was wrong and is corrected; a
+  DLL-load failure is diagnosed explicitly, naming the current
+  `RESOLVE_SCRIPT_LIB`, before the Python 3.13+ ABI theory; and setup ends in
+  `Setup incomplete — the scripting API did not load.`, still listing any configs
+  it wrote and marking them non-functional.
+
+### Fixed in follow-up review
+
+- **The no-clients branch still printed `Environment ready!`** over a failed
+  verification, and **`main()` returned `None` either way**, so
+  `npx davinci-resolve-mcp setup` in a script or CI saw exit status 0 over a dead
+  install — the same lie as `Setup complete!`, one block further down. The
+  summary line and the exit status now agree.
+- **Two bare `except Exception` fallbacks narrowed to `ImportError`.** A defect
+  raised inside `running_resolve_lib()` or `discover_scripting_lib()` would have
+  been laundered into "nothing found" and the caller would have gone on to report
+  the platform default — this repo's recurring silent-fallback bug class.
+- **`_windows_lib_candidates` docstring corrected.** It claimed only fixed drives
+  are probed (there is no `GetDriveTypeW` check, so a connected network drive is
+  probed too) and that it runs on every connection attempt (`get_resolve_paths()`
+  is import-time, so the real cost is one `ps`/`wmic` spawn at server startup, and
+  only when the default is already missing).
+
+### Tests
+
+`tests/test_scripting_lib_discovery.py` (21 cases): library derivation on Windows
+and macOS layouts, WMIC-quoted command lines, the three `None` paths, the
+per-platform candidate lists, override-beats-discovery precedence, the surviving
+platform default, the omitted empty key, both reporting behaviours, and the exit
+status in all three of its states. The `GetResolvePathsDiscoveryTests` cases force
+the platform default absent — without that they check nothing on a machine where
+Resolve *is* at the default path, and on macOS they fail outright; neither the
+Linux CI box nor the Windows machine that prompted the fix shows it, because on
+both the default is already missing for real.
+
+## What's New in v2.98.3
+
+**`fusion_comp` could never delete a Fusion keyframe.** Reported in
+[#155](https://github.com/samuelgursky/davinci-resolve-mcp/issues/155) by
+@Andrei-59, with the root cause already identified: the handler called a method
+that does not exist. The diagnosis was correct, and the suggested replacement is
+confirmed here against a live build.
+
+### Fixed
+
+- **`delete_keyframe` called `RemoveKeyFrame()` on a Fusion Input.** No such
+  method exists there. Keyframes do not live on the Input — they live on the
+  spline modifier connected to it, which is what `add_keyframe` attaches via
+  `AddModifier(input_name, "BezierSpline")`. The action now reaches that spline
+  through `inp.GetConnectedOutput().GetTool()` and calls `DeleteKeyFrames(time)`
+  on it. Introduced with the tool in v2.1.0 and broken for every input, every
+  frame, and every tool since; there is no version of the server in which it
+  worked.
+
+- **The failure surfaced as `'NoneType' object is not callable`.** The
+  fusionscript bridge resolves an unknown attribute to `None` instead of raising
+  `AttributeError`, so the bad lookup succeeded silently and only died at the
+  callsite — an error naming neither the method nor the object. Every branch of
+  the action now returns the normal error envelope: `FUSION_INPUT_NOT_ANIMATED`
+  when the input has no modifier, `FUSION_KEYFRAME_NOT_FOUND` when nothing is
+  keyed at that frame (the frame list is included in `state`),
+  `FUSION_DELETE_KEYFRAMES_UNSUPPORTED` when the modifier has no removal method,
+  and `INVALID_FRAME` for a non-numeric `time`. The existing `_has_method` guard
+  — which exists precisely for this silent-`None` class — is applied before the
+  call rather than after it.
+
+- **Success is verified by readback, not by the return value.** Live testing
+  showed `DeleteKeyFrames()` returns `None` whether or not it removed anything,
+  so trusting the return would have reported failure on every successful
+  delete — and trusting the absence of an exception would have reported success
+  on every silent no-op. The handler re-reads the keyframe list and returns
+  `FUSION_DELETE_KEYFRAME_NOOP` if the frame is still there. On success it
+  returns `{success, time, remaining_keyframes}`.
+
+### Testing
+
+- `tests/test_fusion_comp_targeting.py` gains eleven `delete_keyframe` cases,
+  including a regression test that models the bridge's silent-`None` attribute
+  lookup and asserts the handler never reaches for `RemoveKeyFrame` on the
+  Input. The action previously had no test coverage at all.
+- `tests/live_fusion_delete_keyframe_validation.py` is a new self-contained live
+  harness: it creates a scratch project, inserts a Fusion composition clip (no
+  media needed), and reports which keyframe methods the Input and the spline
+  actually expose before asserting the delete.
+
+### Verified live
+
+Validated on **DaVinci Resolve Studio 19.1.3.7** (macOS). `RemoveKeyFrame`
+confirmed absent on the Input and resolving to `None`; `DeleteKeyFrames`
+confirmed present on the `BezierSpline` and confirmed to remove the key. The
+reporter's exact reproduction — `add_keyframe` then `delete_keyframe` on the
+same tool/input/frame — was run end-to-end through the patched handler and
+succeeds. Not re-verified on Studio 21.0.4.5, the reporter's build.
+
 ## What's New in v2.98.2
 
 **A tool installed next to the server was invisible to it.** Reported in

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.98.2-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.98.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-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.2-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.98.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-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.2 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.98.4 版 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.98.2"
+VERSION = "2.98.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
@@ -284,6 +284,24 @@ def find_resolve_paths():
             lib_path = expanded
             break
 
+    if lib_path is None:
+        # The literal candidates above only cover a default install. An explicit
+        # override wins outright; failing that, ask where Resolve actually is.
+        # Skipping this is what wrote an empty RESOLVE_SCRIPT_LIB into working
+        # configs and left the server importing a DLL that was never there.
+        env_lib = os.environ.get("RESOLVE_SCRIPT_LIB")
+        if env_lib and os.path.isfile(env_lib):
+            lib_path = env_lib
+        else:
+            # Narrow except: an ImportError here means the helper is absent,
+            # which is a real answer. Anything else raised *inside* discovery is
+            # a defect and must not be laundered into "no library found".
+            try:
+                from src.utils.platform import discover_scripting_lib
+            except ImportError:
+                discover_scripting_lib = None
+            lib_path = discover_scripting_lib() if discover_scripting_lib else None
+
     return api_path, lib_path
 
 
@@ -520,7 +538,14 @@ def get_python_base_install(python_path):
 
 
 def build_server_env(python_path, api_path, lib_path, system=SYSTEM, python_home=None):
-    """Build the env block used by all generated stdio MCP configs."""
+    """Build the env block used by all generated stdio MCP configs.
+
+    Keys whose value is empty are omitted rather than written as "". An empty
+    `RESOLVE_SCRIPT_LIB` is worse than an absent one: it reads as configured in
+    the config file, while `DaVinciResolveScript.py` treats it as unset and
+    silently reverts to its own hardcoded install path — so a machine with
+    Resolve elsewhere fails with a DLL-load error that names nothing useful.
+    """
     api_value = str(api_path or "")
     lib_value = str(lib_path or "")
     env = {
@@ -528,6 +553,7 @@ def build_server_env(python_path, api_path, lib_path, system=SYSTEM, python_home
         "RESOLVE_SCRIPT_LIB": lib_value,
         "PYTHONPATH": str(Path(api_value) / "Modules") if api_value else "",
     }
+    env = {key: value for key, value in env.items() if value}
 
     if system == "Windows":
         env["PYTHONHOME"] = str(python_home or get_python_base_install(python_path))
@@ -1921,7 +1947,13 @@ def main():
     if lib_path:
         print(f"  Library:   {green(lib_path)}")
     else:
-        print(f"  Library:   {yellow('Not found')} {dim('(optional — API path is sufficient)')}")
+        # Not optional, whatever this line used to claim: DaVinciResolveScript
+        # is a thin wrapper that loads this binary, so without it every tool
+        # fails at import. Saying "API path is sufficient" here sent people
+        # looking at their Resolve edition and their preferences instead.
+        print(f"  Library:   {red('Not found')} {dim('(required — the scripting API cannot load without it)')}")
+        print(f"  {dim('Set RESOLVE_SCRIPT_LIB to the fusionscript library inside your Resolve install,')}")
+        print(f"  {dim('or start Resolve and re-run setup so its location can be read from the process.')}")
 
     resolve_running = check_resolve_running()
     if resolve_running:
@@ -2122,6 +2154,7 @@ def main():
     if interactive:
         print_step(5, total_steps, "Verification")
 
+    verification_failed = False
     if api_path:
         success, message = verify_resolve_connection(python_path, api_path, lib_path)
         try:
@@ -2171,13 +2204,28 @@ def main():
             else:
                 print(f"  Connected: {green(message)}")
         else:
-            print(f"  Verify:    {yellow(message)}")
+            verification_failed = True
+            print(f"  Verify:    {red(message)}")
+            if "DLL load failed" in message or "cannot open shared object" in message:
+                # This is the shape of a wrong or missing library path, and it
+                # is the one failure the installer can diagnose precisely. Say
+                # so before offering the interpreter theory below — a reader who
+                # is told "try another Python" first will go and do that.
+                print(
+                    f"             The scripting library named by RESOLVE_SCRIPT_LIB did not load. "
+                    f"Current value: {lib_path or dim('(not set)')}"
+                )
+                print(
+                    "             Point RESOLVE_SCRIPT_LIB at the fusionscript library inside your "
+                    "Resolve install, or start Resolve and re-run setup."
+                )
             if py_abi_risk:
                 print(
                     f"             On Python 3.13+ this may be an ABI mismatch with Resolve's "
                     f"scripting library — try Python 3.10-3.12 if it persists."
                 )
     else:
+        verification_failed = True
         print(f"  {yellow('Skipped')} — Resolve API path not detected")
 
     # ══════════════════════════════════════════════════════════════════════
@@ -2185,7 +2233,25 @@ def main():
     # ══════════════════════════════════════════════════════════════════════
 
     print(f"\n  {'═' * 50}")
-    if configured or show_manual:
+    if verification_failed and (configured or show_manual):
+        # Writing the configs is not the job; a working connection is. Reporting
+        # "Setup complete!" over a failed verification is how an install that
+        # never worked gets handed to the user as finished — the error scrolls
+        # past mid-output and the last line says success.
+        print(f"  {yellow(bold('Setup incomplete — the scripting API did not load.'))}")
+        if configured:
+            print(f"  Configured: {', '.join(configured)} {dim('(written, but the server will fail to start)')}")
+        print()
+        print(f"  {bold('Fix the verification error above, then re-run:')}")
+        print(f"    {cyan('python install.py')}")
+        print()
+        print(f"  {dim(f'Server: {server_path}')}")
+        print(f"  {dim(f'Python: {python_path}')}")
+        if api_path:
+            print(f"  {dim(f'API:    {api_path}')}")
+        if lib_path:
+            print(f"  {dim(f'Library: {lib_path}')}")
+    elif configured or show_manual:
         print(f"  {green(bold('Setup complete!'))}")
         if configured:
             print(f"  Configured: {', '.join(configured)}")
@@ -2204,18 +2270,32 @@ def main():
         if api_path:
             print(f"  {dim(f'API:    {api_path}')}")
     elif not selected_ids:
-        print(f"  {green(bold('Environment ready!'))}")
-        print(f"  Run {cyan('python install.py --clients all')} to configure MCP clients later.")
+        # Same rule as the configured branch above: a failed verification is
+        # never "ready". Nothing was written here, so the remedy is the error
+        # itself rather than a re-run to fix a config.
+        if verification_failed:
+            print(f"  {yellow(bold('Environment incomplete — the scripting API did not load.'))}")
+            print(f"  {dim('No client configs were written.')}")
+            print()
+            print(f"  {bold('Fix the verification error above, then re-run:')}")
+            print(f"    {cyan('python install.py')}")
+        else:
+            print(f"  {green(bold('Environment ready!'))}")
+            print(f"  Run {cyan('python install.py --clients all')} to configure MCP clients later.")
     else:
         print(f"  {yellow('No clients configured.')}")
         print(f"  Run {cyan('python install.py')} again to retry.")
 
     print()
+    # Exit status has to agree with the summary line above. `npx
+    # davinci-resolve-mcp setup` is run from scripts and CI, where a zero over a
+    # dead install is the same lie as "Setup complete!" was.
+    return 1 if verification_failed else 0
 
 
 if __name__ == "__main__":
     try:
-        main()
+        sys.exit(main() or 0)
     except KeyboardInterrupt:
         print(f"\n\n  {dim('Interrupted.')}\n")
         sys.exit(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.98.2",
+  "version": "2.98.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.98.2"
+VERSION = "2.98.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.98.2"
+VERSION = "2.98.4"
 
 import base64
 import os
@@ -26582,6 +26582,121 @@ def _fusion_set_text_plus(comp, p: Dict[str, Any]) -> Dict[str, Any]:
         comp.Unlock()
 
 
+def _fusion_keyframe_frames(inp) -> List[float]:
+    """Frame positions currently keyed on `inp`, as a sorted list.
+
+    Fusion's `GetKeyFrames()` returns {1-based index: frame_position}; the
+    frames are the VALUES, not the keys. Frames come back as floats.
+    """
+    try:
+        kfs = inp.GetKeyFrames()
+    except Exception:
+        return []
+    if not kfs:
+        return []
+    return sorted(float(frame) for frame in kfs.values())
+
+
+def _fusion_input_spline(inp):
+    """The modifier/spline tool driving `inp`, or None when it is not animated.
+
+    Keyframes do not live on the Input object -- they live on the spline
+    connected to it, which is what `add_keyframe` attaches via AddModifier.
+    """
+    try:
+        connected = inp.GetConnectedOutput()
+    except Exception:
+        return None
+    if connected is None:
+        return None
+    if not _has_method(connected, "GetTool"):
+        return None
+    try:
+        return connected.GetTool()
+    except Exception:
+        return None
+
+
+def _fusion_delete_keyframe(tool, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Remove one keyframe from an animated Fusion input. (issue #155)
+
+    The original implementation called `inp.RemoveKeyFrame(time)`. No such
+    method exists on a Fusion Input, and the fusionscript bridge resolves an
+    unknown attribute to None rather than raising AttributeError -- so the
+    lookup succeeded silently and every call died at the callsite as an opaque
+    `'NoneType' object is not callable`. The action had never worked.
+
+    Deletion happens on the spline, reached the same way `add_keyframe`
+    created it, and every step that can be absent is checked before it is
+    called. The result is verified by reading the keyframe list back, because
+    a Fusion call returning without error is not proof it did anything.
+    """
+    tool_name = p["tool_name"]
+    input_name = p["input_name"]
+    inp = tool[input_name]
+    if not inp:
+        return _err(
+            f"Input '{input_name}' not found on tool '{tool_name}'",
+            code="FUSION_INPUT_NOT_FOUND", category="invalid_input",
+        )
+
+    try:
+        time = float(p["time"])
+    except (TypeError, ValueError):
+        return _err(
+            f"time must be a frame number, got {p['time']!r}",
+            code="INVALID_FRAME", category="invalid_input",
+        )
+
+    spline = _fusion_input_spline(inp)
+    if spline is None:
+        return _err(
+            f"Input '{input_name}' on tool '{tool_name}' is not animated, so it "
+            "has no keyframe to delete",
+            code="FUSION_INPUT_NOT_ANIMATED", category="precondition",
+            remediation="Use add_keyframe first; it attaches the spline that holds keyframes.",
+            state={"tool_name": tool_name, "input_name": input_name},
+        )
+
+    if not _has_method(spline, "DeleteKeyFrames"):
+        return _err(
+            f"The modifier on '{tool_name}.{input_name}' has no DeleteKeyFrames method",
+            code="FUSION_DELETE_KEYFRAMES_UNSUPPORTED", category="unsupported",
+            reason="Only spline modifiers (e.g. BezierSpline) support keyframe removal.",
+            state={"tool_name": tool_name, "input_name": input_name},
+        )
+
+    before = _fusion_keyframe_frames(inp)
+    if not any(abs(frame - time) < 1e-6 for frame in before):
+        return _err(
+            f"No keyframe at frame {time:g} on '{tool_name}.{input_name}'",
+            code="FUSION_KEYFRAME_NOT_FOUND", category="precondition",
+            state={"tool_name": tool_name, "input_name": input_name,
+                   "time": time, "keyframes": before},
+        )
+
+    try:
+        spline.DeleteKeyFrames(time)
+    except Exception as exc:
+        return _err(
+            f"DeleteKeyFrames({time:g}) raised: {exc}",
+            code="FUSION_DELETE_KEYFRAME_FAILED", category="resolve_api_failed",
+            state={"tool_name": tool_name, "input_name": input_name, "time": time},
+        )
+
+    after = _fusion_keyframe_frames(inp)
+    if any(abs(frame - time) < 1e-6 for frame in after):
+        return _err(
+            f"DeleteKeyFrames({time:g}) returned without error but the keyframe "
+            f"is still on '{tool_name}.{input_name}'",
+            code="FUSION_DELETE_KEYFRAME_NOOP", category="resolve_api_failed",
+            state={"tool_name": tool_name, "input_name": input_name,
+                   "time": time, "keyframes_before": before, "keyframes_after": after},
+        )
+
+    return _ok(time=time, remaining_keyframes=after)
+
+
 def _fusion_get_text_plus(comp, p: Dict[str, Any]) -> Dict[str, Any]:
     """Read the text of a Fusion Text+ tool / title template. (issue #73)"""
     tool, err = _fusion_find_text_tool(comp, p)
@@ -26627,7 +26742,9 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
       get_attrs(tool_name) -> {attrs}
       add_keyframe(tool_name, input_name, time, value) -> {success}
       get_keyframes(tool_name, input_name) -> {keyframes}
-      delete_keyframe(tool_name, input_name, time) -> {success}
+      delete_keyframe(tool_name, input_name, time) -> {success, time, remaining_keyframes}
+        Deletes on the spline attached to the input. Structured errors when the
+        input is not animated or has no keyframe at that frame.
       get_comp_info() -> {name, tool_count, attrs}
       get_position(tool_name) -> {tool_name, x, y}  — read a node's FlowView position
       set_position(tool_name, x, y) -> {success, x, y, readback}  — move a node
@@ -26923,11 +27040,7 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
             return _err(f"Tool '{p['tool_name']}' not found")
         comp.Lock()
         try:
-            inp = tool[p["input_name"]]
-            if not inp:
-                return _err(f"Input '{p['input_name']}' not found on tool '{p['tool_name']}'")
-            inp.RemoveKeyFrame(p["time"])
-            return _ok()
+            return _fusion_delete_keyframe(tool, p)
         finally:
             comp.Unlock()
 

package/src/utils/platform.py

@@ -64,6 +64,12 @@ def get_resolve_paths():
     env_lib = os.environ.get("RESOLVE_SCRIPT_LIB")
     if env_lib and os.path.isfile(env_lib):
         lib_path = env_lib
+    elif not os.path.isfile(lib_path):
+        # No usable override and nothing at the default: look for the real
+        # install before handing back a path we already know is not there.
+        # The default is kept as the return value when discovery finds nothing,
+        # so the failure message still names the location people expect.
+        lib_path = discover_scripting_lib(platform_name) or lib_path
 
     return {
         "api_path": api_path,
@@ -71,6 +77,101 @@ def get_resolve_paths():
         "modules_path": modules_path
     }
 
+
+def _windows_lib_candidates():
+    r"""Plausible `fusionscript.dll` locations on this machine.
+
+    `%PROGRAMFILES%` is not a constant — a 64-bit install can sit under
+    `%PROGRAMW6432%` — and Resolve is routinely moved to a second drive
+    because the application and its caches are large. Every drive letter that
+    responds to `isdir` is probed, two fixed paths each, no directory walk;
+    A: and B: are skipped so a machine with a floppy-mapped letter does not
+    stall. No drive-type check is made, so a mapped network drive that happens
+    to be connected is probed too — the cost is bounded (two `isfile` calls)
+    and the alternative is a `GetDriveTypeW` ctypes call for a case that only
+    arises once, on the path where the default was already missing.
+
+    This is reached from `get_resolve_paths()`, which runs at import time, so
+    the real cost is one `ps`/`wmic` spawn at server startup and only when the
+    platform default is absent.
+    """
+    relative = os.path.join("Blackmagic Design", "DaVinci Resolve", "fusionscript.dll")
+    candidates = []
+    for variable in ("PROGRAMFILES", "PROGRAMW6432", "PROGRAMFILES(X86)"):
+        base = os.environ.get(variable)
+        if base:
+            candidates.append(os.path.join(base, relative))
+    for letter in "CDEFGHIJKLMNOPQRSTUVWXYZ":
+        drive = f"{letter}:\\"
+        if not os.path.isdir(drive):
+            continue
+        candidates.append(os.path.join(drive, relative))
+        candidates.append(os.path.join(drive, "Program Files", relative))
+    return candidates
+
+
+def _macos_lib_candidates():
+    """The App Store bundle as well as the installer one.
+
+    The default above names `/Applications/DaVinci Resolve/DaVinci Resolve.app`.
+    The App Store build installs to `/Applications/DaVinci Resolve.app` instead —
+    the same class of miss as a Windows install on another drive, and
+    `resolve_runtime.MACOS_RESOLVE_APPS` already records both.
+    """
+    inside_bundle = os.path.join("Contents", "Libraries", "Fusion", "fusionscript.so")
+    bundles = (
+        "/Applications/DaVinci Resolve/DaVinci Resolve.app",
+        "/Applications/DaVinci Resolve.app",
+    )
+    return [os.path.join(bundle, inside_bundle) for bundle in bundles]
+
+
+def _linux_lib_candidates():
+    """The documented /opt layouts, both of which Blackmagic has shipped."""
+    return [
+        "/opt/resolve/libs/Fusion/fusionscript.so",
+        "/opt/resolve/libs/fusionscript.so",
+        "/opt/resolve/bin/fusionscript.so",
+    ]
+
+
+def discover_scripting_lib(platform_name=None):
+    """Locate the scripting library of a Resolve installed outside the default.
+
+    Order: the running Resolve first — its executable path is the install
+    location, so it needs no guessing and covers every platform — then the
+    conventional roots for that platform, for when Resolve is not up at the
+    moment (installer runs, cold starts).
+
+    Returns None when nothing is found, which leaves the caller's default in
+    place rather than substituting a second guess.
+    """
+    if platform_name is None:
+        platform_name = get_platform()
+
+    # Relative import and a narrow except: this repo has had a run of
+    # silent-fallback bugs, and a bare `except Exception` here would swallow a
+    # real defect inside running_resolve_lib() as "Resolve is not running".
+    try:
+        from .resolve_runtime import running_resolve_lib
+    except ImportError:
+        running_resolve_lib = None
+    running = running_resolve_lib() if running_resolve_lib else None
+    if running and os.path.isfile(running):
+        return running
+
+    by_platform = {
+        'windows': _windows_lib_candidates,
+        'darwin': _macos_lib_candidates,
+        'linux': _linux_lib_candidates,
+    }
+    builder = by_platform.get(platform_name)
+    candidates = builder() if builder else []
+    for candidate in candidates:
+        if os.path.isfile(candidate):
+            return candidate
+    return None
+
 def get_resolve_plugin_paths():
     """Get platform-specific paths for Resolve plugin install dirs.
 

package/src/utils/resolve_runtime.py

@@ -122,11 +122,21 @@ def _is_resolve_command(line: str) -> bool:
     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.
     """
+    return _matches_pattern(_executable_from_line(line))
+
+
+def _executable_from_line(line: str) -> str:
+    """The executable path from a command line, with argument tokens removed.
+
+    Split out of `_is_resolve_command` so the install-location lookup below
+    agrees with the "is this Resolve" test about where the path ends. See that
+    function's docstring for why the quoting and flag-stripping rules are these.
+    """
     text = line.strip()
     if text.startswith('"'):
         close = text.find('"', 1)
         if close > 1:
-            return _matches_pattern(text[1:close])
+            return text[1:close]
     while True:
         stripped = text.rstrip()
         cut = stripped.rfind(" -")
@@ -138,7 +148,7 @@ def _is_resolve_command(line: str) -> bool:
         if not candidate:
             break
         text = candidate
-    return _matches_pattern(text)
+    return text
 
 
 def resolve_processes() -> Optional[List[str]]:
@@ -149,6 +159,52 @@ def resolve_processes() -> Optional[List[str]]:
     return [line for line in lines if _is_resolve_command(line)]
 
 
+#: Where the scripting library sits relative to the Resolve executable. The
+#: library ships *inside* the application, so the running executable's own path
+#: is the only locator that is right by construction — every hardcoded install
+#: root is a guess about where the user chose to put Resolve.
+_LIB_RELATIVE_TO_EXECUTABLE = {
+    "windows": ("fusionscript.dll",),
+    "darwin": ("../Libraries/Fusion/fusionscript.so",),
+    "linux": (
+        "../libs/Fusion/fusionscript.so",
+        "../libs/fusionscript.so",
+        "fusionscript.so",
+    ),
+}
+
+
+def running_resolve_lib() -> Optional[str]:
+    """Scripting library of the *running* Resolve, or None.
+
+    Blackmagic's own `DaVinciResolveScript.py` falls back to one hardcoded
+    install path per platform, and this project's defaults mirror it. A Resolve
+    installed anywhere else — a second drive, an external volume, a custom
+    directory — is therefore invisible to both, and the failure is silent: the
+    module imports, the DLL behind it does not load, and the user is told the
+    edition or the preference is at fault.
+
+    The running process settles it without guessing. Returns None when nothing
+    is running, the process list is unavailable, or the derived path does not
+    exist; callers keep their existing defaults in that case.
+    """
+    processes = resolve_processes()
+    if not processes:
+        return None
+    suffixes = _LIB_RELATIVE_TO_EXECUTABLE.get(platform.system().lower(), ())
+    for line in processes:
+        executable_dir = os.path.dirname(_executable_from_line(line))
+        if not executable_dir:
+            continue
+        for suffix in suffixes:
+            candidate = os.path.normpath(
+                os.path.join(executable_dir, *suffix.split("/"))
+            )
+            if os.path.isfile(candidate):
+                return candidate
+    return None
+
+
 def runtime_mode() -> Dict[str, Any]:
     """`{running, headless, instances, command_lines, determinable}`.