@hybridlabor-api/aos 4.4.1 → 4.4.2-beta.0

package/mcps/davinci-resolve-mcp/install.py

@@ -1,1687 +0,0 @@
-#!/usr/bin/env python3
-"""
-DaVinci Resolve MCP Server — Universal Installer
-
-Supports: macOS, Windows, Linux
-Configures: Claude Desktop, Claude Code, Cursor, VS Code (Copilot),
-            Windsurf, Cline, Roo Code, Zed, Continue, OpenCode, and manual setup.
-
-Usage:
-    python install.py                  # Interactive mode
-    python install.py --clients all    # Install all clients non-interactively
-    python install.py --clients cursor,claude-desktop --no-venv
-    python install.py --help
-"""
-
-import argparse
-import json
-import os
-import platform
-import shutil
-import subprocess
-import sys
-import textwrap
-import time
-from pathlib import Path
-
-from src.utils.update_check import (
-    clear_update_prompt_preferences,
-    check_for_updates,
-    ignore_update_version,
-    set_update_mode,
-    snooze_update_prompt,
-    update_prompt_decision,
-)
-
-# ─── Version ──────────────────────────────────────────────────────────────────
-
-VERSION = "2.57.5"
-# 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
-# may fail to connect on 3.13+, but the connection check is the real signal,
-# so we proceed with a heads-up rather than refusing to run.
-SUPPORTED_PYTHON_MIN = (3, 10)
-PYTHON_ABI_RISK_MIN = (3, 13)
-
-# ─── Colors (disabled on Windows cmd without ANSI support) ────────────────────
-
-def _supports_color():
-    if os.environ.get("NO_COLOR"):
-        return False
-    if platform.system() == "Windows":
-        return os.environ.get("WT_SESSION") or os.environ.get("TERM_PROGRAM")
-    return hasattr(sys.stdout, "isatty") and sys.stdout.isatty()
-
-USE_COLOR = _supports_color()
-
-def _c(code, text):
-    return f"\033[{code}m{text}\033[0m" if USE_COLOR else text
-
-def green(t):  return _c("32", t)
-def yellow(t): return _c("33", t)
-def red(t):    return _c("31", t)
-def bold(t):   return _c("1", t)
-def dim(t):    return _c("2", t)
-def cyan(t):   return _c("36", t)
-
-# ─── Platform Detection ──────────────────────────────────────────────────────
-
-SYSTEM = platform.system()  # Darwin, Windows, Linux
-
-def is_mac():     return SYSTEM == "Darwin"
-def is_windows(): return SYSTEM == "Windows"
-def is_linux():   return SYSTEM == "Linux"
-
-def platform_name():
-    if is_mac():     return "macOS"
-    if is_windows(): return "Windows"
-    if is_linux():   return "Linux"
-    return SYSTEM
-
-
-def is_supported_python_version(version):
-    major, minor = version[:2]
-    return major == 3 and minor >= SUPPORTED_PYTHON_MIN[1]
-
-
-def is_abi_risk_python_version(version):
-    major, minor = version[:2]
-    return major == 3 and minor >= PYTHON_ABI_RISK_MIN[1]
-
-
-def format_python_version(version):
-    return ".".join(str(part) for part in version[:3])
-
-
-def python_requirement_text():
-    return f"Python {SUPPORTED_PYTHON_MIN[0]}.{SUPPORTED_PYTHON_MIN[1]} or newer"
-
-
-_ABI_NOTE_PRINTED = False
-
-
-def print_abi_risk_note_once(version, label="Python"):
-    """Emit the 3.13+ heads-up at most once per installer run."""
-    global _ABI_NOTE_PRINTED
-    if _ABI_NOTE_PRINTED:
-        return
-    _ABI_NOTE_PRINTED = True
-    print(f"  {yellow(label + ':')} {python_abi_risk_note(version)}")
-
-
-def python_abi_risk_note(version):
-    return (
-        f"Using Python {format_python_version(version)}. Verified working on recent "
-        f"Resolve builds (Studio 20.3.2). If Resolve fails to connect "
-        f"(scriptapp(\"Resolve\") returns None), install Python 3.10-3.12 and re-run "
-        f"with it, e.g.: python3.12 install.py"
-    )
-
-
-def python_fix_hint():
-    return (
-        "  How to fix:\n"
-        "    - Install Python 3.12 (the lowest-risk version for Resolve), e.g.:\n"
-        "        macOS:   brew install python@3.12   (or: pyenv install 3.12)\n"
-        "        Linux:   pyenv install 3.12          (or your distro's python3.12 package)\n"
-        "        Windows: install Python 3.12 from python.org\n"
-        "    - Re-run with that interpreter, e.g.:  python3.12 install.py"
-    )
-
-
-def _version_for_python(python_path):
-    script = (
-        "import sys; "
-        "print(f'{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}')"
-    )
-    result = subprocess.run(
-        [str(python_path), "-c", script],
-        capture_output=True,
-        text=True,
-        timeout=10,
-    )
-    if result.returncode != 0:
-        output = (result.stderr or result.stdout or "").strip()
-        raise RuntimeError(output or f"{python_path} exited with code {result.returncode}")
-    parts = result.stdout.strip().split(".")
-    if len(parts) < 2:
-        raise RuntimeError(f"could not parse Python version from {python_path!s}")
-    return tuple(int(part) for part in parts[:3])
-
-
-def require_supported_python(python_path, label="Python"):
-    try:
-        version = _version_for_python(python_path)
-    except Exception as exc:
-        print(f"  {red(label + ':')} Could not inspect {python_path}: {exc}")
-        sys.exit(1)
-    if not is_supported_python_version(version):
-        print(
-            f"  {red(label + ':')} {python_requirement_text()} is required "
-            f"(the MCP SDK needs 3.10+); found {format_python_version(version)} "
-            f"at {python_path}"
-        )
-        print(python_fix_hint())
-        sys.exit(1)
-    if is_abi_risk_python_version(version):
-        print_abi_risk_note_once(version, label)
-    return version
-
-
-def require_current_python(label="Python"):
-    version = (sys.version_info.major, sys.version_info.minor, sys.version_info.micro)
-    if not is_supported_python_version(version):
-        print(
-            f"  {red(label + ':')} {python_requirement_text()} is required "
-            f"(the MCP SDK needs 3.10+); current interpreter is "
-            f"{format_python_version(version)} at {sys.executable}"
-        )
-        print(python_fix_hint())
-        sys.exit(1)
-    if is_abi_risk_python_version(version):
-        print_abi_risk_note_once(version, label)
-    return version
-
-# ─── Resolve Path Detection ──────────────────────────────────────────────────
-
-RESOLVE_PATHS = {
-    "Darwin": {
-        "api": [
-            "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting",
-        ],
-        "lib": [
-            "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so",
-        ],
-        "app": [
-            "/Applications/DaVinci Resolve/DaVinci Resolve.app",
-        ],
-    },
-    "Windows": {
-        "api": [
-            r"C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\Developer\Scripting",
-            r"C:\Program Files\Blackmagic Design\DaVinci Resolve\Developer\Scripting",
-        ],
-        "lib": [
-            r"C:\Program Files\Blackmagic Design\DaVinci Resolve\fusionscript.dll",
-        ],
-        "app": [
-            r"C:\Program Files\Blackmagic Design\DaVinci Resolve\Resolve.exe",
-        ],
-    },
-    "Linux": {
-        "api": [
-            "/opt/resolve/Developer/Scripting",
-            "/opt/resolve/libs/Fusion/Developer/Scripting",
-            "/home/{user}/.local/share/DaVinciResolve/Developer/Scripting",
-        ],
-        "lib": [
-            "/opt/resolve/libs/Fusion/fusionscript.so",
-            "/opt/resolve/bin/fusionscript.so",
-        ],
-        "app": [
-            "/opt/resolve/bin/resolve",
-        ],
-    },
-}
-
-
-def find_resolve_paths():
-    """Auto-detect DaVinci Resolve installation paths."""
-    candidates = RESOLVE_PATHS.get(SYSTEM, RESOLVE_PATHS["Linux"])
-    username = os.environ.get("USER", os.environ.get("USERNAME", ""))
-
-    api_path = None
-    lib_path = None
-
-    for p in candidates["api"]:
-        expanded = p.replace("{user}", username)
-        if os.path.isdir(expanded):
-            api_path = expanded
-            break
-
-    for p in candidates["lib"]:
-        expanded = p.replace("{user}", username)
-        if os.path.isfile(expanded):
-            lib_path = expanded
-            break
-
-    return api_path, lib_path
-
-
-def check_resolve_running():
-    """Check if DaVinci Resolve is currently running."""
-    try:
-        if is_mac():
-            result = subprocess.run(
-                ["pgrep", "-f", "DaVinci Resolve"],
-                capture_output=True, text=True
-            )
-            return result.returncode == 0
-        elif is_windows():
-            result = subprocess.run(
-                ["tasklist", "/FI", "IMAGENAME eq Resolve.exe"],
-                capture_output=True, text=True
-            )
-            return "Resolve.exe" in result.stdout
-        else:  # Linux
-            result = subprocess.run(
-                ["pgrep", "-f", "resolve"],
-                capture_output=True, text=True
-            )
-            return result.returncode == 0
-    except Exception:
-        return False
-
-# ─── MCP Client Definitions ──────────────────────────────────────────────────
-
-def home():
-    return Path.home()
-
-def appdata():
-    """Windows %APPDATA% equivalent."""
-    return Path(os.environ.get("APPDATA", home() / "AppData" / "Roaming"))
-
-def xdg_config():
-    """Linux XDG_CONFIG_HOME or default."""
-    return Path(os.environ.get("XDG_CONFIG_HOME", home() / ".config"))
-
-def vscode_global_storage():
-    """VS Code global storage path per platform."""
-    if is_mac():
-        return home() / "Library" / "Application Support" / "Code" / "User" / "globalStorage"
-    elif is_windows():
-        return appdata() / "Code" / "User" / "globalStorage"
-    else:
-        return xdg_config() / "Code" / "User" / "globalStorage"
-
-
-# Each client entry:
-#   id, name, config_path_fn, config_key, merge_strategy, notes
-# config_path_fn returns the path; config_key is the JSON key wrapping the server entry
-# merge_strategy: "merge" = add to existing JSON; "create" = create if not exists
-
-MCP_CLIENTS = [
-    {
-        "id": "antigravity",
-        "name": "Antigravity",
-        "get_path": lambda: home() / ".gemini" / "antigravity" / "mcp_config.json",
-        "config_key": "mcpServers",
-        "notes": "Google's agentic AI coding assistant (VS Code fork)",
-    },
-    {
-        "id": "claude-desktop",
-        "name": "Claude Desktop",
-        "get_path": lambda: {
-            "Darwin":  home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json",
-            "Windows": appdata() / "Claude" / "claude_desktop_config.json",
-            "Linux":   xdg_config() / "Claude" / "claude_desktop_config.json",
-        }.get(SYSTEM),
-        "config_key": "mcpServers",
-        "notes": "Anthropic's desktop app for Claude",
-    },
-    {
-        "id": "claude-code",
-        "name": "Claude Code",
-        "get_path": lambda: Path.cwd() / ".mcp.json",
-        "config_key": "mcpServers",
-        "notes": "Project-scoped config (committed to repo)",
-    },
-    {
-        "id": "cursor",
-        "name": "Cursor",
-        "get_path": lambda: {
-            "Darwin":  home() / ".cursor" / "mcp.json",
-            "Windows": home() / ".cursor" / "mcp.json",
-            "Linux":   home() / ".cursor" / "mcp.json",
-        }.get(SYSTEM),
-        "config_key": "mcpServers",
-        "notes": "AI-native code editor (VS Code fork)",
-    },
-    {
-        "id": "vscode",
-        "name": "VS Code (GitHub Copilot)",
-        "get_path": lambda: Path.cwd() / ".vscode" / "mcp.json",
-        "config_key": "servers",
-        "notes": "Workspace-scoped config for Copilot agent mode",
-    },
-    {
-        "id": "windsurf",
-        "name": "Windsurf",
-        "get_path": lambda: {
-            "Darwin":  home() / ".codeium" / "windsurf" / "mcp_config.json",
-            "Windows": appdata() / "windsurf" / "mcp_settings.json",
-            "Linux":   home() / ".codeium" / "windsurf" / "mcp_config.json",
-        }.get(SYSTEM),
-        "config_key": "mcpServers",
-        "notes": "Codeium's AI code editor",
-    },
-    {
-        "id": "cline",
-        "name": "Cline",
-        "get_path": lambda: vscode_global_storage() / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
-        "config_key": "mcpServers",
-        "notes": "AI coding assistant (VS Code extension)",
-    },
-    {
-        "id": "roo-code",
-        "name": "Roo Code",
-        "get_path": lambda: vscode_global_storage() / "rooveterinaryinc.roo-cline" / "settings" / "mcp_settings.json",
-        "config_key": "mcpServers",
-        "notes": "Autonomous AI coding assistant (VS Code extension)",
-    },
-    {
-        "id": "zed",
-        "name": "Zed",
-        "get_path": lambda: {
-            "Darwin":  home() / ".config" / "zed" / "settings.json",
-            "Windows": None,  # Zed doesn't support Windows yet
-            "Linux":   home() / ".config" / "zed" / "settings.json",
-        }.get(SYSTEM),
-        "config_key": "context_servers",
-        "notes": "High-performance code editor (macOS/Linux only)",
-    },
-    {
-        "id": "continue",
-        "name": "Continue",
-        "get_path": lambda: {
-            "Darwin":  home() / ".continue" / "config.json",
-            "Windows": home() / ".continue" / "config.json",
-            "Linux":   home() / ".continue" / "config.json",
-        }.get(SYSTEM),
-        "config_key": "mcpServers",
-        "notes": "Open-source AI code assistant",
-    },
-    {
-        "id": "opencode",
-        "name": "OpenCode",
-        # OpenCode uses ~/.config/opencode/opencode.json on every platform
-        # (it also reads a project-root opencode.json, but the global file is
-        # the safe default for an installer). See https://opencode.ai/docs/config/
-        "get_path": lambda: home() / ".config" / "opencode" / "opencode.json",
-        "config_key": "mcp",
-        "notes": "AI coding agent (uses its own type/enabled/command-array format)",
-    },
-]
-
-CLIENT_IDS = [c["id"] for c in MCP_CLIENTS]
-
-# ─── Server Entry Builder ────────────────────────────────────────────────────
-
-def get_python_base_install(python_path):
-    """Resolve the base Python install used by the selected interpreter."""
-    script = "import sys; print(sys.base_prefix or sys.prefix)"
-    try:
-        result = subprocess.run(
-            [str(python_path), "-c", script],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-        base_prefix = result.stdout.strip()
-        if result.returncode == 0 and base_prefix:
-            return base_prefix
-    except Exception as exc:
-        print(f"Warning: Could not query Python base prefix: {exc}")
-
-    resolved = Path(python_path).resolve()
-    if resolved.parent.name.lower() in {"scripts", "bin"}:
-        return str(resolved.parent.parent)
-    return str(resolved.parent)
-
-
-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."""
-    api_value = str(api_path or "")
-    lib_value = str(lib_path or "")
-    env = {
-        "RESOLVE_SCRIPT_API": api_value,
-        "RESOLVE_SCRIPT_LIB": lib_value,
-        "PYTHONPATH": str(Path(api_value) / "Modules") if api_value else "",
-    }
-
-    if system == "Windows":
-        env["PYTHONHOME"] = str(python_home or get_python_base_install(python_path))
-
-    return env
-
-
-def build_server_entry(python_path, server_path, api_path, lib_path, system=SYSTEM, python_home=None):
-    """Build the standard MCP server config entry."""
-    return {
-        "command": str(python_path),
-        "args": [str(server_path)],
-        "env": build_server_env(python_path, api_path, lib_path, system=system, python_home=python_home),
-    }
-
-
-def build_zed_entry(python_path, server_path, api_path, lib_path, system=SYSTEM, python_home=None):
-    """Build Zed-specific server entry (different format)."""
-    return {
-        "command": {
-            "path": str(python_path),
-            "args": [str(server_path)],
-        },
-        "env": build_server_env(python_path, api_path, lib_path, system=system, python_home=python_home),
-        "settings": {},
-    }
-
-
-def build_opencode_entry(python_path, server_path, api_path, lib_path, system=SYSTEM, python_home=None):
-    """Build OpenCode-specific server entry (issue #72).
-
-    OpenCode's schema differs from the standard format in three ways: it wraps
-    the entry in a ``"mcp"`` key, the interpreter and script are a single
-    ``"command"`` array (no separate ``args``), and the environment block is
-    ``"environment"`` rather than ``"env"``. It also expects ``type``/``enabled``
-    discriminators. See https://opencode.ai/docs/mcp-servers/
-    """
-    return {
-        "type": "local",
-        "enabled": True,
-        "command": [str(python_path), str(server_path)],
-        "environment": build_server_env(python_path, api_path, lib_path, system=system, python_home=python_home),
-    }
-
-
-def build_entry_for_client(client, python_path, server_path, api_path, lib_path, system=SYSTEM, python_home=None):
-    """Return the server entry shaped for a specific client's config schema."""
-    builders = {
-        "zed": build_zed_entry,
-        "opencode": build_opencode_entry,
-    }
-    builder = builders.get(client["id"], build_server_entry)
-    return builder(python_path, server_path, api_path, lib_path, system=system, python_home=python_home)
-
-# ─── Config File Operations ──────────────────────────────────────────────────
-
-class ConfigParseError(Exception):
-    """Existing config file has content but could not be parsed.
-
-    Callers must NOT overwrite such a file -- doing so destroys the user's
-    settings (issue #71).
-    """
-
-
-def _strip_jsonc(text):
-    """Best-effort strip of // and /* */ comments and trailing commas.
-
-    Zed's ``settings.json`` (and several other clients) accept JSON-with-comments.
-    Python's ``json`` module rejects those, so we strip them before parsing.
-    The walk is string-aware, so a ``//`` or ``/*`` sequence inside a JSON
-    string value is preserved.
-    """
-    out = []
-    i = 0
-    n = len(text)
-    in_string = False
-    escape = False
-    while i < n:
-        ch = text[i]
-        if in_string:
-            out.append(ch)
-            if escape:
-                escape = False
-            elif ch == "\\":
-                escape = True
-            elif ch == '"':
-                in_string = False
-            i += 1
-            continue
-        if ch == '"':
-            in_string = True
-            out.append(ch)
-            i += 1
-            continue
-        if ch == "/" and i + 1 < n and text[i + 1] == "/":
-            i += 2
-            while i < n and text[i] not in "\r\n":
-                i += 1
-            continue
-        if ch == "/" and i + 1 < n and text[i + 1] == "*":
-            i += 2
-            while i + 1 < n and not (text[i] == "*" and text[i + 1] == "/"):
-                i += 1
-            i += 2
-            continue
-        out.append(ch)
-        i += 1
-    stripped = "".join(out)
-    # Drop trailing commas before a closing brace/bracket — string-aware, so a
-    # comma inside a string value (e.g. "a, }") is never touched. A prior regex
-    # pass here was NOT string-aware and silently corrupted such values during a
-    # JSONC merge (follow-up to the issue #71 fix).
-    result = []
-    i = 0
-    n = len(stripped)
-    in_string = False
-    escape = False
-    while i < n:
-        ch = stripped[i]
-        if in_string:
-            result.append(ch)
-            if escape:
-                escape = False
-            elif ch == "\\":
-                escape = True
-            elif ch == '"':
-                in_string = False
-            i += 1
-            continue
-        if ch == '"':
-            in_string = True
-            result.append(ch)
-            i += 1
-            continue
-        if ch == ",":
-            j = i + 1
-            while j < n and stripped[j] in " \t\r\n":
-                j += 1
-            if j < n and stripped[j] in "}]":
-                i += 1  # trailing comma: drop it
-                continue
-        result.append(ch)
-        i += 1
-    return "".join(result)
-
-
-def read_json(path):
-    """Read a JSON/JSONC config file.
-
-    Returns an empty dict when the file is absent or empty (safe to create).
-    Raises :class:`ConfigParseError` when the file has content that cannot be
-    parsed even after stripping JSONC comments and trailing commas -- callers
-    must refuse to overwrite such a file, or they would wipe the user's
-    existing settings (issue #71: Zed's settings.json ships with comments).
-    """
-    try:
-        with open(path, "r") as f:
-            raw = f.read()
-    except FileNotFoundError:
-        return {}
-
-    if not raw.strip():
-        return {}
-
-    try:
-        return json.loads(raw)
-    except json.JSONDecodeError:
-        pass
-
-    try:
-        return json.loads(_strip_jsonc(raw))
-    except json.JSONDecodeError as exc:
-        raise ConfigParseError(str(exc)) from exc
-
-
-def write_json(path, data):
-    """Write JSON to file, creating parent directories."""
-    path = Path(path)
-    path.parent.mkdir(parents=True, exist_ok=True)
-
-    # Backup existing file
-    if path.exists():
-        backup = path.with_suffix(path.suffix + ".backup")
-        shutil.copy2(path, backup)
-
-    with open(path, "w") as f:
-        json.dump(data, f, indent=2)
-        f.write("\n")
-
-
-def write_client_config(client, python_path, server_path, api_path, lib_path, dry_run=False):
-    """Write or merge MCP config for a specific client. Returns (success, message)."""
-    config_path = client["get_path"]()
-    if config_path is None:
-        return False, f"{client['name']} is not available on {platform_name()}"
-
-    config_key = client["config_key"]
-
-    # Build the server entry (some clients use a non-standard schema)
-    server_entry = build_entry_for_client(client, python_path, server_path, api_path, lib_path)
-
-    if dry_run:
-        preview = {config_key: {"davinci-resolve": server_entry}}
-        return True, f"Would write to {config_path}:\n{json.dumps(preview, indent=2)}"
-
-    # Read existing config and merge. If the file exists but cannot be parsed,
-    # refuse to overwrite it -- silently replacing it would wipe the user's
-    # settings (issue #71, especially Zed's commented settings.json).
-    try:
-        existing = read_json(config_path)
-    except ConfigParseError as exc:
-        return False, (
-            f"{config_path} exists but could not be parsed ({exc}). "
-            f"Refusing to overwrite to avoid data loss. Add the "
-            f'"{config_key}" entry manually using the manual config output '
-            f"(run with --manual)."
-        )
-
-    if config_key not in existing:
-        existing[config_key] = {}
-
-    existing[config_key]["davinci-resolve"] = server_entry
-
-    write_json(config_path, existing)
-    return True, str(config_path)
-
-
-def generate_manual_config(python_path, server_path, api_path, lib_path):
-    """Generate config snippets for manual setup."""
-    entry = build_server_entry(python_path, server_path, api_path, lib_path)
-    zed_entry = build_zed_entry(python_path, server_path, api_path, lib_path)
-    opencode_entry = build_opencode_entry(python_path, server_path, api_path, lib_path)
-
-    standard = json.dumps({"mcpServers": {"davinci-resolve": entry}}, indent=2)
-    vscode_fmt = json.dumps({"servers": {"davinci-resolve": entry}}, indent=2)
-    zed_fmt = json.dumps({"context_servers": {"davinci-resolve": zed_entry}}, indent=2)
-    opencode_fmt = json.dumps({"mcp": {"davinci-resolve": opencode_entry}}, indent=2)
-
-    return standard, vscode_fmt, zed_fmt, opencode_fmt
-
-# ─── Virtual Environment ─────────────────────────────────────────────────────
-
-def find_python():
-    """Find the best Python 3 executable."""
-    candidates = ["python3", "python"]
-    for cmd in candidates:
-        try:
-            result = subprocess.run(
-                [cmd, "--version"], capture_output=True, text=True
-            )
-            if result.returncode == 0 and "Python 3" in result.stdout:
-                return cmd
-        except FileNotFoundError:
-            continue
-    return None
-
-
-def create_venv(venv_path):
-    """Create a Python virtual environment."""
-    print(f"\n  Creating virtual environment at {dim(str(venv_path))}...")
-    subprocess.run(
-        [sys.executable, "-m", "venv", str(venv_path)],
-        check=True
-    )
-
-
-def get_venv_python(venv_path):
-    """Get the Python executable inside a venv."""
-    if is_windows():
-        return venv_path / "Scripts" / "python.exe"
-    return venv_path / "bin" / "python"
-
-
-def get_venv_pip(venv_path):
-    """Get the pip executable inside a venv."""
-    if is_windows():
-        return venv_path / "Scripts" / "pip.exe"
-    return venv_path / "bin" / "pip"
-
-
-def install_dependencies(venv_path, project_dir):
-    """Install Python dependencies into the venv."""
-    pip = get_venv_pip(venv_path)
-    req_file = project_dir / "requirements.txt"
-
-    print(f"  Installing dependencies...")
-
-    # Install MCP SDK
-    subprocess.run(
-        [str(pip), "install", "-q", "mcp[cli]"],
-        check=True, capture_output=True
-    )
-
-    # Install from requirements.txt if it exists
-    if req_file.exists():
-        subprocess.run(
-            [str(pip), "install", "-q", "-r", str(req_file)],
-            check=True, capture_output=True
-        )
-
-# ─── Connection Verification ─────────────────────────────────────────────────
-
-def verify_resolve_connection(python_path, api_path, lib_path):
-    """Try to import DaVinciResolveScript and connect."""
-    if not api_path:
-        return False, "Resolve API path not found"
-
-    env = {**os.environ, **build_server_env(python_path, api_path, lib_path)}
-    modules_path = env["PYTHONPATH"]
-    test_script = textwrap.dedent(f"""\
-        import sys
-        sys.path.insert(0, {modules_path!r})
-        try:
-            import DaVinciResolveScript as dvr
-            resolve = dvr.scriptapp('Resolve')
-            if resolve:
-                name = resolve.GetProductName()
-                ver = resolve.GetVersionString()
-                print(f"CONNECTED: {{name}} {{ver}}")
-            else:
-                print("IMPORTED_OK: Module loads but Resolve not running or not responding")
-        except ImportError as e:
-            print(f"IMPORT_ERROR: {{e}}")
-        except Exception as e:
-            print(f"ERROR: {{e}}")
-    """)
-
-    try:
-        result = subprocess.run(
-            [str(python_path), "-c", test_script],
-            capture_output=True,
-            text=True,
-            timeout=10,
-            env=env,
-        )
-        output = result.stdout.strip() or result.stderr.strip()
-        if output.startswith("CONNECTED:"):
-            return True, output.replace("CONNECTED: ", "")
-        elif output.startswith("IMPORTED_OK:"):
-            return True, "API module loaded (Resolve not running)"
-        else:
-            if output:
-                return False, output
-            return False, f"Process exited with code {result.returncode}"
-    except subprocess.TimeoutExpired:
-        return False, "Connection timed out"
-    except Exception as e:
-        return False, str(e)
-
-# ─── Interactive UI ───────────────────────────────────────────────────────────
-
-def print_banner():
-    title = f"DaVinci Resolve MCP Server — Installer v{VERSION}"
-    subtitle = "32 compound · 329 full · 3 platforms"
-    print()
-    print(bold("  ╔══════════════════════════════════════════════════════╗"))
-    print(bold(f"  ║{title:^54}║"))
-    print(bold("  ╠══════════════════════════════════════════════════════╣"))
-    print(bold(f"  ║{subtitle:^54}║"))
-    print(bold("  ╚══════════════════════════════════════════════════════╝"))
-    print()
-
-
-def print_step(num, total, text):
-    print(f"\n  {cyan(f'[{num}/{total}]')} {bold(text)}")
-    print(f"  {'─' * 50}")
-
-
-def print_update_status(project_dir, *, force=False):
-    """Best-effort installer update notice."""
-    result = check_for_updates(VERSION, project_dir, timeout=2.0, force=force)
-    status = result.get("status")
-    if status == "update_available":
-        version_note = dim(
-            f"v{result.get('current_version')} -> v{result.get('latest_version')}"
-        )
-        release_note = dim(f"Latest release: {result.get('release_url')}")
-        print(
-            f"  MCP Update: {yellow('Available')} "
-            f"{version_note}"
-        )
-        print(f"  {release_note}")
-    elif status == "up_to_date":
-        print(f"  MCP Update: {green('Up to date')} {dim(f'v{VERSION}')}")
-    elif status == "current_ahead":
-        print(f"  MCP Update: {green('Local build ahead of latest release')} {dim(f'v{VERSION}')}")
-    elif status == "disabled":
-        print(f"  MCP Update: {dim('Check disabled')}")
-    elif status == "error":
-        print(f"  MCP Update: {yellow('Could not check')} {dim(str(result.get('error', '')))}")
-    return result
-
-
-def _run_git(project_dir, args, timeout=45):
-    try:
-        return subprocess.run(
-            ["git", "-C", str(project_dir), *args],
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-        )
-    except FileNotFoundError:
-        return None
-    except subprocess.TimeoutExpired as exc:
-        return exc
-
-
-def _git_failure_message(result, fallback):
-    if result is None:
-        return "git is not available on PATH"
-    if isinstance(result, subprocess.TimeoutExpired):
-        return "git command timed out"
-    output = (result.stderr or result.stdout or "").strip()
-    return output or fallback
-
-
-def _record_update_history(project_dir, entry):
-    """Append `entry` to `<project_dir>/logs/update_history.json` (best-effort)."""
-    import json as _json
-    log_dir = os.path.join(project_dir, "logs")
-    try:
-        os.makedirs(log_dir, exist_ok=True)
-    except OSError:
-        return
-    path = os.path.join(log_dir, "update_history.json")
-    history = {"entries": []}
-    if os.path.isfile(path):
-        try:
-            with open(path, "r", encoding="utf-8") as fh:
-                loaded = _json.load(fh)
-            if isinstance(loaded, dict) and isinstance(loaded.get("entries"), list):
-                history = loaded
-        except (OSError, ValueError):
-            pass
-    history.setdefault("entries", []).append(entry)
-    # Trim to most recent 200 entries — keep history bounded.
-    if len(history["entries"]) > 200:
-        history["entries"] = history["entries"][-200:]
-    history["updated_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-    tmp_path = path + ".tmp"
-    try:
-        with open(tmp_path, "w", encoding="utf-8") as fh:
-            _json.dump(history, fh, indent=2)
-        os.replace(tmp_path, path)
-    except OSError:
-        try:
-            os.remove(tmp_path)
-        except OSError:
-            pass
-
-
-def _read_current_version(project_dir):
-    """Best-effort read of VERSION constant from src/server.py."""
-    server_path = os.path.join(project_dir, "src", "server.py")
-    try:
-        with open(server_path, "r", encoding="utf-8") as fh:
-            for line in fh:
-                if line.startswith("VERSION = "):
-                    return line.split("=", 1)[1].strip().strip('"').strip("'")
-    except OSError:
-        pass
-    return None
-
-
-def _record_attempt(project_dir, *, kind, success, reason=None, message=None,
-                    from_version=None, to_version=None, from_sha=None, to_sha=None,
-                    initiator=None, extra=None):
-    """Append a structured row to update_history.json. `extra` is merged in flat."""
-    entry = {
-        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-        "kind": kind,  # "update" | "rollback" | "dry_run"
-        "success": bool(success),
-        "reason": reason,
-        "message": message,
-        "from_version": from_version,
-        "to_version": to_version,
-        "from_sha": from_sha,
-        "to_sha": to_sha,
-        "initiator": initiator,
-    }
-    if isinstance(extra, dict):
-        entry.update(extra)
-    _record_update_history(project_dir, entry)
-
-
-def apply_safe_self_update(project_dir, dry_run=False, *, initiator="cli",
-                           strategy="refuse_on_dirty"):
-    """Apply a guarded git fast-forward update.
-
-    `strategy` controls behavior when the working tree is dirty:
-    - `"refuse_on_dirty"` (default) — return reason="local_changes" without
-      touching anything.
-    - `"stash_if_needed"` — `git stash push`, apply the update, `git stash pop`.
-      If pop conflicts, leave the stash in place and return reason="stash_pop_conflict"
-      with the stash ref so the user can resolve.
-
-    Every attempt — success or failure — is recorded in
-    `<project_dir>/logs/update_history.json` so the dashboard can show what
-    happened and rollback can find the prior SHA.
-    """
-    inside = _run_git(project_dir, ["rev-parse", "--is-inside-work-tree"])
-    if inside is None or isinstance(inside, subprocess.TimeoutExpired) or inside.returncode != 0:
-        msg = _git_failure_message(inside, "not a git checkout")
-        _record_attempt(project_dir, kind="update", success=False, reason="not_git", message=msg, initiator=initiator)
-        return {"success": False, "reason": "not_git", "message": msg}
-
-    status = _run_git(project_dir, ["status", "--porcelain"])
-    if status is None or isinstance(status, subprocess.TimeoutExpired) or status.returncode != 0:
-        msg = _git_failure_message(status, "could not inspect git status")
-        _record_attempt(project_dir, kind="update", success=False, reason="status_failed", message=msg, initiator=initiator)
-        return {"success": False, "reason": "status_failed", "message": msg}
-
-    stash_ref = None
-    if status.stdout.strip():
-        if strategy != "stash_if_needed":
-            msg = "local changes are present; continuing with the current build"
-            _record_attempt(project_dir, kind="update", success=False, reason="local_changes", message=msg, initiator=initiator)
-            return {"success": False, "reason": "local_changes", "message": msg}
-        # Auto-stash path: push the working tree onto the stash, remember the
-        # ref so we can pop (or surface) it after the update.
-        stash_msg = f"mcp-update-autostash-{time.strftime('%Y%m%dT%H%M%SZ', time.gmtime())}"
-        stash = _run_git(project_dir, ["stash", "push", "-u", "-m", stash_msg], timeout=30)
-        if stash is None or stash.returncode != 0 or "No local changes to save" in (stash.stdout or ""):
-            # If we got here `status` was dirty, so a stash failure means trouble.
-            msg = _git_failure_message(stash, "git stash push failed")
-            _record_attempt(project_dir, kind="update", success=False, reason="stash_failed", message=msg, initiator=initiator)
-            return {"success": False, "reason": "stash_failed", "message": msg}
-        stash_ref = stash_msg
-
-    upstream = _run_git(project_dir, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"])
-    if upstream is None or isinstance(upstream, subprocess.TimeoutExpired) or upstream.returncode != 0:
-        msg = _git_failure_message(upstream, "current branch has no configured upstream")
-        _record_attempt(project_dir, kind="update", success=False, reason="no_upstream", message=msg, initiator=initiator)
-        return {"success": False, "reason": "no_upstream", "message": msg}
-
-    # Capture pre-update SHA + version so rollback knows where to revert to.
-    head_before = _run_git(project_dir, ["rev-parse", "HEAD"])
-    from_sha = head_before.stdout.strip() if head_before and head_before.returncode == 0 else None
-    from_version = _read_current_version(project_dir)
-
-    if dry_run:
-        msg = f"would fast-forward from {upstream.stdout.strip()}"
-        _record_attempt(project_dir, kind="dry_run", success=True, message=msg,
-                        from_version=from_version, from_sha=from_sha, initiator=initiator)
-        return {"success": True, "changed": False, "dry_run": True, "message": msg}
-
-    fetch = _run_git(project_dir, ["fetch", "--tags", "--prune"], timeout=90)
-    if fetch is None or isinstance(fetch, subprocess.TimeoutExpired) or fetch.returncode != 0:
-        msg = _git_failure_message(fetch, "git fetch failed")
-        _record_attempt(project_dir, kind="update", success=False, reason="fetch_failed", message=msg,
-                        from_version=from_version, from_sha=from_sha, initiator=initiator)
-        return {"success": False, "reason": "fetch_failed", "message": msg}
-
-    pull = _run_git(project_dir, ["pull", "--ff-only"], timeout=120)
-    if pull is None or isinstance(pull, subprocess.TimeoutExpired) or pull.returncode != 0:
-        msg = _git_failure_message(pull, "git pull --ff-only failed")
-        _record_attempt(project_dir, kind="update", success=False, reason="pull_failed", message=msg,
-                        from_version=from_version, from_sha=from_sha, initiator=initiator)
-        return {"success": False, "reason": "pull_failed", "message": msg}
-
-    head_after = _run_git(project_dir, ["rev-parse", "HEAD"])
-    to_sha = head_after.stdout.strip() if head_after and head_after.returncode == 0 else None
-    to_version = _read_current_version(project_dir)
-
-    output = "\n".join(part.strip() for part in (pull.stdout, pull.stderr) if part and part.strip())
-    changed = "Already up to date." not in output
-
-    # Integrity verification: confirm our local HEAD matches what GitHub said
-    # was the target SHA. Mismatch could mean: (a) user pushed to a fork mid-
-    # update, (b) the release we resolved was different from the branch tip
-    # (force-pushed), (c) corruption. We don't roll back automatically — the
-    # user may have intentional reasons — but we log it loudly.
-    integrity = {"verified": None, "expected_sha": None, "actual_sha": to_sha}
-    try:
-        from src.utils.update_check import check_for_updates as _cfu  # type: ignore
-        info = _cfu(from_version or "0.0.0", project_dir, force=False)
-        expected = info.get("release_target_sha")
-        if expected:
-            integrity["expected_sha"] = expected
-            # Compare prefixes (release SHA may be a tag name or short SHA).
-            ok = bool(to_sha) and (
-                expected == to_sha
-                or (len(expected) >= 7 and to_sha.startswith(expected[:7]))
-                or (len(to_sha) >= 7 and expected.startswith(to_sha[:7]))
-            )
-            integrity["verified"] = ok
-    except Exception as exc:
-        integrity["error"] = f"{type(exc).__name__}: {exc}"
-
-    # If we stashed changes earlier, try to reapply them now.
-    stash_pop_conflict = False
-    if stash_ref:
-        pop = _run_git(project_dir, ["stash", "pop"], timeout=60)
-        if pop is None or pop.returncode != 0:
-            stash_pop_conflict = True
-
-    result = {
-        "success": True, "changed": changed,
-        "message": output or "update complete",
-        "from_version": from_version, "to_version": to_version,
-        "from_sha": from_sha, "to_sha": to_sha,
-        "stash_ref": stash_ref,
-        "stash_pop_conflict": stash_pop_conflict,
-        "integrity": integrity,
-    }
-    if stash_pop_conflict:
-        # Update applied successfully but the stash pop hit a conflict; the
-        # user's changes are still in the stash. Don't fail the overall update,
-        # but surface the conflict prominently.
-        result["reason"] = "stash_pop_conflict"
-        result["remediation"] = (
-            f"Update applied, but your stashed changes ({stash_ref}) conflict with the new build. "
-            "Resolve via `git stash list` + `git stash pop` after restarting; "
-            "use `git stash drop` if you want to discard them."
-        )
-
-    _record_attempt(project_dir, kind="update", success=True,
-                    message=output or "update complete",
-                    from_version=from_version, to_version=to_version,
-                    from_sha=from_sha, to_sha=to_sha, initiator=initiator,
-                    extra={"stash_ref": stash_ref,
-                           "stash_pop_conflict": stash_pop_conflict,
-                           "integrity": integrity})
-
-    return result
-
-
-def rollback_to_previous_build(project_dir, *, initiator="cli"):
-    """git reset --hard to the from_sha of the most recent successful update.
-
-    Refuses if local changes exist (same guard as apply_safe_self_update) so we
-    never silently lose user work. Records a rollback row in update_history.
-    """
-    import json as _json
-    history_path = os.path.join(project_dir, "logs", "update_history.json")
-    if not os.path.isfile(history_path):
-        return {"success": False, "reason": "no_history", "message": "no update_history.json found"}
-    try:
-        with open(history_path, "r", encoding="utf-8") as fh:
-            history = _json.load(fh)
-    except (OSError, _json.JSONDecodeError) as exc:
-        return {"success": False, "reason": "history_read_failed", "message": str(exc)}
-
-    # Newest first; find the latest successful "update" entry with a from_sha.
-    candidates = [e for e in reversed(history.get("entries") or [])
-                  if e.get("kind") == "update" and e.get("success") and e.get("from_sha")]
-    if not candidates:
-        return {"success": False, "reason": "no_target", "message": "no prior successful update to roll back to"}
-    target = candidates[0]
-    from_sha = target["from_sha"]
-
-    status = _run_git(project_dir, ["status", "--porcelain"])
-    if status is None or status.returncode != 0:
-        return {"success": False, "reason": "status_failed", "message": "could not inspect git status"}
-    if status.stdout.strip():
-        return {"success": False, "reason": "local_changes",
-                "message": "local changes are present; commit or stash before rolling back"}
-
-    head_before = _run_git(project_dir, ["rev-parse", "HEAD"])
-    pre_rollback_sha = head_before.stdout.strip() if head_before and head_before.returncode == 0 else None
-    pre_rollback_version = _read_current_version(project_dir)
-
-    reset = _run_git(project_dir, ["reset", "--hard", from_sha], timeout=60)
-    if reset is None or reset.returncode != 0:
-        msg = _git_failure_message(reset, f"git reset --hard {from_sha} failed")
-        _record_attempt(project_dir, kind="rollback", success=False, reason="reset_failed", message=msg,
-                        from_version=pre_rollback_version, from_sha=pre_rollback_sha,
-                        to_sha=from_sha, initiator=initiator)
-        return {"success": False, "reason": "reset_failed", "message": msg}
-
-    to_version = _read_current_version(project_dir)
-    _record_attempt(project_dir, kind="rollback", success=True,
-                    message=f"rolled back to {from_sha[:10]}",
-                    from_version=pre_rollback_version, to_version=to_version,
-                    from_sha=pre_rollback_sha, to_sha=from_sha, initiator=initiator)
-    return {"success": True, "changed": pre_rollback_sha != from_sha,
-            "message": f"rolled back to {from_sha[:10]}",
-            "from_version": pre_rollback_version, "to_version": to_version,
-            "from_sha": pre_rollback_sha, "to_sha": from_sha}
-
-
-def preview_update(project_dir):
-    """Fetch the target release metadata + scan for breaking-change markers.
-
-    Returns a dict the UI can render before the user confirms the update:
-      {success, latest_version, release_notes, breaking_changes, prerelease,
-       channel, current_version, target_sha}
-    """
-    try:
-        from src.utils.update_check import check_for_updates  # type: ignore
-    except Exception as exc:
-        return {"success": False, "error": f"update_check unavailable: {exc}"}
-    current = _read_current_version(project_dir) or "0.0.0"
-    try:
-        result = check_for_updates(current, project_dir, force=True)
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-    return {
-        "success": True,
-        "current_version": current,
-        "latest_version": result.get("latest_version"),
-        "release_notes": result.get("release_notes") or "",
-        "breaking_changes": result.get("release_notes_breaking") or [],
-        "prerelease": bool(result.get("prerelease")),
-        "channel": result.get("channel"),
-        "target_sha": result.get("release_target_sha"),
-        "release_url": result.get("release_url"),
-        "status": result.get("status"),
-    }
-
-
-def read_update_history(project_dir, limit=20):
-    """Most-recent-first list of recorded update attempts. For the dashboard."""
-    import json as _json
-    path = os.path.join(project_dir, "logs", "update_history.json")
-    if not os.path.isfile(path):
-        return {"success": True, "entries": []}
-    try:
-        with open(path, "r", encoding="utf-8") as fh:
-            history = _json.load(fh)
-    except (OSError, _json.JSONDecodeError) as exc:
-        return {"success": False, "error": str(exc), "entries": []}
-    entries = (history.get("entries") or [])[-int(limit):]
-    entries.reverse()
-    return {"success": True, "entries": entries}
-
-
-def _restart_installer():
-    print(f"  {green('Restarting installer with the updated build...')}")
-    os.execv(sys.executable, [sys.executable, *sys.argv])
-
-
-def _print_update_apply_result(result, *, restart_on_change=True):
-    if result.get("success"):
-        if result.get("dry_run"):
-            print(f"  MCP Update: {yellow('Dry run')} {dim(result.get('message', ''))}")
-            return
-        print(f"  MCP Update: {green('Update command completed')}")
-        message = str(result.get("message") or "").strip()
-        if message:
-            for line in message.splitlines()[:6]:
-                print(f"  {dim(line)}")
-        if result.get("changed") and restart_on_change:
-            _restart_installer()
-        return
-
-    print(f"  MCP Update: {yellow('Not applied')} {dim(result.get('message', ''))}")
-
-
-def maybe_prompt_for_update(project_dir, result, *, interactive, force_update=False, dry_run=False):
-    """Prompt or auto-apply updates only in this human-facing installer."""
-    if not result or result.get("status") != "update_available":
-        return
-
-    decision = update_prompt_decision(result)
-    if force_update or decision.get("action") == "auto":
-        print(f"  MCP Update: {yellow('Applying safe fast-forward update...')}")
-        _print_update_apply_result(apply_safe_self_update(project_dir, dry_run=dry_run))
-        return
-
-    if decision.get("action") == "notify":
-        print(f"  {dim('Update policy is notify-only; continuing with the current build.')}")
-        return
-    if decision.get("reason") == "ignored":
-        print(f"  {dim('This release was ignored; continuing with the current build.')}")
-        return
-    if decision.get("reason") == "snoozed":
-        snooze_note = f"Update reminder snoozed until {decision.get('snooze_until_iso')}."
-        print(f"  {dim(snooze_note)}")
-        return
-    if not interactive:
-        return
-
-    latest = result.get("latest_version") or result.get("latest_tag") or "latest"
-    print()
-    print(f"  {yellow('A newer DaVinci Resolve MCP is available.')} {dim(f'v{VERSION} -> v{latest}')}")
-    print(f"  {dim('Safe auto-update only runs for clean git checkouts with a configured upstream.')}")
-    print(f"    {cyan('1')}. Update now")
-    print(f"    {cyan('2')}. Continue current build")
-    print(f"    {cyan('3')}. Remind me tomorrow")
-    print(f"    {cyan('4')}. Ignore this version")
-    print(f"    {cyan('5')}. Auto-update this checkout when safe")
-    print(f"    {cyan('6')}. Never check automatically")
-    try:
-        choice = input(f"  Select {dim('[2]')} ").strip().lower()
-    except (EOFError, KeyboardInterrupt):
-        print()
-        return
-
-    if choice in ("1", "u", "update", "update now"):
-        _print_update_apply_result(apply_safe_self_update(project_dir, dry_run=dry_run))
-    elif choice in ("3", "r", "remind", "later", "snooze"):
-        snooze_update_prompt(project_dir)
-        print(f"  MCP Update: {dim('Reminder snoozed for 24 hours.')}")
-    elif choice in ("4", "i", "ignore"):
-        ignore_update_version(project_dir, result)
-        print(f"  MCP Update: {dim(f'Ignored v{latest}. Newer releases will still prompt.')}")
-    elif choice in ("5", "a", "auto", "auto-update", "autoupdate"):
-        set_update_mode(project_dir, "auto")
-        print(f"  MCP Update: {green('Safe auto-update enabled for this checkout.')}")
-        _print_update_apply_result(apply_safe_self_update(project_dir, dry_run=dry_run))
-    elif choice in ("6", "n", "never", "disable", "disabled"):
-        set_update_mode(project_dir, "never")
-        print(f"  MCP Update: {dim('Automatic update checks disabled for this checkout.')}")
-
-
-def prompt_yes_no(question, default=True):
-    """Prompt for yes/no with a default."""
-    suffix = "[Y/n]" if default else "[y/N]"
-    try:
-        answer = input(f"  {question} {dim(suffix)} ").strip().lower()
-    except (EOFError, KeyboardInterrupt):
-        print()
-        return default
-    if not answer:
-        return default
-    return answer in ("y", "yes")
-
-
-def prompt_clients():
-    """Interactive client selection menu."""
-    print(f"\n  Which MCP client(s) do you want to configure?\n")
-
-    for i, client in enumerate(MCP_CLIENTS, 1):
-        path = client["get_path"]()
-        available = path is not None
-        status = ""
-        if not available:
-            status = dim(f" (not available on {platform_name()})")
-        elif path and path.exists():
-            status = green(" (config exists)")
-
-        num = f"{i:>2}"
-        print(f"    {cyan(num)}. {client['name']:<28} {dim(client['notes'])}{status}")
-
-    all_num = str(len(MCP_CLIENTS) + 1).rjust(2)
-    manual_num = str(len(MCP_CLIENTS) + 2).rjust(2)
-    print(f"\n    {cyan(all_num)}. {bold('All of the above')}")
-    print(f"    {cyan(manual_num)}. {bold('Manual setup')} {dim('(print config, I will set it up myself)')}")
-    print(f"    {cyan(' 0')}. {dim('Skip client configuration')}")
-
-    print()
-    try:
-        choice = input(f"  Select (comma-separated, e.g. 1,3,5): ").strip()
-    except (EOFError, KeyboardInterrupt):
-        print()
-        return []
-
-    if not choice or choice == "0":
-        return []
-
-    selections = []
-    for part in choice.replace(" ", "").split(","):
-        try:
-            idx = int(part)
-            if idx == len(MCP_CLIENTS) + 1:  # "All"
-                return CLIENT_IDS + ["manual"]
-            elif idx == len(MCP_CLIENTS) + 2:  # "Manual"
-                selections.append("manual")
-            elif 1 <= idx <= len(MCP_CLIENTS):
-                selections.append(MCP_CLIENTS[idx - 1]["id"])
-        except ValueError:
-            # Try matching by name/id
-            part_lower = part.lower()
-            for client in MCP_CLIENTS:
-                if part_lower in client["id"] or part_lower in client["name"].lower():
-                    selections.append(client["id"])
-                    break
-
-    return list(dict.fromkeys(selections))  # deduplicate, preserve order
-
-# ─── Main Install Flow ───────────────────────────────────────────────────────
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="DaVinci Resolve MCP Server — Universal Installer",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=textwrap.dedent("""\
-            Examples:
-              python install.py                            Interactive mode
-              python install.py --clients all              Configure all clients
-              python install.py --clients cursor,claude-desktop
-              python install.py --clients manual           Just print the config
-              python install.py --no-venv --clients cursor Skip venv, configure Cursor
-              python install.py --dry-run --clients all    Preview without writing
-              python install.py --update-policy auto       Enable guarded auto-updates
-              python install.py --update-policy never      Disable update checks
-        """)
-    )
-    parser.add_argument(
-        "--clients", type=str, default=None,
-        help="Comma-separated client IDs, or 'all' / 'manual' (skip interactive prompt)"
-    )
-    parser.add_argument(
-        "--no-venv", action="store_true",
-        help="Skip virtual environment creation (use system Python)"
-    )
-    parser.add_argument(
-        "--dry-run", action="store_true",
-        help="Preview config changes without writing files"
-    )
-    parser.add_argument(
-        "--python", type=str, default=None,
-        help="Path to Python executable to use in MCP configs"
-    )
-    parser.add_argument(
-        "--server", type=str, default=None,
-        help="Path to the MCP server script"
-    )
-    parser.add_argument(
-        "--update-policy",
-        choices=["prompt", "auto", "notify", "never"],
-        default=None,
-        help="Set local update policy: prompt, auto, notify, or never"
-    )
-    parser.add_argument(
-        "--update-now", action="store_true",
-        help="Apply a safe git fast-forward update if a newer release is available"
-    )
-    parser.add_argument(
-        "--clear-update-preferences", action="store_true",
-        help="Clear ignored-version and snooze update preferences"
-    )
-
-    args = parser.parse_args()
-    interactive = args.clients is None
-
-    # ── Banner ──
-    if interactive:
-        print_banner()
-
-    project_dir = Path(__file__).resolve().parent
-    total_steps = 5
-
-    if args.clear_update_preferences:
-        clear_update_prompt_preferences(project_dir)
-        print(f"  MCP Update: {green('Cleared ignored-version and snooze preferences')}")
-    if args.update_policy:
-        set_update_mode(project_dir, args.update_policy)
-        print(f"  MCP Update: {green('Policy set')} {dim(args.update_policy)}")
-
-    # ══════════════════════════════════════════════════════════════════════
-    # STEP 1: Platform & Resolve Detection
-    # ══════════════════════════════════════════════════════════════════════
-
-    if interactive:
-        print_step(1, total_steps, "Detecting Platform & DaVinci Resolve")
-
-    print(f"  Platform:  {bold(platform_name())} ({platform.machine()})")
-    update_result = print_update_status(project_dir, force=args.update_now)
-    maybe_prompt_for_update(
-        project_dir,
-        update_result,
-        interactive=interactive,
-        force_update=args.update_now,
-        dry_run=args.dry_run,
-    )
-
-    api_path, lib_path = find_resolve_paths()
-
-    if api_path:
-        print(f"  API Path:  {green(api_path)}")
-    else:
-        print(f"  API Path:  {red('Not found')}")
-        if is_linux():
-            print(f"  {dim('Tip: DaVinci Resolve typically installs to /opt/resolve/')}")
-            print(f"  {dim('     Set RESOLVE_SCRIPT_API environment variable if installed elsewhere')}")
-
-        # Check environment variable fallback
-        env_api = os.environ.get("RESOLVE_SCRIPT_API")
-        if env_api and os.path.isdir(env_api):
-            api_path = env_api
-            print(f"  {green('Found via $RESOLVE_SCRIPT_API:')} {api_path}")
-
-    if lib_path:
-        print(f"  Library:   {green(lib_path)}")
-    else:
-        print(f"  Library:   {yellow('Not found')} {dim('(optional — API path is sufficient)')}")
-
-    resolve_running = check_resolve_running()
-    if resolve_running:
-        print(f"  Resolve:   {green('Running')}")
-    else:
-        print(f"  Resolve:   {yellow('Not running')} {dim('(start Resolve to verify connection)')}")
-
-    if not api_path:
-        print(f"\n  {yellow('Warning:')} Could not auto-detect DaVinci Resolve installation.")
-        print(f"  The installer will continue, but you may need to set RESOLVE_SCRIPT_API manually.")
-        if interactive and not prompt_yes_no("Continue anyway?"):
-            print(f"\n  {dim('Aborted.')}")
-            sys.exit(1)
-
-    # ══════════════════════════════════════════════════════════════════════
-    # STEP 2: Python Virtual Environment
-    # ══════════════════════════════════════════════════════════════════════
-
-    venv_path = project_dir / "venv"
-    venv_python = get_venv_python(venv_path)
-    skip_venv = args.no_venv
-
-    if interactive:
-        print_step(2, total_steps, "Python Environment")
-
-    if skip_venv:
-        print(f"  Skipping venv (--no-venv)")
-        python_path = Path(args.python) if args.python else Path(sys.executable)
-        require_supported_python(python_path, "Selected Python")
-        print(f"  Using:     {python_path}")
-    elif venv_path.exists() and venv_python.exists():
-        print(f"  Venv:      {green('Already exists')} at {dim(str(venv_path))}")
-        python_path = venv_python
-        require_supported_python(python_path, "Existing venv")
-
-        # Check if deps are installed
-        try:
-            result = subprocess.run(
-                [str(python_path), "-c", "import mcp; print('ok')"],
-                capture_output=True, text=True
-            )
-            if result.stdout.strip() == "ok":
-                print(f"  MCP SDK:   {green('Installed')}")
-            else:
-                print(f"  MCP SDK:   {yellow('Missing')} — installing...")
-                install_dependencies(venv_path, project_dir)
-                print(f"  MCP SDK:   {green('Installed')}")
-        except Exception:
-            install_dependencies(venv_path, project_dir)
-            print(f"  MCP SDK:   {green('Installed')}")
-    else:
-        if interactive:
-            create_venv_ok = prompt_yes_no("Create virtual environment?")
-        else:
-            create_venv_ok = True
-
-        if create_venv_ok:
-            require_current_python("Virtual environment")
-            create_venv(venv_path)
-            python_path = venv_python
-            require_supported_python(python_path, "Created venv")
-            install_dependencies(venv_path, project_dir)
-            print(f"  Venv:      {green('Created')}")
-            print(f"  MCP SDK:   {green('Installed')}")
-        else:
-            python_path = Path(args.python) if args.python else Path(sys.executable)
-            require_supported_python(python_path, "Selected Python")
-            print(f"  Using system Python: {python_path}")
-
-    # Override python path if explicitly provided
-    if args.python:
-        python_path = Path(args.python)
-        require_supported_python(python_path, "Selected --python")
-
-    # ══════════════════════════════════════════════════════════════════════
-    # STEP 3: Locate Server Script
-    # ══════════════════════════════════════════════════════════════════════
-
-    if interactive:
-        print_step(3, total_steps, "Server Script")
-
-    if args.server:
-        server_path = Path(args.server).resolve()
-    else:
-        # Try to find the compound server first.
-        candidates = [
-            project_dir / "src" / "server.py",
-            project_dir / "src" / "resolve_mcp_server.py",
-            project_dir / "src" / "main.py",
-            project_dir / "resolve_mcp_server.py",
-        ]
-        server_path = None
-        for c in candidates:
-            if c.exists():
-                server_path = c
-                break
-        if server_path is None:
-            server_path = candidates[0]  # default even if not found yet
-
-    if server_path.exists():
-        print(f"  Server:    {green(str(server_path))}")
-    else:
-        print(f"  Server:    {yellow(str(server_path))} {dim('(file not found — check path)')}")
-
-    # ══════════════════════════════════════════════════════════════════════
-    # STEP 4: Configure MCP Clients
-    # ══════════════════════════════════════════════════════════════════════
-
-    if interactive:
-        print_step(4, total_steps, "MCP Client Configuration")
-
-    # Determine which clients to configure
-    if args.clients:
-        if args.clients.lower() == "all":
-            selected_ids = CLIENT_IDS
-        elif args.clients.lower() == "manual":
-            selected_ids = ["manual"]
-        else:
-            selected_ids = [s.strip() for s in args.clients.split(",")]
-    elif interactive:
-        selected_ids = prompt_clients()
-    else:
-        selected_ids = []
-
-    # Show manual config if requested
-    show_manual = "manual" in selected_ids
-    client_ids = [c for c in selected_ids if c != "manual"]
-
-    configured = []
-    skipped = []
-
-    for client_id in client_ids:
-        client = next((c for c in MCP_CLIENTS if c["id"] == client_id), None)
-        if not client:
-            print(f"  {yellow('Unknown client:')} {client_id}")
-            skipped.append(client_id)
-            continue
-
-        success, message = write_client_config(
-            client, python_path, server_path, api_path, lib_path, dry_run=args.dry_run
-        )
-
-        if success:
-            if args.dry_run:
-                print(f"\n  {cyan(client['name'])} {dim('(dry run)')}")
-                for line in message.split("\n"):
-                    print(f"    {line}")
-                configured.append(client["name"])
-            else:
-                print(f"  {green('✓')} {client['name']:<28} → {dim(message)}")
-                configured.append(client["name"])
-        else:
-            print(f"  {yellow('⊘')} {client['name']:<28}   {dim(message)}")
-            skipped.append(client["name"])
-
-    # Show manual config
-    if show_manual:
-        standard, vscode_fmt, zed_fmt, opencode_fmt = generate_manual_config(
-            python_path, server_path, api_path, lib_path
-        )
-        env_preview = build_server_env(python_path, api_path, lib_path)
-        print(f"\n  {bold('Manual Configuration')}")
-        print(f"  {'─' * 50}")
-        print(f"\n  {cyan('Standard format')} (Claude Desktop, Cursor, Windsurf, Cline, Roo Code, Continue):")
-        print()
-        for line in standard.split("\n"):
-            print(f"    {line}")
-        print(f"\n  {cyan('VS Code format')} (GitHub Copilot agent mode — save as .vscode/mcp.json):")
-        print()
-        for line in vscode_fmt.split("\n"):
-            print(f"    {line}")
-        print(f"\n  {cyan('Zed format')} (add to ~/.config/zed/settings.json):")
-        print()
-        for line in zed_fmt.split("\n"):
-            print(f"    {line}")
-        print(f"\n  {cyan('OpenCode format')} (add to ~/.config/opencode/opencode.json or a project opencode.json):")
-        print()
-        for line in opencode_fmt.split("\n"):
-            print(f"    {line}")
-        print(f"\n  {cyan('JetBrains IDEs')} (IntelliJ, WebStorm, PyCharm, etc.):")
-        print(f"    Settings → Tools → AI Assistant → Model Context Protocol (MCP)")
-        print(f"    Add server with command: {python_path} {server_path}")
-        for key, value in env_preview.items():
-            print(f"    Set env: {key}={value}")
-        print()
-
-    if not selected_ids:
-        print(f"  {dim('No clients selected — skipping configuration')}")
-
-    # ══════════════════════════════════════════════════════════════════════
-    # STEP 5: Verify Connection
-    # ══════════════════════════════════════════════════════════════════════
-
-    if interactive:
-        print_step(5, total_steps, "Verification")
-
-    if api_path:
-        success, message = verify_resolve_connection(python_path, api_path, lib_path)
-        try:
-            py_abi_risk = is_abi_risk_python_version(_version_for_python(python_path))
-        except Exception:
-            py_abi_risk = False
-        if success:
-            if "not running" in message.lower():
-                print(f"  API:       {green('Module loads OK')}")
-                # If Resolve IS running but the bridge still reported no connection
-                # on a 3.13+ interpreter, that is the ABI-mismatch signature.
-                if resolve_running and py_abi_risk:
-                    print(
-                        f"  Resolve:   {yellow('Running, but the scripting bridge returned no connection')}"
-                    )
-                    print(
-                        f"             This can happen on Python 3.13+ with older Resolve builds. "
-                        f"If MCP tools fail, recreate the venv with Python 3.10-3.12."
-                    )
-                else:
-                    print(f"  Resolve:   {yellow('Not running')} — start Resolve to use MCP tools")
-            else:
-                print(f"  Connected: {green(message)}")
-        else:
-            print(f"  Verify:    {yellow(message)}")
-            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:
-        print(f"  {yellow('Skipped')} — Resolve API path not detected")
-
-    # ══════════════════════════════════════════════════════════════════════
-    # Summary
-    # ══════════════════════════════════════════════════════════════════════
-
-    print(f"\n  {'═' * 50}")
-    if configured or show_manual:
-        print(f"  {green(bold('Setup complete!'))}")
-        if configured:
-            print(f"  Configured: {', '.join(configured)}")
-        print()
-        print(f"  {bold('Next steps:')}")
-        if not resolve_running:
-            print(f"    1. Start DaVinci Resolve")
-            print(f"    2. Open your MCP client")
-            print(f"    3. Start using natural language to control Resolve!")
-        else:
-            print(f"    1. Open your MCP client")
-            print(f"    2. Start using natural language to control Resolve!")
-        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}')}")
-    elif not selected_ids:
-        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()
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        print(f"\n\n  {dim('Interrupted.')}\n")
-        sys.exit(1)