feat(editor): Connect workflows from MCP settings page

packages/@n8n/db/src/repositories/__tests__/workflow.repository.test.ts

@@ -309,11 +309,11 @@ describe('WorkflowRepository', () => {
 		});
 	});
 
-	describe('applyTriggerNodeTypeFilter', () => {
-		it('should left join activeVersion with addSelect and use COALESCE for PostgreSQL', async () => {
+	describe('applyTriggerNodeTypesFilter', () => {
+		it('should left join activeVersion with addSelect and use COALESCE for PostgreSQL with single trigger type', async () => {
 			const workflowIds = ['workflow1'];
 			const options = {
-				filter: { triggerNodeType: 'n8n-nodes-base.executeWorkflowTrigger' },
+				filter: { triggerNodeTypes: ['n8n-nodes-base.executeWorkflowTrigger'] },
 			};
 
 			await workflowRepository.getMany(workflowIds, options);
@@ -324,8 +324,35 @@ describe('WorkflowRepository', () => {
 			// Should use COALESCE to check activeVersion.nodes first, falling back to workflow.nodes
 			// PostgreSQL uses quoted identifiers
 			expect(queryBuilder.andWhere).toHaveBeenCalledWith(
-				'COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :triggerNodeType',
-				{ triggerNodeType: '%n8n-nodes-base.executeWorkflowTrigger%' },
+				'(COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :triggerNodeType0)',
+				{ triggerNodeType0: '%n8n-nodes-base.executeWorkflowTrigger%' },
+			);
+		});
+
+		it('should filter by multiple trigger types with OR condition for PostgreSQL', async () => {
+			const workflowIds = ['workflow1'];
+			const options = {
+				filter: {
+					triggerNodeTypes: [
+						'n8n-nodes-base.executeWorkflowTrigger',
+						'n8n-nodes-base.webhook',
+						'n8n-nodes-base.scheduleTrigger',
+					],
+				},
+			};
+
+			await workflowRepository.getMany(workflowIds, options);
+
+			expect(queryBuilder.leftJoin).toHaveBeenCalledWith('workflow.activeVersion', 'activeVersion');
+			expect(queryBuilder.addSelect).toHaveBeenCalledWith('activeVersion.versionId');
+			// Should use OR conditions for multiple trigger types
+			expect(queryBuilder.andWhere).toHaveBeenCalledWith(
+				'(COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :triggerNodeType0 OR COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :triggerNodeType1 OR COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :triggerNodeType2)',
+				{
+					triggerNodeType0: '%n8n-nodes-base.executeWorkflowTrigger%',
+					triggerNodeType1: '%n8n-nodes-base.webhook%',
+					triggerNodeType2: '%n8n-nodes-base.scheduleTrigger%',
+				},
 			);
 		});
 
@@ -343,7 +370,7 @@ describe('WorkflowRepository', () => {
 
 			const workflowIds = ['workflow1'];
 			const options = {
-				filter: { triggerNodeType: 'n8n-nodes-base.errorTrigger' },
+				filter: { triggerNodeTypes: ['n8n-nodes-base.errorTrigger'] },
 			};
 
 			await sqliteWorkflowRepository.getMany(workflowIds, options);
@@ -352,8 +379,38 @@ describe('WorkflowRepository', () => {
 			expect(queryBuilder.addSelect).toHaveBeenCalledWith('activeVersion.versionId');
 			// Should use COALESCE to check activeVersion.nodes first, falling back to workflow.nodes
 			expect(queryBuilder.andWhere).toHaveBeenCalledWith(
-				'COALESCE(activeVersion.nodes, workflow.nodes) LIKE :triggerNodeType',
-				{ triggerNodeType: '%n8n-nodes-base.errorTrigger%' },
+				'(COALESCE(activeVersion.nodes, workflow.nodes) LIKE :triggerNodeType0)',
+				{ triggerNodeType0: '%n8n-nodes-base.errorTrigger%' },
+			);
+		});
+
+		it('should filter by multiple trigger types with OR condition for SQLite', async () => {
+			const sqliteConfig = mockInstance(GlobalConfig, {
+				database: { type: 'sqlite' },
+			});
+			const sqliteWorkflowRepository = new WorkflowRepository(
+				entityManager.connection,
+				sqliteConfig,
+				folderRepository,
+				workflowHistoryRepository,
+			);
+			jest.spyOn(sqliteWorkflowRepository, 'createQueryBuilder').mockReturnValue(queryBuilder);
+
+			const workflowIds = ['workflow1'];
+			const options = {
+				filter: {
+					triggerNodeTypes: ['n8n-nodes-base.webhook', 'n8n-nodes-base.scheduleTrigger'],
+				},
+			};
+
+			await sqliteWorkflowRepository.getMany(workflowIds, options);
+
+			expect(queryBuilder.andWhere).toHaveBeenCalledWith(
+				'(COALESCE(activeVersion.nodes, workflow.nodes) LIKE :triggerNodeType0 OR COALESCE(activeVersion.nodes, workflow.nodes) LIKE :triggerNodeType1)',
+				{
+					triggerNodeType0: '%n8n-nodes-base.webhook%',
+					triggerNodeType1: '%n8n-nodes-base.scheduleTrigger%',
+				},
 			);
 		});
 
@@ -371,7 +428,7 @@ describe('WorkflowRepository', () => {
 
 			const workflowIds = ['workflow1'];
 			const options = {
-				filter: { triggerNodeType: 'n8n-nodes-base.executeWorkflowTrigger' },
+				filter: { triggerNodeTypes: ['n8n-nodes-base.executeWorkflowTrigger'] },
 			};
 
 			await mysqlWorkflowRepository.getMany(workflowIds, options);
@@ -380,8 +437,8 @@ describe('WorkflowRepository', () => {
 			expect(queryBuilder.addSelect).toHaveBeenCalledWith('activeVersion.versionId');
 			// Should use COALESCE to check activeVersion.nodes first, falling back to workflow.nodes
 			expect(queryBuilder.andWhere).toHaveBeenCalledWith(
-				'COALESCE(activeVersion.nodes, workflow.nodes) LIKE :triggerNodeType',
-				{ triggerNodeType: '%n8n-nodes-base.executeWorkflowTrigger%' },
+				'(COALESCE(activeVersion.nodes, workflow.nodes) LIKE :triggerNodeType0)',
+				{ triggerNodeType0: '%n8n-nodes-base.executeWorkflowTrigger%' },
 			);
 		});
 
@@ -396,7 +453,7 @@ describe('WorkflowRepository', () => {
 
 			const workflowIds = ['workflow1'];
 			const options = {
-				filter: { triggerNodeType: 'n8n-nodes-base.executeWorkflowTrigger' },
+				filter: { triggerNodeTypes: ['n8n-nodes-base.executeWorkflowTrigger'] },
 			};
 
 			await workflowRepository.getMany(workflowIds, options);
@@ -409,12 +466,12 @@ describe('WorkflowRepository', () => {
 
 			// But the filter should still be applied (with quoted identifiers for PostgreSQL)
 			expect(queryBuilder.andWhere).toHaveBeenCalledWith(
-				'COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :triggerNodeType',
-				{ triggerNodeType: '%n8n-nodes-base.executeWorkflowTrigger%' },
+				'(COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :triggerNodeType0)',
+				{ triggerNodeType0: '%n8n-nodes-base.executeWorkflowTrigger%' },
 			);
 		});
 
-		it('should not apply filter when triggerNodeType is not provided', async () => {
+		it('should not apply filter when triggerNodeTypes is not provided', async () => {
 			const workflowIds = ['workflow1'];
 			const options = {
 				filter: { query: 'test' },
@@ -428,10 +485,24 @@ describe('WorkflowRepository', () => {
 			expect(triggerFilterCalls).toHaveLength(0);
 		});
 
-		it('should not apply filter when triggerNodeType is undefined', async () => {
+		it('should not apply filter when triggerNodeTypes is undefined', async () => {
+			const workflowIds = ['workflow1'];
+			const options = {
+				filter: { triggerNodeTypes: undefined },
+			};
+
+			await workflowRepository.getMany(workflowIds, options);
+
+			const triggerFilterCalls = (queryBuilder.andWhere as jest.Mock).mock.calls.filter((call) =>
+				call[0]?.includes?.('triggerNodeType'),
+			);
+			expect(triggerFilterCalls).toHaveLength(0);
+		});
+
+		it('should not apply filter when triggerNodeTypes is empty array', async () => {
 			const workflowIds = ['workflow1'];
 			const options = {
-				filter: { triggerNodeType: undefined },
+				filter: { triggerNodeTypes: [] },
 			};
 
 			await workflowRepository.getMany(workflowIds, options);
@@ -447,14 +518,14 @@ describe('WorkflowRepository', () => {
 			const options = {
 				filter: {
 					query: 'workflow',
-					triggerNodeType: 'n8n-nodes-base.executeWorkflowTrigger',
+					triggerNodeTypes: ['n8n-nodes-base.executeWorkflowTrigger'],
 					active: true,
 				},
 			};
 
 			await workflowRepository.getMany(workflowIds, options);
 
-			// Should have called andWhere for both name and triggerNodeType filters
+			// Should have called andWhere for both name and triggerNodeTypes filters
 			const nameFilterCalls = (queryBuilder.andWhere as jest.Mock).mock.calls.filter((call) =>
 				call[0]?.includes?.('workflow.name'),
 			);

packages/@n8n/db/src/repositories/workflow.repository.ts

@@ -444,7 +444,7 @@ export class WorkflowRepository extends Repository<WorkflowEntity> {
 		const qb = this.createBaseQuery(workflowIds);
 
 		this.applyFilters(qb, options.filter);
-		this.applyTriggerNodeTypeFilter(qb, options.filter?.triggerNodeType as string | undefined);
+		this.applyTriggerNodeTypesFilter(qb, options.filter?.triggerNodeTypes as string[] | undefined);
 		this.applySelect(qb, options.select);
 		this.applyRelations(qb, options.select);
 		this.applySorting(qb, options.sortBy);
@@ -484,50 +484,81 @@ export class WorkflowRepository extends Repository<WorkflowEntity> {
 		if (typeof filter?.availableInMCP === 'boolean') {
 			const dbType = this.globalConfig.database.type;
 
-			if (['postgresdb'].includes(dbType)) {
-				qb.andWhere("workflow.settings ->> 'availableInMCP' = :availableInMCP", {
-					availableInMCP: filter.availableInMCP.toString(),
-				});
-			} else if (['mysqldb', 'mariadb'].includes(dbType)) {
-				qb.andWhere("JSON_EXTRACT(workflow.settings, '$.availableInMCP') = :availableInMCP", {
-					availableInMCP: filter.availableInMCP,
-				});
-			} else if (dbType === 'sqlite') {
-				qb.andWhere("JSON_EXTRACT(workflow.settings, '$.availableInMCP') = :availableInMCP", {
-					availableInMCP: filter.availableInMCP ? 1 : 0, // SQLite stores booleans as 0/1
-				});
+			if (filter.availableInMCP) {
+				// When filtering for true, only match explicit true values
+				if (['postgresdb'].includes(dbType)) {
+					qb.andWhere("workflow.settings ->> 'availableInMCP' = :availableInMCP", {
+						availableInMCP: 'true',
+					});
+				} else if (['mysqldb', 'mariadb'].includes(dbType)) {
+					qb.andWhere("JSON_EXTRACT(workflow.settings, '$.availableInMCP') = :availableInMCP", {
+						availableInMCP: true,
+					});
+				} else if (dbType === 'sqlite') {
+					qb.andWhere("JSON_EXTRACT(workflow.settings, '$.availableInMCP') = :availableInMCP", {
+						availableInMCP: 1, // SQLite stores booleans as 0/1
+					});
+				}
+			} else {
+				// When filtering for false, match explicit false OR null/undefined (field not set)
+				if (['postgresdb'].includes(dbType)) {
+					qb.andWhere(
+						"(workflow.settings ->> 'availableInMCP' = :availableInMCP OR workflow.settings ->> 'availableInMCP' IS NULL)",
+						{ availableInMCP: 'false' },
+					);
+				} else if (['mysqldb', 'mariadb'].includes(dbType)) {
+					qb.andWhere(
+						"(JSON_EXTRACT(workflow.settings, '$.availableInMCP') = :availableInMCP OR JSON_EXTRACT(workflow.settings, '$.availableInMCP') IS NULL)",
+						{ availableInMCP: false },
+					);
+				} else if (dbType === 'sqlite') {
+					qb.andWhere(
+						"(JSON_EXTRACT(workflow.settings, '$.availableInMCP') = :availableInMCP OR JSON_EXTRACT(workflow.settings, '$.availableInMCP') IS NULL)",
+						{ availableInMCP: 0 }, // SQLite stores booleans as 0/1
+					);
+				}
 			}
 		}
 	}
 
-	private applyTriggerNodeTypeFilter(
+	private applyTriggerNodeTypesFilter(
 		qb: SelectQueryBuilder<WorkflowEntity>,
-		triggerNodeType?: string,
+		triggerNodeTypes?: string[],
 	): void {
-		if (triggerNodeType) {
-			const dbType = this.globalConfig.database.type;
+		if (!triggerNodeTypes || triggerNodeTypes.length === 0) {
+			return;
+		}
 
-			// Left join the activeVersion relation if not already joined
-			// We must also addSelect to ensure TypeORM includes the join when using raw SQL in andWhere
-			if (!qb.expressionMap.aliases.find((alias) => alias.name === 'activeVersion')) {
-				qb.leftJoin('workflow.activeVersion', 'activeVersion').addSelect('activeVersion.versionId');
-			}
+		const dbType = this.globalConfig.database.type;
+
+		// Left join the activeVersion relation if not already joined
+		// We must also addSelect to ensure TypeORM includes the join when using raw SQL in andWhere
+		if (!qb.expressionMap.aliases.find((alias) => alias.name === 'activeVersion')) {
+			qb.leftJoin('workflow.activeVersion', 'activeVersion').addSelect('activeVersion.versionId');
+		}
+
+		// Build OR conditions for each trigger node type
+		const conditions: string[] = [];
+		const parameters: Record<string, string> = {};
+
+		triggerNodeTypes.forEach((triggerNodeType, index) => {
+			const paramName = `triggerNodeType${index}`;
+			parameters[paramName] = `%${triggerNodeType}%`;
 
 			// Use COALESCE to check activeVersion.nodes if exists (workflow is active),
 			// otherwise fall back to workflow.nodes (draft workflows)
 			// In PostgreSQL, cast JSON column to text for LIKE operator
 			if (['postgresdb'].includes(dbType)) {
-				qb.andWhere(
-					'COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :triggerNodeType',
-					{ triggerNodeType: `%${triggerNodeType}%` },
+				conditions.push(
+					`COALESCE("activeVersion"."nodes"::text, "workflow"."nodes"::text) LIKE :${paramName}`,
 				);
 			} else {
 				// SQLite and MySQL store nodes as text
-				qb.andWhere('COALESCE(activeVersion.nodes, workflow.nodes) LIKE :triggerNodeType', {
-					triggerNodeType: `%${triggerNodeType}%`,
-				});
+				conditions.push(`COALESCE(activeVersion.nodes, workflow.nodes) LIKE :${paramName}`);
 			}
-		}
+		});
+
+		qb.andWhere(`(${conditions.join(' OR ')})`, parameters);
 	}
 
 	/**

packages/cli/src/middlewares/list-query/dtos/workflow.filter.dto.ts

@@ -46,10 +46,11 @@ export class WorkflowFilter extends BaseFilter {
 	@Expose()
 	nodeTypes?: string[];
 
-	@IsString()
+	@IsArray()
+	@IsString({ each: true })
 	@IsOptional()
 	@Expose()
-	triggerNodeType?: string;
+	triggerNodeTypes?: string[];
 
 	static async fromString(rawFilter: string) {
 		return await this.toFilter(rawFilter, WorkflowFilter);

packages/cli/src/middlewares/list-query/filter.ts

@@ -19,7 +19,7 @@ export const filterListQueryMiddleware = async (
 
 	let Filter;
 
-	if (req.baseUrl.endsWith('workflows')) {
+	if (req.baseUrl.endsWith('workflows') || req.path.endsWith('workflows')) {
 		Filter = WorkflowFilter;
 	} else if (req.baseUrl.endsWith('credentials')) {
 		Filter = CredentialsFilter;

packages/cli/src/middlewares/list-query/select.ts

@@ -15,7 +15,7 @@ export const selectListQueryMiddleware: RequestHandler = (req: ListQuery.Request
 
 	let Select;
 
-	if (req.baseUrl.endsWith('workflows')) {
+	if (req.baseUrl.endsWith('workflows') || req.path.endsWith('workflows')) {
 		Select = WorkflowSelect;
 	} else if (req.baseUrl.endsWith('credentials')) {
 		Select = CredentialsSelect;

packages/cli/src/middlewares/list-query/sort-by.ts

@@ -17,7 +17,7 @@ export const sortByQueryMiddleware: RequestHandler = (req: ListQuery.Request, re
 	let SortBy;
 
 	try {
-		if (req.baseUrl.endsWith('workflows')) {
+		if (req.baseUrl.endsWith('workflows') || req.path.endsWith('workflows')) {
 			SortBy = WorkflowSorting;
 		} else {
 			return next();