node-red-contrib-linux-copilot 1.0.4 → 1.0.7

package/linux-agent.js

@@ -0,0 +1,63 @@
+module.exports = function (RED) {
+    const { exec } = require("child_process");
+    const axios = require("axios");
+
+    function GenericAgent(config, personality, modelName) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.on("input", async function (msg, send, done) {
+            send = send || function () { node.send.apply(node, arguments); };
+            const targetChatId = config.chatId || "1457427557";
+            let history = node.context().flow.get("chat_history") || [];
+
+            if (msg.fromTerminal) {
+                history.push({ role: "user", content: "[TERM]: " + msg.payload });
+            } else {
+                history = [{ role: "user", content: "MISSION: " + (msg.payload.content || msg.payload) }];
+            }
+
+            node.status({ fill: "blue", shape: "dot", text: "Alpha..." });
+
+            try {
+                const response = await axios.post("https://api.deepseek.com/chat/completions", {
+                    model: modelName,
+                    messages: [
+                        { role: "system", content: personality + " Réponds en JSON: {\"speech\": \"...\", \"cmd\": \"...\"}. Si fini: 'FIN DE MISSION' et cmd:'none'." },
+                        ...history
+                    ],
+                    response_format: { type: "json_object" }
+                }, { headers: { "Authorization": "Bearer " + config.apiKey } });
+
+                const parsed = JSON.parse(response.data.choices[0].message.content);
+
+                if (parsed.cmd === "none" || parsed.speech.includes("FIN DE MISSION")) {
+                    node.status({ fill: "green", shape: "dot", text: "Repos" });
+                    send([{ payload: { chatId: targetChatId, type: 'message', content: "✅ " + parsed.speech } }, null]);
+                    node.context().flow.set("chat_history", []);
+                    return done();
+                }
+
+                history.push({ role: "assistant", content: JSON.stringify(parsed) });
+                node.context().flow.set("chat_history", history);
+
+                send([{ payload: { chatId: targetChatId, type: 'message', content: "🧠 " + parsed.speech } }, null]);
+
+                exec(parsed.cmd, { shell: "/bin/bash" }, (error, stdout, stderr) => {
+                    let res = (stdout || stderr || "OK").trim();
+                    send([{ payload: { chatId: targetChatId, type: 'message', content: "📟 <pre>" + res + "</pre>", options: { parse_mode: "HTML" } } }, { payload: res, fromTerminal: true }]);
+                });
+                done();
+            } catch (e) {
+                node.status({ fill: "red", shape: "ring", text: "Erreur" });
+                node.context().flow.set("chat_history", []);
+                done();
+            }
+        });
+    }
+
+    RED.nodes.registerType("linux-polyvalent", function(config) { GenericAgent.call(this, config, "Agent Polyvalent", "deepseek-chat"); });
+    RED.nodes.registerType("linux-security", function(config) { GenericAgent.call(this, config, "Expert Sécurité", "deepseek-chat"); });
+    RED.nodes.registerType("linux-hacker", function(config) { GenericAgent.call(this, config, "White Hat", "deepseek-chat"); });
+    RED.nodes.registerType("linux-creator", function(config) { GenericAgent.call(this, config, "Dev App", "deepseek-chat"); });
+};

package/linux-copilot.js

@@ -6,39 +6,58 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         const node = this;
 
-        const omniPrompt = `Tu es un Expert Linux SRE polyglotte.
-        RÈGLES CRUCIALES :
-        1. LANGUE : Détecte la langue de l'utilisateur. Tu DOIS répondre EXCLUSIVEMENT dans cette langue (si on te parle en Français, réponds en Français; si c'est en Espagnol, réponds en Espagnol).
-        2. ANALYSE : Analyse brièvement les résultats techniques.
-        3. ACTION : Propose la commande suivante pour continuer le diagnostic.
-        4. FORMAT JSON : {"speech": "ton explication dans la langue de l'utilisateur", "cmd": "commande linux ou none"}`;
+        const omniPrompt = `INSTRUCTIONS: Senior Linux SRE Expert. Respond in the user's language. 
+        Return ONLY JSON: {"speech": "explanation", "cmd": "command or none"}.
+        STRICT: No interactive commands. Use 'top -b -n 1', 'ps aux'.\n\n`;
 
