davinci-resolve-mcp 2.63.2 → 2.65.0

package/CHANGELOG.md

@@ -2,6 +2,87 @@
 
 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.65.0
+
+Bundles two community contributions from @double2tea: an optional HTTP
+transcription backend and a localized, build-aware control panel. Both are
+opt-in and change no default behavior — with neither configured, existing
+transcription backends and the English panel work exactly as before.
+
+### Added
+
+- **MLX Audio Router transcription backend** (PR #95, @double2tea) — an optional
+  HTTP transcription backend that runs outside the Resolve MCP Python
+  environment. Enabled only when `DAVINCI_RESOLVE_MCP_MLX_AUDIO_URL` is set and a
+  bounded `GET /health` probe succeeds; an optional
+  `DAVINCI_RESOLVE_MCP_MLX_AUDIO_MODEL` overrides the router's default model.
+  When configured and healthy it is preferred in transcription capability
+  ordering, and its response is normalized into the existing JSON/SRT/VTT
+  transcript artifacts. Standard-library only (`urllib`); the MCP server never
+  installs, starts, or downloads anything on the router's behalf, and existing
+  Whisper backends are untouched when no URL is set.
+- **Control panel localization (English / Simplified Chinese)** (PR #96,
+  @double2tea) — a persistent language switch on the local control panel.
+  English remains the authored, canonical UI; the browser stores only the
+  selected locale in `localStorage` and the initial locale follows browser
+  preferences. Translation runs client-side over the DOM (text nodes plus
+  `aria-label`/`title`/`placeholder`) and is fully reversible; no server API or
+  persisted project data changes.
+- **Build-aware AI console** (PR #96, @double2tea) — the Resolve AI console now
+  uses the runtime capability payload to disable actions the connected Resolve
+  build cannot execute, distinguishing "Requires Resolve 21+" from "Unavailable
+  on this build" and surfacing the Resolve 20 transcription methods
+  (`TranscribeAudio` / `ClearTranscription`). Narrow-screen navigation and the
+  mobile footer were also improved.
+
+### Validation
+
+- Static checks and drift guards pass; `tests/test_media_analysis.py` (110),
+  `tests/test_control_panel_i18n.py` + `tests/test_control_panel_ai_capabilities.py`
+  + `tests/test_open_control_panel.py` (14) pass on the merged tree.
+- No DaVinci Resolve scripting behavior changed: PR #95 is a self-contained
+  HTTP/stdlib backend gated behind an env var, and PR #96 changes only the
+  control panel's client-side HTML/JS. Live Resolve validation not required.
+
+## What's New in v2.64.0
+
+Adds opt-in support for DaVinci Resolve's **Network** external-scripting mode
+(PR #91… correction: PR #94, by @double2tea), so the MCP can drive a Resolve
+instance addressed by IP — including a Resolve running on the same machine with
+`External scripting using = Network`. Contributed in PR #94 by @double2tea,
+with two additional connection sites hardened during adoption. Local mode is
+unchanged and remains the default.
+
+### Added
+
+- **Resolve Network scripting mode** — set `RESOLVE_SCRIPT_HOST` to the Resolve
+  host IP (`127.0.0.1` on the same machine) to route connections through
+  Resolve's explicit IP-targeted `scriptapp("Resolve", host, timeout)` overload.
+  `RESOLVE_SCRIPT_TIMEOUT` (positive finite seconds, default 5) bounds the
+  connection wait. When `RESOLVE_SCRIPT_HOST` is absent, the server uses the
+  one-argument Local discovery exactly as before. A shared `connect_resolve`
+  helper centralizes this behavior; the compound server, granular server,
+  analysis dashboard, `scripts/doctor.py`, and the installer's post-install
+  connection probe all route through it. The installer copies
+  `RESOLVE_SCRIPT_HOST`/`RESOLVE_SCRIPT_TIMEOUT` into generated client configs
+  when present in its environment.
+- **`doctor.py` Network flags** — `python3 scripts/doctor.py --resolve-host
+  <ip> [--resolve-timeout <seconds>]` runs the read-only connection check
+  against a Network-mode host.
+
+### Security
+
+- Network scripting permits remote control of Resolve. Documentation (SKILL.md,
+  install.md) advises using Local mode when remote access is unnecessary, and
+  otherwise restricting access with host firewall and network controls.
+
+### Validation
+
+- Live-validated on DaVinci Resolve Studio 19.1.3.7: Local mode (one-argument
+  discovery) and Network mode (`--resolve-host 127.0.0.1 --resolve-timeout 8`)
+  both connect through the shared `connect_resolve` helper. PR author validated
+  against Studio 20.3.2.9 in Network mode. Full offline suite: 1514 tests.
+
 ## What's New in v2.63.2
 
 Installer fix for Windows MSIX builds of Claude Desktop (issue #93, reported by

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.63.2-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.65.0-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/docs/SKILL.md

@@ -14,8 +14,14 @@ session — projects, timelines, clips, color grading, Fusion compositions, audi
 render queues, and more — through natural language.
 
 DaVinci Resolve must be running with **Preferences > General > "External scripting
-using"** set to **Local**. The server auto-launches Resolve if it is not running,
-but that first connection can take up to 60 seconds.
+using"** set to **Local**, or set to **Network** with `RESOLVE_SCRIPT_HOST`
+configured to the Resolve host IP (use `127.0.0.1` on the same machine). The
+server auto-launches Resolve if it is not running, but that first connection can
+take up to 60 seconds.
+
+Network scripting permits remote control of Resolve. Use Local mode when remote
+access is unnecessary; otherwise restrict access with host firewall and network
+controls.
 
 **Session-start update note.** The first `resolve_control(action="get_version")`
 of a session returns an `mcp` block with the cached update check

package/docs/guides/media-analysis-guide.md

@@ -79,6 +79,23 @@ which ffmpeg && ffmpeg -version 2>&1 | head -1
 which whisper 2>/dev/null || which whisper-cpp 2>/dev/null || python3 -c "import whisper" 2>/dev/null
 ```
 
+An HTTP MLX Audio Router can be used without installing a transcription module
+into the Resolve MCP Python environment:
+
+```bash
+export DAVINCI_RESOLVE_MCP_MLX_AUDIO_URL=http://127.0.0.1:8000
+# Optional: omit this to use the router's own default model.
+export DAVINCI_RESOLVE_MCP_MLX_AUDIO_MODEL=mlx-community/Qwen3-ASR-1.7B-8bit
+```
+
+The configured service must expose `GET /health`, returning JSON with
+`{"status":"ok"}`, and `POST /stt`. The transcription request uses the local
+source path and requests JSON output; the response must contain a `transcript`
+string whose value is a JSON object with `text` and `segments`. The
+[Audiobox MLX Audio Router](https://github.com/double2tea/Audiobox) implements
+this contract. Model download behavior follows the existing
+`allow_model_download` transcription option.
+
 FFprobe is required. If missing:
 - macOS: `brew install ffmpeg`
 - Linux: `sudo apt install ffmpeg` or `sudo dnf install ffmpeg`

package/docs/install.md

@@ -7,7 +7,9 @@ This guide covers Resolve requirements, the universal installer, supported MCP c
 - **DaVinci Resolve Studio** 18.5+ (macOS, Windows, or Linux) — the free edition does not support external scripting
 - **Python 3.10+** (the MCP SDK requires 3.10). **3.10–3.12 is the lowest-risk
   choice**; 3.13/3.14 also work on recent Resolve builds — see below
-- DaVinci Resolve running with **Preferences > General > "External scripting using"** set to **Local**
+- DaVinci Resolve running with **Preferences > General > "External scripting using"**
+  set to **Local**, or **Network** with `RESOLVE_SCRIPT_HOST` set to the Resolve
+  host IP (`127.0.0.1` when Resolve and the MCP run on the same machine)
 
 > **Python 3.13 / 3.14:** these are **allowed** — setup will use them and warn.
 > Python 3.14 is verified working against DaVinci Resolve Studio 20.3.2. On
@@ -170,6 +172,26 @@ If you prefer to set things up yourself, add to your MCP client config:
 
 On Windows, installer-generated configs also include `PYTHONHOME`. That scopes Resolve's Python binding to the selected interpreter and avoids the Resolve 20.3 multi-Python crash reported in [Issue #26](https://github.com/samuelgursky/davinci-resolve-mcp/issues/26).
 
+For Resolve's **Network** scripting mode, add
+`"RESOLVE_SCRIPT_HOST": "127.0.0.1"` to the `env` object above, replacing the
+address when Resolve runs on another host. When this variable is present, the
+server uses Resolve's explicit IP-targeted `scriptapp` call with a bounded
+connection timeout. Set `RESOLVE_SCRIPT_TIMEOUT` to override the default
+five-second timeout with a positive finite number of seconds. The installer
+includes both values in generated client configs when they are present in its
+environment.
+
+Network scripting permits remote control of Resolve. Prefer Local mode when
+remote access is unnecessary; otherwise restrict access with host firewall and
+network controls.
+
+Run the read-only doctor against Network mode explicitly:
+
+```bash
+python3 scripts/doctor.py --resolve-host 127.0.0.1
+python3 scripts/doctor.py --resolve-host resolve.example.test --resolve-timeout 12.5
+```
+
 When the compound server is running, `resolve_control(action="get_version")`
 includes the local MCP version, the last update-check status, and the current
 update decision under the `mcp` key. `resolve_control(action="mcp_update_status",

package/install.py

@@ -15,6 +15,7 @@ Usage:
 
 import argparse
 import json
+import math
 import os
 import platform
 import shutil
@@ -35,7 +36,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.63.2"
+VERSION = "2.65.0"
 # 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
@@ -474,6 +475,13 @@ def build_server_env(python_path, api_path, lib_path, system=SYSTEM, python_home
     if system == "Windows":
         env["PYTHONHOME"] = str(python_home or get_python_base_install(python_path))
 
+    host = os.environ.get("RESOLVE_SCRIPT_HOST")
+    if host:
+        env["RESOLVE_SCRIPT_HOST"] = host
+        timeout = os.environ.get("RESOLVE_SCRIPT_TIMEOUT")
+        if timeout:
+            env["RESOLVE_SCRIPT_TIMEOUT"] = timeout
+
     return env
 
 
@@ -810,12 +818,21 @@ def verify_resolve_connection(python_path, api_path, lib_path):
 
     env = {**os.environ, **build_server_env(python_path, api_path, lib_path)}
     modules_path = env["PYTHONPATH"]
+    repo_root = str(Path(__file__).resolve().parent)
+    # Route through connect_resolve so Network mode (RESOLVE_SCRIPT_HOST, propagated
+    # into env by build_server_env) uses the explicit IP-targeted overload. Fall
+    # back to Local-mode discovery if the helper cannot be imported.
     test_script = textwrap.dedent(f"""\
         import sys
         sys.path.insert(0, {modules_path!r})
+        sys.path.insert(0, {repo_root!r})
         try:
             import DaVinciResolveScript as dvr
-            resolve = dvr.scriptapp('Resolve')
+            try:
+                from src.utils.resolve_connection import connect_resolve
+            except Exception:
+                connect_resolve = lambda mod: mod.scriptapp('Resolve')
+            resolve = connect_resolve(dvr)
             if resolve:
                 name = resolve.GetProductName()
                 ver = resolve.GetVersionString()
@@ -828,12 +845,22 @@ def verify_resolve_connection(python_path, api_path, lib_path):
             print(f"ERROR: {{e}}")
     """)
 
+    process_timeout = 10.0
+    configured_timeout = env.get("RESOLVE_SCRIPT_TIMEOUT")
+    if configured_timeout:
+        try:
+            network_timeout = float(configured_timeout)
+            if math.isfinite(network_timeout) and network_timeout > 0:
+                process_timeout = max(process_timeout, network_timeout + 2)
+        except ValueError:
+            pass
+
     try:
         result = subprocess.run(
             [str(python_path), "-c", test_script],
             capture_output=True,
             text=True,
-            timeout=10,
+            timeout=process_timeout,
             env=env,
         )
         output = result.stdout.strip() or result.stderr.strip()

package/package.json

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

package/scripts/doctor.py

@@ -7,16 +7,19 @@ mutating anything. Prints OK/WARN/FAIL lines (or JSON with --json) and exits
 nonzero only when a FAIL is present.
 
 Run: `python3 scripts/doctor.py`
+Network mode: `python3 scripts/doctor.py --resolve-host 127.0.0.1`
 
 Overridable via environment: DAVINCI_MCP_REPO, DAVINCI_MCP_PYTHON,
 CODEX_HOME, CLAUDE_DESKTOP_CONFIG, RESOLVE_APP, RESOLVE_SCRIPT_API,
-RESOLVE_SCRIPT_MODULES, RESOLVE_SCRIPT_LIB.
+RESOLVE_SCRIPT_MODULES, RESOLVE_SCRIPT_LIB, RESOLVE_SCRIPT_HOST,
+RESOLVE_SCRIPT_TIMEOUT.
 """
 
 from __future__ import annotations
 
 import argparse
 import json
+import math
 import os
 import re
 import subprocess
@@ -128,26 +131,41 @@ def git_head() -> str:
     return head["stdout"] or head["stderr"] or "git describe produced no output"
 
 
-def resolve_probe() -> dict[str, Any]:
+def resolve_probe(
+    resolve_host: str | None = None,
+    resolve_timeout: float | None = None,
+) -> dict[str, Any]:
     if not PYTHON.exists():
         return {"import_ok": False, "error": f"{PYTHON} is missing"}
 
     code = f"""
 import json
 import sys
+sys.path.insert(0, {str(REPO)!r})
 sys.path.insert(0, {str(RESOLVE_MODULES)!r})
 try:
     import DaVinciResolveScript as dvr
-    resolve = dvr.scriptapp("Resolve")
-    payload = {{
-        "import_ok": True,
-        "module": getattr(dvr, "__file__", None),
-        "resolve_connected": bool(resolve),
-        "product": resolve.GetProductName() if resolve else None,
-        "version": resolve.GetVersionString() if resolve else None,
-    }}
+    from src.utils.resolve_connection import connect_resolve
 except Exception as exc:
     payload = {{"import_ok": False, "error": repr(exc)}}
+else:
+    try:
+        resolve = connect_resolve(dvr)
+    except Exception as exc:
+        payload = {{
+            "import_ok": True,
+            "module": getattr(dvr, "__file__", None),
+            "resolve_connected": False,
+            "connection_error": repr(exc),
+        }}
+    else:
+        payload = {{
+            "import_ok": True,
+            "module": getattr(dvr, "__file__", None),
+            "resolve_connected": bool(resolve),
+            "product": resolve.GetProductName() if resolve else None,
+            "version": resolve.GetVersionString() if resolve else None,
+        }}
 print(json.dumps(payload))
 """
     env = {
@@ -156,7 +174,26 @@ print(json.dumps(payload))
         "RESOLVE_SCRIPT_LIB": str(RESOLVE_LIB),
         "PYTHONPATH": str(RESOLVE_MODULES),
     }
-    proc = subprocess.run([str(PYTHON), "-c", code], capture_output=True, text=True, timeout=12, env=env)
+    if resolve_host is not None:
+        env["RESOLVE_SCRIPT_HOST"] = resolve_host
+    if resolve_timeout is not None:
+        env["RESOLVE_SCRIPT_TIMEOUT"] = str(resolve_timeout)
+    process_timeout = 12.0
+    configured_timeout = env.get("RESOLVE_SCRIPT_TIMEOUT")
+    if configured_timeout:
+        try:
+            network_timeout = float(configured_timeout)
+            if math.isfinite(network_timeout) and network_timeout > 0:
+                process_timeout = max(process_timeout, network_timeout + 2)
+        except ValueError:
+            pass
+    proc = subprocess.run(
+        [str(PYTHON), "-c", code],
+        capture_output=True,
+        text=True,
+        timeout=process_timeout,
+        env=env,
+    )
     output = (proc.stdout or proc.stderr).strip()
     try:
         payload = json.loads(output)
@@ -166,7 +203,10 @@ print(json.dumps(payload))
     return payload
 
 
-def collect() -> list[dict[str, str]]:
+def collect(
+    resolve_host: str | None = None,
+    resolve_timeout: float | None = None,
+) -> list[dict[str, str]]:
     results: list[dict[str, str]] = []
 
     check(results, "OK" if REPO.exists() else "FAIL", "MCP checkout", str(REPO))
@@ -186,18 +226,27 @@ def collect() -> list[dict[str, str]]:
     pyver = run([str(PYTHON), "--version"]) if PYTHON.exists() else {"ok": False, "stdout": "", "stderr": "missing"}
     check(results, "OK" if pyver["ok"] else "FAIL", "Python version", pyver["stdout"] or pyver["stderr"])
 
-    probe = resolve_probe()
+    probe = resolve_probe(resolve_host, resolve_timeout)
     if probe.get("import_ok"):
         check(results, "OK", "DaVinciResolveScript import", str(probe.get("module")))
         if probe.get("resolve_connected"):
             detail = f"{probe.get('product')} {probe.get('version')}"
             check(results, "OK", "Resolve scripting connection", detail)
+        elif probe.get("connection_error"):
+            check(
+                results,
+                "FAIL",
+                "Resolve scripting connection",
+                str(probe["connection_error"]),
+            )
         else:
             check(
                 results,
                 "WARN",
                 "Resolve scripting connection",
-                'Module import worked, but scriptapp("Resolve") returned no object. Open DaVinci Resolve Studio, set Preferences > General > External scripting using = Local, and restart Resolve.',
+                "Module import worked, but scriptapp returned no object. Use "
+                "External scripting = Local, or Network with --resolve-host "
+                "set to the Resolve host IP, then restart Resolve.",
             )
     else:
         check(results, "FAIL", "DaVinciResolveScript import", str(probe.get("error")))
@@ -211,9 +260,18 @@ def collect() -> list[dict[str, str]]:
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--json", action="store_true", help="Print machine-readable JSON")
+    parser.add_argument(
+        "--resolve-host",
+        help="Resolve host IP for Network scripting mode",
+    )
+    parser.add_argument(
+        "--resolve-timeout",
+        type=float,
+        help="Network connection timeout in seconds (default: 5)",
+    )
     args = parser.parse_args()
 
-    results = collect()
+    results = collect(args.resolve_host, args.resolve_timeout)
     if args.json:
         print(json.dumps({"checks": results}, indent=2))
     else: