@ferchy/n8n-nodes-aimc-toolkit 0.1.4

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

@@ -0,0 +1,502 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AimcCode = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const vm_1 = require("vm");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+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;
+}
+function indentCode(code, spaces = 4) {
+    const pad = ' '.repeat(spaces);
+    return code
+        .split('\n')
+        .map((line) => (line.trim().length ? `${pad}${line}` : line))
+        .join('\n');
+}
+async function createTempDir(prefix) {
+    return fs.promises.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+async function writeJsonFile(filePath, data) {
+    await fs.promises.writeFile(filePath, JSON.stringify(data), 'utf8');
+}
+async function runPython(params) {
+    const tempDir = await createTempDir('aimc-python-');
+    try {
+        const inputPath = path.join(tempDir, 'input.json');
+        const paramsPath = path.join(tempDir, 'params.json');
+        await writeJsonFile(inputPath, params.items.map((item) => item.json));
+        await writeJsonFile(paramsPath, params.nodeParams);
+        const wrapper = `
+import json
+import os
+import sys
+import traceback
+import subprocess
+
+def _load_json(path):
+    if not path:
+        return None
+    with open(path, 'r', encoding='utf-8') as handle:
+        return json.load(handle)
+
+def _auto_install(packages):
+    if not packages:
+        return
+    pkg_list = [p.strip() for p in packages.split(',') if p.strip()]
+    if not pkg_list:
+        return
+    subprocess.check_call([sys.executable, '-m', 'pip', 'install', '--user'] + pkg_list)
+
+items = _load_json(os.environ.get('AIMC_INPUT_PATH')) or []
+item = items[0] if items else None
+params = _load_json(os.environ.get('AIMC_PARAMS_PATH')) or {}
+result = None
+
+if os.environ.get('AIMC_PIP_AUTOINSTALL') == '1':
+    _auto_install(os.environ.get('AIMC_PIP_PACKAGES', ''))
+
+try:
+${indentCode(params.code, 4)}
+    if 'result' not in locals():
+        result = items
+    print('__AIMC_RESULT__' + json.dumps(result, default=str))
+except Exception:
+    traceback.print_exc()
+    sys.exit(1)
+`;
+        const scriptPath = path.join(tempDir, 'script.py');
+        await fs.promises.writeFile(scriptPath, wrapper, 'utf8');
+        const env = {
+            ...process.env,
+            AIMC_INPUT_PATH: inputPath,
+            AIMC_PARAMS_PATH: paramsPath,
+            AIMC_MODE: params.mode,
+            AIMC_PIP_AUTOINSTALL: params.autoInstall ? '1' : '0',
+            AIMC_PIP_PACKAGES: params.packages,
+        };
+        const { stdout, stderr } = await execFileAsync(params.pythonPath, [scriptPath], {
+            env,
+            timeout: params.timeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        const combined = `${stdout}\n${stderr}`.trim();
+        const marker = '__AIMC_RESULT__';
+        const markerIndex = combined.lastIndexOf(marker);
+        if (markerIndex === -1) {
+            throw new Error('Python did not return a result. Set `result` in your code.');
+        }
+        const jsonPayload = combined.slice(markerIndex + marker.length).trim();
+        return JSON.parse(jsonPayload);
+    }
+    finally {
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+    }
+}
+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: 'Language',
+                    name: 'language',
+                    type: 'options',
+                    options: [
+                        { name: 'JavaScript', value: 'javascript' },
+                        { name: 'Python', value: 'python' },
+                    ],
+                    default: 'javascript',
+                },
+                {
+                    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: 'JavaScript Code',
+                    name: 'code',
+                    type: 'string',
+                    typeOptions: {
+                        editor: 'jsEditor',
+                    },
+                    displayOptions: {
+                        show: {
+                            language: ['javascript'],
+                        },
+                    },
+                    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,
+                },
+                {
+                    displayName: 'Python Code',
+                    name: 'pythonCode',
+                    type: 'string',
+                    typeOptions: {
+                        editor: 'jsEditor',
+                        editorLanguage: 'python',
+                    },
+                    displayOptions: {
+                        show: {
+                            language: ['python'],
+                        },
+                    },
+                    default: `# AIMC Python\n# Access items (list of dicts), item (first item), and params (node params)\n# Set a variable named result to return output\n\nresult = {\n    \"count\": len(items),\n    \"first\": items[0] if items else None\n}\n`,
+                    description: 'Write Python to transform data. Set a variable named result.',
+                    noDataExpression: true,
+                },
+                {
+                    displayName: 'Python Path',
+                    name: 'pythonPath',
+                    type: 'string',
+                    default: 'python3',
+                    displayOptions: {
+                        show: {
+                            language: ['python'],
+                        },
+                    },
+                    description: 'Path to Python executable (e.g. python3 or /usr/bin/python3).',
+                },
+                {
+                    displayName: 'Python Packages (comma separated)',
+                    name: 'pythonPackages',
+                    type: 'string',
+                    default: 'requests,pandas,numpy,beautifulsoup4,lxml,python-dateutil,pytz,pydantic,pyyaml,xmltodict',
+                    displayOptions: {
+                        show: {
+                            language: ['python'],
+                        },
+                    },
+                    description: 'Optional packages to install when auto-install is enabled.',
+                },
+                {
+                    displayName: 'Auto-install Python Packages',
+                    name: 'pythonAutoInstall',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            language: ['python'],
+                        },
+                    },
+                    description: 'Install missing packages using pip before execution.',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const language = this.getNodeParameter('language', 0, 'javascript');
+        const mode = this.getNodeParameter('mode', 0, 'runOnceForAllItems');
+        const timeoutSeconds = this.getNodeParameter('timeoutSeconds', 0, 30);
+        const timeoutMs = Math.max(1, timeoutSeconds) * 1000;
+        const nodeParams = this.getNode().parameters;
+        if (language === 'python') {
+            const pythonCode = this.getNodeParameter('pythonCode', 0, '');
+            if (!pythonCode.trim()) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No Python code provided.');
+            }
+            const pythonPath = this.getNodeParameter('pythonPath', 0, 'python3');
+            const pythonPackages = this.getNodeParameter('pythonPackages', 0, '');
+            const autoInstall = this.getNodeParameter('pythonAutoInstall', 0, false);
+            try {
+                if (mode === 'runOnceForEachItem') {
+                    const results = [];
+                    for (let index = 0; index < items.length; index++) {
+                        const item = items[index];
+                        const result = await runPython({
+                            pythonPath,
+                            code: pythonCode,
+                            items: [item],
+                            mode,
+                            timeoutMs,
+                            nodeParams,
+                            autoInstall,
+                            packages: pythonPackages,
+                        });
+                        const normalized = normalizeResult(result, [item]);
+                        results.push(...normalized);
+                    }
+                    return [results];
+                }
+                const result = await runPython({
+                    pythonPath,
+                    code: pythonCode,
+                    items,
+                    mode,
+                    timeoutMs,
+                    nodeParams,
+                    autoInstall,
+                    packages: pythonPackages,
+                });
+                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(), `Python execution failed: ${message}`);
+            }
+        }
+        const code = this.getNodeParameter('code', 0, '');
+        if (!code.trim()) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No code provided.');
+        }
+        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,31 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <defs>
+    <linearGradient id="aimc-eye-bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#0A1021"/>
+      <stop offset="100%" stop-color="#0D1B3A"/>
+    </linearGradient>
+    <radialGradient id="aimc-eye-core" cx="50%" cy="50%" r="50%">
+      <stop offset="0%" stop-color="#7DD3FC"/>
+      <stop offset="65%" stop-color="#38BDF8"/>
+      <stop offset="100%" stop-color="#0EA5E9"/>
+    </radialGradient>
+  </defs>
+  <rect x="6" y="6" width="52" height="52" rx="10" fill="url(#aimc-eye-bg)"/>
+  <path d="M12 32C18 22 26 18 32 18C38 18 46 22 52 32C46 42 38 46 32 46C26 46 18 42 12 32Z" fill="none" stroke="#38BDF8" stroke-width="2.5"/>
+  <circle cx="32" cy="32" r="9.5" fill="url(#aimc-eye-core)" opacity="0.9"/>
+  <circle cx="32" cy="32" r="3.5" fill="#0B1223"/>
+  <g stroke="#1E3A8A" stroke-width="1.5" stroke-linecap="round" opacity="0.8">
+    <path d="M20 14V26"/>
+    <path d="M24 12V24"/>
+    <path d="M28 10V22"/>
+    <path d="M36 10V22"/>
+    <path d="M40 12V24"/>
+    <path d="M44 14V26"/>
+    <path d="M20 38V50"/>
+    <path d="M24 40V52"/>
+    <path d="M28 42V54"/>
+    <path d="M36 42V54"/>
+    <path d="M40 40V52"/>
+    <path d="M44 38V50"/>
+  </g>
+</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[][]>;
+}