n8n-nodes-chat2crm 0.1.0

package/dist/credentials/Chat2CrmRedisApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class Chat2CrmRedisApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/Chat2CrmRedisApi.credentials.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat2CrmRedisApi = void 0;
+class Chat2CrmRedisApi {
+    constructor() {
+        this.name = 'chat2CrmRedisApi';
+        this.displayName = 'Chat2Crm Redis API';
+        this.documentationUrl = '';
+        this.properties = [
+            {
+                displayName: 'Use SSH Tunnel',
+                name: 'useSSH',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to use SSH tunnel to connect to Redis',
+            },
+            {
+                displayName: 'SSH Host',
+                name: 'sshHost',
+                type: 'string',
+                displayOptions: {
+                    show: {
+                        useSSH: [true],
+                    },
+                },
+                default: '',
+                required: true,
+                description: 'SSH server hostname',
+            },
+            {
+                displayName: 'SSH Port',
+                name: 'sshPort',
+                type: 'number',
+                displayOptions: {
+                    show: {
+                        useSSH: [true],
+                    },
+                },
+                default: 22,
+                required: true,
+                description: 'SSH server port',
+            },
+            {
+                displayName: 'SSH Username',
+                name: 'sshUser',
+                type: 'string',
+                displayOptions: {
+                    show: {
+                        useSSH: [true],
+                    },
+                },
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'SSH Authentication',
+                name: 'sshAuthenticateWith',
+                type: 'options',
+                displayOptions: {
+                    show: {
+                        useSSH: [true],
+                    },
+                },
+                options: [
+                    {
+                        name: 'Password',
+                        value: 'password',
+                    },
+                    {
+                        name: 'Private Key',
+                        value: 'privateKey',
+                    },
+                ],
+                default: 'password',
+                description: 'SSH authentication method',
+            },
+            {
+                displayName: 'SSH Password',
+                name: 'sshPassword',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                displayOptions: {
+                    show: {
+                        useSSH: [true],
+                        sshAuthenticateWith: ['password'],
+                    },
+                },
+                default: '',
+            },
+            {
+                displayName: 'SSH Private Key',
+                name: 'privateKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                displayOptions: {
+                    show: {
+                        useSSH: [true],
+                        sshAuthenticateWith: ['privateKey'],
+                    },
+                },
+                default: '',
+                description: 'SSH private key in PEM format (supports RSA, ED25519, etc.). Can be pasted with or without line breaks - will be normalized automatically.',
+            },
+            {
+                displayName: 'SSH Passphrase',
+                name: 'passphrase',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                displayOptions: {
+                    show: {
+                        useSSH: [true],
+                        sshAuthenticateWith: ['privateKey'],
+                    },
+                },
+                default: '',
+                description: 'SSH private key passphrase (if required)',
+            },
+            {
+                displayName: 'Connection Type',
+                name: 'connectionType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Direct Connection',
+                        value: 'direct',
+                        description: 'Connect directly to Redis (localhost, IP, or container name)',
+                    },
+                    {
+                        name: 'Docker Container',
+                        value: 'docker',
+                        description: 'Connect to Redis in Docker container (same network)',
+                    },
+                ],
+                default: 'direct',
+                description: 'How to connect to Redis',
+            },
+            {
+                displayName: 'Docker Container Name',
+                name: 'dockerContainer',
+                type: 'string',
+                displayOptions: {
+                    show: {
+                        connectionType: ['docker'],
+                    },
+                },
+                default: 'chat2crm-redis-1',
+                required: true,
+                description: 'Docker container name for Redis (must be in the same Docker network as n8n)',
+            },
+            {
+                displayName: 'Redis Host',
+                name: 'host',
+                type: 'string',
+                default: 'localhost',
+                required: true,
+                description: 'Redis server hostname. If using SSH: hostname of Redis on the remote server (usually "localhost" or "127.0.0.1" if Redis is on the same server as SSH). If direct connection: use "localhost" or "127.0.0.1" if Redis is in Docker with port mapped to host.',
+            },
+            {
+                displayName: 'Redis Port',
+                name: 'port',
+                type: 'number',
+                default: 6379,
+                required: true,
+                description: 'Redis server port. If using SSH: port of Redis on the remote server (usually 6379). If direct connection: port on local machine (usually 6379 if Redis is in Docker with port mapped).',
+            },
+            {
+                displayName: 'Redis Database',
+                name: 'db',
+                type: 'number',
+                default: 0,
+                required: true,
+                description: 'Redis database number (0 for ChatWorker, 1 for CrmWorker)',
+            },
+            {
+                displayName: 'Password',
+                name: 'password',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                description: 'Redis password (if required)',
+            },
+        ];
+    }
+}
+exports.Chat2CrmRedisApi = Chat2CrmRedisApi;

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

