davinci-resolve-mcp 2.58.0 → 2.60.0

package/resolve-advanced/server/prproj.mjs

@@ -0,0 +1,262 @@
+/**
+ * Premiere .prproj offline reader — enumeration + normalized events, NO Premiere, NO new deps.
+ *
+ * A .prproj is gzip-compressed XML (Premiere CC 2013+; CS6 was plain XML). The XML is a FLAT
+ * object-reference graph: every object carries an `ObjectID` and is linked from elsewhere by
+ * `ObjectRef`. We gunzip (node `zlib`), parse (`fast-xml-parser`, already a dep), index every
+ * object by ObjectID, then walk Sequence → Video/AudioTracks → Track → TrackItems → *ClipTrackItem.
+ *
+ * Time is in TICKS (254,016,000,000 per second — factors by every standard frame/sample rate).
+ * We derive from tick geometry alone: cuts, source in/out, timeline position, SPEED/retime
+ * (srcDur/recDur), REVERSE (in>out), transitions (VideoTransitionTrackItem span), and markers.
+ *
+ * HONEST limits (skip-not-fake): the schema is proprietary and version-drifting (Project Version
+ * 25→42+); editorial timing/structure decodes with high fidelity, but per-clip EFFECTS / Lumetri
+ * COLOR are NOT translated (that's the Premiere→Resolve semantic gap present in every turnover
+ * format, not a reader limit). Resolve has no native .prproj importer — this is offline READ; to
+ * conform, convert the events to OTIO/EDL/DRT (see authorInterchange) and import that.
+ */
+import fs from 'node:fs';
+import zlib from 'node:zlib';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+export const TICKS_PER_SECOND = 254016000000;
+
+/** Read a .prproj into its XML string, transparently handling gzip (CC) and plain XML (CS6). */
+export function readPrprojXml(pathOrBuffer) {
+  const buf = Buffer.isBuffer(pathOrBuffer) ? pathOrBuffer : fs.readFileSync(pathOrBuffer);
+  if (buf.length >= 2 && buf[0] === 0x1f && buf[1] === 0x8b) return zlib.gunzipSync(buf).toString('utf8');
+  const s = buf.toString('utf8');
+  if (s.includes('<PremiereData')) return s; // CS6 / uncompressed
+  throw new Error('Not a .prproj: no gzip magic and no <PremiereData> root. A .prproj is gzip-compressed XML (CC) or plain XML (CS6).');
+}
+
+const asArray = (v) => (v == null ? [] : Array.isArray(v) ? v : [v]);
+
+/** Text of a child element, tolerating fast-xml-parser's {#text} wrapping when the node has attrs. */
+function childText(node, tag) {
+  if (!node) return null;
+  const v = node[tag];
+  if (v == null) return null;
+  if (typeof v === 'object') return v['#text'] != null ? v['#text'] : null;
+  return v;
+}
+
+const nodeName = (node) => childText(node?.Node?.Properties, 'Name');
+
+/** ticks → whole frames at fps. */
+function ticksToFrames(ticks, fps) {
+  const t = Number(ticks);
+  if (!Number.isFinite(t) || !fps) return null;
+  return Math.round(t / (TICKS_PER_SECOND / fps));
+}
+
+/** Sequence FrameRate is a rate (e.g. 25) OR ticks-per-frame (huge); normalize to fps. */
+function deriveFps(seqNode) {
+  const raw = childText(seqNode?.Node?.Properties, 'FrameRate');
+  const v = Number(raw);
+  if (!Number.isFinite(v) || v <= 0) return 24;
+  if (v > 100000) return +(TICKS_PER_SECOND / v).toFixed(3); // stored as ticks-per-frame
+  return v;
+}
+
+/** Parse the XML into an ObjectID → {tag, node} index. Objects are flat children of PremiereData. */
+function indexObjects(xml) {
+  const { XMLParser } = require('fast-xml-parser');
+  const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' });
+  const doc = parser.parse(xml);
+  const pd = doc.PremiereData;
+  if (!pd) throw new Error('Not a .prproj: missing <PremiereData> root.');
+  const byId = new Map();
+  for (const [tag, val] of Object.entries(pd)) {
+    if (tag.startsWith('@_')) continue;
+    for (const node of asArray(val)) {
+      if (node && typeof node === 'object' && node['@_ObjectID'] != null) byId.set(String(node['@_ObjectID']), { tag, node });
+    }
+  }
+  return { byId, projectVersion: firstProjectVersion(byId) };
+}
+
+function firstProjectVersion(byId) {
+  for (const { tag, node } of byId.values()) {
+    if (tag === 'Project' && node['@_Version'] != null) return Number(node['@_Version']);
+  }
+  return null;
+}
+
+const ref = (node, tag) => {
+  const r = asArray(node?.[tag])[0];
+  return r ? String(r['@_ObjectRef'] ?? '') : null;
+};
+
+/** Best-effort source label for a clip item: media basename, else project-item name, else UNKNOWN. */
+function resolveSourceName(clipNode, byId) {
+  const cpiId = ref(clipNode, 'ClipProjectItem') || ref(clipNode, 'SubClip') || ref(clipNode, 'ProjectItem');
+  const cpi = cpiId ? byId.get(cpiId) : null;
+  if (cpi) {
+    const path = findFirstText(cpi.node, ['ActualMediaFilePath', 'FilePath', 'RelativePath'], 6);
+    if (path) return String(path).split(/[\\/]/).pop();
+    const nm = nodeName(cpi.node);
+    if (nm) return nm;
+  }
+  return nodeName(clipNode) || 'UNKNOWN';
+}
+
+/** Shallow recursive search for the first non-empty text under any of `tags` (depth-bounded). */
+function findFirstText(node, tags, depth) {
+  if (!node || typeof node !== 'object' || depth < 0) return null;
+  for (const tag of tags) {
+    const t = childText(node, tag);
+    if (t) return t;
+  }
+  for (const k of Object.keys(node)) {
+    if (k.startsWith('@_') || k === '#text') continue;
+    for (const child of asArray(node[k])) {
+      const found = findFirstText(child, tags, depth - 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function clipEvent(clipNode, byId, track, fps, index) {
+  const start = childText(clipNode, 'Start');
+  const end = childText(clipNode, 'End');
+  const inPt = childText(clipNode, 'InPoint');
+  const outPt = childText(clipNode, 'OutPoint');
+  const recIn = ticksToFrames(start, fps);
+  const recOut = ticksToFrames(end, fps);
+  const srcIn = ticksToFrames(inPt, fps);
+  const srcOut = ticksToFrames(outPt, fps);
+  // Speed from tick geometry: |source span| / |timeline span|. Reverse when in > out.
+  let speed = 100;
+  let reverse = false;
+  const srcSpan = Number(outPt) - Number(inPt);
+  const recSpan = Number(end) - Number(start);
+  if (Number.isFinite(srcSpan) && Number.isFinite(recSpan) && recSpan !== 0) {
+    speed = +(Math.abs(srcSpan / recSpan) * 100).toFixed(2);
+    reverse = srcSpan < 0;
+  }
+  return {
+    index,
+    track,
+    source: resolveSourceName(clipNode, byId),
+    srcIn: reverse ? srcOut : srcIn,
+    srcOut: reverse ? srcIn : srcOut,
+    recIn,
+    recOut,
+    speed,
+    reverse,
+    transition: null,
+    fps,
+  };
+}
+
+function walkSequence(seqEntry, byId) {
+  const fps = deriveFps(seqEntry.node);
+  const events = [];
+  let idx = 1;
+  for (const [container, trackKind] of [
+    ['VideoTracks', 'V'],
+    ['AudioTracks', 'A'],
+  ]) {
+    const trackRefs = asArray(seqEntry.node[container]?.Track);
+    for (const tref of trackRefs) {
+      const tEntry = byId.get(String(tref['@_ObjectRef'] ?? ''));
+      if (!tEntry) continue;
+      const itemRefs = asArray(tEntry.node.TrackItems?.TrackItem);
+      const transitions = [];
+      const clipEvents = [];
+      for (const iref of itemRefs) {
+        const cEntry = byId.get(String(iref['@_ObjectRef'] ?? ''));
+        if (!cEntry) continue;
+        if (/ClipTrackItem$/.test(cEntry.tag)) {
+          clipEvents.push(clipEvent(cEntry.node, byId, trackKind, fps, idx++));
+        } else if (/Transition/.test(cEntry.tag)) {
+          const dur = ticksToFrames(Number(childText(cEntry.node, 'End')) - Number(childText(cEntry.node, 'Start')), fps);
+          transitions.push({ recIn: ticksToFrames(childText(cEntry.node, 'Start'), fps), duration: dur || 0 });
+        }
+      }
+      // Attach each transition to the clip that begins at its record position (best-effort).
+      for (const tr of transitions) {
+        const hit = clipEvents.find((e) => e.recIn === tr.recIn);
+        if (hit) hit.transition = { type: 'dissolve', duration: tr.duration };
+      }
+      events.push(...clipEvents);
+    }
+  }
+  return events;
+}
+
+/** Enumerate marker objects (project- or sequence-level) with tick→frame positions. */
+function collectMarkers(byId, fps) {
+  const markers = [];
+  for (const { tag, node } of byId.values()) {
+    if (tag !== 'Marker') continue;
+    markers.push({
+      frame: ticksToFrames(childText(node, 'Position'), fps),
+      duration: ticksToFrames(childText(node, 'Duration'), fps) || 0,
+      name: childText(node, 'Name') || '',
+      note: childText(node, 'Comment') || '',
+      type: Number(childText(node, 'MarkerType')) || 0,
+      colorIndex: Number(childText(node, 'ColorIndex')) || 0,
+    });
+  }
+  return markers;
+}
+
+function sequenceEntries(byId) {
+  const seqs = [];
+  for (const entry of byId.values()) if (entry.tag === 'Sequence') seqs.push(entry);
+  return seqs;
+}
+
+/**
+ * Parse a .prproj into per-sequence structure.
+ * @returns {{projectVersion:number|null, sequences:Array<{id,name,fps,eventCount,events,markers}>, mediaPaths:string[]}}
+ */
+export function parsePrprojDoc(pathOrBuffer) {
+  const xml = readPrprojXml(pathOrBuffer);
+  const { byId, projectVersion } = indexObjects(xml);
+  const sequences = sequenceEntries(byId).map((entry) => {
+    const fps = deriveFps(entry.node);
+    const events = walkSequence(entry, byId);
+    return {
+      id: String(entry.node['@_ObjectID']),
+      name: nodeName(entry.node) || `Sequence ${entry.node['@_ObjectID']}`,
+      fps,
+      eventCount: events.length,
+      events,
+      markers: collectMarkers(byId, fps),
+    };
+  });
+  const mediaPaths = [...new Set(collectMediaPaths(byId))].sort();
+  return { projectVersion, sequences, mediaPaths };
+}
+
+function collectMediaPaths(byId) {
+  const paths = [];
+  for (const { node } of byId.values()) {
+    for (const tag of ['ActualMediaFilePath', 'FilePath']) {
+      const t = childText(node, tag);
+      if (t) paths.push(String(t));
+    }
+  }
+  return paths;
+}
+
+/** FLAT normalized-event list across every sequence (mirrors parseEDL/parseOTIO output). */
+export function parsePrproj(pathOrBuffer) {
+  const { sequences } = parsePrprojDoc(pathOrBuffer);
+  const events = [];
+  for (const s of sequences) for (const e of s.events) events.push(e);
+  return events;
+}
+
+/** Enumerate sequences for the picker. */
+export function listPrprojSequences(pathOrBuffer) {
+  const { sequences } = parsePrprojDoc(pathOrBuffer);
+  return sequences.map((s, index) => ({ id: s.id, name: s.name, eventCount: s.eventCount, index }));
+}

package/resolve-advanced/server/sequences.mjs

@@ -0,0 +1,86 @@
+/**
+ * list_sequences — ONE offline enumeration entry point for the app's "which sequence?" picker.
+ *
+ * Works across xml/fcpxml/edl/otio/drt/drp/aaf and returns a uniform
+ *   [{ id, name, eventCount, index }]
+ * so the Conform surface can drive a single selector regardless of the turnover format.
+ * .prproj is an honest refuse. AAF goes through pyaaf2 (aaf.mjs); drt/drp reuse the DRT parser.
+ *
+ * Detection is by file extension unless an explicit `format` is passed.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { parseInterchange } from './editorial.mjs';
+import { listAafSequences } from './aaf.mjs';
+import { listPrprojSequences } from './prproj.mjs';
+import { drt } from './libs.mjs';
+
+const EXT_FORMAT = {
+  '.edl': 'edl',
+  '.otio': 'otio',
+  '.xml': 'xml',
+  '.fcpxml': 'xml',
+  '.xmeml': 'xml',
+  '.drt': 'drt',
+  '.drp': 'drp',
+  '.aaf': 'aaf',
+  '.prproj': 'prproj',
+};
+
+/** Normalize a format string / file extension to a canonical parser key. */
+export function detectFormat(filePath, explicit) {
+  if (explicit) {
+    const f = String(explicit).toLowerCase();
+    if (['xmeml', 'fcp7', 'fcpxml'].includes(f)) return 'xml';
+    return f;
+  }
+  const ext = path.extname(String(filePath || '')).toLowerCase();
+  const fmt = EXT_FORMAT[ext];
+  if (!fmt) {
+    throw new Error(`list_sequences: unknown extension '${ext || '(none)'}' — pass an explicit format (edl|otio|xml|drt|drp|aaf).`);
+  }
+  return fmt;
+}
+
+/** Map a parseDRT() result → uniform [{id,name,eventCount,index}]. Shared with the drt tool. */
+export function summarizeDrtTimelines(parsed) {
+  return (parsed.timelines || []).map((tl, index) => {
+    const vids = (tl.videoTracks || []).reduce((n, t) => n + (t.clips ? t.clips.length : 0), 0);
+    const auds = (tl.audioTracks || []).reduce((n, t) => n + (t.clips ? t.clips.length : 0), 0);
+    return {
+      id: parsed.seqContainers && parsed.seqContainers[index] ? parsed.seqContainers[index] : tl.name || `seq${index + 1}`,
+      name: tl.name || `Sequence ${index + 1}`,
+      eventCount: vids + auds,
+      index,
+    };
+  });
+}
+
+/**
+ * Enumerate sequences in a turnover file.
+ * @param {string} filePath absolute path to the interchange/project file
+ * @param {{format?:string, fps?:number}} [opts]
+ * @returns {Promise<Array<{id:string,name:string,eventCount:number,index:number}>>}
+ */
+export async function listSequences(filePath, opts = {}) {
+  const fmt = detectFormat(filePath, opts.format);
+
+  if (fmt === 'prproj') return listPrprojSequences(filePath);
+
+  if (fmt === 'aaf') {
+    const seqs = await listAafSequences(filePath);
+    return seqs.map((s, index) => ({ ...s, index }));
+  }
+
+  if (fmt === 'drt' || fmt === 'drp') {
+    const parsed = await drt().parseDRT(filePath);
+    return summarizeDrtTimelines(parsed);
+  }
+
+  // Text interchange (edl/otio/xml/xmeml/fcp7) — a single sequence per file.
+  const content = await fs.readFile(filePath, 'utf8');
+  const events = parseInterchange(fmt, content, { fps: opts.fps });
+  const name = path.basename(filePath);
+  return [{ id: name, name, eventCount: events.length, index: 0 }];
+}

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

@@ -15,8 +15,10 @@ import fs from 'node:fs/promises';
 import { z } from 'zod';
 import JSZip from 'jszip';
 import { drt } from '../libs.mjs';
+import { summarizeDrtTimelines } from '../sequences.mjs';
 
 const parseSchema = z.object({ drtPath: z.string().describe('Absolute path to a .drt (or .drp) file') });
+const listSequencesSchema = z.object({ drpPath: z.string().describe('Absolute path to a .drp (or .drt) file') });
 const authorSchema = z.object({
   spec: z.object({}).passthrough().describe('{ timelines, mediaPool?, metadata? } — buildDRP shape minus the project shell'),
   outputPath: z.string().describe('Absolute path where the .drt will be written'),
@@ -71,12 +73,18 @@ const downgradeSchema = z.object({
 export const drtTool = {
   name: 'drt',
   description:
-    'DaVinci Resolve Timeline (.drt) operations — offline, no Resolve required. Actions: parse, author, validate, inject_into_drp, extract_from_drp, 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: 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);
       return drt().parseDRT(p.drtPath);
     }
+    if (action === 'list_sequences') {
+      const p = listSequencesSchema.parse(args);
+      const parsed = await drt().parseDRT(p.drpPath);
+      const sequences = summarizeDrtTimelines(parsed);
+      return { path: p.drpPath, count: sequences.length, sequences };
+    }
     if (action === 'author') {
       const p = authorSchema.parse(args);
       const buf = await drt().buildDRT(p.spec);

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

@@ -3,22 +3,60 @@
  * changelist + conform manifest with TIMING silent-lie guards. Report-only (gate: review). No Resolve.
  *
  * Actions:
- *   parse_interchange   — EDL / OTIO / XMEML (AAF = honest refuse) → normalized edit events
- *   turnover_changelist — diff old vs new events → moved/retimed/replaced/new/gone (+timing flags)
- *   conform_manifest    — per-event assert: source resolved, handles, retime, reverse, TC-base
- *   marker_roundtrip    — marker/note round-trip with provenance tags
+ *   parse_interchange     — EDL / OTIO / XMEML / AAF (pyaaf2) / PRPROJ (gunzip+XML) → normalized events
+ *   list_sequences        — ONE picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}]
+ *   convert_to_interchange— events (or a parsed source) → OTIO/EDL/DRT Resolve CAN import (the .prproj bridge)
+ *   turnover_changelist   — diff old vs new events → moved/retimed/replaced/new/gone (+timing flags)
+ *   conform_manifest      — per-event assert: source resolved, handles, retime, reverse, TC-base
+ *   marker_roundtrip      — marker/note round-trip with provenance tags
  */
+import fs from 'node:fs/promises';
 import { z } from 'zod';
 import { parseInterchange, diffChangelist, timingGuards, conformManifest, markerRoundtrip } from '../editorial.mjs';
+import { parseAAF } from '../aaf.mjs';
+import { parsePrproj, parsePrprojDoc } from '../prproj.mjs';
+import { listSequences, detectFormat } from '../sequences.mjs';
+import { authorInterchange } from '../author-interchange.mjs';
 
 const eventArray = z.array(z.object({}).passthrough());
 
+/** Parse any supported turnover file (by path) into normalized events. Async (AAF spawns). */
+async function parseAnySource(sourcePath, sourceFormat) {
+  const fmt = detectFormat(sourcePath, sourceFormat);
+  if (fmt === 'aaf') return parseAAF(sourcePath);
+  if (fmt === 'prproj') return parsePrproj(sourcePath);
+  if (fmt === 'drt' || fmt === 'drp')
+    throw new Error('convert_to_interchange: .drt/.drp already import into Resolve directly — use timeline.import_from_drp, not the bridge.');
+  const content = await fs.readFile(sourcePath, 'utf8');
+  return parseInterchange(fmt, content, {});
+}
+
 const parseSchema = z.object({
-  format: z.enum(['edl', 'otio', 'xml', 'xmeml', 'fcp7', 'aaf']),
-  content: z.union([z.string(), z.object({}).passthrough()]).describe('EDL text / OTIO JSON (string or object) / XMEML string'),
+  format: z.enum(['edl', 'otio', 'xml', 'xmeml', 'fcp7', 'aaf', 'prproj']),
+  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.'),
+  fps: z.number().optional(),
+});
+
+const listSequencesSchema = z.object({
+  path: z.string().describe('Absolute path to an xml/fcpxml/edl/otio/drt/drp/aaf/prproj file'),
+  format: z.string().optional().describe('Override format detection (edl|otio|xml|drt|drp|aaf|prproj)'),
   fps: z.number().optional(),
 });
 
+const convertSchema = z
+  .object({
+    events: eventArray.optional().describe('Normalized events to author (or provide sourcePath+sourceFormat)'),
+    sourcePath: z.string().optional().describe('Parse this file first (edl/otio/xml/aaf/prproj) then author'),
+    sourceFormat: z.string().optional().describe('Format of sourcePath (default: detect by extension)'),
+    target: z.enum(['otio', 'edl', 'drt']).default('otio').describe('Interchange to author (Resolve-importable)'),
+    outputPath: z.string().optional().describe('Write the authored file here; otherwise return the content'),
+    name: z.string().optional(),
+    fps: z.number().optional(),
+  })
+  .describe('Author an interchange Resolve can import from events or a parsed source — the .prproj→Resolve bridge');
+
 const changelistSchema = z.object({
   old: eventArray.describe('Old (locked-cut) normalized events, OR provide oldFormat+oldContent'),
   new: eventArray.describe('New (turnover) normalized events'),
@@ -43,13 +81,48 @@ 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 → events; AAF = honest refuse), 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). PURE/offline.',
+    '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), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}]), 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/speed survive, per-clip effects/color do not), 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).',
   async handler({ action, args }) {
     if (action === 'parse_interchange') {
       const p = parseSchema.parse(args);
+      // Binary formats parse out-of-band from a PATH: AAF via pyaaf2, .prproj via gunzip+XML.
+      if (p.format === 'aaf') {
+        const events = await parseAAF(p.content);
+        return { format: 'aaf', count: events.length, events };
+      }
+      if (p.format === 'prproj') {
+        const doc = parsePrprojDoc(p.content);
+        const events = parsePrproj(p.content);
+        return { format: 'prproj', count: events.length, events, projectVersion: doc.projectVersion, mediaPaths: doc.mediaPaths };
+      }
       const events = parseInterchange(p.format, p.content, { fps: p.fps });
       return { format: p.format, count: events.length, events };
     }
+    if (action === 'list_sequences') {
+      const p = listSequencesSchema.parse(args);
+      const sequences = await listSequences(p.path, { format: p.format, fps: p.fps });
+      return { path: p.path, count: sequences.length, sequences };
+    }
+    if (action === 'convert_to_interchange') {
+      const p = convertSchema.parse(args);
+      let events = p.events;
+      if (!events || !events.length) {
+        if (!p.sourcePath) throw new Error('convert_to_interchange: provide events, or sourcePath (+sourceFormat)');
+        events = await parseAnySource(p.sourcePath, p.sourceFormat);
+      }
+      const authored = await authorInterchange(events, p.target, { name: p.name, fps: p.fps });
+      let written = null;
+      if (p.outputPath) {
+        await fs.writeFile(p.outputPath, authored.buffer || authored.content);
+        written = { outputPath: p.outputPath, bytes: (authored.buffer || Buffer.from(authored.content)).length };
+      }
+      return {
+        target: authored.target,
+        eventCount: events.length,
+        ...(written || { content: authored.content }),
+        ...(authored.spec ? { spec: authored.spec } : {}),
+      };
+    }
     if (action === 'turnover_changelist') {
       const p = changelistSchema.parse(args);
       const result = diffChangelist(p.old, p.new, { recTolerance: p.recTolerance });

package/src/granular/common.py

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