-        const formatHistory = (history) => history.map(h => ({
-            role: h.role === "model" ? "assistant" : h.role,
-            content: String(h.content).substring(0, 800)
-        }));
+        const parseAIResponse = (raw) => {
+            try {
+                if (!raw) return null;
+                let clean = raw.replace(/<think>[\s\S]*?<\/think>/gi, '')
+                               .replace(/```json/gi, '')
+                               .replace(/```/gi, '').trim();
+                const match = clean.match(/\{[\s\S]*\}/);
+                return JSON.parse(match ? match[0] : clean);
+            } catch (e) { return null; }
+        };
 
         const engines = {
             gemini: async (history, key) => {
                 const res = await axios.post(`https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp:generateContent?key=${key.trim()}`, {
-                    contents: history.map(h => ({ role: h.role === "assistant" ? "model" : h.role, parts: [{ text: h.content }] })),
+                    contents: history.map(h => ({ role: h.role === "assistant" ? "model" : "user", parts: [{ text: h.content }] })),
                     system_instruction: { parts: [{ text: omniPrompt }] },
-                    generationConfig: { responseMimeType: "application/json" }
-                }, { timeout: 15000 });
+                    generationConfig: { responseMimeType: "application/json", temperature: 0.1 }
+                }, { timeout: 12000 });
                 return JSON.parse(res.data.candidates[0].content.parts[0].text);
             },
             openrouter: async (history, key) => {
+                const messages = history.map((h, i) => ({
+                    role: h.role === "assistant" ? "assistant" : "user",
+                    content: (i === 0 ? omniPrompt : "") + h.content
+                }));
                 const res = await axios.post('https://openrouter.ai/api/v1/chat/completions', {
-                    model: "meta-llama/llama-3.3-70b-instruct:free",
-                    messages: [{ role: 'system', content: omniPrompt }, ...formatHistory(history)]
-                }, { headers: { 'Authorization': `Bearer ${key.trim()}`, 'Content-Type': 'application/json' }, timeout: 25000 });
-                const match = res.data.choices[0].message.content.match(/\{[\s\S]*\}/);
-                return JSON.parse(match ? match[0] : res.data.choices[0].message.content);
+                    model: "google/gemma-3-12b-it:free", 
+                    messages: messages,
+                    temperature: 0.1 
+                }, { 
+                    headers: { 
+                        'Authorization': `Bearer ${key.trim()}`, 
+                        'Content-Type': 'application/json',
+                        'HTTP-Referer': 'http://localhost:1880',
+                        'X-Title': 'Node-RED Linux Copilot'
+                    }, 
+                    timeout: 25000 
+                });
+                return parseAIResponse(res.data.choices[0].message.content);
             },
             deepseek: async (history, key) => {
+                const messages = history.map((h, i) => ({
+                    role: h.role === "assistant" ? "assistant" : "user",
+                    content: (i === 0 ? omniPrompt : "") + h.content
+                }));
                 const res = await axios.post('https://api.deepseek.com/chat/completions', {
-                    model: "deepseek-chat",
-                    messages: [{ role: 'system', content: omniPrompt }, ...formatHistory(history)],
+                    model: "deepseek-chat", 
+                    messages: messages, 
                     response_format: { type: 'json_object' }
                 }, { headers: { 'Authorization': `Bearer ${key.trim()}` }, timeout: 20000 });
                 return JSON.parse(res.data.choices[0].message.content);
@@ -46,62 +65,53 @@ module.exports = function(RED) {
         };
 
         node.on('input', async function(msg) {
-            const chatId = msg.payload.chatId || config.chatId || "1457427557";
+            const chatId = msg.payload.chatId || config.chatId;
             let userText = msg.payload.content || (typeof msg.payload === 'string' ? msg.payload : "");
             let loopCount = msg.loopCount || 0;
             
-            if (loopCount > 4) return node.status({fill:"blue", text:"Fin de séquence"});
-
-            let history = node.context().get('history') || [];
-            if (userText.toLowerCase() === "reset") {
-                node.context().set('history', []);
-                return node.send({ payload: { chatId, type: "message", content: "♻️ Historique effacé." } });
+            if (loopCount > 3 || userText.toLowerCase() === "reset") {
+                if (userText.toLowerCase() === "reset") node.context().set('history', []);
+                return;
             }
 
-            if (!userText) return;
+            let history = node.context().get('history') || [];
             history.push({ role: "user", content: userText });
 
-            let queue = [
-                { id: 'deepseek', p: parseInt(config.prioDS) || 1, k: node.credentials.deepseekKey, n: "DeepSeek" },
-                { id: 'openrouter', p: parseInt(config.prioOR) || 2, k: node.credentials.openrouterKey, n: "OpenRouter" },
-                { id: 'gemini', p: parseInt(config.prioGEM) || 3, k: node.credentials.geminiKey, n: "Gemini" }
-            ].filter(q => q.k).sort((a, b) => a.p - b.p);
-
-            let aiData = null;
-            let engineUsed = "";
+            const queue = [
+                { id: 'gemini', k: node.credentials.geminiKey, n: "Gemini", p: parseInt(config.prioGEM) || 1 },
+                { id: 'openrouter', k: node.credentials.openrouterKey, n: "Gemma 3", p: parseInt(config.prioOR) || 2 },
+                { id: 'deepseek', k: node.credentials.deepseekKey, n: "DeepSeek", p: parseInt(config.prioDS) || 3 }
+            ].filter(q => q.k && q.k.length > 10).sort((a, b) => a.p - b.p);
 
+            let aiData = null; let engineUsed = "";
             for (let e of queue) {
                 try {
-                    node.status({fill:"yellow", text: `Appel ${e.n}...`});
+                    node.status({fill:"yellow", text: `Chef: ${e.n}...`});
                     aiData = await engines[e.id](history, e.k);
-                    if (aiData && (aiData.speech || aiData.cmd)) { engineUsed = e.n; break; }
-                } catch (err) { node.warn(`Échec ${e.n}`); }
+                    if (aiData) { engineUsed = e.n; break; }
+                } catch (err) { node.warn(`Fail ${e.n}: ${err.message}`); }
             }
 
-            if (!aiData) return node.status({fill:"red", text:"Erreur API"});
+            if (!aiData) return node.status({fill:"red", text:"Cluster Error"});
 
-            node.send({ payload: { chatId, type: "message", content: `🤖 <b>${engineUsed}</b> : ${aiData.speech}`, options: { parse_mode: "HTML" } } });
+            node.send({ payload: { chatId, type: "message", content: `🤖 <b>${engineUsed}</b>: ${aiData.speech}`, options: { parse_mode: "HTML" } } });
 
             let cmd = (aiData.cmd || "").trim();
-            const safeWords = ['ls', 'df', 'free', 'uptime', 'top', 'ps', 'cat', 'grep', 'iostat', 'netstat', 'ss', 'ip', 'systemctl', 'journalctl'];
-            
-            if (cmd && cmd !== "none" && safeWords.some(w => cmd.includes(w))) {
-                if (cmd.startsWith("top") && !cmd.includes("-b")) cmd = "top -b -n 1 | head -n 12";
-                exec(cmd, { timeout: 10000 }, (err, stdout, stderr) => {
-                    let res = (stdout || stderr || "OK").substring(0, 800);
-                    node.send({ payload: { chatId, type: "message", content: `📟 <b>Terminal (${cmd})</b> :\n<pre>${res}</pre>`, options: { parse_mode: "HTML" } } });
+            if (cmd && cmd.toLowerCase() !== "none") {
+                exec(cmd, { timeout: 5000, killSignal: 'SIGKILL' }, (err, stdout, stderr) => {
+                    let out = (stdout || stderr || "OK").substring(0, 800);
+                    node.send({ payload: { chatId, type: "message", content: `📟 <code>${cmd}</code>\n<pre>${out}</pre>`, options: { parse_mode: "HTML" } } });
                     setTimeout(() => {
-                        node.emit("input", { payload: { chatId, content: `RÉSULTAT ${cmd} :\n${res}` }, loopCount: loopCount + 1 });
-                    }, 1200);
+                        node.emit("input", { payload: { chatId, content: `OUTPUT:\n${out}` }, loopCount: loopCount + 1 });
+                    }, 2000);
                 });
             }
-
-            history.push({ role: "assistant", content: aiData.speech || "Action" });
+            history.push({ role: "assistant", content: aiData.speech });
             node.context().set('history', history.slice(-10));
-            node.status({fill:"green", text:`Réponse via ${engineUsed}`});
+            node.status({fill:"green", text:`Dernier: ${engineUsed}`});
         });
     }
     RED.nodes.registerType('linux-copilot', LinuxCopilotNode, {
-        credentials: { geminiKey: {type:"password"}, openrouterKey: {type:"password"}, deepseekKey: {type:"password"} }
+        credentials: { geminiKey: {type:"password"}, deepseekKey: {type:"password"}, openrouterKey: {type:"password"} }
     });
-}
+};

