n8n-nodes-commandos-image 0.1.4

package/image-payload.json

@@ -0,0 +1,3 @@
+{
+  "note": "Example payload template for Commandos Image."
+}

package/index.ts

@@ -0,0 +1,4 @@
+import { CommandosImage } from './nodes/CommandosImage.node';
+import { CommandosApi } from './credentials/CommandosApi.credentials';
+
+export { CommandosImage, CommandosApi };

package/nodes/CommandosImage.node.ts

@@ -0,0 +1,368 @@
+import type {
+  IDataObject,
+  IExecuteFunctions,
+  INodeExecutionData,
+  INodeType,
+  INodeTypeDescription,
+} from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+
+const COMMANDOS_API_URL = 'https://api.comandos.ai';
+const GENERATION_URL_DEFAULT = String(process.env.COMMANDOS_IMAGE_URL_DEFAULT || '').trim();
+const GENERATION_URL_GPT4O = String(process.env.COMMANDOS_IMAGE_URL_GPT4O || '').trim();
+const GENERATION_URL_MJ = String(process.env.COMMANDOS_IMAGE_URL_MJ || '').trim();
+
+type BuildParams = {
+  model: string;
+  prompt: string;
+  ratio: string;
+  references: string[];
+};
+
+type BuildResult = {
+  url: string;
+  body: Record<string, unknown>;
+  requestedModel: string;
+  resolvedModel: string;
+  ratio: string;
+  references: string[];
+  hasReferences: boolean;
+};
+
+const resolveGenerationUrl = (resolvedModel: string): string => {
+  if (resolvedModel === 'gpt4o-image') {
+    return GENERATION_URL_GPT4O || GENERATION_URL_DEFAULT;
+  }
+  if (resolvedModel === 'midjourney') {
+    return GENERATION_URL_MJ || GENERATION_URL_DEFAULT;
+  }
+  return GENERATION_URL_DEFAULT;
+};
+
+const buildGenerationRequest = ({ model, prompt, ratio, references }: BuildParams): BuildResult => {
+  const hasReferences = references.length > 0;
+  const requestedModel = model;
+  let resolvedModel = model;
+
+  if (requestedModel === 'flux-pro') {
+    resolvedModel = hasReferences ? 'flux-2/pro-image-to-image' : 'flux-2/pro-text-to-image';
+  } else if (requestedModel === 'nano-banana') {
+    resolvedModel = hasReferences ? 'google/nano-banana-edit' : 'google/nano-banana';
+  } else if (requestedModel === 'nano-banana-pro') {
+    resolvedModel = 'nano-banana-pro';
+  } else if (requestedModel === 'seedream') {
+    resolvedModel = 'bytedance/seedream-v4-edit';
+  }
+
+  if (!hasReferences && (requestedModel === 'seedream' || requestedModel === 'midjourney')) {
+    if (requestedModel !== 'midjourney') {
+      resolvedModel = 'gpt4o-image';
+    }
+  }
+
+  let body: Record<string, unknown> = {};
+
+  if (resolvedModel === 'gpt4o-image') {
+    body = {
+      filesUrl: references,
+      prompt,
+      size: ratio,
+      callBackUrl: 'https://your-callback-url.com/callback',
+      fallbackModel: 'FLUX_MAX',
+    };
+  } else if (resolvedModel.includes('flux-2/')) {
+    body = {
+      model: resolvedModel,
+      input: {
+        prompt,
+        aspect_ratio: ratio,
+        resolution: '1K',
+        ...(hasReferences ? { input_urls: references } : {}),
+      },
+    };
+  } else if (resolvedModel === 'nano-banana-pro') {
+    body = {
+      model: resolvedModel,
+      input: {
+        prompt,
+        aspect_ratio: ratio,
+        resolution: '1K',
+        output_format: 'png',
+        ...(hasReferences ? { image_input: references } : {}),
+      },
+    };
+  } else if (resolvedModel.includes('google/nano-banana')) {
+    body = {
+      model: resolvedModel,
+      input: {
+        prompt,
+        image_size: ratio,
+        output_format: 'png',
+        ...(hasReferences ? { image_urls: references } : {}),
+      },
+    };
+  } else if (resolvedModel === 'midjourney') {
+    body = {
+      taskType: hasReferences ? 'mj_img2img' : 'mj_txt2img',
+      speed: 'fast',
+      prompt,
+      fileUrls: references,
+      aspectRatio: ratio,
+      enableTranslation: true,
+    };
+  } else {
+    body = {
+      model: 'bytedance/seedream-v4-edit',
+      input: {
+        image_urls: references,
+        prompt,
+        image_size: ratio === '2:3' ? 'portrait_3_2' : ratio,
+        image_resolution: '1K',
+      },
+    };
+  }
+
+  return {
+    url: resolveGenerationUrl(resolvedModel),
+    body,
+    requestedModel,
+    resolvedModel,
+    ratio,
+    references,
+    hasReferences,
+  };
+};
+
+const extractReferences = (raw: unknown): string[] => {
+  if (!raw || typeof raw !== 'object') {
+    return [];
+  }
+  const collection = raw as { reference?: Array<{ url?: string }> };
+  const items = Array.isArray(collection.reference) ? collection.reference : [];
+  return items
+    .map((entry) => String(entry?.url || '').trim())
+    .filter((value) => value.length > 0 && /^https?:\/\//i.test(value))
+    .slice(0, 2);
+};
+
+export class CommandosImage implements INodeType {
+  description: INodeTypeDescription = {
+    displayName: 'Commandos Image',
+    name: 'commandosImage',
+    group: ['transform'],
+    version: 1,
+    description: 'Create image tasks in Commandos API',
+    defaults: {
+      name: 'Commandos Image',
+    },
+    icon: 'file:Image.png',
+    inputs: ['main'],
+    outputs: ['main'],
+    credentials: [
+      {
+        name: 'commandosApi',
+        required: true,
+      },
+    ],
+    properties: [
+      {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+          {
+            name: 'Create Task',
+            value: 'create',
+          },
+          {
+            name: 'Check Status',
+            value: 'status',
+          },
+        ],
+        default: 'create',
+      },
+      {
+        displayName: 'Model',
+        name: 'model',
+        type: 'options',
+        options: [
+          { name: 'Flux Pro', value: 'flux-pro' },
+          { name: 'GPT-4o Image', value: 'gpt4o-image' },
+          { name: 'Nano Banana', value: 'nano-banana' },
+          { name: 'Nano Banana Pro', value: 'nano-banana-pro' },
+          { name: 'Seedream', value: 'seedream' },
+          { name: 'Midjourney', value: 'midjourney' },
+        ],
+        default: 'flux-pro',
+        displayOptions: {
+          show: {
+            operation: ['create'],
+          },
+        },
+      },
+      {
+        displayName: 'Prompt',
+        name: 'prompt',
+        type: 'string',
+        default: '',
+        typeOptions: {
+          rows: 4,
+        },
+        displayOptions: {
+          show: {
+            operation: ['create'],
+          },
+        },
+      },
+      {
+        displayName: 'Ratio',
+        name: 'ratio',
+        type: 'options',
+        options: [
+          { name: '1:1', value: '1:1' },
+          { name: '2:3', value: '2:3' },
+          { name: '3:2', value: '3:2' },
+          { name: '4:5', value: '4:5' },
+          { name: '16:9', value: '16:9' },
+          { name: '9:16', value: '9:16' },
+        ],
+        default: '2:3',
+        displayOptions: {
+          show: {
+            operation: ['create'],
+          },
+        },
+      },
+      {
+        displayName: 'References',
+        name: 'references',
+        type: 'fixedCollection',
+        default: {},
+        typeOptions: {
+          multipleValues: true,
+        },
+        options: [
+          {
+            name: 'reference',
+            displayName: 'Reference',
+            values: [
+              {
+                displayName: 'Reference URL',
+                name: 'url',
+                type: 'string',
+                default: '',
+              },
+            ],
+          },
+        ],
+        displayOptions: {
+          show: {
+            operation: ['create'],
+          },
+        },
+      },
+      {
+        displayName: 'Task ID',
+        name: 'taskId',
+        type: 'string',
+        default: '',
+        displayOptions: {
+          show: {
+            operation: ['status'],
+          },
+        },
+      },
+    ],
+  };
+
+  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+    const items = this.getInputData();
+    const operation = this.getNodeParameter('operation', 0) as string;
+    const credentials = await this.getCredentials('commandosApi');
+    const licenseKey = String(credentials.licenseKey || '').trim();
+
+    if (!licenseKey) {
+      throw new NodeOperationError(this.getNode(), 'License key is required');
+    }
+
+    const results: INodeExecutionData[] = [];
+
+    for (let i = 0; i < items.length; i += 1) {
+      try {
+        if (operation === 'create') {
+          const model = String(this.getNodeParameter('model', i));
+          const prompt = String(this.getNodeParameter('prompt', i) || '').trim();
+          const ratio = String(this.getNodeParameter('ratio', i));
+          const references = extractReferences(this.getNodeParameter('references', i, {}));
+
+          if (!prompt) {
+            throw new NodeOperationError(this.getNode(), 'Prompt is required', { itemIndex: i });
+          }
+
+          const request = buildGenerationRequest({ model, prompt, ratio, references });
+          if (!request.url) {
+            throw new NodeOperationError(
+              this.getNode(),
+              'URL генерации не настроен. Проверь переменные окружения COMMANDOS_IMAGE_URL_DEFAULT/COMMANDOS_IMAGE_URL_GPT4O/COMMANDOS_IMAGE_URL_MJ',
+              { itemIndex: i },
+            );
+          }
+
+          const payload = {
+            url: request.url,
+            body: request.body,
+            requestedModel: request.requestedModel,
+            resolvedModel: request.resolvedModel,
+            ratio: request.ratio,
+            references: request.references,
+            hasReferences: request.hasReferences,
+          };
+
+          const response = await this.helpers.request({
+            method: 'POST',
+            url: `${COMMANDOS_API_URL}/tasks`,
+            headers: {
+              'Content-Type': 'application/json',
+              'X-License-Key': licenseKey,
+            },
+            body: {
+              process_type: 'IMAGE_GENERATION',
+              payload,
+            },
+            json: true,
+          });
+
+          results.push({ json: response as IDataObject });
+        } else if (operation === 'status') {
+          const taskId = String(this.getNodeParameter('taskId', i) || '').trim();
+          if (!taskId) {
+            throw new NodeOperationError(this.getNode(), 'Task ID is required', { itemIndex: i });
+          }
+
+          const response = await this.helpers.request({
+            method: 'GET',
+            url: `${COMMANDOS_API_URL}/tasks/${encodeURIComponent(taskId)}`,
+            headers: {
+              'X-License-Key': licenseKey,
+            },
+            json: true,
+          });
+
+          results.push({ json: response as IDataObject });
+        } else {
+          throw new NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, {
+            itemIndex: i,
+          });
+        }
+      } catch (error) {
+        if (error instanceof NodeOperationError) {
+          throw error;
+        }
+        throw new NodeOperationError(this.getNode(), 'Request failed', { itemIndex: i });
+      }
+    }
+
+    return [results];
+  }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "n8n-nodes-commandos-image",
+  "version": "0.1.4",
+  "description": "Commandos Image custom node",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json && mkdir -p dist/nodes && cp -f Image.png dist/nodes/"
+  },
+  "dependencies": {
+    "n8n-workflow": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.0",
+    "typescript": "^5.4.5"
+  },
+  "n8n": {
+    "nodes": [
+      "dist/nodes/CommandosImage.node.js"
+    ],
+    "credentials": [
+      "dist/credentials/CommandosApi.credentials.js"
+    ]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "CommonJS",
+    "lib": ["ES2019"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true
+  },
+  "include": ["nodes/**/*.ts", "credentials/**/*.ts", "index.ts"]
+}