n8n-nodes-supermachine 0.1.0

package/nodes/Supermachine/Supermachine.node.ts

@@ -0,0 +1,508 @@
+import type {
+  IExecuteFunctions,
+  INodeExecutionData,
+  INodeType,
+  INodeTypeDescription,
+  IHttpRequestMethods,
+  IDataObject,
+  ILoadOptionsFunctions,
+  INodePropertyOptions,
+} from 'n8n-workflow';
+
+import {
+  getAccountFields,
+  getAccountOperations,
+  getImageFields,
+  getImageOperations,
+  getToolsFields,
+  getToolsOperations,
+} from './descriptions';
+
+export class Supermachine implements INodeType {
+  description: INodeTypeDescription = {
+    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',
+      },
+      ...getAccountOperations,
+      ...getAccountFields,
+      ...getImageOperations,
+      ...getImageFields,
+      ...getToolsOperations,
+      ...getToolsFields,
+    ],
+  };
+
+  methods = {
+    loadOptions: {
+      // ═══════════════════════════════════════════════════════════
+      // Load danh sách Models
+      // ═══════════════════════════════════════════════════════════
+      async getModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+        const credentials = await this.getCredentials('supermachineApi');
+        const apiKey = credentials.apiKey as string;
+        
+        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 as IDataObject).items as IDataObject[];
+          
+          if (!Array.isArray(items) || items.length === 0) {
+            return [{ name: 'No models available', value: '' }];
+          }
+          
+          return items.map((model: IDataObject) => ({
+            name: model.title as string,
+            value: model.title as string,
+            description: `${model.slug} (ID: ${model.id})`,
+          }));
+          
+        } catch (error) {
+          console.error('Supermachine getModels error:', error);
+          return [{ name: `⚠️ Error: ${(error as Error).message}`, value: '' }];
+        }
+      },
+
+      // ═══════════════════════════════════════════════════════════
+      // Load danh sách LoRAs theo modelId được chọn
+      // ═══════════════════════════════════════════════════════════
+      async getLoras(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+        const credentials = await this.getCredentials('supermachineApi');
+        const apiKey = credentials.apiKey as string;
+        
+        const modelTitle = this.getNodeParameter('model') as string;
+        
+        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 as IDataObject).items as IDataObject[];
+          const selectedModel = models.find((m: IDataObject) => 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 as IDataObject).items as IDataObject[];
+          
+          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: IDataObject) => {
+            const triggerWords = lora.triggerWords as string[] || [];
+            const triggerHint = triggerWords.length > 0 
+              ? ` | Trigger: ${triggerWords.join(', ')}` 
+              : '';
+            
+            return {
+              name: lora.name as string,
+              value: String(lora.id),
+              description: `${lora.slug}${triggerHint}`,
+            };
+          });
+          
+        } catch (error) {
+          console.error('Supermachine getLoras error:', error);
+          return [{ 
+            name: `⚠️ Error loading LoRAs: ${(error as Error).message}`, 
+            value: '',
+            description: 'Check your API key and network connection'
+          }];
+        }
+      },
+
+      // ═══════════════════════════════════════════════════════════
+      // Load danh sách Character Categories
+      // ═══════════════════════════════════════════════════════════
+      async getCharacterCategories(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+        const credentials = await this.getCredentials('supermachineApi');
+        const apiKey = credentials.apiKey as string;
+        
+        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 as IDataObject).items as IDataObject[];
+          
+          if (!Array.isArray(items) || items.length === 0) {
+            return [{ 
+              name: 'No categories available', 
+              value: '',
+              description: 'Character categories may not be enabled'
+            }];
+          }
+          
+          return items.map((category: IDataObject) => ({
+            name: category.name as string,
+            value: String(category.id),
+            description: `Category ID: ${category.id}`,
+          }));
+          
+        } catch (error) {
+          console.error('Supermachine getCharacterCategories error:', error);
+          return [{ 
+            name: `⚠️ Error: ${(error as Error).message}`, 
+            value: '',
+            description: 'Check your API key and permissions'
+          }];
+        }
+      },
+
+      // ═══════════════════════════════════════════════════════════
+      // Load danh sách Characters (phụ thuộc category + model)
+      // ═══════════════════════════════════════════════════════════
+      async getCharacters(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+        const credentials = await this.getCredentials('supermachineApi');
+        const apiKey = credentials.apiKey as string;
+        
+        const additionalFields = this.getCurrentNodeParameter('additionalFields') as IDataObject;
+        const categoryId = additionalFields?.characterCategory as string;
+        const modelTitle = this.getNodeParameter('model') as string;
+        
+        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 as IDataObject).items as IDataObject[];
+          const selectedModel = models.find((m: IDataObject) => 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 as IDataObject).items as IDataObject[];
+          
+          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: IDataObject) => {
+            const embedCode = character.embedCode as string;
+            const embedHint = embedCode ? ` | Use: "${embedCode}"` : '';
+            
+            return {
+              name: character.name as string,
+              value: String(character.id),
+              description: `${character.slug}${embedHint}`,
+            };
+          });
+          
+        } catch (error) {
+          console.error('Supermachine getCharacters error:', error);
+          return [{ 
+            name: `⚠️ Error loading characters: ${(error as Error).message}`, 
+            value: '',
+            description: 'Check your API key and network connection'
+          }];
+        }
+      },
+    },
+  };
+
+  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+    const items = this.getInputData();
+    const returnData: INodeExecutionData[] = [];
+    
+    for (let i = 0; i < items.length; i++) {
+      try {
+        const resource = this.getNodeParameter('resource', i) as string;
+        const operation = this.getNodeParameter('operation', i) as string;
+        
+        let requestOptions: IDataObject = {
+          method: 'GET' as IHttpRequestMethods,
+          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) as string;
+            const modelsResponse = await this.helpers.requestWithAuthentication.call(
+              this,
+              'supermachineApi',
+              { method: 'GET', url: 'https://dev.supermachine.art/v1/models', json: true },
+            );
+            const models = (modelsResponse as IDataObject).items as IDataObject[];
+            const model = models.find((m: IDataObject) => 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) as string;
+            const modelsResponse = await this.helpers.requestWithAuthentication.call(
+              this,
+              'supermachineApi',
+              { method: 'GET', url: 'https://dev.supermachine.art/v1/models', json: true },
+            );
+            const models = (modelsResponse as IDataObject).items as IDataObject[];
+            const model = models.find((m: IDataObject) => 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') {
+            requestOptions.method = 'POST';
+            requestOptions.url = 'https://dev.supermachine.art/v1/generate';
+            
+            const additionalFields = this.getNodeParameter('additionalFields', i, {}) as IDataObject;
+            const body: IDataObject = {
+              prompt: this.getNodeParameter('prompt', i) as string,
+              model: this.getNodeParameter('model', i) as string,
+              width: this.getNodeParameter('width', i, 1024) as number,
+              height: this.getNodeParameter('height', i, 768) as number,
+            };
+
+            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;
+            }
+            if (additionalFields.callbackUrl) {
+              body.callbackUrl = additionalFields.callbackUrl;
+            }
+
+            if (additionalFields.loras) {
+              const lorasData = additionalFields.loras as IDataObject;
+              const loraValues = lorasData.loraValues as IDataObject[];
+              if (Array.isArray(loraValues) && loraValues.length > 0) {
+                body.loras = loraValues.map((lora: IDataObject) => ({
+                  id: lora.loraId,
+                  strength: lora.strength || 1,
+                }));
+              }
+            }
+
+            if (additionalFields.characterId) {
+              body.characterId = additionalFields.characterId;
+            }
+
+            if (additionalFields.img2img) {
+              const img2imgData = additionalFields.img2img as IDataObject;
+              const img2imgValues = img2imgData.img2imgValues as IDataObject[];
+              if (Array.isArray(img2imgValues) && img2imgValues.length > 0) {
+                const img2img = img2imgValues[0];
+                if (img2img.sourceImageUrl) {
+                  body.sourceImageUrl = img2img.sourceImageUrl;
+                  body.denoisingStrength = img2img.denoisingStrength || 0.75;
+                }
+              }
+            }
+
+            requestOptions.body = body;
+          } 
+          else if (operation === 'getStatus' || operation === 'listImages') {
+            const batchId = this.getNodeParameter('batchId', i) as string;
+            requestOptions.url = `https://dev.supermachine.art/v1/images?batchId=${batchId}`;
+            
+            if (operation === 'listImages' && !this.getNodeParameter('returnAll', i, false)) {
+              requestOptions.qs = {
+                limit: this.getNodeParameter('limit', i, 20),
+                page: this.getNodeParameter('page', i, 1),
+              };
+            }
+          }
+        }
+
+        // ══════════════════════════════════════════════════════
+        // 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: any;
+        if (operation === 'listModels' || operation === 'listImages' || operation === 'listLoras') {
+          jsonData = responseData;
+        } else {
+          jsonData = (responseData as any).items || responseData;
+        }
+
+        returnData.push({ json: jsonData });
+        
+      } catch (error) {
+        if (this.continueOnFail()) {
+          returnData.push({ 
+            json: { 
+              error: (error as Error).message,
+              stack: (error as Error).stack,
+            } 
+          });
+          continue;
+        }
+        throw error;
+      }
+    }
+    
+    return [returnData];
+  }
+}

