davinci-resolve-mcp 2.181.0 → 2.183.0

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 Release history for the DaVinci Resolve MCP Server. The latest release is summarized in the root README; older entries live here to keep the README focused.
 
+## What's New in v2.183.0 — E129/E130: `import_from_drp` names from the pool, imports timelines, keeps compounds
+
+### Fixed
+
+- **`timeline.import_from_drp` named containers after their first clip.**
+  Resolve's own compound-timeline export listed as "cut_src.mp4" /
+  "white_src.mp4", "by name" could not find the real timeline, and the
+  default (all containers) imported the inner compound containers as
+  separate, hollow timelines. The lister now names each container from the
+  pool (`Sm2MpTimelineClip` / `Sm2MpCompoundClip` embed the `Sm2Sequence`
+  the container's `<Sequence>` names) and reports `kind`; the default
+  imports every TIMELINE; explicit names and indexes are unchanged (E129).
+- **The Python extractor dropped a timeline's compound containers.** A
+  compound is a pool `Sm2MpCompoundClip` whose embedded sequence lives in
+  its own container (the E45 law `drt.extract_from_drp` already honours), so
+  a timeline with compounds imported with hollow compounds. The extractor now
+  keeps them recursively (MediaRefs → compound pool elements → embedded
+  sequence ids → containers) and `metadata.json` lists `keptSeqContainers`.
+  Verified on the fixture: E57_NESTED keeps E57_OUT and E57_IN; E57_OUT keeps
+  E57_IN; the bundled template keeps its one container (E130). The
+  bundled template's sequence now lists as `MediaTemplate` on this route
+  too, where it used to read as its clip `sample.mp4`.
+
+## What's New in v2.182.0 — E128: `extract_from_drp` defaults to the pool's timeline, not the first-sorted compound
+
+### Fixed
+
+- **The default extraction picked an inner compound.** `extract_from_drp`
+  used index 0 by default, and SeqContainers list name-sorted by DbId; on
+  Resolve's own export of a compound timeline (the E127 fixture) index 0 was
+  the inner compound E57_IN, so the default emitted a hollow inner container
+  instead of the timeline. The default is now the first container the pool
+  kinds as a timeline (index 0 only when the export carries no pool kinds);
+  `timelineName` picks a container by its pool name; an explicit
+  `timelineIndex` still means exactly that container. The result reports
+  `pickedBy`, the container's name and kind, and every container kept (a
+  timeline keeps its compounds recursively). Verified on the fixture: the
+  default yields E57_NESTED with E57_OUT and E57_IN kept; `timelineName`
+  E57_OUT yields E57_OUT + E57_IN; index 0 yields E57_IN alone.
+
 ## What's New in v2.181.0 — E127: DRT timelines get their real names, and compounds their kind
 
 ### Fixed

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.181.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.183.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-36%20(353%20full)-blue.svg)](#server-modes)

package/README.zh-CN.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 简体中文
 
-[![Version](https://img.shields.io/badge/version-2.181.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.183.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-36%20(353%20full)-blue.svg)](#服务器模式)
@@ -12,7 +12,7 @@
 [![Python](https://img.shields.io/badge/python-3.10+-green.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-> 本翻译对应 v2.181.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.183.0 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
 
 一个 Model Context Protocol (MCP) 服务器，让 AI 助手通过官方脚本 API 控制 DaVinci Resolve Studio（达芬奇）。它提供完整的 API 覆盖，外加带护栏的工作流助手，涵盖剪辑、媒体池整理、渲染设置、审阅标记、调色、Fusion、Fairlight、项目生命周期任务、扩展开发，以及不碰源媒体的媒体分析。
 

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.181.0"
+VERSION = "2.183.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.181.0",
+  "version": "2.183.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

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

@@ -97,7 +97,8 @@ const injectIntoDrpSchema = z.object({
 const extractFromDrpSchema = z.object({
   drpPath: z.string().describe('Source .drp'),
   outputPath: z.string().describe('Path for the emitted .drt'),
-  timelineIndex: z.number().int().nonnegative().optional().describe('Which SeqContainer to extract (0-based, default 0)'),
+  timelineIndex: z.number().int().nonnegative().optional().describe('Which SeqContainer to extract (0-based). Omitted: the first container the pool kinds as a TIMELINE — SeqContainers list name-sorted by DbId, so index 0 is often a compound\'s inner container (measured, E128)'),
+  timelineName: z.string().optional().describe('Extract the container the pool names this (timeline or compound) — see list_sequences'),
 });
 
 // Verified Resolve app-version → on-disk <ProjectVersion> map (the import GATE).
@@ -153,7 +154,7 @@ function requirePathArg(args, key, action) {
 export const drtTool = {
   name: 'drt',
   description:
-    'DaVinci Resolve Timeline (.drt) operations — offline, no Resolve required. Actions: assemble_from_interchange (EDL/OTIO/XML/AAF + sourceMap → IMPORTABLE RENDERING native .drt in one call; retimes AUTHOR — constant speed fwd/rev AND zero-speed freezes (EDL M2 000.0; render-proven frozen); cross-dissolves are AUTHORED when the cut abuts with handles both sides (render-verified on 19), else dropped with reason; fades AUTHOR across ALL FOUR formats (EDL BL legs, OTIO gap-adjacent Transitions, XMEML edge transitionitems, AAF filler-adjacent Transitions) and AAF overlap-consuming dissolves reconcile+author (CutPoint honored; before E93 they threw at the overlap gate) — BL legs become Solid Color generators and the fade a real clip-to-generator dissolve, luma-ramp render-verified, while Resolve\'s OWN EDL importer drops BL dissolves silently; ledger in `conform`), assemble (spec → IMPORTABLE native-schema .drt via template-spliced real structures; pass targetAppVersion e.g. \'19.1\' for pre-21 hosts), parse, list_sequences (enumerate the timelines inside a .drp/.drt → [{id,name,eventCount,index,kind,nestedIn}] to drive a "which sequence?" picker — names and kind (timeline|compound) come from the pool folder, since a SeqContainer carries no timeline name and its first <Name> is a CLIP\'s (measured, E127); a compound container is nestedIn every timeline that places it, and a media-less clip named after a compound is tagged `compound` in parse), author, validate, inject_into_drp, extract_from_drp (pull one SeqContainer out as a .drt — feed the .drt to the Python davinci-resolve MCP timeline.import_timeline_checked, or use timeline.import_from_drp to do both), downgrade (stamp <ProjectVersion> down so an OLDER Resolve will import a .drt/.drp from a newer one — pass targetAppVersion like "19.1.3" or targetProjectVersion).',
+    'DaVinci Resolve Timeline (.drt) operations — offline, no Resolve required. Actions: assemble_from_interchange (EDL/OTIO/XML/AAF + sourceMap → IMPORTABLE RENDERING native .drt in one call; retimes AUTHOR — constant speed fwd/rev AND zero-speed freezes (EDL M2 000.0; render-proven frozen); cross-dissolves are AUTHORED when the cut abuts with handles both sides (render-verified on 19), else dropped with reason; fades AUTHOR across ALL FOUR formats (EDL BL legs, OTIO gap-adjacent Transitions, XMEML edge transitionitems, AAF filler-adjacent Transitions) and AAF overlap-consuming dissolves reconcile+author (CutPoint honored; before E93 they threw at the overlap gate) — BL legs become Solid Color generators and the fade a real clip-to-generator dissolve, luma-ramp render-verified, while Resolve\'s OWN EDL importer drops BL dissolves silently; ledger in `conform`), assemble (spec → IMPORTABLE native-schema .drt via template-spliced real structures; pass targetAppVersion e.g. \'19.1\' for pre-21 hosts), parse, list_sequences (enumerate the timelines inside a .drp/.drt → [{id,name,eventCount,index,kind,nestedIn}] to drive a "which sequence?" picker — names and kind (timeline|compound) come from the pool folder, since a SeqContainer carries no timeline name and its first <Name> is a CLIP\'s (measured, E127); a compound container is nestedIn every timeline that places it, and a media-less clip named after a compound is tagged `compound` in parse), author, validate, inject_into_drp, extract_from_drp (pull one SeqContainer out as a .drt — by timelineName, an explicit timelineIndex, or by default the first container the pool kinds as a TIMELINE (index 0 is name-sorted by DbId and was an inner compound on Resolve\'s own export, E128); a timeline keeps its compound containers recursively; feed the .drt to the Python davinci-resolve MCP timeline.import_timeline_checked, or use timeline.import_from_drp to do both), downgrade (stamp <ProjectVersion> down so an OLDER Resolve will import a .drt/.drp from a newer one — pass targetAppVersion like "19.1.3" or targetProjectVersion).',
   async handler({ action, args }) {
     if (action === 'parse') {
       const p = parseSchema.parse(requirePathArg(args, 'drtPath', 'parse'));
@@ -579,7 +580,32 @@ export const drtTool = {
       const p = extractFromDrpSchema.parse(args);
       const drpZip = await JSZip.loadAsync(await fs.readFile(p.drpPath));
       const seqEntries = drt().listSeqContainerEntries(drpZip);
-      const idx = p.timelineIndex ?? 0;
+      // Which container (E128): SeqContainers list name-sorted by DbId, so a
+      // bare index 0 picked whichever container's uuid sorted first — on
+      // Resolve's export of a compound timeline that was an INNER compound.
+      // Resolve by pool name/kind unless an index is given explicitly.
+      const poolNames = await drt().loadPoolSequenceNames(drpZip);
+      const containerInfo = [];
+      for (const entryName of seqEntries) {
+        const sx = await drpZip.file(entryName).async('string');
+        const sid = (sx.match(/<Sequence>([0-9a-f-]{36})<\/Sequence>/) || [])[1];
+        const pool = sid ? poolNames.get(sid) : null;
+        containerInfo.push({ entry: entryName, name: pool ? pool.name : null, kind: pool ? pool.kind : null });
+      }
+      let idx;
+      let pickedBy;
+      if (p.timelineName != null) {
+        idx = containerInfo.findIndex((c) => c.name === p.timelineName);
+        if (idx < 0) return { error: `no SeqContainer named ${JSON.stringify(p.timelineName)} — containers: ${containerInfo.map((c) => `${c.name ?? '?'}${c.kind ? ` (${c.kind})` : ''}`).join(', ')}` };
+        pickedBy = 'timelineName';
+      } else if (p.timelineIndex != null) {
+        idx = p.timelineIndex;
+        pickedBy = 'timelineIndex';
+      } else {
+        idx = containerInfo.findIndex((c) => c.kind === 'timeline');
+        pickedBy = idx >= 0 ? 'first timeline in the pool' : 'first container (pool carries no kinds)';
+        if (idx < 0) idx = 0;
+      }
       if (idx >= seqEntries.length) {
         return { error: `timelineIndex ${idx} out of range (${seqEntries.length} SeqContainers)` };
       }
@@ -674,6 +700,9 @@ export const drtTool = {
         outputPath: p.outputPath,
         bytes: outBuf.length,
         sourceSeqContainer: keepEntry,
+        pickedBy,
+        container: { name: containerInfo[idx].name, kind: containerInfo[idx].kind },
+        keptContainers: [...keepContainers].map((e) => ({ entry: e, name: (containerInfo.find((c) => c.entry === e) || {}).name ?? null })),
         droppedTimelines,
         note: 'The imported timeline is named after the FILE. Source must be a SAVED project export — ExportProject snapshots the saved DB state, so unsaved edits are absent.',
       };

package/resolve-advanced/vendor/drt-format/drt-parser.js

@@ -205,4 +205,4 @@ async function parseDRT(drtPathOrBuffer, options = {}) {
   };
 }
 
-module.exports = { parseDRT, listSeqContainerEntries };
+module.exports = { parseDRT, listSeqContainerEntries, loadPoolSequenceNames };

package/resolve-advanced/vendor/drt-format/index.js

@@ -23,6 +23,7 @@ module.exports = {
   // Canonical SeqContainer-entry matcher (both tool-authored SeqContainer<N>.xml and
   // real Resolve SeqContainer/<uuid>.xml). Shared so callers don't re-inline the regex.
   listSeqContainerEntries: drtParser.listSeqContainerEntries,
+loadPoolSequenceNames: drtParser.loadPoolSequenceNames,
 
   // Resolve version registry + retargeting (re-stamp to a target Resolve version).
   // The registry + re-stamp core are universal across DRT/DRP/DRX (same version stamp);

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.181.0"
+VERSION = "2.183.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.181.0"
+VERSION = "2.183.0"
 
 import base64
 import os
@@ -7574,17 +7574,58 @@ def _import_timeline_checked(proj, mp, p: Dict[str, Any]):
 _SEQ_CONTAINER_RE = re.compile(r"(^|/)SeqContainer(\d*\.xml|/[^/]+\.xml)$")
 
 
+def _drp_pool_sequence_names(zf) -> Dict[str, Dict[str, str]]:
+    """Map an embedded Sm2Sequence DbId → {name, kind} from every MpFolder*.xml.
+
+    A SeqContainer XML carries NO timeline name — its first <Name> is the first
+    CLIP's (measured on Resolve 19.1.3.7's EXPORT_DRT of a compound timeline,
+    E127/E129) — while the pool's Sm2MpTimelineClip (a timeline) and
+    Sm2MpCompoundClip (a compound) embed the Sm2Sequence whose DbId the
+    container's track-level <Sequence> names. That is where names and kinds live.
+    """
+    out: Dict[str, Dict[str, str]] = {}
+    for entry in zf.namelist():
+        if entry.endswith("/") or not re.search(r"(^|/)MpFolder[^/]*\.xml$", entry):
+            continue
+        try:
+            xml = zf.read(entry).decode("utf-8", "replace")
+        except Exception:
+            continue
+        for m in re.finditer(r'<(Sm2MpTimelineClip|Sm2MpCompoundClip) DbId="([^"]+)">([\s\S]*?)</\1>', xml):
+            body = m.group(3)
+            nm = re.search(r"<Name>([\s\S]*?)</Name>", body)
+            name = nm.group(1).strip() if nm else None
+            kind = "compound" if m.group(1) == "Sm2MpCompoundClip" else "timeline"
+            for sm in re.finditer(r'<Sm2Sequence DbId="([^"]+)">', body):
+                out.setdefault(sm.group(1), {"name": name, "kind": kind})
+    return out
+
+
 def _drp_seq_containers(zf) -> List[Dict[str, Any]]:
-    """List a .drp/.drt zip's SeqContainers as [{entry, name, index}] (0-based, sorted)."""
+    """List a .drp/.drt zip's SeqContainers as [{entry, name, kind, index}] (0-based, sorted).
+
+    `name` is the POOL's name for the sequence when the archive carries one
+    (the container's own first <Name> is a clip's — E129); `kind` is
+    'timeline' | 'compound' | None.
+    """
     entries = sorted(n for n in zf.namelist() if not n.endswith("/") and _SEQ_CONTAINER_RE.search(n))
+    pool = _drp_pool_sequence_names(zf)
     out = []
     for index, entry in enumerate(entries):
         try:
             xml = zf.read(entry).decode("utf-8", "replace")
         except Exception:
             xml = ""
+        sid = re.search(r"<Sequence>([0-9a-f-]{36})</Sequence>", xml)
+        info = pool.get(sid.group(1)) if sid else None
         m = re.search(r"<Name>([\s\S]*?)</Name>", xml)
-        out.append({"entry": entry, "name": (m.group(1).strip() if m else None), "index": index})
+        fallback = m.group(1).strip() if m else None
+        out.append({
+            "entry": entry,
+            "name": (info["name"] if info and info.get("name") else fallback),
+            "kind": (info["kind"] if info else None),
+            "index": index,
+        })
     return out
 
 
@@ -7608,11 +7649,49 @@ def _extract_seqcontainer_from_drp(drp_path: str, seq_entry: str, out_path: str)
         seq_entries = [n for n in names if _SEQ_CONTAINER_RE.search(n)]
         keep_xml = zf.read(seq_entry).decode("utf-8", "replace")
         keep_seq_ids = re.findall(r"<Sequence>([0-9a-f-]{36})</Sequence>", keep_xml)
+        # COMPOUND CLIPS (E130, the E45 law ported from drt.extract_from_drp): a
+        # compound is a pool Sm2MpCompoundClip with an EMBEDDED Sm2Sequence
+        # whose tracks live in their OWN SeqContainer — dropping that container
+        # ships a compound that imports and reads back but is hollow. Walk the
+        # kept container's MediaRefs → compound pool elements → embedded
+        # sequence ids → keep those containers too, recursively.
+        mp_texts = {}
+        for name in names:
+            if name.endswith("MpFolder.xml"):
+                mp_texts[name] = zf.read(name).decode("utf-8", "replace")
+        seq_xml_by_entry = {seq_entry: keep_xml}
+        keep_containers = {seq_entry}
+        seen_refs = set()
+        queue = [keep_xml]
+        while queue:
+            xml = queue.pop()
+            for ref in re.findall(r"<MediaRef>([0-9a-f-]{36})</MediaRef>", xml):
+                if ref in seen_refs:
+                    continue
+                for mp_xml in mp_texts.values():
+                    cm = re.search(r'<Sm2MpCompoundClip DbId="%s">[\s\S]*?</Sm2MpCompoundClip>' % re.escape(ref), mp_xml)
+                    if not cm:
+                        continue
+                    seen_refs.add(ref)
+                    im = re.search(r'<Sm2Sequence DbId="([0-9a-f-]{36})">', cm.group(0))
+                    if not im:
+                        continue
+                    inner = im.group(1)
+                    for entry_name in seq_entries:
+                        if entry_name in keep_containers:
+                            continue
+                        sx = seq_xml_by_entry.get(entry_name)
+                        if sx is None:
+                            sx = zf.read(entry_name).decode("utf-8", "replace")
+                            seq_xml_by_entry[entry_name] = sx
+                        if ("<Sequence>%s</Sequence>" % inner) in sx:
+                            keep_containers.add(entry_name)
+                            queue.append(sx)
         with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as out:
             for name in names:
                 if name == "Gallery.xml":
                     continue
-                if name in seq_entries and name != seq_entry:
+                if name in seq_entries and name not in keep_containers:
                     continue
                 data = zf.read(name)
                 if name.endswith("MpFolder.xml") and len(seq_entries) > 1:
@@ -7640,6 +7719,7 @@ def _extract_seqcontainer_from_drp(drp_path: str, seq_entry: str, out_path: str)
                         "source": "import_from_drp",
                         "sourceDrp": drp_path,
                         "sourceSeqContainer": seq_entry,
+                        "keptSeqContainers": sorted(keep_containers),
                         "exportedFrom": "davinci-resolve-mcp timeline.import_from_drp",
                     },
                     indent=2,
@@ -7681,7 +7761,7 @@ def _import_from_drp(proj, mp, p: Dict[str, Any]):
         want_indexes = [want_indexes]
 
     selected: List[Dict[str, Any]] = []
-    available = [{"name": c["name"], "index": c["index"]} for c in containers]
+    available = [{"name": c["name"], "kind": c.get("kind"), "index": c["index"]} for c in containers]
     if want_names:
         by_name = {}
         for c in containers:
@@ -7703,7 +7783,11 @@ def _import_from_drp(proj, mp, p: Dict[str, Any]):
                 return _err(f"timelineIndex {i} out of range (0..{len(containers) - 1})", category="invalid_input")
             selected.append(match)
     else:
-        selected = list(containers)
+        # ALL means every TIMELINE (E129): a compound's inner container is not a
+        # timeline of its own — extraction keeps it with the timeline that
+        # places it — so importing it separately lands a hollow duplicate.
+        timelines_only = [c for c in containers if c.get("kind") == "timeline"]
+        selected = timelines_only if timelines_only else list(containers)
 
     # Per-timeline options passthrough (importSourceClips etc.) minus selection
     # keys; background is a top-level option, so each sub-step import runs
@@ -24255,6 +24339,11 @@ def timeline(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str,
         `sanitize.flagged` for human review, never silently applied. verify_threshold
         (default 0.90) sets the structural-match bar.
       import_from_drp(drpPath, timelineNames?|timelineIndexes?, import_source_clips?, dry_run?) -> {success, selected, imported, available, results, partial?}
+        timelineNames are the POOL's names (a SeqContainer's own first <Name>
+        is a clip's — measured E129); `available` rows carry kind
+        (timeline|compound). Omitted selection = every TIMELINE: a compound's
+        inner container is not a timeline of its own, it travels with the
+        timeline that places it (kept recursively in the extracted .drt, E130).
         CAVEAT (measured 19.1.3.7): Resolve refuses extracted containers even
         repacked with the source's project.xml — the sufficient import set
         beyond Resolve's own .drt exports is unmapped, so expect failures on