n8n 2.32.6 → 2.33.1

package/dist/modules/mcp/tools/workflow-builder/workflow-operations.js

@@ -232,9 +232,9 @@ exports.partialUpdateOperationSchema = zod_1.z.discriminatedUnion('type', [
             .array(zod_1.z.object({
             id: zod_1.z.string().trim().min(1).optional().describe('Group id. Generated if omitted.'),
             name: zod_1.z.string().trim().min(1).describe('Unique group name.'),
-            nodeIds: zod_1.z
+            nodeNames: zod_1.z
                 .array(zod_1.z.string().trim().min(1))
-                .describe('IDs of the nodes that belong to this group.'),
+                .describe('Names of the nodes that belong to this group.'),
             description: zod_1.z
                 .string()
                 .trim()
@@ -242,7 +242,46 @@ exports.partialUpdateOperationSchema = zod_1.z.discriminatedUnion('type', [
                 .optional()
                 .describe(`Optional description shown when the group is collapsed. Max ${n8n_workflow_1.GROUP_DESCRIPTION_MAX_LENGTH} characters.`),
         }))
-            .describe('Replaces the workflow node groups entirely. Pass [] to remove all groups. Each nodeId must reference an existing node, and every group must form a valid, connected, trigger-free section of the graph (validated on save).'),
+            .describe('Replaces the workflow node groups entirely. Pass [] to remove all groups. Each nodeName must reference an existing node, and every group must form a valid, connected, trigger-free section of the graph (validated on save).'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('addNodeGroup'),
+        name: zod_1.z.string().trim().min(1).describe('Name for the new group. Must be unique.'),
+        nodeNames: zod_1.z
+            .array(zod_1.z.string().trim().min(1))
+            .min(1)
+            .describe('Names of the nodes that belong to this group. The nodes must form a valid, connected, trigger-free section of the graph (validated on save).'),
+        description: zod_1.z
+            .string()
+            .trim()
+            .max(n8n_workflow_1.GROUP_DESCRIPTION_MAX_LENGTH)
+            .optional()
+            .describe(`Optional description shown when the group is collapsed. Max ${n8n_workflow_1.GROUP_DESCRIPTION_MAX_LENGTH} characters.`),
+        id: zod_1.z.string().trim().min(1).optional().describe('Group id. Generated if omitted.'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('removeNodeGroup'),
+        groupName: zod_1.z
+            .string()
+            .trim()
+            .min(1)
+            .describe('Name of the group to remove. The grouped nodes themselves are kept.'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('updateNodeGroup'),
+        groupName: zod_1.z.string().trim().min(1).describe('Name of the existing group to update.'),
+        newName: zod_1.z.string().trim().min(1).optional().describe('New unique group name.'),
+        nodeNames: zod_1.z
+            .array(zod_1.z.string().trim().min(1))
+            .min(1)
+            .optional()
+            .describe('Replaces the group membership entirely with these node names.'),
+        description: zod_1.z
+            .string()
+            .trim()
+            .max(n8n_workflow_1.GROUP_DESCRIPTION_MAX_LENGTH)
+            .optional()
+            .describe(`New description shown when the group is collapsed (max ${n8n_workflow_1.GROUP_DESCRIPTION_MAX_LENGTH} characters). Pass "" to clear it. Omit to leave unchanged.`),
     }),
 ]);
 const cloneWorkflow = (workflow) => ({
@@ -376,7 +415,7 @@ const pruneConnectionShape = (connections, source, connectionType) => {
     if (!byType)
         return;
     const outputs = byType[connectionType];
-    if (outputs && outputs.every((o) => !o || o.length === 0)) {
+    if (outputs?.every((o) => !o || o.length === 0)) {
         delete byType[connectionType];
     }
     if (Object.keys(byType).length === 0) {
@@ -388,244 +427,386 @@ const fail = (opIndex, message) => ({
     error: `Operation ${opIndex} failed: ${message}`,
     opIndex,
 });
+const resolveGroupNodeIds = (nodeByName, nodeNames, groupName) => {
+    const nodeIds = new Set();
+    for (const nodeName of nodeNames) {
+        const node = nodeByName.get(nodeName);
+        if (!node) {
+            return { error: `node '${nodeName}' in group '${groupName}' not found` };
+        }
+        nodeIds.add(node.id);
+    }
+    return { nodeIds: [...nodeIds] };
+};
+const handleUpdateNodeParameters = (op, ctx) => {
+    const node = ctx.nodeByName.get(op.nodeName);
+    if (!node) {
+        return `node '${op.nodeName}' not found`;
+    }
+    const sanitized = sanitizeUnsafeKeys(op.parameters);
+    const merged = op.replace
+        ? sanitized
+        : deepMerge((node.parameters ?? {}), sanitized);
+    node.parameters = merged;
+    return null;
+};
+const handleSetNodeParameter = (op, ctx) => {
+    const node = ctx.nodeByName.get(op.nodeName);
+    if (!node) {
+        return `node '${op.nodeName}' not found`;
+    }
+    const segments = parseJsonPointer(op.path);
+    if (!segments) {
+        return `path '${op.path}' is invalid or contains unsafe segments`;
+    }
+    const params = (node.parameters ?? {});
+    const setError = setAtPointer(params, segments, op.value);
+    if (setError) {
+        return setError;
+    }
+    node.parameters = params;
+    return null;
+};
+const handleAddNode = (op, ctx) => {
+    if (!(0, n8n_workflow_1.isSafeObjectProperty)(op.node.name)) {
+        return `node name '${op.node.name}' is not allowed`;
+    }
+    if (ctx.nodeByName.has(op.node.name)) {
+        return `a node named '${op.node.name}' already exists`;
+    }
+    const node = {
+        id: op.node.id ?? (0, uuid_1.v4)(),
+        name: op.node.name,
+        type: op.node.type,
+        typeVersion: op.node.typeVersion,
+        position: op.node.position ?? [0, 0],
+        parameters: (sanitizeUnsafeKeys(op.node.parameters ?? {}) ?? {}),
+    };
+    if (op.node.credentials) {
+        const credentialEntries = [];
+        for (const [key, cred] of Object.entries(op.node.credentials)) {
+            if (!(0, n8n_workflow_1.isSafeObjectProperty)(key)) {
+                return `credential key '${key}' is not allowed`;
+            }
+            credentialEntries.push([key, { id: cred.id ?? null, name: cred.name }]);
+        }
+        node.credentials = Object.fromEntries(credentialEntries);
+    }
+    if (op.node.disabled !== undefined) {
+        node.disabled = op.node.disabled;
+    }
+    if (op.node.notes !== undefined) {
+        node.notes = op.node.notes;
+    }
+    ctx.workflow.nodes.push(node);
+    ctx.nodeByName.set(node.name, node);
+    ctx.addedNodeNames.add(node.name);
+    return null;
+};
+const handleRemoveNode = (op, ctx) => {
+    const node = ctx.nodeByName.get(op.nodeName);
+    if (!node) {
+        return `node '${op.nodeName}' not found`;
+    }
+    ctx.workflow.nodes.splice(ctx.workflow.nodes.indexOf(node), 1);
+    ctx.nodeByName.delete(op.nodeName);
+    removeConnectionsFor(ctx.workflow.connections, op.nodeName);
+    ctx.addedNodeNames.delete(op.nodeName);
+    if (ctx.workflow.nodeGroups?.length) {
+        const prunedGroups = [];
+        for (const group of ctx.workflow.nodeGroups) {
+            if (!group.nodeIds.includes(node.id)) {
+                prunedGroups.push(group);
+                continue;
+            }
+            ctx.nodeGroupsChanged = true;
+            const remaining = group.nodeIds.filter((id) => id !== node.id);
+            if (remaining.length > 0)
+                prunedGroups.push({ ...group, nodeIds: remaining });
+        }
+        ctx.workflow.nodeGroups = prunedGroups;
+    }
+    return null;
+};
+const handleRenameNode = (op, ctx) => {
+    if (op.oldName === op.newName) {
+        return null;
+    }
+    if (!(0, n8n_workflow_1.isSafeObjectProperty)(op.newName)) {
+        return `node name '${op.newName}' is not allowed`;
+    }
+    const node = ctx.nodeByName.get(op.oldName);
+    if (!node) {
+        return `node '${op.oldName}' not found`;
+    }
+    if (ctx.nodeByName.has(op.newName)) {
+        return `a node named '${op.newName}' already exists`;
+    }
+    node.name = op.newName;
+    ctx.nodeByName.delete(op.oldName);
+    ctx.nodeByName.set(op.newName, node);
+    renameInConnections(ctx.workflow.connections, op.oldName, op.newName);
+    if (ctx.addedNodeNames.delete(op.oldName)) {
+        ctx.addedNodeNames.add(op.newName);
+    }
+    return null;
+};
+const handleAddConnection = (op, ctx) => {
+    if (!ctx.nodeByName.has(op.source)) {
+        return `source node '${op.source}' not found`;
+    }
+    if (!ctx.nodeByName.has(op.target)) {
+        return `target node '${op.target}' not found`;
+    }
+    const connectionType = (op.connectionType ?? n8n_workflow_1.NodeConnectionTypes.Main);
+    if (!(0, n8n_workflow_1.isSafeObjectProperty)(op.source) || !(0, n8n_workflow_1.isSafeObjectProperty)(connectionType)) {
+        return 'connection name is not allowed';
+    }
+    const sourceIndex = op.sourceIndex ?? 0;
+    const targetIndex = op.targetIndex ?? 0;
+    const slot = ensureOutputSlot(ctx.workflow.connections, op.source, connectionType, sourceIndex);
+    const exists = slot.some((c) => c.node === op.target && c.type === connectionType && c.index === targetIndex);
+    if (!exists)
+        slot.push({ node: op.target, type: connectionType, index: targetIndex });
+    return null;
+};
+const handleRemoveConnection = (op, ctx) => {
+    const connectionType = (op.connectionType ?? n8n_workflow_1.NodeConnectionTypes.Main);
+    const sourceIndex = op.sourceIndex ?? 0;
+    const targetIndex = op.targetIndex ?? 0;
+    const byType = ctx.workflow.connections[op.source];
+    const outputs = byType?.[connectionType];
+    const slot = outputs?.[sourceIndex];
+    if (!slot) {
+        return `no '${connectionType}' connection from '${op.source}'`;
+    }
+    const filtered = slot.filter((c) => !(c.node === op.target && c.type === connectionType && c.index === targetIndex));
+    if (filtered.length === slot.length) {
+        return `connection from '${op.source}'[${sourceIndex}] to '${op.target}'[${targetIndex}] does not exist`;
+    }
+    outputs[sourceIndex] = filtered;
+    pruneConnectionShape(ctx.workflow.connections, op.source, connectionType);
+    return null;
+};
+const handleSetNodeCredential = (op, ctx) => {
+    const node = ctx.nodeByName.get(op.nodeName);
+    if (!node) {
+        return `node '${op.nodeName}' not found`;
+    }
+    if (!(0, n8n_workflow_1.isSafeObjectProperty)(op.credentialKey)) {
+        return `credential key '${op.credentialKey}' is not allowed`;
+    }
+    node.credentials = {
+        ...(node.credentials ?? {}),
+        [op.credentialKey]: { id: op.credentialId, name: op.credentialName },
+    };
+    return null;
+};
+const handleSetNodePosition = (op, ctx) => {
+    const node = ctx.nodeByName.get(op.nodeName);
+    if (!node) {
+        return `node '${op.nodeName}' not found`;
+    }
+    node.position = op.position;
+    return null;
+};
+const handleSetNodeDisabled = (op, ctx) => {
+    const node = ctx.nodeByName.get(op.nodeName);
+    if (!node) {
+        return `node '${op.nodeName}' not found`;
+    }
+    node.disabled = op.disabled;
+    return null;
+};
+const handleSetNodeSettings = (op, ctx) => {
+    const node = ctx.nodeByName.get(op.nodeName);
+    if (!node) {
+        return `node '${op.nodeName}' not found`;
+    }
+    const s = op.settings;
+    if (s.onError !== undefined) {
+        node.onError = s.onError;
+    }
+    if (s.retryOnFail !== undefined) {
+        node.retryOnFail = s.retryOnFail;
+    }
+    if (s.maxTries !== undefined) {
+        node.maxTries = s.maxTries;
+    }
+    if (s.waitBetweenTries !== undefined) {
+        node.waitBetweenTries = s.waitBetweenTries;
+    }
+    if (s.alwaysOutputData !== undefined) {
+        node.alwaysOutputData = s.alwaysOutputData;
+    }
+    if (s.executeOnce !== undefined) {
+        node.executeOnce = s.executeOnce;
+    }
+    return null;
+};
+const handleSetWorkflowMetadata = (op, ctx) => {
+    if (op.name !== undefined) {
+        ctx.workflow.name = op.name;
+    }
+    if (op.description !== undefined) {
+        ctx.workflow.description = op.description;
+    }
+    return null;
+};
+const handleSetWorkflowSettings = (op, ctx) => {
+    ctx.workflow.settings = { ...(ctx.workflow.settings ?? {}), ...op.settings };
+    return null;
+};
+const handleSetNodeGroups = (op, ctx) => {
+    const nodeGroups = [];
+    for (const group of op.nodeGroups) {
+        const resolved = resolveGroupNodeIds(ctx.nodeByName, group.nodeNames, group.name);
+        if ('error' in resolved) {
+            return resolved.error;
+        }
+        const description = group.description?.trim();
+        nodeGroups.push({
+            id: group.id ?? (0, uuid_1.v4)(),
+            name: group.name,
+            nodeIds: resolved.nodeIds,
+            ...(description ? { description } : {}),
+        });
+    }
+    ctx.workflow.nodeGroups = nodeGroups;
+    ctx.nodeGroupsChanged = true;
+    return null;
+};
+const handleAddNodeGroup = (op, ctx) => {
+    const groups = ctx.workflow.nodeGroups ?? [];
+    if (groups.some((g) => g.name === op.name)) {
+        return `a node group named '${op.name}' already exists`;
+    }
+    if (op.id !== undefined && groups.some((g) => g.id === op.id)) {
+        return `a node group with id '${op.id}' already exists`;
+    }
+    const resolved = resolveGroupNodeIds(ctx.nodeByName, op.nodeNames, op.name);
+    if ('error' in resolved) {
+        return resolved.error;
+    }
+    const description = op.description?.trim();
+    groups.push({
+        id: op.id ?? (0, uuid_1.v4)(),
+        name: op.name,
+        nodeIds: resolved.nodeIds,
+        ...(description ? { description } : {}),
+    });
+    ctx.workflow.nodeGroups = groups;
+    ctx.nodeGroupsChanged = true;
+    return null;
+};
+const handleRemoveNodeGroup = (op, ctx) => {
+    const groups = ctx.workflow.nodeGroups ?? [];
+    const index = groups.findIndex((g) => g.name === op.groupName);
+    if (index === -1) {
+        return `node group '${op.groupName}' not found`;
+    }
+    groups.splice(index, 1);
+    ctx.workflow.nodeGroups = groups;
+    ctx.nodeGroupsChanged = true;
+    return null;
+};
+const handleUpdateNodeGroup = (op, ctx) => {
+    if (op.newName === undefined && op.nodeNames === undefined && op.description === undefined) {
+        return 'updateNodeGroup must specify at least one of newName, nodeNames, or description';
+    }
+    const groups = ctx.workflow.nodeGroups ?? [];
+    const group = groups.find((g) => g.name === op.groupName);
+    if (!group) {
+        return `node group '${op.groupName}' not found`;
+    }
+    if (op.nodeNames !== undefined) {
+        const resolved = resolveGroupNodeIds(ctx.nodeByName, op.nodeNames, op.groupName);
+        if ('error' in resolved) {
+            return resolved.error;
+        }
+        group.nodeIds = resolved.nodeIds;
+    }
+    if (op.newName !== undefined && op.newName !== group.name) {
+        if (groups.some((g) => g !== group && g.name === op.newName)) {
+            return `a node group named '${op.newName}' already exists`;
+        }
+        group.name = op.newName;
+    }
+    if (op.description !== undefined) {
+        const description = op.description.trim();
+        if (description) {
+            group.description = description;
+        }
+        else {
+            delete group.description;
+        }
+    }
+    ctx.nodeGroupsChanged = true;
+    return null;
+};
+const handleTagOp = (op, ctx) => {
+    if (ctx.workflow.tagNames === undefined) {
+        return 'tag operations require existing tags to be loaded';
+    }
+    ctx.tagSet ??= new Set(ctx.workflow.tagNames);
+    if (op.type === 'addTags') {
+        for (const name of op.names) {
+            ctx.tagSet.add(name);
+        }
+        return null;
+    }
+    for (const name of op.names) {
+        ctx.tagSet.delete(name);
+    }
+    return null;
+};
+const OPERATION_HANDLERS = {
+    updateNodeParameters: handleUpdateNodeParameters,
+    setNodeParameter: handleSetNodeParameter,
+    addNode: handleAddNode,
+    removeNode: handleRemoveNode,
+    renameNode: handleRenameNode,
+    addConnection: handleAddConnection,
+    removeConnection: handleRemoveConnection,
+    setNodeCredential: handleSetNodeCredential,
+    setNodePosition: handleSetNodePosition,
+    setNodeDisabled: handleSetNodeDisabled,
+    setNodeSettings: handleSetNodeSettings,
+    setWorkflowMetadata: handleSetWorkflowMetadata,
+    setWorkflowSettings: handleSetWorkflowSettings,
+    setNodeGroups: handleSetNodeGroups,
+    addNodeGroup: handleAddNodeGroup,
+    removeNodeGroup: handleRemoveNodeGroup,
+    updateNodeGroup: handleUpdateNodeGroup,
+    addTags: (op, ctx) => handleTagOp(op, ctx),
+    removeTags: (op, ctx) => handleTagOp(op, ctx),
+};
 function applyOperations(input, operations) {
     const workflow = cloneWorkflow(input);
-    const nodeByName = new Map(workflow.nodes.map((n) => [n.name, n]));
-    const addedNodeNames = new Set();
-    let tagSet = null;
+    const ctx = {
+        workflow,
+        nodeByName: new Map(workflow.nodes.map((n) => [n.name, n])),
+        addedNodeNames: new Set(),
+        tagSet: null,
+        nodeGroupsChanged: false,
+    };
     for (let i = 0; i < operations.length; i++) {
         const op = operations[i];
-        switch (op.type) {
-            case 'updateNodeParameters': {
-                const node = nodeByName.get(op.nodeName);
-                if (!node)
-                    return fail(i, `node '${op.nodeName}' not found`);
-                const sanitized = sanitizeUnsafeKeys(op.parameters);
-                const merged = op.replace
-                    ? sanitized
-                    : deepMerge((node.parameters ?? {}), sanitized);
-                node.parameters = merged;
-                break;
-            }
-            case 'setNodeParameter': {
-                const node = nodeByName.get(op.nodeName);
-                if (!node)
-                    return fail(i, `node '${op.nodeName}' not found`);
-                const segments = parseJsonPointer(op.path);
-                if (!segments) {
-                    return fail(i, `path '${op.path}' is invalid or contains unsafe segments`);
-                }
-                const params = (node.parameters ?? {});
-                const setError = setAtPointer(params, segments, op.value);
-                if (setError)
-                    return fail(i, setError);
-                node.parameters = params;
-                break;
-            }
-            case 'addNode': {
-                if (!(0, n8n_workflow_1.isSafeObjectProperty)(op.node.name)) {
-                    return fail(i, `node name '${op.node.name}' is not allowed`);
-                }
-                if (nodeByName.has(op.node.name)) {
-                    return fail(i, `a node named '${op.node.name}' already exists`);
-                }
-                const node = {
-                    id: op.node.id ?? (0, uuid_1.v4)(),
-                    name: op.node.name,
-                    type: op.node.type,
-                    typeVersion: op.node.typeVersion,
-                    position: op.node.position ?? [0, 0],
-                    parameters: (sanitizeUnsafeKeys(op.node.parameters ?? {}) ?? {}),
-                };
-                if (op.node.credentials) {
-                    const credentialEntries = [];
-                    for (const [key, cred] of Object.entries(op.node.credentials)) {
-                        if (!(0, n8n_workflow_1.isSafeObjectProperty)(key)) {
-                            return fail(i, `credential key '${key}' is not allowed`);
-                        }
-                        credentialEntries.push([key, { id: cred.id ?? null, name: cred.name }]);
-                    }
-                    node.credentials = Object.fromEntries(credentialEntries);
-                }
-                if (op.node.disabled !== undefined)
-                    node.disabled = op.node.disabled;
-                if (op.node.notes !== undefined)
-                    node.notes = op.node.notes;
-                workflow.nodes.push(node);
-                nodeByName.set(node.name, node);
-                addedNodeNames.add(node.name);
-                break;
-            }
-            case 'removeNode': {
-                const node = nodeByName.get(op.nodeName);
-                if (!node)
-                    return fail(i, `node '${op.nodeName}' not found`);
-                workflow.nodes.splice(workflow.nodes.indexOf(node), 1);
-                nodeByName.delete(op.nodeName);
-                removeConnectionsFor(workflow.connections, op.nodeName);
-                addedNodeNames.delete(op.nodeName);
-                break;
-            }
-            case 'renameNode': {
-                if (op.oldName === op.newName)
-                    break;
-                if (!(0, n8n_workflow_1.isSafeObjectProperty)(op.newName)) {
-                    return fail(i, `node name '${op.newName}' is not allowed`);
-                }
-                const node = nodeByName.get(op.oldName);
-                if (!node)
-                    return fail(i, `node '${op.oldName}' not found`);
-                if (nodeByName.has(op.newName)) {
-                    return fail(i, `a node named '${op.newName}' already exists`);
-                }
-                node.name = op.newName;
-                nodeByName.delete(op.oldName);
-                nodeByName.set(op.newName, node);
-                renameInConnections(workflow.connections, op.oldName, op.newName);
-                if (addedNodeNames.delete(op.oldName))
-                    addedNodeNames.add(op.newName);
-                break;
-            }
-            case 'addConnection': {
-                if (!nodeByName.has(op.source)) {
-                    return fail(i, `source node '${op.source}' not found`);
-                }
-                if (!nodeByName.has(op.target)) {
-                    return fail(i, `target node '${op.target}' not found`);
-                }
-                const connectionType = (op.connectionType ??
-                    n8n_workflow_1.NodeConnectionTypes.Main);
-                if (!(0, n8n_workflow_1.isSafeObjectProperty)(op.source) || !(0, n8n_workflow_1.isSafeObjectProperty)(connectionType)) {
-                    return fail(i, 'connection name is not allowed');
-                }
-                const sourceIndex = op.sourceIndex ?? 0;
-                const targetIndex = op.targetIndex ?? 0;
-                const slot = ensureOutputSlot(workflow.connections, op.source, connectionType, sourceIndex);
-                const exists = slot.some((c) => c.node === op.target && c.type === connectionType && c.index === targetIndex);
-                if (!exists) {
-                    slot.push({ node: op.target, type: connectionType, index: targetIndex });
-                }
-                break;
-            }
-            case 'removeConnection': {
-                const connectionType = (op.connectionType ??
-                    n8n_workflow_1.NodeConnectionTypes.Main);
-                const sourceIndex = op.sourceIndex ?? 0;
-                const targetIndex = op.targetIndex ?? 0;
-                const byType = workflow.connections[op.source];
-                const outputs = byType?.[connectionType];
-                const slot = outputs?.[sourceIndex];
-                if (!slot) {
-                    return fail(i, `no '${connectionType}' connection from '${op.source}'`);
-                }
-                const filtered = slot.filter((c) => !(c.node === op.target && c.type === connectionType && c.index === targetIndex));
-                if (filtered.length === slot.length) {
-                    return fail(i, `connection from '${op.source}'[${sourceIndex}] to '${op.target}'[${targetIndex}] does not exist`);
-                }
-                outputs[sourceIndex] = filtered;
-                pruneConnectionShape(workflow.connections, op.source, connectionType);
-                break;
-            }
-            case 'setNodeCredential': {
-                const node = nodeByName.get(op.nodeName);
-                if (!node)
-                    return fail(i, `node '${op.nodeName}' not found`);
-                if (!(0, n8n_workflow_1.isSafeObjectProperty)(op.credentialKey)) {
-                    return fail(i, `credential key '${op.credentialKey}' is not allowed`);
-                }
-                node.credentials = {
-                    ...(node.credentials ?? {}),
-                    [op.credentialKey]: { id: op.credentialId, name: op.credentialName },
-                };
-                break;
-            }
-            case 'setNodePosition': {
-                const node = nodeByName.get(op.nodeName);
-                if (!node)
-                    return fail(i, `node '${op.nodeName}' not found`);
-                node.position = op.position;
-                break;
-            }
-            case 'setNodeDisabled': {
-                const node = nodeByName.get(op.nodeName);
-                if (!node)
-                    return fail(i, `node '${op.nodeName}' not found`);
-                node.disabled = op.disabled;
-                break;
-            }
-            case 'setNodeSettings': {
-                const node = nodeByName.get(op.nodeName);
-                if (!node)
-                    return fail(i, `node '${op.nodeName}' not found`);
-                const s = op.settings;
-                if (s.onError !== undefined)
-                    node.onError = s.onError;
-                if (s.retryOnFail !== undefined)
-                    node.retryOnFail = s.retryOnFail;
-                if (s.maxTries !== undefined)
-                    node.maxTries = s.maxTries;
-                if (s.waitBetweenTries !== undefined)
-                    node.waitBetweenTries = s.waitBetweenTries;
-                if (s.alwaysOutputData !== undefined)
-                    node.alwaysOutputData = s.alwaysOutputData;
-                if (s.executeOnce !== undefined)
-                    node.executeOnce = s.executeOnce;
-                break;
-            }
-            case 'setWorkflowMetadata': {
-                if (op.name !== undefined)
-                    workflow.name = op.name;
-                if (op.description !== undefined)
-                    workflow.description = op.description;
-                break;
-            }
-            case 'setWorkflowSettings': {
-                workflow.settings = { ...(workflow.settings ?? {}), ...op.settings };
-                break;
-            }
-            case 'setNodeGroups': {
-                workflow.nodeGroups = op.nodeGroups.map((group) => {
-                    const description = group.description?.trim();
-                    return {
-                        id: group.id ?? (0, uuid_1.v4)(),
-                        name: group.name,
-                        nodeIds: [...group.nodeIds],
-                        ...(description ? { description } : {}),
-                    };
-                });
-                break;
-            }
-            case 'addTags':
-            case 'removeTags': {
-                if (workflow.tagNames === undefined) {
-                    return fail(i, 'tag operations require existing tags to be loaded');
-                }
-                if (tagSet === null)
-                    tagSet = new Set(workflow.tagNames);
-                if (op.type === 'addTags') {
-                    for (const name of op.names)
-                        tagSet.add(name);
-                }
-                else {
-                    for (const name of op.names)
-                        tagSet.delete(name);
-                }
-                break;
-            }
-            default: {
-                op;
-                return fail(i, 'unknown operation type');
-            }
+        const handler = OPERATION_HANDLERS[op.type];
+        const error = handler(op, ctx);
+        if (error) {
+            return fail(i, error);
         }
     }
-    if (tagSet !== null) {
-        workflow.tagNames = [...tagSet];
+    if (ctx.tagSet !== null) {
+        ctx.workflow.tagNames = [...ctx.tagSet];
     }
     return {
         success: true,
-        workflow,
-        addedNodeNames: [...addedNodeNames],
-        tagNames: tagSet !== null ? [...tagSet] : undefined,
+        workflow: ctx.workflow,
+        addedNodeNames: [...ctx.addedNodeNames],
+        tagNames: ctx.tagSet !== null ? [...ctx.tagSet] : undefined,
+        nodeGroupsChanged: ctx.nodeGroupsChanged,
     };
 }
 function toWorkflowSlice(workflow, options = {}) {