davinci-resolve-mcp 2.79.0 → 2.79.1

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 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.79.1
+
+One redirect that was never written, in a dispatcher whose other container formats all have one.
+
+### Fixed
+
+- **`parse_interchange` told `.drt`/`.drp` callers the format was unknown — for formats the
+  same package parses.** `parseInterchange(format, content)` gives AAF and `.prproj` explicit,
+  helpful redirects to their path-based readers, but `drt` and `drp` had no case at all and
+  fell through to `unknown format 'drt' (edl|otio|xml|xmeml|fcp7|aaf|prproj)`. Meanwhile
+  `list_sequences` in the same cluster parses both by path, and the tool description advertises
+  it. So the cluster supports DRT, documents that it supports DRT, then tells the
+  content-shaped caller it does not. The failure is silent downstream: a consumer that reads
+  "unknown format" (or hands `{ content }` to `drt.parse`, whose schema wants `{ drtPath }`)
+  records **zero events**, and an empty sequence is indistinguishable from an unsupported one.
+  `parseInterchange` now throws the same shape of redirect the AAF and `.prproj` cases throw —
+  naming the ZIP container, `parseDRT(path)`, and the two callable entry points — and the
+  `default:` message lists `drt|drp` among the known formats. The `editorial`
+  `parse_interchange` schema accepts `drt`/`drp` so the tool-level caller gets that redirect
+  instead of a bare enum rejection, and `drt.parse` / `list_sequences` / `validate` now name
+  the path argument they wanted rather than emitting a raw zod issue dump.
+
+### Validation
+
+- `resolve-advanced` suite: 778 tests, 748 pass, 30 skipped, 0 fail (4 new assertions, written
+  first and confirmed failing on v2.79.0).
+- Static/drift checks, `--help`/`--version`, `npm pack --dry-run`, `git diff --check`: clean.
+- No Resolve behavior changed; this path never touches the Resolve API, so live validation was
+  not required.
+
 ## What's New in v2.79.0
 
 Six silent failures in the conform path, found by conforming a real Avid picture turnover

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.79.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.79.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-34%20(341%20full)-blue.svg)](#server-modes)

package/install.py

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

package/resolve-advanced/server/editorial.mjs

@@ -196,9 +196,13 @@ export function parseXMEMLEvents(xml, opts = {}) {
 }
 
 /**
- * Dispatch by format (SYNC, pure over TEXT). Binary formats are handled out-of-band by their own
- * path-based readers — AAF via aaf.mjs `parseAAF` (async, pyaaf2), .prproj via prproj.mjs
- * `parsePrproj` (gunzip+XML). This throws to route callers there rather than faking a parse.
+ * Dispatch by format (SYNC, pure over TEXT). Binary/container formats are handled out-of-band by
+ * their own path-based readers — AAF via aaf.mjs `parseAAF` (async, pyaaf2), .prproj via prproj.mjs
+ * `parsePrproj` (gunzip+XML), .drt/.drp via drt.mjs `parseDRT` (ZIP). This throws to route callers
+ * there rather than faking a parse. Every container format gets a NAMED redirect: falling through
+ * to `unknown format` would tell a caller the cluster does not support a format it does support
+ * (list_sequences parses .drt/.drp), and an empty parse is indistinguishable downstream from an
+ * unsupported one.
  */
 export function parseInterchange(format, content, opts = {}) {
   switch (String(format).toLowerCase()) {
@@ -218,8 +222,13 @@ export function parseInterchange(format, content, opts = {}) {
       throw new Error(
         'parse_interchange: .prproj is gzip-compressed XML — parse it via the path-based reader (prproj.mjs `parsePrproj`), not the sync parseInterchange().',
       );
+    case 'drt':
+    case 'drp':
+      throw new Error(
+        `parse_interchange: .${String(format).toLowerCase()} is a ZIP container — parse it via the path-based reader (drt.mjs \`parseDRT(path)\`), not the sync parseInterchange(). Entry points: editorial \`list_sequences({path})\` or drt \`parse({drtPath})\`.`,
+      );
     default:
-      throw new Error(`parse_interchange: unknown format '${format}' (edl|otio|xml|xmeml|fcp7|aaf|prproj)`);
+      throw new Error(`parse_interchange: unknown format '${format}' (edl|otio|xml|xmeml|fcp7|drt|drp|aaf|prproj)`);
   }
 }
 

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

@@ -70,17 +70,32 @@ const downgradeSchema = z.object({
   appVersionString: z.string().optional().describe('DbAppVer comment to stamp (default derived from targetAppVersion, else "<v>.0.0.0000")'),
 });
 
+/**
+ * .drt/.drp are ZIP containers, so every reader here takes a FILE PATH. A caller reaching for the
+ * content-shaped convention its sibling text formats use (`{ content }`) otherwise gets a bare zod
+ * dump that never names the key it wanted.
+ */
+function requirePathArg(args, key, action) {
+  const a = args && typeof args === 'object' ? args : {};
+  if (typeof a[key] === 'string' && a[key]) return a;
+  const given = Object.keys(a).filter((k) => a[k] !== undefined);
+  throw new Error(
+    `drt.${action}: pass \`${key}\` — an absolute path to the .drt/.drp. A .drt/.drp is a ZIP container, so this action reads a FILE PATH, never file content` +
+      `${given.length ? ` (got: ${given.join(', ')})` : ' (got no arguments)'}.`,
+  );
+}
+
 export const drtTool = {
   name: 'drt',
   description:
     'DaVinci Resolve Timeline (.drt) operations — offline, no Resolve required. Actions: parse, list_sequences (enumerate the timelines inside a .drp/.drt → [{id,name,eventCount,index}] to drive a "which sequence?" picker), 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).',
   async handler({ action, args }) {
     if (action === 'parse') {
-      const p = parseSchema.parse(args);
+      const p = parseSchema.parse(requirePathArg(args, 'drtPath', 'parse'));
       return drt().parseDRT(p.drtPath);
     }
     if (action === 'list_sequences') {
-      const p = listSequencesSchema.parse(args);
+      const p = listSequencesSchema.parse(requirePathArg(args, 'drpPath', 'list_sequences'));
       const parsed = await drt().parseDRT(p.drpPath);
       const sequences = summarizeDrtTimelines(parsed);
       return { path: p.drpPath, count: sequences.length, sequences };
@@ -92,7 +107,7 @@ export const drtTool = {
       return { outputPath: p.outputPath, bytes: buf.length };
     }
     if (action === 'validate') {
-      const p = validateSchema.parse(args);
+      const p = validateSchema.parse(requirePathArg(args, 'drtPath', 'validate'));
       return drt().validateDRT(p.drtPath);
     }
     if (action === 'inject_into_drp') {

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

@@ -32,11 +32,15 @@ async function parseAnySource(sourcePath, sourceFormat) {
   return parseInterchange(fmt, content, {});
 }
 
+// drt/drp are accepted only so the caller gets parseInterchange's NAMED redirect to the
+// path-based reader instead of a bare enum-rejection that reads as "unsupported".
 const parseSchema = z.object({
-  format: z.enum(['edl', 'otio', 'xml', 'xmeml', 'fcp7', 'aaf', 'prproj']),
+  format: z.enum(['edl', 'otio', 'xml', 'xmeml', 'fcp7', 'aaf', 'prproj', 'drt', 'drp']),
   content: z
     .union([z.string(), z.object({}).passthrough()])
-    .describe('EDL text / OTIO JSON (string or object) / XMEML string. For AAF or PRPROJ (binary): the file PATH.'),
+    .describe(
+      'EDL text / OTIO JSON (string or object) / XMEML string. For AAF or PRPROJ (binary): the file PATH. For .drt/.drp (ZIP): use list_sequences or drt.parse — this action redirects.',
+    ),
   fps: z.number().optional(),
 });
 

package/src/granular/common.py

@@ -85,7 +85,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.79.0"
+VERSION = "2.79.1"
 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 341-tool granular server instead
 """
 
-VERSION = "2.79.0"
+VERSION = "2.79.1"
 
 import base64
 import os