premiere-cli 0.2.0__py3-none-any.whl

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

@@ -0,0 +1,103 @@
+// Command: get-active-sequence → ppb_getActiveSequence
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// serializeTrackItem, ...) are already defined there.
+//
+// Standard-DOM read only (seq.videoTracks[i].clips[j]) — no QE DOM needed,
+// no need to activate the sequence tab.
+
+function ppb_serializeTrack(track, trackIndex) {
+  var out = {
+    index: trackIndex,
+    name: null,
+    isMuted: null,
+    isLocked: null,
+    clipCount: null,
+    clips: []
+  };
+
+  try { out.name = track.name; } catch (e) { out.name = null; }
+  try { out.isMuted = track.isMuted(); } catch (e) { out.isMuted = null; }
+  try { out.isLocked = track.isLocked(); } catch (e) { out.isLocked = null; }
+
+  try {
+    out.clipCount = track.clips.numItems;
+    for (var c = 0; c < track.clips.numItems; c++) {
+      out.clips.push(serializeTrackItem(track.clips[c], trackIndex, c));
+    }
+  } catch (e) {
+    // leave clipCount/clips as-is (null / whatever was collected so far)
+  }
+
+  return out;
+}
+
+function ppb_getActiveSequence(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = app.project.activeSequence;
+    if (!seq) {
+      return JSON.stringify({ ok: false, error: "no active sequence" });
+    }
+
+    var frameRate = null;
+    try {
+      frameRate = getSequenceFps(seq);
+    } catch (e) {
+      frameRate = null;
+    }
+
+    var durationSeconds = null;
+    try {
+      durationSeconds = (Number(seq.end) - Number(seq.zeroPoint)) / TICKS_PER_SECOND;
+    } catch (e) {
+      durationSeconds = null;
+    }
+
+    var width = null;
+    var height = null;
+    try {
+      var settings = seq.getSettings();
+      width = settings.videoFrameWidth;
+      height = settings.videoFrameHeight;
+    } catch (e) {
+      // best-effort only
+    }
+
+    var videoTracks = [];
+    try {
+      for (var v = 0; v < seq.videoTracks.numTracks; v++) {
+        videoTracks.push(ppb_serializeTrack(seq.videoTracks[v], v));
+      }
+    } catch (e) {
+      // leave videoTracks as whatever was collected so far
+    }
+
+    var audioTracks = [];
+    try {
+      for (var a = 0; a < seq.audioTracks.numTracks; a++) {
+        audioTracks.push(ppb_serializeTrack(seq.audioTracks[a], a));
+      }
+    } catch (e) {
+      // leave audioTracks as whatever was collected so far
+    }
+
+    var result = {
+      name: seq.name,
+      sequenceID: seq.sequenceID,
+      frameRate: frameRate,
+      durationSeconds: durationSeconds,
+      width: width,
+      height: height,
+      videoTracks: videoTracks,
+      audioTracks: audioTracks
+    };
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-all-project-paths.jsx

@@ -0,0 +1,72 @@
+// Command: get-all-project-paths → ppb_getAllProjectPaths
+// 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.
+//
+// Recursive walk of app.project.rootItem.children (same shape as
+// list-project-items.jsx), collecting every unique non-null mediaPath.
+// Helper names are prefixed ppbAllProjectPaths_ to avoid colliding with
+// same-purpose helpers in other lazily-loaded command files evaluated into
+// this same global context.
+
+function ppbAllProjectPaths_isBin(item) {
+  try {
+    return typeof ProjectItemType !== "undefined" && item.type === ProjectItemType.BIN;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Capped at depth 32 to defend against pathological/circular bin
+// structures rather than looping forever.
+function ppbAllProjectPaths_scan(item, depth, pathMap, order) {
+  if (depth > 32) {
+    return;
+  }
+
+  var mediaPath = null;
+  try {
+    mediaPath = item.getMediaPath();
+  } catch (e) {
+    mediaPath = null;
+  }
+
+  if (mediaPath && !pathMap[mediaPath]) {
+    var entry = { path: mediaPath, name: null, nodeId: null, offline: null };
+    try { entry.name = item.name; } catch (e) { entry.name = null; }
+    try { entry.nodeId = item.nodeId; } catch (e) { entry.nodeId = null; }
+    try { entry.offline = item.isOffline(); } catch (e) { entry.offline = null; }
+    pathMap[mediaPath] = entry;
+    order.push(mediaPath);
+  }
+
+  if (ppbAllProjectPaths_isBin(item) && item.children) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      ppbAllProjectPaths_scan(item.children[i], depth + 1, pathMap, order);
+    }
+  }
+}
+
+function ppb_getAllProjectPaths(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var pathMap = {};
+    var order = [];
+    var root = app.project.rootItem;
+    for (var i = 0; i < root.children.numItems; i++) {
+      ppbAllProjectPaths_scan(root.children[i], 1, pathMap, order);
+    }
+
+    var paths = [];
+    for (var j = 0; j < order.length; j++) {
+      paths.push(pathMap[order[j]]);
+    }
+
+    return JSON.stringify({ ok: true, result: { pathCount: paths.length, paths: paths } });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-bin-contents.jsx

@@ -0,0 +1,176 @@
+// Command: get-bin-contents → ppb_getBinContents
+// 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.
+//
+// Resolves a bin by a '/'-separated path (same convention as
+// create-sequence's --bin) starting at app.project.rootItem, then
+// recursively lists its contents (same walk shape as list-project-items.jsx),
+// capped at depth 32. Helper names are prefixed ppbBinContents_ to avoid
+// colliding with same-purpose helpers in other lazily-loaded command files
+// evaluated into this same global context.
+
+function ppbBinContents_isBin(item) {
+  try {
+    return typeof ProjectItemType !== "undefined" && item.type === ProjectItemType.BIN;
+  } catch (e) {
+    return false;
+  }
+}
+
+function ppbBinContents_typeToString(item) {
+  try {
+    if (typeof ProjectItemType !== "undefined") {
+      if (item.type === ProjectItemType.BIN) {
+        return "BIN";
+      }
+      if (item.type === ProjectItemType.CLIP) {
+        return "CLIP";
+      }
+      if (item.type === ProjectItemType.FILE) {
+        return "FILE";
+      }
+      if (item.type === ProjectItemType.ROOT) {
+        return "ROOT";
+      }
+    }
+  } catch (e) {
+    // fall through to raw number below
+  }
+  return String(item.type);
+}
+
+// Capped at depth 32 to defend against pathological/circular bin
+// structures rather than looping forever.
+function ppbBinContents_walk(item, parentPath, depth, results) {
+  if (depth > 32) {
+    return;
+  }
+
+  var treePath = null;
+  try {
+    treePath = item.treePath;
+  } catch (e) {
+    treePath = null;
+  }
+  if (!treePath) {
+    treePath = parentPath + "/" + item.name;
+  }
+
+  var mediaPath = null;
+  try {
+    mediaPath = item.getMediaPath();
+  } catch (e) {
+    mediaPath = null;
+  }
+
+  var isOffline = null;
+  try {
+    isOffline = item.isOffline();
+  } catch (e) {
+    isOffline = null;
+  }
+
+  var colorLabel = null;
+  try {
+    colorLabel = item.getColorLabel();
+  } catch (e) {
+    colorLabel = null;
+  }
+
+  results.push({
+    name: item.name,
+    treePath: treePath,
+    nodeId: item.nodeId,
+    type: ppbBinContents_typeToString(item),
+    mediaPath: mediaPath,
+    isOffline: isOffline,
+    colorLabel: colorLabel
+  });
+
+  if (ppbBinContents_isBin(item) && item.children) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      ppbBinContents_walk(item.children[i], treePath, depth + 1, results);
+    }
+  }
+}
+
+// Resolves a '/'-separated bin path to a bin ProjectItem, starting at
+// rootItem. Every path segment must match an existing bin by name — this
+// command never creates bins (unlike create-sequence's --bin).
+function ppbBinContents_findBin(binPath) {
+  var segments = binPath.split("/").filter(function (s) { return s.length > 0; });
+  var current = app.project.rootItem;
+
+  for (var i = 0; i < segments.length; i++) {
+    var segment = segments[i];
+    var found = null;
+
+    for (var j = 0; j < current.children.numItems; j++) {
+      var child = current.children[j];
+      if (child.name === segment && ppbBinContents_isBin(child)) {
+        found = child;
+        break;
+      }
+    }
+
+    if (!found) {
+      return null;
+    }
+    current = found;
+  }
+
+  return current;
+}
+
+function ppb_getBinContents(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.binPath || typeof args.binPath !== "string") {
+      return JSON.stringify({ ok: false, error: "binPath is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var bin = ppbBinContents_findBin(args.binPath);
+    if (!bin) {
+      return JSON.stringify({ ok: false, error: "no bin found at path \"" + args.binPath + "\"" });
+    }
+    if (!ppbBinContents_isBin(bin)) {
+      return JSON.stringify({ ok: false, error: "\"" + args.binPath + "\" is not a bin" });
+    }
+
+    var results = [];
+    for (var i = 0; i < bin.children.numItems; i++) {
+      ppbBinContents_walk(bin.children[i], bin.treePath || args.binPath, 1, results);
+    }
+
+    var binTreePath = null;
+    try {
+      binTreePath = bin.treePath;
+    } catch (e) {
+      binTreePath = args.binPath;
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        binPath: args.binPath,
+        binNodeId: bin.nodeId,
+        binTreePath: binTreePath,
+        items: results,
+        count: results.length
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-clip-adjustment-layer.jsx

@@ -0,0 +1,83 @@
+// Command: get-clip-adjustment-layer → ppb_getClipAdjustmentLayer
+// 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 read only — no QE DOM needed, no need to activate the
+// sequence tab. Ported from leancoderkavy's premiere-pro-mcp
+// `get_clip_adjustment_layer` tool (advanced.ts), which addresses the clip
+// by nodeId; here it uses the same sequenceName/trackType/trackIndex/
+// clipIndex addressing convention as get-full-clip-info instead.
+
+function ppb_getClipAdjustmentLayer(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 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 result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      clipIndex: args.clipIndex,
+      clipName: null,
+      isAdjustmentLayer: null
+    };
+
+    try { result.clipName = clip.name; } catch (e) { result.clipName = null; }
+    try { result.isAdjustmentLayer = clip.isAdjustmentLayer(); } catch (e) { result.isAdjustmentLayer = null; }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-clip-at-playhead.jsx

@@ -0,0 +1,99 @@
+// Command: get-clip-at-playhead → ppb_getClipAtPlayhead
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// serializeTrackItem, timeValueToSeconds, ...) are already defined there.
+//
+// Standard-DOM read only — no QE DOM needed, no need to activate the
+// sequence tab. Ported from leancoderkavy's premiere-pro-mcp
+// `get_clip_at_playhead` tool (utility.ts): finds every clip (across all
+// tracks, or just video/audio) that covers the sequence's current
+// playhead position.
+
+function ppb_getClipAtPlayhead(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 || "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 playheadSeconds = null;
+    try {
+      playheadSeconds = timeValueToSeconds(seq.getPlayerPosition());
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "could not read playhead position: " + e.toString() });
+    }
+    if (playheadSeconds === null) {
+      return JSON.stringify({ ok: false, error: "could not read playhead position" });
+    }
+
+    var clips = [];
+
+    function findAtPlayhead(trackCollection, type) {
+      var numTracks = 0;
+      try { numTracks = trackCollection.numTracks; } catch (e) { return; }
+      for (var t = 0; t < numTracks; t++) {
+        var track = trackCollection[t];
+        var numClips = 0;
+        try { numClips = track.clips.numItems; } catch (e) { continue; }
+        for (var c = 0; c < numClips; c++) {
+          var clip = track.clips[c];
+          var startSeconds = null;
+          var endSeconds = null;
+          try { startSeconds = timeValueToSeconds(clip.start); } catch (e) { startSeconds = null; }
+          try { endSeconds = timeValueToSeconds(clip.end); } catch (e) { endSeconds = null; }
+          if (startSeconds === null || endSeconds === null) {
+            continue;
+          }
+          if (startSeconds <= playheadSeconds && endSeconds > playheadSeconds) {
+            var serialized = serializeTrackItem(clip, t, c);
+            serialized.trackType = type;
+            clips.push(serialized);
+          }
+        }
+      }
+    }
+
+    if (trackType !== "audio") {
+      findAtPlayhead(seq.videoTracks, "video");
+    }
+    if (trackType !== "video") {
+      findAtPlayhead(seq.audioTracks, "audio");
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        playheadSeconds: playheadSeconds,
+        clipCount: clips.length,
+        clips: clips
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-clip-at-position.jsx

@@ -0,0 +1,120 @@
+// Command: get-clip-at-position → ppb_getClipAtPosition
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// serializeTrackItem, timeValueToSeconds, ...) are already defined there.
+//
+// Standard-DOM read only (seq.videoTracks[i].clips[j]) — no QE DOM needed,
+// no need to activate the sequence tab. Ported from leancoderkavy's
+// premiere-pro-mcp `get_clip_at_position` tool (discovery.ts), which only
+// searches one specific track; here `trackType`/`trackIndex` are optional
+// filters — omitting both scans every video and audio track for whichever
+// clip (if any) covers the given time.
+
+function ppb_getClipAtPosition(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.seconds !== "number" || !isFinite(args.seconds) || args.seconds < 0) {
+      return JSON.stringify({ ok: false, error: "seconds must be a non-negative number" });
+    }
+    if (typeof args.trackType !== "undefined" && args.trackType !== "video" && args.trackType !== "audio") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\" or \"audio\" if given" });
+    }
+    if (typeof args.trackIndex !== "undefined") {
+      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 (!args.trackType) {
+        return JSON.stringify({ ok: false, error: "trackIndex requires trackType to also be given" });
+      }
+    }
+
+    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 clips = [];
+
+    function scanTrack(track, trackType, trackIndex) {
+      var numClips = 0;
+      try { numClips = track.clips.numItems; } catch (e) { return; }
+      for (var c = 0; c < numClips; c++) {
+        var clip = track.clips[c];
+        var startSeconds = null;
+        var endSeconds = null;
+        try { startSeconds = timeValueToSeconds(clip.start); } catch (e) { startSeconds = null; }
+        try { endSeconds = timeValueToSeconds(clip.end); } catch (e) { endSeconds = null; }
+        if (startSeconds === null || endSeconds === null) {
+          continue;
+        }
+        if (args.seconds >= startSeconds && args.seconds < endSeconds) {
+          var serialized = serializeTrackItem(clip, trackIndex, c);
+          serialized.trackType = trackType;
+          clips.push(serialized);
+        }
+      }
+    }
+
+    function scanTrackType(trackType) {
+      var trackCollection = trackType === "video" ? seq.videoTracks : seq.audioTracks;
+      var numTracks = 0;
+      try { numTracks = trackCollection.numTracks; } catch (e) { numTracks = 0; }
+
+      if (typeof args.trackIndex === "number" && args.trackType === trackType) {
+        if (args.trackIndex >= numTracks) {
+          return "trackIndex " + args.trackIndex + " is out of range — sequence has " + numTracks + " " + trackType + " track(s)";
+        }
+        scanTrack(trackCollection[args.trackIndex], trackType, args.trackIndex);
+        return null;
+      }
+
+      for (var t = 0; t < numTracks; t++) {
+        scanTrack(trackCollection[t], trackType, t);
+      }
+      return null;
+    }
+
+    if (!args.trackType || args.trackType === "video") {
+      var videoErr = scanTrackType("video");
+      if (videoErr) {
+        return JSON.stringify({ ok: false, error: videoErr });
+      }
+    }
+    if (!args.trackType || args.trackType === "audio") {
+      var audioErr = scanTrackType("audio");
+      if (audioErr) {
+        return JSON.stringify({ ok: false, error: audioErr });
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        seconds: args.seconds,
+        clipCount: clips.length,
+        clips: clips
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}