davinci-resolve-mcp
samuelgursky/davinci-resolve-mcp
- Type
- MCP server
- Scanned
- Nov 13, 2026
- Version
- 331f7690c4a7
- Files read
- 1076
This tool lets AI assistants control DaVinci Resolve live, analyze media files, and edit Resolve projects, timelines, color grades, and databases offline. The biggest risk is that a tricked AI assistant can turn off built-in safety guards, overwrite arbitrary files, read private local databases like browser cookies, or run malicious code on your computer through Resolve scripts and plugins.
What it can reach
- Files
- Reads media files, Resolve project and timeline files, and local SQLite databases, and writes rendered media, reports, configuration files, and executable Resolve plugins and scripts on disk.
- Network
- Checks GitHub for updates, connects to PostgreSQL project servers, remote Resolve hosts, and transcription services, can fetch remote URLs via FFmpeg, and optionally runs local web servers on your machine.
- Shell commands
- Runs local helper programs such as ffmpeg, Whisper, Python, Node, git, database backup tools, package installers, OS window and process utilities, and optional batch CLI hooks.
- Secrets
- Reads database passwords and service settings from environment variables, and creates and reads local authentication tokens for its control panel, Resolve bridge, and local network server.
- Browser
- Opens your default web browser to the local control panel when launched and generates prefilled GitHub issue links.
- System
- Controls live DaVinci Resolve editing and rendering sessions, launches or quits Resolve, sends window focus and keystrokes, inspects or stops local processes, opens folder pickers, and can open macOS terminal apps.
Findings
-
HighFusion composition inputs and expressions allow arbitrary Lua code execution
Although the server removed inline script execution in v3.0.0 so callers cannot run code on the host, the fusion_comp tool still lets an agent set arbitrary tool inputs (including Fusion's FrameRenderScript, StartRenderScript, and EndRenderScript) and colon-prefixed Lua simple expressions without any confirmation gate. When a frame is rendered via fusion_comp render or timeline_frame capture, DaVinci Resolve's Fusion Lua engine executes that code with standard os and io libraries available, allowing a prompt-injected agent to run arbitrary OS commands.
Fix: Block script-bearing Fusion inputs (FrameRenderScript, StartRenderScript, EndRenderScript, Comments/RunScript) in set_input, safe_set_inputs, and bulk_set_inputs, and reject colon-prefixed Lua script expressions or os/io calls in bulk_set_expressions.
-
HighUnconfirmed Fuse and script plugin installation enables code execution on Resolve startup
The fuse_plugin and script_plugin tools allow raw install and remove actions with overwrite=true and no confirmation token, bypassing the _mcp_ name prefix and @mcp-fuse/@mcp-script ownership markers enforced by safe_install_extension. Because DaVinci Resolve automatically loads and executes all .fuse Lua files in its Fuses directory on startup—and the agent can quit and relaunch Resolve via resolve_control—a prompt-injected agent can plant a malicious .fuse file (or overwrite existing scripts such as resolve_bridge.py) and trigger arbitrary code execution.
Fix: Require confirmation tokens for installing or removing Fuse and script plugins, enforce @mcp-* ownership markers and disallow overwriting non-MCP files on all actions, or gate plugin installation behind an explicit startup flag.
-
HighAgent-accessible setup tool can disable safe_mode, confirmation tokens, and audit logging or redirect log files
The setup tool's set_defaults action lets the AI agent modify security settings in logs/media-analysis-preferences.json without user confirmation and with destructiveHint set to false. A prompt-injected agent can set require_confirm_token, safe_mode, audit_log, and operation_log to false—disabling confirmation gates and audit trails across both servers—and can set audit_log_path or operation_log_path to any path on disk so subsequent operations append JSONL lines to arbitrary files, or set updates.mode to auto.
Fix: Make destructive.*, audit/operation log paths, and updates.mode read-only over MCP so only the human operator or local config file can change them, and restrict any custom log paths to the server's logs directory.
-
HighAudit report export can overwrite arbitrary files and bypasses safe mode
src/utils/execution_trace.py:705
An AI agent tricked by prompt injection can call end_execution with attacker-chosen multi-line text in notes and then call export_execution_report with overwrite=true and any output_path on disk. Because output_path has no file-extension or directory check, it can overwrite user-writable files such as shell startup configs, SSH authorized_keys, or Resolve scripts with attacker-controlled lines. In addition, execution_lifecycle.py classifies every action starting with export_ as read-only and destructive_hook.py omits export_execution_report, so destructive.safe_mode, confirmation tokens, and security audit logs never trigger.
Fix: Restrict output_path to .md or .json extensions within approved directories, sanitize or escape raw newlines in free-text fields, and register export_execution_report (especially with overwrite=true) as a destructive write subject to safe_mode, confirmation tokens, and audit logging.
-
HighUnvalidated FFmpeg input paths allow server-side request forgery and data exfiltration
src/utils/sound_density.py:219
Unlike other FFmpeg helpers in this project, sound_density.measure_track_levels (and prebalance.measure_frame_levels) passes caller-supplied media paths directly to ffmpeg -i without checking os.path.isfile or restricting FFmpeg protocols. Because FFmpeg natively fetches http, https, tcp, and ftp URLs, a prompt-injected agent can call sound_density_audit or plan_reference_match with a URL to probe internal localhost or LAN services or exfiltrate project data in URL query parameters.
Fix: Validate every input media path with os.path.isfile and option_like_path_error before invoking FFmpeg, and pass -protocol_whitelist file,pipe to ffmpeg.
-
HighOffline project_read tool can query any SQLite database on the computer
resolve-advanced/server/tools/project_read.mjs:85
The project_read tool is presented as a read-only inspector for DaVinci Resolve Project.db files, and MCP clients often auto-approve read-only tools. However, its projectDb argument accepts any file path on disk and open() calls openGuarded without requiring any Resolve-specific table such as SM_Project, then query runs any caller-supplied SELECT, WITH, or PRAGMA statement and returns the rows. If the AI agent reads untrusted text containing a prompt injection, an attacker can instruct it to query sensitive non-Resolve SQLite databases at standard paths, such as Cursor or VS Code state.vscdb auth token stores, browser Cookies and Login Data files, or macOS Messages chat.db.
Fix: Require a Resolve schema table such as SM_Project in openGuarded before opening projectDb (matching project_db.mjs), and reject SQLite files that do not match the DaVinci Resolve project database schema.
-
MediumCaller-supplied PostgreSQL host can leak PGPASSWORD and reach internal network services
resolve-advanced/server/offline-ref-db.mjs:208
The offline_ref (and conform/lineage) PostgreSQL database helpers accept a caller-supplied postgres object with arbitrary host and port values, falling back to process.env.PGPASSWORD (or .pgpass) when password is omitted. If a prompt-injected agent passes an attacker-controlled host to a read-only action such as listing timelines, a rogue PostgreSQL server requesting cleartext password authentication will receive the user's PGPASSWORD over the network; even without PGPASSWORD, the agent can probe internal hosts and databases despite the advanced server documenting no network calls.
Fix: Read PostgreSQL connection endpoints and credentials exclusively from operator-controlled environment variables or local Resolve config rather than tool arguments, or restrict host to loopback addresses and never send PGPASSWORD to caller-chosen hosts.
-
MediumGranular inspect_custom_object tool is marked read-only but invokes arbitrary zero-argument methods
src/granular/resolve_control.py:188
In the optional --full granular server, inspect_custom_object is automatically annotated with readOnlyHint=true because its name begins with inspect_, causing MCP clients to auto-approve it without prompting the user. However, any dot-separated segment ending in () is called directly on the target object, allowing destructive Resolve calls such as Quit(), DeleteAllRenderJobs(), or ResetAllGrades() without triggering granular_destructive_op or audit logging, and attribute traversal does not block Python dunder attributes such as __init__ or __globals__.
Fix: Remove arbitrary method invocation from inspect_custom_object (use a strict allowlist of read-only getter methods such as GetMediaStorage, GetProjectManager, GetCurrentProject, GetMediaPool, GetCurrentTimeline) and reject attribute names starting with an underscore.
-
Mediumopen_control_panel with force_restart=true sends SIGTERM to any user process on the chosen TCP port
In resolve_control(action='open_control_panel'), passing force_restart=true skips checking whether the listener on the requested port is actually a davinci-resolve-mcp dashboard, looks up the port owner with lsof, and sends SIGTERM to that PID. A prompt-injected agent can pass any local port number (such as a database, dev server, proxy, or Resolve bridge port) with force_restart=true to terminate unrelated user processes.
Fix: Only terminate a process if it matches a verified PID from the private control_panel.json pidfile or passes _control_panel_probe as a genuine davinci-resolve-mcp dashboard.
-
MediumFFprobe and FFmpeg wrappers allow remote URLs and network protocols (SSRF) in the offline server
resolve-advanced/server/ffprobe-media.mjs:27
Although the advanced server documents that it makes no network calls and can be run in cloud or local environments, probeMedia, probeStream, extractFrames, and loudnessQc pass caller-supplied input paths to ffprobe and ffmpeg without verifying that the path is an existing local file or restricting FFmpeg's protocol whitelist. A prompt-injected agent (or a local HLS playlist referencing remote segments) can pass http://, https://, tcp://, or ftp:// URLs to trigger outbound SSRF requests.
Fix: Verify that media inputs exist as local regular files with fs.statSync before invoking ffprobe or ffmpeg, and pass '-protocol_whitelist', 'file' in the spawned argument list.
-
MediumUnpacking .drp archives via external unzip materializes and follows symbolic links
resolve-advanced/server/drp-timeline-clips.mjs:110
Unlike other modules in the advanced server that inspect .drp zip archives in memory with JSZip, openDrp and readProjectXml extract .drp files to a temporary directory using the system unzip command and read extracted XML files with fs.readFileSync. Because Info-ZIP unzip extracts symbolic links onto disk by default, opening a crafted .drp file from an untrusted source can cause the server to follow symlinks to local XML or Resolve files outside the archive.
Fix: Read project.xml, MpFolder.xml, and SeqContainer/*.xml in memory using JSZip (already a package dependency) instead of extracting archives to disk with spawnSync('unzip', ...).
-
MediumImproper single-quote escaping in lut3d filter allows FFmpeg filtergraph injection
In FFmpeg filtergraph syntax, a backslash inside single quotes is treated literally and does not escape a single quote. If an existing LUT file or parent folder contains a single quote followed by filter syntax (for example from an extracted archive), lut_path breaks out of lut3d='...' during assess_grade or grade_loop.run and injects arbitrary FFmpeg filters such as signature=filename=..., which can overwrite files on disk during a read-only QC check.
Fix: Stage or copy the verified LUT file to a temporary path with a safe alphanumeric filename before passing it to ffmpeg's lut3d filter, or reject paths containing single quotes and filter delimiters.
-
MediumLUT fallback helper copies arbitrary files into shared system LUT directory
When Graph.SetLUT returns False, ensure_lut_in_master copies lut_path into the system-wide master LUT folder (such as C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\LUT\MCP\ or /Library/Application Support/Blackmagic Design/DaVinci Resolve/LUT/MCP/) without checking LUT file extensions, preventing relative ../ traversal, or checking before overwriting an existing file. On Windows, shutil.copy2 does not preserve restrictive NTFS ACLs, so a prompt-injected agent passing a private file path (like bridge.json or an SSH key) exposes a readable copy to all local users on the machine.
Fix: Validate that lut_path has an allowed LUT extension, resolve and confine relative paths to the user or master LUT directories, and refuse to overwrite existing files in MCP/ without explicit confirmation.
-
MediumAuto-loaded house-style skill instructs the agent to modify its own skill file
.agents/skills/house-style/SKILL.md:13
Both .agents/skills/house-style/SKILL.md and its identical copy at .claude/skills/house-style/SKILL.md are configured to load automatically before editing tasks (with user-invocable set to false) and instruct the agent to append new rules into the SKILL.md file itself whenever an editorial decision is corrected. A user giving feedback on a video cut has not asked the agent to modify repository skill files, and the skill's description does not mention writing to disk. Under workspace-write permissions, if untrusted text in transcripts, subtitles, or clip metadata tricks the agent into treating injected text as an editorial correction, the agent can persist attacker-chosen instructions into SKILL.md for future sessions.
Fix: Remove the self-modification instruction from SKILL.md, or require explicit user confirmation before saving preferences to a separate data file that is not loaded as executable skill instructions.
-
LowBridge installer copies HMAC token into all-users folders and shadows user config
scripts/install_resolve_bridge.py:682
When installing the free-edition bridge, _install_to() copies bridge.json (containing the live HMAC authentication token and allowed roots) into .davinci_mcp_runtime/bridge.json inside every detected Resolve Scripts tree, not just macOS App Store sandbox containers. On Windows, when installed into the all-users %PROGRAMDATA% tree, os.chmod(runtime_config, 0o600) only clears the read-only bit and does not restrict NTFS ACLs, leaving the bridge token readable by every local user account on the computer so another local user can send authenticated commands to 127.0.0.1:49632. In addition, resolve_bridge_launcher.py always prefers this runtime copy over ~/.config/davinci-resolve-mcp/bridge.json, silently ignoring later manual token rotations or path restrictions in the user config.
Fix: Only copy bridge.json into .davinci_mcp_runtime when the target path is inside a macOS ~/Library/Containers sandbox; for all other targets, read bridge.json exclusively from the per-user config path and avoid writing secrets under %PROGRAMDATA% or /Library/Application Support.
-
LowControl panel installs and launches the unguarded granular MCP server instead of the compound server
src/analysis_dashboard.py:14876
When a user clicks Install for an AI client or Start networked under Setup -> MCP in the local control panel, _resolve_mcp_paths() hardcodes src/resolve_mcp_server.py (the 390-tool granular server) rather than src/server.py (the 37-tool compound server configured by install.py). Unlike the compound server, granular mode exposes raw Resolve API methods directly to the agent without automatic pre-mutation timeline archiving or compound workflow guards.
Fix: Point _resolve_mcp_paths() in src/analysis_dashboard.py to src/server.py by default so client configs and networked transport match install.py and keep compound-mode guards and timeline archiving.
-
LowSelf-update pulls upstream branch tip instead of the checked release tag and ignores SHA mismatches
Both the installer and the control panel advertise updates against a specific GitHub Release version, but apply_safe_self_update() runs git pull --ff-only on the tracking branch rather than checking out the release tag or target SHA. Even when the subsequent check against release_target_sha detects a mismatch (integrity.verified = False), the update still reports success without warning the user and install.py immediately re-executes the newly pulled code.
Fix: Fetch and fast-forward or check out the exact release tag/SHA returned by the release check, and refuse or warn before re-executing when HEAD does not match release_target_sha.
-
LowSetup and control-panel client install run unpinned npm and pip installs without --ignore-scripts
During setup, sync, or when clicking Install for a client in the control panel, provision_advanced_node_deps() (and bin/davinci-resolve-mcp.mjs) runs npm install in resolve-advanced/ against caret version ranges without a packaged lockfile and without --ignore-scripts, and install_dependencies() installs Python packages from unpinned version ranges. Because the required Node packages are pure JavaScript (optional native modules are omitted), running npm install without a lockfile or --ignore-scripts unnecessarily exposes setup to transitive dependency install scripts.
Fix: Include resolve-advanced/package-lock.json in package.json files, run npm ci --ignore-scripts --omit=dev --omit=optional, and pin Python dependency versions in requirements.txt.
-
LowGranular graph_apply_grade_from_drx bypasses destructive annotations, safe_mode, and confirmation tokens
Replacing a clip's node graph from a .drx file unrecoverably overwrites existing grading work and is gated by confirm_token and destructive_op in the compound server. In the optional granular server, graph_apply_grade_from_drx lacks @granular_destructive_op(), has no confirmation token check, and receives destructiveHint=false because apply_ is classified as a plain write prefix in src/granular/common.py, bypassing destructive.safe_mode and the security audit log.
Fix: Decorate graph_apply_grade_from_drx with @mcp.tool(annotations=DESTRUCTIVE_TOOL) and @granular_destructive_op(), and require CONFIRM_TOKENS just like ti_copy_grades.
-
LowMedia analysis field-correction helpers accept arbitrary absolute clip_dir paths outside project_root
While media_analysis documents that all outputs are validated to stay under the davinci-resolve-mcp-analysis project root and never write beside source media, _v2_corrections_path_for_clip accepts any absolute clip_dir path without checking that it resides inside project_root. Calling update_shot_field or update_clip_field with an arbitrary clip_dir creates directories and writes a corrections.json file at that location.
Fix: Resolve clip_dir with os.path.realpath and verify via os.path.commonpath that it lies inside os.path.realpath(project_root) before reading or writing corrections.json.
-
LowExecutable plugin and script installation is rated medium risk and bypasses safe mode
src/utils/execution_lifecycle.py:294
RiskClassificationHook classifies fuse_plugin.install, script_plugin.install, and script_plugin.safe_install_extension as medium risk rather than high or critical, even when overwrite=true replaces an existing script. Installing a .fuse file into Resolve's Fuses directory runs arbitrary Lua code automatically the next time Resolve starts, and installing a .py or .lua script plants executable code in Resolve's Scripts menu. Because destructive.safe_mode only blocks high and critical actions, users who enable safe mode remain exposed to persistent code execution.
Fix: Classify fuse_plugin.install, script_plugin.install, and script_plugin.safe_install_extension as high or critical risk with system blast radius, and require a one-time confirm_token before writing or overwriting executable extensions.
-
LowDestructive timeline tools in granular server bypass safe mode and audit logging
Although the README states that destructive writes on both servers honour destructive.safe_mode and the security audit log, several mutating tools in src/granular/timeline.py—including high-risk actions timeline_import_into, timeline_create_compound_clip, timeline_create_fusion_clip, and timeline_convert_to_stereo—lack the @granular_destructive_op() decorator. When running in granular (--full) mode, an agent can invoke these tools to irreversibly alter timelines without being blocked by safe_mode or recorded in security-audit.jsonl.
Fix: Add @granular_destructive_op() to all mutating tools in src/granular/timeline.py and map timeline_import_into to HIGH risk to match compound mode's import_into_timeline rating.
-
LowPath traversal in edit_engine plan_id allows reading and overwriting external JSON files
load_plan and mark_plan_executed build file paths directly from plan_id without checking for path separators or .. segments, and os.path.join discards the base directory if plan_id is absolute. Because plan fingerprints use an unkeyed SHA-256 hash rather than a secret HMAC, an agent can probe whether arbitrary .json files exist outside the project root or load and overwrite a crafted plan JSON file placed anywhere on disk.
Fix: Validate that plan_id matches a strict hex identifier pattern (such as ^[a-f0-9]{12}$) and verify the resolved path stays inside _plan_dir(project_root).
-
LowShared /tmp busy sidecar and page lock files allow local cross-user denial of service
While token state files were moved to a private 0700 home directory, resolve_busy.py and page_lock.py still use fixed filenames (davinci_resolve_mcp_busy.json and davinci_resolve_mcp_page.lock) inside tempfile.gettempdir(). On multi-user Linux systems where /tmp is shared, another local user can pre-create the busy sidecar referencing an active system PID or hold an exclusive flock on the page lock file to stall or block Resolve MCP operations.
Fix: Place davinci_resolve_mcp_busy.json and davinci_resolve_mcp_page.lock inside private_state.private_state_dir() (~/.davinci-resolve-mcp/ with 0700 permissions) instead of the shared system temp directory.
-
LowCompanion Node server ignores safe_mode and skips the security audit log
resolve-advanced/server/tools/project_db.mjs:139
Normal setup registers both the Python davinci-resolve server and the Node davinci-resolve-advanced server, and the README states under Security Posture that destructive writes on both servers honour destructive.safe_mode and the security audit log. That statement only holds for the two Python server modes (compound and granular); none of the mutating tools in davinci-resolve-advanced check destructive.safe_mode or write to logs/security-audit.jsonl, and iConfirmProjectClosed is simply a boolean argument that the AI agent itself can set to true. A user who enables safe_mode or relies on the audit log can still have closed Project.db databases and files modified unblocked and unlogged if an agent is tricked into calling the advanced server.
Fix: Enforce the user's destructive.safe_mode preference and append audit records to logs/security-audit.jsonl in davinci-resolve-advanced before executing database or in-place file mutations, or clearly document in README.md and SECURITY.md that safe_mode and audit logging do not cover davinci-resolve-advanced.
-
LowFairlight database writes bypass closed-project checks, schema guards, and backups
resolve-advanced/server/tools/fairlight.mjs:29
Unlike project_db.mjs, which verifies the Resolve schema, requires iConfirmProjectClosed or checks that Resolve is not running, and creates a backup copy before modifying Project.db, fairlight.mjs opens dbPath directly with better-sqlite3 in read-write mode for expand_buses, import_template, and restore. This creates a new empty SQLite file if dbPath does not exist and overwrites binary bus-routing blobs without a backup or closed-project check, risking project corruption if an agent invokes it while Resolve is open.
Fix: Route fairlight.mjs database writes through db-patch.mjs openGuarded, requireClosed (including the Resolve process check), and backup helpers, and pass fileMustExist: true when opening existing databases.
-
LowAuto-loaded house-style skill instructs the agent to modify its own skill file
.claude/skills/house-style/SKILL.md:13
Both .claude/skills/house-style/SKILL.md and .agents/skills/house-style/SKILL.md set user-invocable: false so coding agents load them automatically before editing tasks, and tell the agent to append new rules into the SKILL.md file whenever the user corrects an edit. Users working in a git checkout may not expect routine feedback to rewrite tracked skill files, and prompt injection hidden in transcripts, subtitles, or markers could abuse this rule to persist attacker-chosen instructions across future sessions.
Fix: Require explicit user confirmation before editing SKILL.md, store learned editorial preferences in a separate gitignored data file instead of an instruction file, and treat media transcripts and metadata as untrusted.
