ae-agent-setup 0.2.0

package/host/lib/mutation_shape_handlers.jsx

@@ -0,0 +1,358 @@
+function addShapeRepeater(layerId, layerName, optionsJSON) {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        var resolvedLayer = aeResolveLayer(comp, layerId, layerName);
+        if (resolvedLayer.error) {
+            return encodePayload({ status: "error", message: resolvedLayer.error });
+        }
+        var layer = resolvedLayer.layer;
+        if (layer.matchName !== "ADBE Vector Layer") {
+            return encodePayload({ status: "error", message: "Target layer is not a shape layer." });
+        }
+
+        var options = {};
+        if (optionsJSON && optionsJSON !== "null") {
+            try {
+                options = JSON.parse(optionsJSON);
+            } catch (eParse) {
+                return encodePayload({ status: "error", message: "Invalid options JSON: " + eParse.toString() });
+            }
+        }
+
+        function clamp(value, minValue, maxValue) {
+            if (value < minValue) {
+                return minValue;
+            }
+            if (value > maxValue) {
+                return maxValue;
+            }
+            return value;
+        }
+
+        function toNumberOrNull(value) {
+            if (value === null || value === undefined) {
+                return null;
+            }
+            var num = Number(value);
+            if (isNaN(num)) {
+                return null;
+            }
+            return num;
+        }
+
+        function toVec2(value) {
+            if (!(value instanceof Array) || value.length !== 2) {
+                return null;
+            }
+            var x = Number(value[0]);
+            var y = Number(value[1]);
+            if (isNaN(x) || isNaN(y)) {
+                return null;
+            }
+            return [x, y];
+        }
+
+        var rootVectors = layer.property("ADBE Root Vectors Group");
+        if (!rootVectors) {
+            return encodePayload({ status: "error", message: "Shape contents not found." });
+        }
+
+        var groupIndex = parseInt(options.groupIndex, 10);
+        if (isNaN(groupIndex) || groupIndex <= 0) {
+            groupIndex = 1;
+        }
+
+        var targetGroup = rootVectors.property(groupIndex);
+        if (!targetGroup || targetGroup.matchName !== "ADBE Vector Group") {
+            return encodePayload({ status: "error", message: "Shape group not found at groupIndex " + groupIndex + "." });
+        }
+
+        var contents = targetGroup.property("ADBE Vectors Group");
+        if (!contents) {
+            return encodePayload({ status: "error", message: "Shape group contents not found." });
+        }
+
+        var repeater = contents.addProperty("ADBE Vector Filter - Repeater");
+        if (!repeater) {
+            return encodePayload({ status: "error", message: "Failed to add Repeater." });
+        }
+
+        if (options.name && String(options.name).length > 0) {
+            repeater.name = String(options.name);
+        }
+
+        var copies = toNumberOrNull(options.copies);
+        if (copies !== null) {
+            if (copies < 0) {
+                copies = 0;
+            }
+            repeater.property("ADBE Vector Repeater Copies").setValue(copies);
+        }
+
+        var offset = toNumberOrNull(options.offset);
+        if (offset !== null) {
+            repeater.property("ADBE Vector Repeater Offset").setValue(offset);
+        }
+
+        var transform = repeater.property("ADBE Vector Repeater Transform");
+        if (transform) {
+            var position = toVec2(options.position);
+            if (position) {
+                transform.property("ADBE Vector Repeater Position").setValue(position);
+            }
+
+            var scale = toVec2(options.scale);
+            if (scale) {
+                transform.property("ADBE Vector Repeater Scale").setValue(scale);
+            }
+
+            var rotation = toNumberOrNull(options.rotation);
+            if (rotation !== null) {
+                transform.property("ADBE Vector Repeater Rotation").setValue(rotation);
+            }
+
+            var startOpacity = toNumberOrNull(options.startOpacity);
+            if (startOpacity !== null) {
+                transform.property("ADBE Vector Repeater Opacity 1").setValue(clamp(startOpacity, 0, 100));
+            }
+
+            var endOpacity = toNumberOrNull(options.endOpacity);
+            if (endOpacity !== null) {
+                transform.property("ADBE Vector Repeater Opacity 2").setValue(clamp(endOpacity, 0, 100));
+            }
+        }
+
+        return encodePayload({
+            status: "success",
+            layerId: layer.index,
+            layerUid: aeTryGetLayerUid(layer),
+            layerName: layer.name,
+            groupIndex: groupIndex,
+            repeaterName: repeater.name
+        });
+    } catch (e) {
+        log("addShapeRepeater() threw: " + e.toString());
+        return encodePayload({ status: "error", message: e.toString() });
+    }
+}
+
+function addLayer(layerType, optionsJSON) {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        if (!comp || !(comp instanceof CompItem)) {
+            return encodePayload({ status: "error", message: "Active composition not found." });
+        }
+
+        var requestedType = (layerType || "null").toString().toLowerCase();
+        var options = {};
+        if (optionsJSON && optionsJSON !== "null") {
+            try {
+                options = JSON.parse(optionsJSON);
+            } catch (eParse) {
+                return encodePayload({ status: "error", message: "Invalid options JSON: " + eParse.toString() });
+            }
+        }
+
+        function getNumber(value, fallback) {
+            if (value === null || value === undefined) {
+                return fallback;
+            }
+            var parsed = Number(value);
+            if (isNaN(parsed)) {
+                return fallback;
+            }
+            return parsed;
+        }
+
+        function toColor01(value, fallback) {
+            if (!(value instanceof Array) || value.length !== 3) {
+                return fallback;
+            }
+            var color = [];
+            for (var i = 0; i < 3; i++) {
+                var part = Number(value[i]);
+                if (isNaN(part)) {
+                    return fallback;
+                }
+                if (part > 1) {
+                    part = part / 255;
+                }
+                if (part < 0) {
+                    part = 0;
+                }
+                if (part > 1) {
+                    part = 1;
+                }
+                color.push(part);
+            }
+            return color;
+        }
+
+        function clamp(value, minValue, maxValue) {
+            if (value < minValue) {
+                return minValue;
+            }
+            if (value > maxValue) {
+                return maxValue;
+            }
+            return value;
+        }
+
+        function toVec2(value, fallback) {
+            if (!(value instanceof Array) || value.length !== 2) {
+                return fallback;
+            }
+            var first = Number(value[0]);
+            var second = Number(value[1]);
+            if (isNaN(first) || isNaN(second)) {
+                return fallback;
+            }
+            return [first, second];
+        }
+
+        function toLineCapValue(value) {
+            var normalized = value === null || value === undefined ? "" : String(value).toLowerCase();
+            if (normalized === "round") {
+                return 2;
+            }
+            if (normalized === "projecting") {
+                return 3;
+            }
+            return 1;
+        }
+
+        var layer = null;
+        var name = options.name && options.name.length > 0 ? options.name : null;
+        var createdShapeType = null;
+
+        if (requestedType === "text") {
+            var text = options.text;
+            if (text === null || text === undefined) {
+                text = "";
+            }
+            layer = comp.layers.addText(String(text));
+        } else if (requestedType === "null") {
+            layer = comp.layers.addNull();
+        } else if (requestedType === "shape") {
+            layer = comp.layers.addShape();
+            var rootVectors = layer.property("ADBE Root Vectors Group");
+            if (!rootVectors) {
+                return encodePayload({ status: "error", message: "Shape root vectors not found." });
+            }
+
+            var vectorGroup = rootVectors.addProperty("ADBE Vector Group");
+            if (!vectorGroup) {
+                return encodePayload({ status: "error", message: "Failed to create shape vector group." });
+            }
+
+            var groupContents = vectorGroup.property("ADBE Vectors Group");
+            if (!groupContents) {
+                return encodePayload({ status: "error", message: "Failed to access shape group contents." });
+            }
+
+            var shapeType = options.shapeType ? String(options.shapeType).toLowerCase() : "ellipse";
+            if (shapeType !== "ellipse" && shapeType !== "rect") {
+                shapeType = "ellipse";
+            }
+            createdShapeType = shapeType;
+
+            var shapeSize = toVec2(options.shapeSize, [Math.round(comp.width * 0.25), Math.round(comp.width * 0.25)]);
+            if (shapeSize[0] <= 0) {
+                shapeSize[0] = 1;
+            }
+            if (shapeSize[1] <= 0) {
+                shapeSize[1] = 1;
+            }
+            var shapePosition = toVec2(options.shapePosition, [0, 0]);
+
+            if (shapeType === "rect") {
+                vectorGroup.name = "Rect";
+                var rectPath = groupContents.addProperty("ADBE Vector Shape - Rect");
+                if (!rectPath) {
+                    return encodePayload({ status: "error", message: "Failed to create rectangle shape." });
+                }
+                rectPath.property("ADBE Vector Rect Size").setValue(shapeSize);
+                rectPath.property("ADBE Vector Rect Position").setValue(shapePosition);
+                var roundness = getNumber(options.shapeRoundness, 0);
+                if (roundness < 0) {
+                    roundness = 0;
+                }
+                rectPath.property("ADBE Vector Rect Roundness").setValue(roundness);
+            } else {
+                vectorGroup.name = "Ellipse";
+                var ellipsePath = groupContents.addProperty("ADBE Vector Shape - Ellipse");
+                if (!ellipsePath) {
+                    return encodePayload({ status: "error", message: "Failed to create ellipse shape." });
+                }
+                ellipsePath.property("ADBE Vector Ellipse Size").setValue(shapeSize);
+                ellipsePath.property("ADBE Vector Ellipse Position").setValue(shapePosition);
+            }
+
+            var fill = groupContents.addProperty("ADBE Vector Graphic - Fill");
+            if (fill) {
+                var fillColor = toColor01(options.shapeFillColor, [1, 1, 1]);
+                var fillOpacity = clamp(getNumber(options.shapeFillOpacity, 100), 0, 100);
+                fill.property("ADBE Vector Fill Color").setValue(fillColor);
+                fill.property("ADBE Vector Fill Opacity").setValue(fillOpacity);
+            }
+
+            var shouldAddStroke =
+                options.shapeStrokeColor !== undefined ||
+                options.shapeStrokeOpacity !== undefined ||
+                options.shapeStrokeWidth !== undefined ||
+                options.shapeStrokeLineCap !== undefined;
+            if (shouldAddStroke) {
+                var stroke = groupContents.addProperty("ADBE Vector Graphic - Stroke");
+                if (stroke) {
+                    var strokeColor = toColor01(options.shapeStrokeColor, [1, 1, 1]);
+                    var strokeOpacity = clamp(getNumber(options.shapeStrokeOpacity, 100), 0, 100);
+                    var strokeWidth = getNumber(options.shapeStrokeWidth, 4);
+                    if (strokeWidth < 0) {
+                        strokeWidth = 0;
+                    }
+                    stroke.property("ADBE Vector Stroke Color").setValue(strokeColor);
+                    stroke.property("ADBE Vector Stroke Opacity").setValue(strokeOpacity);
+                    stroke.property("ADBE Vector Stroke Width").setValue(strokeWidth);
+                    stroke.property("ADBE Vector Stroke Line Cap").setValue(toLineCapValue(options.shapeStrokeLineCap));
+                }
+            }
+        } else if (requestedType === "solid") {
+            var solidName = name || "Solid";
+            var solidColor = toColor01(options.color, [0.5, 0.5, 0.5]);
+            var solidWidth = Math.max(1, Math.round(getNumber(options.width, comp.width)));
+            var solidHeight = Math.max(1, Math.round(getNumber(options.height, comp.height)));
+            var solidDuration = getNumber(options.duration, comp.duration);
+            if (solidDuration <= 0) {
+                solidDuration = comp.duration;
+            }
+            layer = comp.layers.addSolid(solidColor, solidName, solidWidth, solidHeight, 1.0, solidDuration);
+        } else {
+            return encodePayload({
+                status: "error",
+                message: "Unsupported layerType. Use one of: text, null, solid, shape."
+            });
+        }
+
+        if (!layer) {
+            return encodePayload({ status: "error", message: "Failed to add layer." });
+        }
+
+        if (name && requestedType !== "solid") {
+            layer.name = name;
+        }
+
+        return encodePayload({
+            status: "success",
+            layerId: layer.index,
+            layerUid: aeTryGetLayerUid(layer),
+            layerName: layer.name,
+            layerType: getLayerTypeName(layer),
+            shapeType: createdShapeType
+        });
+    } catch (e) {
+        log("addLayer() threw: " + e.toString());
+        return encodePayload({ status: "error", message: e.toString() });
+    }
+}

