@hybridlabor-api/aos 4.4.0 → 4.4.2-beta.0

package/mcps/after-effects-mcp/build/scripts/applyEffect.jsx

@@ -0,0 +1,153 @@
+// applyEffect.jsx
+// Applies an effect to a specified layer in a composition
+
+function applyEffect(args) {
+    try {
+        // Extract parameters
+        var compIndex = args.compIndex || 1; // Default to first comp
+        var layerIndex = args.layerIndex || 1; // Default to first layer
+        var effectName = args.effectName; // Name of the effect to apply
+        var effectMatchName = args.effectMatchName; // After Effects internal name (more reliable)
+        var effectCategory = args.effectCategory || ""; // Optional category for filtering
+        var presetPath = args.presetPath; // Optional path to an effect preset
+        var effectSettings = args.effectSettings || {}; // Optional effect parameters
+        
+        if (!effectName && !effectMatchName && !presetPath) {
+            throw new Error("You must specify either effectName, effectMatchName, or presetPath");
+        }
+        
+        // Find the composition by index
+        var comp = app.project.item(compIndex);
+        if (!comp || !(comp instanceof CompItem)) {
+            throw new Error("Composition not found at index " + compIndex);
+        }
+        
+        // Find the layer by index
+        var layer = comp.layer(layerIndex);
+        if (!layer) {
+            throw new Error("Layer not found at index " + layerIndex + " in composition '" + comp.name + "'");
+        }
+        
+        var effectResult;
+        
+        // Apply preset if a path is provided
+        if (presetPath) {
+            var presetFile = new File(presetPath);
+            if (!presetFile.exists) {
+                throw new Error("Effect preset file not found: " + presetPath);
+            }
+            
+            // Apply the preset to the layer
+            layer.applyPreset(presetFile);
+            effectResult = {
+                type: "preset",
+                name: presetPath.split('/').pop().split('\\').pop(),
+                applied: true
+            };
+        }
+        // Apply effect by match name (more reliable method)
+        else if (effectMatchName) {
+            var effect = layer.Effects.addProperty(effectMatchName);
+            effectResult = {
+                type: "effect",
+                name: effect.name,
+                matchName: effect.matchName,
+                index: effect.propertyIndex
+            };
+            
+            // Apply settings if provided
+            applyEffectSettings(effect, effectSettings);
+        }
+        // Apply effect by display name
+        else {
+            // Get the effect from the Effect menu
+            var effect = layer.Effects.addProperty(effectName);
+            effectResult = {
+                type: "effect",
+                name: effect.name,
+                matchName: effect.matchName,
+                index: effect.propertyIndex
+            };
+            
+            // Apply settings if provided
+            applyEffectSettings(effect, effectSettings);
+        }
+        
+        return JSON.stringify({
+            status: "success",
+            message: "Effect applied successfully",
+            effect: effectResult,
+            layer: {
+                name: layer.name,
+                index: layerIndex
+            },
+            composition: {
+                name: comp.name,
+                index: compIndex
+            }
+        }, null, 2);
+    } catch (error) {
+        return JSON.stringify({
+            status: "error",
+            message: error.toString()
+        }, null, 2);
+    }
+}
+
+// Helper function to apply effect settings
+function applyEffectSettings(effect, settings) {
+    // Skip if no settings are provided
+    if (!settings || Object.keys(settings).length === 0) {
+        return;
+    }
+    
+    // Iterate through all provided settings
+    for (var propName in settings) {
+        if (settings.hasOwnProperty(propName)) {
+            try {
+                // Find the property in the effect
+                var property = null;
+                
+                // Try direct property access first
+                try {
+                    property = effect.property(propName);
+                } catch (e) {
+                    // If direct access fails, search through all properties
+                    for (var i = 1; i <= effect.numProperties; i++) {
+                        var prop = effect.property(i);
+                        if (prop.name === propName) {
+                            property = prop;
+                            break;
+                        }
+                    }
+                }
+                
+                // Set the property value if found
+                if (property && property.setValue) {
+                    property.setValue(settings[propName]);
+                }
+            } catch (e) {
+                // Log error but continue with other properties
+                $.writeln("Error setting effect property '" + propName + "': " + e.toString());
+            }
+        }
+    }
+}
+
+// Read arguments from the temp args file written by the launcher
+var argsFile = new File($.fileName.replace(/[^\\\/]*$/, '') + "../temp/args.json");
+var args = {};
+if (argsFile.exists) {
+    argsFile.open("r");
+    var _content = argsFile.read();
+    argsFile.close();
+    if (_content) {
+        try { args = JSON.parse(_content); } catch (_e) { args = {}; }
+    }
+}
+
+// Run the function and write the result
+var result = applyEffect(args);
+
+// Write the result so it can be captured by the Node.js process
+$.write(result); 

