premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/remove-effect-by-name.jsx

@@ -0,0 +1,143 @@
+// Command: remove-effect-by-name → ppb_removeEffectByName
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// resolveTimelineClip, serializeClipComponents,
+// isProtectedBuiltinComponent, ...) are already defined there.
+//
+// Removes EVERY component on a clip whose displayName OR matchName exactly
+// matches effectName (leancoderkavy's clipboard.ts remove_effect_by_name
+// removes all matches too, not just the first). Iterates components
+// backwards so removing one doesn't shift the indices of ones still to be
+// checked. Motion/Opacity are still refused even if effectName happens to
+// match them — see remove-effect's notes on why. Same disputed-API
+// verification as remove-effect: judged by clip.components.numItems
+// dropping, not by remove()'s return value.
+function ppb_removeEffectByName(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.effectName !== "string" || !args.effectName) {
+      return JSON.stringify({ ok: false, error: "effectName must be a non-empty string" });
+    }
+
+    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;
+
+    var matchingIndices = [];
+    for (var i = 0; i < previousCount; i++) {
+      var info = previousComponents[i];
+      if (info.displayName === args.effectName || info.matchName === args.effectName) {
+        matchingIndices.push(i);
+      }
+    }
+
+    if (matchingIndices.length === 0) {
+      return JSON.stringify({ ok: false, error: "no component found on this clip matching displayName/matchName \"" + args.effectName + "\"" });
+    }
+
+    var attempts = [];
+    var removedCount = 0;
+    var skippedProtected = 0;
+    // Iterate backwards so an earlier removal never shifts a later index
+    // still queued for removal.
+    for (var m = matchingIndices.length - 1; m >= 0; m--) {
+      var idx = matchingIndices[m];
+      var comp = clip.components[idx];
+      if (isProtectedBuiltinComponent(comp)) {
+        skippedProtected++;
+        attempts.push({ componentIndex: idx, success: false, skipped: true, reason: "protected built-in component (Motion/Opacity)" });
+        continue;
+      }
+      try {
+        comp.remove();
+        attempts.push({ componentIndex: idx, success: true });
+        removedCount++;
+      } catch (e) {
+        attempts.push({ componentIndex: idx, success: false, error: e.toString() });
+      }
+    }
+
+    var newComponents = serializeClipComponents(clip);
+    var newCount = newComponents.length;
+    var actualDropped = previousCount - newCount;
+    var verified = actualDropped === removedCount;
+
+    if (matchingIndices.length === skippedProtected) {
+      return JSON.stringify({
+        ok: false,
+        error: "every component matching \"" + args.effectName + "\" is a protected built-in (Motion/Opacity) — refusing to remove"
+      });
+    }
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      clipIndex: args.clipIndex,
+      clipName: clipName,
+      effectName: args.effectName,
+      matchedCount: matchingIndices.length,
+      removeCallsSucceeded: removedCount,
+      skippedProtected: skippedProtected,
+      verified: verified,
+      previousComponentCount: previousCount,
+      newComponentCount: newCount,
+      previousComponents: previousComponents,
+      newComponents: newComponents,
+      attempts: attempts
+    };
+    if (actualDropped === 0) {
+      // Live-confirmed 2026-07-17: component.remove() silently no-ops on
+      // this Premiere 2026 build — treat a zero drop as a hard failure,
+      // never a success.
+      result.note = "single-effect removal is NON-FUNCTIONAL on this Premiere build — component.remove() no-throws but removes nothing (live-confirmed). Try remove-all-effects (QE removeEffects strips SOME effects), or remove manually in Effect Controls.";
+      return JSON.stringify({ ok: false, error: "no components were actually removed (component.remove() is a silent no-op on this build)", result: result });
+    }
+    if (!verified) {
+      result.note = "components.numItems dropped, but not by the expected amount — partial removal.";
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/remove-effect.jsx

@@ -0,0 +1,122 @@
+// Command: remove-effect → ppb_removeEffect
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// resolveTimelineClip, serializeClipComponents,
+// isProtectedBuiltinComponent, ...) are already defined there.
+//
+// Removes one component from a clip by its index into clip.components.
+// comp.remove() is DISPUTED across the reference repos this panel ports
+// from — one claims single-effect removal works, another claims it's
+// impossible — so success here is judged ONLY by clip.components.numItems
+// actually dropping by 1 afterward, never by whether remove() itself threw.
+// Refuses outright to touch Motion/Opacity (see isProtectedBuiltinComponent)
+// since undo is non-functional on this build and removing an intrinsic
+// component has no path back. Given that, this command is the primary
+// cleanup path for apply-effect/apply-audio-effect mistakes — it must be
+// solid and honest about what actually happened.
+function ppb_removeEffect(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.componentIndex !== "number" || args.componentIndex < 0 || Math.floor(args.componentIndex) !== args.componentIndex) {
+      return JSON.stringify({ ok: false, error: "componentIndex 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;
+
+    if (args.componentIndex >= previousCount) {
+      return JSON.stringify({
+        ok: false,
+        error: "componentIndex " + args.componentIndex + " is out of range — clip has " + previousCount + " component(s)"
+      });
+    }
+
+    var targetComponent = clip.components[args.componentIndex];
+    if (isProtectedBuiltinComponent(targetComponent)) {
+      return JSON.stringify({
+        ok: false,
+        error: "refusing to remove a built-in component (Motion/Opacity) at componentIndex " + args.componentIndex + " — undo is non-functional on this build, so there is no path back"
+      });
+    }
+
+    var targetInfo = previousComponents[args.componentIndex];
+
+    var attempts = [];
+    try {
+      targetComponent.remove();
+      attempts.push({ call: "component.remove()", success: true });
+    } catch (e) {
+      attempts.push({ call: "component.remove()", success: false, error: e.toString() });
+    }
+
+    var newComponents = serializeClipComponents(clip);
+    var newCount = newComponents.length;
+    var verified = newCount === previousCount - 1;
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      clipIndex: args.clipIndex,
+      clipName: clipName,
+      componentIndex: args.componentIndex,
+      removedComponent: targetInfo,
+      verified: verified,
+      previousComponentCount: previousCount,
+      newComponentCount: newCount,
+      previousComponents: previousComponents,
+      newComponents: newComponents,
+      attempts: attempts
+    };
+    if (!verified) {
+      // Live-confirmed 2026-07-17: component.remove() silently no-ops on
+      // this Premiere 2026 build.
+      result.note = "single-effect removal is NON-FUNCTIONAL on this Premiere build — component.remove() no-throws but removes nothing (live-confirmed). Try remove-all-effects (QE removeEffects strips SOME effects), or remove manually in Effect Controls.";
+      return JSON.stringify({ ok: false, error: "the component was not actually removed (component.remove() is a silent no-op on this build)", result: result });
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/remove-from-timeline.jsx

@@ -0,0 +1,93 @@
+// Command: remove-from-timeline → ppb_removeFromTimeline
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// resolveTimelineClip, serializeTrackItem, ...) are already defined
+// there.
+//
+// DESTRUCTIVE: permanently removes a clip from the timeline via
+// clip.remove(ripple, alignToVideo=false) (PREMIERE_API_NOTES.md's
+// "Clips / TrackItems" section — ripple=true closes the gap, false lifts
+// it in place). Undo is NON-FUNCTIONAL on this build — there is no path
+// back once this succeeds. Ported from leancoderkavy's
+// premiere-pro-mcp remove_from_timeline tool, re-addressed to this
+// panel's trackType/trackIndex/clipIndex convention instead of node_id.
+//
+// MUTATION RULE: verified by a track.clips.numItems drop of exactly one,
+// never by remove()'s own (undocumented) return value.
+
+function ppb_removeFromTimeline(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" || typeof args.clipIndex !== "number") {
+      return JSON.stringify({ ok: false, error: "trackIndex and clipIndex are required" });
+    }
+    if (typeof args.ripple !== "boolean") {
+      return JSON.stringify({ ok: false, error: "ripple (boolean) 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 resolved = resolveTimelineClip(seq, args.trackType, args.trackIndex, args.clipIndex);
+    if (resolved.error) {
+      return JSON.stringify({ ok: false, error: resolved.error });
+    }
+    var clip = resolved.clip;
+    var track = args.trackType === "video" ? seq.videoTracks[args.trackIndex] : seq.audioTracks[args.trackIndex];
+
+    var before = serializeTrackItem(clip, args.trackIndex, args.clipIndex);
+    var clipCountBefore = null;
+    try { clipCountBefore = track.clips.numItems; } catch (e2) { clipCountBefore = null; }
+
+    try {
+      clip.remove(args.ripple, false);
+    } catch (e3) {
+      return JSON.stringify({ ok: false, error: "clip.remove() failed: " + e3.toString() });
+    }
+
+    var clipCountAfter = null;
+    try { clipCountAfter = track.clips.numItems; } catch (e4) { clipCountAfter = null; }
+
+    var verified = clipCountBefore !== null && clipCountAfter !== null && clipCountAfter === clipCountBefore - 1;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        ripple: args.ripple,
+        removedClip: before,
+        clipCountBefore: clipCountBefore,
+        clipCountAfter: clipCountAfter,
+        verified: verified
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/remove-keyframe-range.jsx

@@ -0,0 +1,173 @@
+// Command: remove-keyframe-range → ppb_removeKeyframeRange
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// findClipComponent, findComponentProperty, timeValueToSeconds,
+// secondsToTicksString, secondsToTimeObject, ...) are already defined
+// there.
+//
+// Standard-DOM mutation. Ported from leancoderkavy's premiere-pro-mcp
+// `remove_keyframe_range` tool (keyframes.ts), addressed here by
+// trackType/trackIndex/clipIndex + componentName/propertyName.
+// startSeconds/endSeconds are clip-relative, offset by clip.start to
+// sequence time. removeKeyRange(t1, t2) takes two time arguments whose
+// form is disputed per PREMIERE_API_NOTES.md — tries ticksString, then
+// Time objects, then raw seconds numbers for BOTH arguments together (not
+// mixed forms), recording every attempt. Verified via a getKeys() COUNT
+// drop — this is the cleanup path for add-keyframe/add-audio-keyframes
+// mistakes, since undo is non-functional on this build.
+function ppb_removeKeyframeRange(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.startSeconds !== "number" || typeof args.endSeconds !== "number") {
+      return JSON.stringify({ ok: false, error: "startSeconds and endSeconds must both be numbers (clip-relative)" });
+    }
+
+    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 sequenceStartSeconds = clipStartSeconds + args.startSeconds;
+    var sequenceEndSeconds = clipStartSeconds + args.endSeconds;
+
+    var keyCountBefore = 0;
+    try {
+      var keysBefore = prop.getKeys();
+      keyCountBefore = keysBefore ? keysBefore.length : 0;
+    } catch (e) {
+      keyCountBefore = null;
+    }
+
+    // Two-argument sibling of tryTimeForms — both t1/t2 use the SAME form
+    // per attempt (not mixed), since removeKeyRange presumably expects
+    // matching argument types.
+    var removeAttempts = [];
+    var removed = false;
+    var forms = [
+      { label: "ticksString", t1: secondsToTicksString(sequenceStartSeconds), t2: secondsToTicksString(sequenceEndSeconds) },
+      { label: "TimeObject", t1: secondsToTimeObject(sequenceStartSeconds), t2: secondsToTimeObject(sequenceEndSeconds) },
+      { label: "seconds", t1: sequenceStartSeconds, t2: sequenceEndSeconds }
+    ];
+    for (var f = 0; f < forms.length; f++) {
+      try {
+        prop.removeKeyRange(forms[f].t1, forms[f].t2);
+        removeAttempts.push({ form: forms[f].label, success: true });
+        removed = true;
+        break;
+      } catch (e2) {
+        removeAttempts.push({ form: forms[f].label, success: false, error: e2.toString() });
+      }
+    }
+
+    var keyCountAfter = 0;
+    try {
+      var keysAfter = prop.getKeys();
+      keyCountAfter = keysAfter ? keysAfter.length : 0;
+    } catch (e3) {
+      keyCountAfter = null;
+    }
+
+    var keysRemoved = (keyCountBefore !== null && keyCountAfter !== null) ? (keyCountBefore - keyCountAfter) : null;
+    var verified = (keysRemoved !== null && keysRemoved > 0);
+
+    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,
+        startSeconds: args.startSeconds,
+        endSeconds: args.endSeconds,
+        sequenceStartSeconds: sequenceStartSeconds,
+        sequenceEndSeconds: sequenceEndSeconds,
+        removeAttempts: removeAttempts,
+        keyCountBefore: keyCountBefore,
+        keyCountAfter: keyCountAfter,
+        keysRemoved: keysRemoved,
+        verified: verified
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}