package/host/lib/mutation_timeline_handlers.jsx

@@ -0,0 +1,137 @@
+function setInOutPoint(layerId, layerName, inPoint, outPoint) {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        var resolvedLayer = aeResolveLayer(comp, layerId, layerName);
+        if (resolvedLayer.error) {
+            return encodePayload({ status: "error", message: resolvedLayer.error });
+        }
+        var layer = resolvedLayer.layer;
+
+        var hasIn = inPoint !== null && inPoint !== undefined;
+        var hasOut = outPoint !== null && outPoint !== undefined;
+        if (!hasIn && !hasOut) {
+            return encodePayload({ status: "error", message: "At least one of inPoint/outPoint is required." });
+        }
+
+        var nextIn = hasIn ? Number(inPoint) : Number(layer.inPoint);
+        var nextOut = hasOut ? Number(outPoint) : Number(layer.outPoint);
+        if (isNaN(nextIn) || isNaN(nextOut)) {
+            return encodePayload({ status: "error", message: "inPoint/outPoint must be numeric." });
+        }
+        if (nextOut < nextIn) {
+            return encodePayload({ status: "error", message: "outPoint must be greater than or equal to inPoint." });
+        }
+
+        if (hasIn) {
+            layer.inPoint = nextIn;
+        }
+        if (hasOut) {
+            layer.outPoint = nextOut;
+        }
+
+        return encodePayload({
+            status: "success",
+            layerId: layer.index,
+            layerUid: aeTryGetLayerUid(layer),
+            layerName: layer.name,
+            inPoint: layer.inPoint,
+            outPoint: layer.outPoint
+        });
+    } catch (e) {
+        log("setInOutPoint() threw: " + e.toString());
+        return encodePayload({ status: "error", message: e.toString() });
+    }
+}
+
+function moveLayerTime(layerId, layerName, delta) {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        var resolvedLayer = aeResolveLayer(comp, layerId, layerName);
+        if (resolvedLayer.error) {
+            return encodePayload({ status: "error", message: resolvedLayer.error });
+        }
+        var layer = resolvedLayer.layer;
+
+        var deltaValue = Number(delta);
+        if (isNaN(deltaValue)) {
+            return encodePayload({ status: "error", message: "delta must be a number." });
+        }
+
+        layer.startTime = layer.startTime + deltaValue;
+
+        return encodePayload({
+            status: "success",
+            layerId: layer.index,
+            layerUid: aeTryGetLayerUid(layer),
+            layerName: layer.name,
+            startTime: layer.startTime,
+            inPoint: layer.inPoint,
+            outPoint: layer.outPoint
+        });
+    } catch (e) {
+        log("moveLayerTime() threw: " + e.toString());
+        return encodePayload({ status: "error", message: e.toString() });
+    }
+}
+
+function setCTI(time) {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        if (!comp || !(comp instanceof CompItem)) {
+            return encodePayload({ status: "error", message: "Active composition not found." });
+        }
+
+        var timeValue = Number(time);
+        if (isNaN(timeValue)) {
+            return encodePayload({ status: "error", message: "time must be a number." });
+        }
+
+        comp.time = timeValue;
+
+        return encodePayload({
+            status: "success",
+            compId: comp.id,
+            compName: comp.name,
+            time: comp.time
+        });
+    } catch (e) {
+        log("setCTI() threw: " + e.toString());
+        return encodePayload({ status: "error", message: e.toString() });
+    }
+}
+
+function setWorkArea(start, duration) {
+    try {
+        ensureJSON();
+        var comp = app.project.activeItem;
+        if (!comp || !(comp instanceof CompItem)) {
+            return encodePayload({ status: "error", message: "Active composition not found." });
+        }
+
+        var startValue = Number(start);
+        var durationValue = Number(duration);
+        if (isNaN(startValue) || isNaN(durationValue)) {
+            return encodePayload({ status: "error", message: "start and duration must be numbers." });
+        }
+        if (durationValue < 0) {
+            return encodePayload({ status: "error", message: "duration must be greater than or equal to 0." });
+        }
+
+        comp.workAreaStart = startValue;
+        comp.workAreaDuration = durationValue;
+
+        return encodePayload({
+            status: "success",
+            compId: comp.id,
+            compName: comp.name,
+            start: comp.workAreaStart,
+            duration: comp.workAreaDuration
+        });
+    } catch (e) {
+        log("setWorkArea() threw: " + e.toString());
+        return encodePayload({ status: "error", message: e.toString() });
+    }
+}

