@5minds/node-red-contrib-processcube 1.16.1-feature-5e019f-mhojvcvu → 1.16.1-feature-b8d70b-mhvx8c1e

package/externaltask-error.js

@@ -3,10 +3,10 @@ module.exports = function (RED) {
         RED.nodes.createNode(this, config);
         var node = this;
 
-        node.on('input', function (msg) {
+        node.on('input', function (msg) {            
             const flowNodeInstanceId = msg.flowNodeInstanceId;
             const etw_input_node_id = msg.etw_input_node_id;
-
+           
             if (!etw_input_node_id) {
                 node.error('Error: The message did not contain the required etw_input_node_id.');
             } else {
@@ -24,7 +24,7 @@ module.exports = function (RED) {
                         if (msgError.code) {
                             errorCode = msgError.code;
                             errorMessage = msgError.message;
-                        }
+                        } 
                     } else if (msg.errorCode) {
                         errorCode = msg.errorCode;
                         errorMessage = msg.errorMessage;

package/externaltask-input.js

@@ -1,9 +1,128 @@
 const EventEmitter = require('node:events');
 
+class ExternalTaskNodeStates {
+    constructor(flowNodeInstanceId) {
+        this.flowNodeInstanceId = flowNodeInstanceId;
+        this.nodeStades = {}; // Track send calls per nodeId
+    }
+
+    markSended(nodeId) {
+        if (!this.nodeStades[nodeId]) {
+            this.nodeStades[nodeId] = { gotSend: false, gotCompleted: false };
+        }
+
+        console.log(`[DEBUG] markSended - flowNodeInstanceId: ${this.flowNodeInstanceId}, nodeId: ${nodeId}, before: ${JSON.stringify(this.nodeStades[nodeId])}`);
+        this.nodeStades[nodeId].gotSend = true;
+        console.log(`[DEBUG] markSended - after: ${JSON.stringify(this.nodeStades[nodeId])}`);
+    }
+
+    markCompleted(nodeId) {
+        if (!this.nodeStades[nodeId]) {
+            this.nodeStades[nodeId] = { gotSend: false, gotCompleted: false };
+        }
+
+        console.log(`[DEBUG] markCompleted - flowNodeInstanceId: ${this.flowNodeInstanceId}, nodeId: ${nodeId}, before: ${JSON.stringify(this.nodeStades[nodeId])}`);
+        this.nodeStades[nodeId].gotCompleted = true;
+        console.log(`[DEBUG] markCompleted - after: ${JSON.stringify(this.nodeStades[nodeId])}`);
+    }
+
+    checkIfCompletedWithoutSend(nodeId) {
+        const nodeState = this.nodeStades[nodeId];
+        const result = (nodeState && nodeState.gotCompleted && !nodeState.gotSend);
+
+        console.log(`[DEBUG] checkIfCompletedWithoutSend - flowNodeInstanceId: ${this.flowNodeInstanceId}, nodeId: ${nodeId}, nodeState: ${JSON.stringify(nodeState)}, result: ${result}`);
+        return result;
+    }
+}
+
 module.exports = function (RED) {
 
     const os = require('os');
 
+    // Global dictionary for tracking external tasks by flowNodeInstanceId
+    const globalExternalTaskStates = {};
+    
+    const raiseExternalTaskError = (flowNodeInstanceId, etwInputNodeId, nodeId) => {
+        const fullNode = RED.nodes.getNode(nodeId);
+
+        const wires = fullNode?.wires;
+        const hasConnectedOutputs = wires && wires.some(wireArray => wireArray && wireArray.length > 0);
+
+        console.log(`[DEBUG] raiseExternalTaskError called for flowNodeInstanceId: ${flowNodeInstanceId}, nodeId: ${nodeId}, hasConnectedOutputs: ${hasConnectedOutputs}`);
+
+        if (hasConnectedOutputs) {
+            const inputNode = RED.nodes.getNode(etwInputNodeId);
+
+            if (inputNode && inputNode.eventEmitter) {
+                const errorMessage = `Node ${nodeId} (${fullNode.name || fullNode.type}) completed without sending output`;
+                const error = new Error(errorMessage);
+                error.errorCode = 'NODE_NO_OUTPUT';
+                error.errorDetails = RED.util.encodeObject({
+                    flowNodeInstanceId: flowNodeInstanceId,
+                    nodeId: nodeId,
+                    nodeName: fullNode.name,
+                    nodeType: fullNode.type
+                });
+
+                console.log(`[DEBUG] Emitting error event for flowNodeInstanceId: ${flowNodeInstanceId}, error: ${errorMessage}`);
+                inputNode.eventEmitter.emit(`handle-${flowNodeInstanceId}`, error, true);
+            } else {
+                console.log(`[DEBUG] Cannot raise error - inputNode or eventEmitter not found for etwInputNodeId: ${etwInputNodeId}`);
+            }
+        }
+    };
+
+    // Example synchronous onSend hook
+    RED.hooks.add("onSend", (sendEvents) => {
+        for (const sendEvent of sendEvents) {
+
+             // Call send method on ExternalTaskState if this message has a flowNodeInstanceId
+             if (sendEvent.msg?.flowNodeInstanceId) {
+                let externalTaskNodeStates = globalExternalTaskStates[sendEvent.msg.flowNodeInstanceId];
+
+                console.log(`[DEBUG] onSend - flowNodeInstanceId: ${sendEvent.msg.flowNodeInstanceId}, nodeId: ${sendEvent.source.node.id}, stateExists: ${!!externalTaskNodeStates}`);
+
+                if (!externalTaskNodeStates) {
+                    console.log(`[DEBUG] onSend - Creating NEW ExternalTaskNodeStates for flowNodeInstanceId: ${sendEvent.msg.flowNodeInstanceId}`);
+                    externalTaskNodeStates = new ExternalTaskNodeStates(sendEvent.msg.flowNodeInstanceId);
+                    globalExternalTaskStates[sendEvent.msg.flowNodeInstanceId] = externalTaskNodeStates;
+                }
+
+                externalTaskNodeStates.markSended(sendEvent.source.node.id)
+
+                if (externalTaskNodeStates.checkIfCompletedWithoutSend(sendEvent.source.node.id)) {
+                    console.log(`[DEBUG] onSend - Node completed without send detected! Raising error for nodeId: ${sendEvent.source.node.id}`);
+                    raiseExternalTaskError(sendEvent.msg.flowNodeInstanceId, sendEvent.msg.etw_input_node_id, sendEvent.source.node.id);
+                }
+             }
+        }
+    });
+
+    const onCompleted = (completeEvent) => {
+
+        // Check if this is an external task message
+        if (completeEvent.msg?.flowNodeInstanceId) {
+            let externalTaskNodeStates = globalExternalTaskStates[completeEvent.msg.flowNodeInstanceId];
+
+            console.log(`[DEBUG] onComplete - flowNodeInstanceId: ${completeEvent.msg.flowNodeInstanceId}, nodeId: ${completeEvent.node.id}, stateExists: ${!!externalTaskNodeStates}`);
+
+            if (!externalTaskNodeStates) {
+                console.log(`[DEBUG] onComplete - Creating NEW ExternalTaskNodeStates for flowNodeInstanceId: ${completeEvent.msg.flowNodeInstanceId}`);
+                externalTaskNodeStates = new ExternalTaskNodeStates(completeEvent.msg.flowNodeInstanceId);
+                globalExternalTaskStates[completeEvent.msg.flowNodeInstanceId] = externalTaskNodeStates;
+            }
+
+            externalTaskNodeStates.markCompleted(completeEvent.node.id);
+
+            if (externalTaskNodeStates.checkIfCompletedWithoutSend(completeEvent.node.id)) {
+                console.log(`[DEBUG] onComplete - Node completed without send detected! Raising error for nodeId: ${completeEvent.node.id}`);
+                raiseExternalTaskError(completeEvent.msg.flowNodeInstanceId, completeEvent.msg.etw_input_node_id, completeEvent.node.id);
+            }
+        }
+    }
+
+    RED.hooks.add("onComplete", onCompleted);
+
     function ExternalTaskInput(config) {
         RED.nodes.createNode(this, config);
         var node = this;
@@ -165,60 +284,68 @@ module.exports = function (RED) {
         };
 
         const onPreDeliver = (sendEvent) => {
-            if (node.isHandling() && node.ownMessage(sendEvent.msg)) {  
-                
-                const sourceNode = sendEvent?.source?.node;
-                const destinationNode = sendEvent?.destination?.node;
+            try {
+                if (node.isHandling() && node.ownMessage(sendEvent.msg)) {
 
-                node._step = `${destinationNode.name || destinationNode.type}`;
+                    const sourceNode = sendEvent?.source?.node;
+                    const destinationNode = sendEvent?.destination?.node;
 
-                node.showStatus();
+                    node._step = `${destinationNode.name || destinationNode.type}`;
 
-                const debugMsg = {
-                    event: 'enter',
-                    sourceName: sourceNode.name,
-                    sourceType: sourceNode.type,
-                    destinationNodeName: destinationNode.name,
-                    destinationNodeType: destinationNode.type,
-                    timestamp: new Date().toISOString(),
-                };
+                    node.showStatus();
+
+                    const debugMsg = {
+                        event: 'enter',
+                        sourceName: sourceNode.name,
+                        sourceType: sourceNode.type,
+                        destinationNodeName: destinationNode.name,
+                        destinationNodeType: destinationNode.type,
+                        timestamp: new Date().toISOString(),
+                    };
 
-                node.traceExecution(debugMsg);
+                    node.traceExecution(debugMsg);
 
-                if (process.env.NODE_RED_ETW_STEP_LOGGING == 'true' || process.env.NODERED_ETW_STEP_LOGGING == 'true') {
-                    node._trace = `'${sourceNode.name || sourceNode.type}'->'${destinationNode.name || destinationNode.type}'`;
-                    node.log(`preDeliver: ${node._trace}`);
+                    if (process.env.NODE_RED_ETW_STEP_LOGGING == 'true' || process.env.NODERED_ETW_STEP_LOGGING == 'true') {
+                        node._trace = `'${sourceNode.name || sourceNode.type}'->'${destinationNode.name || destinationNode.type}'`;
+                        node.log(`preDeliver: ${node._trace}`);
+                    }
                 }
+            } catch (error) {
+                node.error(`Error in onPreDeliver: ${error?.message}`, { error: error });
             }
         };
-        RED.hooks.add('preDeliver', onPreDeliver);
+        RED.hooks.add(`preDeliver.etw-input-${node.id}`, onPreDeliver);
 
         const onPostDeliver = (sendEvent) => {
-            if (node.isHandling() && node.ownMessage(sendEvent.msg)) {
-                const sourceNode = sendEvent?.source?.node;
-                const destinationNode = sendEvent?.destination?.node;
-
-                node.decrMsgOnNode(sourceNode, sendEvent.msg);
-                node.incMsgOnNode(destinationNode, sendEvent.msg);
-
-                const debugMsg = {
-                    event: 'exit',
-                    sourceName: sourceNode.name,
-                    sourceType: sourceNode.type,
-                    destinationNodeName: destinationNode.name,
-                    destinationNodeType: destinationNode.type,
-                    timestamp: new Date().toISOString(),
-                };
+            try {
+                if (node.isHandling() && node.ownMessage(sendEvent.msg)) {
+                    const sourceNode = sendEvent?.source?.node;
+                    const destinationNode = sendEvent?.destination?.node;
+
+                    node.decrMsgOnNode(sourceNode, sendEvent.msg);
+                    node.incMsgOnNode(destinationNode, sendEvent.msg);
+
+                    const debugMsg = {
+                        event: 'exit',
+                        sourceName: sourceNode.name,
+                        sourceType: sourceNode.type,
+                        destinationNodeName: destinationNode.name,
+                        destinationNodeType: destinationNode.type,
+                        timestamp: new Date().toISOString(),
+                    };
 
-                node.traceExecution(debugMsg);
+                    node.traceExecution(debugMsg);
 
-                if (process.env.NODE_RED_ETW_STEP_LOGGING == 'true' || process.env.NODERED_ETW_STEP_LOGGING == 'true') {
-                    node._trace = `'${sourceNode.name || sourceNode.type}'->'${destinationNode.name || destinationNode.type}'`;
-                    node.log(`postDeliver: ${node._trace}`);
+                    if (process.env.NODE_RED_ETW_STEP_LOGGING == 'true' || process.env.NODERED_ETW_STEP_LOGGING == 'true') {
+                        node._trace = `'${sourceNode.name || sourceNode.type}'->'${destinationNode.name || destinationNode.type}'`;
+                        node.log(`postDeliver: ${node._trace}`);
+                    }
                 }
+            } catch (error) {
+                node.error(`Error in onPostDeliver: ${error?.message}`, { error: error });
             }
         };
-        RED.hooks.add('postDeliver', onPostDeliver);
+        RED.hooks.add(`postDeliver.etw-input-${node.id}`, onPostDeliver);
 
         node.setSubscribedStatus = () => {
             this._subscribed = true;
@@ -349,15 +476,34 @@ module.exports = function (RED) {
                 return;
             }
             const etwCallback = async (payload, externalTask) => {
+
+                console.log(`[DEBUG] etwCallback - NEW External Task received! flowNodeInstanceId: ${externalTask.flowNodeInstanceId}, processInstanceId: ${externalTask.processInstanceId}`);
+                console.log(`[DEBUG] etwCallback - Creating NEW ExternalTaskNodeStates for flowNodeInstanceId: ${externalTask.flowNodeInstanceId}`);
+                globalExternalTaskStates[externalTask.flowNodeInstanceId] = new ExternalTaskNodeStates(externalTask.flowNodeInstanceId);
+
                 const saveHandleCallback = (data, callback, msg) => {
                     try {
                         callback(data);
                         node.log(`send to engine *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}', topic '${node.topic}' and *processInstanceId* ${externalTask.processInstanceId}`);
+
+                        // Remove ExternalTaskState from global dictionary
+                        if (globalExternalTaskStates[externalTask.flowNodeInstanceId]) {
+                            console.log(`[DEBUG] saveHandleCallback SUCCESS - Deleting ExternalTaskNodeStates for flowNodeInstanceId: ${externalTask.flowNodeInstanceId}`);
+                            delete globalExternalTaskStates[externalTask.flowNodeInstanceId];
+                        }
+
                         node.setFinishHandlingTaskStatus(externalTask);
                     } catch (error) {
+                        // Remove ExternalTaskState from global dictionary on error as well
+                        if (globalExternalTaskStates[externalTask.flowNodeInstanceId]) {
+                            console.log(`[DEBUG] saveHandleCallback ERROR - Deleting ExternalTaskNodeStates for flowNodeInstanceId: ${externalTask.flowNodeInstanceId}, error: ${error?.message}`);
+                            delete globalExternalTaskStates[externalTask.flowNodeInstanceId];
+                        }
+
                         node.setErrorFinishHandlingTaskStatus(externalTask, error);
                         msg.error = error;
                         node.error(`failed send to engine *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}', topic '${node.topic}' and *processInstanceId* ${externalTask.processInstanceId}: ${error?.message}`, msg);
+                        callback(error);
                     }
                 };
 
@@ -378,6 +524,7 @@ module.exports = function (RED) {
                     };
 
                     const handleErrorTask = (error) => {
+                        console.log(`[DEBUG] handleErrorTask - flowNodeInstanceId: ${externalTask.flowNodeInstanceId}, errorCode: ${error?.errorCode}, errorMessage: ${error?.message}`);
                         node.log(
                             `handle error event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' on *msg._msgid* '${error.errorDetails?._msgid}'.`
                         );
@@ -390,6 +537,8 @@ module.exports = function (RED) {
                     };
 
                     node.eventEmitter.once(`handle-${externalTask.flowNodeInstanceId}`, (msg, isError = false) => {
+                        console.log(`[DEBUG] eventEmitter handle event - flowNodeInstanceId: ${externalTask.flowNodeInstanceId}, isError: ${isError}, msgId: ${msg._msgid}`);
+
                         try {
                             msg.etw_finished_at = new Date().toISOString();
 
@@ -397,7 +546,7 @@ module.exports = function (RED) {
                                 msg.etw_duration = new Date(msg.etw_finished_at) - new Date(msg.etw_started_at);
                             }
                         } catch (error) {
-                            node.error(`failed to calculate duration: ${error?.message}`, msg);   
+                            node.error(`failed to calculate duration: ${error?.message}`, msg);
                         }
 
                         node.log(
@@ -406,8 +555,10 @@ module.exports = function (RED) {
 
 
                         if (isError) {
+                            console.log(`[DEBUG] Routing to handleErrorTask`);
                             handleErrorTask(msg);
                         } else {
+                            console.log(`[DEBUG] Routing to handleFinishTask`);
                             handleFinishTask(msg);
                         }
                     });
@@ -429,6 +580,7 @@ module.exports = function (RED) {
                     );
 
                     node.send(msg);
+                    console.log(`[DEBUG] etwCallback - Sent message for flowNodeInstanceId: ${externalTask.flowNodeInstanceId}, msgId: ${msg._msgid}`);
                 });
             };
 
@@ -488,12 +640,12 @@ module.exports = function (RED) {
 
                     node.on('close', () => {
                         try {
-                            RED.hooks.remove('preDeliver', onPreDeliver);
-                            RED.hooks.remove('postDeliver', onPostDeliver);
                             externalTaskWorker.stop();
+                            RED.hooks.remove(`preDeliver.etw-input-${node.id}`);
+                            RED.hooks.remove(`postDeliver.etw-input-${node.id}`);
                             node.log('External Task Worker closed.');
-                        } catch {
-                            node.error('Client close failed', {});
+                        } catch (error) {
+                            node.error(`Client close failed: ${JSON.stringify(error)}`);
                         }
                     });
                 })

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@5minds/node-red-contrib-processcube",
-    "version": "1.16.1-feature-5e019f-mhojvcvu",
+    "version": "1.16.1-feature-b8d70b-mhvx8c1e",
     "license": "MIT",
     "description": "Node-RED nodes for ProcessCube",
     "scripts": {
@@ -39,7 +39,6 @@
             "DataobjectInstanceQuery": "dataobject-instance-query.js",
             "EndEventFinishedListener": "endevent-finished-listener.js",
             "externaltaskInput": "externaltask-input.js",
-            "externaltaskInject": "externaltask-inject.js",
             "externaltaskOutput": "externaltask-output.js",
             "externaltaskError": "externaltask-error.js",
             "externaltaskEventListener": "externaltask-event-listener.js",

package/externaltask-inject.html

@@ -1,123 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('externaltask-inject', {
-        category: 'ProcessCube',
-        color: '#02AFD6',
-        defaults: {
-            name: { value: '' },
-            payloadType: { value: 'json' },
-            payload: { value: '{}' },
-            taskType: { value: 'json' },
-            task: { value: '{}' }
-        },
-        inputs: 0,
-        outputs: 1,
-        icon: 'inject.svg',
-        label: function () {
-            return this.name || 'externaltask-inject';
-        },
-        button: {
-            onclick: function() {
-                var node = this;
-
-                $.ajax({
-                    type: "POST",
-                    url: "externaltask-inject/trigger/" + node.id,
-                    success: function(resp) {
-                        RED.notify("Message injected", "success");
-                    },
-                    error: function(xhr, status, err) {
-                        RED.notify("Error injecting message: " + err, "error");
-                    }
-                });
-            }
-        },
-        oneditprepare: function () {
-            // Initialize the typed input for payload
-            $('#node-input-payload').typedInput({
-                default: 'json',
-                types: ['str', 'num', 'bool', 'json', 'jsonata', 'flow', 'global']
-            });
-            // Restore the saved type for payload from hidden input
-            var payloadType = $('#node-input-payloadType').val();
-            if (payloadType) {
-                $('#node-input-payload').typedInput('type', payloadType);
-            }
-
-            // Initialize the typed input for task
-            $('#node-input-task').typedInput({
-                default: 'json',
-                types: ['str', 'num', 'bool', 'json', 'jsonata', 'flow', 'global']
-            });
-            // Restore the saved type for task from hidden input
-            var taskType = $('#node-input-taskType').val();
-            if (taskType) {
-                $('#node-input-task').typedInput('type', taskType);
-            }
-        },
-        oneditsave: function () {
-            var payloadValue = $('#node-input-payload').typedInput('value');
-            var payloadType = $('#node-input-payload').typedInput('type');
-            this.payload = payloadValue;
-            this.payloadType = payloadType;
-            // Persist type to hidden input field
-            $('#node-input-payloadType').val(payloadType);
-
-            var taskValue = $('#node-input-task').typedInput('value');
-            var taskType = $('#node-input-task').typedInput('type');
-            this.task = taskValue;
-            this.taskType = taskType;
-            // Persist type to hidden input field
-            $('#node-input-taskType').val(taskType);
-        }
-     });
-</script>
-
-<script type="text/html" data-template-name="externaltask-inject">
-    <div class="form-row">
-        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
-        <input type="text" id="node-input-name" placeholder="Name" />
-    </div>
-    <div class="form-row">
-        <label for="node-input-payload">msg.payload</label>
-        <input type="hidden" id="node-input-payloadType">
-        <input type="text" id="node-input-payload" style="width: 70%;">
-    </div>
-    <div class="form-row">
-        <label for="node-input-task">msg.task</label>
-        <input type="hidden" id="node-input-taskType">
-        <input type="text" id="node-input-task" style="width: 70%;">
-    </div>
-</script>
-
-<script type="text/markdown" data-help-name="externaltask-inject">
-A lightweight alternative to the standard Node-RED inject node for testing external task workflows. Use this node to inject test messages directly into an external task workflow without needing a real external task from the ProcessCube engine.
-
-This node is ideal for small-scale testing and debugging of external task workflows. For larger-scale testing with test cases or CI/CD integration, use the **externaltask-testing** node instead.
-
-## Features
-
-- Injects messages with configurable payload and task metadata
-- Automatically generates `flowNodeInstanceId` and `processInstanceId` if not provided
-- Sets required fields for compatibility with externaltask-output and externaltask-error nodes
-- Supports multiple value types (JSON, string, number, boolean, JSONata, flow/global context)
-
-## Configs
-
-: name (string) : The name of the node
-: payload (string | {}) : The payload to inject into the workflow
-: task (string | {}) : The task object to inject
-
-## Outputs
-
-: payload (string | {}) : The injected payload with metadata (flowNodeInstanceId, processInstanceId, task)
-: task (object) : The injected task object
-: flowNodeInstanceId (string) : Unique identifier for the external task
-: processInstanceId (string) : Reference to the process instance
-: etw_input_node_id (string) : Reference to the injecting node
-: etw_started_at (string) : ISO timestamp of when the task was injected
-
-## References
-
--   [The ProcessCube&copy; Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform
--   [ProcessCube&copy; LowCode Integration](https://processcube.io/docs/node-red) - LowCode integration in ProcessCube&copy;
-</script>

package/externaltask-inject.js

@@ -1,98 +0,0 @@
-const { v4: uuidv4 } = require('uuid');
-const EventEmitter = require('node:events');
-
-module.exports = function (RED) {
-    function ExternalTaskInject(config) {
-        RED.nodes.createNode(this, config);
-        var node = this;
-        node.config = config;
-        node.eventEmitter = new EventEmitter();
-
-        node.on('input', function (msg, send, done) {
-            msg.flowNodeInstanceId = msg.flowNodeInstanceId ?? uuidv4();
-            msg.processInstanceId = msg.processInstanceId ?? uuidv4();
-
-            if (!msg.task) {
-                // Use configured task if available, otherwise create default
-                if (config.task) {
-                    msg.task = config.task;
-                } else {
-                    msg.task = {
-                        flowNodeInstanceId: msg.flowNodeInstanceId,
-                        processInstanceId: msg.processInstanceId,
-                        task: {}
-                    }
-                }
-            }
-            msg.etw_started_at = new Date().toISOString();
-            msg.etw_input_node_id = node.id;
-
-            send(msg);
-            if (done) done();
-        });
-
-    }
-
-    RED.nodes.registerType('externaltask-inject', ExternalTaskInject);
-
-    // Helper function to parse typed values
-    function parseTypedValue(value, type) {
-        switch(type) {
-            case 'str':
-                return value || '';
-            case 'num':
-                return Number(value) || 0;
-            case 'bool':
-                return value === 'true' || value === true;
-            case 'json':
-                try {
-                    return JSON.parse(value || '{}');
-                } catch(parseErr) {
-                    console.error("Invalid JSON: " + parseErr.message);
-                    return {};
-                }
-            case 'jsonata':
-                // JSONata expressions would need to be evaluated in Node-RED context
-                // For now, treat as string
-                return value || '';
-            case 'flow':
-            case 'global':
-                // These are context references - store as string for now
-                return value || '';
-            default:
-                return value || '';
-        }
-    }
-
-    // HTTP endpoint to handle button clicks
-    RED.httpAdmin.post('/externaltask-inject/trigger/:id', function(req, res) {
-        var node = RED.nodes.getNode(req.params.id);
-        if (node !== null && typeof node !== 'undefined') {
-            try {
-                var payloadValue = node.config.payload;
-                var payloadType = node.config.payloadType || 'json';
-                var payloadData = parseTypedValue(payloadValue, payloadType);
-
-                var taskValue = node.config.task;
-                var taskType = node.config.taskType || 'json';
-                var taskData = parseTypedValue(taskValue, taskType);
-
-                // Create a message with the configured payload and task
-                var msg = {
-                    payload: payloadData,
-                    task: taskData,
-                    _msgid: uuidv4()
-                };
-
-                // Trigger the node's input handler with the configured message
-                node.receive(msg);
-                res.sendStatus(200);
-            } catch(err) {
-                res.sendStatus(500);
-                node.error("Error injecting message: " + err.message);
-            }
-        } else {
-            res.sendStatus(404);
-        }
-    });
-};