@atom8n/n8n 2.4.7 → 2.5.1

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination.ee.d.ts

@@ -0,0 +1,28 @@
+import { Logger } from '@n8n/backend-common';
+import type { INodeCredentials, MessageEventBusDestinationOptions } from 'n8n-workflow';
+import { MessageEventBusDestinationTypeNames } from 'n8n-workflow';
+import type { AbstractEventMessage } from '../../../eventbus/event-message-classes/abstract-event-message';
+import type { MessageEventBus, MessageWithCallback } from '../../../eventbus/message-event-bus/message-event-bus';
+import { License } from '../../../license';
+import { CircuitBreaker } from '../../../utils/circuit-breaker';
+export declare abstract class MessageEventBusDestination implements MessageEventBusDestinationOptions {
+    readonly id: string;
+    readonly eventBusInstance: MessageEventBus;
+    protected readonly logger: Logger;
+    protected readonly license: License;
+    protected circuitBreakerInstance: CircuitBreaker;
+    __type: MessageEventBusDestinationTypeNames;
+    label: string;
+    enabled: boolean;
+    subscribedEvents: string[];
+    credentials: INodeCredentials;
+    anonymizeAuditMessages: boolean;
+    constructor(eventBusInstance: MessageEventBus, options: MessageEventBusDestinationOptions);
+    getId(): string;
+    hasSubscribedToEvent(msg: AbstractEventMessage): boolean;
+    serialize(): MessageEventBusDestinationOptions;
+    abstract receiveFromEventBus(emitterPayload: MessageWithCallback): Promise<boolean>;
+    sendMessage(emitterPayload: MessageWithCallback): Promise<boolean>;
+    toString(): string;
+    close(): Promise<void>;
+}

