premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/duplicate-clip.jsx

@@ -0,0 +1,140 @@
+// Command: duplicate-clip → ppb_duplicateClip
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// resolveTimelineClip, serializeTrackItem, secondsToTicksString,
+// timeValueToSeconds, ...) are already defined there.
+//
+// Inserts a NEW instance of the addressed clip's own projectItem onto
+// the SAME track, via the standard-DOM seq.insertClip() (ripple) —
+// PREMIERE_API_NOTES.md's "Clips / TrackItems" insert form, same as
+// add-to-timeline. Ported from leancoderkavy's premiere-pro-mcp
+// duplicate_clip tool, adapted: the reference places the duplicate on
+// trackIndex+1 (a DIFFERENT track) with no position argument; this
+// command instead keeps it on the SAME track (no second track is implied
+// by this panel's clip-addressing convention) and accepts an explicit
+// targetStartSeconds, defaulting to right after the original clip's own
+// end (clip.endSeconds) so it never collides with the original — insert
+// ripples, so there's no destructive overwrite risk either way.
+//
+// MUTATION RULE: verified via the track's clips.numItems increasing by
+// exactly one, plus a best-effort lookup of the newly-inserted clip by
+// matching projectItem + requested start time (serialized the same way
+// as get-full-clip-info).
+
+function ppb_duplicateClip(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 projectItem = null;
+    try { projectItem = clip.projectItem; } catch (e2) { projectItem = null; }
+    if (!projectItem) {
+      return JSON.stringify({ ok: false, error: "could not read the source projectItem for this clip" });
+    }
+    var itemNodeId = null;
+    try { itemNodeId = projectItem.nodeId; } catch (e3) { itemNodeId = null; }
+
+    var originalBefore = serializeTrackItem(clip, args.trackIndex, args.clipIndex);
+
+    var targetStartSeconds;
+    if (typeof args.targetStartSeconds === "number") {
+      targetStartSeconds = args.targetStartSeconds;
+    } else if (originalBefore.endSeconds !== null) {
+      targetStartSeconds = originalBefore.endSeconds;
+    } else {
+      return JSON.stringify({ ok: false, error: "targetStartSeconds was not given and the original clip's endSeconds could not be read to default it" });
+    }
+
+    var trackCollection = args.trackType === "video" ? seq.videoTracks : seq.audioTracks;
+    var track = trackCollection[args.trackIndex];
+    var clipCountBefore = null;
+    try { clipCountBefore = track.clips.numItems; } catch (e4) { clipCountBefore = null; }
+
+    var vIdx = args.trackType === "video" ? args.trackIndex : -1;
+    var aIdx = args.trackType === "audio" ? args.trackIndex : -1;
+    var startTicks = secondsToTicksString(targetStartSeconds);
+
+    try {
+      seq.insertClip(projectItem, startTicks, vIdx, aIdx);
+    } catch (e5) {
+      return JSON.stringify({ ok: false, error: "seq.insertClip() failed: " + e5.toString() });
+    }
+
+    var clipCountAfter = null;
+    try { clipCountAfter = track.clips.numItems; } catch (e6) { clipCountAfter = null; }
+    var verified = clipCountBefore !== null && clipCountAfter !== null && clipCountAfter === clipCountBefore + 1;
+
+    var newClip = null;
+    var toleranceSeconds = 0.1;
+    try {
+      for (var c = 0; c < track.clips.numItems; c++) {
+        var candidate = track.clips[c];
+        var candNodeId = null;
+        try { candNodeId = candidate.projectItem.nodeId; } catch (e7) { candNodeId = null; }
+        if (candNodeId !== itemNodeId) {
+          continue;
+        }
+        var candStart = null;
+        try { candStart = timeValueToSeconds(candidate.start); } catch (e8) { candStart = null; }
+        if (candStart !== null && Math.abs(candStart - targetStartSeconds) <= toleranceSeconds) {
+          newClip = serializeTrackItem(candidate, args.trackIndex, c);
+          break;
+        }
+      }
+    } catch (e9) {
+      newClip = null;
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        sourceClipIndex: args.clipIndex,
+        targetStartSeconds: targetStartSeconds,
+        originalClip: originalBefore,
+        newClip: newClip,
+        clipCountBefore: clipCountBefore,
+        clipCountAfter: clipCountAfter,
+        verified: verified
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/duplicate-sequence.jsx

@@ -0,0 +1,150 @@
+// Command: duplicate-sequence → ppb_duplicateSequence
+// 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 duplicate_sequence
+// tool. Duplicates a sequence via `seq.clone()` per PREMIERE_API_NOTES.md's
+// Sequences table. clone() gives the copy a Premiere-generated default name
+// (there is no confirmed API to pass a name directly to it) — this command
+// renames the resulting sequence (and its Project-panel item, per the
+// "renaming gotcha" documented alongside seq.clone() in
+// PREMIERE_API_NOTES.md — seq.name = x does NOT propagate to the panel)
+// afterward, same pattern as nest-clips.jsx.
+//
+// Verification: the sequence count increases by exactly one, and the new
+// sequence is identified as whichever sequence appeared that wasn't in the
+// "before" snapshot (clone()'s own return value is not trusted, matching
+// every other QE/structural command in this panel).
+function ppbDupSeq_snapshotIds(project) {
+  var ids = {};
+  for (var i = 0; i < project.sequences.numSequences; i++) {
+    var s = project.sequences[i];
+    var id = null;
+    try { id = s.sequenceID; } catch (e) { id = null; }
+    ids[id !== null ? id : ("idx" + i)] = true;
+  }
+  return ids;
+}
+
+function ppb_duplicateSequence(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" });
+    }
+    if (!args.newName || typeof args.newName !== "string") {
+      return JSON.stringify({ ok: false, error: "newName is required" });
+    }
+
+    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" });
+      }
+    }
+
+    var numSequencesBefore = app.project.sequences.numSequences;
+    var idsBefore = ppbDupSeq_snapshotIds(app.project);
+
+    var cloneError = null;
+    try {
+      seq.clone();
+    } catch (e) {
+      cloneError = e.toString();
+    }
+
+    var numSequencesAfter = app.project.sequences.numSequences;
+
+    if (cloneError !== null || numSequencesAfter <= numSequencesBefore) {
+      return JSON.stringify({
+        ok: false,
+        error: cloneError !== null
+          ? ("seq.clone() failed: " + cloneError)
+          : "clone() did not throw, but the project's sequence count did not increase",
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter
+      });
+    }
+
+    var newSeq = null;
+    for (var i = 0; i < app.project.sequences.numSequences; i++) {
+      var candidate = app.project.sequences[i];
+      var candidateId = null;
+      try { candidateId = candidate.sequenceID; } catch (e) { candidateId = null; }
+      var key = candidateId !== null ? candidateId : ("idx" + i);
+      if (!idsBefore[key]) {
+        newSeq = candidate;
+        break;
+      }
+    }
+
+    if (!newSeq) {
+      return JSON.stringify({
+        ok: false,
+        error: "sequence count increased but the cloned sequence could not be identified",
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter
+      });
+    }
+
+    var previousName = null;
+    try { previousName = newSeq.name; } catch (e) { previousName = null; }
+
+    var renameNote = null;
+    try {
+      newSeq.name = args.newName;
+    } catch (e) {
+      renameNote = "renaming the sequence object failed: " + e.toString();
+    }
+    // "renaming gotcha" per PREMIERE_API_NOTES.md: seq.name = x does not
+    // propagate to the Project panel item — find and rename it too.
+    try {
+      var rootChildren = app.project.rootItem.children;
+      for (var ri = 0; ri < rootChildren.numItems; ri++) {
+        var it = rootChildren[ri];
+        var itSeq = null;
+        try { itSeq = it.getSequence ? it.getSequence() : null; } catch (e2) { itSeq = null; }
+        if (itSeq && itSeq.sequenceID === newSeq.sequenceID) {
+          it.name = args.newName;
+          break;
+        }
+      }
+    } catch (e3) {
+      // best-effort — panel-item rename is a bonus, not required for success
+    }
+
+    var readBackName = null;
+    try { readBackName = newSeq.name; } catch (e4) { readBackName = null; }
+    var renamed = readBackName === args.newName;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sourceSequenceName: seq.name,
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter,
+        previousDefaultName: previousName,
+        newSequenceName: newSeq.name,
+        newSequenceID: newSeq.sequenceID,
+        requestedName: args.newName,
+        renamed: renamed,
+        renameNote: renameNote
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/encode-file.jsx

