premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/copy-effect-values.jsx

@@ -0,0 +1,183 @@
+// Command: copy-effect-values → ppb_copyEffectValues
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// resolveTimelineClip, findClipComponent, valuesApproximatelyEqual, ...)
+// are already defined there.
+//
+// Ports leancoderkavy's clipboard.ts copy_effect_values: the named effect
+// must ALREADY be applied on BOTH clips (no QE apply step here, unlike
+// copy-effects-between-clips) — only property VALUES are copied across via
+// getValue()/setValue(), matched by displayName. Standard-DOM only, no QE
+// needed, so source and target may be on different sequences with no
+// active-sequence juggling.
+function ppb_copyEffectValues(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (args.sourceTrackType !== "video" && args.sourceTrackType !== "audio") {
+      return JSON.stringify({ ok: false, error: "sourceTrackType must be \"video\" or \"audio\"" });
+    }
+    if (args.targetTrackType !== "video" && args.targetTrackType !== "audio") {
+      return JSON.stringify({ ok: false, error: "targetTrackType must be \"video\" or \"audio\"" });
+    }
+    var indexFields = ["sourceTrackIndex", "sourceClipIndex", "targetTrackIndex", "targetClipIndex"];
+    for (var f = 0; f < indexFields.length; f++) {
+      var v = args[indexFields[f]];
+      if (typeof v !== "number" || v < 0 || Math.floor(v) !== v) {
+        return JSON.stringify({ ok: false, error: indexFields[f] + " must be a non-negative integer" });
+      }
+    }
+    if (typeof args.effectName !== "string" || !args.effectName) {
+      return JSON.stringify({ ok: false, error: "effectName must be a non-empty string" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    function resolveSeq(name) {
+      if (name && typeof name === "string") {
+        var found = findSequenceByName(name);
+        if (!found) {
+          return { error: "no sequence named \"" + name + "\" is open" };
+        }
+        return { seq: found };
+      }
+      var active = app.project.activeSequence;
+      if (!active) {
+        return { error: "no active sequence, and no sequenceName given" };
+      }
+      return { seq: active };
+    }
+
+    var srcSeqResolved = resolveSeq(args.sourceSequenceName);
+    if (srcSeqResolved.error) {
+      return JSON.stringify({ ok: false, error: "source: " + srcSeqResolved.error });
+    }
+    var srcSeq = srcSeqResolved.seq;
+
+    var tgtSeqResolved = resolveSeq(args.targetSequenceName);
+    if (tgtSeqResolved.error) {
+      return JSON.stringify({ ok: false, error: "target: " + tgtSeqResolved.error });
+    }
+    var tgtSeq = tgtSeqResolved.seq;
+
+    var srcResolvedClip = resolveTimelineClip(srcSeq, args.sourceTrackType, args.sourceTrackIndex, args.sourceClipIndex);
+    if (srcResolvedClip.error) {
+      return JSON.stringify({ ok: false, error: "source: " + srcResolvedClip.error });
+    }
+    var srcClip = srcResolvedClip.clip;
+    var srcClipName = null;
+    try { srcClipName = srcClip.name; } catch (e) { srcClipName = null; }
+
+    var tgtResolvedClip = resolveTimelineClip(tgtSeq, args.targetTrackType, args.targetTrackIndex, args.targetClipIndex);
+    if (tgtResolvedClip.error) {
+      return JSON.stringify({ ok: false, error: "target: " + tgtResolvedClip.error });
+    }
+    var tgtClip = tgtResolvedClip.clip;
+    var tgtClipName = null;
+    try { tgtClipName = tgtClip.name; } catch (e) { tgtClipName = null; }
+
+    var srcComp = findClipComponent(srcClip, null, [args.effectName]);
+    if (!srcComp) {
+      return JSON.stringify({ ok: false, error: "effect \"" + args.effectName + "\" not found on the source clip" });
+    }
+    var tgtComp = findClipComponent(tgtClip, null, [args.effectName]);
+    if (!tgtComp) {
+      return JSON.stringify({ ok: false, error: "effect \"" + args.effectName + "\" not found on the target clip" });
+    }
+
+    var numSrcProps = 0;
+    try { numSrcProps = srcComp.properties.numItems; } catch (e) { numSrcProps = 0; }
+    var numTgtProps = 0;
+    try { numTgtProps = tgtComp.properties.numItems; } catch (e) { numTgtProps = 0; }
+
+    var properties = [];
+    var copiedCount = 0;
+
+    for (var sp = 0; sp < numSrcProps; sp++) {
+      var srcProp = srcComp.properties[sp];
+      var spName = null;
+      try { spName = srcProp.displayName; } catch (e2) { spName = null; }
+      if (!spName) {
+        continue;
+      }
+
+      var matchedTgtProp = null;
+      for (var tp = 0; tp < numTgtProps; tp++) {
+        var candidate = tgtComp.properties[tp];
+        var tpName = null;
+        try { tpName = candidate.displayName; } catch (e3) { tpName = null; }
+        if (tpName === spName) {
+          matchedTgtProp = candidate;
+          break;
+        }
+      }
+      if (!matchedTgtProp) {
+        properties.push({ displayName: spName, copied: false, error: "no matching property on target clip's effect" });
+        continue;
+      }
+
+      var previousValue = null;
+      try { previousValue = matchedTgtProp.getValue(); } catch (e4) { previousValue = null; }
+      var requestedValue = null;
+      try { requestedValue = srcProp.getValue(); } catch (e5) { requestedValue = null; }
+
+      var copied = false;
+      var errorMsg = null;
+      try {
+        matchedTgtProp.setValue(requestedValue, true);
+        copied = true;
+      } catch (e6) {
+        errorMsg = e6.toString();
+      }
+
+      var newValue = null;
+      if (copied) {
+        try { newValue = matchedTgtProp.getValue(); } catch (e7) { newValue = null; }
+        copiedCount++;
+      }
+
+      properties.push({
+        displayName: spName,
+        previousValue: previousValue,
+        requestedValue: requestedValue,
+        newValue: newValue,
+        copied: copied,
+        verified: copied && valuesApproximatelyEqual(newValue, requestedValue),
+        error: errorMsg
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        effectName: args.effectName,
+        source: {
+          sequenceName: srcSeq.name,
+          trackType: args.sourceTrackType,
+          trackIndex: args.sourceTrackIndex,
+          clipIndex: args.sourceClipIndex,
+          clipName: srcClipName
+        },
+        target: {
+          sequenceName: tgtSeq.name,
+          trackType: args.targetTrackType,
+          trackIndex: args.targetTrackIndex,
+          clipIndex: args.targetClipIndex,
+          clipName: tgtClipName
+        },
+        propertiesTotal: numSrcProps,
+        propertiesCopied: copiedCount,
+        properties: properties
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/copy-effects-between-clips.jsx

@@ -0,0 +1,234 @@
+// Command: copy-effects-between-clips → ppb_copyEffectsBetweenClips
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, resolveTimelineClip,
+// resolveQeClip, serializeClipComponents, findQeVideoEffectByName,
+// findQeAudioEffectByName, isIntrinsicComponentDisplayName, ...) are already
+// defined there.
+//
+// Ports leancoderkavy's clipboard.ts copy_effects_between_clips: for each
+// non-intrinsic component on the SOURCE clip (Motion/Opacity/Time
+// Remapping/Volume/Channel Volume/Panner are skipped — see
+// isIntrinsicComponentDisplayName — unless effectName narrows the copy to
+// one specific effect), re-applies the same-named effect on the TARGET clip
+// via the standard QE dance, then copies every matching property's value
+// across via getValue()/setValue(). Source and target clips may be on
+// DIFFERENT sequences — QE only ever operates on the ACTIVE sequence, so
+// the TARGET's sequence is made active for the QE apply calls (the source
+// is read via the standard DOM only, which needs no activation).
+function ppb_copyEffectsBetweenClips(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (args.sourceTrackType !== "video" && args.sourceTrackType !== "audio") {
+      return JSON.stringify({ ok: false, error: "sourceTrackType must be \"video\" or \"audio\"" });
+    }
+    if (args.targetTrackType !== "video" && args.targetTrackType !== "audio") {
+      return JSON.stringify({ ok: false, error: "targetTrackType must be \"video\" or \"audio\"" });
+    }
+    var indexFields = ["sourceTrackIndex", "sourceClipIndex", "targetTrackIndex", "targetClipIndex"];
+    for (var f = 0; f < indexFields.length; f++) {
+      var v = args[indexFields[f]];
+      if (typeof v !== "number" || v < 0 || Math.floor(v) !== v) {
+        return JSON.stringify({ ok: false, error: indexFields[f] + " must be a non-negative integer" });
+      }
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    function resolveSeq(name) {
+      if (name && typeof name === "string") {
+        var found = findSequenceByName(name);
+        if (!found) {
+          return { error: "no sequence named \"" + name + "\" is open" };
+        }
+        return { seq: found };
+      }
+      var active = app.project.activeSequence;
+      if (!active) {
+        return { error: "no active sequence, and no sequenceName given" };
+      }
+      return { seq: active };
+    }
+
+    var srcSeqResolved = resolveSeq(args.sourceSequenceName);
+    if (srcSeqResolved.error) {
+      return JSON.stringify({ ok: false, error: "source: " + srcSeqResolved.error });
+    }
+    var srcSeq = srcSeqResolved.seq;
+
+    var tgtSeqResolved = resolveSeq(args.targetSequenceName);
+    if (tgtSeqResolved.error) {
+      return JSON.stringify({ ok: false, error: "target: " + tgtSeqResolved.error });
+    }
+    var tgtSeq = tgtSeqResolved.seq;
+
+    var srcResolvedClip = resolveTimelineClip(srcSeq, args.sourceTrackType, args.sourceTrackIndex, args.sourceClipIndex);
+    if (srcResolvedClip.error) {
+      return JSON.stringify({ ok: false, error: "source: " + srcResolvedClip.error });
+    }
+    var srcClip = srcResolvedClip.clip;
+    var srcClipName = null;
+    try { srcClipName = srcClip.name; } catch (e) { srcClipName = null; }
+
+    var tgtResolvedClip = resolveTimelineClip(tgtSeq, args.targetTrackType, args.targetTrackIndex, args.targetClipIndex);
+    if (tgtResolvedClip.error) {
+      return JSON.stringify({ ok: false, error: "target: " + tgtResolvedClip.error });
+    }
+    var tgtClip = tgtResolvedClip.clip;
+    var tgtClipName = null;
+    try { tgtClipName = tgtClip.name; } catch (e) { tgtClipName = null; }
+
+    var previousTargetComponents = serializeClipComponents(tgtClip);
+
+    try {
+      ensureQEEnabled();
+      activateSequenceForQE(tgtSeq);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.enableQE()/target 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 tgtQeResolved = resolveQeClip(qeSeq, args.targetTrackType, args.targetTrackIndex, args.targetClipIndex);
+    if (tgtQeResolved.error) {
+      return JSON.stringify({ ok: false, error: "target: " + tgtQeResolved.error });
+    }
+    var tgtQeClip = tgtQeResolved.qeClip;
+
+    var effectFilter = (typeof args.effectName === "string" && args.effectName) ? args.effectName : null;
+
+    var numSrcComponents;
+    try {
+      numSrcComponents = srcClip.components.numItems;
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "could not read source clip's components: " + e.toString() });
+    }
+
+    var effectResults = [];
+    var appliedCount = 0;
+
+    for (var i = 0; i < numSrcComponents; i++) {
+      var comp = srcClip.components[i];
+      var dn = null;
+      try { dn = comp.displayName; } catch (e2) { dn = null; }
+      if (!dn) {
+        continue;
+      }
+      if (effectFilter) {
+        if (dn !== effectFilter) {
+          continue;
+        }
+      } else if (isIntrinsicComponentDisplayName(dn)) {
+        continue;
+      }
+
+      var fx = args.targetTrackType === "video" ? findQeVideoEffectByName(dn) : findQeAudioEffectByName(dn);
+      if (!fx) {
+        effectResults.push({ effect: dn, applied: false, error: "effect not found in the target track type's QE catalog" });
+        continue;
+      }
+
+      try {
+        if (args.targetTrackType === "video") {
+          tgtQeClip.addVideoEffect(fx);
+        } else {
+          tgtQeClip.addAudioEffect(fx);
+        }
+      } catch (e3) {
+        effectResults.push({ effect: dn, applied: false, error: "addVideoEffect/addAudioEffect failed: " + e3.toString() });
+        continue;
+      }
+
+      // Per PREMIERE_API_NOTES.md, the newly-applied component is appended
+      // LAST on the standard-DOM clip.
+      var tgtNumComponents;
+      try {
+        tgtNumComponents = tgtClip.components.numItems;
+      } catch (e4) {
+        effectResults.push({ effect: dn, applied: true, propertiesCopied: 0, propertiesTotal: 0, error: "applied, but could not re-read target clip's components to copy property values: " + e4.toString() });
+        appliedCount++;
+        continue;
+      }
+      var tgtComp = tgtClip.components[tgtNumComponents - 1];
+
+      var numSrcProps = 0;
+      try { numSrcProps = comp.properties.numItems; } catch (e5) { numSrcProps = 0; }
+      var numTgtProps = 0;
+      try { numTgtProps = tgtComp.properties.numItems; } catch (e6) { numTgtProps = 0; }
+
+      var propertiesCopied = 0;
+      for (var sp = 0; sp < numSrcProps; sp++) {
+        var srcProp = comp.properties[sp];
+        var spName = null;
+        try { spName = srcProp.displayName; } catch (e7) { spName = null; }
+        if (!spName) {
+          continue;
+        }
+        for (var tp = 0; tp < numTgtProps; tp++) {
+          var tgtProp = tgtComp.properties[tp];
+          var tpName = null;
+          try { tpName = tgtProp.displayName; } catch (e8) { tpName = null; }
+          if (tpName === spName) {
+            try {
+              var val = srcProp.getValue();
+              tgtProp.setValue(val, true);
+              propertiesCopied++;
+            } catch (e9) {
+              // best-effort — one unsettable property must not abort the
+              // whole effect's copy
+            }
+            break;
+          }
+        }
+      }
+
+      effectResults.push({ effect: dn, applied: true, propertiesCopied: propertiesCopied, propertiesTotal: numSrcProps });
+      appliedCount++;
+    }
+
+    var newTargetComponents = serializeClipComponents(tgtClip);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        source: {
+          sequenceName: srcSeq.name,
+          trackType: args.sourceTrackType,
+          trackIndex: args.sourceTrackIndex,
+          clipIndex: args.sourceClipIndex,
+          clipName: srcClipName
+        },
+        target: {
+          sequenceName: tgtSeq.name,
+          trackType: args.targetTrackType,
+          trackIndex: args.targetTrackIndex,
+          clipIndex: args.targetClipIndex,
+          clipName: tgtClipName
+        },
+        effectFilter: effectFilter,
+        appliedCount: appliedCount,
+        effects: effectResults,
+        previousTargetComponents: previousTargetComponents,
+        newTargetComponents: newTargetComponents
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/create-bars-and-tone.jsx

@@ -0,0 +1,152 @@
+// Command: create-bars-and-tone → ppb_createBarsAndTone
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// ensureQEEnabled, ...) are already defined there.
+//
+// REWRITTEN 2026-07-17 after the probe session (see BUILD_FINDINGS.md
+// corrections): the standard-DOM app.project.newBarsAndTone(...) throws
+// "Illegal Parameter type" on this build, but the QE 2-arg form —
+// qe.project.newBarsAndTone(width, height) — WORKS (found in the
+// antipaster/Adobe-Premiere-Pro-MCP repo; live-verified creating an
+// "HD Bars and Tone" project item). The QE call takes no name argument;
+// Premiere names the item itself (e.g. "HD Bars and Tone"), so a
+// requested name is applied afterward via item.name assignment.
+// width/height default to 1920x1080 (bars-and-tone is a calibration/
+// leader item, not a project deliverable). Verified via a project-tree
+// nodeId diff of the root bin's children (never trusting the call's own
+// return value). The standard-DOM form is still tried FIRST in case a
+// future build repairs it (it accepts a name and timebase natively).
+
+function ppbCreateBarsAndTone_snapshotRootIds() {
+  var ids = {};
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var nid = null;
+    try { nid = root.children[i].nodeId; } catch (e) { nid = null; }
+    if (nid) { ids[nid] = true; }
+  }
+  return ids;
+}
+
+function ppbCreateBarsAndTone_findNewItem(beforeIds) {
+  var root = app.project.rootItem;
+  for (var i = root.children.numItems - 1; i >= 0; i--) {
+    var nid = null;
+    try { nid = root.children[i].nodeId; } catch (e) { nid = null; }
+    if (nid && !beforeIds.hasOwnProperty(nid)) {
+      return root.children[i];
+    }
+  }
+  return null;
+}
+
+function ppb_createBarsAndTone(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 width = typeof args.width === "number" ? args.width : 1920;
+    var height = typeof args.height === "number" ? args.height : 1080;
+    var requestedName = (typeof args.name === "string" && args.name.length > 0) ? args.name : null;
+
+    var attempts = [];
+    var newItem = null;
+    var methodUsed = null;
+
+    // 1. standard DOM — broken on 26.3.0 ("Illegal Parameter type") but
+    // cheap to try in case a future build repairs it.
+    if (typeof app.project.newBarsAndTone === "function") {
+      var timebase = null;
+      try {
+        var activeSeq = app.project.activeSequence;
+        timebase = activeSeq ? String(activeSeq.timebase) : String(TICKS_PER_SECOND);
+      } catch (e) {
+        timebase = String(TICKS_PER_SECOND);
+      }
+      var beforeIds1 = ppbCreateBarsAndTone_snapshotRootIds();
+      var att1 = { method: "app.project.newBarsAndTone(w, h, timebaseStr, name)" };
+      try {
+        app.project.newBarsAndTone(width, height, timebase, requestedName || "Bars and Tone");
+        att1.threw = false;
+      } catch (e2) {
+        att1.threw = true;
+        att1.error = e2.toString();
+      }
+      newItem = ppbCreateBarsAndTone_findNewItem(beforeIds1);
+      att1.effective = newItem !== null;
+      attempts.push(att1);
+      if (newItem) { methodUsed = att1.method; }
+    }
+
+    // 2. QE 2-arg form — live-verified working on 26.3.0.
+    if (!newItem) {
+      try {
+        ensureQEEnabled();
+      } catch (e3) {
+        return JSON.stringify({ ok: false, error: "app.enableQE() failed: " + e3.toString(), attempts: attempts });
+      }
+      if (typeof qe === "undefined" || !qe.project || typeof qe.project.newBarsAndTone !== "function") {
+        return JSON.stringify({ ok: false, error: "no working bars-and-tone API on this build (standard DOM failed, qe.project.newBarsAndTone unavailable)", attempts: attempts });
+      }
+      var beforeIds2 = ppbCreateBarsAndTone_snapshotRootIds();
+      var att2 = { method: "qe.project.newBarsAndTone(w, h)" };
+      try {
+        qe.project.newBarsAndTone(width, height);
+        att2.threw = false;
+      } catch (e4) {
+        att2.threw = true;
+        att2.error = e4.toString();
+      }
+      newItem = ppbCreateBarsAndTone_findNewItem(beforeIds2);
+      att2.effective = newItem !== null;
+      attempts.push(att2);
+      if (newItem) { methodUsed = att2.method; }
+    }
+
+    if (!newItem) {
+      return JSON.stringify({
+        ok: false,
+        error: "no bars-and-tone item appeared in the root bin after any attempted call",
+        attempts: attempts
+      });
+    }
+
+    // The QE form takes no name — apply a requested name afterward.
+    var premiereGivenName = null;
+    try { premiereGivenName = newItem.name; } catch (e5) { premiereGivenName = null; }
+    var renamed = null;
+    if (requestedName && premiereGivenName !== requestedName) {
+      try {
+        newItem.name = requestedName;
+        renamed = (newItem.name === requestedName);
+      } catch (e6) {
+        renamed = false;
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        created: true,
+        methodUsed: methodUsed,
+        attempts: attempts,
+        premiereGivenName: premiereGivenName,
+        name: (function () { try { return newItem.name; } catch (e) { return premiereGivenName; } })(),
+        renamed: renamed,
+        width: width,
+        height: height,
+        nodeId: (function () { try { return newItem.nodeId; } catch (e) { return null; } })()
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/create-bin.jsx

@@ -0,0 +1,76 @@
+// Command: create-bin → ppb_createBin
+// 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.
+//
+// Creates every missing segment of a '/'-separated bin path via
+// parentBin.createBin(name), same bin-path-walking approach as
+// create-sequence.jsx's own bin argument. Reports which segments already
+// existed vs. were newly created, rather than silently no-oping on an
+// existing path.
+
+function ppb_createBin(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.binPath || typeof args.binPath !== "string") {
+      return JSON.stringify({ ok: false, error: "binPath is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var segments = args.binPath.split("/").filter(function (s) { return s.length > 0; });
+    if (segments.length === 0) {
+      return JSON.stringify({ ok: false, error: "binPath must contain at least one non-empty segment" });
+    }
+
+    var current = app.project.rootItem;
+    var createdSegments = [];
+    var existedSegments = [];
+
+    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 && typeof ProjectItemType !== "undefined" && child.type === ProjectItemType.BIN) {
+          found = child;
+          break;
+        }
+      }
+      if (found) {
+        existedSegments.push(segment);
+        current = found;
+      } else {
+        var created;
+        try {
+          created = current.createBin(segment);
+        } catch (e) {
+          return JSON.stringify({ ok: false, error: "createBin(\"" + segment + "\") failed: " + e.toString() });
+        }
+        createdSegments.push(segment);
+        current = created;
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        binPath: args.binPath,
+        nodeId: current.nodeId,
+        createdSegments: createdSegments,
+        existedSegments: existedSegments,
+        alreadyExisted: createdSegments.length === 0
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}