@fkom13/mcp-sftp-orchestrator 6.0.0 → 11.8.0

package/inventory.js

@@ -0,0 +1,151 @@
+/**
+ * inventory.js — Inventaire léger d'un serveur (cache TTL).
+ */
+import queue from './queue.js';
+import servers from './servers.js';
+import sshPool from './sshPool.js';
+import utils from './utils.js';
+
+const cache = new Map(); // alias → { at, data }
+const DEFAULT_TTL_MS = 10 * 60 * 1000;
+
+const INVENTORY_CMD = [
+    'echo "===HOST==="',
+    'hostname; whoami; date -u +%Y-%m-%dT%H:%M:%SZ',
+    'echo "===UPTIME==="',
+    'uptime',
+    'echo "===DISK==="',
+    'df -h / 2>/dev/null | tail -1',
+    'echo "===MEM==="',
+    'free -h 2>/dev/null | head -2 || true',
+    'echo "===PM2==="',
+    'command -v pm2 >/dev/null && pm2 jlist 2>/dev/null | head -c 8000 || echo "[]"',
+    'echo "===DOCKER==="',
+    'command -v docker >/dev/null && docker ps --format "{{.Names}}|{{.Status}}|{{.Ports}}" 2>/dev/null | head -40 || true',
+    'echo "===HOME_TOP==="',
+    'ls -1 "$HOME" 2>/dev/null | head -40',
+    'echo "===TAILSCALE==="',
+    'command -v tailscale >/dev/null && tailscale status --json 2>/dev/null | head -c 2000 || echo "no-tailscale"'
+].join('; ');
+
+function parseInventory(raw) {
+    const sections = {};
+    let current = 'raw';
+    for (const line of (raw || '').split('\n')) {
+        const m = line.match(/^===([A-Z_]+)===\s*$/);
+        if (m) {
+            current = m[1].toLowerCase();
+            sections[current] = [];
+            continue;
+        }
+        if (!sections[current]) sections[current] = [];
+        sections[current].push(line);
+    }
+
+    const join = (k) => (sections[k] || []).join('\n').trim();
+
+    let pm2 = [];
+    try {
+        const pm2Raw = join('pm2');
+        if (pm2Raw && pm2Raw !== '[]') {
+            const list = JSON.parse(pm2Raw);
+            if (Array.isArray(list)) {
+                pm2 = list.map(p => ({
+                    name: p.name,
+                    status: p.pm2_env?.status,
+                    pid: p.pid,
+                    pm_id: p.pm_id
+                })).slice(0, 40);
+            }
+        }
+    } catch {
+        pm2 = [{ parse_error: true, raw: join('pm2').slice(0, 200) }];
+    }
+
+    const docker = join('docker')
+        .split('\n')
+        .filter(Boolean)
+        .map(line => {
+            const [name, status, ports] = line.split('|');
+            return { name, status, ports };
+        });
+
+    const home_top = join('home_top').split('\n').filter(Boolean);
+    const hasTailscale = !join('tailscale').includes('no-tailscale');
+
+    return {
+        host: join('host'),
+        uptime: join('uptime'),
+        disk: join('disk'),
+        mem: join('mem'),
+        pm2,
+        docker,
+        home_top,
+        tailscale: hasTailscale ? 'present' : 'absent',
+        tailscale_raw_len: join('tailscale').length
+    };
+}
+
+async function execProbe(alias, timeoutMs = 20000) {
+    const serverConfig = await servers.getServer(alias);
+    let connection = null;
+    try {
+        connection = await sshPool.getConnection(alias, serverConfig);
+        const output = await new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    reject(new Error(`inventory timeout ${timeoutMs}ms`));
+                }
+            }, timeoutMs);
+
+            connection.client.exec(INVENTORY_CMD, (err, stream) => {
+                if (err) {
+                    clearTimeout(timer);
+                    if (!settled) { settled = true; reject(err); }
+                    return;
+                }
+                let out = '';
+                stream.on('data', d => { out += d.toString(); });
+                stream.stderr.on('data', d => { out += d.toString(); });
+                stream.on('close', () => {
+                    clearTimeout(timer);
+                    if (!settled) { settled = true; resolve(out); }
+                });
+            });
+        });
+        return parseInventory(output);
+    } finally {
+        if (connection) sshPool.releaseConnection(connection.id);
+    }
+}
+
+export default {
+    async get(alias, { force = false, ttlMs = DEFAULT_TTL_MS } = {}) {
+        const cached = cache.get(alias);
+        if (!force && cached && (Date.now() - cached.at) < ttlMs) {
+            return { alias, cached: true, ageSeconds: Math.round((Date.now() - cached.at) / 1000), ...cached.data };
+        }
+
+        queue.log('info', `inventory: probe ${alias}`);
+        const sc = await servers.getServer(alias);
+        const data = await execProbe(alias);
+        const payload = {
+            alias,
+            host: sc.host,
+            user: sc.user,
+            port: utils.resolveSshPort(sc),
+            ...data,
+            fetchedAt: new Date().toISOString()
+        };
+        cache.set(alias, { at: Date.now(), data: payload });
+        return { ...payload, cached: false, ageSeconds: 0 };
+    },
+
+    clear(alias = null) {
+        if (alias) cache.delete(alias);
+        else cache.clear();
+        return { cleared: true, alias };
+    }
+};

