From ff0955c995578abd4106274a9314a7a7a0e9a597 Mon Sep 17 00:00:00 2001
From: Alex Grozav <alex@grozav.com>
Date: Fri, 3 May 2024 10:26:15 +0300
Subject: [PATCH 1/7] refactor(editor): Migrate `pushConnection` mixin to
 composable and remove collaboration store side effects (no-changelog) (#9249)

---
 packages/editor-ui/src/Interface.ts           |  32 +-
 .../MainHeader/CollaborationPane.vue          |   2 +
 .../src/components/MainHeader/MainHeader.vue  |  22 +-
 .../src/components/WorkerList.ee.vue          |  56 +-
 .../src/composables/usePushConnection.spec.ts | 123 ++++
 .../src/composables/usePushConnection.ts      | 632 +++++++++++++++++
 .../editor-ui/src/mixins/pushConnection.ts    | 637 ------------------
 .../src/stores/collaboration.store.ts         |  43 +-
 .../src/stores/pushConnection.store.ts        |   1 +
 packages/editor-ui/src/types/index.ts         |   1 +
 .../editor-ui/src/types/pushConnection.ts     |   6 +
 packages/editor-ui/src/views/NodeView.vue     |   3 +
 .../src/views/SettingsCommunityNodesView.vue  |  21 +-
 13 files changed, 874 insertions(+), 705 deletions(-)
 create mode 100644 packages/editor-ui/src/composables/usePushConnection.spec.ts
 create mode 100644 packages/editor-ui/src/composables/usePushConnection.ts
 delete mode 100644 packages/editor-ui/src/mixins/pushConnection.ts
 create mode 100644 packages/editor-ui/src/types/pushConnection.ts

diff --git a/packages/editor-ui/src/Interface.ts b/packages/editor-ui/src/Interface.ts
index 1818b22776683..67a4053308199 100644
--- a/packages/editor-ui/src/Interface.ts
+++ b/packages/editor-ui/src/Interface.ts
@@ -447,6 +447,7 @@ export type IPushData =
 	| PushDataExecutionStarted
 	| PushDataExecuteAfter
 	| PushDataExecuteBefore
+	| PushDataNodeDescriptionUpdated
 	| PushDataConsoleMessage
 	| PushDataReloadNodeType
 	| PushDataRemoveNodeType
@@ -458,67 +459,72 @@ export type IPushData =
 	| PushDataWorkflowFailedToActivate
 	| PushDataWorkflowUsersChanged;
 
-type PushDataActiveWorkflowAdded = {
+export type PushDataActiveWorkflowAdded = {
 	data: IActiveWorkflowAdded;
 	type: 'workflowActivated';
 };
 
-type PushDataActiveWorkflowRemoved = {
+export type PushDataActiveWorkflowRemoved = {
 	data: IActiveWorkflowRemoved;
 	type: 'workflowDeactivated';
 };
 
-type PushDataWorkflowFailedToActivate = {
+export type PushDataWorkflowFailedToActivate = {
 	data: IWorkflowFailedToActivate;
 	type: 'workflowFailedToActivate';
 };
 
-type PushDataExecutionRecovered = {
+export type PushDataExecutionRecovered = {
 	data: IPushDataExecutionRecovered;
 	type: 'executionRecovered';
 };
 
-type PushDataExecutionFinished = {
+export type PushDataExecutionFinished = {
 	data: IPushDataExecutionFinished;
 	type: 'executionFinished';
 };
 
-type PushDataExecutionStarted = {
+export type PushDataExecutionStarted = {
 	data: IPushDataExecutionStarted;
 	type: 'executionStarted';
 };
 
-type PushDataExecuteAfter = {
+export type PushDataExecuteAfter = {
 	data: IPushDataNodeExecuteAfter;
 	type: 'nodeExecuteAfter';
 };
 
-type PushDataExecuteBefore = {
+export type PushDataExecuteBefore = {
 	data: IPushDataNodeExecuteBefore;
 	type: 'nodeExecuteBefore';
 };
 
-type PushDataConsoleMessage = {
+export type PushDataNodeDescriptionUpdated = {
+	data: {};
+	type: 'nodeDescriptionUpdated';
+};
+
+export type PushDataConsoleMessage = {
 	data: IPushDataConsoleMessage;
 	type: 'sendConsoleMessage';
 };
 
-type PushDataReloadNodeType = {
+export type PushDataReloadNodeType = {
 	data: IPushDataReloadNodeType;
 	type: 'reloadNodeType';
 };
 
-type PushDataRemoveNodeType = {
+export type PushDataRemoveNodeType = {
 	data: IPushDataRemoveNodeType;
 	type: 'removeNodeType';
 };
 
-type PushDataTestWebhook = {
+export type PushDataTestWebhook = {
 	data: IPushDataTestWebhook;
 	type: 'testWebhookDeleted' | 'testWebhookReceived';
 };
 
-type PushDataWorkerStatusMessage = {
+export type PushDataWorkerStatusMessage = {
 	data: IPushDataWorkerStatusMessage;
 	type: 'sendWorkerStatusMessage';
 };
diff --git a/packages/editor-ui/src/components/MainHeader/CollaborationPane.vue b/packages/editor-ui/src/components/MainHeader/CollaborationPane.vue
index 31d387b3dbe46..daabc0a1780bc 100644
--- a/packages/editor-ui/src/components/MainHeader/CollaborationPane.vue
+++ b/packages/editor-ui/src/components/MainHeader/CollaborationPane.vue
@@ -54,6 +54,7 @@ const onDocumentVisibilityChange = () => {
 };
 
 onMounted(() => {
+	collaborationStore.initialize();
 	startHeartbeat();
 	document.addEventListener('visibilitychange', onDocumentVisibilityChange);
 });
@@ -61,6 +62,7 @@ onMounted(() => {
 onBeforeUnmount(() => {
 	document.removeEventListener('visibilitychange', onDocumentVisibilityChange);
 	stopHeartbeat();
+	collaborationStore.terminate();
 });
 </script>
 
diff --git a/packages/editor-ui/src/components/MainHeader/MainHeader.vue b/packages/editor-ui/src/components/MainHeader/MainHeader.vue
index c0e70681402a7..ed7b43715e910 100644
--- a/packages/editor-ui/src/components/MainHeader/MainHeader.vue
+++ b/packages/editor-ui/src/components/MainHeader/MainHeader.vue
@@ -16,9 +16,9 @@
 
 <script lang="ts">
 import { defineComponent } from 'vue';
-import type { Route, RouteLocationRaw } from 'vue-router';
+import type { RouteLocation, RouteLocationRaw } from 'vue-router';
+import { useRouter } from 'vue-router';
 import { mapStores } from 'pinia';
-import { pushConnection } from '@/mixins/pushConnection';
 import WorkflowDetails from '@/components/MainHeader/WorkflowDetails.vue';
 import TabBar from '@/components/MainHeader/TabBar.vue';
 import {
@@ -33,6 +33,7 @@ import { useSourceControlStore } from '@/stores/sourceControl.store';
 import { useUIStore } from '@/stores/ui.store';
 import { useWorkflowsStore } from '@/stores/workflows.store';
 import { useExecutionsStore } from '@/stores/executions.store';
+import { usePushConnection } from '@/composables/usePushConnection';
 
 export default defineComponent({
 	name: 'MainHeader',
@@ -40,11 +41,12 @@ export default defineComponent({
 		WorkflowDetails,
 		TabBar,
 	},
-	mixins: [pushConnection],
-	setup(props, ctx) {
+	setup() {
+		const router = useRouter();
+		const pushConnection = usePushConnection({ router });
+
 		return {
-			// eslint-disable-next-line @typescript-eslint/no-misused-promises
-			...pushConnection.setup?.(props, ctx),
+			pushConnection,
 		};
 	},
 	data() {
@@ -99,12 +101,18 @@ export default defineComponent({
 			this.syncTabsWithRoute(to, from);
 		},
 	},
+	beforeMount() {
+		this.pushConnection.initialize();
+	},
 	mounted() {
 		this.dirtyState = this.uiStore.stateIsDirty;
 		this.syncTabsWithRoute(this.$route);
 	},
+	beforeUnmount() {
+		this.pushConnection.terminate();
+	},
 	methods: {
-		syncTabsWithRoute(to: Route, from?: Route): void {
+		syncTabsWithRoute(to: RouteLocation, from?: RouteLocation): void {
 			if (
 				to.name === VIEWS.EXECUTION_HOME ||
 				to.name === VIEWS.WORKFLOW_EXECUTIONS ||
diff --git a/packages/editor-ui/src/components/WorkerList.ee.vue b/packages/editor-ui/src/components/WorkerList.ee.vue
index 2c47f5ed63148..b336d3f2bb4d8 100644
--- a/packages/editor-ui/src/components/WorkerList.ee.vue
+++ b/packages/editor-ui/src/components/WorkerList.ee.vue
@@ -29,30 +29,53 @@ import type { ExecutionStatus } from 'n8n-workflow';
 import { useUIStore } from '@/stores/ui.store';
 import { useOrchestrationStore } from '@/stores/orchestration.store';
 import { setPageTitle } from '@/utils/htmlUtils';
-import { pushConnection } from '@/mixins/pushConnection';
 import WorkerCard from './Workers/WorkerCard.ee.vue';
+import { usePushConnection } from '@/composables/usePushConnection';
+import { useRouter } from 'vue-router';
+import { usePushConnectionStore } from '@/stores/pushConnection.store';
+import { useRootStore } from '@/stores/n8nRoot.store';
 
 // eslint-disable-next-line import/no-default-export
 export default defineComponent({
 	name: 'WorkerList',
 	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/naming-convention
 	components: { PushConnectionTracker, WorkerCard },
-	mixins: [pushConnection],
 	props: {
 		autoRefreshEnabled: {
 			type: Boolean,
 			default: true,
 		},
 	},
-	setup(props, ctx) {
+	setup() {
+		const router = useRouter();
 		const i18n = useI18n();
+		const pushConnection = usePushConnection({ router });
+
 		return {
 			i18n,
+			pushConnection,
 			...useToast(),
-			// eslint-disable-next-line @typescript-eslint/no-misused-promises
-			...pushConnection.setup?.(props, ctx),
 		};
 	},
+	computed: {
+		...mapStores(useRootStore, useUIStore, usePushConnectionStore, useOrchestrationStore),
+		combinedWorkers(): IPushDataWorkerStatusPayload[] {
+			const returnData: IPushDataWorkerStatusPayload[] = [];
+			for (const workerId in this.orchestrationManagerStore.workers) {
+				returnData.push(this.orchestrationManagerStore.workers[workerId]);
+			}
+			return returnData;
+		},
+		initialStatusReceived(): boolean {
+			return this.orchestrationManagerStore.initialStatusReceived;
+		},
+		workerIds(): string[] {
+			return Object.keys(this.orchestrationManagerStore.workers);
+		},
+		pageTitle() {
+			return this.i18n.baseText('workerList.pageTitle');
+		},
+	},
 	mounted() {
 		setPageTitle(`n8n - ${this.pageTitle}`);
 
@@ -64,6 +87,8 @@ export default defineComponent({
 		if (window.Cypress !== undefined) {
 			return;
 		}
+
+		this.pushConnection.initialize();
 		this.pushStore.pushConnect();
 		this.orchestrationManagerStore.startWorkerStatusPolling();
 	},
@@ -71,27 +96,10 @@ export default defineComponent({
 		if (window.Cypress !== undefined) {
 			return;
 		}
+
 		this.orchestrationManagerStore.stopWorkerStatusPolling();
 		this.pushStore.pushDisconnect();
-	},
-	computed: {
-		...mapStores(useUIStore, useOrchestrationStore),
-		combinedWorkers(): IPushDataWorkerStatusPayload[] {
-			const returnData: IPushDataWorkerStatusPayload[] = [];
-			for (const workerId in this.orchestrationManagerStore.workers) {
-				returnData.push(this.orchestrationManagerStore.workers[workerId]);
-			}
-			return returnData;
-		},
-		initialStatusReceived(): boolean {
-			return this.orchestrationManagerStore.initialStatusReceived;
-		},
-		workerIds(): string[] {
-			return Object.keys(this.orchestrationManagerStore.workers);
-		},
-		pageTitle() {
-			return this.i18n.baseText('workerList.pageTitle');
-		},
+		this.pushConnection.terminate();
 	},
 	methods: {
 		averageLoadAvg(loads: number[]) {
diff --git a/packages/editor-ui/src/composables/usePushConnection.spec.ts b/packages/editor-ui/src/composables/usePushConnection.spec.ts
new file mode 100644
index 0000000000000..595f0dfa22e73
--- /dev/null
+++ b/packages/editor-ui/src/composables/usePushConnection.spec.ts
@@ -0,0 +1,123 @@
+import { usePushConnection } from '@/composables/usePushConnection';
+import { useRouter } from 'vue-router';
+import { createPinia, setActivePinia } from 'pinia';
+import { usePushConnectionStore } from '@/stores/pushConnection.store';
+import { useCollaborationStore } from '@/stores/collaboration.store';
+import type { IPushData, PushDataWorkerStatusMessage } from '@/Interface';
+import { useOrchestrationStore } from '@/stores/orchestration.store';
+
+vi.mock('vue-router', () => {
+	return {
+		RouterLink: vi.fn(),
+		useRouter: () => ({
+			push: vi.fn(),
+		}),
+	};
+});
+
+vi.useFakeTimers();
+
+describe('usePushConnection()', () => {
+	let router: ReturnType<typeof useRouter>;
+	let pushStore: ReturnType<typeof usePushConnectionStore>;
+	let collaborationStore: ReturnType<typeof useCollaborationStore>;
+	let orchestrationStore: ReturnType<typeof useOrchestrationStore>;
+	let pushConnection: ReturnType<typeof usePushConnection>;
+
+	beforeEach(() => {
+		setActivePinia(createPinia());
+
+		router = vi.mocked(useRouter)();
+		pushStore = usePushConnectionStore();
+		collaborationStore = useCollaborationStore();
+		orchestrationStore = useOrchestrationStore();
+		pushConnection = usePushConnection({ router });
+	});
+
+	describe('initialize()', () => {
+		it('should add event listener to the pushStore', () => {
+			const spy = vi.spyOn(pushStore, 'addEventListener').mockImplementation(() => () => {});
+
+			pushConnection.initialize();
+
+			expect(spy).toHaveBeenCalled();
+		});
+
+		it('should initialize collaborationStore', () => {
+			const spy = vi.spyOn(collaborationStore, 'initialize').mockImplementation(() => {});
+			pushConnection.initialize();
+			expect(spy).toHaveBeenCalled();
+		});
+	});
+
+	describe('terminate()', () => {
+		it('should remove event listener from the pushStore', () => {
+			const returnFn = vi.fn();
+			vi.spyOn(pushStore, 'addEventListener').mockImplementation(() => returnFn);
+
+			pushConnection.initialize();
+			pushConnection.terminate();
+
+			expect(returnFn).toHaveBeenCalled();
+		});
+
+		it('should terminate collaborationStore', () => {
+			const spy = vi.spyOn(collaborationStore, 'terminate').mockImplementation(() => {});
+			pushConnection.terminate();
+			expect(spy).toHaveBeenCalled();
+		});
+	});
+
+	describe('queuePushMessage()', () => {
+		it('should add message to the queue and sets timeout if not already set', () => {
+			const event: IPushData = {
+				type: 'sendWorkerStatusMessage',
+				data: {
+					workerId: '1',
+					status: {},
+				},
+			} as PushDataWorkerStatusMessage;
+
+			pushConnection.queuePushMessage(event, 5);
+
+			expect(pushConnection.pushMessageQueue.value).toHaveLength(1);
+			expect(pushConnection.pushMessageQueue.value[0]).toEqual({ message: event, retriesLeft: 5 });
+			expect(pushConnection.retryTimeout.value).not.toBeNull();
+		});
+	});
+
+	describe('processWaitingPushMessages()', () => {
+		it('should clear the queue and reset the timeout', async () => {
+			const event: IPushData = { type: 'executionRecovered', data: { executionId: '1' } };
+
+			pushConnection.queuePushMessage(event, 0);
+			expect(pushConnection.pushMessageQueue.value).toHaveLength(1);
+			expect(pushConnection.retryTimeout.value).toBeDefined();
+
+			await pushConnection.processWaitingPushMessages();
+
+			expect(pushConnection.pushMessageQueue.value).toHaveLength(0);
+			expect(pushConnection.retryTimeout.value).toBeNull();
+		});
+	});
+
+	describe('pushMessageReceived()', () => {
+		describe('sendWorkerStatusMessage', () => {
+			it('should handle event type correctly', async () => {
+				const spy = vi.spyOn(orchestrationStore, 'updateWorkerStatus').mockImplementation(() => {});
+				const event: IPushData = {
+					type: 'sendWorkerStatusMessage',
+					data: {
+						workerId: '1',
+						status: {},
+					},
+				} as PushDataWorkerStatusMessage;
+
+				const result = await pushConnection.pushMessageReceived(event);
+
+				expect(spy).toHaveBeenCalledWith(event.data.status);
+				expect(result).toBeTruthy();
+			});
+		});
+	});
+});
diff --git a/packages/editor-ui/src/composables/usePushConnection.ts b/packages/editor-ui/src/composables/usePushConnection.ts
new file mode 100644
index 0000000000000..4762b8aba9975
--- /dev/null
+++ b/packages/editor-ui/src/composables/usePushConnection.ts
@@ -0,0 +1,632 @@
+import type {
+	IExecutionResponse,
+	IExecutionsCurrentSummaryExtended,
+	IPushData,
+	IPushDataExecutionFinished,
+} from '@/Interface';
+
+import { useNodeHelpers } from '@/composables/useNodeHelpers';
+import { useTitleChange } from '@/composables/useTitleChange';
+import { useToast } from '@/composables/useToast';
+
+import type {
+	ExpressionError,
+	IDataObject,
+	INodeTypeNameVersion,
+	IRun,
+	IRunExecutionData,
+	IWorkflowBase,
+	SubworkflowOperationError,
+	IExecuteContextData,
+	NodeOperationError,
+	INodeTypeDescription,
+} from 'n8n-workflow';
+import { TelemetryHelpers } from 'n8n-workflow';
+
+import { WORKFLOW_SETTINGS_MODAL_KEY } from '@/constants';
+import { getTriggerNodeServiceName } from '@/utils/nodeTypesUtils';
+import { codeNodeEditorEventBus, globalLinkActionsEventBus } from '@/event-bus';
+import { useUIStore } from '@/stores/ui.store';
+import { useWorkflowsStore } from '@/stores/workflows.store';
+import { useNodeTypesStore } from '@/stores/nodeTypes.store';
+import { useCredentialsStore } from '@/stores/credentials.store';
+import { useSettingsStore } from '@/stores/settings.store';
+import { parse } from 'flatted';
+import { useSegment } from '@/stores/segment.store';
+import { ref } from 'vue';
+import { useOrchestrationStore } from '@/stores/orchestration.store';
+import { usePushConnectionStore } from '@/stores/pushConnection.store';
+import { useCollaborationStore } from '@/stores/collaboration.store';
+import { useExternalHooks } from '@/composables/useExternalHooks';
+import type { useRouter } from 'vue-router';
+import { useWorkflowHelpers } from '@/composables/useWorkflowHelpers';
+import { useI18n } from '@/composables/useI18n';
+import { useTelemetry } from '@/composables/useTelemetry';
+import type { PushMessageQueueItem } from '@/types';
+
+export function usePushConnection({ router }: { router: ReturnType<typeof useRouter> }) {
+	const workflowHelpers = useWorkflowHelpers({ router });
+	const nodeHelpers = useNodeHelpers();
+	const titleChange = useTitleChange();
+	const toast = useToast();
+	const i18n = useI18n();
+	const telemetry = useTelemetry();
+
+	const collaborationStore = useCollaborationStore();
+	const credentialsStore = useCredentialsStore();
+	const nodeTypesStore = useNodeTypesStore();
+	const orchestrationManagerStore = useOrchestrationStore();
+	const pushStore = usePushConnectionStore();
+	const settingsStore = useSettingsStore();
+	const segmentStore = useSegment();
+	const uiStore = useUIStore();
+	const workflowsStore = useWorkflowsStore();
+
+	const retryTimeout = ref<NodeJS.Timeout | null>(null);
+	const pushMessageQueue = ref<PushMessageQueueItem[]>([]);
+	const removeEventListener = ref<(() => void) | null>(null);
+
+	function initialize() {
+		removeEventListener.value = pushStore.addEventListener((message) => {
+			void pushMessageReceived(message);
+		});
+		collaborationStore.initialize();
+	}
+
+	function terminate() {
+		collaborationStore.terminate();
+		if (typeof removeEventListener.value === 'function') {
+			removeEventListener.value();
+		}
+	}
+
+	/**
+	 * Sometimes the push message is faster as the result from
+	 * the REST API so we do not know yet what execution ID
+	 * is currently active. So internally resend the message
+	 * a few more times
+	 */
+	function queuePushMessage(event: IPushData, retryAttempts: number) {
+		pushMessageQueue.value.push({ message: event, retriesLeft: retryAttempts });
+
+		if (retryTimeout.value === null) {
+			retryTimeout.value = setTimeout(processWaitingPushMessages, 20);
+		}
+	}
+
+	/**
+	 * Process the push messages which are waiting in the queue
+	 */
+	async function processWaitingPushMessages() {
+		if (retryTimeout.value !== null) {
+			clearTimeout(retryTimeout.value);
+			retryTimeout.value = null;
+		}
+
+		const queueLength = pushMessageQueue.value.length;
+		for (let i = 0; i < queueLength; i++) {
+			const messageData = pushMessageQueue.value.shift() as PushMessageQueueItem;
+
+			const result = await pushMessageReceived(messageData.message, true);
+			if (!result) {
+				// Was not successful
+				messageData.retriesLeft -= 1;
+
+				if (messageData.retriesLeft > 0) {
+					// If still retries are left add it back and stop execution
+					pushMessageQueue.value.unshift(messageData);
+				}
+				break;
+			}
+		}
+
+		if (pushMessageQueue.value.length !== 0 && retryTimeout.value === null) {
+			retryTimeout.value = setTimeout(processWaitingPushMessages, 25);
+		}
+	}
+
+	/**
+	 * Process a newly received message
+	 */
+	async function pushMessageReceived(receivedData: IPushData, isRetry?: boolean): Promise<boolean> {
+		const retryAttempts = 5;
+
+		if (receivedData.type === 'sendWorkerStatusMessage') {
+			const pushData = receivedData.data;
+			orchestrationManagerStore.updateWorkerStatus(pushData.status);
+			return true;
+		}
+
+		if (receivedData.type === 'sendConsoleMessage') {
+			const pushData = receivedData.data;
+			console.log(pushData.source, ...pushData.messages);
+			return true;
+		}
+
+		if (
+			!['testWebhookReceived'].includes(receivedData.type) &&
+			isRetry !== true &&
+			pushMessageQueue.value.length
+		) {
+			// If there are already messages in the queue add the new one that all of them
+			// get executed in order
+			queuePushMessage(receivedData, retryAttempts);
+			return false;
+		}
+
+		if (receivedData.type === 'nodeExecuteAfter' || receivedData.type === 'nodeExecuteBefore') {
+			if (!uiStore.isActionActive('workflowRunning')) {
+				// No workflow is running so ignore the messages
+				return false;
+			}
+			const pushData = receivedData.data;
+			if (workflowsStore.activeExecutionId !== pushData.executionId) {
+				// The data is not for the currently active execution or
+				// we do not have the execution id yet.
+				if (isRetry !== true) {
+					queuePushMessage(event as unknown as IPushData, retryAttempts);
+				}
+				return false;
+			}
+		}
+
+		// recovered execution data is handled like executionFinished data, however for security reasons
+		// we need to fetch the data from the server again rather than push it to all clients
+		let recoveredPushData: IPushDataExecutionFinished | undefined = undefined;
+		if (receivedData.type === 'executionRecovered') {
+			const recoveredExecutionId = receivedData.data?.executionId;
+			const isWorkflowRunning = uiStore.isActionActive('workflowRunning');
+			if (isWorkflowRunning && workflowsStore.activeExecutionId === recoveredExecutionId) {
+				// pull execution data for the recovered execution from the server
+				const executionData = await workflowsStore.fetchExecutionDataById(
+					workflowsStore.activeExecutionId,
+				);
+				if (executionData?.data) {
+					// data comes in as 'flatten' object, so we need to parse it
+					executionData.data = parse(executionData.data as unknown as string) as IRunExecutionData;
+					const iRunExecutionData: IRunExecutionData = {
+						startData: executionData.data?.startData,
+						resultData: executionData.data?.resultData ?? { runData: {} },
+						executionData: executionData.data?.executionData,
+					};
+					if (workflowsStore.workflowExecutionData?.workflowId === executionData.workflowId) {
+						const activeRunData = workflowsStore.workflowExecutionData?.data?.resultData?.runData;
+						if (activeRunData) {
+							for (const key of Object.keys(activeRunData)) {
+								iRunExecutionData.resultData.runData[key] = activeRunData[key];
+							}
+						}
+					}
+					const iRun: IRun = {
+						data: iRunExecutionData,
+						finished: executionData.finished,
+						mode: executionData.mode,
+						waitTill: executionData.data?.waitTill,
+						startedAt: executionData.startedAt,
+						stoppedAt: executionData.stoppedAt,
+						status: 'crashed',
+					};
+					if (executionData.data) {
+						recoveredPushData = {
+							executionId: executionData.id,
+							data: iRun,
+						};
+					}
+				}
+			}
+		}
+
+		if (
+			receivedData.type === 'workflowFailedToActivate' &&
+			workflowsStore.workflowId === receivedData.data.workflowId
+		) {
+			workflowsStore.setWorkflowInactive(receivedData.data.workflowId);
+			workflowsStore.setActive(false);
+
+			toast.showError(
+				new Error(receivedData.data.errorMessage),
+				i18n.baseText('workflowActivator.showError.title', {
+					interpolate: { newStateName: 'activated' },
+				}) + ':',
+			);
+
+			return true;
+		}
+
+		if (receivedData.type === 'workflowActivated') {
+			workflowsStore.setWorkflowActive(receivedData.data.workflowId);
+			return true;
+		}
+
+		if (receivedData.type === 'workflowDeactivated') {
+			workflowsStore.setWorkflowInactive(receivedData.data.workflowId);
+			return true;
+		}
+
+		if (receivedData.type === 'executionFinished' || receivedData.type === 'executionRecovered') {
+			// The workflow finished executing
+			let pushData: IPushDataExecutionFinished;
+			if (receivedData.type === 'executionRecovered' && recoveredPushData !== undefined) {
+				pushData = recoveredPushData;
+			} else {
+				pushData = receivedData.data as IPushDataExecutionFinished;
+			}
+
+			const { activeExecutionId } = workflowsStore;
+			if (activeExecutionId === pushData.executionId) {
+				const activeRunData = workflowsStore.workflowExecutionData?.data?.resultData?.runData;
+				if (activeRunData) {
+					for (const key of Object.keys(activeRunData)) {
+						if (
+							pushData.data.data.resultData.runData[key]?.[0]?.data?.main?.[0]?.[0]?.json
+								?.isArtificialRecoveredEventItem === true &&
+							activeRunData[key].length > 0
+						)
+							pushData.data.data.resultData.runData[key] = activeRunData[key];
+					}
+				}
+				workflowsStore.finishActiveExecution(pushData);
+			}
+
+			if (!uiStore.isActionActive('workflowRunning')) {
+				// No workflow is running so ignore the messages
+				return false;
+			}
+
+			if (activeExecutionId !== pushData.executionId) {
+				// The workflow which did finish execution did either not get started
+				// by this session or we do not have the execution id yet.
+				if (isRetry !== true) {
+					queuePushMessage(event as unknown as IPushData, retryAttempts);
+				}
+				return false;
+			}
+
+			const runDataExecuted = pushData.data;
+
+			let runDataExecutedErrorMessage = getExecutionError(runDataExecuted.data);
+
+			if (runDataExecuted.status === 'crashed') {
+				runDataExecutedErrorMessage = i18n.baseText('pushConnection.executionFailed.message');
+			} else if (runDataExecuted.status === 'canceled') {
+				runDataExecutedErrorMessage = i18n.baseText(
+					'executionsList.showMessage.stopExecution.message',
+					{
+						interpolate: { activeExecutionId },
+					},
+				);
+			}
+
+			const lineNumber = runDataExecuted?.data?.resultData?.error?.lineNumber;
+
+			codeNodeEditorEventBus.emit('error-line-number', lineNumber || 'final');
+
+			const workflow = workflowHelpers.getCurrentWorkflow();
+			if (runDataExecuted.waitTill !== undefined) {
+				const workflowSettings = workflowsStore.workflowSettings;
+				const saveManualExecutions = settingsStore.saveManualExecutions;
+
+				const isSavingExecutions =
+					workflowSettings.saveManualExecutions === undefined
+						? saveManualExecutions
+						: workflowSettings.saveManualExecutions;
+
+				let action;
+				if (!isSavingExecutions) {
+					globalLinkActionsEventBus.emit('registerGlobalLinkAction', {
+						key: 'open-settings',
+						action: async () => {
+							if (workflowsStore.isNewWorkflow) await workflowHelpers.saveAsNewWorkflow();
+							uiStore.openModal(WORKFLOW_SETTINGS_MODAL_KEY);
+						},
+					});
+
+					action =
+						'<a data-action="open-settings">Turn on saving manual executions</a> and run again to see what happened after this node.';
+				} else {
+					action = `<a href="/workflow/${workflow.id}/executions/${activeExecutionId}">View the execution</a> to see what happened after this node.`;
+				}
+
+				// Workflow did start but had been put to wait
+				titleChange.titleSet(workflow.name as string, 'IDLE');
+				toast.showToast({
+					title: 'Workflow started waiting',
+					message: `${action} <a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/" target="_blank">More info</a>`,
+					type: 'success',
+					duration: 0,
+				});
+			} else if (runDataExecuted.finished !== true) {
+				titleChange.titleSet(workflow.name as string, 'ERROR');
+
+				if (
+					runDataExecuted.data.resultData.error?.name === 'ExpressionError' &&
+					(runDataExecuted.data.resultData.error as ExpressionError).context.functionality ===
+						'pairedItem'
+				) {
+					const error = runDataExecuted.data.resultData.error as ExpressionError;
+
+					void workflowHelpers.getWorkflowDataToSave().then((workflowData) => {
+						const eventData: IDataObject = {
+							caused_by_credential: false,
+							error_message: error.description,
+							error_title: error.message,
+							error_type: error.context.type,
+							node_graph_string: JSON.stringify(
+								TelemetryHelpers.generateNodesGraph(
+									workflowData as IWorkflowBase,
+									workflowHelpers.getNodeTypes(),
+								).nodeGraph,
+							),
+							workflow_id: workflowsStore.workflowId,
+						};
+
+						if (
+							error.context.nodeCause &&
+							['paired_item_no_info', 'paired_item_invalid_info'].includes(
+								error.context.type as string,
+							)
+						) {
+							const node = workflow.getNode(error.context.nodeCause as string);
+
+							if (node) {
+								eventData.is_pinned = !!workflow.getPinDataOfNode(node.name);
+								eventData.mode = node.parameters.mode;
+								eventData.node_type = node.type;
+								eventData.operation = node.parameters.operation;
+								eventData.resource = node.parameters.resource;
+							}
+						}
+
+						telemetry.track('Instance FE emitted paired item error', eventData, {
+							withPostHog: true,
+						});
+					});
+				}
+
+				if (runDataExecuted.data.resultData.error?.name === 'SubworkflowOperationError') {
+					const error = runDataExecuted.data.resultData.error as SubworkflowOperationError;
+
+					workflowsStore.subWorkflowExecutionError = error;
+
+					toast.showMessage({
+						title: error.message,
+						message: error.description,
+						type: 'error',
+						duration: 0,
+					});
+				} else if (
+					runDataExecuted.data.resultData.error?.name === 'NodeOperationError' &&
+					(runDataExecuted.data.resultData.error as NodeOperationError).functionality ===
+						'configuration-node'
+				) {
+					// If the error is a configuration error of the node itself doesn't get executed so we can't use lastNodeExecuted for the title
+					let title: string;
+					const nodeError = runDataExecuted.data.resultData.error as NodeOperationError;
+					if (nodeError.node.name) {
+						title = `Error in sub-node ‘${nodeError.node.name}‘`;
+					} else {
+						title = 'Problem executing workflow';
+					}
+
+					toast.showMessage({
+						title,
+						message:
+							(nodeError?.description ?? runDataExecutedErrorMessage) +
+							i18n.baseText('pushConnection.executionError.openNode', {
+								interpolate: {
+									node: nodeError.node.name,
+								},
+							}),
+						type: 'error',
+						duration: 0,
+						dangerouslyUseHTMLString: true,
+					});
+				} else {
+					let title: string;
+					const isManualExecutionCancelled =
+						runDataExecuted.mode === 'manual' && runDataExecuted.status === 'canceled';
+
+					// Do not show the error message if the workflow got canceled manually
+					if (isManualExecutionCancelled) {
+						toast.showMessage({
+							title: i18n.baseText('nodeView.showMessage.stopExecutionTry.title'),
+							type: 'success',
+						});
+					} else {
+						if (runDataExecuted.data.resultData.lastNodeExecuted) {
+							title = `Problem in node ‘${runDataExecuted.data.resultData.lastNodeExecuted}‘`;
+						} else {
+							title = 'Problem executing workflow';
+						}
+
+						toast.showMessage({
+							title,
+							message: runDataExecutedErrorMessage,
+							type: 'error',
+							duration: 0,
+							dangerouslyUseHTMLString: true,
+						});
+					}
+				}
+			} else {
+				// Workflow did execute without a problem
+				titleChange.titleSet(workflow.name as string, 'IDLE');
+
+				const execution = workflowsStore.getWorkflowExecution;
+				if (execution?.executedNode) {
+					const node = workflowsStore.getNodeByName(execution.executedNode);
+					const nodeType = node && nodeTypesStore.getNodeType(node.type, node.typeVersion);
+					const nodeOutput =
+						execution &&
+						execution.executedNode &&
+						execution.data?.resultData?.runData?.[execution.executedNode];
+					if (nodeType?.polling && !nodeOutput) {
+						toast.showMessage({
+							title: i18n.baseText('pushConnection.pollingNode.dataNotFound', {
+								interpolate: {
+									service: getTriggerNodeServiceName(nodeType),
+								},
+							}),
+							message: i18n.baseText('pushConnection.pollingNode.dataNotFound.message', {
+								interpolate: {
+									service: getTriggerNodeServiceName(nodeType),
+								},
+							}),
+							type: 'success',
+						});
+					} else {
+						toast.showMessage({
+							title: i18n.baseText('pushConnection.nodeExecutedSuccessfully'),
+							type: 'success',
+						});
+					}
+				} else {
+					toast.showMessage({
+						title: i18n.baseText('pushConnection.workflowExecutedSuccessfully'),
+						type: 'success',
+					});
+				}
+			}
+
+			// It does not push the runData as it got already pushed with each
+			// node that did finish. For that reason copy in here the data
+			// which we already have.
+			if (workflowsStore.getWorkflowRunData) {
+				runDataExecuted.data.resultData.runData = workflowsStore.getWorkflowRunData;
+			}
+
+			workflowsStore.executingNode.length = 0;
+			workflowsStore.setWorkflowExecutionData(runDataExecuted as IExecutionResponse);
+			uiStore.removeActiveAction('workflowRunning');
+
+			// Set the node execution issues on all the nodes which produced an error so that
+			// it can be displayed in the node-view
+			nodeHelpers.updateNodesExecutionIssues();
+
+			const lastNodeExecuted: string | undefined = runDataExecuted.data.resultData.lastNodeExecuted;
+			let itemsCount = 0;
+			if (
+				lastNodeExecuted &&
+				runDataExecuted.data.resultData.runData[lastNodeExecuted] &&
+				!runDataExecutedErrorMessage
+			) {
+				itemsCount =
+					runDataExecuted.data.resultData.runData[lastNodeExecuted][0].data!.main[0]!.length;
+			}
+
+			void useExternalHooks().run('pushConnection.executionFinished', {
+				itemsCount,
+				nodeName: runDataExecuted.data.resultData.lastNodeExecuted,
+				errorMessage: runDataExecutedErrorMessage,
+				runDataExecutedStartData: runDataExecuted.data.startData,
+				resultDataError: runDataExecuted.data.resultData.error,
+			});
+			if (!runDataExecuted.data.resultData.error) {
+				segmentStore.trackSuccessfulWorkflowExecution(runDataExecuted);
+			}
+		} else if (receivedData.type === 'executionStarted') {
+			const pushData = receivedData.data;
+
+			const executionData: IExecutionsCurrentSummaryExtended = {
+				id: pushData.executionId,
+				finished: false,
+				mode: pushData.mode,
+				startedAt: pushData.startedAt,
+				retryOf: pushData.retryOf,
+				workflowId: pushData.workflowId,
+				workflowName: pushData.workflowName,
+			};
+
+			workflowsStore.addActiveExecution(executionData);
+		} else if (receivedData.type === 'nodeExecuteAfter') {
+			// A node finished to execute. Add its data
+			const pushData = receivedData.data;
+			workflowsStore.addNodeExecutionData(pushData);
+			workflowsStore.removeExecutingNode(pushData.nodeName);
+		} else if (receivedData.type === 'nodeExecuteBefore') {
+			// A node started to be executed. Set it as executing.
+			const pushData = receivedData.data;
+			workflowsStore.addExecutingNode(pushData.nodeName);
+		} else if (receivedData.type === 'testWebhookDeleted') {
+			// A test-webhook was deleted
+			const pushData = receivedData.data;
+
+			if (pushData.workflowId === workflowsStore.workflowId) {
+				workflowsStore.executionWaitingForWebhook = false;
+				uiStore.removeActiveAction('workflowRunning');
+			}
+		} else if (receivedData.type === 'testWebhookReceived') {
+			// A test-webhook did get called
+			const pushData = receivedData.data;
+
+			if (pushData.workflowId === workflowsStore.workflowId) {
+				workflowsStore.executionWaitingForWebhook = false;
+				workflowsStore.activeExecutionId = pushData.executionId;
+			}
+
+			void processWaitingPushMessages();
+		} else if (receivedData.type === 'reloadNodeType') {
+			await nodeTypesStore.getNodeTypes();
+			await nodeTypesStore.getFullNodesProperties([receivedData.data]);
+		} else if (receivedData.type === 'removeNodeType') {
+			const pushData = receivedData.data;
+
+			const nodesToBeRemoved: INodeTypeNameVersion[] = [pushData];
+
+			// Force reload of all credential types
+			await credentialsStore.fetchCredentialTypes(false).then(() => {
+				nodeTypesStore.removeNodeTypes(nodesToBeRemoved as INodeTypeDescription[]);
+			});
+		} else if (receivedData.type === 'nodeDescriptionUpdated') {
+			await nodeTypesStore.getNodeTypes();
+			await credentialsStore.fetchCredentialTypes(true);
+		}
+
+		return true;
+	}
+
+	function getExecutionError(data: IRunExecutionData | IExecuteContextData) {
+		const error = data.resultData.error;
+
+		let errorMessage: string;
+
+		if (data.resultData.lastNodeExecuted && error) {
+			errorMessage = error.message || error.description;
+		} else {
+			errorMessage = i18n.baseText('pushConnection.executionError', {
+				interpolate: { error: '!' },
+			});
+
+			if (error?.message) {
+				let nodeName: string | undefined;
+				if ('node' in error) {
+					nodeName = typeof error.node === 'string' ? error.node : error.node!.name;
+				}
+
+				const receivedError = nodeName ? `${nodeName}: ${error.message}` : error.message;
+				errorMessage = i18n.baseText('pushConnection.executionError', {
+					interpolate: {
+						error: `.${i18n.baseText('pushConnection.executionError.details', {
+							interpolate: {
+								details: receivedError,
+							},
+						})}`,
+					},
+				});
+			}
+		}
+
+		return errorMessage;
+	}
+
+	return {
+		initialize,
+		terminate,
+		pushMessageReceived,
+		queuePushMessage,
+		processWaitingPushMessages,
+		pushMessageQueue,
+		removeEventListener,
+		retryTimeout,
+	};
+}
diff --git a/packages/editor-ui/src/mixins/pushConnection.ts b/packages/editor-ui/src/mixins/pushConnection.ts
deleted file mode 100644
index f92dfc10fafad..0000000000000
--- a/packages/editor-ui/src/mixins/pushConnection.ts
+++ /dev/null
@@ -1,637 +0,0 @@
-import type {
-	IExecutionResponse,
-	IExecutionsCurrentSummaryExtended,
-	IPushData,
-	IPushDataExecutionFinished,
-} from '@/Interface';
-
-import { useNodeHelpers } from '@/composables/useNodeHelpers';
-import { useTitleChange } from '@/composables/useTitleChange';
-import { useToast } from '@/composables/useToast';
-
-import type {
-	ExpressionError,
-	IDataObject,
-	INodeTypeNameVersion,
-	IRun,
-	IRunExecutionData,
-	IWorkflowBase,
-	SubworkflowOperationError,
-	IExecuteContextData,
-	NodeOperationError,
-} from 'n8n-workflow';
-import { TelemetryHelpers } from 'n8n-workflow';
-
-import { WORKFLOW_SETTINGS_MODAL_KEY } from '@/constants';
-import { getTriggerNodeServiceName } from '@/utils/nodeTypesUtils';
-import { codeNodeEditorEventBus, globalLinkActionsEventBus } from '@/event-bus';
-import { mapStores } from 'pinia';
-import { useUIStore } from '@/stores/ui.store';
-import { useWorkflowsStore } from '@/stores/workflows.store';
-import { useNodeTypesStore } from '@/stores/nodeTypes.store';
-import { useCredentialsStore } from '@/stores/credentials.store';
-import { useSettingsStore } from '@/stores/settings.store';
-import { parse } from 'flatted';
-import { useSegment } from '@/stores/segment.store';
-import { defineComponent } from 'vue';
-import { useOrchestrationStore } from '@/stores/orchestration.store';
-import { usePushConnectionStore } from '@/stores/pushConnection.store';
-import { useCollaborationStore } from '@/stores/collaboration.store';
-import { useExternalHooks } from '@/composables/useExternalHooks';
-import { useRouter } from 'vue-router';
-import { useWorkflowHelpers } from '@/composables/useWorkflowHelpers';
-
-export const pushConnection = defineComponent({
-	setup() {
-		const router = useRouter();
-		const workflowHelpers = useWorkflowHelpers({ router });
-		const nodeHelpers = useNodeHelpers();
-		return {
-			...useTitleChange(),
-			...useToast(),
-			nodeHelpers,
-			workflowHelpers,
-		};
-	},
-	data() {
-		return {
-			retryTimeout: null as NodeJS.Timeout | null,
-			pushMessageQueue: [] as Array<{ message: IPushData; retriesLeft: number }>,
-			removeEventListener: null as (() => void) | null,
-		};
-	},
-	created() {
-		this.removeEventListener = this.pushStore.addEventListener((message) => {
-			void this.pushMessageReceived(message);
-		});
-	},
-	unmounted() {
-		if (typeof this.removeEventListener === 'function') {
-			this.removeEventListener();
-		}
-	},
-	computed: {
-		...mapStores(
-			useCredentialsStore,
-			useNodeTypesStore,
-			useUIStore,
-			useWorkflowsStore,
-			useSettingsStore,
-			useSegment,
-			useOrchestrationStore,
-			usePushConnectionStore,
-			useCollaborationStore,
-		),
-		pushRef(): string {
-			return this.rootStore.pushRef;
-		},
-	},
-	methods: {
-		/**
-		 * Sometimes the push message is faster as the result from
-		 * the REST API so we do not know yet what execution ID
-		 * is currently active. So internally resend the message
-		 * a few more times
-		 */
-		queuePushMessage(event: IPushData, retryAttempts: number) {
-			this.pushMessageQueue.push({ message: event, retriesLeft: retryAttempts });
-
-			if (this.retryTimeout === null) {
-				this.retryTimeout = setTimeout(this.processWaitingPushMessages, 20);
-			}
-		},
-
-		/**
-		 * Process the push messages which are waiting in the queue
-		 */
-		async processWaitingPushMessages() {
-			if (this.retryTimeout !== null) {
-				clearTimeout(this.retryTimeout);
-				this.retryTimeout = null;
-			}
-
-			const queueLength = this.pushMessageQueue.length;
-			for (let i = 0; i < queueLength; i++) {
-				const messageData = this.pushMessageQueue.shift();
-
-				const result = await this.pushMessageReceived(messageData!.message, true);
-				if (!result) {
-					// Was not successful
-					messageData!.retriesLeft -= 1;
-
-					if (messageData!.retriesLeft > 0) {
-						// If still retries are left add it back and stop execution
-						this.pushMessageQueue.unshift(messageData!);
-					}
-					break;
-				}
-			}
-
-			if (this.pushMessageQueue.length !== 0 && this.retryTimeout === null) {
-				this.retryTimeout = setTimeout(this.processWaitingPushMessages, 25);
-			}
-		},
-
-		/**
-		 * Process a newly received message
-		 */
-		async pushMessageReceived(receivedData: IPushData, isRetry?: boolean): Promise<boolean> {
-			const retryAttempts = 5;
-
-			if (receivedData.type === 'sendWorkerStatusMessage') {
-				const pushData = receivedData.data;
-				this.orchestrationManagerStore.updateWorkerStatus(pushData.status);
-				return true;
-			}
-
-			if (receivedData.type === 'sendConsoleMessage') {
-				const pushData = receivedData.data;
-				console.log(pushData.source, ...pushData.messages);
-				return true;
-			}
-
-			if (
-				!['testWebhookReceived'].includes(receivedData.type) &&
-				isRetry !== true &&
-				this.pushMessageQueue.length
-			) {
-				// If there are already messages in the queue add the new one that all of them
-				// get executed in order
-				this.queuePushMessage(receivedData, retryAttempts);
-				return false;
-			}
-
-			if (receivedData.type === 'nodeExecuteAfter' || receivedData.type === 'nodeExecuteBefore') {
-				if (!this.uiStore.isActionActive('workflowRunning')) {
-					// No workflow is running so ignore the messages
-					return false;
-				}
-				const pushData = receivedData.data;
-				if (this.workflowsStore.activeExecutionId !== pushData.executionId) {
-					// The data is not for the currently active execution or
-					// we do not have the execution id yet.
-					if (isRetry !== true) {
-						this.queuePushMessage(event, retryAttempts);
-					}
-					return false;
-				}
-			}
-
-			// recovered execution data is handled like executionFinished data, however for security reasons
-			// we need to fetch the data from the server again rather than push it to all clients
-			let recoveredPushData: IPushDataExecutionFinished | undefined = undefined;
-			if (receivedData.type === 'executionRecovered') {
-				const recoveredExecutionId = receivedData.data?.executionId;
-				const isWorkflowRunning = this.uiStore.isActionActive('workflowRunning');
-				if (isWorkflowRunning && this.workflowsStore.activeExecutionId === recoveredExecutionId) {
-					// pull execution data for the recovered execution from the server
-					const executionData = await this.workflowsStore.fetchExecutionDataById(
-						this.workflowsStore.activeExecutionId,
-					);
-					if (executionData?.data) {
-						// data comes in as 'flatten' object, so we need to parse it
-						executionData.data = parse(
-							executionData.data as unknown as string,
-						) as IRunExecutionData;
-						const iRunExecutionData: IRunExecutionData = {
-							startData: executionData.data?.startData,
-							resultData: executionData.data?.resultData ?? { runData: {} },
-							executionData: executionData.data?.executionData,
-						};
-						if (
-							this.workflowsStore.workflowExecutionData?.workflowId === executionData.workflowId
-						) {
-							const activeRunData =
-								this.workflowsStore.workflowExecutionData?.data?.resultData?.runData;
-							if (activeRunData) {
-								for (const key of Object.keys(activeRunData)) {
-									iRunExecutionData.resultData.runData[key] = activeRunData[key];
-								}
-							}
-						}
-						const iRun: IRun = {
-							data: iRunExecutionData,
-							finished: executionData.finished,
-							mode: executionData.mode,
-							waitTill: executionData.data?.waitTill,
-							startedAt: executionData.startedAt,
-							stoppedAt: executionData.stoppedAt,
-							status: 'crashed',
-						};
-						if (executionData.data) {
-							recoveredPushData = {
-								executionId: executionData.id,
-								data: iRun,
-							};
-						}
-					}
-				}
-			}
-
-			if (
-				receivedData.type === 'workflowFailedToActivate' &&
-				this.workflowsStore.workflowId === receivedData.data.workflowId
-			) {
-				this.workflowsStore.setWorkflowInactive(receivedData.data.workflowId);
-				this.workflowsStore.setActive(false);
-
-				this.showError(
-					new Error(receivedData.data.errorMessage),
-					this.$locale.baseText('workflowActivator.showError.title', {
-						interpolate: { newStateName: 'activated' },
-					}) + ':',
-				);
-
-				return true;
-			}
-
-			if (receivedData.type === 'workflowActivated') {
-				this.workflowsStore.setWorkflowActive(receivedData.data.workflowId);
-				return true;
-			}
-
-			if (receivedData.type === 'workflowDeactivated') {
-				this.workflowsStore.setWorkflowInactive(receivedData.data.workflowId);
-				return true;
-			}
-
-			if (receivedData.type === 'executionFinished' || receivedData.type === 'executionRecovered') {
-				// The workflow finished executing
-				let pushData: IPushDataExecutionFinished;
-				if (receivedData.type === 'executionRecovered' && recoveredPushData !== undefined) {
-					pushData = recoveredPushData;
-				} else {
-					pushData = receivedData.data as IPushDataExecutionFinished;
-				}
-
-				const { activeExecutionId } = this.workflowsStore;
-				if (activeExecutionId === pushData.executionId) {
-					const activeRunData =
-						this.workflowsStore.workflowExecutionData?.data?.resultData?.runData;
-					if (activeRunData) {
-						for (const key of Object.keys(activeRunData)) {
-							if (
-								pushData.data.data.resultData.runData[key]?.[0]?.data?.main?.[0]?.[0]?.json
-									?.isArtificialRecoveredEventItem === true &&
-								activeRunData[key].length > 0
-							)
-								pushData.data.data.resultData.runData[key] = activeRunData[key];
-						}
-					}
-					this.workflowsStore.finishActiveExecution(pushData);
-				}
-
-				if (!this.uiStore.isActionActive('workflowRunning')) {
-					// No workflow is running so ignore the messages
-					return false;
-				}
-
-				if (activeExecutionId !== pushData.executionId) {
-					// The workflow which did finish execution did either not get started
-					// by this session or we do not have the execution id yet.
-					if (isRetry !== true) {
-						this.queuePushMessage(event, retryAttempts);
-					}
-					return false;
-				}
-
-				const runDataExecuted = pushData.data;
-
-				let runDataExecutedErrorMessage = this.getExecutionError(runDataExecuted.data);
-
-				if (runDataExecuted.status === 'crashed') {
-					runDataExecutedErrorMessage = this.$locale.baseText(
-						'pushConnection.executionFailed.message',
-					);
-				} else if (runDataExecuted.status === 'canceled') {
-					runDataExecutedErrorMessage = this.$locale.baseText(
-						'executionsList.showMessage.stopExecution.message',
-						{
-							interpolate: { activeExecutionId },
-						},
-					);
-				}
-
-				const lineNumber = runDataExecuted?.data?.resultData?.error?.lineNumber;
-
-				codeNodeEditorEventBus.emit('error-line-number', lineNumber || 'final');
-
-				const workflow = this.workflowHelpers.getCurrentWorkflow();
-				if (runDataExecuted.waitTill !== undefined) {
-					const workflowSettings = this.workflowsStore.workflowSettings;
-					const saveManualExecutions = this.settingsStore.saveManualExecutions;
-
-					const isSavingExecutions =
-						workflowSettings.saveManualExecutions === undefined
-							? saveManualExecutions
-							: workflowSettings.saveManualExecutions;
-
-					let action;
-					if (!isSavingExecutions) {
-						globalLinkActionsEventBus.emit('registerGlobalLinkAction', {
-							key: 'open-settings',
-							action: async () => {
-								if (this.workflowsStore.isNewWorkflow)
-									await this.workflowHelpers.saveAsNewWorkflow();
-								this.uiStore.openModal(WORKFLOW_SETTINGS_MODAL_KEY);
-							},
-						});
-
-						action =
-							'<a data-action="open-settings">Turn on saving manual executions</a> and run again to see what happened after this node.';
-					} else {
-						action = `<a href="/workflow/${workflow.id}/executions/${activeExecutionId}">View the execution</a> to see what happened after this node.`;
-					}
-
-					// Workflow did start but had been put to wait
-					this.titleSet(workflow.name as string, 'IDLE');
-					this.showToast({
-						title: 'Workflow started waiting',
-						message: `${action} <a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/" target="_blank">More info</a>`,
-						type: 'success',
-						duration: 0,
-					});
-				} else if (runDataExecuted.finished !== true) {
-					this.titleSet(workflow.name as string, 'ERROR');
-
-					if (
-						runDataExecuted.data.resultData.error?.name === 'ExpressionError' &&
-						(runDataExecuted.data.resultData.error as ExpressionError).context.functionality ===
-							'pairedItem'
-					) {
-						const error = runDataExecuted.data.resultData.error as ExpressionError;
-
-						void this.workflowHelpers.getWorkflowDataToSave().then((workflowData) => {
-							const eventData: IDataObject = {
-								caused_by_credential: false,
-								error_message: error.description,
-								error_title: error.message,
-								error_type: error.context.type,
-								node_graph_string: JSON.stringify(
-									TelemetryHelpers.generateNodesGraph(
-										workflowData as IWorkflowBase,
-										this.workflowHelpers.getNodeTypes(),
-									).nodeGraph,
-								),
-								workflow_id: this.workflowsStore.workflowId,
-							};
-
-							if (
-								error.context.nodeCause &&
-								['paired_item_no_info', 'paired_item_invalid_info'].includes(
-									error.context.type as string,
-								)
-							) {
-								const node = workflow.getNode(error.context.nodeCause as string);
-
-								if (node) {
-									eventData.is_pinned = !!workflow.getPinDataOfNode(node.name);
-									eventData.mode = node.parameters.mode;
-									eventData.node_type = node.type;
-									eventData.operation = node.parameters.operation;
-									eventData.resource = node.parameters.resource;
-								}
-							}
-
-							this.$telemetry.track('Instance FE emitted paired item error', eventData, {
-								withPostHog: true,
-							});
-						});
-					}
-
-					if (runDataExecuted.data.resultData.error?.name === 'SubworkflowOperationError') {
-						const error = runDataExecuted.data.resultData.error as SubworkflowOperationError;
-
-						this.workflowsStore.subWorkflowExecutionError = error;
-
-						this.showMessage({
-							title: error.message,
-							message: error.description,
-							type: 'error',
-							duration: 0,
-						});
-					} else if (
-						runDataExecuted.data.resultData.error?.name === 'NodeOperationError' &&
-						(runDataExecuted.data.resultData.error as NodeOperationError).functionality ===
-							'configuration-node'
-					) {
-						// If the error is a configuration error of the node itself doesn't get executed so we can't use lastNodeExecuted for the title
-						let title: string;
-						const nodeError = runDataExecuted.data.resultData.error as NodeOperationError;
-						if (nodeError.node.name) {
-							title = `Error in sub-node ‘${nodeError.node.name}‘`;
-						} else {
-							title = 'Problem executing workflow';
-						}
-
-						this.showMessage({
-							title,
-							message:
-								(nodeError?.description ?? runDataExecutedErrorMessage) +
-								this.$locale.baseText('pushConnection.executionError.openNode', {
-									interpolate: {
-										node: nodeError.node.name,
-									},
-								}),
-							type: 'error',
-							duration: 0,
-							dangerouslyUseHTMLString: true,
-						});
-					} else {
-						let title: string;
-						const isManualExecutionCancelled =
-							runDataExecuted.mode === 'manual' && runDataExecuted.status === 'canceled';
-
-						// Do not show the error message if the workflow got canceled manually
-						if (isManualExecutionCancelled) {
-							this.showMessage({
-								title: this.$locale.baseText('nodeView.showMessage.stopExecutionTry.title'),
-								type: 'success',
-							});
-						} else {
-							if (runDataExecuted.data.resultData.lastNodeExecuted) {
-								title = `Problem in node ‘${runDataExecuted.data.resultData.lastNodeExecuted}‘`;
-							} else {
-								title = 'Problem executing workflow';
-							}
-
-							this.showMessage({
-								title,
-								message: runDataExecutedErrorMessage,
-								type: 'error',
-								duration: 0,
-								dangerouslyUseHTMLString: true,
-							});
-						}
-					}
-				} else {
-					// Workflow did execute without a problem
-					this.titleSet(workflow.name as string, 'IDLE');
-
-					const execution = this.workflowsStore.getWorkflowExecution;
-					if (execution?.executedNode) {
-						const node = this.workflowsStore.getNodeByName(execution.executedNode);
-						const nodeType = node && this.nodeTypesStore.getNodeType(node.type, node.typeVersion);
-						const nodeOutput =
-							execution &&
-							execution.executedNode &&
-							execution.data?.resultData?.runData?.[execution.executedNode];
-						if (nodeType?.polling && !nodeOutput) {
-							this.showMessage({
-								title: this.$locale.baseText('pushConnection.pollingNode.dataNotFound', {
-									interpolate: {
-										service: getTriggerNodeServiceName(nodeType),
-									},
-								}),
-								message: this.$locale.baseText('pushConnection.pollingNode.dataNotFound.message', {
-									interpolate: {
-										service: getTriggerNodeServiceName(nodeType),
-									},
-								}),
-								type: 'success',
-							});
-						} else {
-							this.showMessage({
-								title: this.$locale.baseText('pushConnection.nodeExecutedSuccessfully'),
-								type: 'success',
-							});
-						}
-					} else {
-						this.showMessage({
-							title: this.$locale.baseText('pushConnection.workflowExecutedSuccessfully'),
-							type: 'success',
-						});
-					}
-				}
-
-				// It does not push the runData as it got already pushed with each
-				// node that did finish. For that reason copy in here the data
-				// which we already have.
-				if (this.workflowsStore.getWorkflowRunData) {
-					runDataExecuted.data.resultData.runData = this.workflowsStore.getWorkflowRunData;
-				}
-
-				this.workflowsStore.executingNode.length = 0;
-				this.workflowsStore.setWorkflowExecutionData(runDataExecuted as IExecutionResponse);
-				this.uiStore.removeActiveAction('workflowRunning');
-
-				// Set the node execution issues on all the nodes which produced an error so that
-				// it can be displayed in the node-view
-				this.nodeHelpers.updateNodesExecutionIssues();
-
-				const lastNodeExecuted: string | undefined =
-					runDataExecuted.data.resultData.lastNodeExecuted;
-				let itemsCount = 0;
-				if (
-					lastNodeExecuted &&
-					runDataExecuted.data.resultData.runData[lastNodeExecuted] &&
-					!runDataExecutedErrorMessage
-				) {
-					itemsCount =
-						runDataExecuted.data.resultData.runData[lastNodeExecuted][0].data!.main[0]!.length;
-				}
-
-				void useExternalHooks().run('pushConnection.executionFinished', {
-					itemsCount,
-					nodeName: runDataExecuted.data.resultData.lastNodeExecuted,
-					errorMessage: runDataExecutedErrorMessage,
-					runDataExecutedStartData: runDataExecuted.data.startData,
-					resultDataError: runDataExecuted.data.resultData.error,
-				});
-				if (!runDataExecuted.data.resultData.error) {
-					this.segmentStore.trackSuccessfulWorkflowExecution(runDataExecuted);
-				}
-			} else if (receivedData.type === 'executionStarted') {
-				const pushData = receivedData.data;
-
-				const executionData: IExecutionsCurrentSummaryExtended = {
-					id: pushData.executionId,
-					finished: false,
-					mode: pushData.mode,
-					startedAt: pushData.startedAt,
-					retryOf: pushData.retryOf,
-					workflowId: pushData.workflowId,
-					workflowName: pushData.workflowName,
-				};
-
-				this.workflowsStore.addActiveExecution(executionData);
-			} else if (receivedData.type === 'nodeExecuteAfter') {
-				// A node finished to execute. Add its data
-				const pushData = receivedData.data;
-				this.workflowsStore.addNodeExecutionData(pushData);
-				this.workflowsStore.removeExecutingNode(pushData.nodeName);
-			} else if (receivedData.type === 'nodeExecuteBefore') {
-				// A node started to be executed. Set it as executing.
-				const pushData = receivedData.data;
-				this.workflowsStore.addExecutingNode(pushData.nodeName);
-			} else if (receivedData.type === 'testWebhookDeleted') {
-				// A test-webhook was deleted
-				const pushData = receivedData.data;
-
-				if (pushData.workflowId === this.workflowsStore.workflowId) {
-					this.workflowsStore.executionWaitingForWebhook = false;
-					this.uiStore.removeActiveAction('workflowRunning');
-				}
-			} else if (receivedData.type === 'testWebhookReceived') {
-				// A test-webhook did get called
-				const pushData = receivedData.data;
-
-				if (pushData.workflowId === this.workflowsStore.workflowId) {
-					this.workflowsStore.executionWaitingForWebhook = false;
-					this.workflowsStore.activeExecutionId = pushData.executionId;
-				}
-
-				void this.processWaitingPushMessages();
-			} else if (receivedData.type === 'reloadNodeType') {
-				await this.nodeTypesStore.getNodeTypes();
-				await this.nodeTypesStore.getFullNodesProperties([receivedData.data]);
-			} else if (receivedData.type === 'removeNodeType') {
-				const pushData = receivedData.data;
-
-				const nodesToBeRemoved: INodeTypeNameVersion[] = [pushData];
-
-				// Force reload of all credential types
-				await this.credentialsStore.fetchCredentialTypes(false).then(() => {
-					this.nodeTypesStore.removeNodeTypes(nodesToBeRemoved);
-				});
-			} else if (receivedData.type === 'nodeDescriptionUpdated') {
-				await this.nodeTypesStore.getNodeTypes();
-				await this.credentialsStore.fetchCredentialTypes(true);
-			}
-			return true;
-		},
-		getExecutionError(data: IRunExecutionData | IExecuteContextData) {
-			const error = data.resultData.error;
-
-			let errorMessage: string;
-
-			if (data.resultData.lastNodeExecuted && error) {
-				errorMessage = error.message || error.description;
-			} else {
-				errorMessage = this.$locale.baseText('pushConnection.executionError', {
-					interpolate: { error: '!' },
-				});
-
-				if (error?.message) {
-					let nodeName: string | undefined;
-					if ('node' in error) {
-						nodeName = typeof error.node === 'string' ? error.node : error.node!.name;
-					}
-
-					const receivedError = nodeName ? `${nodeName}: ${error.message}` : error.message;
-					errorMessage = this.$locale.baseText('pushConnection.executionError', {
-						interpolate: {
-							error: `.${this.$locale.baseText('pushConnection.executionError.details', {
-								interpolate: {
-									details: receivedError,
-								},
-							})}`,
-						},
-					});
-				}
-			}
-
-			return errorMessage;
-		},
-	},
-});
diff --git a/packages/editor-ui/src/stores/collaboration.store.ts b/packages/editor-ui/src/stores/collaboration.store.ts
index 3aa84c1f78fae..208d5fa5884f4 100644
--- a/packages/editor-ui/src/stores/collaboration.store.ts
+++ b/packages/editor-ui/src/stores/collaboration.store.ts
@@ -14,37 +14,48 @@ export const useCollaborationStore = defineStore(STORES.COLLABORATION, () => {
 	const workflowStore = useWorkflowsStore();
 
 	const usersForWorkflows = ref<ActiveUsersForWorkflows>({});
+	const pushStoreEventListenerRemovalFn = ref<(() => void) | null>(null);
 
-	pushStore.addEventListener((event) => {
-		if (event.type === 'activeWorkflowUsersChanged') {
-			const activeWorkflowId = workflowStore.workflowId;
-			if (event.data.workflowId === activeWorkflowId) {
-				usersForWorkflows.value[activeWorkflowId] = event.data.activeUsers;
+	const getUsersForCurrentWorkflow = computed(() => {
+		return usersForWorkflows.value[workflowStore.workflowId] ?? [];
+	});
+
+	function initialize() {
+		pushStoreEventListenerRemovalFn.value = pushStore.addEventListener((event) => {
+			if (event.type === 'activeWorkflowUsersChanged') {
+				const activeWorkflowId = workflowStore.workflowId;
+				if (event.data.workflowId === activeWorkflowId) {
+					usersForWorkflows.value[activeWorkflowId] = event.data.activeUsers;
+				}
 			}
+		});
+	}
+
+	function terminate() {
+		if (typeof pushStoreEventListenerRemovalFn.value === 'function') {
+			pushStoreEventListenerRemovalFn.value();
 		}
-	});
+	}
 
-	const workflowUsersUpdated = (data: ActiveUsersForWorkflows) => {
+	function workflowUsersUpdated(data: ActiveUsersForWorkflows) {
 		usersForWorkflows.value = data;
-	};
+	}
 
-	const notifyWorkflowOpened = (workflowId: string) => {
+	function notifyWorkflowOpened(workflowId: string) {
 		pushStore.send({
 			type: 'workflowOpened',
 			workflowId,
 		});
-	};
+	}
 
-	const notifyWorkflowClosed = (workflowId: string) => {
+	function notifyWorkflowClosed(workflowId: string) {
 		pushStore.send({ type: 'workflowClosed', workflowId });
-	};
-
-	const getUsersForCurrentWorkflow = computed(() => {
-		return usersForWorkflows.value[workflowStore.workflowId];
-	});
+	}
 
 	return {
 		usersForWorkflows,
+		initialize,
+		terminate,
 		notifyWorkflowOpened,
 		notifyWorkflowClosed,
 		workflowUsersUpdated,
diff --git a/packages/editor-ui/src/stores/pushConnection.store.ts b/packages/editor-ui/src/stores/pushConnection.store.ts
index ade38baddfb88..1b5a3ab71bcfa 100644
--- a/packages/editor-ui/src/stores/pushConnection.store.ts
+++ b/packages/editor-ui/src/stores/pushConnection.store.ts
@@ -154,6 +154,7 @@ export const usePushConnectionStore = defineStore(STORES.PUSH, () => {
 		pushRef,
 		pushSource,
 		isConnectionOpen,
+		onMessageReceivedHandlers,
 		addEventListener,
 		pushConnect,
 		pushDisconnect,
diff --git a/packages/editor-ui/src/types/index.ts b/packages/editor-ui/src/types/index.ts
index 7bd3ad2db7474..322e345887251 100644
--- a/packages/editor-ui/src/types/index.ts
+++ b/packages/editor-ui/src/types/index.ts
@@ -1 +1,2 @@
 export * from './externalHooks';
+export * from './pushConnection';
diff --git a/packages/editor-ui/src/types/pushConnection.ts b/packages/editor-ui/src/types/pushConnection.ts
new file mode 100644
index 0000000000000..ae8e54419f3dc
--- /dev/null
+++ b/packages/editor-ui/src/types/pushConnection.ts
@@ -0,0 +1,6 @@
+import type { IPushData } from '@/Interface';
+
+export type PushMessageQueueItem = {
+	message: IPushData;
+	retriesLeft: number;
+};
diff --git a/packages/editor-ui/src/views/NodeView.vue b/packages/editor-ui/src/views/NodeView.vue
index 77b1afc4366a9..a83fe3fe4c193 100644
--- a/packages/editor-ui/src/views/NodeView.vue
+++ b/packages/editor-ui/src/views/NodeView.vue
@@ -806,6 +806,7 @@ export default defineComponent({
 		this.resetWorkspace();
 		this.canvasStore.initInstance(this.nodeViewRef as HTMLElement);
 		this.titleReset();
+
 		window.addEventListener('message', this.onPostMessageReceived);
 
 		this.clipboard.onPaste.value = this.onClipboardPasteEvent;
@@ -980,6 +981,7 @@ export default defineComponent({
 		if (!this.isDemo) {
 			this.pushStore.pushConnect();
 		}
+		this.collaborationStore.initialize();
 	},
 	beforeUnmount() {
 		// Make sure the event listeners get removed again else we
@@ -993,6 +995,7 @@ export default defineComponent({
 		if (!this.isDemo) {
 			this.pushStore.pushDisconnect();
 		}
+		this.collaborationStore.terminate();
 
 		this.resetWorkspace();
 		this.instance.unbind();
diff --git a/packages/editor-ui/src/views/SettingsCommunityNodesView.vue b/packages/editor-ui/src/views/SettingsCommunityNodesView.vue
index be7577a509048..e2dc01491a136 100644
--- a/packages/editor-ui/src/views/SettingsCommunityNodesView.vue
+++ b/packages/editor-ui/src/views/SettingsCommunityNodesView.vue
@@ -60,7 +60,6 @@ import {
 } from '@/constants';
 import CommunityPackageCard from '@/components/CommunityPackageCard.vue';
 import { useToast } from '@/composables/useToast';
-import { pushConnection } from '@/mixins/pushConnection';
 import type { PublicInstalledPackage } from 'n8n-workflow';
 
 import { useCommunityNodesStore } from '@/stores/communityNodes.store';
@@ -69,6 +68,9 @@ import { mapStores } from 'pinia';
 import { useSettingsStore } from '@/stores/settings.store';
 import { defineComponent } from 'vue';
 import { useExternalHooks } from '@/composables/useExternalHooks';
+import { useRouter } from 'vue-router';
+import { usePushConnection } from '@/composables/usePushConnection';
+import { usePushConnectionStore } from '@/stores/pushConnection.store';
 
 const PACKAGE_COUNT_THRESHOLD = 31;
 
@@ -77,15 +79,15 @@ export default defineComponent({
 	components: {
 		CommunityPackageCard,
 	},
-	mixins: [pushConnection],
-	setup(props, ctx) {
+	setup() {
+		const router = useRouter();
+		const pushConnection = usePushConnection({ router });
 		const externalHooks = useExternalHooks();
 
 		return {
 			externalHooks,
 			...useToast(),
-			// eslint-disable-next-line @typescript-eslint/no-misused-promises
-			...pushConnection.setup?.(props, ctx),
+			pushConnection,
 		};
 	},
 	data() {
@@ -93,10 +95,12 @@ export default defineComponent({
 			loading: false,
 		};
 	},
-	async mounted() {
+	beforeMount() {
+		this.pushConnection.initialize();
 		// The push connection is needed here to receive `reloadNodeType` and `removeNodeType` events when community nodes are installed, updated, or removed.
 		this.pushStore.pushConnect();
-
+	},
+	async mounted() {
 		try {
 			this.loading = true;
 			await this.communityNodesStore.fetchInstalledPackages();
@@ -142,9 +146,10 @@ export default defineComponent({
 	},
 	beforeUnmount() {
 		this.pushStore.pushDisconnect();
+		this.pushConnection.terminate();
 	},
 	computed: {
-		...mapStores(useCommunityNodesStore, useSettingsStore, useUIStore),
+		...mapStores(useCommunityNodesStore, useSettingsStore, useUIStore, usePushConnectionStore),
 		getEmptyStateDescription(): string {
 			const packageCount = this.communityNodesStore.availablePackageCount;
 

From 6ab378157041abfc918ae1d9408821f8fd5cfb34 Mon Sep 17 00:00:00 2001
From: Jon <jonathan.bennetts@gmail.com>
Date: Fri, 3 May 2024 10:02:46 +0100
Subject: [PATCH 2/7] fix(n8n Form Trigger Node): Fix missing options when
 using respond to webhook (#9282)

---
 .../nodes-base/nodes/Form/v2/FormTriggerV2.node.ts | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/packages/nodes-base/nodes/Form/v2/FormTriggerV2.node.ts b/packages/nodes-base/nodes/Form/v2/FormTriggerV2.node.ts
index e8afadc719016..7ad3edf79d97d 100644
--- a/packages/nodes-base/nodes/Form/v2/FormTriggerV2.node.ts
+++ b/packages/nodes-base/nodes/Form/v2/FormTriggerV2.node.ts
@@ -76,11 +76,6 @@ const descriptionV2: INodeTypeDescription = {
 			type: 'collection',
 			placeholder: 'Add Option',
 			default: {},
-			displayOptions: {
-				hide: {
-					responseMode: ['responseNode'],
-				},
-			},
 			options: [
 				{
 					// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
@@ -91,7 +86,14 @@ const descriptionV2: INodeTypeDescription = {
 					description:
 						'Whether to include the link “Form automated with n8n” at the bottom of the form',
 				},
-				respondWithOptions,
+				{
+					...respondWithOptions,
+					displayOptions: {
+						hide: {
+							'/responseMode': ['responseNode'],
+						},
+					},
+				},
 			],
 		},
 	],

From d92f994913befd31aec409ef8e40b290ac4185ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Iv=C3=A1n=20Ovejero?= <ivov.src@gmail.com>
Date: Fri, 3 May 2024 14:39:31 +0200
Subject: [PATCH 3/7] fix(editor): Resolve `$vars` and `$secrets` in
 expressions in credentials fields (#9289)

---
 .../src/components/ParameterInputWrapper.vue  |  8 ++-
 .../src/composables/useWorkflowHelpers.ts     | 56 +++++++++++++------
 .../editor-ui/src/views/CredentialsView.vue   |  9 ++-
 packages/workflow/src/WorkflowDataProxy.ts    |  4 +-
 4 files changed, 55 insertions(+), 22 deletions(-)

diff --git a/packages/editor-ui/src/components/ParameterInputWrapper.vue b/packages/editor-ui/src/components/ParameterInputWrapper.vue
index 957b21a9ac842..a3c9c558a4ac8 100644
--- a/packages/editor-ui/src/components/ParameterInputWrapper.vue
+++ b/packages/editor-ui/src/components/ParameterInputWrapper.vue
@@ -202,14 +202,18 @@ export default defineComponent({
 				? this.modelValue.value
 				: this.modelValue;
 
-			if (!this.activeNode || !this.isValueExpression || typeof value !== 'string') {
+			if (
+				!this.isForCredential &&
+				(!this.activeNode || !this.isValueExpression || typeof value !== 'string')
+			) {
 				return { ok: false, error: new Error() };
 			}
 
 			try {
-				let opts;
+				let opts = { isForCredential: this.isForCredential };
 				if (this.ndvStore.isInputParentOfActiveNode) {
 					opts = {
+						...opts,
 						targetItem: this.targetItem ?? undefined,
 						inputNodeName: this.ndvStore.ndvInputNodeName,
 						inputRunIndex: this.ndvStore.ndvInputRunIndex,
diff --git a/packages/editor-ui/src/composables/useWorkflowHelpers.ts b/packages/editor-ui/src/composables/useWorkflowHelpers.ts
index e6b452abbcbb0..9a44f5bb877f6 100644
--- a/packages/editor-ui/src/composables/useWorkflowHelpers.ts
+++ b/packages/editor-ui/src/composables/useWorkflowHelpers.ts
@@ -82,16 +82,51 @@ export function resolveParameter(
 		inputRunIndex?: number;
 		inputBranchIndex?: number;
 		additionalKeys?: IWorkflowDataProxyAdditionalKeys;
+		isForCredential?: boolean;
 	} = {},
 ): IDataObject | null {
 	let itemIndex = opts?.targetItem?.itemIndex || 0;
 
+	const workflow = getCurrentWorkflow();
+
+	const additionalKeys: IWorkflowDataProxyAdditionalKeys = {
+		$execution: {
+			id: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
+			mode: 'test',
+			resumeUrl: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
+			resumeFormUrl: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
+		},
+		$vars: useEnvironmentsStore().variablesAsObject,
+
+		// deprecated
+		$executionId: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
+		$resumeWebhookUrl: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
+
+		...opts.additionalKeys,
+	};
+
+	if (opts.isForCredential) {
+		// node-less expression resolution
+		return workflow.expression.getParameterValue(
+			parameter,
+			null,
+			0,
+			itemIndex,
+			'',
+			[],
+			'manual',
+			additionalKeys,
+			undefined,
+			false,
+			undefined,
+			'',
+		) as IDataObject;
+	}
+
 	const inputName = NodeConnectionType.Main;
 	const activeNode = useNDVStore().activeNode;
 	let contextNode = activeNode;
 
-	const workflow = getCurrentWorkflow();
-
 	if (activeNode) {
 		contextNode = workflow.getParentMainInputNode(activeNode);
 	}
@@ -159,22 +194,6 @@ export function resolveParameter(
 		_connectionInputData = [];
 	}
 
-	const additionalKeys: IWorkflowDataProxyAdditionalKeys = {
-		$execution: {
-			id: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
-			mode: 'test',
-			resumeUrl: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
-			resumeFormUrl: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
-		},
-		$vars: useEnvironmentsStore().variablesAsObject,
-
-		// deprecated
-		$executionId: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
-		$resumeWebhookUrl: PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
-
-		...opts.additionalKeys,
-	};
-
 	if (activeNode?.type === HTTP_REQUEST_NODE_TYPE) {
 		const EMPTY_RESPONSE = { statusCode: 200, headers: {}, body: {} };
 		const EMPTY_REQUEST = { headers: {}, body: {}, qs: {} };
@@ -793,6 +812,7 @@ export function useWorkflowHelpers(options: { router: ReturnType<typeof useRoute
 			inputBranchIndex?: number;
 			c?: number;
 			additionalKeys?: IWorkflowDataProxyAdditionalKeys;
+			isForCredential?: boolean;
 		} = {},
 		stringifyObject = true,
 	) {
diff --git a/packages/editor-ui/src/views/CredentialsView.vue b/packages/editor-ui/src/views/CredentialsView.vue
index bc6c1fc67afb2..11a4b2ba0857c 100644
--- a/packages/editor-ui/src/views/CredentialsView.vue
+++ b/packages/editor-ui/src/views/CredentialsView.vue
@@ -50,7 +50,7 @@ import { defineComponent } from 'vue';
 import ResourcesListLayout from '@/components/layouts/ResourcesListLayout.vue';
 import CredentialCard from '@/components/CredentialCard.vue';
 import type { ICredentialType } from 'n8n-workflow';
-import { CREDENTIAL_SELECT_MODAL_KEY } from '@/constants';
+import { CREDENTIAL_SELECT_MODAL_KEY, EnterpriseEditionFeature } from '@/constants';
 import { mapStores } from 'pinia';
 import { useUIStore } from '@/stores/ui.store';
 import { useUsersStore } from '@/stores/users.store';
@@ -58,6 +58,8 @@ import { useNodeTypesStore } from '@/stores/nodeTypes.store';
 import { useCredentialsStore } from '@/stores/credentials.store';
 import { useExternalSecretsStore } from '@/stores/externalSecrets.ee.store';
 import { useSourceControlStore } from '@/stores/sourceControl.store';
+import useEnvironmentsStore from '@/stores/environments.ee.store';
+import { useSettingsStore } from '@/stores/settings.store';
 
 type IResourcesListLayoutInstance = InstanceType<typeof ResourcesListLayout>;
 
@@ -123,11 +125,16 @@ export default defineComponent({
 			});
 		},
 		async initialize() {
+			const isVarsEnabled = useSettingsStore().isEnterpriseFeatureEnabled(
+				EnterpriseEditionFeature.Variables,
+			);
+
 			const loadPromises = [
 				this.credentialsStore.fetchAllCredentials(),
 				this.credentialsStore.fetchCredentialTypes(false),
 				this.externalSecretsStore.fetchAllSecrets(),
 				this.nodeTypesStore.loadNodeTypesIfNotLoaded(),
+				isVarsEnabled ? useEnvironmentsStore().fetchAllVariables() : Promise.resolve(), // for expression resolution
 			];
 
 			await Promise.all(loadPromises);
diff --git a/packages/workflow/src/WorkflowDataProxy.ts b/packages/workflow/src/WorkflowDataProxy.ts
index 5cc245f330114..e8a1091783fdf 100644
--- a/packages/workflow/src/WorkflowDataProxy.ts
+++ b/packages/workflow/src/WorkflowDataProxy.ts
@@ -164,7 +164,9 @@ export class WorkflowDataProxy {
 		const that = this;
 		const node = this.workflow.nodes[nodeName];
 
-		return new Proxy(node.parameters, {
+		// `node` is `undefined` only in expressions in credentials
+
+		return new Proxy(node?.parameters ?? {}, {
 			has: () => true,
 			ownKeys(target) {
 				return Reflect.ownKeys(target);

From b65e0e28114f576f89e271ab8ffdb8550e1be60f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E0=A4=95=E0=A4=BE=E0=A4=B0=E0=A4=A4=E0=A5=8B=E0=A4=AB?=
 =?UTF-8?q?=E0=A5=8D=E0=A4=AB=E0=A5=87=E0=A4=B2=E0=A4=B8=E0=A5=8D=E0=A4=95?=
 =?UTF-8?q?=E0=A5=8D=E0=A4=B0=E0=A4=BF=E0=A4=AA=E0=A5=8D=E0=A4=9F=E2=84=A2?=
 <netroy@users.noreply.github.com>
Date: Fri, 3 May 2024 15:03:59 +0200
Subject: [PATCH 4/7] fix(editor): Show MFA section to instance owner, even
 when external auth is enabled (#9301)

---
 .../src/views/SettingsPersonalView.vue        | 27 +++++++------
 .../__tests__/SettingsPersonalView.test.ts    | 39 ++++++++++++++-----
 2 files changed, 43 insertions(+), 23 deletions(-)

diff --git a/packages/editor-ui/src/views/SettingsPersonalView.vue b/packages/editor-ui/src/views/SettingsPersonalView.vue
index c985ee613980a..d2248b39d8179 100644
--- a/packages/editor-ui/src/views/SettingsPersonalView.vue
+++ b/packages/editor-ui/src/views/SettingsPersonalView.vue
@@ -32,7 +32,7 @@
 				/>
 			</div>
 		</div>
-		<div v-if="!signInWithLdap && !signInWithSaml">
+		<div v-if="isPersonalSecurityEnabled">
 			<div class="mb-s">
 				<n8n-heading size="large">{{ i18n.baseText('settings.personal.security') }}</n8n-heading>
 			</div>
@@ -43,7 +43,7 @@
 					}}</n8n-link>
 				</n8n-input-label>
 			</div>
-			<div v-if="isMfaFeatureEnabled">
+			<div v-if="isMfaFeatureEnabled" data-test-id="mfa-section">
 				<div class="mb-xs">
 					<n8n-input-label :label="$locale.baseText('settings.personal.mfa.section.title')" />
 					<n8n-text :bold="false" :class="$style.infoText">
@@ -171,7 +171,7 @@ export default defineComponent({
 					required: true,
 					autocomplete: 'given-name',
 					capitalize: true,
-					disabled: this.isLDAPFeatureEnabled && this.signInWithLdap,
+					disabled: this.isExternalAuthEnabled,
 				},
 			},
 			{
@@ -183,7 +183,7 @@ export default defineComponent({
 					required: true,
 					autocomplete: 'family-name',
 					capitalize: true,
-					disabled: this.isLDAPFeatureEnabled && this.signInWithLdap,
+					disabled: this.isExternalAuthEnabled,
 				},
 			},
 			{
@@ -196,7 +196,7 @@ export default defineComponent({
 					validationRules: [{ name: 'VALID_EMAIL' }],
 					autocomplete: 'email',
 					capitalize: true,
-					disabled: (this.isLDAPFeatureEnabled && this.signInWithLdap) || this.signInWithSaml,
+					disabled: !this.isPersonalSecurityEnabled,
 				},
 			},
 		];
@@ -206,16 +206,15 @@ export default defineComponent({
 		currentUser(): IUser | null {
 			return this.usersStore.currentUser;
 		},
-		signInWithLdap(): boolean {
-			return this.currentUser?.signInType === 'ldap';
+		isExternalAuthEnabled(): boolean {
+			const isLdapEnabled =
+				this.settingsStore.settings.enterprise.ldap && this.currentUser?.signInType === 'ldap';
+			const isSamlEnabled =
+				this.settingsStore.isSamlLoginEnabled && this.settingsStore.isDefaultAuthenticationSaml;
+			return isLdapEnabled || isSamlEnabled;
 		},
-		isLDAPFeatureEnabled(): boolean {
-			return this.settingsStore.settings.enterprise.ldap;
-		},
-		signInWithSaml(): boolean {
-			return (
-				this.settingsStore.isSamlLoginEnabled && this.settingsStore.isDefaultAuthenticationSaml
-			);
+		isPersonalSecurityEnabled(): boolean {
+			return this.usersStore.isInstanceOwner || !this.isExternalAuthEnabled;
 		},
 		mfaDisabled(): boolean {
 			return !this.usersStore.mfaEnabled;
diff --git a/packages/editor-ui/src/views/__tests__/SettingsPersonalView.test.ts b/packages/editor-ui/src/views/__tests__/SettingsPersonalView.test.ts
index 09df7dfc216f3..7236800010e07 100644
--- a/packages/editor-ui/src/views/__tests__/SettingsPersonalView.test.ts
+++ b/packages/editor-ui/src/views/__tests__/SettingsPersonalView.test.ts
@@ -57,16 +57,37 @@ describe('SettingsPersonalView', () => {
 		expect(getByTestId('change-password-link')).toBeInTheDocument();
 	});
 
-	it('should disable email and pw change when SAML login is enabled', async () => {
-		vi.spyOn(settingsStore, 'isSamlLoginEnabled', 'get').mockReturnValue(true);
-		vi.spyOn(settingsStore, 'isDefaultAuthenticationSaml', 'get').mockReturnValue(true);
+	describe('when external auth is enabled, email and password change', () => {
+		beforeEach(() => {
+			vi.spyOn(settingsStore, 'isSamlLoginEnabled', 'get').mockReturnValue(true);
+			vi.spyOn(settingsStore, 'isDefaultAuthenticationSaml', 'get').mockReturnValue(true);
+			vi.spyOn(settingsStore, 'isMfaFeatureEnabled', 'get').mockReturnValue(true);
+		});
 
-		const { queryByTestId, getAllByRole } = renderComponent({ pinia });
-		await waitAllPromises();
+		it('should not be disabled for the instance owner', async () => {
+			vi.spyOn(usersStore, 'isInstanceOwner', 'get').mockReturnValue(true);
+
+			const { queryByTestId, getAllByRole } = renderComponent({ pinia });
+			await waitAllPromises();
+
+			expect(
+				getAllByRole('textbox').find((el) => el.getAttribute('type') === 'email'),
+			).toBeEnabled();
+			expect(queryByTestId('change-password-link')).toBeInTheDocument();
+			expect(queryByTestId('mfa-section')).toBeInTheDocument();
+		});
+
+		it('should be disabled for members', async () => {
+			vi.spyOn(usersStore, 'isInstanceOwner', 'get').mockReturnValue(false);
+
+			const { queryByTestId, getAllByRole } = renderComponent({ pinia });
+			await waitAllPromises();
 
-		expect(
-			getAllByRole('textbox').find((el) => el.getAttribute('type') === 'email'),
-		).toBeDisabled();
-		expect(queryByTestId('change-password-link')).not.toBeInTheDocument();
+			expect(
+				getAllByRole('textbox').find((el) => el.getAttribute('type') === 'email'),
+			).toBeDisabled();
+			expect(queryByTestId('change-password-link')).not.toBeInTheDocument();
+			expect(queryByTestId('mfa-section')).not.toBeInTheDocument();
+		});
 	});
 });

From 7bda92cc7c15e7f67f22e0333c50747ddc918884 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Iv=C3=A1n=20Ovejero?= <ivov.src@gmail.com>
Date: Fri, 3 May 2024 15:24:27 +0200
Subject: [PATCH 5/7] refactor(core): Use logger for `packages/cli` messages
 (no-changelog) (#9302)

---
 packages/cli/src/AbstractServer.ts            |  8 ++---
 packages/cli/src/ResponseHelper.ts            |  6 ++--
 .../cli/src/WorkflowExecuteAdditionalData.ts  |  5 ++-
 packages/cli/src/WorkflowRunner.ts            |  9 +++--
 packages/cli/src/commands/BaseCommand.ts      |  2 +-
 packages/cli/src/commands/executeBatch.ts     | 34 +++++++++----------
 packages/cli/src/commands/start.ts            |  4 +--
 packages/cli/src/commands/update/workflow.ts  |  8 ++---
 .../cli/src/controllers/e2e.controller.ts     |  8 +++--
 .../MessageEventBusDestinationSyslog.ee.ts    |  4 ++-
 .../MessageEventBusDestinationWebhook.ee.ts   |  4 +--
 packages/cli/src/help.ts                      |  4 ++-
 .../risk-reporters/InstanceRiskReporter.ts    |  8 +++--
 .../cli/test/integration/credentials.test.ts  |  3 --
 .../test/unit/services/redis.service.test.ts  |  2 +-
 15 files changed, 63 insertions(+), 46 deletions(-)

diff --git a/packages/cli/src/AbstractServer.ts b/packages/cli/src/AbstractServer.ts
index 9496b1dffc453..1610600e50e88 100644
--- a/packages/cli/src/AbstractServer.ts
+++ b/packages/cli/src/AbstractServer.ts
@@ -154,7 +154,7 @@ export abstract class AbstractServer {
 
 		this.server.on('error', (error: Error & { code: string }) => {
 			if (error.code === 'EADDRINUSE') {
-				console.log(
+				this.logger.info(
 					`n8n's port ${PORT} is already in use. Do you have another instance of n8n running already?`,
 				);
 				process.exit(1);
@@ -167,7 +167,7 @@ export abstract class AbstractServer {
 
 		await this.setupHealthCheck();
 
-		console.log(`n8n ready on ${ADDRESS}, port ${PORT}`);
+		this.logger.info(`n8n ready on ${ADDRESS}, port ${PORT}`);
 	}
 
 	async start(): Promise<void> {
@@ -236,11 +236,11 @@ export abstract class AbstractServer {
 		await this.configure();
 
 		if (!inTest) {
-			console.log(`Version: ${N8N_VERSION}`);
+			this.logger.info(`Version: ${N8N_VERSION}`);
 
 			const defaultLocale = config.getEnv('defaultLocale');
 			if (defaultLocale !== 'en') {
-				console.log(`Locale: ${defaultLocale}`);
+				this.logger.info(`Locale: ${defaultLocale}`);
 			}
 
 			await this.externalHooks.run('n8n.ready', [this, config]);
diff --git a/packages/cli/src/ResponseHelper.ts b/packages/cli/src/ResponseHelper.ts
index e9e27d02bed38..42dcdee353331 100644
--- a/packages/cli/src/ResponseHelper.ts
+++ b/packages/cli/src/ResponseHelper.ts
@@ -10,6 +10,8 @@ import { Readable } from 'node:stream';
 
 import { inDevelopment } from '@/constants';
 import { ResponseError } from './errors/response-errors/abstract/response.error';
+import Container from 'typedi';
+import { Logger } from './Logger';
 
 export function sendSuccessResponse(
 	res: Response,
@@ -83,7 +85,7 @@ export function sendErrorResponse(res: Response, error: Error) {
 
 	if (isResponseError(error)) {
 		if (inDevelopment) {
-			console.error(picocolors.red(error.httpStatusCode), error.message);
+			Container.get(Logger).error(picocolors.red([error.httpStatusCode, error.message].join(' ')));
 		}
 
 		//render custom 404 page for form triggers
@@ -112,7 +114,7 @@ export function sendErrorResponse(res: Response, error: Error) {
 
 	if (error instanceof NodeApiError) {
 		if (inDevelopment) {
-			console.error(picocolors.red(error.name), error.message);
+			Container.get(Logger).error([picocolors.red(error.name), error.message].join(' '));
 		}
 
 		Object.assign(response, error);
diff --git a/packages/cli/src/WorkflowExecuteAdditionalData.ts b/packages/cli/src/WorkflowExecuteAdditionalData.ts
index 17799baedf480..88374f0c659dc 100644
--- a/packages/cli/src/WorkflowExecuteAdditionalData.ts
+++ b/packages/cli/src/WorkflowExecuteAdditionalData.ts
@@ -637,7 +637,10 @@ function hookFunctionsSaveWorker(): IWorkflowExecuteHooks {
 						]);
 					} catch (error) {
 						ErrorReporter.error(error);
-						console.error('There was a problem running hook "workflow.postExecute"', error);
+						Container.get(Logger).error(
+							'There was a problem running hook "workflow.postExecute"',
+							error,
+						);
 					}
 				}
 			},
diff --git a/packages/cli/src/WorkflowRunner.ts b/packages/cli/src/WorkflowRunner.ts
index 4c46d45a7d1c8..10ca743fae7e6 100644
--- a/packages/cli/src/WorkflowRunner.ts
+++ b/packages/cli/src/WorkflowRunner.ts
@@ -211,13 +211,16 @@ export class WorkflowRunner {
 							]);
 						} catch (error) {
 							ErrorReporter.error(error);
-							console.error('There was a problem running hook "workflow.postExecute"', error);
+							this.logger.error('There was a problem running hook "workflow.postExecute"', error);
 						}
 					}
 				})
 				.catch((error) => {
 					ErrorReporter.error(error);
-					console.error('There was a problem running internal hook "onWorkflowPostExecute"', error);
+					this.logger.error(
+						'There was a problem running internal hook "onWorkflowPostExecute"',
+						error,
+					);
 				});
 		}
 
@@ -411,7 +414,7 @@ export class WorkflowRunner {
 		try {
 			job = await this.jobQueue.add(jobData, jobOptions);
 
-			console.log(`Started with job ID: ${job.id.toString()} (Execution ID: ${executionId})`);
+			this.logger.info(`Started with job ID: ${job.id.toString()} (Execution ID: ${executionId})`);
 
 			hooks = WorkflowExecuteAdditionalData.getWorkflowHooksWorkerMain(
 				data.executionMode,
diff --git a/packages/cli/src/commands/BaseCommand.ts b/packages/cli/src/commands/BaseCommand.ts
index faa5db165df43..6a7614e57b9cb 100644
--- a/packages/cli/src/commands/BaseCommand.ts
+++ b/packages/cli/src/commands/BaseCommand.ts
@@ -320,7 +320,7 @@ export abstract class BaseCommand extends Command {
 			const forceShutdownTimer = setTimeout(async () => {
 				// In case that something goes wrong with shutdown we
 				// kill after timeout no matter what
-				console.log(`process exited after ${this.gracefulShutdownTimeoutInS}s`);
+				this.logger.info(`process exited after ${this.gracefulShutdownTimeoutInS}s`);
 				const errorMsg = `Shutdown timed out after ${this.gracefulShutdownTimeoutInS} seconds`;
 				await this.exitWithCrash(errorMsg, new Error(errorMsg));
 			}, this.gracefulShutdownTimeoutInS * 1000);
diff --git a/packages/cli/src/commands/executeBatch.ts b/packages/cli/src/commands/executeBatch.ts
index affec09e52fc3..cd01c9c99b207 100644
--- a/packages/cli/src/commands/executeBatch.ts
+++ b/packages/cli/src/commands/executeBatch.ts
@@ -178,11 +178,11 @@ export class ExecuteBatch extends BaseCommand {
 		if (flags.snapshot !== undefined) {
 			if (fs.existsSync(flags.snapshot)) {
 				if (!fs.lstatSync(flags.snapshot).isDirectory()) {
-					console.log('The parameter --snapshot must be an existing directory');
+					this.logger.error('The parameter --snapshot must be an existing directory');
 					return;
 				}
 			} else {
-				console.log('The parameter --snapshot must be an existing directory');
+				this.logger.error('The parameter --snapshot must be an existing directory');
 				return;
 			}
 
@@ -191,11 +191,11 @@ export class ExecuteBatch extends BaseCommand {
 		if (flags.compare !== undefined) {
 			if (fs.existsSync(flags.compare)) {
 				if (!fs.lstatSync(flags.compare).isDirectory()) {
-					console.log('The parameter --compare must be an existing directory');
+					this.logger.error('The parameter --compare must be an existing directory');
 					return;
 				}
 			} else {
-				console.log('The parameter --compare must be an existing directory');
+				this.logger.error('The parameter --compare must be an existing directory');
 				return;
 			}
 
@@ -205,7 +205,7 @@ export class ExecuteBatch extends BaseCommand {
 		if (flags.output !== undefined) {
 			if (fs.existsSync(flags.output)) {
 				if (fs.lstatSync(flags.output).isDirectory()) {
-					console.log('The parameter --output must be a writable file');
+					this.logger.error('The parameter --output must be a writable file');
 					return;
 				}
 			}
@@ -225,7 +225,7 @@ export class ExecuteBatch extends BaseCommand {
 				const matchedIds = paramIds.filter((id) => re.exec(id));
 
 				if (matchedIds.length === 0) {
-					console.log(
+					this.logger.error(
 						'The parameter --ids must be a list of numeric IDs separated by a comma or a file with this content.',
 					);
 					return;
@@ -245,7 +245,7 @@ export class ExecuteBatch extends BaseCommand {
 						.filter((id) => re.exec(id)),
 				);
 			} else {
-				console.log('Skip list file not found. Exiting.');
+				this.logger.error('Skip list file not found. Exiting.');
 				return;
 			}
 		}
@@ -302,18 +302,18 @@ export class ExecuteBatch extends BaseCommand {
 
 		if (flags.output !== undefined) {
 			fs.writeFileSync(flags.output, this.formatJsonOutput(results));
-			console.log('\nExecution finished.');
-			console.log('Summary:');
-			console.log(`\tSuccess: ${results.summary.successfulExecutions}`);
-			console.log(`\tFailures: ${results.summary.failedExecutions}`);
-			console.log(`\tWarnings: ${results.summary.warningExecutions}`);
-			console.log('\nNodes successfully tested:');
+			this.logger.info('\nExecution finished.');
+			this.logger.info('Summary:');
+			this.logger.info(`\tSuccess: ${results.summary.successfulExecutions}`);
+			this.logger.info(`\tFailures: ${results.summary.failedExecutions}`);
+			this.logger.info(`\tWarnings: ${results.summary.warningExecutions}`);
+			this.logger.info('\nNodes successfully tested:');
 			Object.entries(results.coveredNodes).forEach(([nodeName, nodeCount]) => {
-				console.log(`\t${nodeName}: ${nodeCount}`);
+				this.logger.info(`\t${nodeName}: ${nodeCount}`);
 			});
-			console.log('\nCheck the JSON file for more details.');
+			this.logger.info('\nCheck the JSON file for more details.');
 		} else if (flags.shortOutput) {
-			console.log(
+			this.logger.info(
 				this.formatJsonOutput({
 					...results,
 					executions: results.executions.filter(
@@ -322,7 +322,7 @@ export class ExecuteBatch extends BaseCommand {
 				}),
 			);
 		} else {
-			console.log(this.formatJsonOutput(results));
+			this.logger.info(this.formatJsonOutput(results));
 		}
 
 		await this.stopProcess(true);
diff --git a/packages/cli/src/commands/start.ts b/packages/cli/src/commands/start.ts
index 3b7ee763a3244..9cb2b44f1a41f 100644
--- a/packages/cli/src/commands/start.ts
+++ b/packages/cli/src/commands/start.ts
@@ -76,7 +76,7 @@ export class Start extends BaseCommand {
 		const editorUrl = Container.get(UrlService).baseUrl;
 
 		open(editorUrl, { wait: true }).catch(() => {
-			console.log(
+			this.logger.info(
 				`\nWas not able to open URL in browser. Please open manually by visiting:\n${editorUrl}\n`,
 			);
 		});
@@ -339,7 +339,7 @@ export class Start extends BaseCommand {
 	}
 
 	async catch(error: Error) {
-		console.log(error.stack);
+		if (error.stack) this.logger.error(error.stack);
 		await this.exitWithCrash('Exiting due to an error.', error);
 	}
 }
diff --git a/packages/cli/src/commands/update/workflow.ts b/packages/cli/src/commands/update/workflow.ts
index 0a8f0314615c6..f365db2d9814a 100644
--- a/packages/cli/src/commands/update/workflow.ts
+++ b/packages/cli/src/commands/update/workflow.ts
@@ -28,24 +28,24 @@ export class UpdateWorkflowCommand extends BaseCommand {
 		const { flags } = await this.parse(UpdateWorkflowCommand);
 
 		if (!flags.all && !flags.id) {
-			console.info('Either option "--all" or "--id" have to be set!');
+			this.logger.error('Either option "--all" or "--id" have to be set!');
 			return;
 		}
 
 		if (flags.all && flags.id) {
-			console.info(
+			this.logger.error(
 				'Either something else on top should be "--all" or "--id" can be set never both!',
 			);
 			return;
 		}
 
 		if (flags.active === undefined) {
-			console.info('No update flag like "--active=true" has been set!');
+			this.logger.error('No update flag like "--active=true" has been set!');
 			return;
 		}
 
 		if (!['false', 'true'].includes(flags.active)) {
-			console.info('Valid values for flag "--active" are only "false" or "true"!');
+			this.logger.error('Valid values for flag "--active" are only "false" or "true"!');
 			return;
 		}
 
diff --git a/packages/cli/src/controllers/e2e.controller.ts b/packages/cli/src/controllers/e2e.controller.ts
index cdf02852af453..6d99c785b95e0 100644
--- a/packages/cli/src/controllers/e2e.controller.ts
+++ b/packages/cli/src/controllers/e2e.controller.ts
@@ -14,9 +14,11 @@ import { MfaService } from '@/Mfa/mfa.service';
 import { Push } from '@/push';
 import { CacheService } from '@/services/cache/cache.service';
 import { PasswordUtility } from '@/services/password.utility';
+import Container from 'typedi';
+import { Logger } from '@/Logger';
 
 if (!inE2ETests) {
-	console.error('E2E endpoints only allowed during E2E tests');
+	Container.get(Logger).error('E2E endpoints only allowed during E2E tests');
 	process.exit(1);
 }
 
@@ -149,7 +151,9 @@ export class E2EController {
 					`DELETE FROM ${table}; DELETE FROM sqlite_sequence WHERE name=${table};`,
 				);
 			} catch (error) {
-				console.warn('Dropping Table for E2E Reset error: ', error);
+				Container.get(Logger).warn('Dropping Table for E2E Reset error', {
+					error: error as Error,
+				});
 			}
 		}
 	}
diff --git a/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationSyslog.ee.ts b/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationSyslog.ee.ts
index 5fe894ee7d280..ac68d3856a675 100644
--- a/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationSyslog.ee.ts
+++ b/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationSyslog.ee.ts
@@ -10,6 +10,8 @@ import { MessageEventBusDestination } from './MessageEventBusDestination.ee';
 import { isLogStreamingEnabled } from '../MessageEventBus/MessageEventBusHelper';
 import { eventMessageGenericDestinationTestEvent } from '../EventMessageClasses/EventMessageGeneric';
 import type { MessageEventBus, MessageWithCallback } from '../MessageEventBus/MessageEventBus';
+import Container from 'typedi';
+import { Logger } from '@/Logger';
 export const isMessageEventBusDestinationSyslogOptions = (
 	candidate: unknown,
 ): candidate is MessageEventBusDestinationSyslogOptions => {
@@ -63,7 +65,7 @@ export class MessageEventBusDestinationSyslog
 		});
 		this.logger.debug(`MessageEventBusDestinationSyslog with id ${this.getId()} initialized`);
 		this.client.on('error', function (error) {
-			console.error(error);
+			Container.get(Logger).error(`${error.message}`);
 		});
 	}
 
diff --git a/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationWebhook.ee.ts b/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationWebhook.ee.ts
index 59070a023b5b5..6b23c2de78ecb 100644
--- a/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationWebhook.ee.ts
+++ b/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationWebhook.ee.ts
@@ -180,7 +180,7 @@ export class MessageEventBusDestinationWebhook
 				try {
 					JSON.parse(this.jsonQuery);
 				} catch {
-					console.log('JSON parameter need to be an valid JSON');
+					this.logger.error('JSON parameter need to be an valid JSON');
 				}
 				this.axiosRequestOptions.params = jsonParse(this.jsonQuery);
 			}
@@ -198,7 +198,7 @@ export class MessageEventBusDestinationWebhook
 				try {
 					JSON.parse(this.jsonHeaders);
 				} catch {
-					console.log('JSON parameter need to be an valid JSON');
+					this.logger.error('JSON parameter need to be an valid JSON');
 				}
 				this.axiosRequestOptions.headers = jsonParse(this.jsonHeaders);
 			}
diff --git a/packages/cli/src/help.ts b/packages/cli/src/help.ts
index a95a3381e0211..8581483577402 100644
--- a/packages/cli/src/help.ts
+++ b/packages/cli/src/help.ts
@@ -1,10 +1,12 @@
 import { Help } from '@oclif/core';
+import Container from 'typedi';
+import { Logger } from 'winston';
 
 // oclif expects a default export
 // eslint-disable-next-line import/no-default-export
 export default class CustomHelp extends Help {
 	async showRootHelp() {
-		console.log(
+		Container.get(Logger).info(
 			'You can find up to date information about the CLI here:\nhttps://docs.n8n.io/hosting/cli-commands/',
 		);
 	}
diff --git a/packages/cli/src/security-audit/risk-reporters/InstanceRiskReporter.ts b/packages/cli/src/security-audit/risk-reporters/InstanceRiskReporter.ts
index 637fab4d02659..47568b06f3220 100644
--- a/packages/cli/src/security-audit/risk-reporters/InstanceRiskReporter.ts
+++ b/packages/cli/src/security-audit/risk-reporters/InstanceRiskReporter.ts
@@ -14,10 +14,14 @@ import { getN8nPackageJson, inDevelopment } from '@/constants';
 import type { WorkflowEntity } from '@db/entities/WorkflowEntity';
 import type { RiskReporter, Risk, n8n } from '@/security-audit/types';
 import { isApiEnabled } from '@/PublicApi';
+import { Logger } from '@/Logger';
 
 @Service()
 export class InstanceRiskReporter implements RiskReporter {
-	constructor(private readonly instanceSettings: InstanceSettings) {}
+	constructor(
+		private readonly instanceSettings: InstanceSettings,
+		private readonly logger: Logger,
+	) {}
 
 	async report(workflows: WorkflowEntity[]) {
 		const unprotectedWebhooks = this.getUnprotectedWebhookNodes(workflows);
@@ -174,7 +178,7 @@ export class InstanceRiskReporter implements RiskReporter {
 			versions = await this.getNextVersions(localVersion).then((v) => this.removeIconData(v));
 		} catch (error) {
 			if (inDevelopment) {
-				console.error('Failed to fetch n8n versions. Skipping outdated instance report...');
+				this.logger.error('Failed to fetch n8n versions. Skipping outdated instance report...');
 			}
 			return null;
 		}
diff --git a/packages/cli/test/integration/credentials.test.ts b/packages/cli/test/integration/credentials.test.ts
index aa40616ad8681..a25f0108cf3e7 100644
--- a/packages/cli/test/integration/credentials.test.ts
+++ b/packages/cli/test/integration/credentials.test.ts
@@ -398,9 +398,6 @@ describe('PATCH /credentials/:id', () => {
 				.patch(`/credentials/${savedCredential.id}`)
 				.send(invalidPayload);
 
-			if (response.statusCode === 500) {
-				console.log(response.statusCode, response.body);
-			}
 			expect(response.statusCode).toBe(400);
 		}
 	});
diff --git a/packages/cli/test/unit/services/redis.service.test.ts b/packages/cli/test/unit/services/redis.service.test.ts
index 04fb980db6797..a3e4b1b162dd5 100644
--- a/packages/cli/test/unit/services/redis.service.test.ts
+++ b/packages/cli/test/unit/services/redis.service.test.ts
@@ -66,7 +66,7 @@ describe('RedisService', () => {
 
 		const mockHandler = jest.fn();
 		mockHandler.mockImplementation((stream: string, id: string, message: string[]) => {
-			console.log('Received message', stream, id, message);
+			Container.get(Logger).info('Received message', { stream, id, message });
 		});
 		consumer.addMessageHandler('some handler', mockHandler);
 

From bfb0eb7a06f219424486a55256ecca46c14a85ba Mon Sep 17 00:00:00 2001
From: Jon <jonathan.bennetts@gmail.com>
Date: Fri, 3 May 2024 15:56:58 +0100
Subject: [PATCH 6/7] fix(Gmail Node): Remove duplicate options when creating
 drafts (#9299)

---
 .../nodes/Google/Gmail/v2/DraftDescription.ts | 51 +++----------------
 1 file changed, 8 insertions(+), 43 deletions(-)

diff --git a/packages/nodes-base/nodes/Google/Gmail/v2/DraftDescription.ts b/packages/nodes-base/nodes/Google/Gmail/v2/DraftDescription.ts
index 47b99c5762f3b..3bd3dd2efa6f4 100644
--- a/packages/nodes-base/nodes/Google/Gmail/v2/DraftDescription.ts
+++ b/packages/nodes-base/nodes/Google/Gmail/v2/DraftDescription.ts
@@ -116,49 +116,6 @@ export const draftFields: INodeProperties[] = [
 		},
 		default: {},
 		options: [
-			{
-				displayName: 'To Email',
-				name: 'sendTo',
-				type: 'string',
-				default: '',
-				placeholder: 'info@example.com',
-				description:
-					'The email addresses of the recipients. Multiple addresses can be separated by a comma. e.g. jay@getsby.com, jon@smith.com.',
-			},
-			{
-				displayName: 'BCC',
-				name: 'bccList',
-				type: 'string',
-				description:
-					'The email addresses of the blind copy recipients. Multiple addresses can be separated by a comma. e.g. jay@getsby.com, jon@smith.com.',
-				placeholder: 'info@example.com',
-				default: '',
-			},
-			{
-				displayName: 'CC',
-				name: 'ccList',
-				type: 'string',
-				description:
-					'The email addresses of the copy recipients. Multiple addresses can be separated by a comma. e.g. jay@getsby.com, jon@smith.com.',
-				placeholder: 'info@example.com',
-				default: '',
-			},
-			{
-				displayName: 'Send Replies To',
-				name: 'replyTo',
-				type: 'string',
-				placeholder: 'reply@example.com',
-				default: '',
-				description: 'The email address that the reply message is sent to',
-			},
-			{
-				displayName: 'Thread ID',
-				name: 'threadId',
-				type: 'string',
-				placeholder: '18cc573e2431878f',
-				default: '',
-				description: 'The identifier of the thread to attach the draft',
-			},
 			{
 				displayName: 'Attachments',
 				name: 'attachmentsUi',
@@ -223,6 +180,14 @@ export const draftFields: INodeProperties[] = [
 				default: '',
 				description: 'The email address that the reply message is sent to',
 			},
+			{
+				displayName: 'Thread ID',
+				name: 'threadId',
+				type: 'string',
+				placeholder: '18cc573e2431878f',
+				default: '',
+				description: 'The identifier of the thread to attach the draft',
+			},
 			{
 				displayName: 'To Email',
 				name: 'sendTo',

From 22b6f909505d7c3d9c0583a90599e6e9c244e21e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Iv=C3=A1n=20Ovejero?= <ivov.src@gmail.com>
Date: Mon, 6 May 2024 09:04:16 +0200
Subject: [PATCH 7/7] fix(core): Prevent occassional 429s on license init in
 multi-main setup (#9284)

---
 packages/cli/src/License.ts                   | 34 +++++++-
 packages/cli/src/commands/BaseCommand.ts      | 10 ++-
 packages/cli/src/commands/start.ts            |  2 +
 .../orchestration/main/MultiMainSetup.ee.ts   | 10 ++-
 packages/cli/test/unit/License.test.ts        | 78 +++++++++++++++++++
 5 files changed, 124 insertions(+), 10 deletions(-)

diff --git a/packages/cli/src/License.ts b/packages/cli/src/License.ts
index ce678939c8b97..1e31222571b10 100644
--- a/packages/cli/src/License.ts
+++ b/packages/cli/src/License.ts
@@ -41,6 +41,26 @@ export class License {
 		private readonly usageMetricsService: UsageMetricsService,
 	) {}
 
+	/**
+	 * Whether this instance should renew the license - on init and periodically.
+	 */
+	private renewalEnabled(instanceType: N8nInstanceType) {
+		if (instanceType !== 'main') return false;
+
+		const autoRenewEnabled = config.getEnv('license.autoRenewEnabled');
+
+		/**
+		 * In multi-main setup, all mains start off with `unset` status and so renewal disabled.
+		 * On becoming leader or follower, each will enable or disable renewal, respectively.
+		 * This ensures the mains do not cause a 429 (too many requests) on license init.
+		 */
+		if (config.getEnv('multiMainSetup.enabled')) {
+			return autoRenewEnabled && config.getEnv('multiMainSetup.instanceType') === 'leader';
+		}
+
+		return autoRenewEnabled;
+	}
+
 	async init(instanceType: N8nInstanceType = 'main') {
 		if (this.manager) {
 			this.logger.warn('License manager already initialized or shutting down');
@@ -53,7 +73,6 @@ export class License {
 
 		const isMainInstance = instanceType === 'main';
 		const server = config.getEnv('license.serverUrl');
-		const autoRenewEnabled = isMainInstance && config.getEnv('license.autoRenewEnabled');
 		const offlineMode = !isMainInstance;
 		const autoRenewOffset = config.getEnv('license.autoRenewOffset');
 		const saveCertStr = isMainInstance
@@ -66,13 +85,15 @@ export class License {
 			? async () => await this.usageMetricsService.collectUsageMetrics()
 			: async () => [];
 
+		const renewalEnabled = this.renewalEnabled(instanceType);
+
 		try {
 			this.manager = new LicenseManager({
 				server,
 				tenantId: config.getEnv('license.tenantId'),
 				productIdentifier: `n8n-${N8N_VERSION}`,
-				autoRenewEnabled,
-				renewOnInit: autoRenewEnabled,
+				autoRenewEnabled: renewalEnabled,
+				renewOnInit: renewalEnabled,
 				autoRenewOffset,
 				offlineMode,
 				logger: this.logger,
@@ -126,7 +147,7 @@ export class License {
 
 			if (this.orchestrationService.isMultiMainSetupEnabled && !isMultiMainLicensed) {
 				this.logger.debug(
-					'[Multi-main setup] License changed with no support for multi-main setup - no new followers will be allowed to init. To restore multi-main setup, please upgrade to a license that supporst this feature.',
+					'[Multi-main setup] License changed with no support for multi-main setup - no new followers will be allowed to init. To restore multi-main setup, please upgrade to a license that supports this feature.',
 				);
 			}
 		}
@@ -335,4 +356,9 @@ export class License {
 	isWithinUsersLimit() {
 		return this.getUsersLimit() === UNLIMITED_LICENSE_QUOTA;
 	}
+
+	async reinit() {
+		this.manager?.reset();
+		await this.init();
+	}
 }
diff --git a/packages/cli/src/commands/BaseCommand.ts b/packages/cli/src/commands/BaseCommand.ts
index 6a7614e57b9cb..61db09f3a57b7 100644
--- a/packages/cli/src/commands/BaseCommand.ts
+++ b/packages/cli/src/commands/BaseCommand.ts
@@ -41,6 +41,8 @@ export abstract class BaseCommand extends Command {
 
 	protected shutdownService: ShutdownService = Container.get(ShutdownService);
 
+	protected license: License;
+
 	/**
 	 * How long to wait for graceful shutdown before force killing the process.
 	 */
@@ -269,13 +271,13 @@ export abstract class BaseCommand extends Command {
 	}
 
 	async initLicense(): Promise<void> {
-		const license = Container.get(License);
-		await license.init(this.instanceType ?? 'main');
+		this.license = Container.get(License);
+		await this.license.init(this.instanceType ?? 'main');
 
 		const activationKey = config.getEnv('license.activationKey');
 
 		if (activationKey) {
-			const hasCert = (await license.loadCertStr()).length > 0;
+			const hasCert = (await this.license.loadCertStr()).length > 0;
 
 			if (hasCert) {
 				return this.logger.debug('Skipping license activation');
@@ -283,7 +285,7 @@ export abstract class BaseCommand extends Command {
 
 			try {
 				this.logger.debug('Attempting license activation');
-				await license.activate(activationKey);
+				await this.license.activate(activationKey);
 				this.logger.debug('License init complete');
 			} catch (e) {
 				this.logger.error('Could not activate license', e as Error);
diff --git a/packages/cli/src/commands/start.ts b/packages/cli/src/commands/start.ts
index 9cb2b44f1a41f..4ddd999d0c1c5 100644
--- a/packages/cli/src/commands/start.ts
+++ b/packages/cli/src/commands/start.ts
@@ -211,9 +211,11 @@ export class Start extends BaseCommand {
 
 		orchestrationService.multiMainSetup
 			.on('leader-stepdown', async () => {
+				await this.license.reinit(); // to disable renewal
 				await this.activeWorkflowRunner.removeAllTriggerAndPollerBasedWorkflows();
 			})
 			.on('leader-takeover', async () => {
+				await this.license.reinit(); // to enable renewal
 				await this.activeWorkflowRunner.addAllTriggerAndPollerBasedWorkflows();
 			});
 	}
diff --git a/packages/cli/src/services/orchestration/main/MultiMainSetup.ee.ts b/packages/cli/src/services/orchestration/main/MultiMainSetup.ee.ts
index eda788ae670ce..5f74f1931bd73 100644
--- a/packages/cli/src/services/orchestration/main/MultiMainSetup.ee.ts
+++ b/packages/cli/src/services/orchestration/main/MultiMainSetup.ee.ts
@@ -77,7 +77,10 @@ export class MultiMainSetup extends EventEmitter {
 
 			config.set('multiMainSetup.instanceType', 'follower');
 
-			this.emit('leader-stepdown'); // lost leadership - stop triggers, pollers, pruning
+			/**
+			 * Lost leadership - stop triggers, pollers, pruning, wait tracking, license renewal
+			 */
+			this.emit('leader-stepdown');
 
 			await this.tryBecomeLeader();
 		}
@@ -97,7 +100,10 @@ export class MultiMainSetup extends EventEmitter {
 
 			await this.redisPublisher.setExpiration(this.leaderKey, this.leaderKeyTtl);
 
-			this.emit('leader-takeover'); // gained leadership - start triggers, pollers, pruning, wait-tracking
+			/**
+			 * Gained leadership - start triggers, pollers, pruning, wait-tracking, license renewal
+			 */
+			this.emit('leader-takeover');
 		} else {
 			config.set('multiMainSetup.instanceType', 'follower');
 		}
diff --git a/packages/cli/test/unit/License.test.ts b/packages/cli/test/unit/License.test.ts
index 354e672b0bfdb..182656f39a8f1 100644
--- a/packages/cli/test/unit/License.test.ts
+++ b/packages/cli/test/unit/License.test.ts
@@ -175,3 +175,81 @@ describe('License', () => {
 		expect(mainPlan).toBeUndefined();
 	});
 });
+
+describe('License', () => {
+	beforeEach(() => {
+		config.load(config.default);
+	});
+
+	describe('init', () => {
+		describe('in single-main setup', () => {
+			describe('with `license.autoRenewEnabled` enabled', () => {
+				it('should enable renewal', async () => {
+					config.set('multiMainSetup.enabled', false);
+
+					await new License(mock(), mock(), mock(), mock(), mock()).init();
+
+					expect(LicenseManager).toHaveBeenCalledWith(
+						expect.objectContaining({ autoRenewEnabled: true, renewOnInit: true }),
+					);
+				});
+			});
+
+			describe('with `license.autoRenewEnabled` disabled', () => {
+				it('should disable renewal', async () => {
+					config.set('license.autoRenewEnabled', false);
+
+					await new License(mock(), mock(), mock(), mock(), mock()).init();
+
+					expect(LicenseManager).toHaveBeenCalledWith(
+						expect.objectContaining({ autoRenewEnabled: false, renewOnInit: false }),
+					);
+				});
+			});
+		});
+
+		describe('in multi-main setup', () => {
+			describe('with `license.autoRenewEnabled` disabled', () => {
+				test.each(['unset', 'leader', 'follower'])(
+					'if %s status, should disable removal',
+					async (status) => {
+						config.set('multiMainSetup.enabled', true);
+						config.set('multiMainSetup.instanceType', status);
+						config.set('license.autoRenewEnabled', false);
+
+						await new License(mock(), mock(), mock(), mock(), mock()).init();
+
+						expect(LicenseManager).toHaveBeenCalledWith(
+							expect.objectContaining({ autoRenewEnabled: false, renewOnInit: false }),
+						);
+					},
+				);
+			});
+
+			describe('with `license.autoRenewEnabled` enabled', () => {
+				test.each(['unset', 'follower'])('if %s status, should disable removal', async (status) => {
+					config.set('multiMainSetup.enabled', true);
+					config.set('multiMainSetup.instanceType', status);
+					config.set('license.autoRenewEnabled', false);
+
+					await new License(mock(), mock(), mock(), mock(), mock()).init();
+
+					expect(LicenseManager).toHaveBeenCalledWith(
+						expect.objectContaining({ autoRenewEnabled: false, renewOnInit: false }),
+					);
+				});
+
+				it('if leader status, should enable renewal', async () => {
+					config.set('multiMainSetup.enabled', true);
+					config.set('multiMainSetup.instanceType', 'leader');
+
+					await new License(mock(), mock(), mock(), mock(), mock()).init();
+
+					expect(LicenseManager).toHaveBeenCalledWith(
+						expect.objectContaining({ autoRenewEnabled: true, renewOnInit: true }),
+					);
+				});
+			});
+		});
+	});
+});