premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/add-keyframe.jsx

@@ -0,0 +1,181 @@
+// Command: add-keyframe → ppb_addKeyframe
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// findClipComponent, findComponentProperty, timeValueToSeconds,
+// tryTimeForms, ...) are already defined there.
+//
+// Standard-DOM mutation. Ported from leancoderkavy's premiere-pro-mcp
+// `add_keyframe` tool (keyframes.ts), addressed here by
+// trackType/trackIndex/clipIndex + componentName/propertyName. Per
+// PREMIERE_API_NOTES.md: prop.setTimeVarying(true) is REQUIRED before
+// addKey()/setValueAtKey() (called here only if not already time-varying —
+// wasAlreadyTimeVarying reports which); `seconds` is clip-relative
+// (matching add-audio-keyframes' convention) and offset by clip.start to
+// sequence time before use. Key-time argument form is disputed across
+// builds — tryTimeForms() tries ticksString, then a Time object, then a
+// raw seconds number, recording every attempt. Verified via a getKeys()
+// COUNT comparison before/after (not an exact-time match) — remove-keyframe
+// is the cleanup path if this adds the wrong thing, since undo is
+// non-functional on this build.
+function ppb_addKeyframe(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (args.trackType !== "video" && args.trackType !== "audio") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\" or \"audio\"" });
+    }
+    if (typeof args.trackIndex !== "number" || args.trackIndex < 0 || Math.floor(args.trackIndex) !== args.trackIndex) {
+      return JSON.stringify({ ok: false, error: "trackIndex must be a non-negative integer" });
+    }
+    if (typeof args.clipIndex !== "number" || args.clipIndex < 0 || Math.floor(args.clipIndex) !== args.clipIndex) {
+      return JSON.stringify({ ok: false, error: "clipIndex must be a non-negative integer" });
+    }
+    if (typeof args.componentName !== "string" || !args.componentName) {
+      return JSON.stringify({ ok: false, error: "componentName is required" });
+    }
+    if (typeof args.propertyName !== "string" || !args.propertyName) {
+      return JSON.stringify({ ok: false, error: "propertyName is required" });
+    }
+    if (typeof args.seconds !== "number") {
+      return JSON.stringify({ ok: false, error: "seconds must be a number (clip-relative)" });
+    }
+    if (typeof args.value === "undefined") {
+      return JSON.stringify({ ok: false, error: "value is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var trackCollection = args.trackType === "video" ? seq.videoTracks : seq.audioTracks;
+    var numTracks = trackCollection.numTracks;
+    if (args.trackIndex >= numTracks) {
+      return JSON.stringify({
+        ok: false,
+        error: "trackIndex " + args.trackIndex + " is out of range — sequence has " + numTracks + " " + args.trackType + " track(s)"
+      });
+    }
+
+    var track = trackCollection[args.trackIndex];
+    var numClips = track.clips.numItems;
+    if (args.clipIndex >= numClips) {
+      return JSON.stringify({
+        ok: false,
+        error: "clipIndex " + args.clipIndex + " is out of range — track " + args.trackIndex + " has " + numClips + " clip(s)"
+      });
+    }
+
+    var clip = track.clips[args.clipIndex];
+    var clipName = null;
+    try { clipName = clip.name; } catch (e) { clipName = null; }
+
+    var clipStartSeconds = 0;
+    try { clipStartSeconds = timeValueToSeconds(clip.start) || 0; } catch (e) { clipStartSeconds = 0; }
+
+    var comp = findClipComponent(clip, [args.componentName], [args.componentName]);
+    if (!comp) {
+      return JSON.stringify({
+        ok: false,
+        error: "component \"" + args.componentName + "\" not found on clip (matched against matchName and displayName)"
+      });
+    }
+    var compDisplayName = null;
+    try { compDisplayName = comp.displayName; } catch (e) { compDisplayName = null; }
+
+    var prop = findComponentProperty(comp, [args.propertyName]);
+    if (!prop) {
+      return JSON.stringify({
+        ok: false,
+        error: "property \"" + args.propertyName + "\" not found on component \"" + compDisplayName + "\""
+      });
+    }
+
+    var wasAlreadyTimeVarying = false;
+    try { wasAlreadyTimeVarying = prop.isTimeVarying(); } catch (e) { wasAlreadyTimeVarying = false; }
+
+    var setTimeVaryingError = null;
+    if (!wasAlreadyTimeVarying) {
+      try {
+        prop.setTimeVarying(true);
+      } catch (e) {
+        setTimeVaryingError = e.toString();
+      }
+    }
+
+    var keyCountBefore = 0;
+    try {
+      var keysBefore = prop.getKeys();
+      keyCountBefore = keysBefore ? keysBefore.length : 0;
+    } catch (e) {
+      keyCountBefore = null;
+    }
+
+    var sequenceSeconds = clipStartSeconds + args.seconds;
+    var value = args.value;
+
+    var addAttempt = tryTimeForms(sequenceSeconds, function (t) {
+      prop.addKey(t);
+    });
+
+    var setAttempt = null;
+    if (addAttempt.success) {
+      setAttempt = tryTimeForms(sequenceSeconds, function (t) {
+        prop.setValueAtKey(t, value, true);
+      });
+    }
+
+    var keyCountAfter = 0;
+    try {
+      var keysAfter = prop.getKeys();
+      keyCountAfter = keysAfter ? keysAfter.length : 0;
+    } catch (e) {
+      keyCountAfter = null;
+    }
+
+    var verified = (keyCountBefore !== null && keyCountAfter !== null && keyCountAfter === keyCountBefore + 1);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        clipName: clipName,
+        componentName: compDisplayName,
+        propertyName: args.propertyName,
+        seconds: args.seconds,
+        sequenceSeconds: sequenceSeconds,
+        value: value,
+        wasAlreadyTimeVarying: wasAlreadyTimeVarying,
+        setTimeVaryingError: setTimeVaryingError,
+        addKeyAttempts: addAttempt.attempts,
+        setValueAttempts: setAttempt ? setAttempt.attempts : null,
+        keyCountBefore: keyCountBefore,
+        keyCountAfter: keyCountAfter,
+        verified: verified,
+        note: "verified is a KEY-COUNT comparison, not an exact-time match — use get-keyframes to confirm the new key's time/value. remove-keyframe is the cleanup path (undo is non-functional on this build)."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/add-marker-to-project-item.jsx

@@ -0,0 +1,194 @@
+// Command: add-marker-to-project-item → ppb_addMarkerToProjectItem
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers are already defined
+// there (this file needs none of them beyond app itself).
+//
+// Ported from leancoderkavy's premiere-pro-mcp add_marker_to_project_item
+// tool. Project-item addressing matches get-item-metadata.jsx (at least
+// one of nodeId/name required, depth-first bin walk, nodeId matched
+// exactly, name matched exactly against item.name, first match wins) —
+// duplicated locally per this panel's convention since each command file
+// loads independently. Adds a SOURCE marker via item.getMarkers(), the
+// same marker API shape as seq.markers per PREMIERE_API_NOTES.md
+// (createMarker(SECONDS), .name/.comments/.type setters, .end in
+// seconds, .setColorByIndex(0-7)).
+//
+// MUTATION RULE: verified by re-finding the marker just created via a
+// fresh item.getMarkers() walk matched on .guid — never trusting the
+// object createMarker() handed back alone.
+//
+// Wire-arg note: the project item is addressed by nodeId/name (like
+// get-item-metadata), so the marker's own label uses "markerName" instead
+// of "name" to avoid colliding with the item-addressing "name" field.
+
+function ppbAddMarkerToProjectItem_walk(item, args, depth) {
+  if (depth > 32) {
+    return null;
+  }
+
+  var isBin = false;
+  try {
+    isBin = typeof ProjectItemType !== "undefined" && item.type === ProjectItemType.BIN;
+  } catch (e) {
+    isBin = false;
+  }
+
+  var matched = false;
+  if (args.nodeId !== null) {
+    try { matched = item.nodeId === args.nodeId; } catch (e) { matched = false; }
+  } else if (args.name !== null) {
+    try { matched = item.name === args.name; } catch (e) { matched = false; }
+  }
+  if (matched) {
+    return item;
+  }
+
+  if (isBin && item.children) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbAddMarkerToProjectItem_walk(item.children[i], args, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbAddMarkerToProjectItem_resolve(args) {
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var found = ppbAddMarkerToProjectItem_walk(root.children[i], args, 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function ppbAddMarkerToProjectItem_serializeOne(m) {
+  var entry = { name: null, comments: null, type: null, startSeconds: null, endSeconds: null, guid: null };
+  try { entry.name = m.name; } catch (e) { entry.name = null; }
+  try { entry.comments = m.comments; } catch (e) { entry.comments = null; }
+  try { entry.type = m.type; } catch (e) { entry.type = null; }
+  try {
+    entry.startSeconds = typeof m.start.seconds === "number" ? m.start.seconds : Number(m.start.ticks) / TICKS_PER_SECOND;
+  } catch (e) { entry.startSeconds = null; }
+  try {
+    entry.endSeconds = typeof m.end.seconds === "number" ? m.end.seconds : Number(m.end.ticks) / TICKS_PER_SECOND;
+  } catch (e) { entry.endSeconds = null; }
+  try { entry.guid = m.guid; } catch (e) { entry.guid = null; }
+  return entry;
+}
+
+function ppbAddMarkerToProjectItem_findByGuid(markers, guid) {
+  var m = markers.getFirstMarker();
+  var iterations = 0;
+  while (m !== null && typeof m !== "undefined" && iterations < 10000) {
+    var thisGuid = null;
+    try { thisGuid = m.guid; } catch (e) { thisGuid = null; }
+    if (thisGuid === guid) {
+      return m;
+    }
+    m = markers.getNextMarker(m);
+    iterations++;
+  }
+  return null;
+}
+
+function ppb_addMarkerToProjectItem(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var hasNodeId = typeof args.nodeId === "string" && args.nodeId.length > 0;
+    var hasName = typeof args.name === "string" && args.name.length > 0;
+    if (!hasNodeId && !hasName) {
+      return JSON.stringify({ ok: false, error: "either nodeId or name is required" });
+    }
+
+    if (typeof args.seconds !== "number" || isNaN(args.seconds) || args.seconds < 0) {
+      return JSON.stringify({ ok: false, error: "seconds must be a non-negative number" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = ppbAddMarkerToProjectItem_resolve({
+      nodeId: hasNodeId ? args.nodeId : null,
+      name: hasNodeId ? null : args.name
+    });
+    if (!item) {
+      return JSON.stringify({ ok: false, error: "no project item found matching the given nodeId/name" });
+    }
+
+    var markers;
+    try {
+      markers = item.getMarkers();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "getMarkers() failed on this item: " + e.toString() });
+    }
+    if (!markers || typeof markers.createMarker !== "function") {
+      return JSON.stringify({ ok: false, error: "this project item has no marker collection" });
+    }
+
+    var marker;
+    try {
+      marker = markers.createMarker(args.seconds);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "createMarker failed: " + e.toString() });
+    }
+    if (!marker) {
+      return JSON.stringify({ ok: false, error: "createMarker returned no marker" });
+    }
+
+    if (typeof args.markerName === "string") {
+      try { marker.name = args.markerName; } catch (e) { /* best-effort */ }
+    }
+    if (typeof args.comments === "string") {
+      try { marker.comments = args.comments; } catch (e) { /* best-effort */ }
+    }
+    if (typeof args.type === "string") {
+      try { marker.type = args.type; } catch (e) { /* best-effort */ }
+    }
+    if (typeof args.colorIndex === "number") {
+      try { marker.setColorByIndex(args.colorIndex); } catch (e) { /* best-effort */ }
+    }
+    if (typeof args.durationSeconds === "number" && args.durationSeconds > 0) {
+      try {
+        var endTime = new Time();
+        endTime.seconds = args.seconds + args.durationSeconds;
+        marker.end = endTime;
+      } catch (e) { /* best-effort */ }
+    }
+
+    var guid = null;
+    try { guid = marker.guid; } catch (e) { guid = null; }
+
+    var verified = null;
+    if (guid !== null) {
+      var found = ppbAddMarkerToProjectItem_findByGuid(markers, guid);
+      if (found) {
+        verified = ppbAddMarkerToProjectItem_serializeOne(found);
+      }
+    }
+    if (verified === null) {
+      verified = ppbAddMarkerToProjectItem_serializeOne(marker);
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        item: (function () { try { return item.name; } catch (e) { return null; } })(),
+        nodeId: (function () { try { return item.nodeId; } catch (e) { return null; } })(),
+        marker: verified
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/add-marker.jsx

@@ -0,0 +1,129 @@
+// Command: add-marker → ppb_addMarker
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// findSequenceByName, timeValueToSeconds, ...) are already defined there.
+//
+// Ported from leancoderkavy's premiere-pro-mcp add_marker tool — adds a
+// marker to the ACTIVE (or named) SEQUENCE's own marker collection
+// (seq.markers), not a project item (see add-marker-to-project-item.jsx
+// for that). Per PREMIERE_API_NOTES.md: markers.createMarker(SECONDS)
+// returns the new marker; .name/.comments/.type are plain setters; .end
+// is also a SECONDS value (not ticks, despite everything else in this
+// panel using ticks strings); color is set via .setColorByIndex(0-7).
+//
+// MUTATION RULE: verified by re-finding the marker just created via a
+// fresh getFirstMarker()/getNextMarker() walk matched on .guid (never
+// trusting the object createMarker() handed back alone) and serializing
+// that freshly-read marker back to the caller.
+
+function ppbAddMarker_serializeOne(m) {
+  var entry = { name: null, comments: null, type: null, startSeconds: null, endSeconds: null, guid: null };
+  try { entry.name = m.name; } catch (e) { entry.name = null; }
+  try { entry.comments = m.comments; } catch (e) { entry.comments = null; }
+  try { entry.type = m.type; } catch (e) { entry.type = null; }
+  try { entry.startSeconds = timeValueToSeconds(m.start); } catch (e) { entry.startSeconds = null; }
+  try { entry.endSeconds = timeValueToSeconds(m.end); } catch (e) { entry.endSeconds = null; }
+  try { entry.guid = m.guid; } catch (e) { entry.guid = null; }
+  return entry;
+}
+
+function ppbAddMarker_findByGuid(seq, guid) {
+  var m = seq.markers.getFirstMarker();
+  var iterations = 0;
+  while (m !== null && typeof m !== "undefined" && iterations < 10000) {
+    var thisGuid = null;
+    try { thisGuid = m.guid; } catch (e) { thisGuid = null; }
+    if (thisGuid === guid) {
+      return m;
+    }
+    m = seq.markers.getNextMarker(m);
+    iterations++;
+  }
+  return null;
+}
+
+function ppb_addMarker(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (typeof args.seconds !== "number" || isNaN(args.seconds) || args.seconds < 0) {
+      return JSON.stringify({ ok: false, error: "seconds must be a non-negative number" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var marker;
+    try {
+      marker = seq.markers.createMarker(args.seconds);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "createMarker failed: " + e.toString() });
+    }
+    if (!marker) {
+      return JSON.stringify({ ok: false, error: "createMarker returned no marker" });
+    }
+
+    if (typeof args.name === "string") {
+      try { marker.name = args.name; } catch (e) { /* best-effort */ }
+    }
+    if (typeof args.comments === "string") {
+      try { marker.comments = args.comments; } catch (e) { /* best-effort */ }
+    }
+    if (typeof args.type === "string") {
+      try { marker.type = args.type; } catch (e) { /* best-effort */ }
+    }
+    if (typeof args.colorIndex === "number") {
+      try { marker.setColorByIndex(args.colorIndex); } catch (e) { /* best-effort */ }
+    }
+    if (typeof args.durationSeconds === "number" && args.durationSeconds > 0) {
+      try { marker.end = args.seconds + args.durationSeconds; } catch (e) { /* best-effort */ }
+    }
+
+    var guid = null;
+    try { guid = marker.guid; } catch (e) { guid = null; }
+
+    var verified = null;
+    if (guid !== null) {
+      var found = ppbAddMarker_findByGuid(seq, guid);
+      if (found) {
+        verified = ppbAddMarker_serializeOne(found);
+      }
+    }
+    if (verified === null) {
+      // No guid available, or the re-find failed — fall back to
+      // serializing the object createMarker handed back directly. Still a
+      // live read of the marker's own properties, just not an
+      // independently re-fetched one.
+      verified = ppbAddMarker_serializeOne(marker);
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        marker: verified
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/add-text-overlay.jsx

@@ -0,0 +1,101 @@
+// Command: add-text-overlay → ppb_addTextOverlay
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — secondsToTicksString is already
+// defined there.
+//
+// Ported from leancoderkavy's premiere-pro-mcp text.ts add_text_overlay —
+// EXACTLY as that reference implements it, including its own documented
+// caveat: "Premiere's ExtendScript API does not expose Essential-Graphics
+// title creation" (confirmed independently in PREMIERE_API_NOTES.md's
+// "No title-creation API exists" line — createNewTitle is gone, Essential
+// Graphics titles cannot be scripted), so this routes text through the
+// Captions/Subtitle API instead of a real freeform title.
+//
+// ⚠️ API ARITY CONFLICT (documented honestly, not resolved): this file
+// calls seq.createCaptionTrack(formatNum) with ONE argument, matching
+// text.ts's own implementation byte-for-byte. PREMIERE_API_NOTES.md's
+// "Captions" line documents a DIFFERENT, 3-argument signature —
+// seq.createCaptionTrack(srtProjectItem, startSeconds, formatConstant) —
+// which is what this panel's own create-caption-track command uses. The
+// two reference tools this panel ports from disagree on arity for the
+// same underlying call, and text.ts's 1-arg form has NOT been live-tested
+// against this Premiere build — it may throw "Illegal Parameter type" (a
+// known failure mode elsewhere in this codebase when a call's real arity
+// is wrong). If this command fails, prefer create-caption-track (which
+// requires an actual imported .srt project item) or render a PNG
+// externally and import it, per PREMIERE_API_NOTES.md's own suggested
+// alternatives.
+//
+// formatMap below is text.ts's own numeric map (Sequence.captionFormat),
+// NOT the Sequence.CAPTION_FORMAT_* named constants create-caption-track
+// uses — kept separate deliberately since this file mirrors text.ts
+// exactly per its own convention.
+function ppb_addTextOverlay(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (typeof args.text !== "string" || !args.text) {
+      return JSON.stringify({ ok: false, error: "text is required" });
+    }
+
+    var startSeconds = typeof args.startSeconds === "number" ? args.startSeconds : 0;
+    var durationSeconds = typeof args.durationSeconds === "number" ? args.durationSeconds : 5;
+
+    var formatMap = { "subtitle": 3, "608": 1, "708": 2, "teletext": 4 };
+    var captionFormat = (typeof args.captionFormat === "string" && formatMap.hasOwnProperty(args.captionFormat)) ? args.captionFormat : "subtitle";
+    var formatNum = formatMap[captionFormat];
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+    var seq = app.project.activeSequence;
+    if (!seq) {
+      return JSON.stringify({ ok: false, error: "no active sequence" });
+    }
+
+    var startTicks = secondsToTicksString(startSeconds);
+    var endTicks = secondsToTicksString(startSeconds + durationSeconds);
+
+    var captionTrack = null;
+    try {
+      captionTrack = seq.createCaptionTrack(formatNum);
+    } catch (eCT) {
+      return JSON.stringify({ ok: false, error: "createCaptionTrack failed: " + eCT.toString() });
+    }
+    if (!captionTrack) {
+      return JSON.stringify({ ok: false, error: "could not create caption track" });
+    }
+
+    var newCap = null;
+    var textSetError = null;
+    try {
+      newCap = captionTrack.addCaption(startTicks, endTicks);
+      if (newCap) {
+        try { newCap.text = args.text; } catch (eT) { textSetError = eT.toString(); }
+      }
+    } catch (eAdd) {
+      return JSON.stringify({ ok: false, error: "addCaption failed: " + eAdd.toString() });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        added: true,
+        text: args.text,
+        captionFormat: formatNum,
+        captionFormatName: captionFormat,
+        startSeconds: startSeconds,
+        durationSeconds: durationSeconds,
+        textSetError: textSetError,
+        note: "Routed through the Captions API per text.ts's own approach — no Essential-Graphics title-creation API exists on this build. Not live-tested; the 1-arg createCaptionTrack() form conflicts with the 3-arg form PREMIERE_API_NOTES.md documents (see file header comment)."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}