package/mcps/after-effects-mcp/build/scripts/applyEffectTemplate.jsx

@@ -0,0 +1,218 @@
+// applyEffectTemplate.jsx
+// Applies predefined effect templates to layers
+
+function applyEffectTemplate(args) {
+    try {
+        // Extract parameters
+        var compIndex = args.compIndex || 1; // Default to first comp
+        var layerIndex = args.layerIndex || 1; // Default to first layer
+        var templateName = args.templateName; // Name of the template to apply
+        var customSettings = args.customSettings || {}; // Optional customizations
+        
+        if (!templateName) {
+            throw new Error("You must specify a templateName");
+        }
+        
+        // Find the composition by index
+        var comp = app.project.item(compIndex);
+        if (!comp || !(comp instanceof CompItem)) {
+            throw new Error("Composition not found at index " + compIndex);
+        }
+        
+        // Find the layer by index
+        var layer = comp.layer(layerIndex);
+        if (!layer) {
+            throw new Error("Layer not found at index " + layerIndex + " in composition '" + comp.name + "'");
+        }
+        
+        // Template definitions
+        var templates = {
+            // Blur effects
+            "gaussian-blur": {
+                effectMatchName: "ADBE Gaussian Blur 2",
+                settings: {
+                    "Blurriness": customSettings.blurriness || 20
+                }
+            },
+            "directional-blur": {
+                effectMatchName: "ADBE Directional Blur",
+                settings: {
+                    "Direction": customSettings.direction || 0,
+                    "Blur Length": customSettings.length || 10
+                }
+            },
+            
+            // Color correction effects
+            "color-balance": {
+                effectMatchName: "ADBE Color Balance (HLS)",
+                settings: {
+                    "Hue": customSettings.hue || 0,
+                    "Lightness": customSettings.lightness || 0,
+                    "Saturation": customSettings.saturation || 0
+                }
+            },
+            "brightness-contrast": {
+                effectMatchName: "ADBE Brightness & Contrast 2",
+                settings: {
+                    "Brightness": customSettings.brightness || 0,
+                    "Contrast": customSettings.contrast || 0,
+                    "Use Legacy": false
+                }
+            },
+            "curves": {
+                effectMatchName: "ADBE CurvesCustom",
+                // Curves are complex and would need special handling
+            },
+            
+            // Stylistic effects
+            "glow": {
+                effectMatchName: "ADBE Glow",
+                settings: {
+                    "Glow Threshold": customSettings.threshold || 50,
+                    "Glow Radius": customSettings.radius || 15,
+                    "Glow Intensity": customSettings.intensity || 1
+                }
+            },
+            "drop-shadow": {
+                effectMatchName: "ADBE Drop Shadow",
+                settings: {
+                    "Shadow Color": customSettings.color || [0, 0, 0, 1],
+                    "Opacity": customSettings.opacity || 50,
+                    "Direction": customSettings.direction || 135,
+                    "Distance": customSettings.distance || 10,
+                    "Softness": customSettings.softness || 10
+                }
+            },
+            
+            // Common effect chains
+            "cinematic-look": {
+                effects: [
+                    {
+                        effectMatchName: "ADBE CurvesCustom",
+                        settings: {}
+                    },
+                    {
+                        effectMatchName: "ADBE Vibrance",
+                        settings: {
+                            "Vibrance": 15,
+                            "Saturation": -5
+                        }
+                    }
+                ]
+            },
+            "text-pop": {
+                effects: [
+                    {
+                        effectMatchName: "ADBE Drop Shadow",
+                        settings: {
+                            "Shadow Color": [0, 0, 0, 1],
+                            "Opacity": 75,
+                            "Distance": 5,
+                            "Softness": 10
+                        }
+                    },
+                    {
+                        effectMatchName: "ADBE Glow",
+                        settings: {
+                            "Glow Threshold": 50,
+                            "Glow Radius": 10,
+                            "Glow Intensity": 1.5
+                        }
+                    }
+                ]
+            }
+        };
+        
+        // Check if the requested template exists
+        var template = templates[templateName];
+        if (!template) {
+            var availableTemplates = Object.keys(templates).join(", ");
+            throw new Error("Template '" + templateName + "' not found. Available templates: " + availableTemplates);
+        }
+        
+        var appliedEffects = [];
+        
+        // Apply single effect or multiple effects based on template structure
+        if (template.effectMatchName) {
+            // Single effect template
+            var effect = layer.Effects.addProperty(template.effectMatchName);
+            
+            // Apply settings
+            for (var propName in template.settings) {
+                try {
+                    var property = effect.property(propName);
+                    if (property) {
+                        property.setValue(template.settings[propName]);
+                    }
+                } catch (e) {
+                    $.writeln("Warning: Could not set " + propName + " on effect " + effect.name + ": " + e);
+                }
+            }
+            
+            appliedEffects.push({
+                name: effect.name,
+                matchName: effect.matchName
+            });
+        } else if (template.effects) {
+            // Multiple effects template
+            for (var i = 0; i < template.effects.length; i++) {
+                var effectData = template.effects[i];
+                var effect = layer.Effects.addProperty(effectData.effectMatchName);
+                
+                // Apply settings
+                for (var propName in effectData.settings) {
+                    try {
+                        var property = effect.property(propName);
+                        if (property) {
+                            property.setValue(effectData.settings[propName]);
+                        }
+                    } catch (e) {
+                        $.writeln("Warning: Could not set " + propName + " on effect " + effect.name + ": " + e);
+                    }
+                }
+                
+                appliedEffects.push({
+                    name: effect.name,
+                    matchName: effect.matchName
+                });
+            }
+        }
+        
+        return JSON.stringify({
+            status: "success",
+            message: "Effect template '" + templateName + "' applied successfully",
+            appliedEffects: appliedEffects,
+            layer: {
+                name: layer.name,
+                index: layerIndex
+            },
+            composition: {
+                name: comp.name,
+                index: compIndex
+            }
+        }, null, 2);
+    } catch (error) {
+        return JSON.stringify({
+            status: "error",
+            message: error.toString()
+        }, null, 2);
+    }
+}
+
+// Read arguments from the temp args file written by the launcher
+var argsFile = new File($.fileName.replace(/[^\\\/]*$/, '') + "../temp/args.json");
+var args = {};
+if (argsFile.exists) {
+    argsFile.open("r");
+    var _content = argsFile.read();
+    argsFile.close();
+    if (_content) {
+        try { args = JSON.parse(_content); } catch (_e) { args = {}; }
+    }
+}
+
+// Run the function and write the result
+var result = applyEffectTemplate(args);
+
+// Write the result so it can be captured by the Node.js process
+$.write(result); 

