@ferchy/aimc-n8n-toolkit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AIMC Toolkit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# AIMC Toolkit for n8n
+
+AIMC Toolkit is a community node package for n8n with two focused nodes:
+
+- **AIMC Code**: Run JavaScript with a curated library toolbox.
+- **AIMC Media**: FFmpeg-based media operations (convert, compress, extract audio, merge, metadata).
+
+## Why AIMC Toolkit
+
+- **Faster workflows**: replace multiple utility nodes with one code node.
+- **Media ready**: common FFmpeg tasks in a single, consistent UI.
+- **Practical libraries**: data parsing, validation, formatting, and web utilities built-in.
+
+## Installation
+
+### Community Nodes
+1. Open **Settings > Community Nodes** in n8n.
+2. Install: `@ferchy/aimc-n8n-toolkit`.
+
+### Manual
+```bash
+npm install @ferchy/aimc-n8n-toolkit
+```
+
+## FFmpeg Setup
+
+AIMC Media will use the first available option:
+
+1. `FFMPEG_PATH` / `FFPROBE_PATH` environment variables
+2. Optional `ffmpeg-static` / `ffprobe-static`
+3. System FFmpeg on `PATH`
+
+Recommended for servers:
+```bash
+# Debian/Ubuntu
+apt-get update && apt-get install -y ffmpeg
+```
+
+## Nodes
+
+### AIMC Code
+
+**Features**
+- Run once for all items or once per item.
+- Access libraries as globals (`axios`, `_`, `zod`) or via `libs`.
+
+**Example**
+```javascript
+const rows = $input.all().map((i) => i.json);
+const ids = rows.map(() => nanoid());
+
+return rows.map((row, index) => ({
+  ...row,
+  id: ids[index],
+  normalizedEmail: validator.normalizeEmail(row.email || ''),
+  createdAt: utils.now(),
+}));
+```
+
+**Library snapshot**
+`axios`, `lodash`, `zod`, `joi`, `yup`, `dayjs`, `date-fns`, `cheerio`, `papaparse`,
+`yaml`, `xml2js`, `qs`, `form-data`, `uuid`, `nanoid`, and more.
+
+### AIMC Media
+
+**Operations**
+- Convert / Transcode
+- Compress
+- Extract Audio
+- Merge Video + Audio
+- Metadata (ffprobe)
+
+**Example**
+Convert a video to WebM and scale it:
+```text
+Operation: Convert / Transcode
+Output Format: WebM
+Additional Output Options:
+-vf scale=1280:-2
+```
+
+**Large files**
+Use **Input Mode = File Path** to avoid loading big files into memory.
+
+## Configuration
+
+Environment variables:
+
+- `FFMPEG_PATH`: custom FFmpeg binary path
+- `FFPROBE_PATH`: custom ffprobe binary path
+
+## License
+
+MIT

package/dist/nodes/AimcCode/AimcCode.node.d.ts

