premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/set-item-metadata.jsx

@@ -0,0 +1,134 @@
+// Command: set-item-metadata → ppb_setItemMetadata
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Project-item addressing: at least one of nodeId/name is required (see
+// get-item-metadata.jsx for the shared design note — the resolver is
+// duplicated per-file since command files load independently).
+//
+// WRITE command — this is the write-side counterpart of get-item-metadata.
+// setProjectMetadata(value, [fieldPath]) replaces the value at one field
+// path (e.g. "Column.Intrinsic.Description"); it does NOT touch other
+// fields. Undo is NON-FUNCTIONAL on this build — `previousValue` (the
+// full metadata blob read before mutating) is the only restoration path
+// if a caller needs to revert.
+
+function ppbFindItemSetItemMetadata_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 = ppbFindItemSetItemMetadata_walk(item.children[i], args, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbFindItemSetItemMetadata_resolve(args) {
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var found = ppbFindItemSetItemMetadata_walk(root.children[i], args, 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function ppb_setItemMetadata(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" });
+    }
+
+    var hasFieldPath = typeof args.fieldPath === "string" && args.fieldPath.length > 0;
+    if (!hasFieldPath) {
+      return JSON.stringify({ ok: false, error: "fieldPath is required" });
+    }
+    if (typeof args.value !== "string") {
+      return JSON.stringify({ ok: false, error: "value (string) is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = ppbFindItemSetItemMetadata_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" });
+    }
+
+    if (typeof item.setProjectMetadata !== "function") {
+      return JSON.stringify({ ok: false, error: "setProjectMetadata is not available on this Premiere build" });
+    }
+
+    var previousValue = null;
+    try { previousValue = item.getProjectMetadata(); } catch (e) { previousValue = null; }
+
+    try {
+      item.setProjectMetadata(args.value, [args.fieldPath]);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "setProjectMetadata() failed: " + e.toString() });
+    }
+
+    var newValue = null;
+    try { newValue = item.getProjectMetadata(); } catch (e) { newValue = null; }
+
+    var verified = false;
+    try {
+      verified = typeof newValue === "string" && newValue.indexOf(args.value) !== -1;
+    } catch (e) {
+      verified = false;
+    }
+
+    var result = {
+      name: null,
+      nodeId: null,
+      fieldPath: args.fieldPath,
+      requestedValue: args.value,
+      previousValue: previousValue,
+      newValue: newValue,
+      verified: verified
+    };
+    try { result.name = item.name; } catch (e) { result.name = null; }
+    try { result.nodeId = item.nodeId; } catch (e) { result.nodeId = null; }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/set-item-offline.jsx

@@ -0,0 +1,109 @@
+// Command: set-item-offline → ppb_setItemOffline
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND, ...)
+// are already defined there.
+//
+// Ports the reference project's media.ts set_offline tool. Item resolution
+// by nodeId/name uses children-presence recursion (NOT an isBin() gate),
+// per get-project-item-info.jsx's live-debugged finding. **Destructive-ish**:
+// unlinks the item's media (item.setOffline()); undo is non-functional on
+// this build, so there is no scripted path back — relink-media is the
+// manual recovery path once a new/original file path is known. Verified
+// via an isOffline() read-back.
+
+function ppbSetItemOffline_findByNodeId(item, nodeId, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.nodeId === nodeId) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbSetItemOffline_findByNodeId(item.children[i], nodeId, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbSetItemOffline_findByName(item, name, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.name === name) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbSetItemOffline_findByName(item.children[i], name, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppb_setItemOffline(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 (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = hasNodeId
+      ? ppbSetItemOffline_findByNodeId(app.project.rootItem, args.nodeId, 0)
+      : ppbSetItemOffline_findByName(app.project.rootItem, args.name, 0);
+    if (!item) {
+      return JSON.stringify({ ok: false, error: "no project item found matching the given nodeId/name" });
+    }
+
+    var previousValue = null;
+    try { previousValue = item.isOffline(); } catch (e) { previousValue = null; }
+
+    try {
+      item.setOffline();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "setOffline() failed: " + e.toString() });
+    }
+
+    var newValue = null;
+    try { newValue = item.isOffline(); } catch (e) { newValue = null; }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        nodeId: item.nodeId,
+        name: item.name,
+        previousValue: previousValue,
+        newValue: newValue,
+        verified: newValue === true
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/set-item-start-time.jsx

@@ -0,0 +1,139 @@
+// Command: set-item-start-time → ppb_setItemStartTime
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND, ...)
+// are already defined there.
+//
+// Ports the reference project's media.ts/track-targeting.ts set_start_time
+// tool (setStartTime — timecode offset for the source media, not a
+// timeline position). Item resolution by nodeId/name uses children-
+// presence recursion (NOT an isBin() gate), per get-project-item-info.jsx's
+// live-debugged finding. Converts seconds to a ticks string (per
+// PREMIERE_API_NOTES.md's item.setStartTime(ticksStr) signature) before
+// calling. No confirmed getter exists for a project item's start time on
+// this build, so a short list of plausible getter names is probed for
+// read-back verification — same defensive pattern as set-poster-frame.
+
+function ppbSetItemStartTime_findByNodeId(item, nodeId, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.nodeId === nodeId) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbSetItemStartTime_findByNodeId(item.children[i], nodeId, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbSetItemStartTime_findByName(item, name, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.name === name) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbSetItemStartTime_findByName(item.children[i], name, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+// Probes a short list of plausible getter names/shapes for a project
+// item's start time — none is documented in PREMIERE_API_NOTES.md, unlike
+// the well-confirmed getInPoint()/getOutPoint() pair. Returns seconds, or
+// null if none of the probed getters exist/succeed.
+function ppbSetItemStartTime_probeGetter(item) {
+  var candidates = ["getStartTime", "getStartOffset"];
+  for (var i = 0; i < candidates.length; i++) {
+    try {
+      if (typeof item[candidates[i]] === "function") {
+        var raw = item[candidates[i]]();
+        if (raw !== null && typeof raw !== "undefined") {
+          return { name: candidates[i], seconds: timeValueToSeconds(raw) };
+        }
+      }
+    } catch (e) {
+      // try next candidate
+    }
+  }
+  return null;
+}
+
+function ppb_setItemStartTime(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") {
+      return JSON.stringify({ ok: false, error: "seconds is required and must be a number" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = hasNodeId
+      ? ppbSetItemStartTime_findByNodeId(app.project.rootItem, args.nodeId, 0)
+      : ppbSetItemStartTime_findByName(app.project.rootItem, args.name, 0);
+    if (!item) {
+      return JSON.stringify({ ok: false, error: "no project item found matching the given nodeId/name" });
+    }
+
+    var before = ppbSetItemStartTime_probeGetter(item);
+    var ticksStr = String(Math.round(args.seconds * TICKS_PER_SECOND));
+
+    try {
+      item.setStartTime(ticksStr);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "setStartTime() failed: " + e.toString() });
+    }
+
+    var after = ppbSetItemStartTime_probeGetter(item);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        nodeId: item.nodeId,
+        name: item.name,
+        requestedSeconds: args.seconds,
+        ticksString: ticksStr,
+        previousValue: before ? before.seconds : null,
+        newValue: after ? after.seconds : null,
+        readBackGetterUsed: after ? after.name : null,
+        note: after
+          ? null
+          : "no confirmed getter for a project item's start time exists on this build — only the setter's non-throw result is confirmed"
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/set-keyframe-interpolation.jsx

@@ -0,0 +1,186 @@
+// Command: set-keyframe-interpolation → ppb_setKeyframeInterpolation
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// findClipComponent, findComponentProperty, timeValueToSeconds,
+// keyTimeToSeconds, tryTimeForms, getSequenceFps, ...) are already defined
+// there.
+//
+// Standard-DOM mutation. Ported from leancoderkavy's premiere-pro-mcp
+// `set_keyframe_interpolation` tool (keyframes.ts), addressed here by
+// trackType/trackIndex/clipIndex + componentName/propertyName. `seconds`
+// is clip-relative, offset by clip.start to sequence time (same half-frame
+// tolerance existing-key lookup as remove-keyframe).
+//
+// interpolationType IS A RAW INT, and its enum meaning is DISPUTED across
+// Premiere builds per PREMIERE_API_NOTES.md's Property API block:
+// leancoderkavy uses 0=Linear, 4=Hold, 5=Bezier; ayushozha's own docs claim
+// a plain 0/1/2 map instead. This command does NOT translate a name to an
+// int — the caller passes the raw int and gets it back unmodified; treat
+// the actual on-screen result as the source of truth until verified live.
+// There is no confirmed getter to read a keyframe's current interpolation
+// back — `verified` here only means the setInterpolationTypeAtKey() call
+// itself did not throw, NOT that Premiere applied the requested type.
+function ppb_setKeyframeInterpolation(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.interpolationType !== "number" || Math.floor(args.interpolationType) !== args.interpolationType) {
+      return JSON.stringify({ ok: false, error: "interpolationType must be an integer (meaning is version-dependent — see docs)" });
+    }
+
+    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 fps = 30;
+    try { fps = getSequenceFps(seq) || 30; } catch (e) { fps = 30; }
+    var toleranceSeconds = 0.5 / fps;
+
+    var sequenceSeconds = clipStartSeconds + args.seconds;
+
+    var rawKeys = null;
+    try { rawKeys = prop.getKeys(); } catch (e) { rawKeys = null; }
+
+    var matchedKey = null;
+    var matchedSeconds = null;
+    if (rawKeys) {
+      for (var i = 0; i < rawKeys.length; i++) {
+        var ks = null;
+        try { ks = keyTimeToSeconds(rawKeys[i]); } catch (e1) { ks = null; }
+        if (ks !== null && Math.abs(ks - sequenceSeconds) <= toleranceSeconds) {
+          matchedKey = rawKeys[i];
+          matchedSeconds = ks;
+          break;
+        }
+      }
+    }
+
+    var interpolationType = args.interpolationType;
+    var setAttempts = [];
+    var set = false;
+
+    if (matchedKey !== null) {
+      try {
+        prop.setInterpolationTypeAtKey(matchedKey, interpolationType, true);
+        setAttempts.push({ form: "existingKeyObject", success: true });
+        set = true;
+      } catch (e2) {
+        setAttempts.push({ form: "existingKeyObject", success: false, error: e2.toString() });
+      }
+    }
+
+    if (!set) {
+      var tf = tryTimeForms(sequenceSeconds, function (t) {
+        prop.setInterpolationTypeAtKey(t, interpolationType, true);
+      });
+      setAttempts = setAttempts.concat(tf.attempts);
+      set = tf.success;
+    }
+
+    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,
+        toleranceSeconds: toleranceSeconds,
+        matchedExistingKey: matchedKey !== null,
+        matchedSeconds: matchedSeconds,
+        interpolationType: interpolationType,
+        setAttempts: setAttempts,
+        called: set,
+        note: "interpolationType is a RAW INT whose enum meaning is DISPUTED across Premiere builds " +
+          "(0=Linear/4=Hold/5=Bezier per one reference repo vs. a plain 0/1/2 map per another) — " +
+          "no name-mapping is applied here. `called` only confirms the call didn't throw; there is " +
+          "no confirmed getter to read a keyframe's interpolation back and verify the result."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/set-override-frame-rate.jsx

@@ -0,0 +1,123 @@
+// Command: set-override-frame-rate → ppb_setOverrideFrameRate
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND, ...)
+// are already defined there.
+//
+// Ports the reference project's media.ts set_override_frame_rate tool.
+// Item resolution by nodeId/name uses children-presence recursion (NOT an
+// isBin() gate), per get-project-item-info.jsx's live-debugged finding.
+// previousValue/newValue are read via item.getFootageInterpretation().
+// frameRate (same field get-footage-interpretation exposes) before/after
+// calling item.setOverrideFrameRate(fps). Undo is non-functional on this
+// build — previousValue is the only restoration path.
+
+function ppbSetOverrideFrameRate_findByNodeId(item, nodeId, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.nodeId === nodeId) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbSetOverrideFrameRate_findByNodeId(item.children[i], nodeId, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbSetOverrideFrameRate_findByName(item, name, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.name === name) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbSetOverrideFrameRate_findByName(item.children[i], name, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbSetOverrideFrameRate_readFrameRate(item) {
+  try {
+    var interp = item.getFootageInterpretation();
+    if (interp) {
+      return interp.frameRate;
+    }
+  } catch (e) {
+    // fall through
+  }
+  return null;
+}
+
+function ppb_setOverrideFrameRate(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.fps !== "number" || args.fps <= 0) {
+      return JSON.stringify({ ok: false, error: "fps must be a positive number" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = hasNodeId
+      ? ppbSetOverrideFrameRate_findByNodeId(app.project.rootItem, args.nodeId, 0)
+      : ppbSetOverrideFrameRate_findByName(app.project.rootItem, args.name, 0);
+    if (!item) {
+      return JSON.stringify({ ok: false, error: "no project item found matching the given nodeId/name" });
+    }
+
+    var previousValue = ppbSetOverrideFrameRate_readFrameRate(item);
+
+    try {
+      item.setOverrideFrameRate(args.fps);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "setOverrideFrameRate() failed: " + e.toString() });
+    }
+
+    var newValue = ppbSetOverrideFrameRate_readFrameRate(item);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        nodeId: item.nodeId,
+        name: item.name,
+        previousValue: previousValue,
+        requestedValue: args.fps,
+        newValue: newValue,
+        verified: newValue !== null && Math.abs(newValue - args.fps) < 0.001
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}