premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/import-ae-comps.jsx

@@ -0,0 +1,129 @@
+// Command: import-ae-comps → ppb_importAeComps
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's project.ts import_ae_comps.
+// Calls app.project.importAEComps(aep, [names], bin) if compNames is
+// given, else app.project.importAllAEComps(aep, bin) — both per
+// PREMIERE_API_NOTES.md's Project/bins/import section. targetBinPath
+// resolves via the same '/'-separated-path bin walk as get-bin-contents.
+// jsx (never auto-created — must already exist); omitted defaults to
+// app.project.rootItem. Verified by a target-bin children-count increase
+// (never trusting the call's own return value).
+//
+// Helper names prefixed ppbImportAeComps_ to avoid colliding with
+// same-purpose helpers in other lazily-loaded command files evaluated
+// into this same global context.
+
+function ppbImportAeComps_isBin(item) {
+  try {
+    return typeof ProjectItemType !== "undefined" && item.type === ProjectItemType.BIN;
+  } catch (e) {
+    return false;
+  }
+}
+
+function ppbImportAeComps_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 && ppbImportAeComps_isBin(child)) {
+        found = child;
+        break;
+      }
+    }
+
+    if (!found) {
+      return null;
+    }
+    current = found;
+  }
+
+  return current;
+}
+
+function ppb_importAeComps(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.aepPath || typeof args.aepPath !== "string") {
+      return JSON.stringify({ ok: false, error: "aepPath is required" });
+    }
+
+    var file = new File(args.aepPath);
+    if (!file.exists) {
+      return JSON.stringify({ ok: false, error: "no file exists at aepPath: " + args.aepPath });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var targetBin = app.project.rootItem;
+    if (args.targetBinPath && typeof args.targetBinPath === "string") {
+      var found = ppbImportAeComps_findBin(args.targetBinPath);
+      if (!found) {
+        return JSON.stringify({ ok: false, error: "no bin found at targetBinPath \"" + args.targetBinPath + "\"" });
+      }
+      targetBin = found;
+    }
+
+    var hasNames = Object.prototype.toString.call(args.compNames) === "[object Array]" && args.compNames.length > 0;
+
+    var countBefore = targetBin.children.numItems;
+
+    try {
+      if (hasNames) {
+        if (typeof app.project.importAEComps !== "function") {
+          return JSON.stringify({ ok: false, error: "importAEComps is not available on this Premiere build" });
+        }
+        app.project.importAEComps(args.aepPath, args.compNames, targetBin);
+      } else {
+        if (typeof app.project.importAllAEComps !== "function") {
+          return JSON.stringify({ ok: false, error: "importAllAEComps is not available on this Premiere build" });
+        }
+        app.project.importAllAEComps(args.aepPath, targetBin);
+      }
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "AE comp import failed: " + e.toString() });
+    }
+
+    var countAfter = targetBin.children.numItems;
+    var imported = countAfter > countBefore;
+
+    if (!imported) {
+      return JSON.stringify({
+        ok: false,
+        error: "the import call did not throw, but the target bin's item count did not increase",
+        countBefore: countBefore,
+        countAfter: countAfter
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        imported: true,
+        aepPath: args.aepPath,
+        compNames: hasNames ? args.compNames : null,
+        allComps: !hasNames,
+        targetBinPath: args.targetBinPath || null,
+        countBefore: countBefore,
+        countAfter: countAfter
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/import-fcp-xml.jsx

@@ -0,0 +1,103 @@
+// Command: import-fcp-xml → ppb_importFcpXml
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's project.ts import_fcp_xml,
+// which uses the legacy app.openFCPXML(path). PREMIERE_API_NOTES.md's
+// Sequences table flags this as legacy and recommends
+// app.project.importFiles([xmlPath], false, rootItem, false) instead
+// [hetpatel] — so this command tries importFiles first (verified by a
+// root-bin children-count increase, same pattern as create-smart-bin.jsx),
+// falling back to app.openFCPXML() if importFiles isn't available or
+// doesn't visibly add anything. DIALOG RISK: both paths can pop blocking
+// dialogs on malformed/unsupported XML (same caveat as open-project.jsx
+// and PREMIERE_API_NOTES.md's Import section) — a hang here likely means
+// a dialog needs dismissing in Premiere itself.
+
+function ppb_importFcpXml(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.xmlPath || typeof args.xmlPath !== "string") {
+      return JSON.stringify({ ok: false, error: "xmlPath is required" });
+    }
+
+    var file = new File(args.xmlPath);
+    if (!file.exists) {
+      return JSON.stringify({ ok: false, error: "no file exists at xmlPath: " + args.xmlPath });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var countBefore = app.project.rootItem.children.numItems;
+    var attempts = [];
+    var method = null;
+
+    if (typeof app.project.importFiles === "function") {
+      try {
+        app.project.importFiles([args.xmlPath], false, app.project.rootItem, false);
+        var countAfterImportFiles = app.project.rootItem.children.numItems;
+        var success1 = countAfterImportFiles > countBefore;
+        attempts.push({ method: "importFiles", success: success1 });
+        if (success1) {
+          method = "importFiles";
+        }
+      } catch (e) {
+        attempts.push({ method: "importFiles", success: false, error: e.toString() });
+      }
+    } else {
+      attempts.push({ method: "importFiles", success: false, error: "app.project.importFiles is not a function on this Premiere build" });
+    }
+
+    if (method === null) {
+      if (typeof app.openFCPXML === "function") {
+        try {
+          app.openFCPXML(args.xmlPath);
+          var countAfterOpenFCPXML = app.project.rootItem.children.numItems;
+          var success2 = countAfterOpenFCPXML > countBefore;
+          attempts.push({ method: "openFCPXML", success: success2 });
+          if (success2) {
+            method = "openFCPXML";
+          }
+        } catch (e) {
+          attempts.push({ method: "openFCPXML", success: false, error: e.toString() });
+        }
+      } else {
+        attempts.push({ method: "openFCPXML", success: false, error: "app.openFCPXML is not a function on this Premiere build" });
+      }
+    }
+
+    var countAfter = app.project.rootItem.children.numItems;
+
+    if (method === null) {
+      return JSON.stringify({
+        ok: false,
+        error: "could not import the FCP XML with any known method — see attempts",
+        attempts: attempts,
+        countBefore: countBefore,
+        countAfter: countAfter
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        imported: true,
+        xmlPath: args.xmlPath,
+        method: method,
+        countBefore: countBefore,
+        countAfter: countAfter,
+        attempts: attempts
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/import-folder.jsx

@@ -0,0 +1,193 @@
+// Command: import-folder → ppb_importFolder
+// 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.
+//
+// Ports the reference project's media.ts import_folder tool. Same
+// extension-allowlist/nodeId-diff verification approach as import-media.jsx
+// (see that file's header for the dialog-freeze rationale) — duplicated
+// here under its own prefix since each lazily-loaded command file cannot
+// rely on helpers defined only in another command file.
+
+var PPB_IMPORT_FOLDER_ALLOWED_EXTENSIONS = [
+  "mp4", "mov", "avi", "mkv", "webm", "mxf", "m4v", "wmv", "mpg", "mpeg",
+  "wav", "mp3", "aac", "m4a", "aif", "aiff", "flac", "ogg",
+  "png", "jpg", "jpeg", "gif", "tiff", "tif", "bmp", "psd", "tga", "exr", "dpx", "webp",
+  "prproj"
+];
+
+function ppbImportFolder_extensionOf(path) {
+  var lastDot = path.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === path.length - 1) {
+    return "";
+  }
+  return path.substring(lastDot + 1).toLowerCase();
+}
+
+function ppbImportFolder_isAllowedExtension(path) {
+  var ext = ppbImportFolder_extensionOf(path);
+  for (var i = 0; i < PPB_IMPORT_FOLDER_ALLOWED_EXTENSIONS.length; i++) {
+    if (ext === PPB_IMPORT_FOLDER_ALLOWED_EXTENSIONS[i]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function ppbImportFolder_snapshotNodeIds(item, depth, seen) {
+  if (depth > 32) {
+    return;
+  }
+  try {
+    if (item.nodeId) {
+      seen[item.nodeId] = true;
+    }
+  } catch (e) {
+    // ignore
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      ppbImportFolder_snapshotNodeIds(item.children[i], depth + 1, seen);
+    }
+  }
+}
+
+function ppbImportFolder_takeSnapshot() {
+  var seen = {};
+  ppbImportFolder_snapshotNodeIds(app.project.rootItem, 0, seen);
+  return seen;
+}
+
+function ppbImportFolder_collectNew(item, depth, beforeSnapshot, out) {
+  if (depth > 32) {
+    return;
+  }
+  try {
+    if (item.nodeId && !beforeSnapshot[item.nodeId]) {
+      var entry = { name: null, nodeId: null, treePath: null, mediaPath: null };
+      try { entry.name = item.name; } catch (e) { entry.name = null; }
+      try { entry.nodeId = item.nodeId; } catch (e) { entry.nodeId = null; }
+      try { entry.treePath = item.treePath; } catch (e) { entry.treePath = null; }
+      try { entry.mediaPath = item.getMediaPath(); } catch (e) { entry.mediaPath = null; }
+      out.push(entry);
+    }
+  } catch (e) {
+    // ignore
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      ppbImportFolder_collectNew(item.children[i], depth + 1, beforeSnapshot, out);
+    }
+  }
+}
+
+function ppbImportFolder_resolveBinPath(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 found = null;
+    for (var j = 0; j < current.children.numItems; j++) {
+      var child = current.children[j];
+      if (child.name === segments[i] && typeof ProjectItemType !== "undefined" && child.type === ProjectItemType.BIN) {
+        found = child;
+        break;
+      }
+    }
+    if (!found) {
+      return { error: "bin path segment \"" + segments[i] + "\" not found in \"" + binPath + "\" (target bin must already exist)" };
+    }
+    current = found;
+  }
+  return { bin: current };
+}
+
+function ppb_importFolder(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.folderPath || typeof args.folderPath !== "string") {
+      return JSON.stringify({ ok: false, error: "folderPath is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var folder = new Folder(args.folderPath);
+    if (!folder.exists) {
+      return JSON.stringify({ ok: false, error: "folder not found: " + args.folderPath });
+    }
+
+    var files = folder.getFiles();
+    var candidatePaths = [];
+    for (var i = 0; i < files.length; i++) {
+      if (files[i] instanceof File) {
+        candidatePaths.push(files[i].fsName);
+      }
+    }
+
+    if (candidatePaths.length === 0) {
+      return JSON.stringify({ ok: false, error: "no files found in folder: " + args.folderPath });
+    }
+
+    var allowed = [];
+    var refused = [];
+    for (var p = 0; p < candidatePaths.length; p++) {
+      if (ppbImportFolder_isAllowedExtension(candidatePaths[p])) {
+        allowed.push(candidatePaths[p]);
+      } else {
+        refused.push(candidatePaths[p]);
+      }
+    }
+
+    if (allowed.length === 0) {
+      return JSON.stringify({
+        ok: false,
+        error: "refusing to import — none of the folder's files have a recognized extension (an unsupported " +
+          "format can pop a BLOCKING dialog that freezes the Premiere Bridge panel)",
+        refused: refused,
+        allowedExtensions: PPB_IMPORT_FOLDER_ALLOWED_EXTENSIONS
+      });
+    }
+
+    var targetBin = app.project.rootItem;
+    if (typeof args.targetBinPath === "string" && args.targetBinPath.length > 0) {
+      var resolved = ppbImportFolder_resolveBinPath(args.targetBinPath);
+      if (resolved.error) {
+        return JSON.stringify({ ok: false, error: resolved.error });
+      }
+      targetBin = resolved.bin;
+    }
+
+    var before = ppbImportFolder_takeSnapshot();
+
+    try {
+      app.project.importFiles(allowed, true, targetBin, false);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.project.importFiles() threw: " + e.toString() });
+    }
+
+    var imported = [];
+    ppbImportFolder_collectNew(app.project.rootItem, 0, before, imported);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        folderPath: args.folderPath,
+        targetBinPath: args.targetBinPath || null,
+        candidateCount: candidatePaths.length,
+        refusedCount: refused.length,
+        refused: refused,
+        importedCount: imported.length,
+        imported: imported
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/import-image-sequence.jsx

@@ -0,0 +1,171 @@
+// Command: import-image-sequence → ppb_importImageSequence
+// 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.
+//
+// Ports the reference project's track-targeting.ts import_image_sequence
+// tool. Imports a numbered image sequence as ONE clip via importFiles'
+// 4th argument (asNumberedStills=true) per PREMIERE_API_NOTES.md. Same
+// extension-allowlist/nodeId-diff verification approach as import-media.jsx
+// (see that file's header) — duplicated under its own prefix since each
+// lazily-loaded command file cannot rely on helpers defined only in
+// another command file. Only the first frame's path is passed to
+// importFiles(); Premiere itself detects the numbered sibling frames.
+
+var PPB_IMPORT_IMAGE_SEQUENCE_ALLOWED_EXTENSIONS = [
+  "png", "jpg", "jpeg", "gif", "tiff", "tif", "bmp", "psd", "tga", "exr", "dpx", "webp"
+];
+
+function ppbImportImageSequence_extensionOf(path) {
+  var lastDot = path.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === path.length - 1) {
+    return "";
+  }
+  return path.substring(lastDot + 1).toLowerCase();
+}
+
+function ppbImportImageSequence_isAllowedExtension(path) {
+  var ext = ppbImportImageSequence_extensionOf(path);
+  for (var i = 0; i < PPB_IMPORT_IMAGE_SEQUENCE_ALLOWED_EXTENSIONS.length; i++) {
+    if (ext === PPB_IMPORT_IMAGE_SEQUENCE_ALLOWED_EXTENSIONS[i]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function ppbImportImageSequence_snapshotNodeIds(item, depth, seen) {
+  if (depth > 32) {
+    return;
+  }
+  try {
+    if (item.nodeId) {
+      seen[item.nodeId] = true;
+    }
+  } catch (e) {
+    // ignore
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      ppbImportImageSequence_snapshotNodeIds(item.children[i], depth + 1, seen);
+    }
+  }
+}
+
+function ppbImportImageSequence_takeSnapshot() {
+  var seen = {};
+  ppbImportImageSequence_snapshotNodeIds(app.project.rootItem, 0, seen);
+  return seen;
+}
+
+function ppbImportImageSequence_collectNew(item, depth, beforeSnapshot, out) {
+  if (depth > 32) {
+    return;
+  }
+  try {
+    if (item.nodeId && !beforeSnapshot[item.nodeId]) {
+      var entry = { name: null, nodeId: null, treePath: null, mediaPath: null };
+      try { entry.name = item.name; } catch (e) { entry.name = null; }
+      try { entry.nodeId = item.nodeId; } catch (e) { entry.nodeId = null; }
+      try { entry.treePath = item.treePath; } catch (e) { entry.treePath = null; }
+      try { entry.mediaPath = item.getMediaPath(); } catch (e) { entry.mediaPath = null; }
+      out.push(entry);
+    }
+  } catch (e) {
+    // ignore
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      ppbImportImageSequence_collectNew(item.children[i], depth + 1, beforeSnapshot, out);
+    }
+  }
+}
+
+function ppbImportImageSequence_resolveBinPath(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 found = null;
+    for (var j = 0; j < current.children.numItems; j++) {
+      var child = current.children[j];
+      if (child.name === segments[i] && typeof ProjectItemType !== "undefined" && child.type === ProjectItemType.BIN) {
+        found = child;
+        break;
+      }
+    }
+    if (!found) {
+      return { error: "bin path segment \"" + segments[i] + "\" not found in \"" + binPath + "\" (target bin must already exist)" };
+    }
+    current = found;
+  }
+  return { bin: current };
+}
+
+function ppb_importImageSequence(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.firstFramePath || typeof args.firstFramePath !== "string") {
+      return JSON.stringify({ ok: false, error: "firstFramePath is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    if (!ppbImportImageSequence_isAllowedExtension(args.firstFramePath)) {
+      return JSON.stringify({
+        ok: false,
+        error: "refusing to import — firstFramePath does not have a recognized image extension (an unsupported " +
+          "format can pop a BLOCKING dialog that freezes the Premiere Bridge panel): " + args.firstFramePath,
+        allowedExtensions: PPB_IMPORT_IMAGE_SEQUENCE_ALLOWED_EXTENSIONS
+      });
+    }
+
+    var targetBin = app.project.rootItem;
+    if (typeof args.targetBinPath === "string" && args.targetBinPath.length > 0) {
+      var resolved = ppbImportImageSequence_resolveBinPath(args.targetBinPath);
+      if (resolved.error) {
+        return JSON.stringify({ ok: false, error: resolved.error });
+      }
+      targetBin = resolved.bin;
+    }
+
+    var before = ppbImportImageSequence_takeSnapshot();
+
+    try {
+      app.project.importFiles([args.firstFramePath], true, targetBin, true);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.project.importFiles() threw: " + e.toString() });
+    }
+
+    var imported = [];
+    ppbImportImageSequence_collectNew(app.project.rootItem, 0, before, imported);
+
+    if (imported.length === 0) {
+      return JSON.stringify({
+        ok: false,
+        error: "importFiles() did not throw, but no new project item appeared (nodeId-diff found nothing)",
+        firstFramePath: args.firstFramePath
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        firstFramePath: args.firstFramePath,
+        targetBinPath: args.targetBinPath || null,
+        asNumberedStills: true,
+        importedCount: imported.length,
+        imported: imported
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}