davinci-resolve-mcp 2.124.0 → 2.126.0

package/docs/guides/native-drt-authoring.md

@@ -111,6 +111,12 @@ Everything else stays in `droppedTransitions` with the reason.
 3. For audio: RMS per window (silence = -inf is a failed placement).
 4. Never trust `created_new: false` — a same-named timeline already in the
    project is returned as "success" (internal-name-wins law).
+5. Close the loop with `editorial.verify_roundtrip`: parse the original
+   interchange and Resolve's own re-export of the imported timeline, and the
+   verifier normalizes track labels, source naming, and per-source
+   TC-absolute source frames (fitting the offsets, e.g. 86400 for a
+   01:00:00:00 source) — `pass: true` means the authored timeline's export
+   matches the turnover's intent event-for-event.
 
 ## References
 

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.124.0"
+VERSION = "2.126.0"
 # Only hard floor: mcp[cli] requires Python 3.10+. There is no upper bound —
 # Resolve's scripting bridge loads into newer interpreters on recent builds
 # (Python 3.14 verified against Resolve Studio 20.3.2). Older Resolve builds

package/package.json

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

package/resolve-advanced/server/aaf.mjs

@@ -18,7 +18,13 @@ const PROBE = fileURLToPath(new URL('./aaf_probe.py', import.meta.url));
 
 /** python interpreter — overridable for environments/tests (must have `aaf2` importable). */
 function pythonCmd() {
-  return process.env.AAF_PROBE_PYTHON || process.env.PYTHON || 'python3';
+  if (process.env.AAF_PROBE_PYTHON) return process.env.AAF_PROBE_PYTHON;
+  if (process.env.PYTHON) return process.env.PYTHON;
+  // The repo venv carries pyaaf2; a bare python3 usually does not. Prefer it
+  // when present so the tool path works without env plumbing.
+  const venvPy = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'venv', 'bin', 'python');
+  if (existsSync(venvPy)) return venvPy;
+  return 'python3';
 }
 
 const REMEDIATION =

package/resolve-advanced/server/author-interchange.mjs

@@ -575,3 +575,62 @@ export async function authorInterchange(events, target, opts = {}) {
   }
   throw new Error(`authorInterchange: unknown target '${target}' (otio|edl|drt)`);
 }
+
+/**
+ * verifyRoundtrip — assert that a re-EXPORT of an authored timeline matches
+ * the interchange it was built from, normalizing the three cross-format
+ * conventions measured on a live AAF→assemble→import→OTIO-export loop
+ * (19.1.3.7):
+ *   1. track labels: first tracks read 'V'/'A' in one format, 'V1'/'A1' in
+ *      the other — canonicalized to the numbered form;
+ *   2. source names: AAF mob name vs file basename ('rt_source_1' vs
+ *      'rt_source_1.mov') — compared after stripping the extension,
+ *      case-insensitively;
+ *   3. source frames: Resolve's OTIO export is TIMECODE-ABSOLUTE while
+ *      event lists are usually source-relative — a CONSTANT per-source
+ *      offset is fitted from the first pair and every other pair must agree
+ *      (the offset itself is reported, e.g. 86400 for a 01:00:00:00 source).
+ * Record positions are min-anchored per side. Video events only (audio
+ * channel legs merge by design).
+ *
+ * @returns {{pass:boolean, pairs:number, srcOffsets:Object, mismatches:Array}}
+ */
+export function verifyRoundtrip(inputEvents, exportedEvents, opts = {}) {
+  const recTol = opts.recTol ?? 1;
+  const srcTol = opts.srcTol ?? 1;
+  const canonTrack = (t) => {
+    const m = /^([VA])(\d+)?$/.exec(String(t || ''));
+    return m ? `${m[1]}${m[2] || '1'}` : String(t);
+  };
+  const canonSource = (x) => String(x || '').replace(/\.[^.]+$/, '').toLowerCase();
+  const vids = (evts) => evts.filter((e) => /^V\d*$/.test(String(e.track)) && e.recIn != null && e.recOut != null);
+  const norm = (evts) => {
+    const v = vids(evts);
+    if (!v.length) return [];
+    const off = Math.min(...v.map((e) => e.recIn));
+    return v
+      .map((e) => ({ track: canonTrack(e.track), source: canonSource(e.source), recIn: e.recIn - off, recOut: e.recOut - off, srcIn: e.srcIn ?? 0 }))
+      .sort((a, b) => a.track.localeCompare(b.track) || a.recIn - b.recIn);
+  };
+  const a = norm(inputEvents);
+  const b = norm(exportedEvents);
+  const mismatches = [];
+  if (a.length !== b.length) mismatches.push({ kind: 'count', input: a.length, exported: b.length });
+  const srcOffsets = {};
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i += 1) {
+    const x = a[i], y = b[i];
+    if (x.track !== y.track) { mismatches.push({ kind: 'track', at: i, input: x.track, exported: y.track }); continue; }
+    if (x.source !== y.source) { mismatches.push({ kind: 'source', at: i, input: x.source, exported: y.source }); continue; }
+    if (Math.abs(x.recIn - y.recIn) > recTol || Math.abs(x.recOut - y.recOut) > recTol) {
+      mismatches.push({ kind: 'record', at: i, input: [x.recIn, x.recOut], exported: [y.recIn, y.recOut] });
+      continue;
+    }
+    const off = y.srcIn - x.srcIn;
+    if (srcOffsets[x.source] === undefined) srcOffsets[x.source] = off;
+    else if (Math.abs(off - srcOffsets[x.source]) > srcTol) {
+      mismatches.push({ kind: 'source-frames', at: i, source: x.source, expectedOffset: srcOffsets[x.source], gotOffset: off });
+    }
+  }
+  return { pass: mismatches.length === 0, pairs: n, srcOffsets, mismatches };
+}

