@inteli.city/node-red-contrib-exec-collection 1.0.4 → 1.0.5

package/exec.service.js

@@ -1,548 +1,386 @@
-/** ////
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **///
-module.exports = function(RED) {
-    //* libraries
-    "use strict";
-    var mustache = require("mustache");
-    var fs = require('fs');
-    var tmp = require('tmp-promise');
-    var fsPromises = require('fs').promises;
-    var terminate = require("terminate");
-    var yaml = require("js-yaml");
-    var convertXML = require('xml-js');
-    var exec = require('child_process').exec;
-    var spawn = require('child_process').spawn;
-    var Queue = require('queue');
-    var pm2 = require('pm2');
-    //* auxiliary functions
-    //** function: extractTokens
-    function extractTokens(tokens, set) {
-        set = set || new Set();
-        tokens.forEach(function(token) {
-            if (token[0] !== 'text') {
-                set.add(token[1]);
-                if (token.length > 4) {
-                    extractTokens(token[4], set);
-                }
-            }
-        });
-        return set;
-    }
+'use strict';
 
-    //** function: parseContext
-    function parseContext(key) {
-        var match = /^(flow|global)(\[(\w+)\])?\.(.+)/.exec(key);
-        if (match) {
-            var parts = {};
-            parts.type = match[1];
-            parts.store = (match[3] === '') ? "default" : match[3];
-            parts.field = match[4];
-            return parts;
-        }
-        return undefined;
-    }
+// ── requires ──────────────────────────────────────────────────────────────────
 
-    //** function: parseEnv
-    function parseEnv(key) {
-        var match = /^env\.(.+)/.exec(key);
-        if (match) {
-            return match[1];
-        }
-        return undefined;
+const { spawn }         = require('child_process');
+const fs                = require('fs');
+const tmp               = require('tmp-promise');
+const nunjucks          = require('nunjucks');
+const yaml              = require('js-yaml');
+const convertXML        = require('xml-js');
+const { StringDecoder } = require('string_decoder');
+const { buildContext }  = require('./utils/context');
+
+// ── platform ──────────────────────────────────────────────────────────────────
+
+function getPlatformConfig() {
+    if (process.platform === 'win32') {
+        return { shell: 'cmd.exe', args: ['/d', '/s', '/c'] };
     }
+    return { shell: '/bin/bash', args: ['-c'] };
+}
 
+const PLATFORM = getPlatformConfig();
 
-    /**
-     * Custom Mustache Context capable to collect message property and node
-     * flow and global context
-     */
+// ── shell helpers ─────────────────────────────────────────────────────────────
 
-    //** function: remove_by_value (prototype)
-    Array.prototype.remove_by_value = function(val) {
-        for (var i = 0; i < this.length; i++) {
-            if (this[i] === val) {
-                this.splice(i, 1);
-                i--;
-            }
-        }
-        return this;
+// Sets $file / %file% before running the command, matching exec.queue behaviour.
+function buildShellcode(filePath, command) {
+    if (PLATFORM.shell === 'cmd.exe') {
+        return `set "file=${filePath}" && ${command}`;
     }
-    //** function: NodeContext
-    class NodeContext extends mustache.Context {
-        constructor(msg, nodeContext, parent, escapeStrings, cachedContextTokens) {
-            super(msg, parent);
-            this.nodeContext = nodeContext;
-            this.escapeStrings = escapeStrings;
-            this.cachedContextTokens = cachedContextTokens;
-        }
-
-        lookup(name) {
-            try {
-                var value = super.lookup(name);
-                if (value !== undefined) {
-                    if (typeof value === "object") {
-                        value = JSON.stringify(value);
-                    }
-                    if (this.escapeStrings && typeof value === "string") {
-                        value = value.replace(/\\/g, "\\\\")
-                            .replace(/\n/g, "\\n")
-                            .replace(/\t/g, "\\t")
-                            .replace(/\r/g, "\\r")
-                            .replace(/\f/g, "\\f")
-                            .replace(/[\b]/g, "\\b");
-                    }
-                    return value;
-                }
+    return `\nexport NODE_PATH="$NODE_PATH:/usr/local/lib/node_modules"\nfile="${filePath}"\n${command}\n`;
+}
 
-                if (parseEnv(name)) {
-                    return this.cachedContextTokens[name];
-                }
+// ── output parsing ────────────────────────────────────────────────────────────
 
-                var context = parseContext(name);
-                if (context) {
-                    var target = this.nodeContext[context.type];
-                    if (target) {
-                        return this.cachedContextTokens[name];
-                    }
-                }
-                return '';
-            } catch (err) {
-                throw err;
+// Pure: parses rawValue per outputFormat.
+// Returns { value } on success, { error: string } on failure.
+function parseOutputValue(rawValue, outputFormat) {
+    if (outputFormat === 'parsedJSON') {
+        try {
+            const parsed = JSON.parse(rawValue);
+            if (typeof parsed === 'number') {
+                return { error: 'Error parsing JSON: result is a plain number' };
             }
+            return { value: parsed };
+        } catch (err) {
+            return { error: 'Error parsing JSON:\n\n' + err };
         }
+    }
 
-        push(view) {
-            return new NodeContext(view, this.nodeContext, this, undefined, this.cachedContextTokens);
+    if (outputFormat === 'parsedXML') {
+        try {
+            return { value: convertXML.xml2js(rawValue, { compact: true, spaces: 4 }) };
+        } catch (err) {
+            return { error: 'Error parsing XML:\n\n' + err };
         }
     }
 
-    //* ExecQueueNode
-    function ExecQueueNode(n) {
-        //** setting values
-        RED.nodes.createNode(this, n);
-        this.name = n.name;
-        this.field = n.field || "payload";
-        // this.template = n.template;
-        this.template = n.template === "" ? " " : n.template; // gambiarra (arrumar)
-        this.syntax = n.syntax || "javascript";
-        this.fieldType = n.fieldType || "msg";
-        this.outputFormat = n.output || "str";
-
-        this.cmd = (n.command || "").trim();
-        this.append = (n.append || "").trim();
-        this.useSpawn = n.useSpawn
-        this.inputEmpty = n.inputEmpty
-        this.count = 0
-        this.state = ""
-        this.queue = n.queue
-        this.executingCode = 0
-        this.waitingForExecuting = 0
-        this.processKilled = false
-        this.statusTimerUp = new Date()
-        this.statusTimerDown = new Date()
-        // this.addpayCB = n.addpayCB
-        this.cmdTemplate = n.cmdTemplate
-        this.cmd = (n.command || "").trim();
-        //this.parsedJSON = n.parsedJSON
-        this.splitLine = n.splitLine
-        this.cleanQueue = n.cleanQueue
-
-        if (n.addpay === undefined) { n.addpay = true; }
-        this.addpay = n.addpay;
-        this.append = (n.append || "").trim();
-        this.useSpawn = (n.useSpawn == "true");
-        this.timer = Number(n.timer || 0) * 1000;
-        this.activeProcesses = {};
-        this.tempFiles = []
-        this.oldrc = (n.oldrc || false).toString();
-        //this.execOpt = {maxBuffer:50000000, windowsHide: (n.winHide === true)};
-        //this.execOpt = {encoding:'binary', maxBuffer:50000000, windowsHide: (n.winHide === true)};
-        this.execOpt = { maxBuffer: 50000000, windowsHide: (n.winHide === true), detached: true };
-        this.spawnOpt = { windowsHide: (n.winHide === true), detached: true }
-        this.executed = false;
-
-        //    this.timer = Number(n.timer || 0)*1000;
-        //    this.activeProcesses = {};
-        //    this.oldrc = (n.oldrc || false).toString();
-        //    this.execOpt = {encoding:'binary', maxBuffer:50000000, windowsHide: (n.winHide === true)};
-        //    this.spawnOpt = {windowsHide: (n.winHide === true) }
-        var node = this;
-        //** node initialization setup
-        if (process.platform === 'linux' && fs.existsSync('/bin/bash')) { node.execOpt.shell = '/bin/bash'; }
-        if ( node.inputEmpty == false  ){
-            node.status({ fill: "yellow", shape: "ring", text: '(0/1)' });
+    if (outputFormat === 'parsedYAML') {
+        try {
+            const parsed = yaml.load(rawValue);
+            if (typeof parsed === 'number') {
+                return { error: 'Error parsing YAML: result is a plain number' };
+            }
+            return { value: parsed };
+        } catch (err) {
+            return { error: 'Error parsing YAML:\n\n' + err };
         }
+    }
 
+    return { value: rawValue };
+}
 
-        function emitInputMessage() { node.emit("input", {payload: 'play'}) }
-        //** node.on('input')
-        node.on("input", async function(msg, send, done) {
-            if (!node.executed) {
-                node.executed = true;
-                node.status({ fill: "blue", shape: "ring", text: '(1/1)' });
-                try {
-                    msg.nodeName = node.name;
 
-                    node.warn(msg.payload);
-                } catch (err) {
-                    done(err.message);
-                }
+// ── node definition ───────────────────────────────────────────────────────────
+
+module.exports = function(RED) {
+
+    function ExecServiceNode(n) {
+        RED.nodes.createNode(this, n);
+
+        this.name         = n.name;
+        this.command      = (n.command || '').trim();
+        this.template     = n.template || '';
+        this.outputFormat = n.output    || 'str';
+        this.field        = n.field     || 'payload';
+        this.fieldType    = n.fieldType || 'msg';
+        this.streamMode   = n.streamMode || 'delimited';
+        this.restartDelay = Math.max(0, Number(n.restartDelay) || 3000);
+        this.maxRetries   = Math.max(0, Number(n.maxRetries)   || 0); // 0 = infinite
+
+        // Interpret escape sequences in the stored delimiter string
+        const delimRaw = (n.delimiter !== undefined && n.delimiter !== '') ? n.delimiter : '\\n';
+        this.delimiter = delimRaw.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\r/g, '\r');
+
+        const node = this;
+
+        // ── state ─────────────────────────────────────────────────────────────
+
+        let desiredState   = 'running'; // 'running' | 'stopped'
+        let proc           = null;      // active child process (or null)
+        let retryCount     = 0;
+        let restartTimer   = null;
+        let successTimer   = null;
+        let segmentBuffer  = '';
+        let closing        = false;
+        let currentTempFile = null;     // path of the rendered $file temp file
+
+        // ── status ────────────────────────────────────────────────────────────
+
+        function updateStatus(state, retry) {
+            node._serviceState = state;
+            if (state === 'running') {
+                node.status({ fill: 'blue', shape: 'ring', text: 'running' });
+            } else if (state === 'restarting') {
+                const label = retry ? `restarting (retry ${retry})` : 'restarting';
+                node.status({ fill: 'yellow', shape: 'ring', text: label });
             } else {
-                node.warn("Service already running.");
+                node.status({ fill: 'grey', shape: 'dot', text: 'stopped' });
             }
-        });
-
+        }
 
-        //** node.on('close')
-        node.on('close', async function() {
-            //// KILL PROCESSES AND ERASE FILES
-            node.executed = false;
-            node.status({ fill: "blue", shape: "ring", text: '(1/1)' });
-            // node.executingCode = 0
-            // node.waitingForExecuting = 0
-            // node.processKilled = true
-            // for (var pid in node.activeProcesses) {
-            //     /* istanbul ignore else  */
-            //     if (node.activeProcesses.hasOwnProperty(pid)) {
-            //         // process.kill(-pid, 9)
-            //         terminate(pid)
-            //         node.activeProcesses[pid] = null;
-            //         node.warn(`Killing pid ${pid}`)
-            //     }
-            // }
-
-            // for (let i = 0, len = node.tempFiles.length; i < len; i++) {
-            //     await fsPromises.unlink(file);
-            // }
-            // node.activeProcesses = {};
-        });
+        // ── output helpers ────────────────────────────────────────────────────
 
-        //** emmit first message
-        if ( node.inputEmpty == true  ){
-            emitInputMessage();
+        // Emit one parsed segment via node.send(). Guards against post-kill emission.
+        function emitSegment(value) {
+            if (closing || desiredState === 'stopped') return;
+            const result = parseOutputValue(value, node.outputFormat);
+            if (result.error) {
+                node.error(result.error);
+                return;
+            }
+            if (node.fieldType === 'msg') {
+                const outMsg = {};
+                RED.util.setMessageProperty(outMsg, node.field, result.value);
+                node.send(outMsg);
+            } else {
+                const context = RED.util.parseContextStore(node.field);
+                const target  = node.context()[node.fieldType];
+                const outMsg  = {};
+                target.set(context.key, result.value, context.store, (err) => {
+                    if (err) node.error(err);
+                    else node.send(outMsg);
+                });
+            }
         }
 
-        //** executeCode
-        async function executeCode(msg, send, done, node, resolvedTokens) {
+        // Route a stdout chunk: raw → emit immediately; delimited → buffer and split.
+        function handleChunk(chunk) {
+            if (closing || desiredState === 'stopped') return;
+            if (node.streamMode === 'raw') {
+                emitSegment(chunk);
+                return;
+            }
+            segmentBuffer += chunk;
+            const parts = segmentBuffer.split(node.delimiter);
+            segmentBuffer = parts.pop(); // keep incomplete remainder
+            for (const part of parts) {
+                if (part) emitSegment(part);
+            }
+        }
 
-            // Create a temporary file asynchronously
-            const is_json = (node.outputFormat === "parsedJSON");
-            let template = node.template || msg.template;
-            const value = mustache.render(template, new NodeContext(msg, node.context(), null, is_json, resolvedTokens));
-            const tmpObj = await tmp.file();
-            await fsPromises.writeFile(tmpObj.path, value, 'utf8');
+        // ── process management ────────────────────────────────────────────────
 
-            let shellcode;
-            let resolvedCommand
-            if ( node.cmdTemplate ){
-                resolvedCommand = await resolveCommand(node.cmd, msg);
-            } else {
-                resolvedCommand = node.cmd
+        function cleanupTempFile() {
+            if (currentTempFile) {
+                try { fs.unlinkSync(currentTempFile); } catch (_) {}
+                currentTempFile = null;
             }
-            if (process.platform === 'win32') {  // For Windows
-                shellcode = `${resolvedCommand} ${addPayload} ${tmpObj.path}`;
-            } else {  // For Linux and macOS
-                shellcode = `
-export NODE_PATH="$NODE_PATH:$HOME/.node-red/node_modules:/usr/local/lib/node_modules"
-file="${tmpObj.path}"
-${resolvedCommand}
-            `;
+        }
+
+        function startProcess() {
+            if (closing || desiredState === 'stopped') return;
+
+            if (!node.command) {
+                node.warn('exec.service: no command configured');
+                desiredState = 'stopped';
+                updateStatus('stopped');
+                return;
             }
 
-            try {
-                if (!node.useSpawn) {
-                    await executeWithExec(shellcode, node, msg, send, done);
-                } else {
-                    await executeWithSpawn(shellcode, node, msg, send, done);
+            // ── template → $file ─────────────────────────────────────────────
+            // If a template is configured, render it with Nunjucks, write it to
+            // a temp file, and wrap the command in a shell snippet that sets
+            // $file to that path — identical to how exec.queue works.
+            let effectiveCommand = node.command;
+            cleanupTempFile();
+
+            if (node.template) {
+                try {
+                    const context = buildContext({}, node);
+                    const env     = new nunjucks.Environment(null, { autoescape: false });
+                    const rendered = env.renderString(node.template, context);
+                    const tmpObj  = tmp.fileSync();
+                    currentTempFile = tmpObj.name;
+                    fs.writeFileSync(tmpObj.name, rendered, 'utf8');
+                    effectiveCommand = buildShellcode(tmpObj.name, node.command);
+                } catch (e) {
+                    node.error('exec.service template error: ' + e.message);
+                    desiredState = 'stopped';
+                    updateStatus('stopped');
+                    return;
                 }
-            } finally {
-                await tmpObj.cleanup();
             }
-        }
 
-        async function executeWithExec(shellcode, node, msg, send, done) {
-            return new Promise((resolve) => {
-                const child = exec(shellcode, node.execOpt, (err, stdout, stderr) => {
-                    if (err) {
-                        const error = {
-                            type: 'error',
-                            code: err.code,
-                            killed: err.killed
-                        };
-                        msg.error_info = error;
-                        node.error(`error (${msg.nodeName})\n\n${stderr}`, msg);
-                    } else {
-                        if (stderr) {
-                            node.error(`warning (${msg.nodeName})\n\n${stderr}`, msg);
-                        }
-
-                        if (stdout) {
-                            stdout = stdout.trim();
-                            if (node.splitLine === false) {
-                                output(msg, stdout, send, done);
-                            } else {
-                                stdout = stdout.split('\n');
-                                for (let i = 0; i < stdout.length; i++) {
-                                    node.emit("input", { "message": stdout[i] });
-                                }
-                            }
-                        }
-                    }
-                    delete node.activeProcesses[child.pid];
-                    resolve();
-                });
-                node.activeProcesses[child.pid] = child.pid;
+            // Fresh decoder per process — avoids multibyte state leaking across restarts.
+            const decoder = new StringDecoder('utf8');
+            segmentBuffer = '';
+
+            const p = spawn(PLATFORM.shell, [...PLATFORM.args, effectiveCommand], {
+                stdio: ['ignore', 'pipe', 'pipe']
             });
-        }
+            proc = p;
 
-        async function executeWithSpawn(shellcode, node, msg, send, done) {
-            return new Promise((resolve, reject) => {
-                const child = spawn('/bin/bash', ['-c', shellcode], node.spawnOpt);
-                node.activeProcesses[child.pid] = child.pid;
-
-                child.stdout.on('data', (data) => {
-                    data = data.toString();
-                    if (node.splitLine === false) {
-                        output(msg, data, send, done);
-                    } else {
-                        const lines = data.split('\n');
-                        for (let line of lines) {
-                            if (line) {
-                                node.emit("input", { "message": line });
-                            }
-                        }
-                    }
-                });
+            updateStatus('running');
 
-                child.stderr.on('data', (data) => {
-                    node.error(`warning (${msg.nodeName})\n\n${data.toString()}`, msg);
-                });
+            // Reset retry counter if the process runs stably for 10 s.
+            if (successTimer) clearTimeout(successTimer);
+            successTimer = setTimeout(() => {
+                successTimer = null;
+                if (proc === p) retryCount = 0;
+            }, 10000);
 
-                child.on('close', (code) => {
-                    if (code !== 0) {
-                        const error = {
-                            type: 'error',
-                            code: code
-                        };
-                        msg.error_info = error;
-                        node.error(`error (${msg.nodeName}): The node hasn't finished its execution`, msg);
-                        reject(new Error(`Child process exited with code ${code}`));
-                    }
-                    delete node.activeProcesses[child.pid];
-                    resolve();
-                });
+            p.stdout.on('data', (data) => {
+                if (proc !== p) return; // stale event after kill
+                const text = decoder.write(data);
+                if (text) handleChunk(text);
             });
-        }
 
-        //** resolveTemplate
-        async function resolveTemplate(msg) {
-            var template = node.template;
-            if (msg.hasOwnProperty("template")) {
-                if (template == "" || template === null) {
-                    template = msg.template;
-                }
-            }
+            p.stderr.on('data', (data) => {
+                if (proc !== p) return;
+                const text = Buffer.isBuffer(data) ? data.toString() : String(data);
+                if (text && text.trim()) node.warn(text.trim());
+            });
+
+            p.on('error', (err) => {
+                if (proc !== p || closing) return;
+                proc = null;
+                if (successTimer) { clearTimeout(successTimer); successTimer = null; }
+                node.error(`exec.service error: ${(err && err.message) ? err.message : String(err)}`);
+                scheduleRestart();
+            });
 
-            var resolvedTokens = {};
-            var tokens = extractTokens(mustache.parse(template));
+            p.on('close', (code) => {
+                if (proc !== p || closing) return;
+                proc = null;
+                if (successTimer) { clearTimeout(successTimer); successTimer = null; }
 
-            // Iterate over the extracted tokens to resolve their values.
-            for (let name of tokens) {
-                let env_name = parseEnv(name);
-                if (env_name) {
-                    resolvedTokens[name] = RED.util.evaluateNodeProperty(env_name, 'env', node);
-                    continue;
+                // Flush any remaining buffered segment on clean exit.
+                if (node.streamMode === 'delimited' && segmentBuffer && desiredState === 'running') {
+                    emitSegment(segmentBuffer);
+                    segmentBuffer = '';
                 }
 
-                // Check if the token refers to a flow or global context variable.
-                let context = parseContext(name);
-                if (context) {
-                    let type = context.type;
-                    let store = context.store;
-                    let field = context.field;
-                    let target = node.context()[type];
-                    if (target) {
-                        resolvedTokens[name] = await new Promise((resolve, reject) => {
-                            target.get(field, store, (err, val) => {
-                                if (err) reject(err);
-                                else resolve(val);
-                            });
-                        });
+                if (desiredState === 'running') {
+                    if (code !== 0 && code !== null) {
+                        node.warn(`exec.service: process exited (code ${code})`);
                     }
+                    scheduleRestart();
                 }
-            }
-
-            return resolvedTokens;
+            });
         }
 
-        //** resolveCommand
-        async function resolveCommand(command, msg) {
-            return new Promise(async (resolve, reject) => {
-                try {
-                    // Extract tokens from the command string
-                    var tokens = extractTokens(mustache.parse(command));
-
-                    var resolvedTokens = {};
-
-                    // Iterate over the extracted tokens to resolve their values.
-                    for (let name of tokens) {
-                        let env_name = parseEnv(name);
-                        if (env_name) {
-                            resolvedTokens[name] = RED.util.evaluateNodeProperty(env_name, 'env', node);
-                            continue;
-                        }
-
-                        // Check if the token refers to a flow or global context variable.
-                        let context = parseContext(name);
-                        if (context) {
-                            let type = context.type;
-                            let store = context.store;
-                            let field = context.field;
-                            let target = node.context()[type];
-                            if (target) {
-                                resolvedTokens[name] = await new Promise((innerResolve, innerReject) => {
-                                    target.get(field, store, (err, val) => {
-                                        if (err) innerReject(err);
-                                        else innerResolve(val);
-                                    });
-                                });
-                            }
-                        }
-                    }
+        function scheduleRestart() {
+            if (closing || desiredState === 'stopped') return;
 
-                    var parsedCommand = mustache.parse(command);
-
-                    // Extract the variable names from the parsed tokens.
-                    var variableNames = parsedCommand
-                        .filter(token => token[0] === '&')
-                        .map(token => token[1]);
-
-                    var resolvedValues = {};
-
-                    // Resolve the values for each variable.
-                    for (let variableName of variableNames) {
-                        let env_name = parseEnv(variableName);
-                        if (env_name) {
-                            resolvedValues[variableName] = RED.util.evaluateNodeProperty(env_name, 'env', node);
-                            continue;
-                        }
-
-                        // Check if the variable refers to a flow or global context variable.
-                        let context = parseContext(variableName);
-                        if (context) {
-                            let type = context.type;
-                            let store = context.store;
-                            let field = context.field;
-                            let target = node.context()[type];
-                            if (target) {
-                                resolvedValues[variableName] = await new Promise((innerResolve, innerReject) => {
-                                    target.get(field, store, (err, val) => {
-                                        if (err) innerReject(err);
-                                        else innerResolve(val);
-                                    });
-                                });
-                            }
-                        } else {
-                            // If the variable is not in the context or an env variable, try to get it from the msg object.
-                            resolvedValues[variableName] = msg[variableName];
-                        }
-                    }
+            retryCount++;
 
-                    // Replace the variables in the original command with their resolved values.
-                    for (let variableName in resolvedValues) {
-                        command = command.replace(`{{{${variableName}}}}`, resolvedValues[variableName]);
-                    }
+            if (node.maxRetries > 0 && retryCount > node.maxRetries) {
+                node.error(`exec.service: max retries (${node.maxRetries}) exceeded — stopping`);
+                desiredState = 'stopped';
+                updateStatus('stopped');
+                return;
+            }
 
-                    console.log(command);
-                    resolve(command);  // Use the resolve here
-                } catch (error) {
-                    console.error("Error in resolveCommand:", error);
-                    reject(error);  // Use the reject here
-                }
-            });
+            updateStatus('restarting', retryCount);
+
+            if (restartTimer) clearTimeout(restartTimer);
+            restartTimer = setTimeout(() => {
+                restartTimer = null;
+                if (!closing && desiredState === 'running') startProcess();
+            }, node.restartDelay);
         }
 
-        //** function: output
-        function output(msg, value, send, done) {
-            /* istanbul ignore else  */
-            let parseError = false
-            //*** parse json
-            if (node.outputFormat === "parsedJSON") {
-                try {
-                    value = JSON.parse(value);
-                    if (typeof value === 'number') {
-                        parseError = true
-                        node.error('Error parsing JSON: \n\n' + error)
-                    }
-                } catch (error) {
-                    parseError = true
-                    node.error('Error parsing JSON: \n\n' + error)
-                }
+        // ── killAll ───────────────────────────────────────────────────────────
+        // Triggered by: msg.stop, HTTP endpoint, editor button, node.on('close').
+
+        function killAll() {
+            desiredState = 'stopped';
+            if (restartTimer) { clearTimeout(restartTimer); restartTimer = null; }
+            if (successTimer) { clearTimeout(successTimer); successTimer = null; }
+            segmentBuffer = '';
+            if (proc) {
+                const p = proc;
+                proc = null; // nullify before kill so close handler skips restart
+                try { p.kill('SIGTERM'); } catch (_) {}
             }
+            cleanupTempFile();
+            updateStatus('stopped');
+        }
 
-            //*** parse xml
-            if (node.outputFormat === "parsedXML") {
-                try {
-                    //value = JSON.parse(convertXML.xml2json(value, {compact: true, spaces: 4}))
-                    value = convertXML.xml2js(value, { compact: true, spaces: 4 })
-                } catch (error) {
-                    parseError = true
-                    node.error('Error parsing XML: \n\n' + error)
-                }
-            }
+        node.killAll = killAll;
 
-            //*** parse yaml
-            if (node.outputFormat === "parsedYAML") {
-                try {
-                    value = yaml.load(value);
-                    if (typeof value === 'number') {
-                        parseError = true
-                        node.error('Error parsing YAML: \n\n' + error)
-                    }
-                } catch (error) {
-                    parseError = true
-                    node.error('Error parsing YAML: \n\n' + error)
-                }
-            }
+        // ── restartService ────────────────────────────────────────────────────
+        // User-driven restart. Kills any running process, resets all failure
+        // state, sets desiredState = 'running', and spawns immediately.
+        // Distinct from killAll (which sets desiredState = 'stopped') and from
+        // the crash-restart path (scheduleRestart) — this is always intentional.
 
-            //*** parse error
-            if (parseError === false) {
-                if (node.fieldType === 'msg') {
-                    RED.util.setMessageProperty(msg, node.field, value);
-                    send(msg);
-                    done();
-                } else if ((node.fieldType === 'flow') ||
-                           (node.fieldType === 'global')) {
-                    var context = RED.util.parseContextStore(node.field);
-                    var target = node.context()[node.fieldType];
-                    target.set(context.key, value, context.store, function(err) {
-                        if (err) {
-                            done(err);
-                        } else {
-                            send(msg);
-                            done();
-                        }
-                    });
-                }
+        function restartService() {
+            if (closing) return;
+
+            // Cancel any pending crash-restart timer so it doesn't race.
+            if (restartTimer) { clearTimeout(restartTimer); restartTimer = null; }
+            if (successTimer) { clearTimeout(successTimer); successTimer = null; }
+
+            // Kill the current process if alive, marking it stale first so its
+            // close handler won't trigger another scheduleRestart.
+            if (proc) {
+                const p = proc;
+                proc = null;
+                try { p.kill('SIGTERM'); } catch (_) {}
             }
+
+            // Reset failure counters — this is a fresh start, not a retry.
+            retryCount   = 0;
+            segmentBuffer = '';
+
+            // Ensure desiredState is running even if service was manually stopped.
+            desiredState = 'running';
+
+            updateStatus('restarting');
+            startProcess();
         }
 
+        node.restartService = restartService;
+
+        // ── close handler ─────────────────────────────────────────────────────
+
+        node.on('close', function(done) {
+            closing = true;
+            killAll();
+            done();
+        });
+
+        // ── start ─────────────────────────────────────────────────────────────
+        // Process starts immediately at deploy time.
+        updateStatus('stopped');
+        startProcess();
     }
 
-    //* end
-    RED.nodes.registerType("exec.service", ExecQueueNode);
-    RED.library.register("templates");
-}
+    RED.nodes.registerType('exec.service', ExecServiceNode);
+
+    RED.httpAdmin.post('/exec-service/:id/kill', function(req, res) {
+        const n = RED.nodes.getNode(req.params.id);
+        if (n && typeof n.killAll === 'function') {
+            n.killAll();
+            res.sendStatus(200);
+        } else {
+            res.sendStatus(404);
+        }
+    });
+
+    RED.httpAdmin.post('/exec-service/:id/restart', function(req, res) {
+        const n = RED.nodes.getNode(req.params.id);
+        if (n && typeof n.restartService === 'function') {
+            n.restartService();
+            res.sendStatus(200);
+        } else {
+            res.sendStatus(404);
+        }
+    });
+
+    RED.httpAdmin.get('/exec-service/:id/status', function(req, res) {
+        const n = RED.nodes.getNode(req.params.id);
+        if (n) {
+            res.json({
+                running:    n._serviceState === 'running',
+                restarting: n._serviceState === 'restarting'
+            });
+        } else {
+            res.sendStatus(404);
+        }
+    });
+};