package/dist/modules/log-streaming.ee/destinations/message-event-bus-destination.ee.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageEventBusDestination = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const constants_1 = require("@n8n/constants");
+const di_1 = require("@n8n/di");
+const uuid_1 = require("uuid");
+const license_1 = require("../../../license");
+const circuit_breaker_1 = require("../../../utils/circuit-breaker");
+class MessageEventBusDestination {
+    constructor(eventBusInstance, options) {
+        this.credentials = {};
+        this.logger = di_1.Container.get(backend_common_1.Logger);
+        this.license = di_1.Container.get(license_1.License);
+        const timeout = options.circuitBreaker?.maxDuration ?? constants_1.LOGSTREAMING_CB_DEFAULT_MAX_DURATION_MS;
+        const maxFailures = options.circuitBreaker?.maxFailures ?? constants_1.LOGSTREAMING_CB_DEFAULT_MAX_FAILURES;
+        const halfOpenRequests = options.circuitBreaker?.halfOpenRequests ?? constants_1.LOGSTREAMING_CB_DEFAULT_HALF_OPEN_REQUESTS;
+        const failureWindow = options.circuitBreaker?.failureWindow ?? constants_1.LOGSTREAMING_CB_DEFAULT_FAILURE_WINDOW_MS;
+        const maxConcurrentHalfOpenRequests = options.circuitBreaker?.maxConcurrentHalfOpenRequests ??
+            constants_1.LOGSTREAMING_CB_DEFAULT_CONCURRENT_HALF_OPEN_REQUESTS;
+        this.circuitBreakerInstance = new circuit_breaker_1.CircuitBreaker({
+            timeout,
+            maxFailures,
+            halfOpenRequests,
+            failureWindow,
+            maxConcurrentHalfOpenRequests,
+        });
+        this.eventBusInstance = eventBusInstance;
+        this.id = !options.id || options.id.length !== 36 ? (0, uuid_1.v4)() : options.id;
+        this.__type = options.__type ?? "$$AbstractMessageEventBusDestination";
+        this.label = options.label ?? 'Log Destination';
+        this.enabled = options.enabled ?? false;
+        this.subscribedEvents = options.subscribedEvents ?? [];
+        this.anonymizeAuditMessages = options.anonymizeAuditMessages ?? false;
+        if (options.credentials)
+            this.credentials = options.credentials;
+        this.logger.debug(`${this.__type}(${this.id}) event destination constructed`);
+    }
+    getId() {
+        return this.id;
+    }
+    hasSubscribedToEvent(msg) {
+        if (!this.enabled)
+            return false;
+        for (const eventName of this.subscribedEvents) {
+            if (eventName === '*' || msg.eventName.startsWith(eventName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    serialize() {
+        return {
+            __type: this.__type,
+            id: this.getId(),
+            label: this.label,
+            enabled: this.enabled,
+            subscribedEvents: this.subscribedEvents,
+            anonymizeAuditMessages: this.anonymizeAuditMessages,
+        };
+    }
+    async sendMessage(emitterPayload) {
+        return await this.circuitBreakerInstance.execute(async () => {
+            return await this.receiveFromEventBus(emitterPayload);
+        });
+    }
+    toString() {
+        return JSON.stringify(this.serialize());
+    }
+    async close() {
+        this.enabled = false;
+    }
+}
+exports.MessageEventBusDestination = MessageEventBusDestination;

package/dist/modules/log-streaming.ee/log-streaming-destination.service.d.ts

@@ -0,0 +1,32 @@
+import { LicenseState, Logger } from '@n8n/backend-common';
+import type { DeleteResult } from '@n8n/typeorm';
+import type { MessageEventBusDestinationOptions } from 'n8n-workflow';
+import type { EventMessageTypes } from '../../eventbus';
+import { MessageEventBus } from '../../eventbus/message-event-bus/message-event-bus';
+import { Publisher } from '../../scaling/pubsub/publisher.service';
+import { EventDestinationsRepository } from './database/repositories/event-destination.repository';
+import { MessageEventBusDestination } from './destinations/message-event-bus-destination.ee';
+export declare class LogStreamingDestinationService {
+    private readonly logger;
+    private readonly eventDestinationsRepository;
+    private readonly eventBus;
+    private readonly licenseState;
+    private readonly publisher;
+    private destinations;
+    private isListening;
+    private readonly messageHandler;
+    constructor(logger: Logger, eventDestinationsRepository: EventDestinationsRepository, eventBus: MessageEventBus, licenseState: LicenseState, publisher: Publisher);
+    loadDestinationsFromDb(): Promise<void>;
+    saveDestinationToDb(destination: MessageEventBusDestination): Promise<import("@n8n/typeorm").InsertResult>;
+    deleteDestinationFromDb(id: string): Promise<DeleteResult>;
+    addDestination(destination: MessageEventBusDestination, notifyWorkers?: boolean): Promise<MessageEventBusDestination>;
+    removeDestination(id: string, notifyWorkers?: boolean): Promise<DeleteResult>;
+    initialize(): Promise<void>;
+    private handleMessage;
+    findDestination(id?: string): Promise<MessageEventBusDestinationOptions[]>;
+    testDestination(destinationId: string): Promise<boolean>;
+    private hasAnyDestinationSubscribedToEvent;
+    shouldSendMsg(msg: EventMessageTypes): boolean;
+    close(): Promise<void>;
+    restart(): Promise<void>;
+}

package/dist/modules/log-streaming.ee/log-streaming-destination.service.js

@@ -0,0 +1,175 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogStreamingDestinationService = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const decorators_1 = require("@n8n/decorators");
+const di_1 = require("@n8n/di");
+const event_message_generic_1 = require("../../eventbus/event-message-classes/event-message-generic");
+const message_event_bus_1 = require("../../eventbus/message-event-bus/message-event-bus");
+const publisher_service_1 = require("../../scaling/pubsub/publisher.service");
+const event_destination_repository_1 = require("./database/repositories/event-destination.repository");
+const message_event_bus_destination_from_db_1 = require("./destinations/message-event-bus-destination-from-db");
+let LogStreamingDestinationService = class LogStreamingDestinationService {
+    constructor(logger, eventDestinationsRepository, eventBus, licenseState, publisher) {
+        this.logger = logger;
+        this.eventDestinationsRepository = eventDestinationsRepository;
+        this.eventBus = eventBus;
+        this.licenseState = licenseState;
+        this.publisher = publisher;
+        this.destinations = {};
+        this.isListening = false;
+        this.messageHandler = this.handleMessage.bind(this);
+    }
+    async loadDestinationsFromDb() {
+        const savedEventDestinations = await this.eventDestinationsRepository.find({});
+        if (savedEventDestinations.length > 0) {
+            for (const destinationData of savedEventDestinations) {
+                try {
+                    const destination = (0, message_event_bus_destination_from_db_1.messageEventBusDestinationFromDb)(this.eventBus, destinationData);
+                    if (destination) {
+                        this.destinations[destination.getId()] = destination;
+                        this.logger.debug(`Loaded destination ${destination.getId()} from database`);
+                    }
+                }
+                catch (error) {
+                    this.logger.debug('Failed to load destination from database', { error });
+                }
+            }
+        }
+    }
+    async saveDestinationToDb(destination) {
+        const data = {
+            id: destination.getId(),
+            destination: destination.serialize(),
+        };
+        const dbResult = await this.eventDestinationsRepository.upsert(data, {
+            skipUpdateIfNoValuesChanged: true,
+            conflictPaths: ['id'],
+        });
+        return dbResult;
+    }
+    async deleteDestinationFromDb(id) {
+        return await this.eventDestinationsRepository.delete({ id });
+    }
+    async addDestination(destination, notifyWorkers = true) {
+        await this.destinations[destination.getId()]?.close();
+        this.destinations[destination.getId()] = destination;
+        this.logger.debug(`Added destination ${destination.getId()}`);
+        await this.saveDestinationToDb(destination);
+        if (notifyWorkers) {
+            void this.publisher.publishCommand({ command: 'restart-event-bus' });
+        }
+        return destination;
+    }
+    async removeDestination(id, notifyWorkers = true) {
+        if (this.destinations[id]) {
+            await this.destinations[id].close();
+            delete this.destinations[id];
+            this.logger.debug(`Removed destination ${id}`);
+        }
+        if (notifyWorkers) {
+            void this.publisher.publishCommand({ command: 'restart-event-bus' });
+        }
+        return await this.deleteDestinationFromDb(id);
+    }
+    async initialize() {
+        if (this.isListening) {
+            return;
+        }
+        this.logger.debug('Initializing log streaming destination service...');
+        this.eventBus.on('message', this.messageHandler);
+        this.isListening = true;
+        this.logger.debug(`Log streaming destination service initialized with ${Object.keys(this.destinations).length} destinations`);
+    }
+    async handleMessage(msg, confirmCallback) {
+        if (!this.shouldSendMsg(msg)) {
+            this.eventBus.confirmSent(msg, { id: '0', name: 'eventBus' });
+            return;
+        }
+        for (const destination of Object.values(this.destinations)) {
+            if (destination.hasSubscribedToEvent(msg)) {
+                try {
+                    await destination.sendMessage({ msg, confirmCallback });
+                }
+                catch (error) {
+                    this.logger.error(`Failed to send message to destination ${destination.getId()}`, {
+                        error,
+                    });
+                }
+            }
+        }
+    }
+    async findDestination(id) {
+        const result = id
+            ? this.destinations[id]
+                ? [this.destinations[id].serialize()]
+                : []
+            : Object.values(this.destinations).map((dest) => dest.serialize());
+        return result.sort((a, b) => (a.__type ?? '').localeCompare(b.__type ?? ''));
+    }
+    async testDestination(destinationId) {
+        const msg = new event_message_generic_1.EventMessageGeneric({
+            eventName: event_message_generic_1.eventMessageGenericDestinationTestEvent,
+        });
+        const destination = await this.findDestination(destinationId);
+        if (destination.length > 0) {
+            const sendResult = await this.destinations[destinationId].receiveFromEventBus({
+                msg,
+                confirmCallback: () => this.eventBus.confirmSent(msg, { id: '0', name: 'eventBus' }),
+            });
+            return sendResult;
+        }
+        return false;
+    }
+    hasAnyDestinationSubscribedToEvent(msg) {
+        return Object.values(this.destinations).some((destination) => destination.hasSubscribedToEvent(msg));
+    }
+    shouldSendMsg(msg) {
+        return (this.licenseState.isLogStreamingLicensed() &&
+            Object.keys(this.destinations).length > 0 &&
+            this.hasAnyDestinationSubscribedToEvent(msg));
+    }
+    async close() {
+        this.logger.debug('Closing log streaming destination service...');
+        if (this.isListening) {
+            this.eventBus.removeListener('message', this.messageHandler);
+            this.isListening = false;
+        }
+        for (const destination of Object.values(this.destinations)) {
+            this.logger.debug(`Closing destination ${destination.getId()}...`);
+            await destination.close();
+        }
+        this.destinations = {};
+        this.logger.debug('Log streaming destination service closed');
+    }
+    async restart() {
+        this.logger.debug('Restarting log streaming destination service...');
+        await this.close();
+        await this.loadDestinationsFromDb();
+        await this.initialize();
+    }
+};
+exports.LogStreamingDestinationService = LogStreamingDestinationService;
+__decorate([
+    (0, decorators_1.OnPubSubEvent)('restart-event-bus'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], LogStreamingDestinationService.prototype, "restart", null);
+exports.LogStreamingDestinationService = LogStreamingDestinationService = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [backend_common_1.Logger,
+        event_destination_repository_1.EventDestinationsRepository,
+        message_event_bus_1.MessageEventBus,
+        backend_common_1.LicenseState,
+        publisher_service_1.Publisher])
+], LogStreamingDestinationService);

package/dist/modules/log-streaming.ee/log-streaming.controller.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedRequest } from '@n8n/db';
+import express from 'express';
+import type { MessageEventBusDestinationOptions } from 'n8n-workflow';
+import { MessageEventBus } from '../../eventbus/message-event-bus/message-event-bus';
+import { LogStreamingDestinationService } from './log-streaming-destination.service';
+export declare class EventBusController {
+    private readonly eventBus;
+    private readonly destinationService;
+    constructor(eventBus: MessageEventBus, destinationService: LogStreamingDestinationService);
+    getEventNames(): Promise<string[]>;
+    getDestination(req: express.Request): Promise<MessageEventBusDestinationOptions[]>;
+    postDestination(req: AuthenticatedRequest): Promise<any>;
+    sendTestMessage(req: express.Request): Promise<boolean>;
+    deleteDestination(req: AuthenticatedRequest): Promise<void>;
+}

package/dist/modules/log-streaming.ee/log-streaming.controller.js

@@ -0,0 +1,149 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBusController = void 0;
+const decorators_1 = require("@n8n/decorators");
+const express_1 = __importDefault(require("express"));
+const bad_request_error_1 = require("../../errors/response-errors/bad-request.error");
+const event_message_classes_1 = require("../../eventbus/event-message-classes");
+const message_event_bus_1 = require("../../eventbus/message-event-bus/message-event-bus");
+const message_event_bus_destination_sentry_ee_1 = require("./destinations/message-event-bus-destination-sentry.ee");
+const message_event_bus_destination_syslog_ee_1 = require("./destinations/message-event-bus-destination-syslog.ee");
+const message_event_bus_destination_webhook_ee_1 = require("./destinations/message-event-bus-destination-webhook.ee");
+const log_streaming_destination_service_1 = require("./log-streaming-destination.service");
+const isWithIdString = (candidate) => {
+    const o = candidate;
+    if (!o)
+        return false;
+    return o.id !== undefined;
+};
+const isMessageEventBusDestinationWebhookOptions = (candidate) => {
+    const o = candidate;
+    if (!o)
+        return false;
+    return o.url !== undefined;
+};
+const isMessageEventBusDestinationOptions = (candidate) => {
+    const o = candidate;
+    if (!o)
+        return false;
+    return o.__type !== undefined;
+};
+let EventBusController = class EventBusController {
+    constructor(eventBus, destinationService) {
+        this.eventBus = eventBus;
+        this.destinationService = destinationService;
+    }
+    async getEventNames() {
+        return event_message_classes_1.eventNamesAll;
+    }
+    async getDestination(req) {
+        if (isWithIdString(req.query)) {
+            return await this.destinationService.findDestination(req.query.id);
+        }
+        else {
+            return await this.destinationService.findDestination();
+        }
+    }
+    async postDestination(req) {
+        let result;
+        if (isMessageEventBusDestinationOptions(req.body)) {
+            switch (req.body.__type) {
+                case "$$MessageEventBusDestinationSentry":
+                    if ((0, message_event_bus_destination_sentry_ee_1.isMessageEventBusDestinationSentryOptions)(req.body)) {
+                        result = await this.destinationService.addDestination(new message_event_bus_destination_sentry_ee_1.MessageEventBusDestinationSentry(this.eventBus, req.body));
+                    }
+                    break;
+                case "$$MessageEventBusDestinationWebhook":
+                    if (isMessageEventBusDestinationWebhookOptions(req.body)) {
+                        result = await this.destinationService.addDestination(new message_event_bus_destination_webhook_ee_1.MessageEventBusDestinationWebhook(this.eventBus, req.body));
+                    }
+                    break;
+                case "$$MessageEventBusDestinationSyslog":
+                    if ((0, message_event_bus_destination_syslog_ee_1.isMessageEventBusDestinationSyslogOptions)(req.body)) {
+                        result = await this.destinationService.addDestination(new message_event_bus_destination_syslog_ee_1.MessageEventBusDestinationSyslog(this.eventBus, req.body));
+                    }
+                    break;
+                default:
+                    throw new bad_request_error_1.BadRequestError(`Body is missing ${req.body.__type} options or type ${req.body.__type} is unknown`);
+            }
+            if (result) {
+                return {
+                    ...result.serialize(),
+                    eventBusInstance: undefined,
+                };
+            }
+            throw new bad_request_error_1.BadRequestError('There was an error adding the destination');
+        }
+        throw new bad_request_error_1.BadRequestError('Body is not configuring MessageEventBusDestinationOptions');
+    }
+    async sendTestMessage(req) {
+        if (isWithIdString(req.query)) {
+            return await this.destinationService.testDestination(req.query.id);
+        }
+        return false;
+    }
+    async deleteDestination(req) {
+        if (isWithIdString(req.query)) {
+            await this.destinationService.removeDestination(req.query.id);
+        }
+        else {
+            throw new bad_request_error_1.BadRequestError('Query is missing id');
+        }
+    }
+};
+exports.EventBusController = EventBusController;
+__decorate([
+    (0, decorators_1.Get)('/eventnames'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EventBusController.prototype, "getEventNames", null);
+__decorate([
+    (0, decorators_1.Licensed)('feat:logStreaming'),
+    (0, decorators_1.Get)('/destination'),
+    (0, decorators_1.GlobalScope)('eventBusDestination:list'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EventBusController.prototype, "getDestination", null);
+__decorate([
+    (0, decorators_1.Licensed)('feat:logStreaming'),
+    (0, decorators_1.Post)('/destination'),
+    (0, decorators_1.GlobalScope)('eventBusDestination:create'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EventBusController.prototype, "postDestination", null);
+__decorate([
+    (0, decorators_1.Licensed)('feat:logStreaming'),
+    (0, decorators_1.Get)('/testmessage'),
+    (0, decorators_1.GlobalScope)('eventBusDestination:test'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EventBusController.prototype, "sendTestMessage", null);
+__decorate([
+    (0, decorators_1.Licensed)('feat:logStreaming'),
+    (0, decorators_1.Delete)('/destination'),
+    (0, decorators_1.GlobalScope)('eventBusDestination:delete'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EventBusController.prototype, "deleteDestination", null);
+exports.EventBusController = EventBusController = __decorate([
+    (0, decorators_1.RestController)('/eventbus'),
+    __metadata("design:paramtypes", [message_event_bus_1.MessageEventBus,
+        log_streaming_destination_service_1.LogStreamingDestinationService])
+], EventBusController);

package/dist/modules/log-streaming.ee/log-streaming.module.d.ts

@@ -0,0 +1,5 @@
+import type { ModuleInterface } from '@n8n/decorators';
+export declare class LogStreamingModule implements ModuleInterface {
+    init(): Promise<void>;
+    entities(): Promise<typeof import("./database/entities/event-destination.entity").EventDestinations[]>;
+}

package/dist/modules/log-streaming.ee/log-streaming.module.js

@@ -0,0 +1,66 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.LogStreamingModule = void 0;
+const constants_1 = require("@n8n/constants");
+const decorators_1 = require("@n8n/decorators");
+const di_1 = require("@n8n/di");
+let LogStreamingModule = class LogStreamingModule {
+    async init() {
+        await Promise.resolve().then(() => __importStar(require('./log-streaming.controller')));
+        const { LogStreamingDestinationService } = await Promise.resolve().then(() => __importStar(require('./log-streaming-destination.service')));
+        const destinationService = di_1.Container.get(LogStreamingDestinationService);
+        await destinationService.loadDestinationsFromDb();
+        await destinationService.initialize();
+    }
+    async entities() {
+        const { EventDestinations } = await Promise.resolve().then(() => __importStar(require('./database/entities/event-destination.entity')));
+        return [EventDestinations];
+    }
+};
+exports.LogStreamingModule = LogStreamingModule;
+exports.LogStreamingModule = LogStreamingModule = __decorate([
+    (0, decorators_1.BackendModule)({
+        name: 'log-streaming',
+        licenseFlag: constants_1.LICENSE_FEATURES.LOG_STREAMING,
+        instanceTypes: ['main', 'worker', 'webhook'],
+    })
+], LogStreamingModule);

package/dist/modules/mcp/tools/execute-workflow.tool.d.ts

@@ -12,11 +12,11 @@ declare const inputSchema: z.ZodObject<{
         type: z.ZodLiteral<"chat">;
         chatInput: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        type: "chat";
         chatInput: string;
-    }, {
         type: "chat";
+    }, {
         chatInput: string;
+        type: "chat";
     }>, z.ZodObject<{
         type: z.ZodLiteral<"form">;
         formData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -34,20 +34,20 @@ declare const inputSchema: z.ZodObject<{
             body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, "strip", z.ZodTypeAny, {
-            method: "GET" | "DELETE" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH";
+            method: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT";
             body?: Record<string, unknown> | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
         }, {
+            method?: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT" | undefined;
             body?: Record<string, unknown> | undefined;
-            method?: "GET" | "DELETE" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH" | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
         type: "webhook";
         webhookData: {
-            method: "GET" | "DELETE" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH";
+            method: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT";
             body?: Record<string, unknown> | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
@@ -55,8 +55,8 @@ declare const inputSchema: z.ZodObject<{
     }, {
         type: "webhook";
         webhookData: {
+            method?: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT" | undefined;
             body?: Record<string, unknown> | undefined;
-            method?: "GET" | "DELETE" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH" | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
         };
@@ -64,15 +64,15 @@ declare const inputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     workflowId: string;
     inputs?: {
-        type: "chat";
         chatInput: string;
+        type: "chat";
     } | {
         type: "form";
         formData: Record<string, unknown>;
     } | {
         type: "webhook";
         webhookData: {
-            method: "GET" | "DELETE" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH";
+            method: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT";
             body?: Record<string, unknown> | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
@@ -81,16 +81,16 @@ declare const inputSchema: z.ZodObject<{
 }, {
     workflowId: string;
     inputs?: {
-        type: "chat";
         chatInput: string;
+        type: "chat";
     } | {
         type: "form";
         formData: Record<string, unknown>;
     } | {
         type: "webhook";
         webhookData: {
+            method?: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT" | undefined;
             body?: Record<string, unknown> | undefined;
-            method?: "GET" | "DELETE" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH" | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
         };