premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/roll-edit.jsx

@@ -0,0 +1,162 @@
+// Command: roll-edit → ppb_rollEdit
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, resolveTimelineClip,
+// resolveQeClip, serializeTrackItem, TICKS_PER_SECOND, ...) are already
+// defined there.
+//
+// Rolls the edit point between the addressed clip and its neighbor —
+// moves the shared cut point in time WITHOUT changing the overall
+// sequence duration (one clip's out point and the next clip's in point
+// move together). Ported from leancoderkavy's premiere-pro-mcp
+// `roll_edit` tool (advanced.ts: `qeClip.roll(offsetTicksString)`), whose
+// signature is UNCONFIRMED on this build (`roll` is on our own reflect
+// list per QE_DOM_NOTES.md/PREMIERE_API_NOTES.md, but never live-called)
+// — every plausible argument form is tried in turn (ticks string, then a
+// raw seconds number, then a Time object), recording an `attempts` array,
+// and success is judged by an actual before/after change in the clip's
+// own end time, never by whether the call merely avoided throwing.
+// Positive offsetSeconds rolls the edit point later (per the reference
+// tool's convention); negative rolls it earlier.
+
+function ppbRollEdit_offsetForms(offsetSeconds) {
+  var ticksString = String(Math.round(offsetSeconds * TICKS_PER_SECOND));
+  var timeObj = null;
+  try {
+    timeObj = new Time();
+    timeObj.seconds = offsetSeconds;
+  } catch (e) {
+    timeObj = null;
+  }
+  var forms = [
+    { label: "ticksString", value: ticksString },
+    { label: "seconds", value: offsetSeconds }
+  ];
+  if (timeObj !== null) {
+    forms.push({ label: "TimeObject", value: timeObj });
+  }
+  return forms;
+}
+
+function ppb_rollEdit(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.offsetSeconds !== "number" || isNaN(args.offsetSeconds) || args.offsetSeconds === 0) {
+      return JSON.stringify({ ok: false, error: "offsetSeconds must be a non-zero number" });
+    }
+
+    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 before = serializeTrackItem(resolved.clip, args.trackIndex, args.clipIndex);
+
+    try {
+      ensureQEEnabled();
+      activateSequenceForQE(seq);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.enableQE()/sequence activation failed: " + e.toString() });
+    }
+    if (typeof qe === "undefined" || !qe.project) {
+      return JSON.stringify({ ok: false, error: "QE DOM not available after enableQE()" });
+    }
+
+    var qeSeq;
+    try {
+      qeSeq = qe.project.getActiveSequence();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "qe.project.getActiveSequence() failed: " + e.toString() });
+    }
+    var qeResolved = resolveQeClip(qeSeq, args.trackType, args.trackIndex, args.clipIndex);
+    if (qeResolved.error) {
+      return JSON.stringify({ ok: false, error: qeResolved.error });
+    }
+    var qeClip = qeResolved.qeClip;
+
+    if (typeof qeClip.roll !== "function") {
+      return JSON.stringify({ ok: false, error: "qeClip.roll is not available on this Premiere build" });
+    }
+
+    var attempts = [];
+    var forms = ppbRollEdit_offsetForms(args.offsetSeconds);
+    var succeeded = false;
+    var formUsed = null;
+    for (var i = 0; i < forms.length && !succeeded; i++) {
+      try {
+        qeClip.roll(forms[i].value);
+        attempts.push({ form: forms[i].label, success: true });
+        succeeded = true;
+        formUsed = forms[i].label;
+      } catch (e) {
+        attempts.push({ form: forms[i].label, success: false, error: e.toString() });
+      }
+    }
+
+    if (!succeeded) {
+      return JSON.stringify({
+        ok: false,
+        error: "qeClip.roll() failed with every argument form tried",
+        attempts: attempts
+      });
+    }
+
+    var afterResolved = resolveTimelineClip(seq, args.trackType, args.trackIndex, args.clipIndex);
+    var after = afterResolved.clip ? serializeTrackItem(afterResolved.clip, args.trackIndex, args.clipIndex) : null;
+
+    var endDelta = (after && before && after.endSeconds !== null && before.endSeconds !== null)
+      ? (after.endSeconds - before.endSeconds)
+      : null;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        requestedOffsetSeconds: args.offsetSeconds,
+        formUsed: formUsed,
+        attempts: attempts,
+        before: before,
+        after: after,
+        endSecondsDelta: endDelta,
+        verified: endDelta !== null && Math.abs(endDelta - args.offsetSeconds) < 0.5,
+        note: "verified compares the clip's own end-time shift against the requested offset within half a second — roll's exact per-neighbor semantics are unconfirmed on this build (see PREMIERE_API_NOTES.md)."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/save-project-as.jsx