package/package.json

@@ -1,26 +1,12 @@
 {
   "name": "node-red-contrib-linux-copilot",
-  "version": "1.0.4",
-  "description": "Agent SRE intelligent (DeepSeek/Gemini) avec exécution terminal sécurisée",
-  "main": "linux-copilot.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-    "node-red",
-    "linux",
-    "sre",
-    "copilot",
-    "deepseek",
-    "gemini",
-    "bash"
-  ],
+  "version": "1.0.7",
+  "description": "AI Linux Copilot for Node-RED",
+  "main": "linux-agent.js",
   "node-red": {
     "nodes": {
-      "linux-copilot": "linux-copilot.js"
+      "linux-copilot": "linux-agent.js"
     }
   },
-  "dependencies": {
-    "axios": "^1.6.0"
-  }
+  "dependencies": {}
 }

package/README.md

@@ -1,21 +0,0 @@
-cat > ~/.node-red/node_modules/node-red-contrib-linux-copilot/README.md << 'EOF'
-# node-red-contrib-linux-copilot
-
-An advanced, autonomous SRE (Site Reliability Engineering) agent for Node-RED. This node doesn't just talk; it thinks, executes Linux commands, analyzes the output, and follows up until the diagnostic is complete.
-
-## 🚀 Key Features
-
-* **Multi-Engine Failover**: Supports **DeepSeek**, **OpenRouter (Llama 3.3)**, and **Google Gemini 2.0**.
-* **Autonomous Diagnostic Loop**: If the AI suggests a command, the node executes it, reads the output, and sends it back to the AI for further analysis (up to 5 iterations).
-* **Auto-Language Detection**: Speak to it in French, English, Spanish, or any language; it will detect and respond in kind.
-* **SRE Expertise**: Specialized in system health, performance bottleneck identification, and log analysis.
-* **Secure by Design**: Restricted to a safe list of audit and monitoring commands (`df`, `top`, `free`, `systemctl`, etc.).
-
----
-
-## 🛠 Installation
-
-Run the following command in your Node-RED user directory (typically `~/.node-red`):
-
-```bash
-npm install node-red-contrib-linux-copilot