package/host/lib/property_utils.jsx

@@ -0,0 +1,105 @@
+var AE_PROPERTY_TYPE_PROPERTY = 6212;
+var AE_PROPERTY_TYPE_GROUP = 6213;
+
+function aePropertyValueToString(prop) {
+    try {
+        var value = prop.value;
+        if (value === null || value === undefined) {
+            return "";
+        }
+        if (value instanceof Array) {
+            return value.join(", ");
+        }
+        if (typeof value === "boolean") {
+            return value ? "true" : "false";
+        }
+        return value.toString();
+    } catch (e) {
+        return "";
+    }
+}
+
+function aeCanTraverseProperty(prop) {
+    if (!prop) {
+        return false;
+    }
+    try {
+        if (prop.propertyType === AE_PROPERTY_TYPE_GROUP) {
+            return true;
+        }
+    } catch (e) {}
+    return typeof prop.numProperties === "number" && prop.numProperties > 0;
+}
+
+function aeIsPropertyNode(prop) {
+    if (!prop) {
+        return false;
+    }
+    try {
+        if (prop.propertyType === AE_PROPERTY_TYPE_PROPERTY) {
+            return true;
+        }
+    } catch (e) {}
+    return !aeCanTraverseProperty(prop);
+}
+
+function aeIsEnabledProperty(prop) {
+    if (!prop) {
+        return false;
+    }
+    try {
+        if (typeof prop.enabled === "boolean") {
+            return prop.enabled;
+        }
+    } catch (e) {}
+    return true;
+}
+
+function aeCanExposeProperty(prop) {
+    if (!aeIsEnabledProperty(prop)) {
+        return false;
+    }
+    try {
+        if (prop.canSetExpression === false) {
+            return false;
+        }
+        if (prop.canSetExpression === true) {
+            return true;
+        }
+    } catch (e) {}
+    try {
+        if (typeof prop.canSetValue === "boolean") {
+            return prop.canSetValue;
+        }
+    } catch (e2) {}
+    return true;
+}
+
+function aeArrayContains(arr, value) {
+    if (!arr || !value) {
+        return false;
+    }
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i] === value) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function aeGetPropertyIdentifier(prop, fallbackIndex) {
+    try {
+        if (prop.matchName && prop.matchName.length > 0) {
+            return prop.matchName;
+        }
+    } catch (e) {}
+    try {
+        if (prop.name && prop.name.length > 0) {
+            return prop.name;
+        }
+    } catch (e2) {}
+    if (typeof fallbackIndex === "number") {
+        return "Property_" + fallbackIndex;
+    }
+    return "Property";
+}