n8n-nodes-supermachine 0.7.0 → 0.7.1

package/dist/nodes/Supermachine/Supermachine.node.js

@@ -1379,8 +1379,164 @@ class Supermachine {
                             }
                         });
                     }
+                    else if (operation === 'faceSwap') {
+                        const faceImageSource = this.getNodeParameter('faceImageSource', i);
+                        const targetImageSource = this.getNodeParameter('targetImageSource', i);
+                        const additionalOptions = this.getNodeParameter('additionalOptions', i, {});
+                        let faceImageUrl = '';
+                        let targetImageUrl = '';
+                        // Step 1: Get face image URL
+                        if (faceImageSource === 'imageId') {
+                            const faceImageId = this.getNodeParameter('faceImageId', i);
+                            const faceImageDetails = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                                method: 'GET',
+                                url: `https://dev.supermachine.art/v1/images/${faceImageId}`,
+                                json: true,
+                            });
+                            faceImageUrl = faceImageDetails.url;
+                            if (!faceImageUrl) {
+                                throw new Error(`Face image ID ${faceImageId} does not have a valid URL`);
+                            }
+                        }
+                        else if (faceImageSource === 'imageUrl') {
+                            faceImageUrl = this.getNodeParameter('faceImageUrl', i);
+                        }
+                        // Step 2: Get target image URL
+                        if (targetImageSource === 'imageId') {
+                            const targetImageId = this.getNodeParameter('targetImageId', i);
+                            const targetImageDetails = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                                method: 'GET',
+                                url: `https://dev.supermachine.art/v1/images/${targetImageId}`,
+                                json: true,
+                            });
+                            targetImageUrl = targetImageDetails.url;
+                            if (!targetImageUrl) {
+                                throw new Error(`Target image ID ${targetImageId} does not have a valid URL`);
+                            }
+                        }
+                        else if (targetImageSource === 'imageUrl') {
+                            targetImageUrl = this.getNodeParameter('targetImageUrl', i);
+                        }
+                        // Step 3: Download face image as binary
+                        const faceImageBuffer = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: faceImageUrl,
+                            encoding: 'arraybuffer',
+                            returnFullResponse: false,
+                        });
+                        // Step 4: Download target image as binary
+                        const targetImageBuffer = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: targetImageUrl,
+                            encoding: 'arraybuffer',
+                            returnFullResponse: false,
+                        });
+                        // Step 5: Convert both images to base64
+                        const base64FaceImage = Buffer.from(faceImageBuffer).toString('base64');
+                        const base64TargetImage = Buffer.from(targetImageBuffer).toString('base64');
+                        // Detect MIME types
+                        let faceMimeType = 'image/jpeg';
+                        if (faceImageUrl.toLowerCase().includes('.png')) {
+                            faceMimeType = 'image/png';
+                        }
+                        else if (faceImageUrl.toLowerCase().includes('.webp')) {
+                            faceMimeType = 'image/webp';
+                        }
+                        let targetMimeType = 'image/jpeg';
+                        if (targetImageUrl.toLowerCase().includes('.png')) {
+                            targetMimeType = 'image/png';
+                        }
+                        else if (targetImageUrl.toLowerCase().includes('.webp')) {
+                            targetMimeType = 'image/webp';
+                        }
+                        const faceDataUri = `data:${faceMimeType};base64,${base64FaceImage}`;
+                        const targetDataUri = `data:${targetMimeType};base64,${base64TargetImage}`;
+                        // Step 6: Submit to face-swap API
+                        const body = {
+                            faceImage: faceDataUri,
+                            targetImage: targetDataUri,
+                        };
+                        // Add folderId if provided
+                        if (additionalOptions.folderId) {
+                            body.folderId = additionalOptions.folderId;
+                        }
+                        let faceSwapResponse;
+                        try {
+                            faceSwapResponse = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                                method: 'POST',
+                                url: 'https://dev.supermachine.art/v1/tools/faceswap',
+                                json: true,
+                                body,
+                            });
+                        }
+                        catch (error) {
+                            throw new Error(`Failed to swap faces: ${error.message}`);
+                        }
+                        const batchId = faceSwapResponse.batchId;
+                        if (!batchId) {
+                            throw new Error('No batch ID returned from face-swap API');
+                        }
+                        // Step 7: Handle polling or return batch ID
+                        const skipPolling = additionalOptions.skipPolling;
+                        if (skipPolling) {
+                            returnData.push({
+                                json: {
+                                    success: true,
+                                    batchId,
+                                    tool: 'faceswap',
+                                    creditsCost: faceSwapResponse.creditsCost || 2,
+                                    creditsRemaining: faceSwapResponse.creditsRemaining,
+                                    operation: 'faceSwap',
+                                    faceImage: faceImageUrl,
+                                    targetImage: targetImageUrl,
+                                    message: 'Face swap job submitted. Use "Get Batch Status" to check results.',
+                                    ...faceSwapResponse,
+                                },
+                            });
+                        }
+                        else {
+                            // Poll for results
+                            const pollingInterval = additionalOptions.pollingInterval || 2;
+                            const maxPollingTime = additionalOptions.maxPollingTime || 120;
+                            const startTime = Date.now();
+                            let completed = false;
+                            let finalResult = null;
+                            while (!completed && (Date.now() - startTime) / 1000 < maxPollingTime) {
+                                await new Promise((resolve) => setTimeout(resolve, pollingInterval * 1000));
+                                const statusResponse = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                                    method: 'GET',
+                                    url: `https://dev.supermachine.art/v1/batches/${batchId}`,
+                                    json: true,
+                                });
+                                const status = statusResponse.status;
+                                if (status === 'completed') {
+                                    completed = true;
+                                    finalResult = statusResponse;
+                                }
+                                else if (status === 'failed') {
+                                    throw new Error(`Face swap failed: ${statusResponse.error || 'Unknown error'}`);
+                                }
+                            }
+                            if (!completed) {
+                                throw new Error(`Face swap timed out after ${maxPollingTime} seconds`);
+                            }
+                            returnData.push({
+                                json: {
+                                    success: true,
+                                    batchId,
+                                    status: 'completed',
+                                    operation: 'faceSwap',
+                                    tool: 'faceswap',
+                                    faceImage: faceImageUrl,
+                                    targetImage: targetImageUrl,
+                                    completedAt: new Date().toISOString(),
+                                    ...finalResult,
+                                },
+                            });
+                        }
+                    }
                     else {
-                        throw new Error(`⚠️ Operation "${operation}" is coming soon.`);
+                        throw new Error(`⚠️ Operation "${operation}" is not yet implemented.`);
                     }
                 }
             }

