flowfram-runtime 1.0.2

package/dist/server.js

@@ -0,0 +1,1050 @@
+"use strict";
+/**
+ * FlowRed Runtime Service
+ *
+ * Distributed runtime execution engine with REST API + SSE events.
+ *
+ * Endpoints:
+ * - POST /deploy    - Deploy a flow
+ * - POST /stop      - Stop a flow
+ * - POST /inject    - Execute an inject node
+ * - GET  /status    - Get runtime status
+ * - GET  /events    - SSE endpoint for real-time events
+ * - GET  /health    - Health check
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+// Load environment variables from .env files
+// In production: only .env
+// In development: .env + .env.local (local overrides)
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Load .env first (base config) - suppress dotenv logs
+dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+// Only load .env.local in development mode (not production)
+const isProduction = process.env.NODE_ENV === "production";
+if (!isProduction) {
+    const envLocalPath = path.resolve(process.cwd(), ".env.local");
+    if (fs.existsSync(envLocalPath)) {
+        dotenv.config({ path: envLocalPath, override: true });
+    }
+}
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const ServerFlowRuntime_1 = require("./ServerFlowRuntime");
+const persistence_1 = require("./persistence");
+const logger_1 = __importDefault(require("./logger"));
+const app = (0, express_1.default)();
+app.use((0, cors_1.default)());
+app.use(express_1.default.json({ limit: "10mb" }));
+const PORT = process.env.PORT || 3001;
+// Map of runtimes per flowId
+const runtimes = new Map();
+const deployedFlows = new Map();
+// SSE connections per flowId
+const sseConnections = new Map();
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Format duration in milliseconds to human-readable string
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+        return `${days}d ${hours % 24}h ${minutes % 60}m`;
+    }
+    else if (hours > 0) {
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    else if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    else {
+        return `${seconds}s`;
+    }
+}
+// ============================================================================
+// REST ENDPOINTS
+// ============================================================================
+/**
+ * POST /deploy
+ * Deploy a flow to the runtime
+ */
+app.post("/deploy", async (req, res) => {
+    const { flowId, flowData, tenantId, modelName, scenarioName, userId, modelId, executionContext, maxHops, } = req.body;
+    if (!flowId) {
+        return res
+            .status(400)
+            .json({ success: false, error: "flowId is required" });
+    }
+    // Use tenantId from request or default to flowId
+    const effectiveTenantId = tenantId || flowId;
+    // Default execution context is 'floweditor' for backwards compatibility
+    const effectiveContext = executionContext || "floweditor";
+    logger_1.default.info(`[Runtime] POST /deploy flowId=${flowId} tenant=${effectiveTenantId} context=${effectiveContext} model=${modelName || "N/A"} nodes=${flowData?.nodes?.length || 0}`);
+    // Debug: log node types to check if chart-output/table-output are included
+    const nodeTypes = (flowData?.nodes || []).map((n) => n.type);
+    const vizNodes = (flowData?.nodes || []).filter((n) => n.type === "chart-output" || n.type === "table-output");
+    logger_1.default.debug(`[Runtime] Node types: ${JSON.stringify(nodeTypes)}`);
+    logger_1.default.debug(`[Runtime] Visualization nodes: ${vizNodes.length} (chart-output: ${vizNodes.filter((n) => n.type === "chart-output").length}, table-output: ${vizNodes.filter((n) => n.type === "table-output").length})`);
+    try {
+        let runtime = runtimes.get(flowId);
+        if (!runtime) {
+            runtime = new ServerFlowRuntime_1.ServerFlowRuntime(flowId, effectiveTenantId);
+            runtimes.set(flowId, runtime);
+            setupEventForwarding(runtime, flowId);
+        }
+        else {
+            // Clear flow context on redeploy to ensure fresh state for self-referential variables
+            const clearedKeys = runtime.clearFlowContext();
+            logger_1.default.debug(`[Runtime] Cleared ${clearedKeys.length} flow context keys on redeploy`);
+        }
+        // Set execution context for SSE event tagging
+        runtime.setExecutionContext(effectiveContext);
+        // Set max hops for cycle protection (user-configurable per model)
+        if (maxHops && typeof maxHops === 'number') {
+            runtime.setMaxHops(maxHops);
+        }
+        // Convert flowData to the format expected by ServerFlowRuntime
+        const flowJSON = buildFlowJSON(flowId, flowData);
+        const result = await runtime.deploy([flowJSON]);
+        const deployedAt = Date.now();
+        // Persist the deployed flow with tenant info and metadata
+        deployedFlows.set(flowId, {
+            flowData,
+            deployedAt,
+            tenantId: effectiveTenantId,
+            modelName,
+            scenarioName,
+            userId,
+            modelId,
+        });
+        (0, persistence_1.savePersistedState)(deployedFlows);
+        res.json({
+            success: result.status === "success" || result.status === "partial",
+            status: result.status,
+            nodesDeployed: result.nodesDeployed,
+            flowsDeployed: result.flowsDeployed,
+            errors: result.errors,
+            deployedAt,
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`[Runtime] Deploy error:`, error);
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+});
+/**
+ * POST /stop
+ * Stop a running flow
+ */
+app.post("/stop", async (req, res) => {
+    const { flowId } = req.body;
+    if (!flowId) {
+        return res
+            .status(400)
+            .json({ success: false, error: "flowId is required" });
+    }
+    logger_1.default.info(`[Runtime] POST /stop flowId=${flowId}`);
+    try {
+        const runtime = runtimes.get(flowId);
+        if (!runtime) {
+            return res.status(404).json({ success: false, error: "Flow not found" });
+        }
+        const result = await runtime.stop(flowId);
+        // Remove from persistence
+        deployedFlows.delete(flowId);
+        (0, persistence_1.removePersistedFlow)(flowId);
+        // Cleanup runtime after stop
+        runtimes.delete(flowId);
+        res.json({
+            success: result.success,
+            error: result.error,
+            timestamp: Date.now(),
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`[Runtime] Stop error:`, error);
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+            timestamp: Date.now(),
+        });
+    }
+});
+/**
+ * POST /config
+ * Configure runtime flags for a deployed flow
+ * Supports: suppressFunctionLogs, fastMode
+ */
+app.post("/config", (req, res) => {
+    const { flowId, suppressFunctionLogs, fastMode } = req.body;
+    if (!flowId) {
+        return res
+            .status(400)
+            .json({ success: false, error: "flowId is required" });
+    }
+    const runtime = runtimes.get(flowId);
+    if (!runtime) {
+        return res
+            .status(404)
+            .json({ success: false, error: "Flow not found. Deploy first." });
+    }
+    const applied = {};
+    if (typeof suppressFunctionLogs === "boolean") {
+        runtime.setSuppressFunctionLogs(suppressFunctionLogs);
+        applied.suppressFunctionLogs = suppressFunctionLogs;
+    }
+    if (typeof fastMode === "boolean") {
+        runtime.setFastMode(fastMode);
+        applied.fastMode = fastMode;
+    }
+    res.json({ success: true, applied });
+});
+/**
+ * POST /batch-run
+ * Execute multiple iterations server-side to eliminate per-iteration network latency
+ * Emits progress events via SSE as iterations complete
+ */
+app.post("/batch-run", async (req, res) => {
+    const { flowId, injectNodeIds, iterations, delayBetweenIterations = 0, executionContext = "instantiator", fastMode = false, // PERFORMANCE: Skip debug SSE events when true
+    suppressFunctionLogs, // Optional: override function log suppression (defaults to LOG_LEVEL-based)
+     } = req.body;
+    if (!flowId || !injectNodeIds || !iterations) {
+        return res.status(400).json({
+            success: false,
+            error: "flowId, injectNodeIds, and iterations are required",
+        });
+    }
+    logger_1.default.info(`[Runtime] POST /batch-run flowId=${flowId} iterations=${iterations} nodes=${injectNodeIds.length} delay=${delayBetweenIterations}ms fastMode=${fastMode}`);
+    try {
+        const runtime = runtimes.get(flowId);
+        if (!runtime) {
+            return res
+                .status(404)
+                .json({ success: false, error: "Flow not found. Deploy first." });
+        }
+        // Set execution context for SSE event tagging
+        runtime.setExecutionContext(executionContext);
+        // PERFORMANCE: Enable fast mode to suppress debug SSE events
+        runtime.setFastMode(fastMode);
+        // Optional: override function log suppression for this run
+        if (typeof suppressFunctionLogs === "boolean") {
+            runtime.setSuppressFunctionLogs(suppressFunctionLogs);
+        }
+        const startTime = Date.now();
+        let completedIterations = 0;
+        const currentMaxHops = runtime.getMaxHops();
+        // Emit batch-start event immediately so the client shows progress UI right away
+        // This is critical for fast mode UX: without it the user sees no feedback for up to a minute
+        const startConnections = sseConnections.get(flowId);
+        if (startConnections && startConnections.size > 0) {
+            const startEvent = {
+                type: "batch-start",
+                flowId,
+                totalIterations: iterations,
+                maxHops: currentMaxHops,
+                fastMode,
+                executionContext,
+                timestamp: Date.now(),
+            };
+            const startMessage = `event: batch-start\ndata: ${JSON.stringify(startEvent)}\n\n`;
+            startConnections.forEach((conn) => {
+                try {
+                    conn.write(startMessage);
+                }
+                catch (e) {
+                    // Connection closed
+                }
+            });
+        }
+        // Execute all iterations server-side
+        let flowError = null;
+        for (let i = 1; i <= iterations; i++) {
+            // CRITICAL: Check if flow has encountered an error - stop immediately
+            if (runtime.hasError()) {
+                flowError = runtime.getError() || "Flow execution stopped due to error";
+                logger_1.default.error(`[Runtime] Batch-run stopping at iteration ${i}: ${flowError}`);
+                // Emit batch-error event via SSE
+                const connections = sseConnections.get(flowId);
+                if (connections && connections.size > 0) {
+                    const errorEvent = {
+                        type: "batch-error",
+                        flowId,
+                        iteration: i,
+                        totalIterations: iterations,
+                        error: flowError,
+                        executionContext,
+                        timestamp: Date.now(),
+                    };
+                    const message = `event: batch-error\ndata: ${JSON.stringify(errorEvent)}\n\n`;
+                    connections.forEach((conn) => {
+                        try {
+                            conn.write(message);
+                        }
+                        catch (e) {
+                            // Connection closed
+                        }
+                    });
+                }
+                break;
+            }
+            // Set current iteration for SSE message tagging
+            runtime.setCurrentIteration(i);
+            // Execute all inject nodes for this iteration
+            for (const nodeId of injectNodeIds) {
+                await runtime.executeNode(nodeId, {});
+                // Check for error after each inject
+                if (runtime.hasError()) {
+                    break;
+                }
+            }
+            // CRITICAL: Wait for all async operations (HTTP, MQTT, CSV) to complete
+            // This ensures the entire flow chain finishes before moving to next iteration
+            const completed = await runtime.waitForPendingMessages(30000, 50);
+            if (!completed) {
+                logger_1.default.warn(`[Runtime] Iteration ${i} timed out waiting for pending operations`);
+            }
+            // CRITICAL: Check for error AFTER async operations complete
+            // Errors occur during async execution, so we must check here
+            if (runtime.hasError()) {
+                flowError = runtime.getError() || "Flow execution stopped due to error";
+                logger_1.default.error(`[Runtime] Batch-run stopping after iteration ${i} due to error: ${flowError}`);
+                // Emit batch-error event via SSE
+                const errorConnections = sseConnections.get(flowId);
+                if (errorConnections && errorConnections.size > 0) {
+                    const errorEvent = {
+                        type: "batch-error",
+                        flowId,
+                        iteration: i,
+                        totalIterations: iterations,
+                        error: flowError,
+                        executionContext,
+                        timestamp: Date.now(),
+                    };
+                    const errorMessage = `event: batch-error\ndata: ${JSON.stringify(errorEvent)}\n\n`;
+                    errorConnections.forEach((conn) => {
+                        try {
+                            conn.write(errorMessage);
+                        }
+                        catch (e) {
+                            // Connection closed
+                        }
+                    });
+                }
+                break;
+            }
+            // Trigger observer nodes (coupling-matrix, resonance-indicator) at end of iteration
+            // This auto-triggers nodes without input wires to compute visualization data
+            // Safe: only affects nodes without input connections, no impact on normal flow
+            // PERFORMANCE: In fast mode, only compute entropy on the LAST iteration
+            // to avoid O(N²) re-scanning of the ever-growing _messageFlowHistory array.
+            // The full history is still accumulated and processed once at the end.
+            if (!fastMode || i === iterations) {
+                await runtime.triggerObserverNodes();
+            }
+            completedIterations = i;
+            // Emit batch progress event via SSE
+            const connections = sseConnections.get(flowId);
+            if (connections && connections.size > 0) {
+                const progressEvent = {
+                    type: "batch-progress",
+                    flowId,
+                    iteration: i,
+                    totalIterations: iterations,
+                    maxHops: currentMaxHops,
+                    executionContext,
+                    timestamp: Date.now(),
+                };
+                const message = `event: batch-progress\ndata: ${JSON.stringify(progressEvent)}\n\n`;
+                connections.forEach((conn) => {
+                    try {
+                        conn.write(message);
+                    }
+                    catch (e) {
+                        // Connection closed
+                    }
+                });
+            }
+            // Delay between iterations if specified
+            if (delayBetweenIterations > 0 && i < iterations) {
+                await new Promise((resolve) => setTimeout(resolve, delayBetweenIterations));
+            }
+        }
+        const totalTime = Date.now() - startTime;
+        const avgTimePerIteration = totalTime / iterations;
+        // FAST MODE: Get accumulated data that was collected during fast mode execution
+        const fastModeMetadata = runtime.getAndClearFastModeMetadata();
+        const fastModeMessageFlow = runtime.getAndClearFastModeMessageFlow();
+        const fastModeOutputData = runtime.getAndClearFastModeOutputData();
+        // SERVER-SIDE RUNNING STATS: Get pre-computed statistics (no truncation)
+        const runningStats = runtime.getAndClearRunningStats();
+        const runningStatsVarCount = Object.values(runningStats).reduce((sum, funcVars) => sum + Object.keys(funcVars).length, 0);
+        logger_1.default.info(`[Runtime] Fast mode data collected: ${fastModeMetadata.length} metadata snapshots, ${fastModeMessageFlow.length} message-flow records, ${fastModeOutputData.length} output-data records, ${runningStatsVarCount} running-stats variables`);
+        // Emit batch complete event via SSE with accumulated fast mode data
+        const connections = sseConnections.get(flowId);
+        if (connections && connections.size > 0) {
+            const completeEvent = {
+                type: "batch-complete",
+                flowId,
+                iterations: completedIterations,
+                totalTime,
+                avgTimePerIteration,
+                executionContext,
+                timestamp: Date.now(),
+                // Include accumulated fast mode data for client-side processing
+                batchData: {
+                    metadataSnapshots: fastModeMetadata,
+                    messageFlowData: fastModeMessageFlow,
+                    outputData: fastModeOutputData,
+                },
+                // SERVER-SIDE RUNNING STATS: Pre-computed statistics per function per variable
+                // These are computed using Welford's online algorithm with ZERO truncation
+                // Structure: { "F1 - Detection": { "PERF_F01": { count, mean, std, min, max, p5..p95, histogram } } }
+                serverStats: runningStats,
+            };
+            const message = `event: batch-complete\ndata: ${JSON.stringify(completeEvent)}\n\n`;
+            connections.forEach((conn) => {
+                try {
+                    conn.write(message);
+                }
+                catch (e) {
+                    // Connection closed
+                }
+            });
+        }
+        logger_1.default.info(`[Runtime] Batch complete: ${completedIterations} iterations in ${totalTime}ms (avg ${avgTimePerIteration.toFixed(2)}ms/iter)`);
+        // CRITICAL: Return error response if flow encountered an error
+        if (flowError) {
+            logger_1.default.error(`[Runtime] Batch-run stopped due to error: ${flowError}`);
+            return res.status(500).json({
+                success: false,
+                error: flowError,
+                completedIterations,
+                totalTime,
+                stoppedDueToError: true,
+            });
+        }
+        res.json({
+            success: true,
+            completedIterations,
+            totalTime,
+            avgTimePerIteration,
+            // Include serverStats in HTTP response for reliable delivery
+            // SSE batch-complete may not arrive in time for large payloads
+            serverStats: runningStats,
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`[Runtime] Batch-run error:`, error);
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+});
+/**
+ * POST /inject
+ * Execute an inject node
+ * Accepts optional simulationContext with iteration number for tracking
+ * If trackCompletion is true, starts a flow cycle and returns cycleId
+ */
+app.post("/inject", async (req, res) => {
+    const { flowId, nodeId, payload, simulationContext, trackCompletion } = req.body;
+    if (!flowId || !nodeId) {
+        return res
+            .status(400)
+            .json({ success: false, error: "flowId and nodeId are required" });
+    }
+    const iteration = simulationContext?.iteration;
+    logger_1.default.info(`[Runtime] POST /inject flowId=${flowId} nodeId=${nodeId} iteration=${iteration ?? "N/A"} trackCompletion=${trackCompletion ?? false}`);
+    try {
+        const runtime = runtimes.get(flowId);
+        if (!runtime) {
+            return res.status(404).json({ success: false, error: "Flow not found" });
+        }
+        // Store current iteration in runtime for SSE message tagging
+        if (iteration !== undefined) {
+            runtime.setCurrentIteration(iteration);
+        }
+        // Start flow cycle tracking if requested
+        let cycleId;
+        if (trackCompletion) {
+            cycleId = runtime.startFlowCycle();
+        }
+        await runtime.executeNode(nodeId, payload || {});
+        res.json({ success: true, cycleId });
+    }
+    catch (error) {
+        logger_1.default.error(`[Runtime] Inject error:`, error);
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+});
+/**
+ * GET /status
+ * Get runtime status
+ */
+app.get("/status", async (req, res) => {
+    const flowId = req.query.flowId;
+    if (flowId) {
+        const runtime = runtimes.get(flowId);
+        if (!runtime) {
+            return res.status(404).json({ error: "Flow not found" });
+        }
+        try {
+            const status = await runtime.getStatus();
+            res.json(status);
+        }
+        catch (error) {
+            res.status(500).json({ error: "Failed to get status" });
+        }
+    }
+    else {
+        // Return global status
+        res.json({
+            totalFlows: runtimes.size,
+            flows: Array.from(runtimes.keys()),
+            sseConnections: Array.from(sseConnections.values()).reduce((sum, set) => sum + set.size, 0),
+        });
+    }
+});
+/**
+ * GET /flows
+ * List all active flows with detailed information (for admin panel)
+ */
+app.get("/flows", async (req, res) => {
+    logger_1.default.info(`[Runtime] GET /flows - listing ${runtimes.size} active flows`);
+    try {
+        const flows = [];
+        for (const [flowId, runtime] of runtimes.entries()) {
+            const deployInfo = deployedFlows.get(flowId);
+            const sseCount = sseConnections.get(flowId)?.size || 0;
+            let status = {};
+            try {
+                status = await runtime.getStatus();
+            }
+            catch (e) {
+                // Ignore status errors
+            }
+            // Calculate running time
+            const deployedAt = deployInfo?.deployedAt || Date.now();
+            const runningTimeMs = Date.now() - deployedAt;
+            flows.push({
+                flowId,
+                tenantId: deployInfo?.tenantId || flowId,
+                deployedAt,
+                runningTimeMs,
+                runningTimeFormatted: formatDuration(runningTimeMs),
+                nodeCount: deployInfo?.flowData?.nodes?.length || 0,
+                edgeCount: deployInfo?.flowData?.edges?.length || 0,
+                sseConnections: sseCount,
+                status: {
+                    uptime: status.uptime || 0,
+                    nodesTotal: status.nodes?.total || 0,
+                    nodesRunning: status.nodes?.running || 0,
+                },
+                // Additional metadata for admin display
+                modelName: deployInfo?.modelName || null,
+                scenarioName: deployInfo?.scenarioName || null,
+                userId: deployInfo?.userId || null,
+                modelId: deployInfo?.modelId || null,
+            });
+        }
+        // Sort by deployedAt descending (newest first)
+        flows.sort((a, b) => b.deployedAt - a.deployedAt);
+        res.json({
+            success: true,
+            totalFlows: flows.length,
+            flows,
+            timestamp: Date.now(),
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`[Runtime] GET /flows error:`, error);
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+});
+/**
+ * POST /flows/:flowId/stop
+ * Stop a specific flow (admin action)
+ */
+app.post("/flows/:flowId/stop", async (req, res) => {
+    const { flowId } = req.params;
+    logger_1.default.info(`[Runtime] POST /flows/${flowId}/stop (admin action)`);
+    try {
+        const runtime = runtimes.get(flowId);
+        if (!runtime) {
+            return res.status(404).json({ success: false, error: "Flow not found" });
+        }
+        const result = await runtime.stop(flowId);
+        // Remove from persistence
+        deployedFlows.delete(flowId);
+        (0, persistence_1.removePersistedFlow)(flowId);
+        // Cleanup runtime after stop
+        runtimes.delete(flowId);
+        // Close SSE connections for this flow
+        const connections = sseConnections.get(flowId);
+        if (connections) {
+            connections.forEach((conn) => {
+                try {
+                    conn.write(`event: flow-stopped\ndata: ${JSON.stringify({ flowId, timestamp: Date.now() })}\n\n`);
+                    conn.end();
+                }
+                catch (e) {
+                    // Ignore connection errors
+                }
+            });
+            sseConnections.delete(flowId);
+        }
+        res.json({
+            success: result.success,
+            flowId,
+            timestamp: Date.now(),
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`[Runtime] Stop flow error:`, error);
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        });
+    }
+});
+// ============================================================================
+// SSE ENDPOINT
+// ============================================================================
+/**
+ * GET /events
+ * SSE endpoint for real-time runtime events
+ */
+app.get("/events", (req, res) => {
+    const flowId = req.query.flowId;
+    if (!flowId) {
+        return res
+            .status(400)
+            .json({ error: "flowId query parameter is required" });
+    }
+    logger_1.default.info(`[Runtime] SSE connection for flowId=${flowId}`);
+    // Setup SSE headers
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    // Send retry delay instruction (3 seconds for reconnection)
+    res.write("retry: 3000\n\n");
+    // Check if flow is running
+    const runtime = runtimes.get(flowId);
+    const isRunning = runtime ? true : false;
+    // Send initial connection event with flow status
+    const connectionEvent = JSON.stringify({
+        type: "connected",
+        flowId,
+        timestamp: Date.now(),
+        flowRunning: isRunning,
+    });
+    res.write(`event: connected\ndata: ${connectionEvent}\n\n`);
+    // Add to SSE connections
+    if (!sseConnections.has(flowId)) {
+        sseConnections.set(flowId, new Set());
+    }
+    sseConnections.get(flowId).add(res);
+    // Heartbeat every 10s with flow status
+    const heartbeat = setInterval(async () => {
+        try {
+            const rt = runtimes.get(flowId);
+            const running = rt ? true : false;
+            let metrics = {};
+            if (rt) {
+                try {
+                    const status = await rt.getStatus();
+                    metrics = {
+                        uptime: status.uptime,
+                        nodes: status.nodes?.total || 0,
+                    };
+                }
+                catch (e) {
+                    // Ignore errors getting status
+                }
+            }
+            const heartbeatEvent = JSON.stringify({
+                type: "heartbeat",
+                flowId,
+                timestamp: Date.now(),
+                flowRunning: running,
+                metrics,
+            });
+            res.write(`event: heartbeat\ndata: ${heartbeatEvent}\n\n`);
+        }
+        catch (error) {
+            clearInterval(heartbeat);
+        }
+    }, 10000);
+    // Cleanup on disconnect
+    req.on("close", () => {
+        logger_1.default.info(`[Runtime] SSE disconnected flowId=${flowId}`);
+        clearInterval(heartbeat);
+        sseConnections.get(flowId)?.delete(res);
+    });
+});
+// ============================================================================
+// HEALTH CHECK
+// ============================================================================
+/**
+ * POST /context/clear
+ * Clear flow context for a specific flow (for self-referential variables)
+ */
+app.post("/context/clear", async (req, res) => {
+    const { flowId } = req.body;
+    if (!flowId) {
+        return res
+            .status(400)
+            .json({ success: false, error: "flowId is required" });
+    }
+    logger_1.default.info(`[Runtime] POST /context/clear flowId=${flowId}`);
+    try {
+        const runtime = runtimes.get(flowId);
+        let clearedKeys = [];
+        if (runtime) {
+            // Use the runtime's clearFlowContext method
+            clearedKeys = runtime.clearFlowContext();
+        }
+        else {
+            // Flow not deployed yet - nothing to clear
+            logger_1.default.debug(`[Runtime] Flow ${flowId} not deployed, nothing to clear`);
+        }
+        res.json({
+            success: true,
+            data: {
+                flowId,
+                clearedKeys,
+            },
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`[Runtime] Context clear error:`, error);
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to clear context",
+        });
+    }
+});
+/**
+ * POST /setInstantiation
+ * Set the current instantiation number for a flow (used by multi-cycle controllers)
+ */
+app.post("/setInstantiation", async (req, res) => {
+    const { flowId, instantiation, version } = req.body;
+    if (!flowId) {
+        return res
+            .status(400)
+            .json({ success: false, error: "flowId is required" });
+    }
+    logger_1.default.info(`[Runtime] POST /setInstantiation flowId=${flowId} instantiation=${instantiation} version=${version}`);
+    try {
+        const runtime = runtimes.get(flowId);
+        if (runtime) {
+            // Store instantiation number in runtime context for tracking
+            runtime.setFlowContextValue("_currentInstantiation", instantiation);
+            runtime.setFlowContextValue("_controllerVersion", version);
+        }
+        else {
+            logger_1.default.debug(`[Runtime] Flow ${flowId} not deployed, cannot set instantiation`);
+            return res
+                .status(404)
+                .json({ success: false, error: "Flow not deployed" });
+        }
+        res.json({
+            success: true,
+            data: {
+                flowId,
+                instantiation,
+                version,
+            },
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`[Runtime] SetInstantiation error:`, error);
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to set instantiation",
+        });
+    }
+});
+/**
+ * GET /health
+ * Health check endpoint
+ */
+app.get("/health", (req, res) => {
+    res.json({
+        status: "healthy",
+        uptime: process.uptime(),
+        flows: runtimes.size,
+        sseConnections: Array.from(sseConnections.values()).reduce((sum, set) => sum + set.size, 0),
+        memory: process.memoryUsage(),
+        timestamp: Date.now(),
+    });
+});
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Setup event forwarding from runtime to SSE connections
+ * Includes current iteration and execution context in events for proper message tagging
+ */
+function setupEventForwarding(runtime, flowId) {
+    runtime.on("runtime-event", (event) => {
+        const connections = sseConnections.get(flowId);
+        // Debug: log coupling-data and resonance-data events
+        if (event.type === "coupling-data" || event.type === "resonance-data") {
+            logger_1.default.debug(`[SSE Forward] ${event.type} event for ${flowId}: connections=${connections?.size || 0}`);
+        }
+        if (connections && connections.size > 0) {
+            // Include current iteration and execution context in event data for client-side filtering
+            const eventWithContext = {
+                ...event,
+                iteration: runtime.getCurrentIteration(),
+                executionContext: runtime.getExecutionContext(),
+            };
+            const message = `event: ${event.type}\ndata: ${JSON.stringify(eventWithContext)}\n\n`;
+            connections.forEach((res) => {
+                try {
+                    res.write(message);
+                }
+                catch (error) {
+                    // Connection closed, will be cleaned up on 'close' event
+                }
+            });
+        }
+    });
+}
+/**
+ * Build flow JSON from flowData
+ */
+function buildFlowJSON(flowId, flowData) {
+    if (!flowData || !flowData.nodes) {
+        return { id: flowId, name: `Flow ${flowId}`, nodes: [], edges: [] };
+    }
+    // Convert React Flow edges to Node-RED wires format
+    // wires format: [[output0-targets], [output1-targets], ...]
+    // sourceHandle indicates which output port (0, 1, 2, etc.)
+    const edgesBySourceAndHandle = new Map();
+    for (const edge of flowData.edges || []) {
+        const sourceId = edge.source;
+        const targetId = edge.target;
+        // sourceHandle can be "0", "1", "output-0", "output-1", etc. or undefined (defaults to 0)
+        let handleIndex = 0;
+        if (edge.sourceHandle) {
+            // Extract number from sourceHandle (handles both "0" and "output-0" formats)
+            const match = edge.sourceHandle.match(/(\d+)/);
+            handleIndex = match ? parseInt(match[1], 10) : 0;
+        }
+        if (!edgesBySourceAndHandle.has(sourceId)) {
+            edgesBySourceAndHandle.set(sourceId, new Map());
+        }
+        const handleMap = edgesBySourceAndHandle.get(sourceId);
+        if (!handleMap.has(handleIndex)) {
+            handleMap.set(handleIndex, []);
+        }
+        handleMap.get(handleIndex).push(targetId);
+    }
+    return {
+        id: flowId,
+        name: flowData.name || `Flow ${flowId}`,
+        nodes: flowData.nodes.map((node) => {
+            const handleMap = edgesBySourceAndHandle.get(node.id);
+            let wires = [];
+            if (handleMap && handleMap.size > 0) {
+                // Find max handle index to create proper array size
+                const maxHandle = Math.max(...handleMap.keys());
+                wires = Array(maxHandle + 1)
+                    .fill(null)
+                    .map(() => []);
+                handleMap.forEach((targets, handleIndex) => {
+                    // Deduplicate targets to avoid sending duplicate messages
+                    // This can happen when edges with different sourceHandle names (e.g., "output-success", "output-error")
+                    // that don't contain numbers all map to handleIndex 0
+                    wires[handleIndex] = [...new Set(targets)];
+                });
+            }
+            else if (node.data?.wires) {
+                wires = node.data.wires;
+            }
+            // Destructure node to separate known fields from extra properties
+            const { id, type, position, data, ...nodeExtras } = node;
+            // For debug nodes, map outputType to complete property
+            // outputType: "payload" -> complete: false (show payload only)
+            // outputType: "complete" -> complete: true (show full message)
+            // outputType: "property" -> complete: <property path> (show specific property)
+            let debugComplete = undefined;
+            if (type === "debug") {
+                const outputType = data?.outputType || "payload";
+                if (outputType === "complete") {
+                    debugComplete = true;
+                }
+                else if (outputType === "property") {
+                    debugComplete = data?.property || "payload";
+                }
+                else {
+                    debugComplete = false; // Default: show payload only
+                }
+                // DEBUG: Log the mapping
+                logger_1.default.debug(`[buildFlowJSON] Debug node ${id}: outputType=${outputType}, property=${data?.property}, mapped complete=${debugComplete}, original complete=${data?.complete}`);
+            }
+            return {
+                id,
+                type,
+                name: data?.name || data?.label || id,
+                x: position?.x || 0,
+                y: position?.y || 0,
+                z: flowId,
+                // Include properties from node level (e.g., property, rules for switch)
+                ...nodeExtras,
+                // Include properties from data
+                ...data,
+                // For debug nodes, override complete with mapped value
+                ...(type === "debug" && debugComplete !== undefined
+                    ? { complete: debugComplete }
+                    : {}),
+                // wires MUST come last to ensure edges take priority
+                wires,
+            };
+        }),
+        edges: flowData.edges || [],
+    };
+}
+// ============================================================================
+// RESTORE PERSISTED FLOWS ON STARTUP
+// ============================================================================
+async function restorePersistedFlows() {
+    const state = (0, persistence_1.loadPersistedState)();
+    if (!state || state.flows.length === 0) {
+        logger_1.default.info("[Startup] No flows to restore");
+        return;
+    }
+    logger_1.default.info(`[Startup] Restoring ${state.flows.length} persisted flows...`);
+    for (const persistedFlow of state.flows) {
+        try {
+            const { flowId, flowData, deployedAt, tenantId } = persistedFlow;
+            logger_1.default.info(`[Startup] Restoring flow: ${flowId}`);
+            // Create runtime
+            const runtime = new ServerFlowRuntime_1.ServerFlowRuntime(flowId, tenantId || flowId);
+            runtimes.set(flowId, runtime);
+            setupEventForwarding(runtime, flowId);
+            // Deploy the flow
+            const flowJSON = buildFlowJSON(flowId, flowData);
+            await runtime.deploy([flowJSON]);
+            // Track in memory
+            deployedFlows.set(flowId, { flowData, deployedAt, tenantId });
+            logger_1.default.info(`[Startup] ✅ Flow ${flowId} restored successfully`);
+        }
+        catch (error) {
+            logger_1.default.error(`[Startup] ❌ Failed to restore flow ${persistedFlow.flowId}:`, error);
+        }
+    }
+    logger_1.default.info(`[Startup] Restoration complete: ${runtimes.size} flows active`);
+}
+function createServer(options = {}) {
+    const port = options.port || parseInt(process.env.PORT || "3001", 10);
+    const host = options.host || "0.0.0.0";
+    const silent = options.silent || false;
+    return new Promise((resolve, reject) => {
+        const server = app.listen(port, host, async () => {
+            // CRITICAL: Increase server timeouts for long-running batch operations.
+            // Node.js HTTP server defaults: headersTimeout=60s, requestTimeout=300s, keepAliveTimeout=5s.
+            // For batch-run with 10,000+ iterations, operations can take 20+ minutes.
+            // Without this, the server may close the connection before the batch completes.
+            server.headersTimeout = 60 * 60 * 1000; // 60 minutes
+            server.requestTimeout = 60 * 60 * 1000; // 60 minutes  
+            server.keepAliveTimeout = 60 * 60 * 1000; // 60 minutes
+            if (!silent) {
+                logger_1.default.always(`
+╔══════════════════════════════════════════════════════════════╗
+║           FlowRed Runtime Service                            ║
+╠══════════════════════════════════════════════════════════════╣
+║  REST API + SSE Events                                       ║
+║  Port: ${port}                                                    ║
+║  Host: ${host}                                             ║
+║  Log Level: ${process.env.LOG_LEVEL || "info"}                                         ║
+╠══════════════════════════════════════════════════════════════╣
+║  Endpoints:                                                  ║
+║  • POST /deploy        - Deploy a flow                       ║
+║  • POST /stop          - Stop a flow                         ║
+║  • POST /inject        - Execute inject node                 ║
+║  • POST /context/clear - Clear flow context                  ║
+║  • GET  /status        - Runtime status                      ║
+║  • GET  /events        - SSE events (flowId required)        ║
+║  • GET  /health        - Health check                        ║
+╚══════════════════════════════════════════════════════════════╝
+        `);
+            }
+            // Restore persisted flows after server starts
+            await restorePersistedFlows();
+            resolve(server);
+        });
+        server.on("error", (error) => {
+            reject(error);
+        });
+    });
+}
+// ============================================================================
+// AUTO-START (when run directly, not imported)
+// ============================================================================
+// Only auto-start if this file is run directly (not imported as module)
+const isMainModule = require.main === module;
+if (isMainModule) {
+    createServer().catch((error) => {
+        console.error("Failed to start server:", error.message);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=server.js.map