package/mcps/after-effects-mcp/build/scripts/createComposition.jsx

@@ -0,0 +1,71 @@
+// createComposition.jsx
+// Creates a new composition with the specified settings
+
+function createComposition(args) {
+    try {
+        // Extract parameters from args
+        var name = args.name || "New Composition";
+        var width = parseInt(args.width) || 1920;
+        var height = parseInt(args.height) || 1080;
+        var pixelAspect = parseFloat(args.pixelAspect) || 1.0;
+        var duration = parseFloat(args.duration) || 10.0;
+        var frameRate = parseFloat(args.frameRate) || 30.0;
+        var bgColor = args.backgroundColor ? [args.backgroundColor.r/255, args.backgroundColor.g/255, args.backgroundColor.b/255] : [0, 0, 0];
+        
+        // Create the composition
+        var newComp = app.project.items.addComp(name, width, height, pixelAspect, duration, frameRate);
+        
+        // Set background color if provided
+        if (args.backgroundColor) {
+            newComp.bgColor = bgColor;
+        }
+        
+        // Return success with composition details
+        return JSON.stringify({
+            status: "success",
+            message: "Composition created successfully",
+            composition: {
+                name: newComp.name,
+                id: newComp.id,
+                width: newComp.width,
+                height: newComp.height,
+                pixelAspect: newComp.pixelAspect,
+                duration: newComp.duration,
+                frameRate: newComp.frameRate,
+                bgColor: newComp.bgColor
+            }
+        }, null, 2);
+    } catch (error) {
+        // Return error message
+        return JSON.stringify({
+            status: "error",
+            message: error.toString()
+        }, null, 2);
+    }
+}
+
+// Read arguments from the file (passed by the Node.js script)
+var argsFile = new File($.fileName.replace(/[^\\\/]*$/, '') + "../temp/args.json");
+var args = {};
+if (argsFile.exists) {
+    argsFile.open("r");
+    var content = argsFile.read();
+    argsFile.close();
+    if (content) {
+        try {
+            args = JSON.parse(content);
+        } catch (e) {
+            // Handle parsing error
+            $.write(JSON.stringify({
+                status: "error",
+                message: "Failed to parse arguments: " + e.toString()
+            }, null, 2));
+        }
+    }
+}
+
+// Run the function and write the result
+var result = createComposition(args);
+
+// Write the result so it can be captured by the Node.js process
+$.write(result); 