@@ -0,0 +1,5 @@
+import { INodeExecutionData, INodeType, INodeTypeDescription, IExecuteFunctions } from 'n8n-workflow';
+export declare class AimcCode implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/AimcCode/AimcCode.node.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AimcCode = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const vm_1 = require("vm");
+const optionalRequire = (moduleName) => () => {
+    try {
+        return require(moduleName);
+    }
+    catch {
+        return undefined;
+    }
+};
+const libraryLoaders = {
+    _: () => require('lodash'),
+    lodash: () => require('lodash'),
+    axios: () => require('axios'),
+    cheerio: () => require('cheerio'),
+    dayjs: () => require('dayjs'),
+    moment: () => require('moment-timezone'),
+    dateFns: () => require('date-fns'),
+    dateFnsTz: () => require('date-fns-tz'),
+    joi: () => require('joi'),
+    Joi: () => require('joi'),
+    validator: () => require('validator'),
+    uuid: () => require('uuid'),
+    Ajv: () => require('ajv'),
+    yup: () => require('yup'),
+    zod: () => require('zod'),
+    z: () => require('zod'),
+    xml2js: () => require('xml2js'),
+    XMLParser: () => require('fast-xml-parser').XMLParser,
+    YAML: () => require('yaml'),
+    papaparse: () => require('papaparse'),
+    Papa: () => require('papaparse'),
+    Handlebars: () => require('handlebars'),
+    htmlToText: () => require('html-to-text'),
+    marked: () => require('marked'),
+    slug: () => {
+        const slugLib = require('slug');
+        return slugLib.default || slugLib;
+    },
+    pluralize: () => require('pluralize'),
+    qs: () => require('qs'),
+    FormData: () => require('form-data'),
+    ini: () => require('ini'),
+    toml: () => require('toml'),
+    nanoid: () => {
+        const nanoidLib = require('nanoid');
+        return nanoidLib.nanoid || nanoidLib;
+    },
+    bytes: () => require('bytes'),
+    ms: () => require('ms'),
+    phoneNumber: () => require('libphonenumber-js'),
+    iban: () => require('iban'),
+    fuzzy: () => require('fuse.js'),
+    stringSimilarity: () => require('string-similarity'),
+    pRetry: () => require('p-retry'),
+    jsonDiff: () => require('json-diff-ts'),
+    cronParser: () => require('cron-parser'),
+    franc: () => require('franc-min'),
+    compromise: () => require('compromise'),
+    protobuf: () => require('protobufjs'),
+    protobufjs: () => require('protobufjs'),
+    knex: () => require('knex'),
+    QRCode: () => require('qrcode'),
+    qrcode: () => require('qrcode'),
+    ytdl: () => require('@distube/ytdl-core'),
+    httpProxyAgent: () => require('http-proxy-agent'),
+    socksProxyAgent: () => require('socks-proxy-agent'),
+    bufferutil: optionalRequire('bufferutil'),
+    utf8Validate: optionalRequire('utf-8-validate'),
+};
+function attachLibraries(target, cache) {
+    for (const [name, loader] of Object.entries(libraryLoaders)) {
+        Object.defineProperty(target, name, {
+            enumerable: true,
+            get() {
+                if (!(name in cache)) {
+                    cache[name] = loader();
+                }
+                return cache[name];
+            },
+        });
+    }
+}
+function normalizeResult(result, fallbackItems) {
+    const isItem = (value) => !!value && typeof value === 'object' && 'json' in value;
+    const toJson = (value) => value && typeof value === 'object' ? JSON.parse(JSON.stringify(value)) : value;
+    if (result === undefined) {
+        return fallbackItems;
+    }
+    if (Array.isArray(result)) {
+        if (result.every(isItem)) {
+            return result;
+        }
+        return result.map((entry) => ({
+            json: entry && typeof entry === 'object' ? toJson(entry) : { data: entry },
+        }));
+    }
+    if (isItem(result)) {
+        return [result];
+    }
+    return [
+        {
+            json: result && typeof result === 'object' ? toJson(result) : { data: result },
+        },
+    ];
+}
+function buildSandbox(params) {
+    const cache = {};
+    const sandbox = {
+        items: params.items,
+        item: params.item,
+        $input: {
+            all: () => params.items,
+            first: () => params.items[0],
+            last: () => params.items[params.items.length - 1],
+            item: () => params.item,
+            json: () => params.mode === 'runOnceForEachItem' && params.item
+                ? params.item.json
+                : params.items.map((entry) => entry.json),
+        },
+        params: params.nodeParams,
+        utils: {
+            now: () => new Date().toISOString(),
+            sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+            isEmpty: (value) => value === null || value === undefined || value === '' ||
+                (Array.isArray(value) && value.length === 0),
+            safeJson: (value) => {
+                try {
+                    return JSON.parse(JSON.stringify(value));
+                }
+                catch {
+                    return value;
+                }
+            },
+            toArray: (value) => (Array.isArray(value) ? value : [value]),
+            availableLibraries: () => Object.keys(libraryLoaders).sort(),
+        },
+        console: {
+            log: (...args) => console.log('[AIMC Code]', ...args),
+            warn: (...args) => console.warn('[AIMC Code]', ...args),
+            error: (...args) => console.error('[AIMC Code]', ...args),
+        },
+        Buffer,
+        Date,
+        Math,
+        JSON,
+        Promise,
+        setTimeout,
+        clearTimeout,
+    };
+    attachLibraries(sandbox, cache);
+    const libs = {};
+    attachLibraries(libs, cache);
+    sandbox.libs = libs;
+    return sandbox;
+}
+class AimcCode {
+    constructor() {
+        this.description = {
+            displayName: 'AIMC Code',
+            name: 'aimcCode',
+            icon: 'file:aimc-code.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Execute JavaScript with a curated toolkit of libraries.',
+            defaults: {
+                name: 'AIMC Code',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Mode',
+                    name: 'mode',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Run Once for All Items',
+                            value: 'runOnceForAllItems',
+                        },
+                        {
+                            name: 'Run Once for Each Item',
+                            value: 'runOnceForEachItem',
+                        },
+                    ],
+                    default: 'runOnceForAllItems',
+                },
+                {
+                    displayName: 'Timeout (Seconds)',
+                    name: 'timeoutSeconds',
+                    type: 'number',
+                    default: 30,
+                    typeOptions: {
+                        minValue: 1,
+                        maxValue: 300,
+                    },
+                },
+                {
+                    displayName: 'Code',
+                    name: 'code',
+                    type: 'string',
+                    typeOptions: {
+                        editor: 'jsEditor',
+                    },
+                    default: `// AIMC Code node\n// Use libs.<name> or direct globals like axios, _, zod\n\n// Example: transform all items\nconst data = $input.all().map((entry) => entry.json);\nconst ids = data.map((row) => nanoid());\n\nreturn data.map((row, index) => ({\n  ...row,\n  id: ids[index],\n  processedAt: utils.now(),\n}));\n`,
+                    description: 'Write JavaScript to transform data.',
+                    noDataExpression: true,
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const mode = this.getNodeParameter('mode', 0, 'runOnceForAllItems');
+        const code = this.getNodeParameter('code', 0, '');
+        const timeoutSeconds = this.getNodeParameter('timeoutSeconds', 0, 30);
+        if (!code.trim()) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No code provided.');
+        }
+        const timeoutMs = Math.max(1, timeoutSeconds) * 1000;
+        const nodeParams = this.getNode().parameters;
+        const runCode = async (sandbox) => {
+            const context = (0, vm_1.createContext)(sandbox);
+            const wrapped = `(async () => {\n${code}\n})()`;
+            return (0, vm_1.runInContext)(wrapped, context, { timeout: timeoutMs });
+        };
+        try {
+            if (mode === 'runOnceForEachItem') {
+                const results = [];
+                for (let index = 0; index < items.length; index++) {
+                    const item = items[index];
+                    const sandbox = buildSandbox({
+                        items: [item],
+                        item,
+                        mode,
+                        nodeParams,
+                    });
+                    const result = await runCode(sandbox);
+                    const normalized = normalizeResult(result, [item]);
+                    results.push(...normalized);
+                }
+                return [results];
+            }
+            const sandbox = buildSandbox({
+                items,
+                mode,
+                nodeParams,
+            });
+            const result = await runCode(sandbox);
+            const normalized = normalizeResult(result, items);
+            return [normalized];
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Code execution failed: ${message}`);
+        }
+    }
+}
+exports.AimcCode = AimcCode;

package/dist/nodes/AimcCode/aimc-code.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <rect x="6" y="6" width="52" height="52" rx="8" fill="#111827"/>
+  <path d="M24 22L14 32L24 42" stroke="#E5E7EB" stroke-width="4" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M40 22L50 32L40 42" stroke="#E5E7EB" stroke-width="4" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M30 20L34 44" stroke="#3B82F6" stroke-width="4" fill="none" stroke-linecap="round"/>
+</svg>

package/dist/nodes/AimcMedia/AimcMedia.node.d.ts

@@ -0,0 +1,5 @@
+import { INodeExecutionData, INodeType, INodeTypeDescription, IExecuteFunctions } from 'n8n-workflow';
+export declare class AimcMedia implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

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

@@ -0,0 +1,549 @@
+"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;
+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 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();
+        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) {
+                                reject(err);
+                                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,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <rect x="6" y="6" width="52" height="52" rx="8" fill="#0F172A"/>
+  <polygon points="26,20 26,44 46,32" fill="#22D3EE"/>
+  <path d="M14 48C22 40 30 40 38 48" stroke="#94A3B8" stroke-width="3" 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/aimc-n8n-toolkit'
+  }
+};

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@ferchy/aimc-n8n-toolkit",
+  "version": "0.1.0",
+  "description": "AIMC Toolkit nodes for n8n: code execution and media operations.",
+  "license": "MIT",
+  "author": "Ferchy",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "index.js",
+  "files": [
+    "dist/**/*",
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rimraf dist && tsc && gulp build:icons",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "aimc",
+    "toolkit"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/AimcCode/AimcCode.node.js",
+      "dist/nodes/AimcMedia/AimcMedia.node.js"
+    ]
+  },
+  "dependencies": {
+    "@distube/ytdl-core": "^4.15.1",
+    "ajv": "^8.17.1",
+    "axios": "^1.6.0",
+    "bytes": "^3.1.2",
+    "cheerio": "^1.0.0-rc.12",
+    "compromise": "^14.14.3",
+    "cron-parser": "^5.3.0",
+    "date-fns": "^4.1.0",
+    "date-fns-tz": "^3.2.0",
+    "dayjs": "^1.11.10",
+    "fast-xml-parser": "^5.2.5",
+    "fluent-ffmpeg": "^2.1.2",
+    "form-data": "^4.0.4",
+    "franc-min": "^6.2.0",
+    "fuse.js": "^7.1.0",
+    "handlebars": "^4.7.8",
+    "html-to-text": "^9.0.5",
+    "http-proxy-agent": "^7.0.2",
+    "iban": "^0.0.14",
+    "ini": "^5.0.0",
+    "joi": "^17.11.0",
+    "json-diff-ts": "^4.8.2",
+    "knex": "^3.1.0",
+    "libphonenumber-js": "^1.12.10",
+    "lodash": "^4.17.21",
+    "marked": "^15.0.6",
+    "moment-timezone": "^0.6.0",
+    "ms": "^2.1.3",
+    "nanoid": "^5.1.5",
+    "p-retry": "^5.1.2",
+    "papaparse": "^5.5.3",
+    "pluralize": "^8.0.0",
+    "protobufjs": "^7.5.4",
+    "qrcode": "^1.5.4",
+    "qs": "^6.14.0",
+    "slug": "^11.0.0",
+    "socks-proxy-agent": "^8.0.5",
+    "string-similarity": "^4.0.4",
+    "toml": "^3.0.0",
+    "uuid": "^11.1.0",
+    "validator": "^13.11.0",
+    "xml2js": "^0.6.2",
+    "yaml": "^2.8.1",
+    "yup": "^1.7.0",
+    "zod": "^3.25.76"
+  },
+  "optionalDependencies": {
+    "bufferutil": "^4.0.8",
+    "ffmpeg-static": "^5.3.0",
+    "ffprobe-static": "^3.1.0",
+    "utf-8-validate": "^6.0.4"
+  },
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "^2.1.28",
+    "@types/node": "^20.11.30",
+    "gulp": "^5.0.0",
+    "n8n-workflow": "^1.70.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.7.2"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}