davinci-resolve-mcp 2.69.0 → 2.69.3

package/CHANGELOG.md

@@ -2,6 +2,161 @@
 
 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.69.3
+
+Ships the v2.69.2 bundle, which never reached npm. Same fixes, plus the one that
+stopped it publishing.
+
+### Fixed
+
+- **The offline guard failed the publish workflow instead of guarding it.**
+  `tests/__init__.py` installs the guard before any test module loads, and the
+  guard imports `src.server` — which imports `anyio`. The publish workflow
+  installs only pyflakes, by design: the static drift guards are pure AST
+  readers that deliberately run without the runtime stack. So every module
+  argument raised at import, six of them turned into six `_FailedTest` errors,
+  and the npm publish failed with what looked like six broken guards rather than
+  one missing package.
+
+  This shipped in v2.69.1's tail (the guard moved under `unittest` after that
+  tag was cut), so v2.69.2 was the first release to run it and the first to fail.
+
+  A missing third-party package now skips the swap: if `src.server` cannot be
+  imported there is no live-Resolve entry point to neuter, so the guard is
+  vacuously satisfied. The skip is narrow on purpose — a `ModuleNotFoundError`
+  naming something under `src/`, or any non-import error, still propagates.
+  Swallowing those would leave the static guards silently vacuous, which is a
+  worse failure than the one being fixed since it fails open.
+
+### Added
+
+- `tests/test_offline_guard.py` — five tests, including the two that matter:
+  a broken import inside `src/` must still raise, and a non-import error must
+  never be swallowed. A skip that fails open would be indistinguishable from a
+  passing suite.
+
+### Validation
+
+- Offline suite 2247 → 2252. Reproduced the CI failure locally against an
+  interpreter without `anyio` (six errors before, clean after), rather than
+  inferring it from the workflow log.
+
+## What's New in v2.69.2
+
+Community bug-fix bundle: #100, #101 and #102, plus the installer half of #104.
+The headline is that a fresh clone had stopped working entirely.
+
+### Fixed
+
+- **A fresh install produced a server that could not start** (issue #103, PR
+  #101 by @Mastaish). `install.py` installed `mcp[cli]` with no upper bound, and
+  the MCP Python SDK published 2.0.0 — which restructured the package and
+  dropped `mcp.server.fastmcp`, the module `src/server.py` imports. Every clone
+  after that release died at import, surfacing to the user as nothing more
+  informative than "Server disconnected".
+
+  The contributed fix caps the SDK in `requirements.txt`, which `install.py`
+  installs second. That works, but the unpinned first call still downloads 2.x
+  and its `httpx2` tree before downgrading it, and the fix evaporates silently
+  if the install order ever changes — so the cap is now on the `pip install`
+  call as well. `McpSdkPinTest` guards both sites, reading the actual string
+  literals rather than matching text: `install.py` discusses `mcp[cli]` in prose
+  too, and a first cut of that guard was satisfied by a comment. It is
+  conditional on `server.py` still importing `mcp.server.fastmcp`, so it retires
+  itself when the server is ported to the 2.x layout instead of blocking it.
+
+- **The Advanced (Node) suite was not running at all on Node 20+** (PR #102 by
+  @double2tea). `node --test` resolves a bare directory argument as a module
+  entry point on Node 20 and later, so the suite exited with `MODULE_NOT_FOUND`
+  at 4 failures and 0 passes — a shape that reads more like a broken checkout
+  than 731 skipped tests. Explicit test-file globs restore the full run on 18,
+  20 and 22 alike.
+
+- **`RESOLVE_SCRIPT_API` / `RESOLVE_SCRIPT_LIB` were silently overwritten** (PR
+  #100 by @abbc400). `get_resolve_paths()` returned only platform defaults, and
+  `src/server.py` writes those straight back into `os.environ` — so a client
+  that had correctly pointed at a Resolve installed outside `/Applications` had
+  its setting discarded at import. Every other signal looked healthy (Resolve
+  running, external scripting Local, `fuscript` listening) while `scriptapp()`
+  returned `None`. The override now wins, but only when the path exists, so a
+  stale variable cannot shadow a working default install.
+
+- **The bridge installer wrote to a tree Resolve did not read** (issue #104,
+  reported by @RananjayRaj). Which script tree the free App Store build scans is
+  not decidable from outside Resolve: this installer was measured on a machine
+  where the documented Blackmagic Design tree listed, and #104 reports the exact
+  opposite on the same 21.0.3.7 build — the documented tree listed nothing, not
+  even the Lua canary (which rules out the framework-Python explanation and
+  points at the folder), while the Fusion standalone tree listed everything with
+  no restart.
+
+  Rather than pick a winner from two contradictory measurements, both container
+  trees now receive the files, documented path first. This stays inside the
+  sandbox: outside a container that path really is Fusion's own tree and is
+  still not targeted.
+
+- **`--probe-only` reported success on a machine with no Resolve installed**
+  (also #104). A container outlives the app that created it, and the container's
+  existence is precisely what makes the installer target it — so a stale
+  container from an uninstalled Resolve produced a clean success listing files
+  that had genuinely been written and would never be read. The installer now
+  warns when no app bundle can be found, honoring `RESOLVE_APP` as
+  `scripts/doctor.py` already does. It warns rather than refuses: not every
+  legitimate install location can be enumerated, and refusing wrongly would
+  block a working install.
+
+### Validation
+
+- Offline suite 2237 → 2247 (six new installer-target tests, one pin guard).
+  Advanced Node suite 731 tests / 701 pass on Node 18.
+- The new guards were verified to fail against the pre-fix code, not merely to
+  pass against the fix.
+- No DaVinci Resolve scripting behavior changed; the path-resolution change is
+  env-var-gated with defaults unchanged. Live Resolve validation not required.
+
+## What's New in v2.69.1
+
+Bug fix. The Studio bridge differential no longer reports the Deliver page its
+own render probes navigated to as a transport difference.
+
+### Fixed
+
+- **A clean bridge produced a red result on any run that did not start on
+  Deliver.** Run live on Studio 19.1.3.7, the differential reported
+  `resolve.GetCurrentPage` as a `value_mismatch` — bridge `edit`, native
+  `deliver` — and it reproduced on command: start on Edit, one difference; start
+  on Deliver, none. The transport was never involved. The harness's own render
+  probes navigate Resolve to the Deliver page, and the bridge pass runs before
+  the native pass, so the native pass read a page the bridge pass had moved. Read
+  at the same instant the two transports always agreed.
+
+  Adding the method to `VOLATILE_METHODS` would have turned red green and thrown
+  away the signal — a bridge that genuinely reports the wrong page is exactly
+  what this harness exists to catch. Instead each pass now records the page on
+  the way in and on the way out, and the value is compared **only when both
+  passes prove it held still**. If both were stable and the values still
+  disagree, that is the transport, and it is reported as before. A page that
+  cannot be read counts as unknown rather than stable, so an unreadable page
+  disables the comparison instead of quietly restoring the false positive.
+
+  `page_compared_by_value` and both passes' before/after values now ride in the
+  report either way. "The page was not compared" is a fact about the run, and
+  burying it would recreate the silence this fixes.
+
+### Added
+
+- `tests/test_bridge_differential.py` — the module's first tests, 13 of them,
+  including the one that matters: a stable page that genuinely disagrees must
+  still be reported, or the fix is a mute button rather than a fix. The absence
+  of any coverage here is why the false positive shipped.
+
+### Validation
+
+- Static checks and the full unit suite: 2243 → 2256 tests, pyflakes clean.
+- Live Resolve validation on Studio 19.1.3.7 after the fix: 142 probes, 0
+  differences, 110/112 read methods, started from the Edit page that previously
+  failed.
+
 ## What's New in v2.69.0
 
 The free edition is documented as reachable, silence ripple stops clipping

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.69.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.69.3-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-34%20(341%20full)-blue.svg)](#server-modes)

package/install.py

@@ -36,7 +36,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.69.0"
+VERSION = "2.69.3"
 # 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
@@ -796,9 +796,14 @@ def install_dependencies(venv_path, project_dir):
 
     print(f"  Installing dependencies...")
 
-    # Install MCP SDK
+    # Install MCP SDK. The upper bound is load-bearing: SDK 2.0.0 restructured
+    # the package and dropped `mcp.server.fastmcp`, which src/server.py imports.
+    # requirements.txt carries the same constraint, but it is installed second —
+    # pinning here too means we never download 2.x (and its httpx2 tree) only to
+    # downgrade it, and the fix does not depend on install ordering. Lift both
+    # together when server.py is ported to the 2.x layout.
     subprocess.run(
-        [str(pip), "install", "-q", "mcp[cli]"],
+        [str(pip), "install", "-q", "mcp[cli]>=1.29,<2"],
         check=True, capture_output=True
     )
 

package/package.json

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

package/resolve-advanced/package.json

@@ -38,9 +38,9 @@
     "_comment": "audio (split/trim/convert) + conform frame ops need system ffmpeg/ffprobe on PATH (NOT bundled — FFmpeg binaries are GPL; this package stays MIT). Install ffmpeg yourself: brew install ffmpeg."
   },
   "scripts": {
-    "test": "node --test vendor/drp-format/__tests__/ vendor/drt-format/__tests__/ vendor/drx-codec/__tests__/ test/",
-    "test:libs": "node --test vendor/drp-format/__tests__/ vendor/drt-format/__tests__/ vendor/drx-codec/__tests__/",
-    "test:server": "node --test test/"
+    "test": "node --test vendor/drp-format/__tests__/*.test.js vendor/drt-format/__tests__/*.test.js vendor/drx-codec/__tests__/*.test.js test/*.test.mjs",
+    "test:libs": "node --test vendor/drp-format/__tests__/*.test.js vendor/drt-format/__tests__/*.test.js vendor/drx-codec/__tests__/*.test.js",
+    "test:server": "node --test test/*.test.mjs"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/install_resolve_bridge.py

@@ -53,11 +53,26 @@ _SCRIPTS_SUFFIX = "Library/Application Support/Blackmagic Design/DaVinci Resolve
 #: `<container>/Data/Library/Application Support/Fusion/Scripts/Utility` appeared
 #: under Workspace ▸ Scripts, as did one in
 #: `<container>/Data/Documents/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/Utility`.
-#: So Lite scans more locations than the README documents. That changes nothing
-#: about *where to install* — the documented paths work, and each extra target is
-#: another chance for the App Management prompt to stall the copy — but the reason
-#: to prefer them is that they are documented, not that the others are dead.
+#: So Lite scans more locations than the README documents.
+#:
+#: **Second correction (issue #104), same version, opposite result:** on another
+#: free 21.0.3.7 App Store install the documented tree listed *nothing* — not
+#: even the Lua canary, which rules out the Python-detection explanation and
+#: points at the folder — while the Fusion standalone tree listed all four files
+#: with no restart. Two machines, same build, contradictory results.
+#:
+#: We cannot tell them apart from outside Resolve, so we stop trying to pick a
+#: winner and install to BOTH container trees. The documented path stays first
+#: (it is the one Blackmagic commits to), the standalone tree is the fallback
+#: that demonstrably works where the documented one silently does not. The cost
+#: is one extra App Management prompt; the cost of guessing wrong is a bridge
+#: that never appears and gives the user nothing to diagnose.
 _SANDBOX_MARKER = "com.blackmagic-design."
+
+#: Scanned by Lite in addition to `_SCRIPTS_SUFFIX`, inside the container only.
+#: NOT used outside a sandbox: on a normal install this is genuinely Fusion's
+#: own tree and has nothing to do with Resolve.
+_SANDBOX_FALLBACK_SUFFIX = "Library/Application Support/Fusion/Scripts/Utility"
 #: Containers that are not Resolve (RAW Player, Speed Test, the IO XPC helper).
 _NON_RESOLVE_CONTAINERS = ("BlackmagicRaw", "IOXPC")
 
@@ -73,7 +88,9 @@ def script_targets() -> list[Path]:
 
     Sandboxed containers are included because the App Store build cannot see the
     normal per-user path — that isolation is exactly what lets the free edition
-    coexist with a direct-download Studio install.
+    coexist with a direct-download Studio install. Each container contributes
+    TWO targets (see the module comment on issue #104): the documented tree
+    first, then the Fusion standalone tree that Lite also scans.
     """
     home = Path.home()
     candidates = [
@@ -87,6 +104,7 @@ def script_targets() -> list[Path]:
         for entry in sorted(containers.iterdir()):
             if _is_resolve_container(entry) and (entry / "Data").is_dir():
                 sandboxed.append(entry / "Data" / _SCRIPTS_SUFFIX)
+                sandboxed.append(entry / "Data" / _SANDBOX_FALLBACK_SUFFIX)
 
     usable: list[Path] = []
     for path in candidates:
@@ -98,6 +116,51 @@ def script_targets() -> list[Path]:
     return list(dict.fromkeys(usable))
 
 
+#: Where a Resolve app bundle actually lives. The App Store build installs flat
+#: into /Applications; the direct download uses its own folder. RESOLVE_APP
+#: overrides both, matching scripts/doctor.py.
+_APP_BUNDLE_CANDIDATES = (
+    "/Applications/DaVinci Resolve/DaVinci Resolve.app",
+    "/Applications/DaVinci Resolve.app",
+    "/Applications/DaVinci Resolve Studio.app",
+)
+
+
+def installed_app_bundles() -> list[str]:
+    """Resolve app bundles present on this machine."""
+    override = os.environ.get("RESOLVE_APP")
+    candidates = (override,) + _APP_BUNDLE_CANDIDATES if override else _APP_BUNDLE_CANDIDATES
+    return [path for path in candidates if path and Path(path).is_dir()]
+
+
+def stale_container_warning(targets: list[Path]) -> str | None:
+    """Are we about to install into a container left by an *uninstalled* Resolve?
+
+    A container outlives the app that created it — uninstalling Resolve leaves
+    the whole `~/Library/Containers/com.blackmagic-design.*` tree behind. Since
+    a container's existence is what makes us target it, the installer would
+    otherwise report a clean success on a machine with no Resolve at all, and
+    the user would go hunting through the Scripts menu of an app they do not
+    have (issue #104). Warn rather than refuse: we cannot enumerate every place
+    an app bundle might legitimately live, and being wrong in the refusing
+    direction blocks a working install.
+    """
+    if not any("Containers" in str(target) for target in targets):
+        return None
+    if installed_app_bundles():
+        return None
+    return (
+        "Installed into a sandbox container, but no DaVinci Resolve app bundle "
+        "was found on this machine. A container OUTLIVES the app that created "
+        "it, so this is what an uninstalled Resolve looks like — the files were "
+        "written, but nothing will ever read them. Checked: "
+        + ", ".join(_APP_BUNDLE_CANDIDATES)
+        + ". If Resolve is installed somewhere else, re-run with RESOLVE_APP "
+        "set to its .app bundle to silence this. If it is not installed, "
+        "install it first, then re-run."
+    )
+
+
 #: Resolve enumerates `.py` scripts in Workspace > Scripts only when it finds a
 #: **framework** Python. Homebrew/pyenv/conda interpreters are not detected, and
 #: the failure is completely silent: the script sits in the right folder with the
@@ -233,6 +296,8 @@ def install(*, probe_only: bool, port: int, rotate: bool) -> dict:
             launcher_path.write_text(launcher, encoding="utf-8")
             installed.append(str(launcher_path))
     result = {"installed": installed, "probe_only": probe_only, "python": python_preflight()}
+    stale = stale_container_warning(targets)
+    result["warnings"] = [stale] if stale else []
     if not probe_only:
         loaded = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
         result["config"] = {"path": str(CONFIG_PATH),
@@ -258,6 +323,11 @@ def main() -> int:
         print("WARNING: " + result["python"]["advice"])
         print("!" * 72)
         print()
+    for warning in result["warnings"]:
+        print("!" * 72)
+        print("WARNING: " + warning)
+        print("!" * 72)
+        print()
     print("Next:")
     print("  1. Restart DaVinci Resolve so it re-scans the Scripts folders.")
     print("  2. Open a saved project (the Scripts menu is empty in Project Manager).")

package/src/granular/common.py

@@ -85,7 +85,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.69.0"
+VERSION = "2.69.3"
 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 341-tool granular server instead
 """
 
-VERSION = "2.69.0"
+VERSION = "2.69.3"
 
 import base64
 import os

package/src/utils/bridge_differential.py

@@ -61,6 +61,28 @@ VOLATILE_METHODS = frozenset({
     "IsPlayheadOnVideoFrame",
 })
 
+#: App-global state that **the harness's own probes move**, which is a different
+#: problem from `VOLATILE_METHODS` drifting on its own.
+#:
+#: Measured on Studio 19.1.3.7: the render probes navigate Resolve to the Deliver
+#: page, and the bridge pass runs before the native pass — so the native pass
+#: reads a page the bridge pass changed. That produced a `value_mismatch` on
+#: `GetCurrentPage` (bridge `edit`, native `deliver`) on every run that did not
+#: happen to start on Deliver, and none on the runs that did. Read at the same
+#: instant the two transports always agreed.
+#:
+#: Excusing it unconditionally would throw away a real signal — a bridge that
+#: genuinely reported the wrong page is exactly the bug this harness is for. So
+#: each pass records the page on the way in and on the way out, and the value is
+#: only excused when a pass proves it did not hold still. If both passes were
+#: stable and the values still disagree, that is the transport and it is reported.
+ORDER_SENSITIVE_METHODS = frozenset({"GetCurrentPage"})
+
+#: Key `run_probes` adds for `compare`'s own use rather than as a probe result.
+#: Underscore-prefixed so the diff skips it instead of reading it as a method
+#: that one transport has and the other does not.
+PASS_META_KEY = "_pass_meta"
+
 #: Never invoked by the harness, whatever the enumeration says. These either
 #: change the project, touch the filesystem, or block on UI. The write paths are
 #: exercised by named scenarios instead, where the setup and teardown are
@@ -326,6 +348,19 @@ def probe_one(target: Any, method: str) -> Dict[str, Any]:
     return {"outcome": "returned", "value": normalise(value), "type": describe(value)}
 
 
+def _current_page(resolve: Any) -> Optional[str]:
+    """The page, or None if it cannot be read.
+
+    Never raises: this is bookkeeping around the probes, and a failure here must
+    not take down a pass that is otherwise fine.
+    """
+    try:
+        page = resolve.GetCurrentPage()
+    except Exception:  # noqa: BLE001 - an unreadable page is simply unknown
+        return None
+    return page if isinstance(page, str) else None
+
+
 def run_probes(resolve: Any, methods: Sequence[str]) -> Dict[str, Dict[str, Any]]:
     """Every enumerated safe method, against every object that has it.
 
@@ -333,6 +368,7 @@ def run_probes(resolve: Any, methods: Sequence[str]) -> Dict[str, Dict[str, Any]
     not merely that they did.
     """
     results: Dict[str, Dict[str, Any]] = {}
+    page_before = _current_page(resolve)
     for label, chain in OBJECT_GRAPH:
         target = walk(resolve, chain)
         if target is None:
@@ -342,13 +378,28 @@ def run_probes(resolve: Any, methods: Sequence[str]) -> Dict[str, Dict[str, Any]
             if getattr(target, method, None) is None:
                 continue  # not on this object; absence is reported by the diff
             results[f"{label}.{method}"] = probe_one(target, method)
+    page_after = _current_page(resolve)
+    results[PASS_META_KEY] = {
+        "page_before": page_before,
+        "page_after": page_after,
+        # None on either side means we could not tell, which must not read as
+        # "stable" — an unknown has to disable the value comparison, not enable it.
+        "page_stable": page_before is not None and page_before == page_after,
+    }
     return results
 
 
 def compare(native: Dict[str, Dict[str, Any]], bridged: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
     """Diff two probe runs. Empty `differences` is the pass condition."""
     differences: List[Dict[str, Any]] = []
+    # A pass that moved the page cannot have its page compared by value against
+    # another pass taken at a different moment. Both must have held still.
+    native_meta = native.get(PASS_META_KEY) or {}
+    bridge_meta = bridged.get(PASS_META_KEY) or {}
+    page_held_still = bool(native_meta.get("page_stable")) and bool(bridge_meta.get("page_stable"))
     for key in sorted(set(native) | set(bridged)):
+        if key.startswith("_"):
+            continue  # harness bookkeeping, not a probe result
         left, right = native.get(key), bridged.get(key)
         if left is None or right is None:
             differences.append({
@@ -364,17 +415,32 @@ def compare(native: Dict[str, Dict[str, Any]], bridged: Dict[str, Dict[str, Any]
                 differences.append({"key": key, "kind": "volatile_type_mismatch",
                                     "native": left.get("type"), "bridge": right.get("type")})
             continue
+        if method in ORDER_SENSITIVE_METHODS and not page_held_still:
+            # The harness moved it mid-run, so the two readings are of different
+            # moments. Still hold the transport to returning the same kind of
+            # thing, and say why the value was not compared.
+            if left.get("type") != right.get("type") or left["outcome"] != right["outcome"]:
+                differences.append({"key": key, "kind": "order_sensitive_type_mismatch",
+                                    "native": left.get("type"), "bridge": right.get("type")})
+            continue
         if left != right:
             differences.append({"key": key, "kind": "value_mismatch",
                                 "native": left, "bridge": right})
-    agreed = len(set(native) & set(bridged)) - len(
+    probe_keys = {k for k in set(native) | set(bridged) if not k.startswith("_")}
+    agreed = len({k for k in set(native) & set(bridged) if not k.startswith("_")}) - len(
         [d for d in differences if d["kind"] != "only_one_transport_reached_it"]
     )
     return {
-        "compared": len(set(native) | set(bridged)),
+        "compared": len(probe_keys),
         "agreed": agreed,
         "differences": differences,
         "identical": not differences,
+        # Reported either way. "The page was not compared" is a fact about the
+        # run that a reader needs, and burying it would recreate the silence
+        # this fix exists to end.
+        "page_compared_by_value": page_held_still,
+        "page_native": {k: native_meta.get(k) for k in ("page_before", "page_after")},
+        "page_bridge": {k: bridge_meta.get(k) for k in ("page_before", "page_after")},
     }
 
 

package/src/utils/platform.py

@@ -55,6 +55,16 @@ def get_resolve_paths():
         lib_path = "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so"
         modules_path = os.path.join(api_path, "Modules")
     
+    # An explicit install location wins over the platform default: Resolve is
+    # not always under /Applications (external volume, custom install dir).
+    env_api = os.environ.get("RESOLVE_SCRIPT_API")
+    if env_api and os.path.isdir(env_api):
+        api_path = env_api
+        modules_path = os.path.join(api_path, "Modules")
+    env_lib = os.environ.get("RESOLVE_SCRIPT_LIB")
+    if env_lib and os.path.isfile(env_lib):
+        lib_path = env_lib
+
     return {
         "api_path": api_path,
         "lib_path": lib_path,