premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/razor-all-tracks.jsx

@@ -0,0 +1,171 @@
+
+// seconds -> "HH:MM:SS:FF" — the razor argument form PROVEN working on
+// this build (remove-track-intervals live-validated it); the ticksString
+// form silently no-ops (live-tested 2026-07-17).
+function ppbRazorAll_secondsToQeTimecode(seconds, fps) {
+  var totalFrames = Math.round(seconds * fps);
+  var ff = totalFrames % Math.round(fps);
+  var totalSeconds = Math.floor(totalFrames / Math.round(fps));
+  var ss = totalSeconds % 60;
+  var totalMinutes = Math.floor(totalSeconds / 60);
+  var mm = totalMinutes % 60;
+  var hh = Math.floor(totalMinutes / 60);
+  function pad2(n) { return (n < 10 ? "0" : "") + n; }
+  return pad2(hh) + ":" + pad2(mm) + ":" + pad2(ss) + ":" + pad2(ff);
+}
+// Command: razor-all-tracks → ppb_razorAllTracks
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (ensureQEEnabled,
+// findSequenceByName, TICKS_PER_SECOND, activateSequenceForQE, ...) are
+// already defined there.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's track-targeting.ts
+// razor_all_tracks. Razors (splits) every video+audio track at a given
+// time (defaults to the sequence's own playhead if `seconds` is omitted)
+// via QE `track.razor(ticksString)` — same razor mechanism as
+// remove-track-intervals, but applied to every track instead of one.
+// Destructive-ish: a razor cut cannot be undone (undo is non-functional on
+// this build per README.md), and callers should not run this against real
+// footage without first duplicating the sequence.
+//
+// Verification: per-track clip-item-COUNT before/after (via the QE
+// track's numItems) rather than trusting razor()'s own return value —
+// same "never trust the call's return value" rule as every other QE
+// command in this panel.
+function ppb_razorAllTracks(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" });
+    }
+
+    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" });
+      }
+    }
+
+    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 = qe.project.getActiveSequence();
+    if (!qeSeq) {
+      return JSON.stringify({ ok: false, error: "qe.project.getActiveSequence() returned nothing after activating the sequence" });
+    }
+
+    var atSeconds;
+    if (typeof args.seconds === "number" && !isNaN(args.seconds)) {
+      atSeconds = args.seconds;
+    } else {
+      try {
+        atSeconds = seq.getPlayerPosition().seconds;
+      } catch (e) {
+        return JSON.stringify({ ok: false, error: "seconds was omitted and the playhead position could not be read: " + e.toString() });
+      }
+    }
+    var ticksString = String(Math.round(atSeconds * TICKS_PER_SECOND));
+    var fps = getSequenceFps(seq);
+    var qeTimecode = ppbRazorAll_secondsToQeTimecode(args.seconds, fps);
+
+    var perTrack = [];
+    var totalRazored = 0;
+
+    var numVideoTracks = 0;
+    try { numVideoTracks = qeSeq.numVideoTracks; } catch (e) { numVideoTracks = 0; }
+    for (var v = 0; v < numVideoTracks; v++) {
+      var vTrack = null;
+      try { vTrack = qeSeq.getVideoTrackAt(v); } catch (e) { vTrack = null; }
+      if (!vTrack) {
+        perTrack.push({ trackType: "video", trackIndex: v, error: "QE track lookup failed" });
+        continue;
+      }
+      var vBefore = null;
+      try { vBefore = vTrack.numItems; } catch (e) { vBefore = null; }
+      var vRazorError = null;
+      try {
+        vTrack.razor(qeTimecode);
+      } catch (e) {
+        vRazorError = e.toString();
+      }
+      var vAfter = null;
+      try { vAfter = vTrack.numItems; } catch (e) { vAfter = null; }
+      var vChanged = vBefore !== null && vAfter !== null && vAfter > vBefore;
+      if (vChanged) {
+        totalRazored++;
+      }
+      perTrack.push({
+        trackType: "video",
+        trackIndex: v,
+        itemCountBefore: vBefore,
+        itemCountAfter: vAfter,
+        razored: vChanged,
+        error: vRazorError
+      });
+    }
+
+    var numAudioTracks = 0;
+    try { numAudioTracks = qeSeq.numAudioTracks; } catch (e) { numAudioTracks = 0; }
+    for (var a = 0; a < numAudioTracks; a++) {
+      var aTrack = null;
+      try { aTrack = qeSeq.getAudioTrackAt(a); } catch (e) { aTrack = null; }
+      if (!aTrack) {
+        perTrack.push({ trackType: "audio", trackIndex: a, error: "QE track lookup failed" });
+        continue;
+      }
+      var aBefore = null;
+      try { aBefore = aTrack.numItems; } catch (e) { aBefore = null; }
+      var aRazorError = null;
+      try {
+        aTrack.razor(qeTimecode);
+      } catch (e) {
+        aRazorError = e.toString();
+      }
+      var aAfter = null;
+      try { aAfter = aTrack.numItems; } catch (e) { aAfter = null; }
+      var aChanged = aBefore !== null && aAfter !== null && aAfter > aBefore;
+      if (aChanged) {
+        totalRazored++;
+      }
+      perTrack.push({
+        trackType: "audio",
+        trackIndex: a,
+        itemCountBefore: aBefore,
+        itemCountAfter: aAfter,
+        razored: aChanged,
+        error: aRazorError
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        atSeconds: atSeconds,
+        tracksAttempted: perTrack.length,
+        tracksRazored: totalRazored,
+        tracks: perTrack
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/redo.jsx

@@ -0,0 +1,69 @@
+// Command: redo → ppb_redo
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (ensureQEEnabled, ...)
+// are already defined there.
+//
+// REWRITTEN 2026-07-17 after the probe session (see BUILD_FINDINGS.md
+// corrections): qe.project.redo() WORKS on this build — live-verified
+// re-applying an undone setSpeed, with qe.project.undoStackIndex()
+// (an int-returning function) incrementing on a real redo. That index
+// is the verification primitive; app.project.redo() does not exist here.
+
+function ppb_redo(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    try {
+      ensureQEEnabled();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.enableQE() failed: " + e.toString() });
+    }
+    if (typeof qe === "undefined" || !qe.project || typeof qe.project.redo !== "function") {
+      return JSON.stringify({ ok: false, error: "qe.project.redo is not available on this Premiere build" });
+    }
+
+    function readStackIndex() {
+      try {
+        if (typeof qe.project.undoStackIndex === "function") {
+          return qe.project.undoStackIndex();
+        }
+      } catch (e2) {
+        // fall through
+      }
+      return null;
+    }
+
+    var indexBefore = readStackIndex();
+    try {
+      qe.project.redo();
+    } catch (e3) {
+      return JSON.stringify({ ok: false, error: "qe.project.redo() threw: " + e3.toString() });
+    }
+    var indexAfter = readStackIndex();
+
+    var verified = null;
+    if (indexBefore !== null && indexAfter !== null) {
+      verified = indexAfter > indexBefore;
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        redone: verified !== false,
+        verified: verified,
+        method: "qe.project.redo",
+        undoStackIndexBefore: indexBefore,
+        undoStackIndexAfter: indexAfter,
+        note: verified === null
+          ? "undoStackIndex() unavailable — this only confirms the call did not throw"
+          : (verified
+            ? "verified via qe.project.undoStackIndex() incrementing"
+            : "the stack index did not move — there was nothing to redo")
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/refresh-media.jsx

@@ -0,0 +1,101 @@
+// Command: refresh-media → ppb_refreshMedia
+// 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 refresh_media tool. Item
+// resolution by nodeId/name uses children-presence recursion (NOT an
+// isBin() gate), per get-project-item-info.jsx's live-debugged finding.
+// item.refreshMedia() has no confirmed getter to detect a real content
+// change, so success here only confirms the call didn't throw — the same
+// honesty pattern as select-project-item's "called: true" result.
+
+function ppbRefreshMedia_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 = ppbRefreshMedia_findByNodeId(item.children[i], nodeId, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbRefreshMedia_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 = ppbRefreshMedia_findByName(item.children[i], name, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppb_refreshMedia(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
+      ? ppbRefreshMedia_findByNodeId(app.project.rootItem, args.nodeId, 0)
+      : ppbRefreshMedia_findByName(app.project.rootItem, args.name, 0);
+    if (!item) {
+      return JSON.stringify({ ok: false, error: "no project item found matching the given nodeId/name" });
+    }
+
+    try {
+      item.refreshMedia();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "refreshMedia() failed: " + e.toString() });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        nodeId: item.nodeId,
+        name: item.name,
+        called: true,
+        note: "refreshMedia() has no confirmed getter to detect a content change — this only confirms the call didn't throw"
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/relink-media.jsx

@@ -0,0 +1,132 @@
+// Command: relink-media → ppb_relinkMedia
+// 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 relink_media tool. Item
+// resolution by nodeId/name uses children-presence recursion (NOT an
+// isBin() gate), per get-project-item-info.jsx's live-debugged finding
+// that the ROOT item's type is ROOT, not BIN. Checks canChangeMediaPath()
+// first, then calls item.changeMediaPath(newPath, true) per
+// PREMIERE_API_NOTES.md, verified via a getMediaPath() read-back against
+// the requested path.
+
+function ppbRelinkMedia_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 = ppbRelinkMedia_findByNodeId(item.children[i], nodeId, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbRelinkMedia_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 = ppbRelinkMedia_findByName(item.children[i], name, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbRelinkMedia_resolveItem(args) {
+  if (args.nodeId) {
+    return ppbRelinkMedia_findByNodeId(app.project.rootItem, args.nodeId, 0);
+  }
+  return ppbRelinkMedia_findByName(app.project.rootItem, args.name, 0);
+}
+
+function ppb_relinkMedia(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 (!args.newPath || typeof args.newPath !== "string") {
+      return JSON.stringify({ ok: false, error: "newPath is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = ppbRelinkMedia_resolveItem({ 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 canChange = null;
+    try { canChange = item.canChangeMediaPath(); } catch (e) { canChange = null; }
+    if (canChange === false) {
+      return JSON.stringify({
+        ok: false,
+        error: "canChangeMediaPath() returned false — this item's media path cannot be changed",
+        nodeId: item.nodeId,
+        name: item.name
+      });
+    }
+
+    var previousValue = null;
+    try { previousValue = item.getMediaPath(); } catch (e) { previousValue = null; }
+
+    var callResult = null;
+    try {
+      callResult = item.changeMediaPath(args.newPath, true);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "changeMediaPath() failed: " + e.toString() });
+    }
+
+    var newValue = null;
+    try { newValue = item.getMediaPath(); } catch (e) { newValue = null; }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        nodeId: item.nodeId,
+        name: item.name,
+        canChangeMediaPath: canChange,
+        callResult: callResult,
+        previousValue: previousValue,
+        requestedValue: args.newPath,
+        newValue: newValue,
+        verified: newValue === args.newPath
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/remove-all-effects.jsx

@@ -0,0 +1,114 @@
+// Command: remove-all-effects → ppb_removeAllEffects
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, resolveTimelineClip,
+// resolveQeClip, serializeClipComponents, ...) are already defined there.
+//
+// QE-only: qeClip.removeEffects() — per PREMIERE_API_NOTES.md, this strips
+// ALL applied effects from a clip in one call, but the built-in components
+// (Motion/Opacity/Volume/Panner) survive per QE semantics and are NOT
+// removed. Verified by reading standard-DOM clip.components before/after —
+// the count should drop to (at most) the built-in baseline, never to zero
+// on a normal clip.
+function ppb_removeAllEffects(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 (!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 resolvedClip = resolveTimelineClip(seq, args.trackType, args.trackIndex, args.clipIndex);
+    if (resolvedClip.error) {
+      return JSON.stringify({ ok: false, error: resolvedClip.error });
+    }
+    var clip = resolvedClip.clip;
+    var clipName = null;
+    try { clipName = clip.name; } catch (e) { clipName = null; }
+
+    var previousComponents = serializeClipComponents(clip);
+    var previousCount = previousComponents.length;
+
+    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 qeResolved = resolveQeClip(qeSeq, args.trackType, args.trackIndex, args.clipIndex);
+    if (qeResolved.error) {
+      return JSON.stringify({ ok: false, error: qeResolved.error });
+    }
+
+    try {
+      qeResolved.qeClip.removeEffects();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "qeClip.removeEffects() failed: " + e.toString() });
+    }
+
+    var newComponents = serializeClipComponents(clip);
+    var newCount = newComponents.length;
+    var removedCount = previousCount - newCount;
+    var verified = removedCount > 0;
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      clipIndex: args.clipIndex,
+      clipName: clipName,
+      verified: verified,
+      removedCount: removedCount,
+      previousComponentCount: previousCount,
+      newComponentCount: newCount,
+      previousComponents: previousComponents,
+      remainingComponents: newComponents
+    };
+    if (!verified) {
+      result.note = "qeClip.removeEffects() did not throw, but components.numItems did not drop — either the clip had no removable (non-built-in) effects applied, or removeEffects() is non-functional on this build.";
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}