premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/get-mogrt-component.jsx

@@ -0,0 +1,111 @@
+// Command: get-mogrt-component → ppb_getMogrtComponent
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — findSequenceByName,
+// resolveTimelineClip are already defined there.
+//
+// Ported from leancoderkavy's premiere-pro-mcp advanced.ts
+// get_mogrt_component, re-addressed to this panel's
+// trackType/trackIndex/clipIndex convention (same as get-full-clip-info)
+// instead of node_id. READ-ONLY — properties are serialized the same
+// shape as get-effect-properties ({displayName, value, isTimeVarying,
+// keyCount}).
+//
+// ⚠️ Per PREMIERE_API_NOTES.md's "MOGRT Source Text format" note, a
+// MOGRT's Source Text property value is a 4-byte binary header + JSON
+// (mTextParam structure) — plain getValue() returns that raw blob, not
+// human-readable text. This command does NOT attempt to strip the header
+// or parse the JSON (that's a write-path concern per the reference
+// project's hard-won notes, and this command never writes) — the raw
+// value is reported as-is; callers wanting the actual displayed text need
+// to decode it client-side.
+function ppb_getMogrtComponent(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 (!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 clipName = null;
+    try { clipName = clip.name; } catch (e2) { clipName = null; }
+
+    var mgtComp = null;
+    try {
+      mgtComp = clip.getMGTComponent();
+    } catch (e3) {
+      return JSON.stringify({ ok: false, error: "clip.getMGTComponent() failed: " + e3.toString() });
+    }
+    if (!mgtComp) {
+      return JSON.stringify({ ok: false, error: "not a MOGRT clip, or no MGT component found on this clip" });
+    }
+
+    var numProps = 0;
+    try { numProps = mgtComp.properties.numItems; } catch (e4) { numProps = 0; }
+
+    var properties = [];
+    for (var p = 0; p < numProps; p++) {
+      var prop = mgtComp.properties[p];
+      var info = { displayName: null, value: null, isTimeVarying: null, keyCount: null };
+      try { info.displayName = prop.displayName; } catch (e5) { info.displayName = null; }
+      try { info.value = prop.getValue(); } catch (e6) { info.value = null; }
+      try { info.isTimeVarying = prop.isTimeVarying(); } catch (e7) { info.isTimeVarying = null; }
+      try {
+        if (info.isTimeVarying) {
+          var keys = prop.getKeys();
+          info.keyCount = keys ? keys.length : 0;
+        } else {
+          info.keyCount = 0;
+        }
+      } catch (e8) {
+        info.keyCount = null;
+      }
+      properties.push(info);
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        clipName: clipName,
+        properties: properties,
+        propertyCount: properties.length,
+        note: "values are raw getValue() output — a MOGRT's Source Text property is a 4-byte-header+JSON binary blob on this build per PREMIERE_API_NOTES.md, not decoded here (read-only command)."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-next-edit-point.jsx

@@ -0,0 +1,131 @@
+// Command: get-next-edit-point → ppb_getNextEditPoint
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// 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_next_edit_point` tool (utility.ts): collects every clip start/end
+// boundary across the given track type(s), then finds the nearest one
+// strictly before/after the playhead.
+
+var GET_NEXT_EDIT_POINT_EPSILON_SECONDS = 1e-6;
+
+function ppb_getNextEditPoint(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var direction = args.direction || "next";
+    if (direction !== "next" && direction !== "previous") {
+      return JSON.stringify({ ok: false, error: "direction must be \"next\" or \"previous\"" });
+    }
+    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 editPoints = [];
+
+    function collectPoints(trackCollection) {
+      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];
+          try { editPoints.push(timeValueToSeconds(clip.start)); } catch (e) { /* skip */ }
+          try { editPoints.push(timeValueToSeconds(clip.end)); } catch (e) { /* skip */ }
+        }
+      }
+    }
+
+    if (trackType !== "audio") {
+      collectPoints(seq.videoTracks);
+    }
+    if (trackType !== "video") {
+      collectPoints(seq.audioTracks);
+    }
+
+    editPoints.sort(function (a, b) { return a - b; });
+    var unique = [];
+    for (var i = 0; i < editPoints.length; i++) {
+      if (editPoints[i] === null || typeof editPoints[i] === "undefined") {
+        continue;
+      }
+      if (unique.length === 0 || Math.abs(editPoints[i] - unique[unique.length - 1]) > GET_NEXT_EDIT_POINT_EPSILON_SECONDS) {
+        unique.push(editPoints[i]);
+      }
+    }
+
+    var found = null;
+    if (direction === "next") {
+      for (var n = 0; n < unique.length; n++) {
+        if (unique[n] > playheadSeconds + GET_NEXT_EDIT_POINT_EPSILON_SECONDS) {
+          found = unique[n];
+          break;
+        }
+      }
+    } else {
+      for (var p = unique.length - 1; p >= 0; p--) {
+        if (unique[p] < playheadSeconds - GET_NEXT_EDIT_POINT_EPSILON_SECONDS) {
+          found = unique[p];
+          break;
+        }
+      }
+    }
+
+    if (found === null) {
+      return JSON.stringify({
+        ok: true,
+        result: { sequenceName: seq.name, found: false, direction: direction, playheadSeconds: playheadSeconds }
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        found: true,
+        direction: direction,
+        editPointSeconds: found,
+        playheadSeconds: playheadSeconds
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-offline-media.jsx

@@ -0,0 +1,67 @@
+// Command: get-offline-media → ppb_getOfflineMedia
+// 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 item where isOffline() is
+// true. Helper names are prefixed ppbOfflineMedia_ to avoid colliding with
+// same-purpose helpers in other lazily-loaded command files evaluated into
+// this same global context.
+
+function ppbOfflineMedia_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 ppbOfflineMedia_scan(item, depth, results) {
+  if (depth > 32) {
+    return;
+  }
+
+  var isOffline = false;
+  try {
+    isOffline = item.isOffline();
+  } catch (e) {
+    isOffline = false;
+  }
+
+  if (isOffline) {
+    var entry = { nodeId: null, name: null, treePath: null, mediaPath: null, colorLabel: null };
+    try { entry.nodeId = item.nodeId; } catch (e) { entry.nodeId = null; }
+    try { entry.name = item.name; } catch (e) { entry.name = null; }
+    try { entry.treePath = item.treePath; } catch (e) { entry.treePath = null; }
+    try { entry.mediaPath = item.getMediaPath(); } catch (e) { entry.mediaPath = null; }
+    try { entry.colorLabel = item.getColorLabel(); } catch (e) { entry.colorLabel = null; }
+    results.push(entry);
+  }
+
+  if (ppbOfflineMedia_isBin(item) && item.children) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      ppbOfflineMedia_scan(item.children[i], depth + 1, results);
+    }
+  }
+}
+
+function ppb_getOfflineMedia(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var results = [];
+    var root = app.project.rootItem;
+    for (var i = 0; i < root.children.numItems; i++) {
+      ppbOfflineMedia_scan(root.children[i], 1, results);
+    }
+
+    return JSON.stringify({ ok: true, result: { offlineCount: results.length, items: results } });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-open-projects.jsx

@@ -0,0 +1,50 @@
+// Command: get-open-projects → ppb_getOpenProjects
+// 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.
+//
+// Lightweight list of every currently OPEN project (app.projects), unlike
+// get-project-info (single active project, full sequence detail) or
+// get-full-project-overview (single active project, bin tree + media
+// counts) — this command deliberately reports name/path/isActive only, no
+// per-project sequence data. This replaces the multi-project-listing role
+// previously covered by get-project-metadata (removed in a parallel task);
+// use get-project-info / get-full-project-overview for sequence/bin detail
+// on whichever project is currently active.
+
+function ppb_getOpenProjects(argsJson) {
+  try {
+    if (!app.projects || app.projects.numProjects === 0) {
+      return JSON.stringify({ ok: true, result: { projects: [], count: 0 } });
+    }
+
+    var activePath = null;
+    try {
+      activePath = app.project ? app.project.path : null;
+    } catch (e) {
+      activePath = null;
+    }
+
+    var projects = [];
+    for (var i = 0; i < app.projects.numProjects; i++) {
+      var proj = app.projects[i];
+      var name = null;
+      var path = null;
+      var isActive = null;
+
+      try { name = proj.name; } catch (e) { name = null; }
+      try { path = proj.path; } catch (e) { path = null; }
+      try {
+        isActive = (path !== null && activePath !== null) ? (path === activePath) : null;
+      } catch (e) {
+        isActive = null;
+      }
+
+      projects.push({ name: name, path: path, isActive: isActive });
+    }
+
+    return JSON.stringify({ ok: true, result: { projects: projects, count: projects.length } });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-premiere-state.jsx

@@ -0,0 +1,164 @@
+// Command: get-premiere-state → ppb_getPremiereState
+// 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.
+//
+// A full point-in-time snapshot of whatever Premiere Pro state currently
+// exists: app version, open project, active sequence, playhead position,
+// and current selection. Unlike most other commands, having no project (or
+// no active sequence, or no selection) open is NOT an error here — the
+// whole point of this command is to truthfully report whatever state
+// exists, including "nothing is open right now".
+
+function ppb_getPremiereState() {
+  try {
+    var result = {
+      appVersion: null,
+      project: null,
+      activeSequence: null,
+      playheadSeconds: null,
+      selection: null
+    };
+
+    try {
+      result.appVersion = app.version;
+    } catch (e) {
+      result.appVersion = null;
+    }
+
+    var proj = null;
+    try {
+      proj = app.project;
+    } catch (e) {
+      proj = null;
+    }
+
+    if (proj) {
+      var projectInfo = { name: null, path: null };
+      try {
+        projectInfo.name = proj.name;
+      } catch (e) {
+        projectInfo.name = null;
+      }
+      try {
+        projectInfo.path = proj.path;
+      } catch (e) {
+        projectInfo.path = null;
+      }
+      result.project = projectInfo;
+
+      var seq = null;
+      try {
+        seq = proj.activeSequence;
+      } catch (e) {
+        seq = null;
+      }
+
+      if (seq) {
+        var seqInfo = {
+          name: null,
+          sequenceID: null,
+          frameRate: null,
+          durationSeconds: null,
+          width: null,
+          height: null
+        };
+        try {
+          seqInfo.name = seq.name;
+        } catch (e) {
+          seqInfo.name = null;
+        }
+        try {
+          seqInfo.sequenceID = seq.sequenceID;
+        } catch (e) {
+          seqInfo.sequenceID = null;
+        }
+        try {
+          seqInfo.frameRate = TICKS_PER_SECOND / Number(seq.timebase);
+        } catch (e) {
+          seqInfo.frameRate = null;
+        }
+        try {
+          seqInfo.durationSeconds = (Number(seq.end) - Number(seq.zeroPoint)) / TICKS_PER_SECOND;
+        } catch (e) {
+          seqInfo.durationSeconds = null;
+        }
+        try {
+          var settings = seq.getSettings();
+          seqInfo.width = settings.videoFrameWidth;
+          seqInfo.height = settings.videoFrameHeight;
+        } catch (e) {
+          seqInfo.width = null;
+          seqInfo.height = null;
+        }
+        result.activeSequence = seqInfo;
+
+        try {
+          var pos = seq.getPlayerPosition();
+          try {
+            result.playheadSeconds = pos.seconds;
+          } catch (e2) {
+            result.playheadSeconds = Number(pos.ticks) / TICKS_PER_SECOND;
+          }
+        } catch (e) {
+          result.playheadSeconds = null;
+        }
+
+        // seq.getSelection() has been seen returning either a plain array
+        // (.length) or a TrackItem-collection-style object (.numItems) —
+        // probe both defensively rather than assuming one shape.
+        try {
+          var sel = seq.getSelection();
+          var selCount = 0;
+          if (sel) {
+            if (typeof sel.numItems === "number") {
+              selCount = sel.numItems;
+            } else if (typeof sel.length === "number") {
+              selCount = sel.length;
+            }
+          }
+
+          var selArray = [];
+          for (var i = 0; i < selCount; i++) {
+            var item = sel[i];
+            var entry = { name: null, mediaType: null, startSeconds: null, endSeconds: null, nodeId: null };
+            try {
+              entry.name = item.name;
+            } catch (e) {
+              entry.name = null;
+            }
+            try {
+              entry.mediaType = item.mediaType;
+            } catch (e) {
+              entry.mediaType = null;
+            }
+            try {
+              entry.startSeconds = item.start.seconds;
+            } catch (e) {
+              entry.startSeconds = null;
+            }
+            try {
+              entry.endSeconds = item.end.seconds;
+            } catch (e) {
+              entry.endSeconds = null;
+            }
+            try {
+              entry.nodeId = item.nodeId;
+            } catch (e) {
+              entry.nodeId = null;
+            }
+            selArray.push(entry);
+          }
+          result.selection = selArray;
+        } catch (e) {
+          // getSelection() itself unavailable/threw — distinct from "nothing selected"
+          result.selection = null;
+        }
+      }
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-project-info.jsx

@@ -0,0 +1,63 @@
+// Command: get-project-info → ppb_getProjectInfo
+// 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.
+//
+// Unlike the multi-project get-open-projects.jsx (which lists every
+// currently OPEN project), this operates on app.project — the single
+// active project — and additionally reports the root bin's item count.
+
+function ppb_getProjectInfo(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var proj = app.project;
+    var sequences = [];
+
+    for (var j = 0; j < proj.sequences.numSequences; j++) {
+      var seq = proj.sequences[j];
+      var frameRate = null;
+      var durationSeconds = null;
+
+      try {
+        frameRate = TICKS_PER_SECOND / Number(seq.timebase);
+      } catch (e) {
+        frameRate = null;
+      }
+
+      try {
+        durationSeconds = (Number(seq.end) - Number(seq.zeroPoint)) / TICKS_PER_SECOND;
+      } catch (e) {
+        durationSeconds = null;
+      }
+
+      sequences.push({
+        name: seq.name,
+        sequenceID: seq.sequenceID,
+        frameRate: frameRate,
+        durationSeconds: durationSeconds
+      });
+    }
+
+    var numRootItems = null;
+    try {
+      numRootItems = proj.rootItem.children.numItems;
+    } catch (e) {
+      numRootItems = null;
+    }
+
+    var result = {
+      name: proj.name,
+      path: proj.path,
+      numSequences: proj.sequences.numSequences,
+      sequences: sequences,
+      numRootItems: numRootItems
+    };
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}