@@ -0,0 +1,86 @@
+// Command: encode-file → ppb_encodeFile
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Queues an EXTERNAL file (not a project item, not a sequence — a path on
+// disk not necessarily imported into this project at all) for export in
+// Adobe Media Encoder via app.encoder.launchEncoder() + encodeFile() +
+// startBatch(), mirroring the reference tool this ports (leancoderkavy's
+// premiere-pro-mcp encode_file). **Fire-and-forget** — same no-progress-API
+// caveat as add-to-render-queue/encode-project-item: encodeFile() returns
+// as soon as the job is queued, so this command cannot verify the output
+// file exists.
+
+function ppb_encodeFile(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.inputPath || typeof args.inputPath !== "string") {
+      return JSON.stringify({ ok: false, error: "inputPath is required" });
+    }
+    if (!args.outputPath || typeof args.outputPath !== "string") {
+      return JSON.stringify({ ok: false, error: "outputPath is required" });
+    }
+    if (!args.presetPath || typeof args.presetPath !== "string") {
+      return JSON.stringify({ ok: false, error: "presetPath is required (an absolute .epr file path)" });
+    }
+
+    var inputFile = new File(args.inputPath);
+    if (!inputFile.exists) {
+      return JSON.stringify({ ok: false, error: "input file not found: " + args.inputPath });
+    }
+    var presetFile = new File(args.presetPath);
+    if (!presetFile.exists) {
+      return JSON.stringify({ ok: false, error: "preset file not found: " + args.presetPath });
+    }
+
+    var startBatch = args.startBatch === true;
+
+    if (!app.encoder) {
+      return JSON.stringify({ ok: false, error: "Adobe Media Encoder is not available (app.encoder is undefined)" });
+    }
+
+    try {
+      app.encoder.launchEncoder();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.encoder.launchEncoder() failed: " + e.toString() });
+    }
+
+    try {
+      // Matches the reference tool's own call shape: encodeFile(input,
+      // output, preset, removeOnCompletion01, srcIn, srcOut) — srcIn/srcOut
+      // are left undefined here (this command takes no in/out-point args
+      // per spec), encoding the entire input file.
+      app.encoder.encodeFile(args.inputPath, args.outputPath, args.presetPath, 1 /* removeOnCompletion */);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.encoder.encodeFile() failed: " + e.toString() });
+    }
+
+    if (startBatch) {
+      try {
+        app.encoder.startBatch();
+      } catch (e) {
+        return JSON.stringify({ ok: false, error: "job was queued but app.encoder.startBatch() failed: " + e.toString() });
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        presetPath: args.presetPath,
+        startBatch: startBatch,
+        note: "fire-and-forget: the job is queued in Adobe Media Encoder, not exported synchronously — " +
+          "there is no progress API, so this result does NOT confirm the output file exists yet."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/encode-project-item.jsx

@@ -0,0 +1,145 @@
+// Command: encode-project-item → ppb_encodeProjectItem
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Queues a PROJECT ITEM (not a sequence) for export in Adobe Media Encoder
+// via app.encoder.launchEncoder() + encodeProjectItem() + startBatch(),
+// mirroring the reference tool this ports (leancoderkavy's
+// premiere-pro-mcp encode_project_item). **Fire-and-forget** — same no-
+// progress-API caveat as add-to-render-queue: encodeProjectItem() returns
+// as soon as the job is queued, so this command cannot verify the output
+// file exists.
+
+// Project-item addressing (nodeId or name) — duplicated per command file
+// since each loads independently; same walk as get-item-metadata.jsx's
+// ppbFindItemGetItemMetadata_* helpers, prefixed for this file.
+function ppbFindItemEncodeProjectItem_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 = ppbFindItemEncodeProjectItem_walk(item.children[i], args, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbFindItemEncodeProjectItem_resolve(args) {
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var found = ppbFindItemEncodeProjectItem_walk(root.children[i], args, 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function ppb_encodeProjectItem(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 to address the project item" });
+    }
+    if (!args.outputPath || typeof args.outputPath !== "string") {
+      return JSON.stringify({ ok: false, error: "outputPath is required" });
+    }
+    if (!args.presetPath || typeof args.presetPath !== "string") {
+      return JSON.stringify({ ok: false, error: "presetPath is required (an absolute .epr file path)" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = ppbFindItemEncodeProjectItem_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 presetFile = new File(args.presetPath);
+    if (!presetFile.exists) {
+      return JSON.stringify({ ok: false, error: "preset file not found: " + args.presetPath });
+    }
+
+    var startBatch = args.startBatch === true;
+
+    if (!app.encoder) {
+      return JSON.stringify({ ok: false, error: "Adobe Media Encoder is not available (app.encoder is undefined)" });
+    }
+
+    try {
+      app.encoder.launchEncoder();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.encoder.launchEncoder() failed: " + e.toString() });
+    }
+
+    var itemName = null;
+    try { itemName = item.name; } catch (e) { itemName = null; }
+
+    try {
+      app.encoder.encodeProjectItem(
+        item,
+        args.outputPath,
+        args.presetPath,
+        typeof app.encoder.ENCODE_IN_TO_OUT !== "undefined" ? app.encoder.ENCODE_IN_TO_OUT : 1,
+        1 /* removeOnCompletion */
+      );
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.encoder.encodeProjectItem() failed: " + e.toString() });
+    }
+
+    if (startBatch) {
+      try {
+        app.encoder.startBatch();
+      } catch (e) {
+        return JSON.stringify({ ok: false, error: "job was queued but app.encoder.startBatch() failed: " + e.toString() });
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        item: itemName,
+        nodeId: hasNodeId ? args.nodeId : (item.nodeId || null),
+        outputPath: args.outputPath,
+        presetPath: args.presetPath,
+        startBatch: startBatch,
+        note: "fire-and-forget: the job is queued in Adobe Media Encoder, not exported synchronously — " +
+          "there is no progress API, so this result does NOT confirm the output file exists yet."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/export-aaf.jsx

@@ -0,0 +1,77 @@
+// Command: export-aaf → ppb_exportAaf
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// Exports the given (or active) sequence as an AAF file via
+// seq.exportAsAAF(path, mixdown01, mono01, rate, bits)
+// (PREMIERE_API_NOTES.md's "FCP XML / AAF / OMF / EDL" line) — synchronous,
+// no AME dependency. Defaults mirror the reference tool this ports
+// (leancoderkavy's premiere-pro-mcp export_aaf): mixdown=true,
+// explodeToMono=false, sampleRate=48000, bitsPerSample=16.
+
+function ppb_exportAaf(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.outputPath || typeof args.outputPath !== "string") {
+      return JSON.stringify({ ok: false, error: "outputPath 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 mixdown = args.mixdown !== false; // default true
+    var mono = args.mono === true; // default false
+    var rate = typeof args.rate === "number" ? args.rate : 48000;
+    var bits = typeof args.bits === "number" ? args.bits : 16;
+
+    var result = {
+      sequenceName: seq.name,
+      outputPath: args.outputPath,
+      mixdown: mixdown,
+      mono: mono,
+      rate: rate,
+      bits: bits
+    };
+
+    try {
+      seq.exportAsAAF(args.outputPath, mixdown ? 1 : 0, mono ? 1 : 0, rate, bits);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "exportAsAAF failed: " + e.toString() });
+    }
+
+    var outFile = new File(args.outputPath);
+    if (!outFile.exists) {
+      return JSON.stringify({
+        ok: false,
+        error: "exportAsAAF ran but no file was written to " + args.outputPath
+      });
+    }
+
+    result.fileSizeBytes = outFile.length;
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

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

@@ -0,0 +1,65 @@
+// Command: export-fcp-xml → ppb_exportFcpXml
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// Exports the given (or active) sequence as a Final Cut Pro XML file via
+// seq.exportAsFinalCutProXML(path) (PREMIERE_API_NOTES.md's "FCP XML / AAF
+// / OMF / EDL" line) — synchronous, no AME dependency.
+
+function ppb_exportFcpXml(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.outputPath || typeof args.outputPath !== "string") {
+      return JSON.stringify({ ok: false, error: "outputPath 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 result = {
+      sequenceName: seq.name,
+      outputPath: args.outputPath
+    };
+
+    try {
+      seq.exportAsFinalCutProXML(args.outputPath);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "exportAsFinalCutProXML failed: " + e.toString() });
+    }
+
+    var outFile = new File(args.outputPath);
+    if (!outFile.exists) {
+      return JSON.stringify({
+        ok: false,
+        error: "exportAsFinalCutProXML ran but no file was written to " + args.outputPath
+      });
+    }
+
+    result.fileSizeBytes = outFile.length;
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}