package/mcps/after-effects-mcp/build/scripts/createShapeLayer.jsx

@@ -0,0 +1,147 @@
+// createShapeLayer.jsx
+// Creates a new shape layer in the specified composition
+
+function createShapeLayer(args) {
+    try {
+        // Extract parameters from args
+        var compName = args.compName || "";
+        var shapeType = args.shapeType || "rectangle"; // rectangle, ellipse, polygon
+        var position = args.position || [960, 540]; // Default to center
+        var size = args.size || [200, 200]; // Width, Height
+        var fillColor = args.fillColor || [1, 0, 0]; // Default to red
+        var strokeColor = args.strokeColor || [0, 0, 0]; // Default to black
+        var strokeWidth = args.strokeWidth || 0; // Default to no stroke
+        var startTime = args.startTime || 0;
+        var duration = args.duration || 5; // Default 5 seconds
+        var name = args.name || "Shape Layer";
+        var points = args.points || 5; // For polygon, number of points
+        
+        // Find the composition by name
+        var comp = null;
+        for (var i = 1; i <= app.project.numItems; i++) {
+            var item = app.project.item(i);
+            if (item instanceof CompItem && item.name === compName) {
+                comp = item;
+                break;
+            }
+        }
+        
+        // If no composition was found by name, use the active composition
+        if (!comp) {
+            if (app.project.activeItem instanceof CompItem) {
+                comp = app.project.activeItem;
+            } else {
+                throw new Error("No composition found with name '" + compName + "' and no active composition");
+            }
+        }
+        
+        // Create a shape layer
+        var shapeLayer = comp.layers.addShape();
+        shapeLayer.name = name;
+        
+        // Get the root content property group
+        var contents = shapeLayer.property("Contents"); // Changed from "ADBE Root Vectors Group" for simplicity
+        
+        // Add a shape group (e.g., "Group 1")
+        var shapeGroup = contents.addProperty("ADBE Vector Group");
+        // Get the Contents property group WITHIN the new shape group
+        var groupContents = shapeGroup.property("Contents"); 
+        
+        // Add the appropriate shape path based on type TO THE GROUP'S CONTENTS
+        var shapePathProperty;
+        if (shapeType === "rectangle") {
+            shapePathProperty = groupContents.addProperty("ADBE Vector Shape - Rect");
+            var rectSizeProp = shapePathProperty.property("Size");
+            rectSizeProp.setValue(size);
+        } else if (shapeType === "ellipse") {
+            shapePathProperty = groupContents.addProperty("ADBE Vector Shape - Ellipse");
+            var ellipseSizeProp = shapePathProperty.property("Size");
+            ellipseSizeProp.setValue(size);
+        } else if (shapeType === "polygon" || shapeType === "star") { // Combine polygon/star logic
+            shapePathProperty = groupContents.addProperty("ADBE Vector Shape - Star");
+            shapePathProperty.property("Type").setValue(shapeType === "polygon" ? 1 : 2); // 1=Polygon, 2=Star
+            shapePathProperty.property("Points").setValue(points);
+            shapePathProperty.property("Outer Radius").setValue(size[0] / 2);
+            // For stars, set inner radius; for polygons, maybe outer roundness if needed
+            if (shapeType === "star") {
+                shapePathProperty.property("Inner Radius").setValue(size[0] / 3);
+            }
+        }
+        
+        // Add fill TO THE GROUP'S CONTENTS
+        var fill = groupContents.addProperty("ADBE Vector Graphic - Fill");
+        fill.property("Color").setValue(fillColor);
+        fill.property("Opacity").setValue(100);
+        
+        // Add stroke TO THE GROUP'S CONTENTS if width > 0
+        if (strokeWidth > 0) {
+            var stroke = groupContents.addProperty("ADBE Vector Graphic - Stroke");
+            stroke.property("Color").setValue(strokeColor);
+            stroke.property("Stroke Width").setValue(strokeWidth);
+            stroke.property("Opacity").setValue(100);
+        }
+        
+        // Add transform properties TO THE GROUP (not the layer's main transform initially)
+        var groupTransform = shapeGroup.property("Transform");
+        // Note: Position is relative to the layer anchor point, 
+        // Layer position sets the anchor point relative to the comp.
+        // Setting group position might be more intuitive for simple shapes.
+        // groupTransform.property("Position").setValue([0,0]); // Keep group centered initially
+
+        // Set layer's main transform properties
+        shapeLayer.property("Position").setValue(position);
+        
+        // Set timing
+        shapeLayer.startTime = startTime;
+        if (duration > 0) {
+            shapeLayer.outPoint = startTime + duration;
+        }
+        
+        // Return success with layer details
+        return JSON.stringify({
+            status: "success",
+            message: "Shape layer created successfully",
+            layer: {
+                name: shapeLayer.name,
+                index: shapeLayer.index,
+                type: "shape",
+                shapeType: shapeType,
+                inPoint: shapeLayer.inPoint,
+                outPoint: shapeLayer.outPoint,
+                position: shapeLayer.property("Position").value
+            }
+        }, null, 2);
+    } catch (error) {
+        // Return error message
+        return JSON.stringify({
+            status: "error",
+            message: error.toString()
+        }, null, 2);
+    }
+}
+
+// Read arguments from the file (passed by the Node.js script)
+var argsFile = new File($.fileName.replace(/[^\\\/]*$/, '') + "../temp/args.json");
+var args = {};
+if (argsFile.exists) {
+    argsFile.open("r");
+    var content = argsFile.read();
+    argsFile.close();
+    if (content) {
+        try {
+            args = JSON.parse(content);
+        } catch (e) {
+            // Handle parsing error
+            $.write(JSON.stringify({
+                status: "error",
+                message: "Failed to parse arguments: " + e.toString()
+            }, null, 2));
+        }
+    }
+}
+
+// Run the function and write the result
+var result = createShapeLayer(args);
+
+// Write the result so it can be captured by the Node.js process
+$.write(result);