n8n-nodes-supermachine 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,24 @@
+# n8n-nodes-supermachine
+
+[![npm version](https://badge.fury.io/js/n8n-nodes-supermachine.svg)](https://www.npmjs.com/package/n8n-nodes-supermachine)
+
+This is an n8n community node for the [Supermachine AI Image API](https://supermachine.art). It lets you generate AI images, manage models, LoRAs, and characters in your n8n workflows.
+
+[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.
+
+## Installation
+
+Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.
+
+### Via n8n UI
+
+1. Go to **Settings** > **Community Nodes**
+2. Select **Install**
+3. Enter `n8n-nodes-supermachine` in **Enter npm package name**
+4. Click **Install**
+5. Restart n8n
+
+### Via CLI
+
+```bash
+npm install n8n-nodes-supermachine

package/dist/credentials/SupermachineApi.credentials.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupermachineApi = void 0;
+class SupermachineApi {
+    name = 'supermachineApi';
+    displayName = 'Supermachine API';
+    documentationUrl = 'https://knowledge.supermachine.art/help/accessing-the-supermachine-api';
+    properties = [
+        {
+            displayName: 'API Key',
+            name: 'apiKey',
+            type: 'string',
+            typeOptions: { password: true },
+            default: '',
+            required: true,
+            placeholder: 'sk-xxxxxxxxxxxxxxxxxxxxxx',
+            description: 'Your Supermachine API key. Get it from <a href="https://supermachine.art/settings/api" target="_blank">Supermachine Settings</a>',
+        },
+    ];
+    authenticate = {
+        type: 'generic',
+        properties: {
+            headers: {
+                'Authorization': '=Bearer {{$credentials.apiKey}}',
+            },
+        },
+    };
+    test = {
+        request: {
+            baseURL: 'https://dev.supermachine.art',
+            url: '/v1/user',
+            method: 'GET',
+        },
+    };
+}
+exports.SupermachineApi = SupermachineApi;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentials = exports.nodes = void 0;
+const Supermachine_node_1 = require("./nodes/Supermachine/Supermachine.node");
+const SupermachineApi_credentials_1 = require("./credentials/SupermachineApi.credentials");
+exports.nodes = [Supermachine_node_1.Supermachine];
+exports.credentials = [SupermachineApi_credentials_1.SupermachineApi];

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

@@ -0,0 +1,477 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Supermachine = void 0;
+const descriptions_1 = require("./descriptions");
+class Supermachine {
+    description = {
+        displayName: 'Supermachine',
+        name: 'supermachine',
+        icon: 'file:supermachine.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+        description: 'Interact with Supermachine AI Image API',
+        defaults: { name: 'Supermachine' },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [{ name: 'supermachineApi', required: true }],
+        properties: [
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options',
+                noDataExpression: true,
+                options: [
+                    { name: 'Account', value: 'account' },
+                    { name: 'Image', value: 'image' },
+                    { name: 'Tools', value: 'tools' },
+                ],
+                default: 'image',
+            },
+            ...descriptions_1.getAccountOperations,
+            ...descriptions_1.getAccountFields,
+            ...descriptions_1.getImageOperations,
+            ...descriptions_1.getImageFields,
+            ...descriptions_1.getToolsOperations,
+            ...descriptions_1.getToolsFields,
+        ],
+    };
+    methods = {
+        loadOptions: {
+            // ═══════════════════════════════════════════════════════════
+            // Load danh sách Models
+            // ═══════════════════════════════════════════════════════════
+            async getModels() {
+                const credentials = await this.getCredentials('supermachineApi');
+                const apiKey = credentials.apiKey;
+                try {
+                    const response = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: 'https://dev.supermachine.art/v1/models',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    const items = response.items;
+                    if (!Array.isArray(items) || items.length === 0) {
+                        return [{ name: 'No models available', value: '' }];
+                    }
+                    return items.map((model) => ({
+                        name: model.title,
+                        value: model.title,
+                        description: `${model.slug} (ID: ${model.id})`,
+                    }));
+                }
+                catch (error) {
+                    console.error('Supermachine getModels error:', error);
+                    return [{ name: `⚠️ Error: ${error.message}`, value: '' }];
+                }
+            },
+            // ═══════════════════════════════════════════════════════════
+            // Load danh sách LoRAs theo modelId được chọn
+            // ═══════════════════════════════════════════════════════════
+            async getLoras() {
+                const credentials = await this.getCredentials('supermachineApi');
+                const apiKey = credentials.apiKey;
+                const modelTitle = this.getNodeParameter('model');
+                if (!modelTitle) {
+                    return [{
+                            name: '⚠️ Please select a model first',
+                            value: '',
+                            description: 'LoRAs depend on the selected model'
+                        }];
+                }
+                try {
+                    const modelsResponse = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: 'https://dev.supermachine.art/v1/models',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    const models = modelsResponse.items;
+                    const selectedModel = models.find((m) => m.title === modelTitle);
+                    if (!selectedModel) {
+                        return [{
+                                name: `⚠️ Model "${modelTitle}" not found`,
+                                value: '',
+                                description: 'Try refreshing the page'
+                            }];
+                    }
+                    const modelId = selectedModel.id;
+                    const lorasResponse = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: `https://dev.supermachine.art/v1/loras?modelId=${modelId}`,
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    const items = lorasResponse.items;
+                    if (!Array.isArray(items) || items.length === 0) {
+                        return [{
+                                name: 'No LoRAs available for this model',
+                                value: '',
+                                description: `Model "${modelTitle}" doesn't support LoRAs`
+                            }];
+                    }
+                    return items.map((lora) => {
+                        const triggerWords = lora.triggerWords || [];
+                        const triggerHint = triggerWords.length > 0
+                            ? ` | Trigger: ${triggerWords.join(', ')}`
+                            : '';
+                        return {
+                            name: lora.name,
+                            value: String(lora.id),
+                            description: `${lora.slug}${triggerHint}`,
+                        };
+                    });
+                }
+                catch (error) {
+                    console.error('Supermachine getLoras error:', error);
+                    return [{
+                            name: `⚠️ Error loading LoRAs: ${error.message}`,
+                            value: '',
+                            description: 'Check your API key and network connection'
+                        }];
+                }
+            },
+            // ═══════════════════════════════════════════════════════════
+            // Load danh sách Character Categories
+            // ═══════════════════════════════════════════════════════════
+            async getCharacterCategories() {
+                const credentials = await this.getCredentials('supermachineApi');
+                const apiKey = credentials.apiKey;
+                try {
+                    const response = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: 'https://dev.supermachine.art/v1/characters/categories',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    const items = response.items;
+                    if (!Array.isArray(items) || items.length === 0) {
+                        return [{
+                                name: 'No categories available',
+                                value: '',
+                                description: 'Character categories may not be enabled'
+                            }];
+                    }
+                    return items.map((category) => ({
+                        name: category.name,
+                        value: String(category.id),
+                        description: `Category ID: ${category.id}`,
+                    }));
+                }
+                catch (error) {
+                    console.error('Supermachine getCharacterCategories error:', error);
+                    return [{
+                            name: `⚠️ Error: ${error.message}`,
+                            value: '',
+                            description: 'Check your API key and permissions'
+                        }];
+                }
+            },
+            // ═══════════════════════════════════════════════════════════
+            // Load danh sách Characters (phụ thuộc category + model)
+            // ═══════════════════════════════════════════════════════════
+            async getCharacters() {
+                const credentials = await this.getCredentials('supermachineApi');
+                const apiKey = credentials.apiKey;
+                const additionalFields = this.getCurrentNodeParameter('additionalFields');
+                const categoryId = additionalFields?.characterCategory;
+                const modelTitle = this.getNodeParameter('model');
+                if (!categoryId) {
+                    return [{
+                            name: '⚠️ Please select a Character Category first',
+                            value: '',
+                            description: 'Characters depend on the selected category'
+                        }];
+                }
+                if (!modelTitle) {
+                    return [{
+                            name: '⚠️ Please select a Model first',
+                            value: '',
+                            description: 'Characters depend on the selected model'
+                        }];
+                }
+                try {
+                    const modelsResponse = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: 'https://dev.supermachine.art/v1/models',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    const models = modelsResponse.items;
+                    const selectedModel = models.find((m) => m.title === modelTitle);
+                    if (!selectedModel) {
+                        return [{
+                                name: `⚠️ Model "${modelTitle}" not found`,
+                                value: '',
+                                description: 'Try refreshing the page'
+                            }];
+                    }
+                    const modelId = selectedModel.id;
+                    const charactersResponse = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: `https://dev.supermachine.art/v1/characters?categoryId=${categoryId}&modelId=${modelId}`,
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    });
+                    const items = charactersResponse.items;
+                    if (!Array.isArray(items) || items.length === 0) {
+                        return [{
+                                name: 'No characters available',
+                                value: '',
+                                description: `No characters found for this category and model combination`
+                            }];
+                    }
+                    return items.map((character) => {
+                        const embedCode = character.embedCode;
+                        const embedHint = embedCode ? ` | Use: "${embedCode}"` : '';
+                        return {
+                            name: character.name,
+                            value: String(character.id),
+                            description: `${character.slug}${embedHint}`,
+                        };
+                    });
+                }
+                catch (error) {
+                    console.error('Supermachine getCharacters error:', error);
+                    return [{
+                            name: `⚠️ Error loading characters: ${error.message}`,
+                            value: '',
+                            description: 'Check your API key and network connection'
+                        }];
+                }
+            },
+        },
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                let requestOptions = {
+                    method: 'GET',
+                    url: '',
+                    json: true,
+                };
+                // ══════════════════════════════════════════════════════
+                // ACCOUNT OPERATIONS
+                // ══════════════════════════════════════════════════════
+                if (resource === 'account') {
+                    if (operation === 'getProfile') {
+                        requestOptions.url = 'https://dev.supermachine.art/v1/user';
+                    }
+                    else if (operation === 'listModels') {
+                        requestOptions.url = 'https://dev.supermachine.art/v1/models';
+                        if (!this.getNodeParameter('returnAll', i, false)) {
+                            requestOptions.qs = {
+                                perPage: this.getNodeParameter('limit', i, 20),
+                                page: 1,
+                            };
+                        }
+                    }
+                    else if (operation === 'getModelDetail') {
+                        const modelTitle = this.getNodeParameter('modelId', i);
+                        const modelsResponse = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', { method: 'GET', url: 'https://dev.supermachine.art/v1/models', json: true });
+                        const models = modelsResponse.items;
+                        const model = models.find((m) => m.title === modelTitle);
+                        if (!model) {
+                            throw new Error(`Model "${modelTitle}" not found`);
+                        }
+                        requestOptions.url = `https://dev.supermachine.art/v1/models/gems/id/${model.id}`;
+                    }
+                    else if (operation === 'listModelCategories') {
+                        requestOptions.url = 'https://dev.supermachine.art/v1/models/categories';
+                    }
+                    else if (operation === 'listLoras') {
+                        const modelTitle = this.getNodeParameter('modelId', i);
+                        const modelsResponse = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', { method: 'GET', url: 'https://dev.supermachine.art/v1/models', json: true });
+                        const models = modelsResponse.items;
+                        const model = models.find((m) => m.title === modelTitle);
+                        if (!model) {
+                            throw new Error(`Model "${modelTitle}" not found`);
+                        }
+                        requestOptions.url = `https://dev.supermachine.art/v1/loras?modelId=${model.id}`;
+                    }
+                    else if (operation === 'listLoraCategories') {
+                        requestOptions.url = 'https://dev.supermachine.art/v1/loras/categories';
+                    }
+                    else if (operation === 'listCharacterCategories') {
+                        requestOptions.url = 'https://dev.supermachine.art/v1/characters/categories';
+                    }
+                }
+                // ══════════════════════════════════════════════════════
+                // IMAGE OPERATIONS
+                // ══════════════════════════════════════════════════════
+                else if (resource === 'image') {
+                    if (operation === 'generate') {
+                        // BƯỚC 1: Start generation
+                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                        const body = {
+                            prompt: this.getNodeParameter('prompt', i),
+                            model: this.getNodeParameter('model', i),
+                            width: this.getNodeParameter('width', i, 1024),
+                            height: this.getNodeParameter('height', i, 768),
+                        };
+                        // Add optional fields
+                        if (additionalFields.negativePrompt) {
+                            body.negativePrompt = additionalFields.negativePrompt;
+                        }
+                        if (additionalFields.numberResults) {
+                            body.numberResults = additionalFields.numberResults;
+                        }
+                        if (additionalFields.outputFormat) {
+                            body.outputFormat = additionalFields.outputFormat;
+                        }
+                        if (additionalFields.seed) {
+                            body.seed = additionalFields.seed;
+                        }
+                        if (additionalFields.steps) {
+                            body.steps = additionalFields.steps;
+                        }
+                        if (additionalFields.cfgScale) {
+                            body.cfgScale = additionalFields.cfgScale;
+                        }
+                        // Add LoRAs
+                        if (additionalFields.loras) {
+                            const lorasData = additionalFields.loras;
+                            const loraValues = lorasData.loraValues;
+                            if (Array.isArray(loraValues) && loraValues.length > 0) {
+                                body.loras = loraValues.map((lora) => ({
+                                    id: lora.loraId,
+                                    strength: lora.strength || 1,
+                                }));
+                            }
+                        }
+                        // Add character
+                        if (additionalFields.characterId) {
+                            body.characterId = additionalFields.characterId;
+                        }
+                        // Add img2img
+                        if (additionalFields.img2img) {
+                            const img2imgData = additionalFields.img2img;
+                            const img2imgValues = img2imgData.img2imgValues;
+                            if (Array.isArray(img2imgValues) && img2imgValues.length > 0) {
+                                const img2img = img2imgValues[0];
+                                if (img2img.sourceImageUrl) {
+                                    body.sourceImageUrl = img2img.sourceImageUrl;
+                                    body.denoisingStrength = img2img.denoisingStrength || 0.75;
+                                }
+                            }
+                        }
+                        // Start generation
+                        const generateResponse = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                            method: 'POST',
+                            url: 'https://dev.supermachine.art/v1/generate',
+                            json: true,
+                            body,
+                        });
+                        const batchId = generateResponse.batchId;
+                        if (!batchId) {
+                            throw new Error('No batchId returned from generate API');
+                        }
+                        // BƯỚC 2: Poll for completion
+                        const pollingInterval = additionalFields.pollingInterval || 2;
+                        const maxPollingTime = additionalFields.maxPollingTime || 120;
+                        const startTime = Date.now();
+                        let completedImage = null;
+                        while (!completedImage) {
+                            // Check timeout
+                            if ((Date.now() - startTime) / 1000 > maxPollingTime) {
+                                throw new Error(`Image generation timed out after ${maxPollingTime} seconds. BatchId: ${batchId}`);
+                            }
+                            // Wait before polling
+                            await new Promise((resolve) => setTimeout(resolve, pollingInterval * 1000));
+                            // Poll status
+                            const pollResponse = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+                                method: 'GET',
+                                url: `https://dev.supermachine.art/v1/images?batchId=${batchId}`,
+                                json: true,
+                            });
+                            const items = pollResponse.items;
+                            if (Array.isArray(items) && items.length > 0) {
+                                const firstItem = items[0];
+                                const status = firstItem.status;
+                                if (status === 'completed') {
+                                    completedImage = firstItem;
+                                    break;
+                                }
+                                else if (status === 'failed') {
+                                    throw new Error(`Image generation failed. BatchId: ${batchId}. Error: ${firstItem.error || 'Unknown error'}`);
+                                }
+                                // If status is 'pending' or 'processing', continue polling
+                            }
+                        }
+                        // Return completed image data
+                        returnData.push({
+                            json: {
+                                batchId,
+                                ...completedImage,
+                            }
+                        });
+                    }
+                    else if (operation === 'listImages') {
+                        const batchId = this.getNodeParameter('batchId', i);
+                        requestOptions.url = `https://dev.supermachine.art/v1/images?batchId=${batchId}`;
+                        if (!this.getNodeParameter('returnAll', i, false)) {
+                            requestOptions.qs = {
+                                limit: this.getNodeParameter('limit', i, 20),
+                                page: this.getNodeParameter('page', i, 1),
+                            };
+                        }
+                        const responseData = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', requestOptions);
+                        returnData.push({ json: responseData });
+                    }
+                }
+                // ══════════════════════════════════════════════════════
+                // TOOLS OPERATIONS
+                // ══════════════════════════════════════════════════════
+                else if (resource === 'tools') {
+                    throw new Error('Tools operations chưa có endpoints chính thức từ Supermachine API docs. Vui lòng check documentation.');
+                }
+                const responseData = await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', requestOptions);
+                let jsonData;
+                if (operation === 'listModels' || operation === 'listImages' || operation === 'listLoras') {
+                    jsonData = responseData;
+                }
+                else {
+                    jsonData = responseData.items || responseData;
+                }
+                returnData.push({ json: jsonData });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                            stack: error.stack,
+                        }
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Supermachine = Supermachine;

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountFields = exports.getAccountOperations = void 0;
+exports.getAccountOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['account'],
+            },
+        },
+        options: [
+            {
+                name: 'Get Profile',
+                value: 'getProfile',
+                description: 'Lấy thông tin tài khoản và credit còn lại',
+                action: 'Get account profile',
+            },
+            {
+                name: 'List Models',
+                value: 'listModels',
+                description: 'Liệt kê tất cả models có sẵn',
+                action: 'List available models',
+            },
+            {
+                name: 'Get Model Categories',
+                value: 'listModelCategories',
+                description: 'Lấy danh mục models',
+                action: 'List model categories',
+            },
+        ],
+        default: 'getProfile',
+    },
+];
+exports.getAccountFields = [
+    // Get Profile - không cần fields
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                resource: ['account'],
+                operation: ['listModels', 'listModelCategories'],
+            },
+        },
+        default: false,
+        description: 'Trả về tất cả kết quả hay chỉ giới hạn',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        typeOptions: {
+            minValue: 1,
+            maxValue: 100,
+        },
+        displayOptions: {
+            show: {
+                resource: ['account'],
+                operation: ['listModels', 'listModelCategories'],
+                returnAll: [false],
+            },
+        },
+        default: 20,
+        description: 'Số lượng items trả về mỗi trang',
+    },
+];