n8n-editor-ui 1.119.1 → 1.120.1

package/dist/assets/{logStreaming.store-CPvxjcQB.js → logStreaming.store-DFZnZ2Rt.js}

@@ -1,5 +1,5 @@
 import { It as ref } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { As as hasDestinationId, Ds as deleteDestinationFromDb, Ms as sendTestMessageToDestination, Os as getDestinationsFromBackend, Ys as useRootStore, js as saveDestinationToDb, ks as getEventNamesFromBackend, vc as defineStore } from "./useTelemetry-EOV0Llso.js";
+import { As as deleteDestinationFromDb, Fs as sendTestMessageToDestination, Ms as getEventNamesFromBackend, Ns as hasDestinationId, Ps as saveDestinationToDb, Qs as useRootStore, js as getDestinationsFromBackend, xc as defineStore } from "./useTelemetry-DedEakwK.js";
 var eventGroupFromEventName = (eventName) => {
 	const matches = eventName.match(/^[\w\s]+\.[\w\s]+/);
 	if (matches && matches?.length > 0) return matches[0];

package/dist/assets/logStreaming.store-legacy-B_cbQPAW.js

@@ -0,0 +1,209 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./useTelemetry-legacy-Bu_8SoSm.js"], function (_export, _context) {
+    "use strict";
+
+    var ref, deleteDestinationFromDb, sendTestMessageToDestination, getEventNamesFromBackend, hasDestinationId, saveDestinationToDb, useRootStore, getDestinationsFromBackend, defineStore, eventGroupFromEventName, prettifyEventName, eventGroupsFromStringList, useLogStreamingStore;
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        ref = _vueRuntimeEsmBundlerLegacy003Js.It;
+      }, function (_useTelemetryLegacy00FJs) {
+        deleteDestinationFromDb = _useTelemetryLegacy00FJs.As;
+        sendTestMessageToDestination = _useTelemetryLegacy00FJs.Fs;
+        getEventNamesFromBackend = _useTelemetryLegacy00FJs.Ms;
+        hasDestinationId = _useTelemetryLegacy00FJs.Ns;
+        saveDestinationToDb = _useTelemetryLegacy00FJs.Ps;
+        useRootStore = _useTelemetryLegacy00FJs.Qs;
+        getDestinationsFromBackend = _useTelemetryLegacy00FJs.js;
+        defineStore = _useTelemetryLegacy00FJs.xc;
+      }],
+      execute: function () {
+        //#region src/features/integrations/logStreaming.ee/logStreaming.store.ts
+        eventGroupFromEventName = eventName => {
+          const matches = eventName.match(/^[\w\s]+\.[\w\s]+/);
+          if (matches && matches?.length > 0) return matches[0];
+        };
+        prettifyEventName = (label, group = "") => {
+          label = label.replace(group + ".", "");
+          if (label.length > 0) {
+            label = label[0].toUpperCase() + label.substring(1);
+            label = label.replaceAll(".", " ");
+          }
+          return label;
+        };
+        eventGroupsFromStringList = (dottedList, selectionList = /* @__PURE__ */new Set()) => {
+          const result = [];
+          const eventNameArray = Array.from(dottedList.values());
+          const groups = /* @__PURE__ */new Set();
+          groups.add("n8n.workflow");
+          groups.add("n8n.node");
+          for (const eventName of eventNameArray) {
+            const matches = eventName.match(/^[\w\s]+\.[\w\s]+/);
+            if (matches && matches?.length > 0) groups.add(matches[0]);
+          }
+          for (const group of groups) {
+            const collection = {
+              children: [],
+              label: group,
+              name: group,
+              selected: selectionList.has(group),
+              indeterminate: false
+            };
+            const eventsOfGroup = eventNameArray.filter(e => e.startsWith(group));
+            for (const event of eventsOfGroup) {
+              if (!collection.selected && selectionList.has(event)) collection.indeterminate = true;
+              const subCollection = {
+                label: prettifyEventName(event, group),
+                name: event,
+                selected: selectionList.has(event),
+                indeterminate: false
+              };
+              collection.children.push(subCollection);
+            }
+            result.push(collection);
+          }
+          return result;
+        };
+        _export("t", useLogStreamingStore = defineStore("logStreaming", () => {
+          const items = ref({});
+          const eventNames = ref(/* @__PURE__ */new Set());
+          const rootStore = useRootStore();
+          const setSelectionAndBuildItems = destination => {
+            if (destination.id) {
+              if (!items.value[destination.id]) items.value[destination.id] = {
+                destination,
+                selectedEvents: /* @__PURE__ */new Set(),
+                eventGroups: [],
+                isNew: false
+              };
+              items.value[destination.id]?.selectedEvents?.clear();
+              if (destination.subscribedEvents) for (const eventName of destination.subscribedEvents) items.value[destination.id]?.selectedEvents?.add(eventName);
+              items.value[destination.id].eventGroups = eventGroupsFromStringList(eventNames.value, items.value[destination.id]?.selectedEvents);
+            }
+          };
+          const addDestination = destination => {
+            if (destination.id && items.value[destination.id]) items.value[destination.id].destination = destination;else setSelectionAndBuildItems(destination);
+          };
+          const getDestination = destinationId => {
+            if (items.value[destinationId]) return items.value[destinationId].destination;else return;
+          };
+          const getAllDestinations = () => {
+            return Object.values(items.value).map(item => item.destination);
+          };
+          const clearDestinations = () => {
+            items.value = {};
+          };
+          const addEventName = name => {
+            eventNames.value.add(name);
+          };
+          const removeEventName = name => {
+            eventNames.value.delete(name);
+          };
+          const clearEventNames = () => {
+            eventNames.value.clear();
+          };
+          const setSelectedInGroup = (destinationId, name, isSelected) => {
+            if (!items.value[destinationId]) return;
+            const groupName = eventGroupFromEventName(name);
+            const group = items.value[destinationId].eventGroups.find(e => e.name === groupName);
+            if (!group) return;
+            const children = group.children;
+            if (groupName === name) {
+              group.selected = isSelected;
+              group.indeterminate = false;
+              children.forEach(e => e.selected = false);
+              return;
+            }
+            const event = children.find(e => e.name === name);
+            if (!event) return;
+            event.selected = isSelected;
+            if (!isSelected && group.selected) {
+              group.selected = false;
+              group.children.filter(e => e !== event).forEach(e => e.selected = true);
+            }
+            const selectedChildren = children.filter(e => e.selected);
+            if (isSelected && selectedChildren.length === children.length) {
+              group.selected = true;
+              group.children.forEach(e => e.selected = false);
+            }
+            group.indeterminate = selectedChildren.length > 0 && selectedChildren.length < children.length;
+          };
+          const addSelectedEvent = (id, name) => {
+            items.value[id]?.selectedEvents?.add(name);
+            setSelectedInGroup(id, name, true);
+          };
+          const removeSelectedEvent = (id, name) => {
+            items.value[id]?.selectedEvents?.delete(name);
+            setSelectedInGroup(id, name, false);
+          };
+          const removeDestinationItemTree = id => {
+            delete items.value[id];
+          };
+          const updateDestination = destination => {
+            if (destination.id && items.value[destination.id]) items.value[destination.id].destination = destination;
+          };
+          const removeDestination = destinationId => {
+            if (!destinationId) return;
+            delete items.value[destinationId];
+          };
+          const getSelectedEvents = destinationId => {
+            const selectedEvents = [];
+            if (items.value[destinationId]) for (const group of items.value[destinationId].eventGroups) {
+              if (group.selected) selectedEvents.push(group.name);
+              for (const event of group.children) if (event.selected) selectedEvents.push(event.name);
+            }
+            return selectedEvents;
+          };
+          const saveDestination = async destination => {
+            if (!hasDestinationId(destination)) return false;
+            const selectedEvents = getSelectedEvents(destination.id);
+            try {
+              await saveDestinationToDb(rootStore.restApiContext, destination, selectedEvents);
+              updateDestination(destination);
+              return true;
+            } catch {
+              return false;
+            }
+          };
+          const sendTestMessage = async destination => {
+            if (!hasDestinationId(destination)) return false;
+            return await sendTestMessageToDestination(rootStore.restApiContext, destination);
+          };
+          const fetchEventNames = async () => {
+            return await getEventNamesFromBackend(rootStore.restApiContext);
+          };
+          const fetchDestinations = async () => {
+            return await getDestinationsFromBackend(rootStore.restApiContext);
+          };
+          const deleteDestination = async destinationId => {
+            await deleteDestinationFromDb(rootStore.restApiContext, destinationId);
+            removeDestination(destinationId);
+          };
+          return {
+            addDestination,
+            setSelectionAndBuildItems,
+            getDestination,
+            getAllDestinations,
+            clearDestinations,
+            addEventName,
+            removeEventName,
+            clearEventNames,
+            addSelectedEvent,
+            removeSelectedEvent,
+            setSelectedInGroup,
+            removeDestinationItemTree,
+            updateDestination,
+            removeDestination,
+            getSelectedEvents,
+            saveDestination,
+            sendTestMessage,
+            fetchEventNames,
+            fetchDestinations,
+            deleteDestination,
+            items
+          };
+        })); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/mcp.constants-BCNosk1p.js

@@ -0,0 +1,5 @@
+const MCP_SETTINGS_VIEW = "McpSettings";
+const MCP_STORE = "mcp";
+const LOADING_INDICATOR_TIMEOUT = 200;
+const MCP_DOCS_PAGE_URL = "https://docs.n8n.io/advanced-ai/accessing-n8n-mcp-server";
+export { MCP_STORE as i, MCP_DOCS_PAGE_URL as n, MCP_SETTINGS_VIEW as r, LOADING_INDICATOR_TIMEOUT as t };

package/dist/assets/mcp.constants-legacy-CZfk8DW2.js

@@ -0,0 +1,18 @@
+;
+(function () {
+  System.register([], function (_export, _context) {
+    "use strict";
+
+    var MCP_SETTINGS_VIEW, MCP_STORE, LOADING_INDICATOR_TIMEOUT, MCP_DOCS_PAGE_URL;
+    return {
+      setters: [],
+      execute: function () {
+        //#region src/features/ai/mcpAccess/mcp.constants.ts
+        _export("r", MCP_SETTINGS_VIEW = "McpSettings");
+        _export("i", MCP_STORE = "mcp");
+        _export("t", LOADING_INDICATOR_TIMEOUT = 200);
+        _export("n", MCP_DOCS_PAGE_URL = "https://docs.n8n.io/advanced-ai/accessing-n8n-mcp-server"); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{mcp.store-YGfe2oZU.js → mcp.store-Bd62s_4P.js}

@@ -1,6 +1,6 @@
 import { C as computed, It as ref } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { Ro as useSettingsStore, Ys as useRootStore, lc as makeRestApiRequest, o as useWorkflowsStore, vc as defineStore, yr as isWorkflowListItem } from "./useTelemetry-EOV0Llso.js";
-import { a as MCP_STORE } from "./useMcp-_gyuyL1x.js";
+import { Bo as useSettingsStore, Qs as useRootStore, fc as makeRestApiRequest, o as useWorkflowsStore, xc as defineStore, yr as isWorkflowListItem } from "./useTelemetry-DedEakwK.js";
+import { i as MCP_STORE } from "./mcp.constants-BCNosk1p.js";
 async function updateMcpSettings(context, enabled) {
 	return await makeRestApiRequest(context, "PATCH", "/mcp/settings", { mcpAccessEnabled: enabled });
 }
@@ -13,11 +13,18 @@ async function rotateApiKey(context) {
 async function toggleWorkflowMcpAccessApi(context, workflowId, availableInMCP) {
 	return await makeRestApiRequest(context, "PATCH", `/mcp/workflows/${encodeURIComponent(workflowId)}/toggle-access`, { availableInMCP });
 }
+async function fetchOAuthClients(context) {
+	return await makeRestApiRequest(context, "GET", "/mcp/oauth-clients");
+}
+async function deleteOAuthClient(context, clientId) {
+	return await makeRestApiRequest(context, "DELETE", `/mcp/oauth-clients/${encodeURIComponent(clientId)}`);
+}
 const useMCPStore = defineStore("mcp", () => {
 	const workflowsStore = useWorkflowsStore();
 	const rootStore = useRootStore();
 	const settingsStore = useSettingsStore();
 	const currentUserMCPKey = ref(null);
+	const oauthClients = ref([]);
 	const mcpAccessEnabled = computed(() => !!settingsStore.moduleSettings.mcp?.mcpAccessEnabled);
 	async function fetchWorkflowsAvailableForMCP(page = 1, pageSize = 50) {
 		return (await workflowsStore.fetchWorkflowsPage(void 0, page, pageSize, "updatedAt:desc", {
@@ -57,6 +64,16 @@ const useMCPStore = defineStore("mcp", () => {
 		currentUserMCPKey.value = apiKey;
 		return apiKey;
 	}
+	async function getAllOAuthClients() {
+		const response = await fetchOAuthClients(rootStore.restApiContext);
+		oauthClients.value = response.data;
+		return response.data;
+	}
+	async function removeOAuthClient(clientId) {
+		const response = await deleteOAuthClient(rootStore.restApiContext, clientId);
+		oauthClients.value = oauthClients.value.filter((client) => client.id !== clientId);
+		return response;
+	}
 	return {
 		mcpAccessEnabled,
 		fetchWorkflowsAvailableForMCP,
@@ -64,7 +81,10 @@ const useMCPStore = defineStore("mcp", () => {
 		toggleWorkflowMcpAccess,
 		currentUserMCPKey,
 		getOrCreateApiKey,
-		generateNewApiKey
+		generateNewApiKey,
+		oauthClients,
+		getAllOAuthClients,
+		removeOAuthClient
 	};
 });
 export { useMCPStore as t };

package/dist/assets/mcp.store-legacy-C00py4q_.js

@@ -0,0 +1,125 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./useTelemetry-legacy-Bu_8SoSm.js", "./mcp.constants-legacy-CZfk8DW2.js"], function (_export, _context) {
+    "use strict";
+
+    var computed, ref, useSettingsStore, useRootStore, makeRestApiRequest, useWorkflowsStore, defineStore, isWorkflowListItem, MCP_STORE, useMCPStore;
+    //#region src/features/ai/mcpAccess/mcp.api.ts
+    async function updateMcpSettings(context, enabled) {
+      return await makeRestApiRequest(context, "PATCH", "/mcp/settings", {
+        mcpAccessEnabled: enabled
+      });
+    }
+    async function fetchApiKey(context) {
+      return await makeRestApiRequest(context, "GET", "/mcp/api-key");
+    }
+    async function rotateApiKey(context) {
+      return await makeRestApiRequest(context, "POST", "/mcp/api-key/rotate");
+    }
+    async function toggleWorkflowMcpAccessApi(context, workflowId, availableInMCP) {
+      return await makeRestApiRequest(context, "PATCH", `/mcp/workflows/${encodeURIComponent(workflowId)}/toggle-access`, {
+        availableInMCP
+      });
+    }
+    async function fetchOAuthClients(context) {
+      return await makeRestApiRequest(context, "GET", "/mcp/oauth-clients");
+    }
+    async function deleteOAuthClient(context, clientId) {
+      return await makeRestApiRequest(context, "DELETE", `/mcp/oauth-clients/${encodeURIComponent(clientId)}`);
+    }
+
+    //#endregion
+    //#region src/features/ai/mcpAccess/mcp.store.ts
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        computed = _vueRuntimeEsmBundlerLegacy003Js.C;
+        ref = _vueRuntimeEsmBundlerLegacy003Js.It;
+      }, function (_useTelemetryLegacy00FJs) {
+        useSettingsStore = _useTelemetryLegacy00FJs.Bo;
+        useRootStore = _useTelemetryLegacy00FJs.Qs;
+        makeRestApiRequest = _useTelemetryLegacy00FJs.fc;
+        useWorkflowsStore = _useTelemetryLegacy00FJs.o;
+        defineStore = _useTelemetryLegacy00FJs.xc;
+        isWorkflowListItem = _useTelemetryLegacy00FJs.yr;
+      }, function (_mcpConstantsLegacy037Js) {
+        MCP_STORE = _mcpConstantsLegacy037Js.i;
+      }],
+      execute: function () {
+        _export("t", useMCPStore = defineStore("mcp", () => {
+          const workflowsStore = useWorkflowsStore();
+          const rootStore = useRootStore();
+          const settingsStore = useSettingsStore();
+          const currentUserMCPKey = ref(null);
+          const oauthClients = ref([]);
+          const mcpAccessEnabled = computed(() => !!settingsStore.moduleSettings.mcp?.mcpAccessEnabled);
+          async function fetchWorkflowsAvailableForMCP(page = 1, pageSize = 50) {
+            return (await workflowsStore.fetchWorkflowsPage(void 0, page, pageSize, "updatedAt:desc", {
+              isArchived: false,
+              availableInMCP: true
+            }, false, false)).filter(isWorkflowListItem);
+          }
+          async function setMcpAccessEnabled(enabled) {
+            const {
+              mcpAccessEnabled: updated
+            } = await updateMcpSettings(rootStore.restApiContext, enabled);
+            settingsStore.moduleSettings.mcp = {
+              ...(settingsStore.moduleSettings.mcp ?? {}),
+              mcpAccessEnabled: updated
+            };
+            return updated;
+          }
+          async function toggleWorkflowMcpAccess(workflowId, availableInMCP) {
+            const response = await toggleWorkflowMcpAccessApi(rootStore.restApiContext, workflowId, availableInMCP);
+            const {
+              id,
+              settings,
+              versionId
+            } = response;
+            if (id === workflowsStore.workflowId) {
+              workflowsStore.setWorkflowVersionId(versionId);
+              if (settings) workflowsStore.private.setWorkflowSettings(settings);
+            }
+            if (workflowsStore.workflowsById[id]) workflowsStore.workflowsById[id] = {
+              ...workflowsStore.workflowsById[id],
+              settings,
+              versionId
+            };
+            return response;
+          }
+          async function getOrCreateApiKey() {
+            const apiKey = await fetchApiKey(rootStore.restApiContext);
+            currentUserMCPKey.value = apiKey;
+            return apiKey;
+          }
+          async function generateNewApiKey() {
+            const apiKey = await rotateApiKey(rootStore.restApiContext);
+            currentUserMCPKey.value = apiKey;
+            return apiKey;
+          }
+          async function getAllOAuthClients() {
+            const response = await fetchOAuthClients(rootStore.restApiContext);
+            oauthClients.value = response.data;
+            return response.data;
+          }
+          async function removeOAuthClient(clientId) {
+            const response = await deleteOAuthClient(rootStore.restApiContext, clientId);
+            oauthClients.value = oauthClients.value.filter(client => client.id !== clientId);
+            return response;
+          }
+          return {
+            mcpAccessEnabled,
+            fetchWorkflowsAvailableForMCP,
+            setMcpAccessEnabled,
+            toggleWorkflowMcpAccess,
+            currentUserMCPKey,
+            getOrCreateApiKey,
+            generateNewApiKey,
+            oauthClients,
+            getAllOAuthClients,
+            removeOAuthClient
+          };
+        })); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{merge-CKEa8BM2.js → merge-Dnkh07HW.js}

@@ -1,5 +1,5 @@
 import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
-import { a as require__getNative, c as require_isObject, f as require__root, i as require_eq, l as require_isObjectLike, m as require_isArray, n as require__Map, p as require__freeGlobal, r as require__ListCache, s as require_isFunction, t as require__MapCache, u as require__baseGetTag } from "./_MapCache-Byd-DTfo.js";
+import { a as require__getNative, c as require_isObject, f as require__root, i as require_eq, l as require_isObjectLike, m as require_isArray, n as require__Map, p as require__freeGlobal, r as require__ListCache, s as require_isFunction, t as require__MapCache, u as require__baseGetTag } from "./_MapCache-Dw6Llo22.js";
 var require__stackClear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var ListCache$2 = require__ListCache();
 	function stackClear$1() {