package/lhm.plugin.json

@@ -0,0 +1,7 @@
+{
+  "identifier": "fkom13-mcp-sftp-orchestrator",
+  "name": "MCP SFTP/SSH Orchestrator",
+  "version": "11.8.0",
+  "description": "82 outils SSH/SFTP et orchestration infra pour agents IA : multi-host, fichiers hash-safe, tmux, tunnels, snapshots, projets, work sessions, topologie, blocklist et allowed_roots",
+  "tags": "ssh,sftp,mcp,devops,server-management,infrastructure"
+}

package/notes.js

@@ -0,0 +1,3 @@
+import path from 'path'; import config from './config.js'; import jsonStore from './atomicJsonStore.js';
+const NOTES_FILE=path.join(config.dataDir,'server_notes.json'), EMPTY={}; const readAll=()=>jsonStore.readJson(NOTES_FILE,EMPTY);
+export default { async set(alias,fields={}){let merged; await jsonStore.updateJson(NOTES_FILE,EMPTY,notes=>{merged={...(notes[alias]||{})}; for(const key of ['description','services','warnings','conventions','note'])if(fields[key]!==undefined)merged[key]=fields[key]; if(fields.intervention)merged.last_intervention={at:new Date().toISOString(),summary:fields.intervention}; merged.updatedAt=new Date().toISOString(); notes[alias]=merged; return notes;}); return{alias,note:merged};}, async get(alias){const n=await readAll();return n[alias]||null;}, async list(){return readAll();}, async remove(alias){let removed=false; await jsonStore.updateJson(NOTES_FILE,EMPTY,n=>{removed=!!n[alias]; if(removed)delete n[alias]; return n;}); return{removed,alias};} };

package/package.json

@@ -1,40 +1,25 @@
 {
   "name": "@fkom13/mcp-sftp-orchestrator",
-  "version": "6.0.0",
+  "version": "11.8.0",
   "description": "Un serveur MCP stdio pour l'orchestration de tâches distantes avec exécution hybride (synchrone/asynchrone) et configuration flexible.",
   "main": "server.js",
   "type": "module",
-  "bin": {
-    "mcp-sftp-orchestrator": "server.js"
-  },
+  "mcpName": "io.github.fkom13/mcp-sftp-orchestrator",
   "scripts": {
-    "test": "node test_features.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/fkom13/mcp-sftp-orchestrator.git"
-  },
-  "keywords": [
-    "mcp",
-    "orchestrator",
-    "ssh",
-    "sftp",
-    "automation"
-  ],
-  "author": "fkom13",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/fkom13/mcp-sftp-orchestrator/issues"
+    "start": "node server.js",
+    "test": "node test_p0_unit.js && node test_p1_unit.js && node test_p16_unit.js && node test_hardening_1161.js && node test_atomic_store_1161.js && node test_queue_atomic_1161.js && node test_aix_117.js && node test_mcp_hardening_integration.js && node test_mcp.js && node test_features.js",
+    "test:unit": "node test_p0_unit.js && node test_p1_unit.js && node test_p16_unit.js",
+    "test:integration": "node test_features.js"
   },
-  "homepage": "https://github.com/fkom13/mcp-sftp-orchestrator#readme",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.17.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "diff": "^5.2.2",
     "dotenv": "^16.4.5",
-    "glob": "^11.0.3",
+    "glob": "^13.0.6",
     "micromatch": "^4.0.5",
     "ssh2": "^1.15.0",
     "ssh2-sftp-client": "^9.1.0",
-    "uuid": "^9.0.1",
+    "uuid": "^11.1.1",
     "zod": "^3.23.8"
   }
-}
+}

