premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/set-active-project.jsx

@@ -0,0 +1,184 @@
+// Command: set-active-project → ppb_setActiveProject
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// ensureQEEnabled, findSequenceByName, ...) are already defined there.
+//
+// Switches which currently-OPEN project (app.projects) is the active one
+// (app.project). DESIGNED BUT NOT YET LIVE-VERIFIED: no reference repo we
+// studied (see PREMIERE_API_NOTES.md) has a multi-open-project activation
+// tool to copy — none of hetpatel/leancoderkavy/ayushozha's code touches
+// app.projects at all, only the single app.project. The activation
+// mechanism on this Premiere build is therefore genuinely uncertain: three
+// candidate methods are tried in order, and success is verified AFTER each
+// one by checking that app.project.path actually changed to the target's
+// path — never by trusting a method's return value (same distrust pattern
+// as export-frame.jsx's exportFramePNG guesses).
+//
+// Mutation caveats:
+//   - app.openDocument() is documented (PREMIERE_API_NOTES.md) as an
+//     "open project" call; its behavior when the target is ALREADY open is
+//     unconfirmed — it may simply foreground the existing project, or it
+//     may pop a dialog, or (worst case) re-open a second instance. This is
+//     a fallback guess, not a verified-safe operation.
+//   - The direct-assignment attempt (`app.project = target`) is a bare
+//     guess with no supporting reference anywhere in the three MCP repos
+//     studied — kept last, after the two better-attested attempts.
+//   - Live-test this against a real multi-project-open Premiere session
+//     before relying on it in an unattended workflow.
+
+function ppb_setActiveProject(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var hasName = !!(args.name && typeof args.name === "string");
+    var hasPath = !!(args.path && typeof args.path === "string");
+    if (!hasName && !hasPath) {
+      return JSON.stringify({ ok: false, error: "at least one of name or path is required" });
+    }
+
+    if (!app.projects || app.projects.numProjects === 0) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var byPath = null;
+    var byName = null;
+    var availableProjects = [];
+
+    for (var i = 0; i < app.projects.numProjects; i++) {
+      var p = app.projects[i];
+      var pName = null;
+      var pPath = null;
+      try { pName = p.name; } catch (e) { pName = null; }
+      try { pPath = p.path; } catch (e) { pPath = null; }
+
+      if (pName !== null) {
+        availableProjects.push(pName);
+      }
+      if (hasPath && pPath !== null && pPath === args.path) {
+        byPath = p;
+      }
+      if (hasName && pName !== null && pName === args.name) {
+        byName = p;
+      }
+    }
+
+    var target = null;
+    if (hasName && hasPath) {
+      if (!byPath || !byName || byPath !== byName) {
+        return JSON.stringify({
+          ok: false,
+          error: "name and path did not resolve to the same open project",
+          availableProjects: availableProjects
+        });
+      }
+      target = byPath;
+    } else if (hasPath) {
+      target = byPath;
+    } else {
+      target = byName;
+    }
+
+    if (!target) {
+      var missingDesc = "";
+      if (hasName) { missingDesc += " name \"" + args.name + "\""; }
+      if (hasPath) { missingDesc += " path \"" + args.path + "\""; }
+      return JSON.stringify({
+        ok: false,
+        error: "no open project matched" + missingDesc,
+        availableProjects: availableProjects
+      });
+    }
+
+    var targetName = null;
+    var targetPath = null;
+    try { targetName = target.name; } catch (e) { targetName = null; }
+    try { targetPath = target.path; } catch (e) { targetPath = null; }
+
+    var currentPath = null;
+    try { currentPath = app.project ? app.project.path : null; } catch (e) { currentPath = null; }
+
+    if (targetPath !== null && currentPath !== null && targetPath === currentPath) {
+      return JSON.stringify({
+        ok: true,
+        result: { activated: { name: targetName, path: targetPath }, alreadyActive: true }
+      });
+    }
+
+    function isNowActive() {
+      var curPath = null;
+      try { curPath = app.project ? app.project.path : null; } catch (e) { curPath = null; }
+      return targetPath !== null && curPath === targetPath;
+    }
+
+    var attempts = [];
+
+    // --- Attempt 1: targetProject.activate(), if this build exposes it.
+    if (typeof target.activate === "function") {
+      try {
+        target.activate();
+        var success1 = isNowActive();
+        attempts.push({ method: "activate", success: success1 });
+        if (success1) {
+          return JSON.stringify({
+            ok: true,
+            result: { activated: { name: targetName, path: targetPath }, attempts: attempts }
+          });
+        }
+      } catch (e) {
+        attempts.push({ method: "activate", success: false, error: e.toString() });
+      }
+    } else {
+      attempts.push({ method: "activate", success: false, error: "target.activate is not a function on this Premiere build" });
+    }
+
+    // --- Attempt 2: app.openDocument(targetPath) — documented to open/
+    // foreground a project; on an already-open project its behavior is an
+    // unconfirmed fallback guess (see header comment).
+    if (targetPath !== null) {
+      try {
+        app.openDocument(targetPath);
+        var success2 = isNowActive();
+        attempts.push({ method: "openDocument", success: success2 });
+        if (success2) {
+          return JSON.stringify({
+            ok: true,
+            result: { activated: { name: targetName, path: targetPath }, attempts: attempts }
+          });
+        }
+      } catch (e) {
+        attempts.push({ method: "openDocument", success: false, error: e.toString() });
+      }
+    } else {
+      attempts.push({ method: "openDocument", success: false, error: "target project has no readable path" });
+    }
+
+    // --- Attempt 3: direct property assignment — a bare guess with no
+    // supporting reference in any studied repo, tried last.
+    try {
+      app.project = target;
+      var success3 = isNowActive();
+      attempts.push({ method: "directAssign", success: success3 });
+      if (success3) {
+        return JSON.stringify({
+          ok: true,
+          result: { activated: { name: targetName, path: targetPath }, attempts: attempts }
+        });
+      }
+    } catch (e) {
+      attempts.push({ method: "directAssign", success: false, error: e.toString() });
+    }
+
+    return JSON.stringify({
+      ok: false,
+      error: "could not activate project \"" + (targetName || targetPath) + "\" with any known method",
+      attempts: attempts
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/set-active-sequence.jsx

@@ -0,0 +1,87 @@
+// Command: set-active-sequence → ppb_setActiveSequence
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's project.ts
+// set_active_sequence. Per PREMIERE_API_NOTES.md's Sequences table,
+// activation has two documented forms — assignment
+// (app.project.activeSequence = seq) and app.project.openSequence(seq.
+// sequenceID) — both are tried in order (assignment first, matching the
+// reference tool), each verified independently by re-reading
+// app.project.activeSequence.name afterward rather than trusting either
+// call's return value.
+
+function ppb_setActiveSequence(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.sequenceName || typeof args.sequenceName !== "string") {
+      return JSON.stringify({ ok: false, error: "sequenceName is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = findSequenceByName(args.sequenceName);
+    if (!seq) {
+      return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" found in the project" });
+    }
+
+    function isNowActive() {
+      try {
+        return app.project.activeSequence && app.project.activeSequence.name === args.sequenceName;
+      } catch (e) {
+        return false;
+      }
+    }
+
+    var attempts = [];
+
+    try {
+      app.project.activeSequence = seq;
+      var success1 = isNowActive();
+      attempts.push({ method: "activeSequenceAssign", success: success1 });
+      if (success1) {
+        return JSON.stringify({
+          ok: true,
+          result: { name: seq.name, sequenceID: seq.sequenceID, attempts: attempts }
+        });
+      }
+    } catch (e) {
+      attempts.push({ method: "activeSequenceAssign", success: false, error: e.toString() });
+    }
+
+    if (typeof app.project.openSequence === "function") {
+      try {
+        app.project.openSequence(seq.sequenceID);
+        var success2 = isNowActive();
+        attempts.push({ method: "openSequence", success: success2 });
+        if (success2) {
+          return JSON.stringify({
+            ok: true,
+            result: { name: seq.name, sequenceID: seq.sequenceID, attempts: attempts }
+          });
+        }
+      } catch (e) {
+        attempts.push({ method: "openSequence", success: false, error: e.toString() });
+      }
+    } else {
+      attempts.push({ method: "openSequence", success: false, error: "app.project.openSequence is not a function on this Premiere build" });
+    }
+
+    return JSON.stringify({
+      ok: false,
+      error: "could not make sequence \"" + args.sequenceName + "\" active with any known method",
+      attempts: attempts
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/set-all-tracks-targeted.jsx

@@ -0,0 +1,112 @@
+// Command: set-all-tracks-targeted → ppb_setAllTracksTargeted
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// Standard-DOM mutation. Ported from leancoderkavy's premiere-pro-mcp
+// `set_all_tracks_targeted` tool (track-targeting.ts): loops every track
+// (optionally filtered to one trackType) and calls setTargeted(targeted,
+// isVideoBool). Verified with a per-track isTargeted() read-back summary
+// rather than trusting the mutation calls' own (lack of) return values.
+function ppb_setAllTracksTargeted(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.targeted !== "boolean") {
+      return JSON.stringify({ ok: false, error: "targeted must be a boolean" });
+    }
+
+    var trackType = args.trackType || "both";
+    if (trackType !== "video" && trackType !== "audio" && trackType !== "both") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\", \"audio\", or \"both\"" });
+    }
+
+    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 video = [];
+    var audio = [];
+    var affected = 0;
+
+    if (trackType !== "audio") {
+      for (var v = 0; v < seq.videoTracks.numTracks; v++) {
+        var vTrack = seq.videoTracks[v];
+        var vEntry = { index: v, name: null, requested: args.targeted, isTargeted: null, error: null };
+        try { vEntry.name = vTrack.name; } catch (e) { vEntry.name = null; }
+        try {
+          vTrack.setTargeted(args.targeted, true);
+          affected++;
+        } catch (e) {
+          vEntry.error = e.toString();
+        }
+        try { vEntry.isTargeted = vTrack.isTargeted(); } catch (e) { vEntry.isTargeted = null; }
+        video.push(vEntry);
+      }
+    }
+
+    if (trackType !== "video") {
+      for (var a = 0; a < seq.audioTracks.numTracks; a++) {
+        var aTrack = seq.audioTracks[a];
+        var aEntry = { index: a, name: null, requested: args.targeted, isTargeted: null, error: null };
+        try { aEntry.name = aTrack.name; } catch (e) { aEntry.name = null; }
+        try {
+          aTrack.setTargeted(args.targeted, false);
+          affected++;
+        } catch (e) {
+          aEntry.error = e.toString();
+        }
+        try { aEntry.isTargeted = aTrack.isTargeted(); } catch (e) { aEntry.isTargeted = null; }
+        audio.push(aEntry);
+      }
+    }
+
+    var mismatches = [];
+    var i;
+    for (i = 0; i < video.length; i++) {
+      if (video[i].isTargeted !== null && video[i].isTargeted !== args.targeted) {
+        mismatches.push("video[" + video[i].index + "]");
+      }
+    }
+    for (i = 0; i < audio.length; i++) {
+      if (audio[i].isTargeted !== null && audio[i].isTargeted !== args.targeted) {
+        mismatches.push("audio[" + audio[i].index + "]");
+      }
+    }
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: trackType,
+      requestedTargeted: args.targeted,
+      tracksAffected: affected,
+      video: video,
+      audio: audio
+    };
+
+    if (mismatches.length > 0) {
+      result.warning = "the following tracks did not read back the requested targeted state: " + mismatches.join(", ");
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/set-anti-alias-quality.jsx

@@ -0,0 +1,125 @@
+// Command: set-anti-alias-quality → ppb_setAntiAliasQuality
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// findClipComponent, setComponentProperty, ...) are already defined there.
+//
+// Standard-DOM only — no QE needed. Ported from leancoderkavy's
+// premiere-pro-mcp `set_anti_alias_quality` tool (track-targeting.ts),
+// addressed here by trackType/trackIndex/clipIndex (same convention as
+// get-full-clip-info) instead of node_id.
+//
+// **API UNCERTAIN**: no property named anything like "Anti-Alias" or
+// "Anti-Alias Quality" is documented for the Motion component in
+// PREMIERE_API_NOTES.md, and the reference tool itself only probes two
+// loosely-related displayNames ("Anti-flicker Filter",
+// "Use Composition's Shutter Angle") — neither is really an anti-alias
+// control. This command probes a short list of plausible displayNames on
+// the Motion component and returns an honest "not found on this Premiere
+// build" error (naming every name tried) if none exist, rather than
+// silently mutating an unrelated property. Mutating IF a match is found —
+// undo is non-functional on this build, so previousValue in the result is
+// the caller's only restoration path.
+
+var SET_ANTI_ALIAS_QUALITY_CANDIDATE_NAMES = [
+  "Anti-flicker Filter",
+  "Anti-aliasing Quality",
+  "Anti-Alias Quality",
+  "Antialias Quality",
+  "Use Composition's Shutter Angle"
+];
+
+function ppb_setAntiAliasQuality(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.amount !== "number" || args.amount < 0 || args.amount > 1) {
+      return JSON.stringify({ ok: false, error: "amount must be a number between 0 and 1" });
+    }
+
+    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 motion = findClipComponent(clip, ["AE.ADBE Motion"], ["Motion"]);
+    if (!motion) {
+      return JSON.stringify({ ok: false, error: "Motion component not found on clip" });
+    }
+
+    // Live-discovered 2026-07-17: the boolean form throws "Illegal
+    // Parameter type" — Motion's real property here is the NUMERIC
+    // "Anti-flicker Filter" (0..1 amount).
+    var setResult = setComponentProperty(motion, SET_ANTI_ALIAS_QUALITY_CANDIDATE_NAMES, args.amount);
+    if (!setResult.found) {
+      return JSON.stringify({
+        ok: false,
+        error: "no anti-alias-quality-like property exists on the Motion component on this Premiere build (tried: " + SET_ANTI_ALIAS_QUALITY_CANDIDATE_NAMES.join(", ") + ")"
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        clipName: clipName,
+        previousValue: setResult.previousValue,
+        requestedValue: setResult.requestedValue,
+        newValue: setResult.newValue,
+        verified: setResult.verified
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/set-blend-mode.jsx

@@ -0,0 +1,111 @@
+// Command: set-blend-mode → ppb_setBlendMode
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// findClipComponent, setComponentProperty, ...) are already defined there.
+//
+// Standard-DOM only — no QE needed. Ported from leancoderkavy's
+// premiere-pro-mcp `set_blend_mode` tool (clipboard.ts), addressed here by
+// trackType/trackIndex/clipIndex (same convention as get-full-clip-info)
+// instead of node_id. Sets the Opacity component's Blend Mode property.
+//
+// **API UNCERTAIN**: per PREMIERE_API_NOTES.md, Blend Mode is an int enum
+// (1=Normal...22 or 27=Luminosity — the reference repos disagree on the
+// map size/order), and that mapping is version-dependent across Premiere
+// builds. This command takes and returns the RAW integer only — it does
+// NOT attempt a name→int mapping table of its own (unlike the reference
+// tool, which hardcodes one) since we have no way to verify it against
+// this Premiere build. Callers are responsible for picking the right int
+// for their build; previousValue/newValue in the result are the only
+// reliable calibration signal available. Mutating — undo is non-functional
+// on this build, so previousValue is the caller's only restoration path.
+
+function ppb_setBlendMode(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.blendMode !== "number" || Math.floor(args.blendMode) !== args.blendMode) {
+      return JSON.stringify({ ok: false, error: "blendMode must be an integer (Blend Mode enum value — version-dependent, see command header comment)" });
+    }
+
+    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 opacityComp = findClipComponent(clip, ["AE.ADBE Opacity"], ["Opacity"]);
+    if (!opacityComp) {
+      return JSON.stringify({ ok: false, error: "Opacity component not found on clip" });
+    }
+
+    var setResult = setComponentProperty(opacityComp, ["Blend Mode"], args.blendMode);
+    if (!setResult.found) {
+      return JSON.stringify({ ok: false, error: "Blend Mode property not found on the Opacity component" });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        clipName: clipName,
+        previousValue: setResult.previousValue,
+        requestedValue: setResult.requestedValue,
+        newValue: setResult.newValue,
+        verified: setResult.verified,
+        note: "Blend Mode enum mapping is version-dependent across Premiere builds — this raw int is not name-mapped by this command."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}