@atom8n/n8n-editor-ui 2.2.0

package/dist/assets/logStreaming.store-IZhWe_VK.js

@@ -0,0 +1,190 @@
+import { It as ref } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+import { $s as deleteDestinationFromDb, ec as getDestinationsFromBackend, ic as sendTestMessageToDestination, nc as hasDestinationId, rc as saveDestinationToDb, tc as getEventNamesFromBackend } from "./builder.store-Czk2ipDE.js";
+import { k as defineStore, r as useRootStore } from "./_baseOrderBy-N8Be_6z6.js";
+var eventGroupFromEventName = (eventName) => {
+	const matches = eventName.match(/^[\w\s]+\.[\w\s]+/);
+	if (matches && matches?.length > 0) return matches[0];
+};
+var prettifyEventName = (label, group = "") => {
+	label = label.replace(group + ".", "");
+	if (label.length > 0) {
+		label = label[0].toUpperCase() + label.substring(1);
+		label = label.replaceAll(".", " ");
+	}
+	return label;
+};
+var 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;
+};
+const 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
+	};
+});
+export { useLogStreamingStore as t };

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

@@ -0,0 +1,10 @@
+const MCP_ENDPOINT = "mcp-server/http";
+const MCP_DOCS_PAGE_URL = "https://docs.n8n.io/advanced-ai/accessing-n8n-mcp-server";
+const ELIGIBLE_WORKFLOWS_DOCS_SECTION = "workflow-eligibility";
+const MCP_SETTINGS_VIEW = "McpSettings";
+const MCP_STORE = "mcp";
+const LOADING_INDICATOR_TIMEOUT = 200;
+const MCP_TOOLTIP_DELAY = 100;
+const MCP_CONNECT_POPOVER_WIDTH = 460;
+const MCP_CONNECT_WORKFLOWS_MODAL_KEY = "mcpConnectWorkflowsModal";
+export { MCP_DOCS_PAGE_URL as a, MCP_STORE as c, MCP_CONNECT_WORKFLOWS_MODAL_KEY as i, MCP_TOOLTIP_DELAY as l, LOADING_INDICATOR_TIMEOUT as n, MCP_ENDPOINT as o, MCP_CONNECT_POPOVER_WIDTH as r, MCP_SETTINGS_VIEW as s, ELIGIBLE_WORKFLOWS_DOCS_SECTION as t };

package/dist/assets/mcp.store-B9yfcAN9.js

@@ -0,0 +1,116 @@
+import { C as computed, It as ref } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+import { Gr as isWorkflowListItem, P as useWorkflowsStore, ms as useSettingsStore } from "./builder.store-Czk2ipDE.js";
+import { k as defineStore, l as getFullApiResponse, r as useRootStore, u as makeRestApiRequest } from "./_baseOrderBy-N8Be_6z6.js";
+import { c as MCP_STORE } from "./mcp.constants-_Jcn7fPq.js";
+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)}`);
+}
+async function fetchMcpEligibleWorkflows(context, options) {
+	const params = {};
+	if (options?.take !== void 0) params.take = options.take;
+	if (options?.skip !== void 0) params.skip = options.skip;
+	if (options?.query) params.filter = JSON.stringify({ query: options.query });
+	return await getFullApiResponse(context, "GET", "/mcp/workflows", params);
+}
+const useMCPStore = defineStore("mcp", () => {
+	const workflowsStore = useWorkflowsStore();
+	const rootStore = useRootStore();
+	const settingsStore = useSettingsStore();
+	const currentUserMCPKey = ref(null);
+	const oauthClients = ref([]);
+	const connectPopoverOpen = ref(false);
+	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;
+	}
+	function resetCurrentUserMCPKey() {
+		currentUserMCPKey.value = null;
+	}
+	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;
+	}
+	async function getMcpEligibleWorkflows(options) {
+		return await fetchMcpEligibleWorkflows(rootStore.restApiContext, options);
+	}
+	function openConnectPopover() {
+		connectPopoverOpen.value = true;
+	}
+	function closeConnectPopover() {
+		connectPopoverOpen.value = false;
+	}
+	return {
+		mcpAccessEnabled,
+		fetchWorkflowsAvailableForMCP,
+		setMcpAccessEnabled,
+		toggleWorkflowMcpAccess,
+		currentUserMCPKey,
+		getOrCreateApiKey,
+		generateNewApiKey,
+		resetCurrentUserMCPKey,
+		oauthClients,
+		getAllOAuthClients,
+		removeOAuthClient,
+		getMcpEligibleWorkflows,
+		connectPopoverOpen,
+		openConnectPopover,
+		closeConnectPopover
+	};
+});
+export { useMCPStore as t };