package/resolve-advanced/server/tools/drt.mjs

@@ -213,8 +213,13 @@ export const drtTool = {
       let content = p.content;
       let events;
       if (p.format === 'aaf') {
+        // BUG FIX: this branch used to fall through to the sync
+        // parseInterchange, which THROWS for aaf ("parse it via the async
+        // AAF path") — the tool-layer AAF route never worked until now.
         if (!p.path) return { error: 'aaf input requires path' };
-        content = p.path;
+        const { parseAAF } = await import('../aaf.mjs');
+        const parsed = await parseAAF(p.path);
+        events = Array.isArray(parsed) ? parsed : parsed.events;
       } else if (p.format === 'prproj') {
         // Premiere: offline gunzip+graph read (no Premiere, no Resolve import
         // path). parsePrproj flattens EVERY sequence's events; a multi-sequence

package/resolve-advanced/server/tools/editorial.mjs

@@ -17,7 +17,7 @@ import { parseInterchange, diffChangelist, timingGuards, conformManifest, marker
 import { parseAAF, parseAafDocument } from '../aaf.mjs';
 import { parsePrproj, parsePrprojDoc } from '../prproj.mjs';
 import { listSequences, detectFormat } from '../sequences.mjs';
-import { authorInterchange } from '../author-interchange.mjs';
+import { authorInterchange, verifyRoundtrip } from '../author-interchange.mjs';
 
 const eventArray = z.array(z.object({}).passthrough());
 
@@ -86,7 +86,7 @@ const markerSchema = z.object({
 export const editorialTool = {
   name: 'editorial',
   description:
-    'Editorial integrity (Cluster E) — turnover interchange → normalized events → changelist + conform manifest with TIMING silent-lie guards (flattened retime / dropped J/L-cut audio / framerate-pulldown slip / reverse dropped / transition-handle starvation → flag, skip-not-fake). Report-only (gate: review). Actions: parse_interchange (EDL/OTIO/XMEML natively + AAF via pyaaf2 + PRPROJ via gunzip+XML → normalized events; for AAF/PRPROJ pass the file PATH as content; AAF also returns per-sequence startTimecode/startFrame — build the timeline at THAT start, not the Resolve 01:00:00:00 default — and per-clip `geometry` for Avid transform effects), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}], plus startTimecode/startFrame for AAF), convert_to_interchange (author OTIO/EDL/DRT Resolve CAN import from events or a parsed source — the .prproj→Resolve conform bridge, no Premiere needed; editorial timing/transitions survive and per-clip effects/color do not. SPEED/REVERSE survive on the otio (LinearTimeWarp) and edl (M2) targets ONLY — this FLAT drt target flattens every retime to 100% forward and returns `flattened`/`flattenedCount` naming each event that lost one (`flattened` is always present on `drt`, empty when there were none); for a .drt that AUTHORS retimes/dissolves/multi-track/audio, use drt.assemble_from_interchange), turnover_changelist (diff old vs new → moved/retimed/replaced/new/gone + timing flags), conform_manifest (per-event assert: source resolved/handles/retime/reverse/TC-base), marker_roundtrip (markers with provenance tags). Offline (AAF needs pyaaf2; live AAF/DRP import is on the Python davinci-resolve MCP).',
+    'Editorial integrity (Cluster E) — turnover interchange → normalized events → changelist + conform manifest with TIMING silent-lie guards (flattened retime / dropped J/L-cut audio / framerate-pulldown slip / reverse dropped / transition-handle starvation → flag, skip-not-fake). Report-only (gate: review). Actions: parse_interchange (EDL/OTIO/XMEML natively + AAF via pyaaf2 + PRPROJ via gunzip+XML → normalized events; for AAF/PRPROJ pass the file PATH as content; AAF also returns per-sequence startTimecode/startFrame — build the timeline at THAT start, not the Resolve 01:00:00:00 default — and per-clip `geometry` for Avid transform effects), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}], plus startTimecode/startFrame for AAF), convert_to_interchange (author OTIO/EDL/DRT Resolve CAN import from events or a parsed source — the .prproj→Resolve conform bridge, no Premiere needed; editorial timing/transitions survive and per-clip effects/color do not. SPEED/REVERSE survive on the otio (LinearTimeWarp) and edl (M2) targets ONLY — this FLAT drt target flattens every retime to 100% forward and returns `flattened`/`flattenedCount` naming each event that lost one (`flattened` is always present on `drt`, empty when there were none); for a .drt that AUTHORS retimes/dissolves/multi-track/audio, use drt.assemble_from_interchange), turnover_changelist (diff old vs new → moved/retimed/replaced/new/gone + timing flags), conform_manifest (per-event assert: source resolved/handles/retime/reverse/TC-base), marker_roundtrip (markers with provenance tags), verify_roundtrip (input events vs re-export events -> pass/mismatches + fitted per-source TC offsets; the conform QC loop-closer). Offline (AAF needs pyaaf2; live AAF/DRP import is on the Python davinci-resolve MCP).',
   async handler({ action, args }) {
     if (action === 'parse_interchange') {
       const p = parseSchema.parse(args);
@@ -145,6 +145,20 @@ export const editorialTool = {
       const p = conformManifestSchema.parse(args);
       return conformManifest(p.events, p.resolution, { minHandle: p.minHandle, expectTcBase: p.expectTcBase });
     }
+    if (action === 'verify_roundtrip') {
+      // Round-trip QC: input interchange events vs a re-EXPORT of the
+      // authored timeline, normalized for the three measured cross-format
+      // conventions (track label, source naming, per-source TC-absolute
+      // source frames). Live-proven: AAF -> assemble -> import -> Resolve
+      // OTIO export verified pass with srcOffsets 86400.
+      const p = z.object({
+        input: z.array(z.any()).describe('Normalized events of the ORIGINAL interchange (parse_interchange output)'),
+        exported: z.array(z.any()).describe('Normalized events of the re-export (parse_interchange on the exported OTIO/EDL/XML)'),
+        recTol: z.number().optional(),
+        srcTol: z.number().optional(),
+      }).parse(args);
+      return verifyRoundtrip(p.input, p.exported, { recTol: p.recTol, srcTol: p.srcTol });
+    }
     if (action === 'marker_roundtrip') {
       const p = markerSchema.parse(args);
       return markerRoundtrip(p.markers, { provenanceTag: p.provenanceTag });

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.124.0"
+VERSION = "2.126.0"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 353-tool granular server instead
 """
 
-VERSION = "2.124.0"
+VERSION = "2.126.0"
 
 import base64
 import os