n8n-nodes-supermachine 0.8.0 → 0.10.0

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

@@ -1183,6 +1183,154 @@ class Supermachine {
                             });
                         }
                     }
+                    else if (operation === 'upscale') {
+                        const imageSource = this.getNodeParameter('imageSource', i);
+                        const upscaler = this.getNodeParameter('upscaler', i);
+                        const factor = this.getNodeParameter('factor', i);
+                        const additionalOptions = this.getNodeParameter('additionalOptions', i, {});
+                        let imageUrl = '';
+                        if (imageSource === 'imageId') {
+                            const imageId = this.getNodeParameter('imageId', i);
+                            const imageDetails = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                                method: 'GET',
+                                url: `https://dev.supermachine.art/v1/images/${imageId}`,
+                                json: true,
+                            });
+                            imageUrl = imageDetails.url;
+                            if (!imageUrl) {
+                                throw new Error(`Image ID ${imageId} does not have a valid URL`);
+                            }
+                        }
+                        else if (imageSource === 'imageUrl') {
+                            imageUrl = this.getNodeParameter('imageUrl', i);
+                        }
+                        const imageBuffer = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: imageUrl,
+                            encoding: 'arraybuffer',
+                            returnFullResponse: false,
+                        });
+                        const base64Image = Buffer.from(imageBuffer).toString('base64');
+                        let mimeType = 'image/jpeg';
+                        if (imageUrl.toLowerCase().includes('.png')) {
+                            mimeType = 'image/png';
+                        }
+                        else if (imageUrl.toLowerCase().includes('.webp')) {
+                            mimeType = 'image/webp';
+                        }
+                        const dataUri = `data:${mimeType};base64,${base64Image}`;
+                        const body = {
+                            image: dataUri,
+                            upscaler: upscaler,
+                            factor: factor,
+                            faceEnhance: additionalOptions.faceEnhance || false,
+                        };
+                        if (additionalOptions.folderId) {
+                            body.folderId = parseInt(additionalOptions.folderId, 10) || 0;
+                        }
+                        let upscaleResponse;
+                        try {
+                            upscaleResponse = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                                method: 'POST',
+                                url: 'https://dev.supermachine.art/v1/tools/upscale',
+                                json: true,
+                                body,
+                            });
+                        }
+                        catch (error) {
+                            throw new Error(`Failed to upscale image: ${error.message}`);
+                        }
+                        const batchId = upscaleResponse.batchId;
+                        if (!batchId) {
+                            if (upscaleResponse.url || upscaleResponse.imageUrl) {
+                                returnData.push({
+                                    json: {
+                                        success: true,
+                                        imageUrl: upscaleResponse.url || upscaleResponse.imageUrl,
+                                        imageId: upscaleResponse.id || upscaleResponse.imageId,
+                                        creditsCost: upscaleResponse.creditsCost,
+                                        creditsRemaining: upscaleResponse.creditsRemaining,
+                                        upscaler,
+                                        factor,
+                                        faceEnhance: body.faceEnhance,
+                                        processedAt: new Date().toISOString(),
+                                        ...upscaleResponse,
+                                    }
+                                });
+                                continue;
+                            }
+                            throw new Error('No batchId or result returned from upscale API');
+                        }
+                        const skipPolling = additionalOptions.skipPolling;
+                        if (skipPolling) {
+                            returnData.push({
+                                json: {
+                                    batchId,
+                                    tool: upscaleResponse.tool || 'upscale',
+                                    creditsCost: upscaleResponse.creditsCost,
+                                    creditsRemaining: upscaleResponse.creditsRemaining,
+                                    upscaler,
+                                    factor,
+                                    faceEnhance: body.faceEnhance,
+                                    status: 'submitted',
+                                    message: 'Image upscaling submitted. Use List Images with this batchId to check status.',
+                                    submittedAt: new Date().toISOString(),
+                                    ...upscaleResponse,
+                                }
+                            });
+                            continue;
+                        }
+                        const pollingInterval = additionalOptions.pollingInterval || 2;
+                        const maxPollingTime = additionalOptions.maxPollingTime || 120;
+                        const startTime = Date.now();
+                        let completedResult = null;
+                        await new Promise((resolve) => setTimeout(resolve, 2000));
+                        while (!completedResult) {
+                            if ((Date.now() - startTime) / 1000 > maxPollingTime) {
+                                throw new Error(`Image upscaling timed out after ${maxPollingTime} seconds. Batch ID: ${batchId}`);
+                            }
+                            let pollResponse;
+                            try {
+                                pollResponse = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                                    method: 'GET',
+                                    url: `https://dev.supermachine.art/v1/images?batchId=${batchId}`,
+                                    json: true,
+                                });
+                            }
+                            catch (error) {
+                                await new Promise((resolve) => setTimeout(resolve, pollingInterval * 1000));
+                                continue;
+                            }
+                            const pollItems = pollResponse.items;
+                            if (Array.isArray(pollItems) && pollItems.length > 0) {
+                                const firstItem = pollItems[0];
+                                const status = firstItem.status;
+                                if (status === 'completed') {
+                                    completedResult = firstItem;
+                                    break;
+                                }
+                                else if (status === 'failed') {
+                                    throw new Error(`Image upscaling failed. Batch ID: ${batchId}. Error: ${firstItem.error || 'Unknown error'}`);
+                                }
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, pollingInterval * 1000));
+                        }
+                        returnData.push({
+                            json: {
+                                batchId,
+                                success: true,
+                                operation: 'upscale',
+                                tool: 'upscale',
+                                upscaler,
+                                factor,
+                                faceEnhance: body.faceEnhance,
+                                creditsCost: upscaleResponse.creditsCost,
+                                creditsRemaining: upscaleResponse.creditsRemaining,
+                                processedAt: new Date().toISOString(),
+                                ...completedResult,
+                            }
+                        });
+                    }
                     else {
                         throw new Error(`⚠️ Operation "${operation}" is coming soon.`);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-supermachine",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "n8n community node for Supermachine AI Image API — Generate images, manage models, LoRAs, and characters",
   "keywords": [
     "n8n-community-node-package",
@@ -54,6 +54,7 @@
     "gulp": "^5.0.1",
     "gulp-sourcemaps": "^3.0.0",
     "gulp-typescript": "^6.0.0-alpha.1",
+    "merge-stream": "^2.0.0",
     "n8n-workflow": "*",
     "prettier": "^2.8.8",
     "typescript": "^5.3.3"