package/nodes/Supermachine/SupermachineTrigger.node.ts

@@ -0,0 +1,175 @@
+import type {
+  IHookFunctions,
+  IWebhookFunctions,
+  IWebhookResponseData,
+  INodeType,
+  INodeTypeDescription,
+  IDataObject,
+  ILoadOptionsFunctions,
+  INodePropertyOptions,
+} from 'n8n-workflow';
+
+import { createHmac, timingSafeEqual } from 'crypto';
+
+export class SupermachineTrigger implements INodeType {
+  description: INodeTypeDescription = {
+    displayName: 'Supermachine Trigger',
+    name: 'supermachineTrigger',
+    // eslint-disable-next-line n8n-nodes-base/node-class-description-icon-not-svg
+    icon: 'file:supermachine.svg',
+    group: ['trigger'],
+    version: 1,
+    subtitle: '=Job Completed',
+    description: 'Starts the workflow when Supermachine job is completed',
+    defaults: {
+      name: 'Supermachine Trigger',
+    },
+    inputs: [],
+    outputs: ['main'],
+    credentials: [
+      {
+        name: 'supermachineApi',
+        required: true,
+      },
+    ],
+    webhooks: [
+      {
+        name: 'default',
+        httpMethod: 'POST',
+        responseMode: 'onReceived',
+        path: 'webhook',
+      },
+    ],
+    properties: [
+      {
+        displayName: 'Event',
+        name: 'event',
+        type: 'options',
+        options: [
+          {
+            name: 'Job Completed',
+            value: 'job.completed',
+          },
+          {
+            name: 'Job Failed',
+            value: 'job.failed',
+          },
+        ],
+        default: 'job.completed',
+        required: true,
+      },
+    ],
+  };
+
+  methods = {
+    loadOptions: {
+      async getEvents(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+        return [
+          {
+            name: 'Job Completed',
+            value: 'job.completed',
+          },
+          {
+            name: 'Job Failed',
+            value: 'job.failed',
+          },
+        ];
+      },
+    },
+  };
+
+  webhookMethods = {
+    default: {
+      async checkExists(this: IHookFunctions): Promise<boolean> {
+        // Webhook must be configured manually in Supermachine dashboard
+        // This returns true to indicate webhook is ready to receive
+        return true;
+      },
+      async create(this: IHookFunctions): Promise<boolean> {
+        const webhookUrl = this.getNodeWebhookUrl('default') as string;
+        // Store webhook URL for user to configure manually
+        const staticData = this.getWorkflowStaticData('node');
+        staticData.webhookUrl = webhookUrl;
+        
+        // Note: If Supermachine API supports webhook registration, implement here
+        // Example:
+        // const credentials = await this.getCredentials('supermachineApi');
+        // await this.helpers.requestWithAuthentication.call(this, 'supermachineApi', {
+        //   method: 'POST',
+        //   url: 'https://dev.supermachine.art/v1/webhooks',
+        //   body: { url: webhookUrl, events: ['job.completed'] }
+        // });
+        
+        return true;
+      },
+      async delete(this: IHookFunctions): Promise<boolean> {
+        // Implement webhook deletion if API supports
+        return true;
+      },
+    },
+  };
+
+  async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
+    const bodyData = this.getBodyData() as IDataObject;
+    const headers = this.getHeaderData() as IDataObject;
+
+    // Verify webhook signature if Supermachine sends signature
+    const signature = headers['x-supermachine-signature'];
+    if (signature && typeof signature === 'string') {
+      try {
+        const credentials = await this.getCredentials('supermachineApi');
+        const apiKey = credentials.apiKey as string;
+        
+        // Get raw body for signature verification
+        const req = this.getRequestObject();
+        const rawBody = (req as any).rawBody || JSON.stringify(bodyData);
+        
+        const hmac = createHmac('sha256', apiKey);
+        hmac.update(rawBody);
+        const calculatedSig = 'sha256=' + hmac.digest('hex');
+
+        // Safe comparison to prevent timing attacks
+        if (
+          signature.length !== calculatedSig.length ||
+          !timingSafeEqual(Buffer.from(signature), Buffer.from(calculatedSig))
+        ) {
+          throw new Error('Invalid webhook signature');
+        }
+      } catch (error) {
+        const err = error as Error;
+        throw new Error(`Signature verification failed: ${err.message}`);
+      }
+    }
+
+    // Parse response from Supermachine
+    let imageUrl = '';
+    if (bodyData.imageUrl && typeof bodyData.imageUrl === 'string') {
+      imageUrl = bodyData.imageUrl;
+    } else if (bodyData.output && typeof bodyData.output === 'object') {
+      const output = bodyData.output as IDataObject;
+      if (output.imageUrl && typeof output.imageUrl === 'string') {
+        imageUrl = output.imageUrl;
+      }
+    }
+
+    const jobData: IDataObject = {
+      batchId: bodyData.batchId || bodyData.id,
+      status: bodyData.status,
+      imageUrl,
+      model: bodyData.model,
+      prompt: bodyData.prompt,
+      creditsUsed: bodyData.creditsUsed,
+      timestamp: new Date().toISOString(),
+    };
+
+    return {
+      workflowData: [
+        [
+          {
+            json: jobData,
+          },
+        ],
+      ],
+    };
+  }
+}