premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/auto-reframe-sequence.jsx

@@ -0,0 +1,124 @@
+// Command: auto-reframe-sequence → ppb_autoReframeSequence
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// PREMIERE_API_NOTES.md's Sequences table documents the 5-arg form:
+// `seq.autoReframeSequence(num, den, motionPreset, newName, nestBool)`
+// ("2020+ only") — that is what this command calls. This differs from
+// leancoderkavy's own advanced.ts auto_reframe_sequence tool, which instead
+// calls a 3-arg `seq.autoReframeSequence(targetWidth, targetHeight, nestBool)`
+// with no motionPreset/newName. The 5-arg form is used here per the task
+// spec and PREMIERE_API_NOTES.md; numerator/denominator are taken to be an
+// ASPECT RATIO (e.g. 9/16 for vertical), not pixel dimensions — UNCONFIRMED
+// against this build (no live test performed).
+//
+// Unlike createSubsequence/clone(), autoReframeSequence takes the new
+// sequence's name directly as an argument — no post-hoc rename step is
+// needed, but the new sequence is still located by a fresh
+// findSequenceByName() call afterward rather than trusting the call's own
+// (undocumented) return value.
+function ppb_autoReframeSequence(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+    if (typeof args.numerator !== "number" || args.numerator <= 0) {
+      return JSON.stringify({ ok: false, error: "numerator must be a positive number" });
+    }
+    if (typeof args.denominator !== "number" || args.denominator <= 0) {
+      return JSON.stringify({ ok: false, error: "denominator must be a positive number" });
+    }
+    var validPresets = { slower: true, "default": true, faster: true };
+    if (!args.motionPreset || !validPresets[args.motionPreset]) {
+      return JSON.stringify({ ok: false, error: "motionPreset must be one of slower, default, faster" });
+    }
+    if (!args.newName || typeof args.newName !== "string") {
+      return JSON.stringify({ ok: false, error: "newName is required" });
+    }
+    if (typeof args.nest !== "boolean") {
+      return JSON.stringify({ ok: false, error: "nest (boolean) is required" });
+    }
+
+    var seq;
+    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 numSequencesBefore = app.project.sequences.numSequences;
+
+    var callError = null;
+    try {
+      seq.autoReframeSequence(args.numerator, args.denominator, args.motionPreset, args.newName, args.nest);
+    } catch (e) {
+      callError = e.toString();
+    }
+
+    var numSequencesAfter = app.project.sequences.numSequences;
+
+    if (callError !== null) {
+      return JSON.stringify({
+        ok: false,
+        error: "seq.autoReframeSequence() failed: " + callError,
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter
+      });
+    }
+
+    var newSeq = findSequenceByName(args.newName);
+    if (!newSeq) {
+      return JSON.stringify({
+        ok: false,
+        error: "autoReframeSequence() did not throw, but no sequence named \"" + args.newName + "\" was found afterward",
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter
+      });
+    }
+
+    var newWidth = null;
+    var newHeight = null;
+    try {
+      var s = newSeq.getSettings();
+      newWidth = s.videoFrameWidth;
+      newHeight = s.videoFrameHeight;
+    } catch (e) {
+      newWidth = null;
+      newHeight = null;
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sourceSequenceName: seq.name,
+        numerator: args.numerator,
+        denominator: args.denominator,
+        motionPreset: args.motionPreset,
+        nest: args.nest,
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter,
+        newSequenceName: newSeq.name,
+        newSequenceID: newSeq.sequenceID,
+        newWidth: newWidth,
+        newHeight: newHeight,
+        note: "numerator/denominator are treated as an aspect ratio per PREMIERE_API_NOTES.md's 5-arg signature — UNCONFIRMED against this build; newWidth/newHeight are reported so a caller can verify the actual result"
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/batch-add-transitions.jsx

@@ -0,0 +1,158 @@
+// Command: batch-add-transitions → ppb_batchAddTransitions
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (ensureQEEnabled,
+// activateSequenceForQE, qeFindNthNonEmptyClip, ppbApplyTransitionToClip,
+// ...) are already defined there.
+//
+// Port of the reference project's batch_add_transitions, generalized from
+// its fixed "at every cut point on a track" behavior to the same atEnd
+// semantic as add-transition: applies the SAME transition to every clip
+// on one video track (default atEnd: true, i.e. at each clip's end/the
+// cut point between it and its successor — matching the reference tool's
+// own loop). Capped at 100 clips per call. Reuses the shared
+// ppbApplyTransitionToClip helper per clip, so the disputed addTransition
+// signature and transitions-count verification are identical to
+// add-transition's — see that file's header and PREMIERE_API_NOTES.md's
+// "Transitions (QE only)" section.
+var PPB_BATCH_ADD_TRANSITIONS_CAP = 100;
+
+function ppb_batchAddTransitions(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var trackType = args.trackType || "video";
+    if (trackType !== "video") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\" — no reference API demonstrates adding a transition to an audio track" });
+    }
+    var trackIndex = 0;
+    if (typeof args.trackIndex === "number") {
+      if (args.trackIndex < 0 || Math.floor(args.trackIndex) !== args.trackIndex) {
+        return JSON.stringify({ ok: false, error: "trackIndex must be a non-negative integer" });
+      }
+      trackIndex = args.trackIndex;
+    }
+    var atEnd = true;
+    if (typeof args.atEnd === "boolean") {
+      atEnd = args.atEnd;
+    } else if (args.atEnd !== undefined && args.atEnd !== null) {
+      return JSON.stringify({ ok: false, error: "atEnd must be a boolean if given (default true)" });
+    }
+    var transitionName = null;
+    if (typeof args.transitionName === "string" && args.transitionName.length > 0) {
+      transitionName = args.transitionName;
+    } else if (args.transitionName !== undefined && args.transitionName !== null) {
+      return JSON.stringify({ ok: false, error: "transitionName must be a non-empty string, or omitted/null for the default transition" });
+    }
+    var durationSeconds = 1.0;
+    if (typeof args.durationSeconds === "number") {
+      if (args.durationSeconds <= 0) {
+        return JSON.stringify({ ok: false, error: "durationSeconds must be a positive number" });
+      }
+      durationSeconds = args.durationSeconds;
+    } else if (args.durationSeconds !== undefined && args.durationSeconds !== null) {
+      return JSON.stringify({ ok: false, error: "durationSeconds must be a 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 numTracks;
+    try { numTracks = seq.videoTracks.numTracks; } catch (eNt) { numTracks = 0; }
+    if (trackIndex >= numTracks) {
+      return JSON.stringify({ ok: false, error: "trackIndex " + trackIndex + " is out of range — sequence has " + numTracks + " video track(s)" });
+    }
+    var numClips;
+    try { numClips = seq.videoTracks[trackIndex].clips.numItems; } catch (eNc) { numClips = 0; }
+    if (numClips < 2) {
+      return JSON.stringify({ ok: true, result: { sequenceName: seq.name, trackType: "video", trackIndex: trackIndex, totalClipsOnTrack: numClips, attempted: 0, succeeded: 0, cappedAtLimit: false, results: [] } });
+    }
+
+    try {
+      ensureQEEnabled();
+      activateSequenceForQE(seq);
+    } catch (e2) {
+      return JSON.stringify({ ok: false, error: "app.enableQE()/sequence activation failed: " + e2.toString() });
+    }
+    if (typeof qe === "undefined" || !qe.project) {
+      return JSON.stringify({ ok: false, error: "QE DOM not available after enableQE()" });
+    }
+
+    var transitionQE = null;
+    if (transitionName !== null) {
+      try {
+        if (qe.project.getVideoTransitionByName) {
+          transitionQE = qe.project.getVideoTransitionByName(transitionName);
+        }
+      } catch (e3) {
+        transitionQE = null;
+      }
+      if (!transitionQE) {
+        return JSON.stringify({ ok: false, error: "transition not found: \"" + transitionName + "\" (try list-available-transitions)" });
+      }
+    }
+
+    // One transition per cut point: clips 0..numClips-2 (the last clip has
+    // no successor to transition into), same range the reference tool's
+    // own loop uses.
+    var cutPointCount = numClips - 1;
+    var cappedAtLimit = cutPointCount > PPB_BATCH_ADD_TRANSITIONS_CAP;
+    var attemptCount = cappedAtLimit ? PPB_BATCH_ADD_TRANSITIONS_CAP : cutPointCount;
+
+    var results = [];
+    var succeeded = 0;
+    for (var c = 0; c < attemptCount; c++) {
+      var applyResult = ppbApplyTransitionToClip(seq, trackIndex, c, transitionQE, atEnd, durationSeconds);
+      results.push({
+        clipIndex: c,
+        clipName: applyResult.clipName,
+        previousTransitionCount: applyResult.previousCount,
+        newTransitionCount: applyResult.newCount,
+        addedTransitionName: applyResult.addedTransitionName,
+        verified: applyResult.verified,
+        succeededWithArgs: applyResult.succeededWithArgs,
+        error: applyResult.verified ? null : applyResult.error
+      });
+      if (applyResult.verified) {
+        succeeded++;
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: "video",
+        trackIndex: trackIndex,
+        transitionName: transitionName,
+        atEnd: atEnd,
+        durationSeconds: durationSeconds,
+        totalClipsOnTrack: numClips,
+        attempted: attemptCount,
+        succeeded: succeeded,
+        cappedAtLimit: cappedAtLimit,
+        results: results
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/batch-apply-effect.jsx

@@ -0,0 +1,182 @@
+// Command: batch-apply-effect → ppb_batchApplyEffect
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, resolveQeClip,
+// serializeClipComponents, findQeVideoEffectByName,
+// findQeAudioEffectByName, ...) are already defined there.
+//
+// Ports leancoderkavy's clipboard.ts batch_apply_effect's "track"/"all"
+// targets (there is no "selected" target here — combine with
+// select-clips-by-name/nameContains instead, same pattern
+// batch-set-clips-enabled uses). Matches clips across the given track
+// type(s) (default "both"), optionally narrowed to one trackIndex and/or a
+// case-insensitive nameContains substring, capped at 100 clips per call.
+// Each matching clip gets the effect applied via the standard QE dance
+// (getVideoEffectByName/getAudioEffectByName + addVideoEffect/
+// addAudioEffect chosen by THAT clip's own track type, not a single global
+// effect object — a video effect and an audio effect with the same name are
+// different catalog entries), verified individually by that clip's own
+// clip.components.numItems increasing by 1.
+function ppb_batchApplyEffect(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.effectName !== "string" || !args.effectName) {
+      return JSON.stringify({ ok: false, error: "effectName must be a non-empty string" });
+    }
+    var trackTypeFilter = args.trackType || "both";
+    if (trackTypeFilter !== "video" && trackTypeFilter !== "audio" && trackTypeFilter !== "both") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\", \"audio\", or \"both\"" });
+    }
+    if (args.trackIndex !== undefined && args.trackIndex !== null) {
+      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 given" });
+      }
+      if (trackTypeFilter === "both") {
+        return JSON.stringify({ ok: false, error: "trackIndex requires trackType to be \"video\" or \"audio\" (not \"both\")" });
+      }
+    }
+    var nameContains = (typeof args.nameContains === "string" && args.nameContains) ? args.nameContains.toLowerCase() : null;
+
+    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" });
+      }
+    }
+
+    // Collect every matching clip's standard-DOM addressing BEFORE any QE
+    // mutation — mutating one clip never shifts another's trackIndex/
+    // clipIndex, but we still want a stable, fully-enumerated list up front.
+    var matches = [];
+    function collectFrom(trackCollection, trackTypeName) {
+      var numTracks = trackCollection.numTracks;
+      for (var t = 0; t < numTracks; t++) {
+        if (args.trackIndex !== undefined && args.trackIndex !== null && t !== args.trackIndex) {
+          continue;
+        }
+        var track = trackCollection[t];
+        var numClips = track.clips.numItems;
+        for (var c = 0; c < numClips; c++) {
+          var clip = track.clips[c];
+          var name = null;
+          try { name = clip.name; } catch (e) { name = null; }
+          if (nameContains && (!name || name.toLowerCase().indexOf(nameContains) === -1)) {
+            continue;
+          }
+          matches.push({ trackType: trackTypeName, trackIndex: t, clipIndex: c, clipName: name, clip: clip });
+        }
+      }
+    }
+    if (trackTypeFilter === "video" || trackTypeFilter === "both") {
+      collectFrom(seq.videoTracks, "video");
+    }
+    if (trackTypeFilter === "audio" || trackTypeFilter === "both") {
+      collectFrom(seq.audioTracks, "audio");
+    }
+
+    var totalMatched = matches.length;
+    var cappedAtLimit = totalMatched > 100;
+    if (cappedAtLimit) {
+      matches = matches.slice(0, 100);
+    }
+
+    try {
+      ensureQEEnabled();
+      activateSequenceForQE(seq);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.enableQE()/sequence activation failed: " + e.toString() });
+    }
+    if (typeof qe === "undefined" || !qe.project) {
+      return JSON.stringify({ ok: false, error: "QE DOM not available after enableQE()" });
+    }
+
+    var qeSeq;
+    try {
+      qeSeq = qe.project.getActiveSequence();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "qe.project.getActiveSequence() failed: " + e.toString() });
+    }
+
+    var results = [];
+    var appliedCount = 0;
+
+    for (var m = 0; m < matches.length; m++) {
+      var match = matches[m];
+      var previousCount = 0;
+      try { previousCount = match.clip.components.numItems; } catch (e) { previousCount = 0; }
+
+      var qeResolved = resolveQeClip(qeSeq, match.trackType, match.trackIndex, match.clipIndex);
+      if (qeResolved.error) {
+        results.push({ trackType: match.trackType, trackIndex: match.trackIndex, clipIndex: match.clipIndex, clipName: match.clipName, applied: false, error: qeResolved.error });
+        continue;
+      }
+
+      var fx = match.trackType === "video" ? findQeVideoEffectByName(args.effectName) : findQeAudioEffectByName(args.effectName);
+      if (!fx) {
+        results.push({ trackType: match.trackType, trackIndex: match.trackIndex, clipIndex: match.clipIndex, clipName: match.clipName, applied: false, error: "effect not found in this track type's QE catalog: \"" + args.effectName + "\"" });
+        continue;
+      }
+
+      try {
+        if (match.trackType === "video") {
+          qeResolved.qeClip.addVideoEffect(fx);
+        } else {
+          qeResolved.qeClip.addAudioEffect(fx);
+        }
+      } catch (e2) {
+        results.push({ trackType: match.trackType, trackIndex: match.trackIndex, clipIndex: match.clipIndex, clipName: match.clipName, applied: false, error: "addVideoEffect/addAudioEffect failed: " + e2.toString() });
+        continue;
+      }
+
+      var newCount = 0;
+      try { newCount = match.clip.components.numItems; } catch (e3) { newCount = 0; }
+      var verified = newCount === previousCount + 1;
+      if (verified) {
+        appliedCount++;
+      }
+
+      results.push({
+        trackType: match.trackType,
+        trackIndex: match.trackIndex,
+        clipIndex: match.clipIndex,
+        clipName: match.clipName,
+        applied: true,
+        verified: verified,
+        previousComponentCount: previousCount,
+        newComponentCount: newCount
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        effectName: args.effectName,
+        trackType: trackTypeFilter,
+        nameContains: args.nameContains || null,
+        totalMatched: totalMatched,
+        cappedAtLimit: cappedAtLimit,
+        appliedCount: appliedCount,
+        results: results
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/batch-rename-clips.jsx

@@ -0,0 +1,170 @@
+// Command: batch-rename-clips → ppb_batchRenameClips
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, qeFindNthNonEmptyClip, ...) are
+// already defined there.
+//
+// Ported from leancoderkavy's premiere-pro-mcp `batch_rename_clips` tool
+// (track-targeting.ts), which renames via QE `qeClip.setName()` only (no
+// standard-DOM fallback, unlike the single-clip rename-clip command) —
+// matched here for fidelity to the reference's actual renaming path.
+// `newNameTemplate` supports "{n}" (sequential counter, starting at
+// `startNumber`, default 1) and "{name}" (the clip's existing name),
+// applied via simple split/join (no regex). `nameContains` optionally
+// filters which clips on the track are renamed (case-insensitive substring
+// match against the clip's CURRENT name, checked before the counter
+// advances so skipped clips don't consume a number). Capped at 200 renames
+// per call to bound QE call volume. Every clip's rename is verified
+// individually via a clip.name read-back — never trusted from setName()'s
+// own return value.
+var BATCH_RENAME_CLIPS_MAX = 200;
+
+function ppb_batchRenameClips(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.newNameTemplate !== "string" || args.newNameTemplate.length === 0) {
+      return JSON.stringify({ ok: false, error: "newNameTemplate must be a non-empty string" });
+    }
+    var startNumber = 1;
+    if (typeof args.startNumber === "number" && !isNaN(args.startNumber)) {
+      startNumber = args.startNumber;
+    }
+    var nameContains = null;
+    if (typeof args.nameContains === "string" && args.nameContains.length > 0) {
+      nameContains = args.nameContains.toLowerCase();
+    }
+
+    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;
+
+    try {
+      ensureQEEnabled();
+      activateSequenceForQE(seq);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.enableQE()/sequence activation failed: " + e.toString() });
+    }
+    if (typeof qe === "undefined" || !qe.project) {
+      return JSON.stringify({ ok: false, error: "QE DOM not available after enableQE()" });
+    }
+
+    var qeSeq;
+    try {
+      qeSeq = qe.project.getActiveSequence();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "qe.project.getActiveSequence() failed: " + e.toString() });
+    }
+    var qeTrack;
+    try {
+      qeTrack = args.trackType === "video" ? qeSeq.getVideoTrackAt(args.trackIndex) : qeSeq.getAudioTrackAt(args.trackIndex);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "QE track lookup failed: " + e.toString() });
+    }
+    if (!qeTrack) {
+      return JSON.stringify({ ok: false, error: "QE track not found at index " + args.trackIndex });
+    }
+
+    var results = [];
+    var renamed = 0;
+    var skippedByFilter = 0;
+    var cappedAtLimit = false;
+    var num = startNumber;
+
+    for (var c = 0; c < numClips; c++) {
+      if (renamed >= BATCH_RENAME_CLIPS_MAX) {
+        cappedAtLimit = true;
+        break;
+      }
+
+      var clip = track.clips[c];
+      var oldName = null;
+      try { oldName = clip.name; } catch (e) { oldName = null; }
+
+      if (nameContains !== null) {
+        var haystack = oldName === null ? "" : String(oldName).toLowerCase();
+        if (haystack.indexOf(nameContains) === -1) {
+          skippedByFilter++;
+          continue;
+        }
+      }
+
+      var newName = args.newNameTemplate.split("{n}").join(String(num)).split("{name}").join(oldName === null ? "" : oldName);
+
+      var entry = { clipIndex: c, previousValue: oldName, requestedValue: newName, newValue: null, verified: false };
+
+      try {
+        var qeClip = qeFindNthNonEmptyClip(qeTrack, c);
+        if (!qeClip) {
+          entry.error = "could not locate corresponding QE clip";
+        } else {
+          qeClip.setName(newName);
+        }
+      } catch (e) {
+        entry.error = e.toString();
+      }
+
+      try { entry.newValue = clip.name; } catch (e) { entry.newValue = null; }
+      entry.verified = entry.newValue === newName;
+      if (entry.verified) {
+        renamed++;
+      }
+
+      num++;
+      results.push(entry);
+    }
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      newNameTemplate: args.newNameTemplate,
+      nameContains: args.nameContains || null,
+      totalClipsOnTrack: numClips,
+      skippedByFilter: skippedByFilter,
+      renamed: renamed,
+      cappedAtLimit: cappedAtLimit,
+      results: results
+    };
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}