@@ -0,0 +1,5 @@
+import { ITriggerFunctions, INodeType, INodeTypeDescription, ITriggerResponse } from 'n8n-workflow';
+export declare class Chat2CrmTrigger implements INodeType {
+    description: INodeTypeDescription;
+    trigger(this: ITriggerFunctions): Promise<ITriggerResponse | undefined>;
+}

package/dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat2CrmTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const RedisConnection_1 = require("./Infra/RedisConnection");
+class Chat2CrmTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Chat2Crm Trigger',
+            name: 'chat2CrmTrigger',
+            icon: 'file:chat2crm.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["streams"].join(", ")}}',
+            description: 'Triggers workflow when messages arrive in Chat2Crm Redis streams',
+            defaults: {
+                name: 'Chat2Crm Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'chat2CrmRedisApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Streams',
+                    name: 'streams',
+                    type: 'multiOptions',
+                    required: true, // Вернули required: true
+                    description: 'Select Redis streams to listen to',
+                    options: [
+                        {
+                            name: 'Chat Incoming Message',
+                            value: 'chat_incoming_message',
+                            description: 'Messages to chat (DB 0)',
+                        },
+                        {
+                            name: 'Chat Outgoing Message',
+                            value: 'chat_outgoing_message',
+                            description: 'Messages from chat to CRM (DB 0)',
+                        },
+                        {
+                            name: 'Chat Outgoing Status',
+                            value: 'chat_outgoing_status',
+                            description: 'Status messages from chat (DB 0)',
+                        },
+                        {
+                            name: 'Chat Outgoing Status (CRM)',
+                            value: 'chat_outgoing_status',
+                            description: 'Chat outgoing status in CRM DB (DB 1)',
+                        },
+                        {
+                            name: 'CRM Contacts',
+                            value: 'crm_contacts',
+                            description: 'CRM contacts stream (DB 1)',
+                        },
+                        {
+                            name: 'CRM Incoming Message',
+                            value: 'crm_incoming_message',
+                            description: 'Messages to CRM (DB 1)',
+                        },
+                        {
+                            name: 'CRM Incoming Status',
+                            value: 'crm_incoming_status',
+                            description: 'Status messages to CRM (DB 0)',
+                        },
+                        {
+                            name: 'CRM Lazy Incoming Message',
+                            value: 'crm_lazy_incoming_message',
+                            description: 'Lazy incoming messages to CRM (DB 1)',
+                        },
+                        {
+                            name: 'CRM Outgoing Message',
+                            value: 'crm_outgoing_message',
+                            description: 'Messages from CRM to chat (DB 1)',
+                        },
+                        {
+                            name: 'CRM Outgoing Status',
+                            value: 'crm_outgoing_status',
+                            description: 'Status messages from CRM (DB 1)',
+                        },
+                    ],
+                    default: ['chat_outgoing_message'],
+                },
+                {
+                    displayName: 'Block Time (Ms)',
+                    name: 'block',
+                    type: 'number',
+                    default: 1000,
+                    description: 'Block time in milliseconds when waiting for messages (0 = no blocking)',
+                },
+                {
+                    displayName: 'Count',
+                    name: 'count',
+                    type: 'number',
+                    default: 10,
+                    description: 'Maximum number of messages to read in one batch',
+                },
+                {
+                    displayName: 'Polling Interval (Seconds)',
+                    name: 'pollInterval',
+                    type: 'number',
+                    default: 0.5,
+                    description: 'How often to check for new messages (in seconds). Recommended: 0.1-1 second for real-time processing.',
+                },
+            ],
+        };
+    }
+    async trigger() {
+        const credentials = await this.getCredentials('chat2CrmRedisApi');
+        const selectedStreams = this.getNodeParameter('streams', []);
+        const block = this.getNodeParameter('block', 1000);
+        const count = this.getNodeParameter('count', 10);
+        const pollIntervalSeconds = this.getNodeParameter('pollInterval', 0.5);
+        const pollInterval = Math.min(pollIntervalSeconds * 1000, 500); // Максимум 500ms
+        // Проверяем, что выбраны streams
+        if (!selectedStreams || selectedStreams.length === 0) {
+            throw new n8n_workflow_1.ApplicationError('Please select at least one stream to monitor', { level: 'warning' });
+        }
+        // Группируем выбранные streams по базам данных
+        const streamsByDb = new Map();
+        selectedStreams.forEach(stream => {
+            let db = 0; // По умолчанию DB 0
+            // Streams в DB 1 (CrmWorker)
+            if (stream === 'crm_outgoing_message' ||
+                stream === 'crm_incoming_message' ||
+                stream === 'crm_lazy_incoming_message' ||
+                stream === 'crm_contacts') {
+                db = 1;
+            }
+            // Все остальные streams (chat_incoming_message, chat_outgoing_message, 
+            // crm_incoming_status, crm_outgoing_status) находятся в DB 0
+            if (!streamsByDb.has(db)) {
+                streamsByDb.set(db, []);
+            }
+            streamsByDb.get(db).push(stream);
+        });
+        // Создаем подключения к Redis только для нужных баз данных
+        const redisConnections = new Map();
+        for (const db of streamsByDb.keys()) {
+            const redis = await RedisConnection_1.createRedisConnection.call(this, credentials, db);
+            redisConnections.set(db, redis);
+        }
+        // Храним последние прочитанные ID для каждого stream
+        const lastReadIds = new Map();
+        // Собираем информацию о найденных streams для вывода
+        const foundStreams = [];
+        // Инициализируем lastReadIds для каждого stream и собираем информацию
+        for (const [db, dbStreams] of streamsByDb.entries()) {
+            const redis = redisConnections.get(db);
+            for (const stream of dbStreams) {
+                try {
+                    // Пытаемся получить информацию о stream
+                    const streamInfo = await redis.xinfo('STREAM', stream);
+                    if (streamInfo && Array.isArray(streamInfo)) {
+                        // Ищем 'last-entry' в информации о stream
+                        const lastEntryIndex = streamInfo.indexOf('last-entry');
+                        if (lastEntryIndex >= 0 && lastEntryIndex < streamInfo.length - 1) {
+                            const lastEntry = streamInfo[lastEntryIndex + 1];
+                            if (Array.isArray(lastEntry) && lastEntry.length > 0) {
+                                const lastId = lastEntry[0];
+                                lastReadIds.set(stream, lastId);
+                                foundStreams.push({ db, stream, exists: true, lastId });
+                            }
+                            else {
+                                lastReadIds.set(stream, '$');
+                                foundStreams.push({ db, stream, exists: true });
+                            }
+                        }
+                        else {
+                            lastReadIds.set(stream, '$');
+                            foundStreams.push({ db, stream, exists: true });
+                        }
+                    }
+                    else {
+                        lastReadIds.set(stream, '$');
+                        foundStreams.push({ db, stream, exists: true });
+                    }
+                }
+                catch (error) {
+                    // Если stream не существует или ошибка, используем '$' для новых сообщений
+                    if (error.message?.includes('no such key') || error.message?.includes('not found')) {
+                        lastReadIds.set(stream, '$');
+                        foundStreams.push({ db, stream, exists: false });
+                    }
+                    else {
+                        lastReadIds.set(stream, '$');
+                        foundStreams.push({ db, stream, exists: false });
+                    }
+                }
+            }
+        }
+        // Выводим список найденных streams
+        console.log(`[Chat2Crm Trigger] Connected to Redis. Monitoring ${foundStreams.length} selected stream(s):`);
+        foundStreams.forEach(({ db, stream, exists, lastId }) => {
+            if (exists) {
+                if (lastId) {
+                    console.log(`  ✓ DB ${db}: ${stream} (last ID: ${lastId})`);
+                }
+                else {
+                    console.log(`  ✓ DB ${db}: ${stream} (empty, waiting for messages)`);
+                }
+            }
+            else {
+                console.log(`  ✗ DB ${db}: ${stream} (not found, will monitor when created)`);
+            }
+        });
+        // Флаг для отслеживания состояния закрытия
+        let isClosing = false;
+        // Функция для чтения сообщений
+        const readMessages = async () => {
+            // Проверяем, не закрывается ли триггер
+            if (isClosing) {
+                return;
+            }
+            for (const [db, dbStreams] of streamsByDb.entries()) {
+                // Проверяем снова перед каждой итерацией
+                if (isClosing) {
+                    break;
+                }
+                const redis = redisConnections.get(db);
+                // Читаем каждый stream отдельно через XREAD
+                // XREAD читает напрямую из stream, независимо от consumer groups
+                for (const stream of dbStreams) {
+                    if (isClosing) {
+                        break;
+                    }
+                    try {
+                        const lastId = lastReadIds.get(stream) || '$';
+                        // Используем более короткий block time для возможности быстрого закрытия
+                        const blockTime = isClosing ? 0 : Math.min(block, 500); // Максимум 500ms для более быстрого отклика
+                        // Используем XREAD чтобы читать все сообщения напрямую из stream
+                        // Это позволяет читать сообщения даже если они уже обработаны другими consumer'ами
+                        const messages = await redis.xread('COUNT', count, 'BLOCK', blockTime, 'STREAMS', stream, lastId);
+                        // Проверяем снова после блокирующей операции
+                        if (isClosing) {
+                            return;
+                        }
+                        if (messages && Array.isArray(messages) && messages.length > 0) {
+                            // XREAD возвращает массив с одним элементом [streamName, messages]
+                            const streamData = messages[0];
+                            const [streamName, streamMessages] = streamData;
+                            if (Array.isArray(streamMessages) && streamMessages.length > 0) {
+                                // Обновляем lastReadId на последний прочитанный ID
+                                const lastMessageId = streamMessages[streamMessages.length - 1][0];
+                                lastReadIds.set(streamName, lastMessageId);
+                                for (const [messageId, fields] of streamMessages) {
+                                    if (isClosing) {
+                                        break;
+                                    }
+                                    const messageData = {};
+                                    // Parse fields
+                                    for (let j = 0; j < fields.length; j += 2) {
+                                        messageData[fields[j]] = fields[j + 1];
+                                    }
+                                    // Parse commands if it's a string
+                                    if (messageData.commands && typeof messageData.commands === 'string') {
+                                        try {
+                                            messageData.commands = JSON.parse(messageData.commands);
+                                        }
+                                        catch (e) {
+                                            // Ignore parse errors
+                                        }
+                                    }
+                                    // Триггерим workflow с данными сообщения
+                                    const executionData = {
+                                        json: {
+                                            messageId,
+                                            stream: streamName,
+                                            data: messageData,
+                                            commandList: messageData,
+                                        },
+                                    };
+                                    this.emit([[executionData]]);
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        // Игнорируем ошибки при закрытии
+                        if (isClosing && (error.message?.includes('Connection is closed') || error.message?.includes('disconnect'))) {
+                            return;
+                        }
+                        // Игнорируем ошибки для несуществующих streams
+                        if (error.message?.includes('Invalid stream ID') || error.message?.includes('no such key')) {
+                            continue;
+                        }
+                        // Логируем только критические ошибки
+                        console.error(`[Chat2Crm Trigger] Error reading stream ${stream} from Redis DB ${db}:`, error);
+                    }
+                }
+            }
+        };
+        // Начинаем polling с более коротким интервалом
+        let interval = null;
+        const startPolling = () => {
+            interval = setInterval(async () => {
+                if (!isClosing) {
+                    await readMessages();
+                }
+            }, pollInterval);
+        };
+        startPolling();
+        // Первый запуск сразу
+        await readMessages();
+        // Возвращаем объект с функцией closeFunction для cleanup
+        return {
+            closeFunction: async () => {
+                console.log(`[Chat2Crm Trigger] Closing trigger, cleaning up resources...`);
+                isClosing = true; // Устанавливаем флаг закрытия
+                try {
+                    if (interval) {
+                        clearInterval(interval);
+                        interval = null;
+                    }
+                    // Используем disconnect() вместо quit() для более быстрого закрытия
+                    for (const [db, redis] of redisConnections.entries()) {
+                        try {
+                            redis.disconnect();
+                        }
+                        catch (error) {
+                            console.error(`[Chat2Crm Trigger] Error disconnecting Redis connection for DB ${db}:`, error);
+                        }
+                    }
+                    redisConnections.clear();
+                    console.log(`[Chat2Crm Trigger] Cleanup completed`);
+                }
+                catch (error) {
+                    console.error(`[Chat2Crm Trigger] Error during cleanup:`, error);
+                }
+            },
+        };
+    }
+}
+exports.Chat2CrmTrigger = Chat2CrmTrigger;

package/dist/nodes/Chat2CrmTrigger/Infra/RedisConnection.d.ts

@@ -0,0 +1,3 @@
+import Redis from 'ioredis';
+import { ITriggerFunctions, IExecuteFunctions } from 'n8n-workflow';
+export declare function createRedisConnection(this: IExecuteFunctions | ITriggerFunctions, credentials: any, db?: number): Promise<Redis>;

package/dist/nodes/Chat2CrmTrigger/Infra/RedisConnection.js

@@ -0,0 +1,197 @@
+"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.createRedisConnection = createRedisConnection;
+const ioredis_1 = __importDefault(require("ioredis"));
+const net = __importStar(require("net"));
+/**
+ * Нормализует приватный ключ SSH
+ * Удаляет лишние пробелы и обеспечивает правильные переносы строк
+ */
+function normalizePrivateKey(privateKey) {
+    if (!privateKey) {
+        return privateKey;
+    }
+    // Удаляем все пробелы в начале и конце
+    let normalized = privateKey.trim();
+    // Если ключ уже содержит правильные заголовки, просто нормализуем переносы строк
+    if (normalized.includes('-----BEGIN')) {
+        // Заменяем все варианты переносов строк на \n
+        normalized = normalized.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        // Удаляем лишние пустые строки
+        normalized = normalized.replace(/\n{3,}/g, '\n\n');
+        // Убеждаемся, что в конце есть перенос строки
+        if (!normalized.endsWith('\n')) {
+            normalized += '\n';
+        }
+        return normalized;
+    }
+    // Если ключ в одну строку, пытаемся определить формат и добавить переносы
+    // Это для случаев, когда пользователь вставил ключ без переносов
+    if (normalized.length > 50 && !normalized.includes('\n')) {
+        // Пытаемся найти начало ключа
+        const beginMatch = normalized.match(/-----BEGIN[^-]+-----/);
+        const endMatch = normalized.match(/-----END[^-]+-----/);
+        if (beginMatch && endMatch) {
+            const begin = beginMatch[0];
+            const end = endMatch[0];
+            const keyContent = normalized.substring(beginMatch.index + begin.length, endMatch.index).trim();
+            // Добавляем переносы строк каждые 64 символа (стандарт для PEM)
+            const formattedContent = keyContent.replace(/.{64}/g, '$&\n').trim();
+            return `${begin}\n${formattedContent}\n${end}\n`;
+        }
+    }
+    return normalized;
+}
+async function createRedisConnection(credentials, db = 0) {
+    let redisHost = credentials.host;
+    let redisPort = credentials.port;
+    // Если используется SSH туннель
+    if (credentials.useSSH) {
+        console.log(`[Redis Connection] Setting up SSH tunnel to ${credentials.sshHost}:${credentials.sshPort}`);
+        let sshCredentials;
+        if (credentials.sshAuthenticateWith === 'password') {
+            sshCredentials = {
+                sshHost: credentials.sshHost,
+                sshPort: credentials.sshPort || 22,
+                sshUser: credentials.sshUser,
+                sshAuthenticateWith: 'password',
+                sshPassword: credentials.sshPassword,
+            };
+        }
+        else {
+            // Нормализуем приватный ключ перед использованием
+            const privateKey = normalizePrivateKey(credentials.privateKey);
+            sshCredentials = {
+                sshHost: credentials.sshHost,
+                sshPort: credentials.sshPort || 22,
+                sshUser: credentials.sshUser,
+                sshAuthenticateWith: 'privateKey',
+                privateKey: privateKey,
+                passphrase: credentials.passphrase,
+            };
+        }
+        try {
+            // Создаем SSH клиент
+            console.log(`[Redis Connection] Creating SSH client...`);
+            const sshClient = await this.helpers.getSSHClient(sshCredentials);
+            console.log(`[Redis Connection] SSH client created successfully`);
+            // Redis на удаленном сервере
+            const remoteRedisHost = credentials.host || 'localhost';
+            const remoteRedisPort = credentials.port || 6379;
+            console.log(`[Redis Connection] Creating tunnel to Redis at ${remoteRedisHost}:${remoteRedisPort} on remote server`);
+            // Создаем локальный TCP сервер для проксирования через SSH туннель
+            const localServer = net.createServer((localSocket) => {
+                // Создаем SSH туннель для каждого соединения
+                sshClient.forwardOut('127.0.0.1', 0, remoteRedisHost, remoteRedisPort, (err, stream) => {
+                    if (err) {
+                        console.error(`[Redis Connection] SSH forwardOut error:`, err.message);
+                        localSocket.destroy();
+                        return;
+                    }
+                    // Проксируем данные между локальным сокетом и SSH stream
+                    localSocket.pipe(stream);
+                    stream.pipe(localSocket);
+                    // Обработка ошибок
+                    localSocket.on('error', (err) => {
+                        console.error(`[Redis Connection] Local socket error:`, err.message);
+                        stream.destroy();
+                    });
+                    stream.on('error', (err) => {
+                        console.error(`[Redis Connection] SSH stream error:`, err.message);
+                        localSocket.destroy();
+                    });
+                });
+            });
+            // Запускаем локальный сервер на случайном порту
+            await new Promise((resolve, reject) => {
+                localServer.listen(0, '127.0.0.1', () => {
+                    const address = localServer.address();
+                    if (address && typeof address === 'object') {
+                        redisHost = '127.0.0.1';
+                        redisPort = address.port;
+                        console.log(`[Redis Connection] SSH tunnel established: localhost:${redisPort} -> ${remoteRedisHost}:${remoteRedisPort} via ${credentials.sshHost}:${credentials.sshPort}`);
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('Failed to get local server address'));
+                    }
+                });
+                localServer.on('error', (err) => {
+                    reject(err);
+                });
+            });
+        }
+        catch (error) {
+            console.error(`[Redis Connection] Failed to create SSH tunnel:`, error.message);
+            throw new Error(`SSH tunnel failed: ${error.message}`);
+        }
+    }
+    else {
+        console.log(`[Redis Connection] Direct connection to Redis at ${redisHost}:${redisPort}`);
+    }
+    // Создаем подключение к Redis
+    console.log(`[Redis Connection] Connecting to Redis: ${redisHost}:${redisPort}, DB: ${db}`);
+    const redis = new ioredis_1.default({
+        host: redisHost,
+        port: redisPort,
+        db: db,
+        password: credentials.password,
+        enableReadyCheck: true,
+        maxRetriesPerRequest: 3,
+        connectTimeout: 10000, // 10 секунд таймаут подключения
+        retryStrategy: (times) => {
+            const delay = Math.min(times * 50, 2000);
+            return delay;
+        },
+    });
+    // Добавляем обработчики событий для диагностики
+    redis.on('connect', () => {
+        console.log(`[Redis Connection] Connected to Redis at ${redisHost}:${redisPort}, DB ${db}`);
+    });
+    redis.on('ready', () => {
+        console.log(`[Redis Connection] Redis ready at ${redisHost}:${redisPort}, DB ${db}`);
+    });
+    redis.on('error', (err) => {
+        console.error(`[Redis Connection] Redis error on ${redisHost}:${redisPort}, DB ${db}:`, err.message);
+    });
+    redis.on('close', () => {
+        console.log(`[Redis Connection] Redis connection closed: ${redisHost}:${redisPort}, DB ${db}`);
+    });
+    return redis;
+}

package/dist/nodes/Chat2CrmTrigger/chat2crm.svg

@@ -0,0 +1,25 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="640.000000pt" height="640.000000pt" viewBox="0 0 640.000000 640.000000"
+ preserveAspectRatio="xMidYMid meet">
+
+<g transform="translate(0.000000,640.000000) scale(0.100000,-0.100000)"
+fill="#000000" stroke="none">
+<path d="M2150 4544 l0 -979 416 -416 415 -416 -3 -611 c-2 -337 0 -611 3
+-610 17 7 1036 1008 1192 1170 l177 186 0 248 0 249 -275 275 -275 275 0 -255
+0 -254 47 -48 47 -48 43 42 43 42 0 -453 c0 -249 -4 -451 -9 -449 -4 2 -231
+223 -504 492 l-495 489 -1 282 -1 283 -115 212 c-63 117 -114 215 -112 216 2
+2 52 -46 112 -106 60 -61 112 -110 115 -110 3 0 4 111 3 247 l-2 248 -313 298
+c-172 164 -357 338 -410 388 l-98 91 0 -978z"/>
+<path d="M3092 3547 l-32 -33 253 -249 c139 -138 286 -283 328 -323 l75 -72
+42 39 c52 49 56 81 10 81 l-32 0 32 33 c31 31 32 37 32 112 l0 79 -57 59 -58
+58 37 31 38 30 -87 94 -87 94 -231 0 -231 0 -32 -33z"/>
+<path d="M2643 1858 l-243 -243 0 93 c0 50 -1 92 -3 92 -2 0 -58 -55 -125
+-122 l-122 -123 0 -95 0 -95 125 125 125 125 0 -220 0 -220 245 245 245 245
+-2 218 -3 217 -242 -242z"/>
+<path d="M3415 1792 c-27 -25 -138 -131 -245 -236 l-194 -191 -1 -217 c0 -120
+3 -217 6 -215 4 1 115 108 248 238 l241 237 -2 215 -3 216 -50 -47z"/>
+</g>
+</svg>

package/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+  nodes: [
+    require('./dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js'),
+  ],
+  credentials: [
+    require('./dist/credentials/Chat2CrmRedisApi.credentials.js'),
+  ],
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "n8n-nodes-chat2crm",
+    "version": "0.1.0",
+    "description": "n8n node for Chat2Crm Redis integration",
+    "keywords": [
+        "n8n-community-node-package",
+        "chat2crm",
+        "redis",
+        "messaging"
+    ],
+    "main": "index.js",
+    "scripts": {
+        "build": "rm -rf dist && tsc && gulp build:icons",
+        "dev": "npm run build && npx n8n",
+        "dev:watch": "tsc --watch",
+        "format": "prettier nodes credentials --write",
+        "lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" \"package.json\"",
+        "lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" \"package.json\" --fix",
+        "prepublishOnly": "npm run build && npm run lint -s"
+    },
+    "files": [
+        "dist"
+    ],
+    "n8n": {
+        "n8nNodesApiVersion": 1,
+        "credentials": [
+            "dist/credentials/Chat2CrmRedisApi.credentials.js"
+        ],
+        "nodes": [
+            "dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js"
+        ]
+    },
+    "devDependencies": {
+        "@types/node": "^20.10.0",
+        "@typescript-eslint/parser": "^6.13.0",
+        "@typescript-eslint/eslint-plugin": "^6.13.0",
+        "@types/uuid": "^9.0.7",
+        "eslint": "^8.57.1",
+        "eslint-plugin-n8n-nodes-base": "^1.11.0",
+        "gulp": "^4.0.2",
+        "n8n": "*",
+        "n8n-workflow": "*",
+        "prettier": "^3.1.0",
+        "typescript": "^5.3.0"
+    },
+    "dependencies": {
+        "ioredis": "^5.3.2",
+        "uuid": "^9.0.1"
+    },
+    "peerDependencies": {
+        "n8n-workflow": "*"
+    }
+}