@ferchy/n8n-nodes-aimc-toolkit 0.1.4

package/dist/nodes/AimcMedia/AimcMedia.node.js

@@ -0,0 +1,587 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AimcMedia = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+let ffmpegConfigured = false;
+let ffmpegChecked = null;
+function resolveOptional(moduleName) {
+    try {
+        const resolved = require(moduleName);
+        if (typeof resolved === 'string') {
+            return resolved;
+        }
+        if (resolved && typeof resolved.path === 'string') {
+            return resolved.path;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function configureFfmpeg() {
+    if (ffmpegConfigured) {
+        return;
+    }
+    const envFfmpeg = process.env.FFMPEG_PATH;
+    const envFfprobe = process.env.FFPROBE_PATH;
+    const staticFfmpeg = resolveOptional('ffmpeg-static');
+    const staticFfprobe = resolveOptional('ffprobe-static');
+    if (envFfmpeg) {
+        fluent_ffmpeg_1.default.setFfmpegPath(envFfmpeg);
+    }
+    else if (staticFfmpeg) {
+        fluent_ffmpeg_1.default.setFfmpegPath(staticFfmpeg);
+    }
+    if (envFfprobe) {
+        fluent_ffmpeg_1.default.setFfprobePath(envFfprobe);
+    }
+    else if (staticFfprobe) {
+        fluent_ffmpeg_1.default.setFfprobePath(staticFfprobe);
+    }
+    ffmpegConfigured = true;
+}
+async function ensureFfmpegAvailable() {
+    if (ffmpegChecked) {
+        if (!ffmpegChecked.ok) {
+            throw new Error(ffmpegChecked.message || 'FFmpeg not available');
+        }
+        return;
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            fluent_ffmpeg_1.default.getAvailableFormats((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+        ffmpegChecked = { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error && error.message
+            ? error.message
+            : 'FFmpeg not available';
+        ffmpegChecked = { ok: false, message };
+        throw new Error(message);
+    }
+}
+async function createTempDir() {
+    return fs.promises.mkdtemp(path.join(os.tmpdir(), 'aimc-media-'));
+}
+async function writeTempFile(dir, fileName, data) {
+    const filePath = path.join(dir, fileName);
+    await fs.promises.writeFile(filePath, data);
+    return filePath;
+}
+function parseExtraArgs(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split('\n')
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function ensureFileExists(filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File does not exist: ${filePath}`);
+    }
+}
+class AimcMedia {
+    constructor() {
+        this.description = {
+            displayName: 'AIMC Media',
+            name: 'aimcMedia',
+            icon: 'file:aimc-media.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Media operations using FFmpeg.',
+            defaults: {
+                name: 'AIMC Media',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    options: [
+                        { name: 'Convert / Transcode', value: 'convert' },
+                        { name: 'Compress', value: 'compress' },
+                        { name: 'Extract Audio', value: 'extractAudio' },
+                        { name: 'Merge Video + Audio', value: 'merge' },
+                        { name: 'Metadata', value: 'metadata' },
+                    ],
+                    default: 'convert',
+                },
+                {
+                    displayName: 'Input Mode',
+                    name: 'inputMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Binary', value: 'binary' },
+                        { name: 'File Path', value: 'filePath' },
+                    ],
+                    default: 'binary',
+                },
+                {
+                    displayName: 'Input Binary Property',
+                    name: 'binaryProperty',
+                    type: 'string',
+                    default: 'data',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['binary'],
+                            operation: ['convert', 'compress', 'extractAudio', 'metadata'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Input File Path',
+                    name: 'inputFilePath',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['filePath'],
+                            operation: ['convert', 'compress', 'extractAudio', 'metadata'],
+                        },
+                    },
+                    placeholder: '/path/to/input.mp4',
+                },
+                {
+                    displayName: 'Video Binary Property',
+                    name: 'videoBinaryProperty',
+                    type: 'string',
+                    default: 'video',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['binary'],
+                            operation: ['merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Audio Binary Property',
+                    name: 'audioBinaryProperty',
+                    type: 'string',
+                    default: 'audio',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['binary'],
+                            operation: ['merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Video File Path',
+                    name: 'videoFilePath',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['filePath'],
+                            operation: ['merge'],
+                        },
+                    },
+                    placeholder: '/path/to/video.mp4',
+                },
+                {
+                    displayName: 'Audio File Path',
+                    name: 'audioFilePath',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['filePath'],
+                            operation: ['merge'],
+                        },
+                    },
+                    placeholder: '/path/to/audio.mp3',
+                },
+                {
+                    displayName: 'Output Mode',
+                    name: 'outputMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Binary', value: 'binary' },
+                        { name: 'File Path', value: 'filePath' },
+                    ],
+                    default: 'binary',
+                    displayOptions: {
+                        show: {
+                            operation: ['convert', 'compress', 'extractAudio', 'merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Binary Property',
+                    name: 'outputBinaryProperty',
+                    type: 'string',
+                    default: 'data',
+                    displayOptions: {
+                        show: {
+                            outputMode: ['binary'],
+                            operation: ['convert', 'compress', 'extractAudio', 'merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output File Path',
+                    name: 'outputFilePath',
+                    type: 'string',
+                    default: '',
+                    placeholder: '/path/to/output.mp4',
+                    displayOptions: {
+                        show: {
+                            outputMode: ['filePath'],
+                            operation: ['convert', 'compress', 'extractAudio', 'merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormat',
+                    type: 'options',
+                    options: [
+                        { name: 'MP4', value: 'mp4' },
+                        { name: 'MOV', value: 'mov' },
+                        { name: 'WebM', value: 'webm' },
+                        { name: 'MP3', value: 'mp3' },
+                        { name: 'WAV', value: 'wav' },
+                        { name: 'AAC', value: 'aac' },
+                        { name: 'M4A', value: 'm4a' },
+                        { name: 'FLAC', value: 'flac' },
+                        { name: 'OGG', value: 'ogg' },
+                        { name: 'Custom', value: 'custom' },
+                    ],
+                    default: 'mp4',
+                    displayOptions: {
+                        show: {
+                            operation: ['convert', 'compress', 'extractAudio', 'merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Custom Output Format',
+                    name: 'customOutputFormat',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'mkv',
+                    displayOptions: {
+                        show: {
+                            outputFormat: ['custom'],
+                            operation: ['convert', 'compress', 'extractAudio', 'merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Video Codec',
+                    name: 'videoCodec',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'libx264',
+                    displayOptions: {
+                        show: {
+                            operation: ['convert'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Audio Codec',
+                    name: 'audioCodec',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'aac',
+                    displayOptions: {
+                        show: {
+                            operation: ['convert'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'CRF',
+                    name: 'videoCrf',
+                    type: 'number',
+                    default: 23,
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 51,
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['compress'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Preset',
+                    name: 'videoPreset',
+                    type: 'options',
+                    options: [
+                        { name: 'Ultrafast', value: 'ultrafast' },
+                        { name: 'Superfast', value: 'superfast' },
+                        { name: 'Veryfast', value: 'veryfast' },
+                        { name: 'Faster', value: 'faster' },
+                        { name: 'Fast', value: 'fast' },
+                        { name: 'Medium', value: 'medium' },
+                        { name: 'Slow', value: 'slow' },
+                        { name: 'Slower', value: 'slower' },
+                        { name: 'Veryslow', value: 'veryslow' },
+                    ],
+                    default: 'medium',
+                    displayOptions: {
+                        show: {
+                            operation: ['compress'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Audio Bitrate',
+                    name: 'audioBitrate',
+                    type: 'string',
+                    default: '128k',
+                    placeholder: '128k',
+                    displayOptions: {
+                        show: {
+                            operation: ['compress'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Additional Output Options',
+                    name: 'additionalOutputOptions',
+                    type: 'string',
+                    default: '',
+                    description: 'One option per line, e.g. -vf scale=1280:-2',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['convert', 'compress', 'extractAudio', 'merge'],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        configureFfmpeg();
+        try {
+            await ensureFfmpegAvailable();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'FFmpeg not available';
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `FFmpeg not found. Install FFmpeg or set FFMPEG_PATH/FFPROBE_PATH. ${message}`);
+        }
+        const items = this.getInputData();
+        const results = [];
+        for (let index = 0; index < items.length; index++) {
+            const item = items[index];
+            const operation = this.getNodeParameter('operation', index);
+            const inputMode = this.getNodeParameter('inputMode', index);
+            const outputMode = this.getNodeParameter('outputMode', index, 'binary');
+            const outputFormatParam = this.getNodeParameter('outputFormat', index, 'mp4');
+            const customOutputFormat = this.getNodeParameter('customOutputFormat', index, '');
+            let outputFormat = outputFormatParam === 'custom' ? customOutputFormat : outputFormatParam;
+            if (operation === 'extractAudio' && outputFormatParam === 'mp4' && !customOutputFormat) {
+                outputFormat = 'mp3';
+            }
+            if (operation !== 'metadata' && !outputFormat) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Output format is required.');
+            }
+            const tempDir = await createTempDir();
+            try {
+                let inputPath = '';
+                let videoPath = '';
+                let audioPath = '';
+                if (inputMode === 'binary') {
+                    if (operation === 'merge') {
+                        const videoProp = this.getNodeParameter('videoBinaryProperty', index);
+                        const audioProp = this.getNodeParameter('audioBinaryProperty', index);
+                        const videoBinary = this.helpers.assertBinaryData(index, videoProp);
+                        const audioBinary = this.helpers.assertBinaryData(index, audioProp);
+                        const videoBuffer = await this.helpers.getBinaryDataBuffer(index, videoProp);
+                        const audioBuffer = await this.helpers.getBinaryDataBuffer(index, audioProp);
+                        videoPath = await writeTempFile(tempDir, `video.${videoBinary.fileExtension || 'bin'}`, videoBuffer);
+                        audioPath = await writeTempFile(tempDir, `audio.${audioBinary.fileExtension || 'bin'}`, audioBuffer);
+                    }
+                    else {
+                        const binaryProperty = this.getNodeParameter('binaryProperty', index);
+                        const binary = this.helpers.assertBinaryData(index, binaryProperty);
+                        const buffer = await this.helpers.getBinaryDataBuffer(index, binaryProperty);
+                        inputPath = await writeTempFile(tempDir, `input.${binary.fileExtension || 'bin'}`, buffer);
+                    }
+                }
+                else {
+                    if (operation === 'merge') {
+                        videoPath = this.getNodeParameter('videoFilePath', index);
+                        audioPath = this.getNodeParameter('audioFilePath', index);
+                        ensureFileExists(videoPath);
+                        ensureFileExists(audioPath);
+                    }
+                    else {
+                        inputPath = this.getNodeParameter('inputFilePath', index);
+                        ensureFileExists(inputPath);
+                    }
+                }
+                if (operation === 'metadata') {
+                    const targetPath = inputMode === 'binary' ? inputPath : inputPath;
+                    const metadata = await new Promise((resolve, reject) => {
+                        fluent_ffmpeg_1.default.ffprobe(targetPath, (err, data) => {
+                            if (err) {
+                                const hint = err.message.includes('ffprobe')
+                                    ? 'ffprobe not found. Install ffprobe or set FFPROBE_PATH.'
+                                    : err.message;
+                                reject(new Error(hint));
+                                return;
+                            }
+                            resolve(data);
+                        });
+                    });
+                    results.push({
+                        json: {
+                            ...item.json,
+                            media: {
+                                operation,
+                                metadata,
+                            },
+                        },
+                    });
+                    continue;
+                }
+                const outputModeValue = outputMode;
+                const outputPathParam = this.getNodeParameter('outputFilePath', index, '');
+                const outputPath = outputModeValue === 'filePath' && outputPathParam
+                    ? outputPathParam
+                    : path.join(tempDir, `output.${outputFormat || 'mp4'}`);
+                const extraOptions = parseExtraArgs(this.getNodeParameter('additionalOutputOptions', index, ''));
+                let command = (0, fluent_ffmpeg_1.default)();
+                if (operation === 'merge') {
+                    command = command.input(videoPath).input(audioPath);
+                    command.outputOptions(['-map 0:v:0', '-map 1:a:0']);
+                }
+                else {
+                    command = command.input(inputPath);
+                }
+                if (operation === 'convert') {
+                    const videoCodec = this.getNodeParameter('videoCodec', index, '');
+                    const audioCodec = this.getNodeParameter('audioCodec', index, '');
+                    if (videoCodec) {
+                        command.videoCodec(videoCodec);
+                    }
+                    if (audioCodec) {
+                        command.audioCodec(audioCodec);
+                    }
+                    if (outputFormat) {
+                        command.format(outputFormat);
+                    }
+                }
+                if (operation === 'compress') {
+                    const crf = this.getNodeParameter('videoCrf', index, 23);
+                    const preset = this.getNodeParameter('videoPreset', index, 'medium');
+                    const audioBitrate = this.getNodeParameter('audioBitrate', index, '128k');
+                    command.videoCodec('libx264');
+                    command.outputOptions([`-crf ${crf}`, `-preset ${preset}`]);
+                    command.audioBitrate(audioBitrate);
+                    if (outputFormat) {
+                        command.format(outputFormat);
+                    }
+                }
+                if (operation === 'extractAudio') {
+                    command.noVideo();
+                    if (outputFormat) {
+                        command.format(outputFormat);
+                    }
+                }
+                if (extraOptions.length) {
+                    command.outputOptions(extraOptions);
+                }
+                await new Promise((resolve, reject) => {
+                    command
+                        .on('error', (err) => reject(err))
+                        .on('end', () => resolve())
+                        .save(outputPath);
+                });
+                let outputItem = {
+                    json: {
+                        ...item.json,
+                        media: {
+                            operation,
+                            outputFormat,
+                            outputPath: outputModeValue === 'filePath' ? outputPath : undefined,
+                        },
+                    },
+                };
+                if (outputModeValue === 'binary') {
+                    const outputBinaryProperty = this.getNodeParameter('outputBinaryProperty', index, 'data');
+                    const data = await fs.promises.readFile(outputPath);
+                    const binaryData = await this.helpers.prepareBinaryData(data, path.basename(outputPath));
+                    outputItem = {
+                        ...outputItem,
+                        binary: {
+                            [outputBinaryProperty]: binaryData,
+                        },
+                    };
+                }
+                results.push(outputItem);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Media operation failed: ${message}`);
+            }
+            finally {
+                if (tempDir) {
+                    await fs.promises.rm(tempDir, { recursive: true, force: true });
+                }
+            }
+        }
+        return [results];
+    }
+}
+exports.AimcMedia = AimcMedia;

package/dist/nodes/AimcMedia/aimc-media.svg

@@ -0,0 +1,23 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <defs>
+    <linearGradient id="aimc-media-bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#0A1021"/>
+      <stop offset="100%" stop-color="#0B1B3A"/>
+    </linearGradient>
+    <linearGradient id="aimc-media-play" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#7DD3FC"/>
+      <stop offset="100%" stop-color="#0EA5E9"/>
+    </linearGradient>
+  </defs>
+  <rect x="6" y="6" width="52" height="52" rx="10" fill="url(#aimc-media-bg)"/>
+  <polygon points="26,20 26,44 46,32" fill="url(#aimc-media-play)"/>
+  <g stroke="#1E3A8A" stroke-width="1.5" stroke-linecap="round" opacity="0.85">
+    <path d="M14 18V30"/>
+    <path d="M18 16V28"/>
+    <path d="M22 14V26"/>
+    <path d="M42 38V50"/>
+    <path d="M46 36V48"/>
+    <path d="M50 34V46"/>
+  </g>
+  <path d="M14 48C22 40 30 40 38 48" stroke="#38BDF8" stroke-width="2.5" fill="none" stroke-linecap="round"/>
+</svg>

package/index.js

@@ -0,0 +1,6 @@
+// Entry point for n8n custom nodes package
+module.exports = {
+  description: {
+    packageName: '@ferchy/n8n-nodes-aimc-toolkit'
+  }
+};