package/policies.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import config from './config.js';
+import jsonStore from './atomicJsonStore.js';
+const POLICIES_PATH=path.join(config.dataDir,'policies.json');
+const DEFAULT_POLICIES={command_blocklist:["rm -rf /","rm -rf /*","mkfs*",":(){:|:&};:","dd if=/dev/zero","> /dev/sda","chmod -R 000 /","mv / /dev/null","wget -O- http://* | sh","curl http://* | sh","eval $(curl","eval $(wget","git clone http://* | sh"]};
+const loadPolicies=()=>jsonStore.readJson(POLICIES_PATH,DEFAULT_POLICIES);
+function checkCommand(cmd,blocklist){ const c=(cmd||'').trim(); if(!c)return{blocked:false}; for(const pattern of blocklist){ if(!pattern)continue; if(pattern.includes('*')){const r=new RegExp('^'+pattern.replace(/[.+^${}()|[\]\\]/g,'\\$&').replace(/\*/g,'.*')+'$','i'); if(r.test(c))return{blocked:true,pattern}; continue;} const e=pattern.replace(/[.*+?^${}()|[\]\\]/g,'\\$&'); const r=/\/$/.test(pattern)?new RegExp(e+'(?=$|\\s|\\*)','i'):new RegExp(e,'i'); if(r.test(c))return{blocked:true,pattern}; } return{blocked:false}; }
+export default { async list(){return loadPolicies();}, async add(pattern){return jsonStore.updateJson(POLICIES_PATH,DEFAULT_POLICIES,p=>{if(!p.command_blocklist.includes(pattern))p.command_blocklist.push(pattern);return p;});}, async remove(pattern){return jsonStore.updateJson(POLICIES_PATH,DEFAULT_POLICIES,p=>{p.command_blocklist=p.command_blocklist.filter(x=>x!==pattern);return p;});}, async check(cmd){const p=await loadPolicies();return checkCommand(cmd,p.command_blocklist);}, checkCommand };

package/projects.js

@@ -0,0 +1,108 @@
+/**
+ * projects.js — Registre sémantique projet ↔ serveur(s) ↔ paths local/remote.
+ * Stockage atomique: <dataDir>/projects.json
+ */
+import path from 'path';
+import config from './config.js';
+import servers from './servers.js';
+import jsonStore from './atomicJsonStore.js';
+
+const PROJECTS_PATH = path.join(config.dataDir, 'projects.json');
+const EMPTY = {};
+
+const load = () => jsonStore.readJson(PROJECTS_PATH, EMPTY);
+
+function validateName(name) {
+    if (!name || !/^[a-zA-Z0-9_./-]+$/.test(name)) {
+        throw new Error("Nom de projet invalide (alphanumérique, _ . / -).");
+    }
+}
+
+export default {
+    async list() {
+        return load();
+    },
+
+    async get(name) {
+        const all = await load();
+        if (!all[name]) throw new Error(`Projet '${name}' introuvable. project_list pour voir.`);
+        return { name, ...all[name] };
+    },
+
+    async set(name, fields = {}) {
+        validateName(name);
+
+        // Valider d'abord les aliases hors verrou projets afin de ne pas garder
+        // le lock pendant une I/O vers le registre serveurs.
+        let known = null;
+        if (fields.servers !== undefined) known = await servers.listServers();
+
+        let merged;
+        await jsonStore.updateJson(PROJECTS_PATH, EMPTY, async (all) => {
+            const existing = all[name] || {};
+            merged = { ...existing };
+            for (const key of ['description', 'ignore', 'local', 'servers', 'tags', 'network']) {
+                if (fields[key] !== undefined) merged[key] = fields[key];
+            }
+
+            if (merged.servers && typeof merged.servers === 'object') {
+                const serverMap = known || await servers.listServers();
+                for (const [role, cfg] of Object.entries(merged.servers)) {
+                    if (!cfg || !cfg.alias) throw new Error(`servers.${role}: 'alias' requis`);
+                    if (!serverMap[cfg.alias]) throw new Error(`servers.${role}: alias '${cfg.alias}' inconnu (server_list)`);
+                    if (!cfg.path) throw new Error(`servers.${role}: 'path' requis`);
+                }
+            }
+
+            merged.updatedAt = new Date().toISOString();
+            all[name] = merged;
+            return all;
+        });
+        return { name, ...merged };
+    },
+
+    async remove(name) {
+        await jsonStore.updateJson(PROJECTS_PATH, EMPTY, (all) => {
+            if (!all[name]) throw new Error(`Projet '${name}' introuvable.`);
+            delete all[name];
+            return all;
+        });
+        return { success: true, message: `Projet '${name}' supprimé.` };
+    },
+
+    async resolve(name, role = null) {
+        const project = await this.get(name);
+        const ignore = project.ignore || ['node_modules', '.git', 'dist', 'coverage', '.env'];
+        let remote = null;
+        let runtime = null;
+        let url = null;
+        const serverEntries = project.servers || {};
+        const roles = Object.keys(serverEntries);
+
+        if (roles.length) {
+            const useRole = role || (serverEntries.prod ? 'prod' : roles[0]);
+            const cfg = serverEntries[useRole];
+            if (!cfg) throw new Error(`Rôle '${useRole}' absent. Rôles: ${roles.join(', ')}`);
+            remote = { type: 'remote', alias: cfg.alias, path: cfg.path, label: `${name}:${useRole}` };
+            runtime = cfg.runtime || null;
+            url = cfg.url || null;
+        }
+
+        const local = project.local?.path
+            ? { type: 'local', path: project.local.path, label: `${name}:local` }
+            : null;
+
+        return {
+            name,
+            role: role || (serverEntries.prod ? 'prod' : roles[0] || null),
+            local,
+            remote,
+            ignore,
+            runtime,
+            url,
+            description: project.description || null,
+            network: project.network || null,
+            project
+        };
+    }
+};