@hybridlabor-api/aos 4.4.1 → 4.4.2-beta.1

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

@@ -0,0 +1,114 @@
+// createSolidLayer.jsx
+// Creates a new solid layer in the specified composition
+
+function createSolidLayer(args) {
+    try {
+        // Extract parameters from args
+        var compName = args.compName || "";
+        var color = args.color || [1, 1, 1]; // Default to white
+        var name = args.name || "Solid Layer";
+        var position = args.position || [960, 540]; // Default to center
+        var size = args.size; // Width, Height (if null, will use comp size)
+        var startTime = args.startTime || 0;
+        var duration = args.duration || 5; // Default 5 seconds
+        var isAdjustment = args.isAdjustment || false; // Make it an adjustment layer?
+        
+        // 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");
+            }
+        }
+        
+        // If size is not specified, use composition size
+        if (!size) {
+            size = [comp.width, comp.height];
+        }
+        
+        // Create a solid layer
+        var solidLayer;
+        
+        if (isAdjustment) {
+            // Create an adjustment layer
+            solidLayer = comp.layers.addSolid([0, 0, 0], name, size[0], size[1], 1);
+            solidLayer.adjustmentLayer = true;
+        } else {
+            // Create a regular solid layer
+            solidLayer = comp.layers.addSolid(
+                color,
+                name,
+                size[0],
+                size[1],
+                1 // Pixel aspect ratio
+            );
+        }
+        
+        // Set position
+        solidLayer.property("Position").setValue(position);
+        
+        // Set timing
+        solidLayer.startTime = startTime;
+        if (duration > 0) {
+            solidLayer.outPoint = startTime + duration;
+        }
+        
+        // Return success with layer details
+        return JSON.stringify({
+            status: "success",
+            message: isAdjustment ? "Adjustment layer created successfully" : "Solid layer created successfully",
+            layer: {
+                name: solidLayer.name,
+                index: solidLayer.index,
+                type: isAdjustment ? "adjustment" : "solid",
+                inPoint: solidLayer.inPoint,
+                outPoint: solidLayer.outPoint,
+                position: solidLayer.property("Position").value,
+                isAdjustment: solidLayer.adjustmentLayer
+            }
+        }, 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 = createSolidLayer(args);
+
+// Write the result so it can be captured by the Node.js process
+$.write(result); 

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

@@ -0,0 +1,115 @@
+// createTextLayer.jsx
+// Creates a new text layer in the specified composition
+
+function createTextLayer(args) {
+    try {
+        // Extract parameters from args
+        var compName = args.compName || "";
+        var text = args.text || "Text Layer";
+        var position = args.position || [960, 540]; // Default to center
+        var fontSize = args.fontSize || 72;
+        var color = args.color || [1, 1, 1]; // Default to white
+        var startTime = args.startTime || 0;
+        var duration = args.duration || 5; // Default 5 seconds
+        var fontFamily = args.fontFamily || "Arial";
+        var alignment = args.alignment || "center"; // "left", "center", "right"
+        
+        // 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 the text layer
+        var textLayer = comp.layers.addText(text);
+        
+        // Get text properties
+        var textProp = textLayer.property("ADBE Text Properties").property("ADBE Text Document");
+        var textDocument = textProp.value;
+        
+        // Set font size and color
+        textDocument.fontSize = fontSize;
+        textDocument.fillColor = color;
+        textDocument.font = fontFamily;
+        
+        // Set text alignment
+        if (alignment === "left") {
+            textDocument.justification = ParagraphJustification.LEFT_JUSTIFY;
+        } else if (alignment === "center") {
+            textDocument.justification = ParagraphJustification.CENTER_JUSTIFY;
+        } else if (alignment === "right") {
+            textDocument.justification = ParagraphJustification.RIGHT_JUSTIFY;
+        }
+        
+        // Update the text property
+        textProp.setValue(textDocument);
+        
+        // Set position
+        textLayer.property("Position").setValue(position);
+        
+        // Set timing
+        textLayer.startTime = startTime;
+        if (duration > 0) {
+            textLayer.outPoint = startTime + duration;
+        }
+        
+        // Return success with layer details
+        return JSON.stringify({
+            status: "success",
+            message: "Text layer created successfully",
+            layer: {
+                name: textLayer.name,
+                index: textLayer.index,
+                type: "text",
+                inPoint: textLayer.inPoint,
+                outPoint: textLayer.outPoint,
+                position: textLayer.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 = createTextLayer(args);
+
+// Write the result so it can be captured by the Node.js process
+$.write(result); 

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

@@ -0,0 +1,192 @@
+// getLayerInfo.jsx
+// Get detailed information about layers in a composition
+
+function getLayerInfo() {
+    var project = app.project;
+    var compName = undefined;
+    
+    // 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);
+                compName = args.compositionName;
+            } catch (e) {
+                // Handle parsing error
+            }
+        }
+    }
+    
+    var result = { 
+        compositions: []
+    };
+    
+    // Find compositions and their layers
+    for (var i = 1; i <= project.numItems; i++) {
+        var item = project.item(i);
+        if (item instanceof CompItem && (!compName || item.name === compName)) {
+            var compData = {
+                name: item.name,
+                id: item.id,
+                duration: item.duration,
+                frameRate: item.frameRate,
+                width: item.width,
+                height: item.height,
+                layers: []
+            };
+            
+            // Process layers in the composition
+            for (var j = 1; j <= item.numLayers; j++) {
+                var layer = item.layer(j);
+                var layerData = {
+                    name: layer.name,
+                    index: layer.index,
+                    enabled: layer.enabled,
+                    locked: layer.locked,
+                    solo: layer.solo,
+                    shy: layer.shy,
+                    type: determineLayerType(layer),
+                    inPoint: layer.inPoint,
+                    outPoint: layer.outPoint,
+                    duration: layer.outPoint - layer.inPoint,
+                    startTime: layer.startTime,
+                    label: layer.label,
+                    hasAudio: layer.hasAudio,
+                    hasVideo: layer.hasVideo,
+                    position: layer.position.value,
+                    effects: getEffects(layer),
+                    properties: getKeyProperties(layer)
+                };
+                
+                compData.layers.push(layerData);
+            }
+            
+            result.compositions.push(compData);
+            
+            if (compName) {
+                break; // If we found the specific comp, no need to continue
+            }
+        }
+    }
+    
+    return JSON.stringify(result, null, 2);
+}
+
+function determineLayerType(layer) {
+    if (!layer.source) {
+        return "Null";
+    }
+    
+    if (layer.source instanceof CompItem) {
+        return "Composition";
+    }
+    
+    if (layer.source instanceof FootageItem) {
+        if (layer.source.mainSource instanceof SolidSource) {
+            return "Solid";
+        }
+        
+        if (layer.source.mainSource instanceof FileSource) {
+            if (layer.source.hasVideo) {
+                return "Video";
+            }
+            if (layer.source.hasAudio) {
+                return "Audio";
+            }
+            
+            // Check file extension for image types
+            var fileName = layer.source.file.name.toLowerCase();
+            if (/\.(png|jpg|jpeg|gif|tiff|tif|bmp|psd|ai|eps)$/.test(fileName)) {
+                return "Image";
+            }
+        }
+        
+        if (layer.source.mainSource instanceof PlaceholderSource) {
+            return "Placeholder";
+        }
+        
+        return "Footage";
+    }
+    
+    if (layer.text) {
+        return "Text";
+    }
+    
+    if (layer.name.indexOf("Light") === 0) {
+        return "Light";
+    }
+    
+    if (layer.name.indexOf("Camera") === 0) {
+        return "Camera";
+    }
+    
+    return "Unknown";
+}
+
+function getEffects(layer) {
+    var effects = [];
+    
+    if (!layer.effect || layer.effect.numProperties === 0) {
+        return effects;
+    }
+    
+    for (var i = 1; i <= layer.effect.numProperties; i++) {
+        var effect = layer.effect(i);
+        effects.push({
+            name: effect.name,
+            matchName: effect.matchName,
+            enabled: effect.enabled
+        });
+    }
+    
+    return effects;
+}
+
+function getKeyProperties(layer) {
+    var properties = [];
+    
+    // Common properties to check
+    var propNames = [
+        "Opacity", "Position", "Scale", "Rotation",
+        "Anchor Point", "Transform", "Effects"
+    ];
+    
+    for (var i = 0; i < propNames.length; i++) {
+        try {
+            var propName = propNames[i];
+            var prop = layer.property(propName);
+            
+            if (prop && prop.numKeys > 0) {
+                var keyframes = [];
+                
+                for (var k = 1; k <= prop.numKeys; k++) {
+                    keyframes.push({
+                        time: prop.keyTime(k),
+                        value: prop.keyValue(k)
+                    });
+                }
+                
+                properties.push({
+                    name: propName,
+                    numKeys: prop.numKeys,
+                    keyframes: keyframes
+                });
+            }
+        } catch (e) {
+            // Skip properties that don't exist or can't be accessed
+        }
+    }
+    
+    return properties;
+}
+
+// Run the function and write the result
+var result = getLayerInfo();
+
+// Write the result so it can be captured by the Node.js process
+$.write(result);

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

@@ -0,0 +1,90 @@
+// getProjectInfo.jsx
+// Get information about the current After Effects project
+
+function getProjectInfo() {
+    var project = app.project;
+    var result = {
+        projectName: project.file ? project.file.name : "Untitled Project",
+        path: project.file ? project.file.fsName : "",
+        numItems: project.numItems,
+        bitsPerChannel: project.bitsPerChannel,
+        timeMode: project.timeDisplayType === TimeDisplayType.FRAMES ? "Frames" : "Timecode",
+        items: []
+    };
+
+    // Count item types
+    var countByType = {
+        compositions: 0,
+        footage: 0,
+        folders: 0,
+        solids: 0
+    };
+
+    // Get item information
+    for (var i = 1; i <= project.numItems; i++) {
+        var item = project.item(i);
+        var itemType = "";
+        
+        if (item instanceof CompItem) {
+            itemType = "Composition";
+            countByType.compositions++;
+        } else if (item instanceof FolderItem) {
+            itemType = "Folder";
+            countByType.folders++;
+        } else if (item instanceof FootageItem) {
+            if (item.mainSource instanceof SolidSource) {
+                itemType = "Solid";
+                countByType.solids++;
+            } else {
+                itemType = "Footage";
+                countByType.footage++;
+            }
+        }
+        
+        result.items.push({
+            id: item.id,
+            name: item.name,
+            type: itemType
+        });
+    }
+    
+    result.itemCounts = countByType;
+
+    // Include active composition metadata if available
+    if (app.project.activeItem instanceof CompItem) {
+        var ac = app.project.activeItem;
+        result.activeComp = {
+            id: ac.id,
+            name: ac.name,
+            width: ac.width,
+            height: ac.height,
+            duration: ac.duration,
+            frameRate: ac.frameRate,
+            numLayers: ac.numLayers
+        };
+    }
+    
+    return JSON.stringify(result, 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
+        }
+    }
+}
+
+// Run the function and write the result
+var result = getProjectInfo();
+
+// Write the result so it can be captured by the Node.js process
+$.write(result);

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

@@ -0,0 +1,50 @@
+// listCompositions.jsx
+// Lists all compositions in the current project
+
+function listCompositions() {
+    var project = app.project;
+    var result = {
+        projectName: project.file ? project.file.name : "Untitled Project",
+        compositions: []
+    };
+
+    for (var i = 1; i <= project.numItems; i++) {
+        var item = project.item(i);
+        if (item instanceof CompItem) {
+            result.compositions.push({
+                name: item.name,
+                id: item.id,
+                duration: item.duration,
+                frameDuration: item.frameDuration,
+                frameRate: item.frameRate,
+                width: item.width,
+                height: item.height,
+                numLayers: item.numLayers
+            });
+        }
+    }
+
+    return JSON.stringify(result, 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
+        }
+    }
+}
+
+// Run the function and write the result
+var result = listCompositions();
+
+// Write the result so it can be captured by the Node.js process
+$.write(result);