premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/get-effect-properties.jsx

@@ -0,0 +1,129 @@
+// Command: get-effect-properties → ppb_getEffectProperties
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// findClipComponent, findComponentProperty, ...) are already defined there.
+//
+// Standard-DOM only — no QE needed. Ported from leancoderkavy's
+// premiere-pro-mcp `get_effect_properties` tool (keyframes.ts), addressed
+// here by trackType/trackIndex/clipIndex + componentName (same convention
+// as get-full-clip-info) instead of node_id/effect_name. Unlike
+// get-full-clip-info's per-clip component summary (capped, values
+// truncated), this reads ALL properties of ONE named component, uncapped.
+// componentName is matched generically against BOTH matchName and
+// displayName via the shared findClipComponent() helper — this is not
+// hardcoded to Motion/Opacity like the wave-3 transform setters.
+function ppb_getEffectProperties(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 (!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 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;
+    var compMatchName = null;
+    try { compDisplayName = comp.displayName; } catch (e) { compDisplayName = null; }
+    try { compMatchName = comp.matchName; } catch (e) { compMatchName = null; }
+
+    var numProps = 0;
+    try { numProps = comp.properties.numItems; } catch (e) { numProps = 0; }
+
+    var properties = [];
+    for (var p = 0; p < numProps; p++) {
+      var prop = comp.properties[p];
+      var info = { displayName: null, value: null, isTimeVarying: null, keyCount: null };
+      try { info.displayName = prop.displayName; } catch (e1) { info.displayName = null; }
+      try { info.value = prop.getValue(); } catch (e2) { info.value = null; }
+      try { info.isTimeVarying = prop.isTimeVarying(); } catch (e3) { info.isTimeVarying = null; }
+      try {
+        if (info.isTimeVarying) {
+          var keys = prop.getKeys();
+          info.keyCount = keys ? keys.length : 0;
+        } else {
+          info.keyCount = 0;
+        }
+      } catch (e4) {
+        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,
+        componentName: compDisplayName,
+        matchName: compMatchName,
+        properties: properties,
+        propertyCount: properties.length
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-encoder-presets.jsx

@@ -0,0 +1,131 @@
+// Command: get-encoder-presets → ppb_getEncoderPresets
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use.
+//
+// PREMIERE_API_NOTES.md flags `app.encoder.getExporters()` →
+// `.getPresets()` as an unconfirmed API surface ([ayushozha] uses it, the
+// other two repos scan .epr files on disk instead). We probe the live-API
+// route only (no filesystem scanning) with a try/catch around every single
+// field access, so an unsupported build reports an honest
+// {"available": false} rather than throwing or guessing preset paths.
+// Ported (loosely) from leancoderkavy's premiere-pro-mcp
+// `get_encoder_presets` tool (track-targeting.ts), which instead walks
+// .epr files on disk — not attempted here, see the note above.
+
+function ppb_getEncoderPresets(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var result = { available: false, presets: [], count: 0 };
+
+    var encoder = null;
+    try {
+      encoder = app.encoder;
+    } catch (e) {
+      encoder = null;
+    }
+    if (!encoder) {
+      result.error = "app.encoder is not available on this Premiere build";
+      return JSON.stringify({ ok: true, result: result });
+    }
+
+    var exporters = null;
+    try {
+      exporters = encoder.getExporters();
+    } catch (e) {
+      result.error = "app.encoder.getExporters() failed: " + e.toString();
+      return JSON.stringify({ ok: true, result: result });
+    }
+    if (!exporters) {
+      result.error = "app.encoder.getExporters() returned nothing";
+      return JSON.stringify({ ok: true, result: result });
+    }
+
+    var numExporters = 0;
+    try {
+      numExporters = typeof exporters.numItems === "number" ? exporters.numItems : exporters.length;
+    } catch (e) {
+      numExporters = 0;
+    }
+    if (typeof numExporters !== "number" || isNaN(numExporters)) {
+      numExporters = 0;
+    }
+
+    result.available = true;
+    result.exportersCount = numExporters;
+
+    for (var i = 0; i < numExporters; i++) {
+      var exporter = null;
+      try {
+        exporter = exporters[i];
+      } catch (e) {
+        continue;
+      }
+      if (!exporter) {
+        continue;
+      }
+
+      var exporterName = null;
+      try { exporterName = exporter.name; } catch (e) { exporterName = null; }
+
+      var presetsForExporter = null;
+      try {
+        presetsForExporter = exporter.getPresets();
+      } catch (e) {
+        continue;
+      }
+      if (!presetsForExporter) {
+        continue;
+      }
+
+      var numPresets = 0;
+      try {
+        numPresets = typeof presetsForExporter.numItems === "number" ? presetsForExporter.numItems : presetsForExporter.length;
+      } catch (e) {
+        numPresets = 0;
+      }
+      if (typeof numPresets !== "number" || isNaN(numPresets)) {
+        numPresets = 0;
+      }
+
+      for (var p = 0; p < numPresets; p++) {
+        var preset = null;
+        try {
+          preset = presetsForExporter[p];
+        } catch (e) {
+          continue;
+        }
+        if (!preset) {
+          continue;
+        }
+        var entry = { exporterName: exporterName, name: null, path: null };
+        try { entry.name = preset.name; } catch (e) { entry.name = null; }
+        try { entry.path = preset.path; } catch (e) { entry.path = null; }
+        result.presets.push(entry);
+      }
+    }
+
+    if (args.format && typeof args.format === "string") {
+      var needle = args.format.toLowerCase();
+      var filtered = [];
+      for (var f = 0; f < result.presets.length; f++) {
+        var entryName = (result.presets[f].name || "").toLowerCase();
+        var entryExporter = (result.presets[f].exporterName || "").toLowerCase();
+        if (entryName.indexOf(needle) !== -1 || entryExporter.indexOf(needle) !== -1) {
+          filtered.push(result.presets[f]);
+        }
+      }
+      result.presets = filtered;
+    }
+
+    result.count = result.presets.length;
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-export-file-extension.jsx

@@ -0,0 +1,56 @@
+// Command: get-export-file-extension → ppb_getExportFileExtension
+// 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 sequence.ts
+// get_export_file_extension. Standard DOM only — no QE needed.
+function ppb_getExportFileExtension(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.presetPath !== "string" || args.presetPath.length === 0) {
+      return JSON.stringify({ ok: false, error: "presetPath (string) 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 extension = null;
+    try {
+      extension = seq.getExportFileExtension(args.presetPath);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "could not read export file extension: " + e.toString() });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        presetPath: args.presetPath,
+        extension: extension
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-footage-interpretation.jsx

@@ -0,0 +1,113 @@
+// Command: get-footage-interpretation → ppb_getFootageInterpretation
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Project-item addressing: at least one of nodeId/name is required (see
+// get-item-metadata.jsx for the shared design note — the resolver is
+// duplicated per-file since command files load independently).
+
+function ppbFindItemGetFootageInterp_walk(item, args, depth) {
+  if (depth > 32) {
+    return null;
+  }
+
+  var isBin = false;
+  try {
+    isBin = typeof ProjectItemType !== "undefined" && item.type === ProjectItemType.BIN;
+  } catch (e) {
+    isBin = false;
+  }
+
+  var matched = false;
+  if (args.nodeId !== null) {
+    try { matched = item.nodeId === args.nodeId; } catch (e) { matched = false; }
+  } else if (args.name !== null) {
+    try { matched = item.name === args.name; } catch (e) { matched = false; }
+  }
+  if (matched) {
+    return item;
+  }
+
+  if (isBin && item.children) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbFindItemGetFootageInterp_walk(item.children[i], args, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbFindItemGetFootageInterp_resolve(args) {
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var found = ppbFindItemGetFootageInterp_walk(root.children[i], args, 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function ppb_getFootageInterpretation(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 = ppbFindItemGetFootageInterp_resolve({
+      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 interp = null;
+    try {
+      interp = item.getFootageInterpretation();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "getFootageInterpretation() failed: " + e.toString() });
+    }
+    if (!interp) {
+      return JSON.stringify({ ok: false, error: "no footage interpretation available for this item" });
+    }
+
+    var result = {
+      name: null,
+      nodeId: null,
+      alphaUsage: null,
+      fieldType: null,
+      frameRate: null,
+      ignoreAlpha: null,
+      invertAlpha: null,
+      pixelAspectRatio: null
+    };
+    try { result.name = item.name; } catch (e) { result.name = null; }
+    try { result.nodeId = item.nodeId; } catch (e) { result.nodeId = null; }
+    try { result.alphaUsage = interp.alphaUsage; } catch (e) { result.alphaUsage = null; }
+    try { result.fieldType = interp.fieldType; } catch (e) { result.fieldType = null; }
+    try { result.frameRate = interp.frameRate; } catch (e) { result.frameRate = null; }
+    try { result.ignoreAlpha = interp.ignoreAlpha; } catch (e) { result.ignoreAlpha = null; }
+    try { result.invertAlpha = interp.invertAlpha; } catch (e) { result.invertAlpha = null; }
+    try { result.pixelAspectRatio = interp.pixelAspectRatio; } catch (e) { result.pixelAspectRatio = null; }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-full-clip-info.jsx

@@ -0,0 +1,162 @@
+// Command: get-full-clip-info → ppb_getFullClipInfo
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// 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.
+
+var GET_FULL_CLIP_INFO_MAX_COMPONENTS = 50;
+var GET_FULL_CLIP_INFO_MAX_PROPERTIES = 100;
+
+function ppb_serializePropertyForFullClipInfo(prop) {
+  var out = { displayName: null, value: null, isTimeVarying: null, keyCount: null };
+
+  try { out.displayName = prop.displayName; } catch (e) { out.displayName = null; }
+
+  try {
+    var raw = prop.getValue();
+    var str = String(raw);
+    out.value = str.length > 200 ? str.substring(0, 200) : str;
+  } catch (e) {
+    out.value = null;
+  }
+
+  try {
+    out.isTimeVarying = prop.isTimeVarying();
+  } catch (e) {
+    out.isTimeVarying = null;
+  }
+
+  if (out.isTimeVarying === true) {
+    try {
+      out.keyCount = prop.getKeys().length;
+    } catch (e) {
+      out.keyCount = null;
+    }
+  }
+
+  return out;
+}
+
+function ppb_serializeComponentForFullClipInfo(comp) {
+  var out = { displayName: null, matchName: null, enabled: null, properties: [] };
+
+  try { out.displayName = comp.displayName; } catch (e) { out.displayName = null; }
+  try { out.matchName = comp.matchName; } catch (e) { out.matchName = null; }
+  try { out.enabled = comp.enabled; } catch (e) { out.enabled = null; }
+
+  try {
+    var numProps = comp.properties.numItems;
+    var cap = numProps > GET_FULL_CLIP_INFO_MAX_PROPERTIES ? GET_FULL_CLIP_INFO_MAX_PROPERTIES : numProps;
+    for (var p = 0; p < cap; p++) {
+      out.properties.push(ppb_serializePropertyForFullClipInfo(comp.properties[p]));
+    }
+    if (numProps > GET_FULL_CLIP_INFO_MAX_PROPERTIES) {
+      out.truncated = true;
+    }
+  } catch (e) {
+    // leave properties as whatever was collected so far
+  }
+
+  return out;
+}
+
+function ppb_serializeComponentsForFullClipInfo(clip) {
+  var components = [];
+  var truncated = false;
+  try {
+    var numComponents = clip.components.numItems;
+    var cap = numComponents > GET_FULL_CLIP_INFO_MAX_COMPONENTS ? GET_FULL_CLIP_INFO_MAX_COMPONENTS : numComponents;
+    for (var i = 0; i < cap; i++) {
+      components.push(ppb_serializeComponentForFullClipInfo(clip.components[i]));
+    }
+    if (numComponents > GET_FULL_CLIP_INFO_MAX_COMPONENTS) {
+      truncated = true;
+    }
+  } catch (e) {
+    // leave components as whatever was collected so far
+  }
+  return { components: components, truncated: truncated };
+}
+
+function ppb_getFullClipInfo(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 = serializeTrackItem(clip, args.trackIndex, args.clipIndex);
+
+    try { result.type = clip.type; } catch (e) { result.type = null; }
+    try { result.speed = clip.getSpeed(); } catch (e) { result.speed = null; }
+    try { result.isSpeedReversed = clip.isSpeedReversed(); } catch (e) { result.isSpeedReversed = null; }
+    try { result.linkedItemsCount = clip.getLinkedItems().numItems; } catch (e) { result.linkedItemsCount = null; }
+
+    result.projectItem = { name: null, treePath: null, nodeId: null };
+    try { result.projectItem.name = clip.projectItem.name; } catch (e) { result.projectItem.name = null; }
+    try { result.projectItem.treePath = clip.projectItem.treePath; } catch (e) { result.projectItem.treePath = null; }
+    try { result.projectItem.nodeId = clip.projectItem.nodeId; } catch (e) { result.projectItem.nodeId = null; }
+
+    var componentsResult = ppb_serializeComponentsForFullClipInfo(clip);
+    result.components = componentsResult.components;
+    if (componentsResult.truncated) {
+      result.truncated = true;
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}