@invect/core 0.0.1

package/dist/services/flow-runs/flow-runs.service.js

@@ -0,0 +1,273 @@
+import { DatabaseError, FlowNotFoundError } from "../../types/common/errors.types.js";
+//#region src/services/flow-runs/flow-runs.service.ts
+/**
+* Core Execution Service implementation using database models
+*/
+var FlowRunsService = class {
+	initialized = false;
+	eventBus = null;
+	constructor(logger, databaseService, flowService) {
+		this.logger = logger;
+		this.databaseService = databaseService;
+		this.flowService = flowService;
+	}
+	/** Attach the event bus so state changes are broadcast to SSE subscribers. */
+	setEventBus(bus) {
+		this.eventBus = bus;
+	}
+	/**
+	* Initialize the service
+	*/
+	async initialize() {
+		if (this.initialized) {
+			this.logger.debug("Execution service already initialized");
+			return;
+		}
+		try {
+			await this.flowService.initialize();
+			this.initialized = true;
+			this.logger.info("Execution service initialized successfully");
+		} catch (error) {
+			this.logger.error("Failed to initialize execution service", { error });
+			throw new DatabaseError("Failed to initialize execution service", { error });
+		}
+	}
+	/**
+	* Create a new flow run record
+	*/
+	async createFlowRun(data) {
+		this.logger.debug("Creating flow run record", {
+			flowId: data.flowId,
+			flowVersion: data.flowVersion
+		});
+		try {
+			const flowRun = await this.databaseService.flowRuns.create({
+				flowId: data.flowId,
+				flowVersion: data.flowVersion,
+				inputs: data.inputs,
+				createdBy: data.createdBy,
+				triggerType: data.triggerType,
+				triggerId: data.triggerId,
+				triggerNodeId: data.triggerNodeId,
+				triggerData: data.triggerData
+			});
+			this.logger.debug("Flow run created successfully", { flowRunId: flowRun.id });
+			this.eventBus?.emitFlowRunUpdate(flowRun);
+			return flowRun;
+		} catch (error) {
+			this.logger.error("Failed to create flow run", { error });
+			throw new DatabaseError("Failed to create flow run", { error });
+		}
+	}
+	/**
+	* Get execution by ID
+	*/
+	async getRunById(flowRunId) {
+		this.logger.debug("Retrieving execution by ID", { flowRunId });
+		try {
+			const execution = await this.databaseService.flowRuns.findById(flowRunId);
+			if (!execution) {
+				this.logger.warn("Execution not found", { flowRunId });
+				throw new FlowNotFoundError(`Execution with ID ${flowRunId} not found`);
+			}
+			this.logger.debug("Execution retrieved successfully", { flowRunId });
+			return execution;
+		} catch (error) {
+			if (error instanceof FlowNotFoundError) throw error;
+			this.logger.error("Failed to retrieve execution", {
+				flowRunId,
+				error
+			});
+			throw new DatabaseError("Failed to retrieve execution", { error });
+		}
+	}
+	/**
+	* Get flow executions
+	*/
+	async listRunsByFlowId(flowId) {
+		try {
+			return await this.databaseService.flowRuns.listRunsByFlowId(flowId);
+		} catch (error) {
+			this.logger.error("Failed to get flow executions", {
+				flowId,
+				error
+			});
+			throw new DatabaseError("Failed to get flow executions", { error });
+		}
+	}
+	/**
+	* Retry execution
+	*/
+	async retryRun(flowRunId) {
+		try {
+			await this.getRunById(flowRunId);
+			throw new DatabaseError("Retry execution not implemented - should be handled by orchestration service");
+		} catch (error) {
+			this.logger.error("Failed to retry execution", {
+				flowRunId,
+				error
+			});
+			throw new DatabaseError("Failed to retry execution", { error });
+		}
+	}
+	/**
+	* Get all executions with optional filtering and pagination
+	*/
+	async listRuns(options) {
+		try {
+			return await this.databaseService.flowRuns.findAll(options);
+		} catch (error) {
+			this.logger.error("Failed to retrieve executions", { error });
+			throw new DatabaseError("Failed to retrieve executions", { error });
+		}
+	}
+	/**
+	* Cancel execution
+	*/
+	async cancelRun(flowRunId) {
+		this.logger.info("Cancelling execution", { flowRunId });
+		try {
+			const execution = await this.getRunById(flowRunId);
+			if (execution.status === "SUCCESS" || execution.status === "FAILED" || execution.status === "CANCELLED") throw new DatabaseError(`Cannot cancel execution in ${execution.status} state`);
+			await this.databaseService.flowRuns.update(flowRunId, {
+				status: "CANCELLED",
+				completedAt: /* @__PURE__ */ new Date()
+			});
+			this.logger.info("Execution cancelled successfully", { flowRunId });
+			return {
+				message: "Execution cancelled",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		} catch (error) {
+			if (error instanceof FlowNotFoundError || error instanceof DatabaseError) throw error;
+			this.logger.error("Failed to cancel execution", {
+				flowRunId,
+				error
+			});
+			throw new DatabaseError("Failed to cancel execution", { error });
+		}
+	}
+	/**
+	* Pause execution
+	*/
+	async pauseRun(flowRunId, reason = "USER") {
+		this.logger.info("Pausing execution", {
+			flowRunId,
+			reason
+		});
+		try {
+			const execution = await this.getRunById(flowRunId);
+			if (execution.status !== "RUNNING") throw new DatabaseError(`Cannot pause execution in ${execution.status} state`);
+			await this.databaseService.flowRuns.update(flowRunId, { status: "PAUSED" });
+			this.logger.info("Execution paused successfully", {
+				flowRunId,
+				reason
+			});
+			return {
+				message: "Execution paused",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		} catch (error) {
+			if (error instanceof FlowNotFoundError || error instanceof DatabaseError) throw error;
+			this.logger.error("Failed to pause execution", {
+				flowRunId,
+				error
+			});
+			throw new DatabaseError("Failed to pause execution", { error });
+		}
+	}
+	/**
+	* Resume execution - COMPLETE IMPLEMENTATION
+	*/
+	async resumeRun(flowRunId) {
+		this.logger.info("Resuming execution", { flowRunId });
+		try {
+			const execution = await this.getRunById(flowRunId);
+			if (!["PAUSED", "PAUSED_FOR_BATCH"].includes(execution.status)) throw new DatabaseError(`Cannot resume execution in ${execution.status} state`);
+			await this.databaseService.flowRuns.update(flowRunId, { status: "RUNNING" });
+			if (execution.status === "PAUSED") {
+				if (!(await this.flowService.getFlowById(execution.flowId))?.flowVersion?.invectDefinition) throw new DatabaseError("Flow definition not found for resume");
+				this.logger.warn("Manual resume not fully implemented - requires orchestration service injection");
+			}
+			this.logger.info("Execution resumed successfully", { flowRunId });
+			return {
+				message: "Execution resumed",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		} catch (error) {
+			if (error instanceof FlowNotFoundError || error instanceof DatabaseError) throw error;
+			this.logger.error("Failed to resume execution", {
+				flowRunId,
+				error
+			});
+			throw new DatabaseError("Failed to resume execution", { error });
+		}
+	}
+	/**
+	* Update execution status
+	*/
+	async updateRunStatus(flowRunId, status, data) {
+		try {
+			this.logger.debug("Updating execution status", {
+				flowRunId,
+				status,
+				data
+			});
+			const updateInput = {
+				status,
+				completedAt: status !== "PENDING" && status !== "RUNNING" && status !== "PAUSED" ? /* @__PURE__ */ new Date() : void 0,
+				...data
+			};
+			const updatedExecution = await this.databaseService.flowRuns.update(flowRunId, updateInput);
+			this.logger.debug("Execution status updated successfully", {
+				flowRunId,
+				status: updatedExecution.status
+			});
+			this.eventBus?.emitFlowRunUpdate(updatedExecution);
+			return updatedExecution;
+		} catch (error) {
+			this.logger.error("Failed to update execution status", {
+				flowRunId,
+				status,
+				error
+			});
+			throw new DatabaseError("Failed to update execution status", { error });
+		}
+	}
+	/**
+	* Update heartbeat timestamp for a running flow.
+	* Called periodically by the execution coordinator.
+	*/
+	async updateHeartbeat(flowRunId) {
+		await this.databaseService.flowRuns.updateHeartbeat(flowRunId);
+	}
+	/**
+	* Find and fail stale flow runs whose heartbeat is older than the threshold.
+	* Returns the count of runs that were marked as FAILED.
+	*/
+	async failStaleRuns(thresholdMs) {
+		return this.databaseService.flowRuns.failStaleRuns(thresholdMs);
+	}
+	/**
+	* Get dashboard statistics: run counts by status, both total and within a time window.
+	*/
+	async getStats() {
+		const twentyFourHoursAgo = /* @__PURE__ */ new Date(Date.now() - 1440 * 60 * 1e3);
+		const [totalRuns, recentRuns] = await Promise.all([this.databaseService.flowRuns.countByStatus(), this.databaseService.flowRuns.countByStatus(twentyFourHoursAgo)]);
+		return {
+			totalRuns,
+			recentRuns
+		};
+	}
+	/**
+	* Close the service
+	*/
+	async close() {
+		this.logger.debug("Closing execution service");
+		this.initialized = false;
+	}
+};
+//#endregion
+export { FlowRunsService };
+
+//# sourceMappingURL=flow-runs.service.js.map

package/dist/services/flow-runs/flow-runs.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-runs.service.js","names":[],"sources":["../../../src/services/flow-runs/flow-runs.service.ts"],"sourcesContent":["import type { FlowsService } from '../flows/flows.service';\nimport type { DatabaseService } from '../database/database.service';\nimport { Logger, PaginatedResponse, QueryOptions } from 'src/types/schemas';\nimport { DatabaseError, FlowNotFoundError } from 'src/types/common/errors.types';\nimport { FlowRunStatus } from 'src/types/base';\n\nimport { NodeExecution } from '../node-executions/node-executions.model';\nimport { FlowRun, UpdateFlowRunInput } from './flow-runs.model';\nimport type { ExecutionEventBus } from '../execution-event-bus';\n\nexport interface FlowInputs {\n  [key: string]: unknown;\n}\n\nexport type FlowRunResult = {\n  status: FlowRunStatus;\n  flowRunId: string;\n  startedAt: Date;\n  error?: string;\n  metadata?: Record<string, unknown>;\n  completedAt?: Date;\n  duration?: number;\n  outputs?: Record<string, unknown>;\n  /** Per-node error messages keyed by nodeId (only present when nodes failed) */\n  nodeErrors?: Record<string, string>;\n  inputs?: Record<string, unknown>;\n  traces: NodeExecution[];\n};\n\nexport type ExecuteFlowOptions = {\n  version?: number | 'latest';\n  initiatedBy?: string;\n  useBatchProcessing?: boolean;\n};\n\n/**\n * Core Execution Service implementation using database models\n */\nexport class FlowRunsService {\n  private initialized: boolean = false;\n\n  private eventBus: ExecutionEventBus | null = null;\n\n  constructor(\n    private readonly logger: Logger,\n    private readonly databaseService: DatabaseService,\n    private readonly flowService: FlowsService,\n  ) {}\n\n  /** Attach the event bus so state changes are broadcast to SSE subscribers. */\n  setEventBus(bus: ExecutionEventBus): void {\n    this.eventBus = bus;\n  }\n\n  /**\n   * Initialize the service\n   */\n  async initialize(): Promise<void> {\n    if (this.initialized) {\n      this.logger.debug('Execution service already initialized');\n      return;\n    }\n\n    try {\n      // Ensure database service is initialized\n      await this.flowService.initialize();\n      this.initialized = true;\n      this.logger.info('Execution service initialized successfully');\n    } catch (error) {\n      this.logger.error('Failed to initialize execution service', { error });\n      throw new DatabaseError('Failed to initialize execution service', { error });\n    }\n  }\n\n  /**\n   * Create a new flow run record\n   */\n  async createFlowRun(data: {\n    flowId: string;\n    flowVersion: number;\n    inputs: FlowInputs;\n    createdBy?: string;\n    // Trigger provenance (populated when started via webhook/cron)\n    triggerType?: string;\n    triggerId?: string;\n    triggerNodeId?: string;\n    triggerData?: Record<string, unknown>;\n  }): Promise<FlowRun> {\n    this.logger.debug('Creating flow run record', {\n      flowId: data.flowId,\n      flowVersion: data.flowVersion,\n    });\n\n    try {\n      const flowRun = await this.databaseService.flowRuns.create({\n        flowId: data.flowId,\n        flowVersion: data.flowVersion,\n        inputs: data.inputs,\n        createdBy: data.createdBy,\n        triggerType: data.triggerType,\n        triggerId: data.triggerId,\n        triggerNodeId: data.triggerNodeId,\n        triggerData: data.triggerData,\n      });\n\n      this.logger.debug('Flow run created successfully', { flowRunId: flowRun.id });\n      this.eventBus?.emitFlowRunUpdate(flowRun);\n      return flowRun;\n    } catch (error) {\n      this.logger.error('Failed to create flow run', { error });\n      throw new DatabaseError('Failed to create flow run', { error });\n    }\n  }\n\n  /**\n   * Get execution by ID\n   */\n  async getRunById(flowRunId: string): Promise<FlowRun> {\n    this.logger.debug('Retrieving execution by ID', { flowRunId });\n\n    try {\n      const execution = await this.databaseService.flowRuns.findById(flowRunId);\n\n      if (!execution) {\n        this.logger.warn('Execution not found', { flowRunId });\n        throw new FlowNotFoundError(`Execution with ID ${flowRunId} not found`);\n      }\n\n      this.logger.debug('Execution retrieved successfully', { flowRunId });\n      return execution;\n    } catch (error) {\n      if (error instanceof FlowNotFoundError) {\n        throw error;\n      }\n      this.logger.error('Failed to retrieve execution', { flowRunId, error });\n      throw new DatabaseError('Failed to retrieve execution', { error });\n    }\n  }\n\n  /**\n   * Get flow executions\n   */\n  async listRunsByFlowId(flowId: string): Promise<FlowRun[]> {\n    try {\n      const executions = await this.databaseService.flowRuns.listRunsByFlowId(flowId);\n      return executions;\n    } catch (error) {\n      this.logger.error('Failed to get flow executions', { flowId, error });\n      throw new DatabaseError('Failed to get flow executions', { error });\n    }\n  }\n\n  /**\n   * Retry execution\n   */\n  async retryRun(flowRunId: string) {\n    try {\n      const _execution = await this.getRunById(flowRunId);\n\n      // TODO: This should delegate to the orchestration service\n      // For now, return the execution as-is\n      throw new DatabaseError(\n        'Retry execution not implemented - should be handled by orchestration service',\n      );\n    } catch (error) {\n      this.logger.error('Failed to retry execution', { flowRunId, error });\n      throw new DatabaseError('Failed to retry execution', { error });\n    }\n  }\n\n  /**\n   * Get all executions with optional filtering and pagination\n   */\n  async listRuns(options?: QueryOptions<FlowRun>): Promise<PaginatedResponse<FlowRun>> {\n    try {\n      return await this.databaseService.flowRuns.findAll(options);\n    } catch (error) {\n      this.logger.error('Failed to retrieve executions', { error });\n      throw new DatabaseError('Failed to retrieve executions', { error });\n    }\n  }\n\n  /**\n   * Cancel execution\n   */\n  async cancelRun(flowRunId: string): Promise<{ message: string; timestamp: string }> {\n    this.logger.info('Cancelling execution', { flowRunId });\n\n    try {\n      // First check if execution exists and can be cancelled\n      const execution = await this.getRunById(flowRunId);\n\n      if (\n        execution.status === 'SUCCESS' ||\n        execution.status === 'FAILED' ||\n        execution.status === 'CANCELLED'\n      ) {\n        throw new DatabaseError(`Cannot cancel execution in ${execution.status} state`);\n      }\n\n      await this.databaseService.flowRuns.update(flowRunId, {\n        status: 'CANCELLED' as FlowRunStatus,\n        completedAt: new Date(),\n      } as UpdateFlowRunInput);\n\n      this.logger.info('Execution cancelled successfully', { flowRunId });\n\n      return {\n        message: 'Execution cancelled',\n        timestamp: new Date().toISOString(),\n      };\n    } catch (error) {\n      if (error instanceof FlowNotFoundError || error instanceof DatabaseError) {\n        throw error;\n      }\n      this.logger.error('Failed to cancel execution', { flowRunId, error });\n      throw new DatabaseError('Failed to cancel execution', { error });\n    }\n  }\n\n  /**\n   * Pause execution\n   */\n  async pauseRun(\n    flowRunId: string,\n    reason: string = 'USER',\n  ): Promise<{ message: string; timestamp: string }> {\n    this.logger.info('Pausing execution', { flowRunId, reason });\n\n    try {\n      // First check if execution exists and can be paused\n      const execution = await this.getRunById(flowRunId);\n\n      if (execution.status !== 'RUNNING') {\n        throw new DatabaseError(`Cannot pause execution in ${execution.status} state`);\n      }\n\n      await this.databaseService.flowRuns.update(flowRunId, {\n        status: 'PAUSED' as FlowRunStatus,\n        // Note: pausedAt and pauseReason would need to be added to schema if needed\n      } as UpdateFlowRunInput);\n\n      this.logger.info('Execution paused successfully', { flowRunId, reason });\n\n      return {\n        message: 'Execution paused',\n        timestamp: new Date().toISOString(),\n      };\n    } catch (error) {\n      if (error instanceof FlowNotFoundError || error instanceof DatabaseError) {\n        throw error;\n      }\n      this.logger.error('Failed to pause execution', { flowRunId, error });\n      throw new DatabaseError('Failed to pause execution', { error });\n    }\n  }\n\n  /**\n   * Resume execution - COMPLETE IMPLEMENTATION\n   */\n  async resumeRun(flowRunId: string): Promise<{ message: string; timestamp: string }> {\n    this.logger.info('Resuming execution', { flowRunId });\n\n    try {\n      // Get execution and validate state\n      const execution = await this.getRunById(flowRunId);\n\n      // Check if execution can be resumed\n      if (!['PAUSED', 'PAUSED_FOR_BATCH'].includes(execution.status)) {\n        throw new DatabaseError(`Cannot resume execution in ${execution.status} state`);\n      }\n\n      // Update database status to RUNNING\n      await this.databaseService.flowRuns.update(flowRunId, {\n        status: 'RUNNING' as FlowRunStatus,\n      } as UpdateFlowRunInput);\n\n      // For manual pause, restart orchestration (PAUSED_FOR_BATCH handled automatically)\n      if (execution.status === 'PAUSED') {\n        // Get flow definition for resumption\n        const flow = await this.flowService.getFlowById(execution.flowId);\n\n        if (!flow?.flowVersion?.invectDefinition) {\n          throw new DatabaseError('Flow definition not found for resume');\n        }\n\n        // Resume execution through orchestration\n        // TODO: Need to inject orchestration service or implement resume logic differently\n        this.logger.warn(\n          'Manual resume not fully implemented - requires orchestration service injection',\n        );\n      }\n\n      // Log successful resume\n      this.logger.info('Execution resumed successfully', { flowRunId });\n\n      // Return success response\n      return {\n        message: 'Execution resumed',\n        timestamp: new Date().toISOString(),\n      };\n    } catch (error) {\n      // Handle resume errors\n      if (error instanceof FlowNotFoundError || error instanceof DatabaseError) {\n        throw error;\n      }\n      this.logger.error('Failed to resume execution', { flowRunId, error });\n      throw new DatabaseError('Failed to resume execution', { error });\n    }\n  }\n\n  /**\n   * Update execution status\n   */\n  async updateRunStatus(\n    flowRunId: string,\n    status: FlowRunStatus,\n    data?: {\n      outputs?: Record<string, unknown>;\n      error?: string;\n    },\n  ): Promise<FlowRun> {\n    try {\n      this.logger.debug('Updating execution status', { flowRunId, status, data });\n\n      const updateInput: UpdateFlowRunInput = {\n        status,\n        completedAt:\n          status !== 'PENDING' && status !== 'RUNNING' && status !== 'PAUSED'\n            ? new Date()\n            : undefined,\n        ...data,\n      };\n\n      const updatedExecution = await this.databaseService.flowRuns.update(flowRunId, updateInput);\n\n      this.logger.debug('Execution status updated successfully', {\n        flowRunId,\n        status: updatedExecution.status,\n      });\n      this.eventBus?.emitFlowRunUpdate(updatedExecution);\n      return updatedExecution;\n    } catch (error) {\n      this.logger.error('Failed to update execution status', { flowRunId, status, error });\n      throw new DatabaseError('Failed to update execution status', { error });\n    }\n  }\n\n  /**\n   * Update heartbeat timestamp for a running flow.\n   * Called periodically by the execution coordinator.\n   */\n  async updateHeartbeat(flowRunId: string): Promise<void> {\n    await this.databaseService.flowRuns.updateHeartbeat(flowRunId);\n  }\n\n  /**\n   * Find and fail stale flow runs whose heartbeat is older than the threshold.\n   * Returns the count of runs that were marked as FAILED.\n   */\n  async failStaleRuns(thresholdMs: number): Promise<number> {\n    return this.databaseService.flowRuns.failStaleRuns(thresholdMs);\n  }\n\n  /**\n   * Get dashboard statistics: run counts by status, both total and within a time window.\n   */\n  async getStats(): Promise<{\n    totalRuns: Record<string, number>;\n    recentRuns: Record<string, number>;\n  }> {\n    const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);\n    const [totalRuns, recentRuns] = await Promise.all([\n      this.databaseService.flowRuns.countByStatus(),\n      this.databaseService.flowRuns.countByStatus(twentyFourHoursAgo),\n    ]);\n    return { totalRuns, recentRuns };\n  }\n\n  /**\n   * Close the service\n   */\n  async close(): Promise<void> {\n    this.logger.debug('Closing execution service');\n    this.initialized = false;\n    // Database service lifecycle is managed externally\n  }\n}\n"],"mappings":"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"}

package/dist/services/flow-validator.cjs

@@ -0,0 +1,149 @@
+const require_graph_service = require("./graph.service.cjs");
+const require_validation = require("../types/validation.cjs");
+//#region src/services/flow-validator.ts
+/**
+* Checks whether a node type is an entry point (receives external data, not flow data).
+* Entry points: trigger actions and legacy core.input / INPUT nodes.
+*/
+function isEntryPointNode(nodeType) {
+	return nodeType === "INPUT" || nodeType === "core.input" || nodeType.startsWith("trigger.");
+}
+/**
+* Static flow validator.
+*
+* Designed to help an agent (or user) verify that a flow definition will
+* execute correctly. This does NOT prevent saving — it only reports issues.
+*
+* Errors  = the flow WILL fail at execution time (topological sort throws, etc.)
+* Warnings = the flow will run but something looks unintentional.
+*/
+var FlowValidator = class {
+	static validateFlowDefinition(flowDefinition) {
+		try {
+			const context = new require_validation.ValidationContext(flowDefinition, this.analyzeGraph(flowDefinition.nodes, flowDefinition.edges));
+			this.validateNotEmpty(context);
+			this.validateEdgeReferences(context);
+			this.validateNoSelfReferences(context);
+			this.validateNoDuplicateEdges(context);
+			this.validateNoCycles(context);
+			this.validateEntryPoints(context);
+			this.validateNoDisconnectedNodes(context);
+			this.validateSingleManualTrigger(context);
+			return this.buildResult(context);
+		} catch (error) {
+			return {
+				isValid: false,
+				errors: [{
+					severity: "error",
+					type: "VALIDATION_SYSTEM_ERROR",
+					message: `Validation system error: ${error instanceof Error ? error.message : "Unknown error"}`
+				}],
+				warnings: []
+			};
+		}
+	}
+	static analyzeGraph(nodes, edges) {
+		const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+		const edgeMap = new Map(edges.map((e) => [e.id, e]));
+		const incomingEdges = /* @__PURE__ */ new Map();
+		const outgoingEdges = /* @__PURE__ */ new Map();
+		for (const node of nodes) {
+			incomingEdges.set(node.id, require_graph_service.GraphService.getIncomingEdges(node.id, edges));
+			outgoingEdges.set(node.id, require_graph_service.GraphService.getOutgoingEdges(node.id, edges));
+		}
+		return {
+			nodeMap,
+			edgeMap,
+			incomingEdges,
+			outgoingEdges
+		};
+	}
+	static validateNotEmpty(context) {
+		if (context.definition.nodes.length === 0) context.addWarning("EMPTY_FLOW", "Flow has no nodes");
+	}
+	static validateEdgeReferences(context) {
+		const { nodeMap } = context.analysis;
+		for (const edge of context.definition.edges) {
+			if (!nodeMap.has(edge.source)) context.addError("INVALID_EDGE_REFERENCE", "Edge references non-existent source node", {
+				edgeId: edge.id,
+				sourceNodeId: edge.source,
+				targetNodeId: edge.target
+			});
+			if (!nodeMap.has(edge.target)) context.addError("INVALID_EDGE_REFERENCE", "Edge references non-existent target node", {
+				edgeId: edge.id,
+				sourceNodeId: edge.source,
+				targetNodeId: edge.target
+			});
+		}
+	}
+	static validateNoSelfReferences(context) {
+		for (const edge of context.definition.edges) if (edge.source === edge.target) context.addError("SELF_REFERENCING_EDGE", "Edge connects a node to itself", {
+			edgeId: edge.id,
+			nodeId: edge.source
+		});
+	}
+	static validateNoDuplicateEdges(context) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const edge of context.definition.edges) {
+			const key = `${edge.source}:${edge.sourceHandle ?? ""}→${edge.target}:${edge.targetHandle ?? ""}`;
+			if (seen.has(key)) context.addWarning("DUPLICATE_EDGE", "Duplicate connection between the same nodes", {
+				edgeId: edge.id,
+				sourceNodeId: edge.source,
+				targetNodeId: edge.target
+			});
+			seen.add(key);
+		}
+	}
+	static validateNoCycles(context) {
+		const { nodes, edges } = context.definition;
+		const result = require_graph_service.GraphService.hasCycleDetection(nodes, edges);
+		if (result.hasCycle && result.cyclePath) context.addError("CIRCULAR_DEPENDENCY", "Flow contains a cycle and cannot be executed", { additionalContext: {
+			cyclePath: result.cyclePath,
+			involvedNodeIds: result.cyclePath.slice(0, -1)
+		} });
+	}
+	static validateEntryPoints(context) {
+		const { incomingEdges } = context.analysis;
+		for (const node of context.definition.nodes) {
+			if (!isEntryPointNode(node.type)) continue;
+			const incoming = incomingEdges.get(node.id) || [];
+			if (incoming.length > 0) context.addWarning("ENTRY_NODE_HAS_INCOMING_EDGES", `${node.label || node.type} is an entry-point node and should not have incoming connections`, {
+				nodeId: node.id,
+				sourceNodeType: node.type,
+				additionalContext: { incomingEdgeCount: incoming.length }
+			});
+		}
+	}
+	static validateNoDisconnectedNodes(context) {
+		const { incomingEdges, outgoingEdges } = context.analysis;
+		if (context.definition.nodes.length < 2) return;
+		for (const node of context.definition.nodes) {
+			const incoming = incomingEdges.get(node.id) || [];
+			const outgoing = outgoingEdges.get(node.id) || [];
+			if (incoming.length === 0 && outgoing.length === 0) context.addWarning("DISCONNECTED_NODE", "Node has no connections to other nodes", {
+				nodeId: node.id,
+				sourceNodeType: node.type
+			});
+		}
+	}
+	static validateSingleManualTrigger(context) {
+		const manualTriggers = context.definition.nodes.filter((n) => n.type === "trigger.manual");
+		if (manualTriggers.length > 1) context.addError("MULTIPLE_MANUAL_TRIGGERS", `Only one Manual Trigger is allowed per flow, but ${manualTriggers.length} were found`, { additionalContext: { triggerNodeIds: manualTriggers.map((n) => n.id) } });
+	}
+	static buildResult(context) {
+		const warnings = context.issues.filter((i) => i.severity === "warning");
+		if (context.hasErrors()) return {
+			isValid: false,
+			errors: context.issues.filter((i) => i.severity === "error"),
+			warnings
+		};
+		return {
+			isValid: true,
+			warnings: warnings.length > 0 ? warnings : void 0
+		};
+	}
+};
+//#endregion
+exports.FlowValidator = FlowValidator;
+
+//# sourceMappingURL=flow-validator.cjs.map

package/dist/services/flow-validator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-validator.cjs","names":["ValidationContext","GraphService"],"sources":["../../src/services/flow-validator.ts"],"sourcesContent":["import {\n  FlowValidationResult,\n  ValidationContext,\n  GraphAnalysis,\n  FlowValidationError,\n  FlowValidationWarning,\n} from '../types/validation';\nimport { InvectDefinition, FlowNodeDefinitions, FlowEdge } from './flow-versions/schemas-fresh';\nimport { GraphService } from './graph.service';\n\n/**\n * Checks whether a node type is an entry point (receives external data, not flow data).\n * Entry points: trigger actions and legacy core.input / INPUT nodes.\n */\nfunction isEntryPointNode(nodeType: string): boolean {\n  return nodeType === 'INPUT' || nodeType === 'core.input' || nodeType.startsWith('trigger.');\n}\n\n/**\n * Static flow validator.\n *\n * Designed to help an agent (or user) verify that a flow definition will\n * execute correctly. This does NOT prevent saving — it only reports issues.\n *\n * Errors  = the flow WILL fail at execution time (topological sort throws, etc.)\n * Warnings = the flow will run but something looks unintentional.\n */\nexport class FlowValidator {\n  static validateFlowDefinition(flowDefinition: InvectDefinition): FlowValidationResult {\n    try {\n      const context = new ValidationContext(\n        flowDefinition,\n        this.analyzeGraph(flowDefinition.nodes, flowDefinition.edges),\n      );\n\n      // Phase 1: Empty flow\n      this.validateNotEmpty(context);\n\n      // Phase 2: Edge integrity — edges must reference existing nodes\n      this.validateEdgeReferences(context);\n\n      // Phase 3: Self-referencing edges (source === target)\n      this.validateNoSelfReferences(context);\n\n      // Phase 4: Duplicate edges (same source→target on same handles)\n      this.validateNoDuplicateEdges(context);\n\n      // Phase 5: Cycle detection — cycles make topological sort throw\n      this.validateNoCycles(context);\n\n      // Phase 6: Entry-point nodes should not have incoming edges\n      this.validateEntryPoints(context);\n\n      // Phase 7: Completely disconnected nodes (zero edges)\n      this.validateNoDisconnectedNodes(context);\n\n      // Phase 8: Single manual trigger per flow\n      this.validateSingleManualTrigger(context);\n\n      return this.buildResult(context);\n    } catch (error) {\n      return {\n        isValid: false,\n        errors: [\n          {\n            severity: 'error' as const,\n            type: 'VALIDATION_SYSTEM_ERROR',\n            message: `Validation system error: ${error instanceof Error ? error.message : 'Unknown error'}`,\n          },\n        ],\n        warnings: [],\n      };\n    }\n  }\n\n  // ─── Graph analysis ──────────────────────────────────────────────────────────\n\n  private static analyzeGraph(\n    nodes: readonly FlowNodeDefinitions[],\n    edges: readonly FlowEdge[],\n  ): GraphAnalysis {\n    const nodeMap = new Map(nodes.map((n) => [n.id, n]));\n    const edgeMap = new Map(edges.map((e) => [e.id, e]));\n    const incomingEdges = new Map<string, FlowEdge[]>();\n    const outgoingEdges = new Map<string, FlowEdge[]>();\n\n    for (const node of nodes) {\n      incomingEdges.set(node.id, GraphService.getIncomingEdges(node.id, edges));\n      outgoingEdges.set(node.id, GraphService.getOutgoingEdges(node.id, edges));\n    }\n\n    return { nodeMap, edgeMap, incomingEdges, outgoingEdges };\n  }\n\n  // ─── Phase 1: Empty flow ────────────────────────────────────────────────────\n\n  private static validateNotEmpty(context: ValidationContext): void {\n    if (context.definition.nodes.length === 0) {\n      context.addWarning('EMPTY_FLOW', 'Flow has no nodes');\n    }\n  }\n\n  // ─── Phase 2: Edge references ───────────────────────────────────────────────\n\n  private static validateEdgeReferences(context: ValidationContext): void {\n    const { nodeMap } = context.analysis;\n\n    for (const edge of context.definition.edges) {\n      if (!nodeMap.has(edge.source)) {\n        context.addError('INVALID_EDGE_REFERENCE', 'Edge references non-existent source node', {\n          edgeId: edge.id,\n          sourceNodeId: edge.source,\n          targetNodeId: edge.target,\n        });\n      }\n      if (!nodeMap.has(edge.target)) {\n        context.addError('INVALID_EDGE_REFERENCE', 'Edge references non-existent target node', {\n          edgeId: edge.id,\n          sourceNodeId: edge.source,\n          targetNodeId: edge.target,\n        });\n      }\n    }\n  }\n\n  // ─── Phase 3: Self-referencing edges ────────────────────────────────────────\n\n  private static validateNoSelfReferences(context: ValidationContext): void {\n    for (const edge of context.definition.edges) {\n      if (edge.source === edge.target) {\n        context.addError('SELF_REFERENCING_EDGE', 'Edge connects a node to itself', {\n          edgeId: edge.id,\n          nodeId: edge.source,\n        });\n      }\n    }\n  }\n\n  // ─── Phase 4: Duplicate edges ───────────────────────────────────────────────\n\n  private static validateNoDuplicateEdges(context: ValidationContext): void {\n    const seen = new Set<string>();\n\n    for (const edge of context.definition.edges) {\n      // Include handles so parallel edges on different output ports are allowed\n      const key = `${edge.source}:${edge.sourceHandle ?? ''}→${edge.target}:${edge.targetHandle ?? ''}`;\n      if (seen.has(key)) {\n        context.addWarning('DUPLICATE_EDGE', 'Duplicate connection between the same nodes', {\n          edgeId: edge.id,\n          sourceNodeId: edge.source,\n          targetNodeId: edge.target,\n        });\n      }\n      seen.add(key);\n    }\n  }\n\n  // ─── Phase 5: Cycle detection ───────────────────────────────────────────────\n\n  private static validateNoCycles(context: ValidationContext): void {\n    const { nodes, edges } = context.definition;\n    const result = GraphService.hasCycleDetection(nodes, edges);\n\n    if (result.hasCycle && result.cyclePath) {\n      context.addError('CIRCULAR_DEPENDENCY', 'Flow contains a cycle and cannot be executed', {\n        additionalContext: {\n          cyclePath: result.cyclePath,\n          involvedNodeIds: result.cyclePath.slice(0, -1),\n        },\n      });\n    }\n  }\n\n  // ─── Phase 6: Entry-point nodes ─────────────────────────────────────────────\n\n  private static validateEntryPoints(context: ValidationContext): void {\n    const { incomingEdges } = context.analysis;\n\n    for (const node of context.definition.nodes) {\n      if (!isEntryPointNode(node.type)) {\n        continue;\n      }\n\n      const incoming = incomingEdges.get(node.id) || [];\n      if (incoming.length > 0) {\n        context.addWarning(\n          'ENTRY_NODE_HAS_INCOMING_EDGES',\n          `${node.label || node.type} is an entry-point node and should not have incoming connections`,\n          {\n            nodeId: node.id,\n            sourceNodeType: node.type,\n            additionalContext: {\n              incomingEdgeCount: incoming.length,\n            },\n          },\n        );\n      }\n    }\n  }\n\n  // ─── Phase 7: Disconnected nodes ────────────────────────────────────────────\n\n  private static validateNoDisconnectedNodes(context: ValidationContext): void {\n    const { incomingEdges, outgoingEdges } = context.analysis;\n\n    // Only meaningful when there are at least 2 nodes\n    if (context.definition.nodes.length < 2) {\n      return;\n    }\n\n    for (const node of context.definition.nodes) {\n      const incoming = incomingEdges.get(node.id) || [];\n      const outgoing = outgoingEdges.get(node.id) || [];\n\n      if (incoming.length === 0 && outgoing.length === 0) {\n        context.addWarning('DISCONNECTED_NODE', 'Node has no connections to other nodes', {\n          nodeId: node.id,\n          sourceNodeType: node.type,\n        });\n      }\n    }\n  }\n\n  // ─── Phase 8: Single manual trigger ─────────────────────────────────────────\n\n  private static validateSingleManualTrigger(context: ValidationContext): void {\n    const manualTriggers = context.definition.nodes.filter((n) => n.type === 'trigger.manual');\n\n    if (manualTriggers.length > 1) {\n      context.addError(\n        'MULTIPLE_MANUAL_TRIGGERS',\n        `Only one Manual Trigger is allowed per flow, but ${manualTriggers.length} were found`,\n        {\n          additionalContext: {\n            triggerNodeIds: manualTriggers.map((n) => n.id),\n          },\n        },\n      );\n    }\n  }\n\n  // ─── Result builder ─────────────────────────────────────────────────────────\n\n  private static buildResult(context: ValidationContext): FlowValidationResult {\n    const warnings = context.issues.filter(\n      (i) => i.severity === 'warning',\n    ) as FlowValidationWarning[];\n\n    if (context.hasErrors()) {\n      return {\n        isValid: false,\n        errors: context.issues.filter((i) => i.severity === 'error') as FlowValidationError[],\n        warnings,\n      };\n    }\n\n    return {\n      isValid: true,\n      warnings: warnings.length > 0 ? warnings : undefined,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/services/flow-validator.js

@@ -0,0 +1,149 @@
+import { GraphService } from "./graph.service.js";
+import { ValidationContext } from "../types/validation.js";
+//#region src/services/flow-validator.ts
+/**
+* Checks whether a node type is an entry point (receives external data, not flow data).
+* Entry points: trigger actions and legacy core.input / INPUT nodes.
+*/
+function isEntryPointNode(nodeType) {
+	return nodeType === "INPUT" || nodeType === "core.input" || nodeType.startsWith("trigger.");
+}
+/**
+* Static flow validator.
+*
+* Designed to help an agent (or user) verify that a flow definition will
+* execute correctly. This does NOT prevent saving — it only reports issues.
+*
+* Errors  = the flow WILL fail at execution time (topological sort throws, etc.)
+* Warnings = the flow will run but something looks unintentional.
+*/
+var FlowValidator = class {
+	static validateFlowDefinition(flowDefinition) {
+		try {
+			const context = new ValidationContext(flowDefinition, this.analyzeGraph(flowDefinition.nodes, flowDefinition.edges));
+			this.validateNotEmpty(context);
+			this.validateEdgeReferences(context);
+			this.validateNoSelfReferences(context);
+			this.validateNoDuplicateEdges(context);
+			this.validateNoCycles(context);
+			this.validateEntryPoints(context);
+			this.validateNoDisconnectedNodes(context);
+			this.validateSingleManualTrigger(context);
+			return this.buildResult(context);
+		} catch (error) {
+			return {
+				isValid: false,
+				errors: [{
+					severity: "error",
+					type: "VALIDATION_SYSTEM_ERROR",
+					message: `Validation system error: ${error instanceof Error ? error.message : "Unknown error"}`
+				}],
+				warnings: []
+			};
+		}
+	}
+	static analyzeGraph(nodes, edges) {
+		const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+		const edgeMap = new Map(edges.map((e) => [e.id, e]));
+		const incomingEdges = /* @__PURE__ */ new Map();
+		const outgoingEdges = /* @__PURE__ */ new Map();
+		for (const node of nodes) {
+			incomingEdges.set(node.id, GraphService.getIncomingEdges(node.id, edges));
+			outgoingEdges.set(node.id, GraphService.getOutgoingEdges(node.id, edges));
+		}
+		return {
+			nodeMap,
+			edgeMap,
+			incomingEdges,
+			outgoingEdges
+		};
+	}
+	static validateNotEmpty(context) {
+		if (context.definition.nodes.length === 0) context.addWarning("EMPTY_FLOW", "Flow has no nodes");
+	}
+	static validateEdgeReferences(context) {
+		const { nodeMap } = context.analysis;
+		for (const edge of context.definition.edges) {
+			if (!nodeMap.has(edge.source)) context.addError("INVALID_EDGE_REFERENCE", "Edge references non-existent source node", {
+				edgeId: edge.id,
+				sourceNodeId: edge.source,
+				targetNodeId: edge.target
+			});
+			if (!nodeMap.has(edge.target)) context.addError("INVALID_EDGE_REFERENCE", "Edge references non-existent target node", {
+				edgeId: edge.id,
+				sourceNodeId: edge.source,
+				targetNodeId: edge.target
+			});
+		}
+	}
+	static validateNoSelfReferences(context) {
+		for (const edge of context.definition.edges) if (edge.source === edge.target) context.addError("SELF_REFERENCING_EDGE", "Edge connects a node to itself", {
+			edgeId: edge.id,
+			nodeId: edge.source
+		});
+	}
+	static validateNoDuplicateEdges(context) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const edge of context.definition.edges) {
+			const key = `${edge.source}:${edge.sourceHandle ?? ""}→${edge.target}:${edge.targetHandle ?? ""}`;
+			if (seen.has(key)) context.addWarning("DUPLICATE_EDGE", "Duplicate connection between the same nodes", {
+				edgeId: edge.id,
+				sourceNodeId: edge.source,
+				targetNodeId: edge.target
+			});
+			seen.add(key);
+		}
+	}
+	static validateNoCycles(context) {
+		const { nodes, edges } = context.definition;
+		const result = GraphService.hasCycleDetection(nodes, edges);
+		if (result.hasCycle && result.cyclePath) context.addError("CIRCULAR_DEPENDENCY", "Flow contains a cycle and cannot be executed", { additionalContext: {
+			cyclePath: result.cyclePath,
+			involvedNodeIds: result.cyclePath.slice(0, -1)
+		} });
+	}
+	static validateEntryPoints(context) {
+		const { incomingEdges } = context.analysis;
+		for (const node of context.definition.nodes) {
+			if (!isEntryPointNode(node.type)) continue;
+			const incoming = incomingEdges.get(node.id) || [];
+			if (incoming.length > 0) context.addWarning("ENTRY_NODE_HAS_INCOMING_EDGES", `${node.label || node.type} is an entry-point node and should not have incoming connections`, {
+				nodeId: node.id,
+				sourceNodeType: node.type,
+				additionalContext: { incomingEdgeCount: incoming.length }
+			});
+		}
+	}
+	static validateNoDisconnectedNodes(context) {
+		const { incomingEdges, outgoingEdges } = context.analysis;
+		if (context.definition.nodes.length < 2) return;
+		for (const node of context.definition.nodes) {
+			const incoming = incomingEdges.get(node.id) || [];
+			const outgoing = outgoingEdges.get(node.id) || [];
+			if (incoming.length === 0 && outgoing.length === 0) context.addWarning("DISCONNECTED_NODE", "Node has no connections to other nodes", {
+				nodeId: node.id,
+				sourceNodeType: node.type
+			});
+		}
+	}
+	static validateSingleManualTrigger(context) {
+		const manualTriggers = context.definition.nodes.filter((n) => n.type === "trigger.manual");
+		if (manualTriggers.length > 1) context.addError("MULTIPLE_MANUAL_TRIGGERS", `Only one Manual Trigger is allowed per flow, but ${manualTriggers.length} were found`, { additionalContext: { triggerNodeIds: manualTriggers.map((n) => n.id) } });
+	}
+	static buildResult(context) {
+		const warnings = context.issues.filter((i) => i.severity === "warning");
+		if (context.hasErrors()) return {
+			isValid: false,
+			errors: context.issues.filter((i) => i.severity === "error"),
+			warnings
+		};
+		return {
+			isValid: true,
+			warnings: warnings.length > 0 ? warnings : void 0
+		};
+	}
+};
+//#endregion
+export { FlowValidator };
+
+//# sourceMappingURL=flow-validator.js.map