package/dist/nodes/Supermachine/descriptions/ToolsDescription.js

@@ -38,7 +38,7 @@ exports.getToolsOperations = [
                 action: 'Image to prompt',
             },
             {
-                name: 'Face Swap (Coming Soon)',
+                name: 'Face Swap',
                 value: 'faceSwap',
                 description: 'Swap faces in images',
                 action: 'Face swap',
@@ -260,8 +260,8 @@ exports.getToolsFields = [
                 description: 'High quality 4x upscaling (recommended)',
             },
             {
-                name: 'R-ESRGAN 4x+ Anime',
-                value: 'R-ESRGAN 4x+ Anime',
+                name: 'R-ESRGAN 4x+ Anime6B',
+                value: 'R-ESRGAN 4x+ Anime6B',
                 description: 'Optimized for anime/cartoon images',
             },
         ],
@@ -546,19 +546,176 @@ exports.getToolsFields = [
         description: 'The URL of the image to analyze',
     },
     // ══════════════════════════════════════════════════════
-    // COMING SOON NOTICE FOR OTHER OPERATIONS
+    // FACE SWAP FIELDS
     // ══════════════════════════════════════════════════════
     {
-        displayName: 'Coming Soon',
-        name: 'comingSoonNotice',
-        type: 'notice',
+        displayName: 'Face Image Source',
+        name: 'faceImageSource',
+        type: 'options',
+        displayOptions: {
+            show: {
+                resource: ['tools'],
+                operation: ['faceSwap'],
+            },
+        },
+        options: [
+            {
+                name: 'Image ID',
+                value: 'imageId',
+                description: 'Use an image already in Supermachine by its ID',
+            },
+            {
+                name: 'Image URL',
+                value: 'imageUrl',
+                description: 'Use an external image URL',
+            },
+        ],
+        default: 'imageId',
+        description: 'Where to get the face image from (the face you want to use)',
+    },
+    {
+        displayName: 'Face Image ID',
+        name: 'faceImageId',
+        type: 'string',
+        displayOptions: {
+            show: {
+                resource: ['tools'],
+                operation: ['faceSwap'],
+                faceImageSource: ['imageId'],
+            },
+        },
+        required: true,
+        default: '',
+        placeholder: '12345',
+        description: 'The ID of the face image to use',
+    },
+    {
+        displayName: 'Face Image URL',
+        name: 'faceImageUrl',
+        type: 'string',
+        displayOptions: {
+            show: {
+                resource: ['tools'],
+                operation: ['faceSwap'],
+                faceImageSource: ['imageUrl'],
+            },
+        },
+        required: true,
+        default: '',
+        placeholder: 'https://example.com/face.jpg',
+        description: 'The URL of the face image to use',
+    },
+    {
+        displayName: 'Target Image Source',
+        name: 'targetImageSource',
+        type: 'options',
+        displayOptions: {
+            show: {
+                resource: ['tools'],
+                operation: ['faceSwap'],
+            },
+        },
+        options: [
+            {
+                name: 'Image ID',
+                value: 'imageId',
+                description: 'Use an image already in Supermachine by its ID',
+            },
+            {
+                name: 'Image URL',
+                value: 'imageUrl',
+                description: 'Use an external image URL',
+            },
+        ],
+        default: 'imageId',
+        description: 'Where to get the target image from (the image where face will be swapped)',
+    },
+    {
+        displayName: 'Target Image ID',
+        name: 'targetImageId',
+        type: 'string',
         displayOptions: {
             show: {
                 resource: ['tools'],
                 operation: ['faceSwap'],
+                targetImageSource: ['imageId'],
             },
         },
+        required: true,
         default: '',
-        description: '⚠️ This tool operation is coming soon. It will be available in a future update when Supermachine API provides official endpoints.',
+        placeholder: '67890',
+        description: 'The ID of the target image',
+    },
+    {
+        displayName: 'Target Image URL',
+        name: 'targetImageUrl',
+        type: 'string',
+        displayOptions: {
+            show: {
+                resource: ['tools'],
+                operation: ['faceSwap'],
+                targetImageSource: ['imageUrl'],
+            },
+        },
+        required: true,
+        default: '',
+        placeholder: 'https://example.com/target.jpg',
+        description: 'The URL of the target image',
+    },
+    {
+        displayName: 'Additional Options',
+        name: 'additionalOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['tools'],
+                operation: ['faceSwap'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Save to Folder',
+                name: 'folderId',
+                type: 'options',
+                typeOptions: {
+                    loadOptionsMethod: 'getFolders',
+                },
+                default: '',
+                description: 'Save the result to a specific folder. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+            },
+            {
+                displayName: 'Skip Polling',
+                name: 'skipPolling',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to skip waiting for the result and return immediately with batch ID',
+            },
+            {
+                displayName: 'Polling Interval (seconds)',
+                name: 'pollingInterval',
+                type: 'number',
+                default: 2,
+                description: 'How often to check if face swap is complete (in seconds)',
+                displayOptions: {
+                    show: {
+                        skipPolling: [false],
+                    },
+                },
+            },
+            {
+                displayName: 'Max Polling Time (seconds)',
+                name: 'maxPollingTime',
+                type: 'number',
+                default: 120,
+                description: 'Maximum time to wait for face swap to complete (in seconds)',
+                displayOptions: {
+                    show: {
+                        skipPolling: [false],
+                    },
+                },
+            },
+        ],
     },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-supermachine",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "n8n community node for Supermachine AI Image API — Generate images, manage models, LoRAs, and characters",
   "keywords": [
     "n8n-community-node-package",