@lee-jisoo/n8n-nodes-mediafx 1.6.20 → 1.6.21

package/README.md

@@ -10,6 +10,17 @@ This is a custom n8n node for comprehensive, local media processing using FFmpeg
 
 ## 🆕 What's New in This Fork
 
+### v1.6.21
+**New Features**
+
+- **🖼️ Add Text to Image**: Overlay text onto static images
+  - Font selection (bundled, user-uploaded, system fonts)
+  - Text styling: size, color
+  - **Outline**: configurable width and color for text border
+  - **Background Box**: optional background with color, opacity, and padding
+  - Positioning: alignment-based (9-point grid) or custom X/Y coordinates
+  - Output format matches input image format (PNG, JPG, etc.)
+
 ### v1.6.20
 **New Features**
 
@@ -81,6 +92,27 @@ npm install @lee-jisoo/n8n-nodes-mediafx
 RUN cd /home/node/.n8n/nodes && npm install @lee-jisoo/n8n-nodes-mediafx
 ```
 
+## ⚠️ Troubleshooting
+
+### Node not working after upgrade
+If the node doesn't work properly after upgrading to a new version, try **uninstalling and reinstalling** the plugin:
+
+**Via n8n Community Nodes:**
+1. Go to **Settings > Community Nodes**
+2. Find `@lee-jisoo/n8n-nodes-mediafx` and click **Uninstall**
+3. Restart n8n
+4. Go to **Settings > Community Nodes** again
+5. Click **Install** and enter `@lee-jisoo/n8n-nodes-mediafx`
+6. Restart n8n
+
+**Manual Installation:**
+```bash
+cd ~/.n8n/nodes
+npm uninstall @lee-jisoo/n8n-nodes-mediafx
+npm install @lee-jisoo/n8n-nodes-mediafx
+# Restart n8n
+```
+
 ## Features
 
 ### Video Operations
@@ -103,6 +135,7 @@ RUN cd /home/node/.n8n/nodes && npm install @lee-jisoo/n8n-nodes-mediafx
 ### Image Operations
 | Operation | Description |
 |-----------|-------------|
+| **Add Text** | Overlay text on image with styling, outline, background box ⭐ NEW |
 | **Image to Video** | Create video from image with custom duration |
 | **Stamp Image** | Add watermark with position, size, rotation, opacity, time control |
 
@@ -126,7 +159,42 @@ RUN cd /home/node/.n8n/nodes && npm install @lee-jisoo/n8n-nodes-mediafx
 
 ## Usage Examples
 
-### Get Media Metadata (New!)
+### Add Text to Image (New!)
+Overlay text on an image with styling:
+```json
+{
+  "resource": "image",
+  "operation": "addTextToImage",
+  "sourceImageText": {
+    "source": { "sourceType": "binary", "binaryProperty": "data" }
+  },
+  "imageText": "Hello, World!",
+  "imageTextFontKey": "noto-sans-kr",
+  "imageTextSize": 48,
+  "imageTextColor": "white",
+  "imageTextOutlineWidth": 2,
+  "imageTextOutlineColor": "black",
+  "imageTextPositionType": "alignment",
+  "imageTextHorizontalAlign": "center",
+  "imageTextVerticalAlign": "bottom",
+  "imageTextPaddingY": 50
+}
+```
+
+With background box:
+```json
+{
+  "resource": "image",
+  "operation": "addTextToImage",
+  "imageText": "Caption Text",
+  "imageTextEnableBackground": true,
+  "imageTextBackgroundColor": "black",
+  "imageTextBackgroundOpacity": 0.7,
+  "imageTextBoxPadding": 10
+}
+```
+
+### Get Media Metadata
 Extract metadata from video or audio files:
 ```json
 {

package/dist/nodes/MediaFX/MediaFX.node.js

@@ -406,6 +406,35 @@ class MediaFX {
                             outputPath = await operations_1.executeSingleVideoFade.call(this, paths[0], fadeEffect, fadeStartTime, fadeDuration, outputFormat, i);
                             break;
                         }
+                        case 'addTextToImage': {
+                            const sourceParam = this.getNodeParameter('sourceImageText', i, {});
+                            if (!sourceParam.source) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Image source is required. Please add an image source.', { itemIndex: i });
+                            }
+                            const { paths, cleanup: c } = await (0, utils_1.resolveInputs)(this, i, [sourceParam.source]);
+                            cleanup = c;
+                            const text = this.getNodeParameter('imageText', i, 'Hello, n8n!');
+                            const textOptions = {
+                                fontKey: this.getNodeParameter('imageTextFontKey', i, 'noto-sans-kr'),
+                                size: this.getNodeParameter('imageTextSize', i, 48),
+                                color: this.getNodeParameter('imageTextColor', i, 'white'),
+                                outlineWidth: this.getNodeParameter('imageTextOutlineWidth', i, 0),
+                                outlineColor: this.getNodeParameter('imageTextOutlineColor', i, 'black'),
+                                enableBackground: this.getNodeParameter('imageTextEnableBackground', i, false),
+                                backgroundColor: this.getNodeParameter('imageTextBackgroundColor', i, 'black'),
+                                backgroundOpacity: this.getNodeParameter('imageTextBackgroundOpacity', i, 0.5),
+                                boxPadding: this.getNodeParameter('imageTextBoxPadding', i, 5),
+                                positionType: this.getNodeParameter('imageTextPositionType', i, 'alignment'),
+                                horizontalAlign: this.getNodeParameter('imageTextHorizontalAlign', i, 'center'),
+                                verticalAlign: this.getNodeParameter('imageTextVerticalAlign', i, 'middle'),
+                                paddingX: this.getNodeParameter('imageTextPaddingX', i, 20),
+                                paddingY: this.getNodeParameter('imageTextPaddingY', i, 20),
+                                x: this.getNodeParameter('imageTextX', i, '(w-text_w)/2'),
+                                y: this.getNodeParameter('imageTextY', i, '(h-text_h)/2'),
+                            };
+                            outputPath = await operations_1.executeAddTextToImage.call(this, paths[0], text, textOptions, i);
+                            break;
+                        }
                         case 'imageToVideo': {
                             const sourceParam = this.getNodeParameter('sourceImage', i, {});
                             const { paths, cleanup: c } = await (0, utils_1.resolveInputs)(this, i, [sourceParam.source]);

package/dist/nodes/MediaFX/operations/addSubtitle.js

@@ -159,6 +159,7 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
         // Find timestamp line (may be first or second line)
         let timestampLine = '';
         let textStartIndex = 0;
+        let inlineText = ''; // Text that may be on the same line as timestamp
         for (let i = 0; i < lines.length; i++) {
             if (lines[i].includes('-->')) {
                 timestampLine = lines[i];
@@ -168,15 +169,33 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
         }
         if (!timestampLine)
             continue;
-        // Parse timestamps: 00:00:01,000 --> 00:00:04,000
-        const match = timestampLine.match(/(\d{1,2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{1,2}):(\d{2}):(\d{2})[,.](\d{3})/);
+        // Parse timestamps: 00:00:01,000 --> 00:00:04,000 [optional inline text]
+        // Extended regex to capture text after timestamp on same line
+        const match = timestampLine.match(/(\d{1,2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{1,2}):(\d{2}):(\d{2})[,.](\d{3})(?:\s+(.*))?/);
         if (!match)
             continue;
+        // Check if text exists on the same line as timestamp (non-standard SRT format)
+        if (match[9] && match[9].trim()) {
+            inlineText = match[9].trim();
+        }
         // Convert to ASS time format: H:MM:SS.cc
         const startTime = `${parseInt(match[1])}:${match[2]}:${match[3]}.${match[4].substring(0, 2)}`;
         const endTime = `${parseInt(match[5])}:${match[6]}:${match[7]}.${match[8].substring(0, 2)}`;
-        // Get subtitle text (remaining lines)
-        let text = lines.slice(textStartIndex).join('\\N');
+        // Get subtitle text
+        // Priority: inline text (on timestamp line) > remaining lines
+        let text;
+        if (inlineText) {
+            // Non-standard format: text on same line as timestamp
+            // Also include any additional lines if present
+            const additionalLines = lines.slice(textStartIndex).filter(l => l.trim());
+            text = additionalLines.length > 0
+                ? [inlineText, ...additionalLines].join('\\N')
+                : inlineText;
+        }
+        else {
+            // Standard format: text on separate lines
+            text = lines.slice(textStartIndex).join('\\N');
+        }
         // Add horizontal padding when background is enabled
         if (enableBackground && text.trim()) {
             text = addTextPadding(text, paddingSpaces);

package/dist/nodes/MediaFX/operations/addTextToImage.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, IDataObject } from 'n8n-workflow';
+export declare function executeAddTextToImage(this: IExecuteFunctions, imagePath: string, text: string, options: IDataObject, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/addTextToImage.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAddTextToImage = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const path = __importStar(require("path"));
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+function getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY) {
+    let x;
+    let y;
+    // Set X position based on horizontal alignment
+    switch (horizontalAlign) {
+        case 'left':
+            x = `${paddingX}`;
+            break;
+        case 'right':
+            x = `w-text_w-${paddingX}`;
+            break;
+        case 'center':
+        default:
+            x = '(w-text_w)/2';
+            break;
+    }
+    // Set Y position based on vertical alignment
+    switch (verticalAlign) {
+        case 'top':
+            y = `${paddingY}`;
+            break;
+        case 'bottom':
+            y = `h-th-${paddingY}`;
+            break;
+        case 'middle':
+        default:
+            y = '(h-text_h)/2';
+            break;
+    }
+    return { x, y };
+}
+async function executeAddTextToImage(imagePath, text, options, itemIndex) {
+    var _a, _b, _c;
+    // Get font (includes bundled, user, and system fonts)
+    const allFonts = (0, utils_1.getAvailableFonts)(true);
+    const fontKey = options.fontKey || 'noto-sans-kr';
+    const font = allFonts[fontKey];
+    if (!font || !font.path) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+    }
+    const fontPath = font.path;
+    // Set default values for text options
+    const fontSize = options.size || 48;
+    const fontColor = options.color || 'white';
+    // Outline options
+    const outlineWidth = options.outlineWidth || 0;
+    const outlineColor = options.outlineColor || 'black';
+    // Background box options
+    const enableBackground = options.enableBackground || false;
+    const backgroundColor = options.backgroundColor || 'black';
+    const backgroundOpacity = (_a = options.backgroundOpacity) !== null && _a !== void 0 ? _a : 0.5;
+    const boxPadding = options.boxPadding || 5;
+    // Handle position based on position type
+    let positionX;
+    let positionY;
+    const positionType = options.positionType || 'alignment';
+    if (positionType === 'alignment') {
+        const horizontalAlign = options.horizontalAlign || 'center';
+        const verticalAlign = options.verticalAlign || 'middle';
+        const paddingX = (_b = options.paddingX) !== null && _b !== void 0 ? _b : 20;
+        const paddingY = (_c = options.paddingY) !== null && _c !== void 0 ? _c : 20;
+        const position = getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY);
+        positionX = position.x;
+        positionY = position.y;
+    }
+    else {
+        // Custom position
+        positionX = options.x || '(w-text_w)/2';
+        positionY = options.y || '(h-text_h)/2';
+    }
+    // Use the same extension as input image
+    const inputExt = path.extname(imagePath);
+    const outputPath = (0, utils_1.getTempFile)(inputExt);
+    // Escape single quotes in text
+    const escapedText = text.replace(/'/g, `''`);
+    // Build drawtext filter
+    let drawtext = `drawtext=fontfile=${fontPath}:text='${escapedText}':fontsize=${fontSize}:fontcolor=${fontColor}:x=${positionX}:y=${positionY}`;
+    // Add outline (border) if width > 0
+    if (outlineWidth > 0) {
+        drawtext += `:borderw=${outlineWidth}:bordercolor=${outlineColor}`;
+    }
+    // Add background box if enabled
+    if (enableBackground) {
+        drawtext += `:box=1:boxcolor=${backgroundColor}@${backgroundOpacity}:boxborderw=${boxPadding}`;
+    }
+    const command = ffmpeg(imagePath)
+        .videoFilters(drawtext)
+        .frames(1)
+        .save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error adding text to image. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeAddTextToImage = executeAddTextToImage;

package/dist/nodes/MediaFX/operations/index.d.ts

@@ -4,6 +4,7 @@ export * from './speed';
 export * from './mixAudio';
 export * from './addSubtitle';
 export * from './addText';
+export * from './addTextToImage';
 export * from './extractAudio';
 export * from './separateAudio';
 export * from './multiVideoTransition';

package/dist/nodes/MediaFX/operations/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./speed"), exports);
 __exportStar(require("./mixAudio"), exports);
 __exportStar(require("./addSubtitle"), exports);
 __exportStar(require("./addText"), exports);
+__exportStar(require("./addTextToImage"), exports);
 __exportStar(require("./extractAudio"), exports);
 __exportStar(require("./separateAudio"), exports);
 __exportStar(require("./multiVideoTransition"), exports);

package/dist/nodes/MediaFX/properties/image.properties.js

@@ -14,6 +14,11 @@ exports.imageProperties = [
             },
         },
         options: [
+            {
+                name: 'Add Text',
+                value: 'addTextToImage',
+                description: 'Overlay text onto an image',
+            },
             {
                 name: 'To Video',
                 value: 'imageToVideo',
@@ -28,6 +33,299 @@ exports.imageProperties = [
         default: 'imageToVideo',
     },
     // =============================
+    // == ADD TEXT TO IMAGE FIELDS ==
+    // =============================
+    {
+        displayName: 'Source Image',
+        name: 'sourceImageText',
+        type: 'fixedCollection',
+        placeholder: 'Add Image Source',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        default: {},
+        options: [
+            {
+                displayName: 'Source',
+                name: 'source',
+                values: [
+                    {
+                        displayName: 'Source Type', name: 'sourceType', type: 'options',
+                        options: [{ name: 'URL', value: 'url' }, { name: 'Binary Data', value: 'binary' }],
+                        default: 'url',
+                    },
+                    { displayName: 'Value', name: 'value', type: 'string', default: '', placeholder: 'https://example.com/image.png', displayOptions: { show: { sourceType: ['url'] } } },
+                    { displayName: 'Binary Property', name: 'binaryProperty', type: 'string', default: 'data', displayOptions: { show: { sourceType: ['binary'] } } },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Text',
+        name: 'imageText',
+        type: 'string',
+        default: 'Hello, n8n!',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'The text to overlay on the image',
+    },
+    {
+        displayName: 'Font',
+        name: 'imageTextFontKey',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getFonts',
+        },
+        default: 'noto-sans-kr',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'Select a font for the text',
+    },
+    {
+        displayName: 'Font Size',
+        name: 'imageTextSize',
+        type: 'number',
+        default: 48,
+        typeOptions: {
+            minValue: 1,
+        },
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'Font size in pixels',
+    },
+    {
+        displayName: 'Color',
+        name: 'imageTextColor',
+        type: 'string',
+        default: 'white',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'Text color (e.g., white, #FF0000, rgb(255,0,0))',
+    },
+    {
+        displayName: 'Outline Width',
+        name: 'imageTextOutlineWidth',
+        type: 'number',
+        default: 0,
+        typeOptions: {
+            minValue: 0,
+        },
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'Width of the text outline/border in pixels. Set to 0 for no outline.',
+    },
+    {
+        displayName: 'Outline Color',
+        name: 'imageTextOutlineColor',
+        type: 'string',
+        default: 'black',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'Color of the text outline/border',
+    },
+    {
+        displayName: 'Enable Background Box',
+        name: 'imageTextEnableBackground',
+        type: 'boolean',
+        default: false,
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'Whether to add a background box behind the text',
+    },
+    {
+        displayName: 'Background Color',
+        name: 'imageTextBackgroundColor',
+        type: 'string',
+        default: 'black',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextEnableBackground: [true],
+            },
+        },
+        description: 'Color of the background box',
+    },
+    {
+        displayName: 'Background Opacity',
+        name: 'imageTextBackgroundOpacity',
+        type: 'number',
+        default: 0.5,
+        typeOptions: {
+            minValue: 0,
+            maxValue: 1,
+            numberStepSize: 0.1,
+        },
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextEnableBackground: [true],
+            },
+        },
+        description: 'Opacity of the background box (0 = transparent, 1 = opaque)',
+    },
+    {
+        displayName: 'Box Padding',
+        name: 'imageTextBoxPadding',
+        type: 'number',
+        default: 5,
+        typeOptions: {
+            minValue: 0,
+        },
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextEnableBackground: [true],
+            },
+        },
+        description: 'Padding around the text inside the background box',
+    },
+    {
+        displayName: 'Position Type',
+        name: 'imageTextPositionType',
+        type: 'options',
+        options: [
+            { name: 'Alignment', value: 'alignment' },
+            { name: 'Custom', value: 'custom' },
+        ],
+        default: 'alignment',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+            },
+        },
+        description: 'How to position the text on the image',
+    },
+    {
+        displayName: 'Horizontal Alignment',
+        name: 'imageTextHorizontalAlign',
+        type: 'options',
+        options: [
+            { name: 'Left', value: 'left' },
+            { name: 'Center', value: 'center' },
+            { name: 'Right', value: 'right' },
+        ],
+        default: 'center',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextPositionType: ['alignment'],
+            },
+        },
+        description: 'Horizontal alignment of the text',
+    },
+    {
+        displayName: 'Vertical Alignment',
+        name: 'imageTextVerticalAlign',
+        type: 'options',
+        options: [
+            { name: 'Top', value: 'top' },
+            { name: 'Middle', value: 'middle' },
+            { name: 'Bottom', value: 'bottom' },
+        ],
+        default: 'middle',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextPositionType: ['alignment'],
+            },
+        },
+        description: 'Vertical alignment of the text',
+    },
+    {
+        displayName: 'Padding X',
+        name: 'imageTextPaddingX',
+        type: 'number',
+        default: 20,
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextPositionType: ['alignment'],
+            },
+        },
+        description: 'Horizontal padding from the edge in pixels',
+    },
+    {
+        displayName: 'Padding Y',
+        name: 'imageTextPaddingY',
+        type: 'number',
+        default: 20,
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextPositionType: ['alignment'],
+            },
+        },
+        description: 'Vertical padding from the edge in pixels',
+    },
+    {
+        displayName: 'Position X',
+        name: 'imageTextX',
+        type: 'string',
+        default: '(w-text_w)/2',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextPositionType: ['custom'],
+            },
+        },
+        description: "X position. Supports FFmpeg expressions like '10', '(w-text_w)/2', 'w-text_w-10'.",
+    },
+    {
+        displayName: 'Position Y',
+        name: 'imageTextY',
+        type: 'string',
+        default: '(h-text_h)/2',
+        displayOptions: {
+            show: {
+                resource: ['image'],
+                operation: ['addTextToImage'],
+                imageTextPositionType: ['custom'],
+            },
+        },
+        description: "Y position. Supports FFmpeg expressions like '10', '(h-text_h)/2', 'h-th-10'.",
+    },
+    // =============================
     // == IMAGE TO VIDEO FIELDS ==
     // =============================
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lee-jisoo/n8n-nodes-mediafx",
-  "version": "1.6.20",
+  "version": "1.6.21",
   "description": "N8N custom nodes for video editing and media processing (Enhanced fork with Speed control and Subtitle fixes)",
   "license": "MIT",
   "author": {