@@ -0,0 +1,55 @@
+// Command: save-project-as → ppb_saveProjectAs
+// 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 save_project_as.
+// Calls app.project.saveAs(path). NOTE: this switches the currently OPEN
+// project (app.project) to point at the new file — it is not a "save a
+// copy" operation. Verified by reading app.project.path back afterward
+// and confirming it now matches the requested path.
+
+function ppb_saveProjectAs(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.path || typeof args.path !== "string") {
+      return JSON.stringify({ ok: false, error: "path is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    try {
+      app.project.saveAs(args.path);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.project.saveAs() failed: " + e.toString() });
+    }
+
+    var newPath = null;
+    var newName = null;
+    try { newPath = app.project.path; } catch (e) { newPath = null; }
+    try { newName = app.project.name; } catch (e) { newName = null; }
+
+    var verified = newPath !== null && newPath === args.path;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        saved: true,
+        requestedPath: args.path,
+        path: newPath,
+        name: newName,
+        verified: verified,
+        note: "saveAs() switches the currently open project to the new file — the original file on disk is untouched but is no longer what app.project refers to"
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/save-project.jsx

@@ -0,0 +1,57 @@
+// Command: save-project → ppb_saveProject
+// 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 save_project.
+// Calls app.project.save() (no args — saves to the project's current
+// path). Verification is best-effort: if this Premiere build exposes
+// project.isDirty() (unconfirmed, not documented in
+// PREMIERE_API_NOTES.md), it's read before and after and the command
+// only reports success if it went from dirty to clean; if isDirty isn't
+// available, verification degrades to call-level only (no throw), and
+// `verified` is reported as null with a note rather than a false claim.
+
+function ppb_saveProject(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var hasIsDirty = typeof app.project.isDirty === "function";
+    var dirtyBefore = null;
+    if (hasIsDirty) {
+      try { dirtyBefore = app.project.isDirty(); } catch (e) { dirtyBefore = null; }
+    }
+
+    try {
+      app.project.save();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.project.save() failed: " + e.toString() });
+    }
+
+    var dirtyAfter = null;
+    if (hasIsDirty) {
+      try { dirtyAfter = app.project.isDirty(); } catch (e) { dirtyAfter = null; }
+    }
+
+    var verified = null;
+    var note = null;
+    if (hasIsDirty && dirtyBefore !== null && dirtyAfter !== null) {
+      verified = dirtyAfter === false;
+    } else {
+      note = "isDirty() is not available (or not readable) on this Premiere build — verification is call-level only (save() did not throw)";
+    }
+
+    var name = null;
+    var path = null;
+    try { name = app.project.name; } catch (e) { name = null; }
+    try { path = app.project.path; } catch (e) { path = null; }
+
+    return JSON.stringify({
+      ok: true,
+      result: { saved: true, name: name, path: path, verified: verified, note: note }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/scene-edit-detection.jsx

@@ -0,0 +1,128 @@
+// Command: scene-edit-detection → ppb_sceneEditDetection
+// 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 advanced.ts
+// scene_edit_detection tool, expanded per PREMIERE_API_NOTES.md's fuller
+// signature: `seq.performSceneEditDetectionOnSelection(mode, applyToLinked
+// AudioBool, sensitivity)` where mode is "ApplyCuts"|"CreateMarkers" and
+// sensitivity is "Low"|"Medium"|"High" (the reference tool's own handler
+// calls the zero-arg form, dropping all three).
+//
+// ⚠️ OPERATES ON THE CURRENT SELECTION, not the whole sequence — same
+// selection precondition as nest-clips.jsx. This command refuses outright
+// if nothing is selected rather than letting Premiere silently no-op, and
+// reports selectedClipCount so callers know what was actually processed.
+// Marker counts are read before/after only for "CreateMarkers" mode;
+// "ApplyCuts" mode's razor-cut effect is not independently verified here
+// (scene detection can run asynchronously, same caveat as
+// stabilize-clip.jsx's Warp Stabilizer analysis).
+function ppb_sceneEditDetection(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var validModes = { ApplyCuts: true, CreateMarkers: true };
+    if (!args.mode || !validModes[args.mode]) {
+      return JSON.stringify({ ok: false, error: "mode must be one of ApplyCuts, CreateMarkers" });
+    }
+    if (typeof args.applyToLinkedAudio !== "boolean") {
+      return JSON.stringify({ ok: false, error: "applyToLinkedAudio (boolean) is required" });
+    }
+    var validSensitivities = { Low: true, Medium: true, High: true };
+    if (!args.sensitivity || !validSensitivities[args.sensitivity]) {
+      return JSON.stringify({ ok: false, error: "sensitivity must be one of Low, Medium, High" });
+    }
+
+    var seq;
+    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" });
+      }
+    }
+    if (app.project.activeSequence !== seq) {
+      app.project.activeSequence = seq;
+    }
+
+    var selectedCount = 0;
+    function countSelected(tracks) {
+      for (var t = 0; t < tracks.numTracks; t++) {
+        for (var c = 0; c < tracks[t].clips.numItems; c++) {
+          var isSel = false;
+          try { isSel = tracks[t].clips[c].isSelected(); } catch (e) { isSel = false; }
+          if (isSel) {
+            selectedCount++;
+          }
+        }
+      }
+    }
+    countSelected(seq.videoTracks);
+    countSelected(seq.audioTracks);
+
+    if (selectedCount === 0) {
+      return JSON.stringify({
+        ok: false,
+        error: "no clips selected — this operation runs on the current SELECTION (select clips first, e.g. select-clips-by-name/select-all-clips)"
+      });
+    }
+
+    function countMarkers() {
+      var n = 0;
+      var m = seq.markers.getFirstMarker();
+      while (m) {
+        n++;
+        m = seq.markers.getNextMarker(m);
+      }
+      return n;
+    }
+
+    var markerCountBefore = null;
+    try { markerCountBefore = countMarkers(); } catch (e) { markerCountBefore = null; }
+
+    try {
+      seq.performSceneEditDetectionOnSelection(args.mode, args.applyToLinkedAudio, args.sensitivity);
+    } catch (e) {
+      return JSON.stringify({
+        ok: false,
+        error: "seq.performSceneEditDetectionOnSelection() failed: " + e.toString(),
+        selectedClipCount: selectedCount
+      });
+    }
+
+    var markerCountAfter = null;
+    if (args.mode === "CreateMarkers") {
+      try { markerCountAfter = countMarkers(); } catch (e) { markerCountAfter = null; }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        mode: args.mode,
+        applyToLinkedAudio: args.applyToLinkedAudio,
+        sensitivity: args.sensitivity,
+        selectedClipCount: selectedCount,
+        markerCountBefore: markerCountBefore,
+        markerCountAfter: markerCountAfter,
+        note: "operates on the current SELECTION, not the whole sequence. ApplyCuts mode's razor-cut effect is not independently verified here (scene detection may run asynchronously); markerCountAfter is only populated for CreateMarkers mode."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/search-project-items.jsx

@@ -0,0 +1,180 @@
+// Command: search-project-items → ppb_searchProjectItems
+// 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 the whole project item tree (same shape as
+// list-project-items.jsx's walk), skipping bins for matching purposes but
+// always recursing through them. A matching item must satisfy ALL given
+// filters. Helper names are prefixed ppbSearchItems_ to avoid colliding
+// with same-purpose helpers in other lazily-loaded command files
+// evaluated into this same global context.
+
+function ppbSearchItems_extOf(mediaPath) {
+  if (!mediaPath || typeof mediaPath !== "string") {
+    return null;
+  }
+  var dot = mediaPath.lastIndexOf(".");
+  if (dot === -1 || dot === mediaPath.length - 1) {
+    return null;
+  }
+  return mediaPath.substring(dot + 1).toLowerCase();
+}
+
+function ppbSearchItems_normalizeExtFilter(extension) {
+  var e = extension.toLowerCase();
+  if (e.charAt(0) === ".") {
+    e = e.substring(1);
+  }
+  return e;
+}
+
+function ppbSearchItems_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. errorHolder.error is set (and
+// the walk aborted) only when a colorLabel filter was requested AND
+// getColorLabel() isn't available on this Premiere build.
+function ppbSearchItems_walk(item, parentPath, depth, filters, results, errorHolder) {
+  if (depth > 32 || errorHolder.error) {
+    return;
+  }
+
+  var treePath = null;
+  try {
+    treePath = item.treePath;
+  } catch (e) {
+    treePath = null;
+  }
+  if (!treePath) {
+    treePath = parentPath + "/" + item.name;
+  }
+
+  var isBin = ppbSearchItems_isBin(item);
+
+  if (!isBin) {
+    var mediaPath = null;
+    try {
+      mediaPath = item.getMediaPath();
+    } catch (e) {
+      mediaPath = null;
+    }
+
+    var isOffline = false;
+    try {
+      isOffline = item.isOffline();
+    } catch (e) {
+      isOffline = false;
+    }
+
+    var colorLabel = null;
+    var colorLabelAvailable = true;
+    try {
+      colorLabel = item.getColorLabel();
+    } catch (e) {
+      colorLabelAvailable = false;
+      colorLabel = null;
+    }
+
+    if (filters.colorLabel !== null && !colorLabelAvailable) {
+      errorHolder.error = "getColorLabel is not available on this Premiere build";
+      return;
+    }
+
+    var matches = true;
+
+    if (filters.nameContains !== null && item.name.toLowerCase().indexOf(filters.nameContains) === -1) {
+      matches = false;
+    }
+
+    if (matches && filters.extension !== null) {
+      var ext = ppbSearchItems_extOf(mediaPath);
+      if (ext !== filters.extension) {
+        matches = false;
+      }
+    }
+
+    if (matches && filters.offlineOnly === true && !isOffline) {
+      matches = false;
+    }
+
+    if (matches && filters.colorLabel !== null && colorLabel !== filters.colorLabel) {
+      matches = false;
+    }
+
+    if (matches) {
+      results.push({
+        name: item.name,
+        treePath: treePath,
+        nodeId: item.nodeId,
+        mediaPath: mediaPath,
+        isOffline: isOffline,
+        colorLabel: colorLabel
+      });
+    }
+  }
+
+  if (isBin && item.children) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      ppbSearchItems_walk(item.children[i], treePath, depth + 1, filters, results, errorHolder);
+      if (errorHolder.error) {
+        return;
+      }
+    }
+  }
+}
+
+function ppb_searchProjectItems(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var hasNameContains = typeof args.nameContains === "string" && args.nameContains.length > 0;
+    var hasExtension = typeof args.extension === "string" && args.extension.length > 0;
+    var hasOfflineOnly = args.offlineOnly === true;
+    var hasColorLabel = typeof args.colorLabel === "number";
+
+    if (!hasNameContains && !hasExtension && !hasOfflineOnly && !hasColorLabel) {
+      return JSON.stringify({ ok: false, error: "at least one filter is required (nameContains, extension, offlineOnly, colorLabel)" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var filters = {
+      nameContains: hasNameContains ? args.nameContains.toLowerCase() : null,
+      extension: hasExtension ? ppbSearchItems_normalizeExtFilter(args.extension) : null,
+      offlineOnly: hasOfflineOnly,
+      colorLabel: hasColorLabel ? args.colorLabel : null
+    };
+
+    var results = [];
+    var errorHolder = { error: null };
+    var root = app.project.rootItem;
+    for (var i = 0; i < root.children.numItems; i++) {
+      ppbSearchItems_walk(root.children[i], "", 1, filters, results, errorHolder);
+      if (errorHolder.error) {
+        break;
+      }
+    }
+
+    if (errorHolder.error) {
+      return JSON.stringify({ ok: false, error: errorHolder.error });
+    }
+
+    return JSON.stringify({ ok: true, result: { items: results, count: results.length } });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/select-all-clips.jsx

@@ -0,0 +1,107 @@
+// Command: select-all-clips → ppb_selectAllClips
+// 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 only (clip.setSelected(true, true)) — no QE needed. Ported
+// from leancoderkavy's premiere-pro-mcp `select_all_clips` tool
+// (selection.ts). Mutation — verified via seq.getSelection() afterward.
+
+function ppb_selectAllClipsCollectSelection(seq) {
+  var sel = null;
+  try {
+    sel = seq.getSelection();
+  } catch (e) {
+    sel = null;
+  }
+  var selCount = 0;
+  if (sel) {
+    if (typeof sel.numItems === "number") {
+      selCount = sel.numItems;
+    } else if (typeof sel.length === "number") {
+      selCount = sel.length;
+    }
+  }
+  var selectedClips = [];
+  var cap = selCount > 20 ? 20 : selCount;
+  for (var i = 0; i < cap; 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 = timeValueToSeconds(item.start); } catch (e) { entry.startSeconds = null; }
+    try { entry.endSeconds = timeValueToSeconds(item.end); } catch (e) { entry.endSeconds = null; }
+    try { entry.nodeId = item.nodeId; } catch (e) { entry.nodeId = null; }
+    selectedClips.push(entry);
+  }
+  var result = { selectedCount: selCount, selectedClips: selectedClips };
+  if (selCount > 20) {
+    result.truncated = true;
+  }
+  return result;
+}
+
+function ppb_selectAllClips(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 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" });
+      }
+    }
+
+    function selectAllInTracks(tracks) {
+      for (var t = 0; t < tracks.numTracks; t++) {
+        var track = tracks[t];
+        for (var c = 0; c < track.clips.numItems; c++) {
+          try { track.clips[c].setSelected(true, true); } catch (e) { /* best-effort */ }
+        }
+      }
+    }
+
+    if (trackType !== "audio") {
+      selectAllInTracks(seq.videoTracks);
+    }
+    if (trackType !== "video") {
+      selectAllInTracks(seq.audioTracks);
+    }
+
+    var selectionResult = ppb_selectAllClipsCollectSelection(seq);
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: trackType
+    };
+    result.selectedCount = selectionResult.selectedCount;
+    result.selectedClips = selectionResult.selectedClips;
+    if (selectionResult.truncated) {
+      result.truncated = true;
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}