@fkom13/mcp-sftp-orchestrator 6.0.0

package/.env.example

@@ -0,0 +1,22 @@
+# Chemin où seront stockés les fichiers servers.json et history.json
+# Par défaut, ce sera ~/.config/mcp-orchestrator
+MCP_DATA_DIR="/home/fkomp/Bureau/oracle/tools/sftp-mcp/data"
+
+# Délai en secondes avant qu'une tâche ne passe en arrière-plan (mode asynchrone)
+MCP_SYNC_TIMEOUT_S=30
+
+# Timeout pour l'exécution synchrone (ms)
+SYNC_TIMEOUT=30000
+
+# Taille maximale de la queue
+MAX_QUEUE_SIZE=1000
+
+# Pool de connexions
+MAX_CONNECTIONS_PER_SERVER=5
+MIN_CONNECTIONS_PER_SERVER=1
+IDLE_TIMEOUT=320000
+KEEP_ALIVE_INTERVAL=300000
+
+# Sauvegarde
+SAVE_INTERVAL=5000
+HISTORY_RETENTION=2678400000

package/README.md

@@ -0,0 +1,102 @@
+# 🚀 MCP SFTP/SSH Orchestrator
+
+Un serveur MCP (Model-Context-Protocol) puissant pour l'orchestration de tâches distantes. Il gère des connexions SSH et SFTP, une file d'attente de tâches persistante, et expose un ensemble riche d'outils pour la gestion de serveurs, le monitoring, et l'exécution de commandes via une interface `stdio` compatible avec les LLM.
+
+✨ **Fonctionnalités Principales**
+
+- **Gestion de Serveurs** : Ajoutez, listez et supprimez des configurations de serveurs SSH/SFTP.
+- **Exécution de Tâches SSH** : Simple, interactive, ou en séquence.
+- **Transferts de Fichiers SFTP** : Upload/Download de fichiers et dossiers, avec support des patterns `glob`.
+- **File d'Attente Intelligente** : Mode hybride (synchrone/asynchrone) et persistance des tâches.
+- **Pooling de Connexions** : Gère un pool de connexions SSH pour une exécution ultra-rapide.
+- **Outils de Monitoring** : Surveillez les ressources système, le statut des services (systemd, Docker, PM2) et Fail2Ban.
+- **Outils de Logs** : Récupérez les logs de PM2, Docker, ou suivez la fin d'un fichier (`tail`).
+
+## 📦 Installation
+
+Ce projet est conçu pour être utilisé comme un outil MCP dans un environnement compatible (comme la `gemini-cli`).
+
+Enregistrez ce MCP auprès de votre client en utilisant la configuration suivante :
+
+```json
+{
+  "mcpServers": {
+    "mcp-sftp-orchestrator": {
+      "command": "npx",
+      "args": [
+        "@fkom13/mcp-sftp-orchestrator"
+      ],
+      "env": {
+        "MCP_DATA_DIR": "~/.config/mcp-orchestrator"
+      }
+    }
+  }
+}
+```
+
+Le client MCP lancera automatiquement le serveur via `npx` lors de son premier appel.
+
+## 🛠️ Configuration
+
+Le serveur est configurable via des variables d'environnement. Vous pouvez créer un fichier `.env` à la racine du projet si vous l'exécutez localement pour le développement.
+
+- `MCP_DATA_DIR`: Le dossier où seront stockées les données (configurations des serveurs, historique, etc.). Par défaut : `~/.config/mcp-orchestrator`.
+- `MCP_SYNC_TIMEOUT_S`: Le délai en secondes avant qu'une tâche longue ne passe en arrière-plan. Par défaut : `30`.
+
+## 🧰 Référence des Outils (API)
+
+Voici la liste complète des outils exposés par ce serveur MCP.
+
+### Gestion des Serveurs
+
+- `server_add`: Enregistre ou met à jour les informations de connexion d'un serveur.
+- `server_list`: Affiche la liste de tous les alias de serveurs configurés.
+- `server_remove`: Supprime un alias de serveur de la configuration.
+
+### Exécution de Tâches
+
+- `task_exec`: Exécute une commande SSH (hybride synchrone/asynchrone).
+- `task_transfer`: Transfère un fichier ou dossier via SFTP (hybride synchrone/asynchrone).
+- `task_exec_interactive`: Exécute une commande SSH interactive (gère les prompts `yes/no`, etc.).
+- `task_exec_sequence`: Exécute plusieurs commandes SSH en séquence sur le même serveur.
+- `task_transfer_multi`: Transfère plusieurs fichiers/dossiers avec support de patterns `glob`.
+
+### Monitoring & Diagnostics
+
+- `get_system_resources`: Récupère les métriques système vitales (CPU, RAM, Disque).
+- `get_services_status`: Récupère le statut des services (systemd, Docker, PM2).
+- `get_fail2ban_status`: Récupère les informations du service Fail2Ban.
+
+### Récupération de Logs
+
+- `get_pm2_logs`: Raccourci pour récupérer les logs PM2.
+- `get_docker_logs`: Raccourci pour récupérer les logs d'un container Docker.
+- `tail_file`: Affiche les dernières lignes d'un fichier distant.
+
+### Gestion de la File d'Attente (Queue)
+
+- `task_queue`: Affiche le statut de toutes les tâches dans la file d'attente.
+- `task_status`: Récupère les détails d'une tâche par son ID.
+- `task_history`: Affiche l'historique des dernières tâches lancées.
+- `task_retry`: Relance une tâche qui a échoué ou crashé.
+- `queue_stats`: Affiche les statistiques de la queue de tâches.
+
+### Gestion des APIs (Monitoring Externe)
+
+- `api_add`: Ajoute une API au catalogue de monitoring.
+- `api_list`: Affiche toutes les APIs configurées.
+- `api_remove`: Supprime une API du catalogue.
+- `api_check`: Lance un test de santé sur une API.
+
+### Administration du Serveur MCP
+
+- `task_logs`: Affiche les logs du système MCP lui-même.
+- `pool_stats`: Affiche les statistiques du pool de connexions SSH.
+
+## 🤝 Contribution
+
+Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une *Issue* pour signaler un bug ou proposer une fonctionnalité, ou une *Pull Request* pour soumettre des modifications.
+
+## 📄 Licence
+
+Ce projet est sous licence MIT.

package/apis.js

@@ -0,0 +1,88 @@
+import fs from 'fs/promises';
+import path from 'path';
+import config from './config.js';
+
+const APIS_FILE = path.join(config.dataDir, 'apis.json');
+
+let apis = {};
+
+let isInitialized = false;
+let initPromise = null;
+
+// Charger les APIs au démarrage
+async function loadApis() {
+    try {
+        const data = await fs.readFile(APIS_FILE, 'utf-8');
+        apis = JSON.parse(data);
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            // Le fichier n'existe pas encore, c'est normal
+            apis = {};
+        } else {
+            console.error("Erreur lors du chargement de apis.json:", err);
+        }
+    }
+}
+
+async function ensureInitialized() {
+    if (isInitialized) return;
+    if (!initPromise) {
+        initPromise = loadApis().then(() => { isInitialized = true; });
+    }
+    return initPromise;
+}
+
+// Sauvegarder les APIs
+async function saveApis() {
+    await ensureInitialized();
+    try {
+        await fs.writeFile(APIS_FILE, JSON.stringify(apis, null, 2));
+    } catch (err) {
+        console.error("Erreur lors de la sauvegarde de apis.json:", err);
+    }
+}
+
+// Ajouter ou mettre à jour une API
+async function addApi(alias, apiConfig) {
+    await ensureInitialized();
+    apis[alias] = apiConfig;
+    await saveApis();
+    return { success: true, message: `API '${alias}' ajoutée/mise à jour avec succès.` };
+}
+
+// Lister toutes les APIs
+async function listApis() {
+    await ensureInitialized();
+    return apis;
+}
+
+// Obtenir une API par son alias
+async function getApi(alias) {
+    await ensureInitialized();
+    const apiConfig = apis[alias];
+    if (!apiConfig) {
+        throw new Error(`L'alias d'API '${alias}' est inconnu.`);
+    }
+    return apiConfig;
+}
+
+// Supprimer une API
+async function removeApi(alias) {
+    await ensureInitialized();
+    if (!apis[alias]) {
+        throw new Error(`L'alias d'API '${alias}' est inconnu.`);
+    }
+    delete apis[alias];
+    await saveApis();
+    return { success: true, message: `API '${alias}' supprimée avec succès.` };
+}
+
+// Initialiser le module
+ensureInitialized();
+
+export default {
+    addApi,
+    listApis,
+    getApi,
+    removeApi
+};

package/config.js

@@ -0,0 +1,34 @@
+import dotenv from 'dotenv';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+// --- Début de la Correction ---
+// Trouve le chemin du .env par rapport à l'emplacement de ce script, et non du répertoire de travail
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+dotenv.config({ path: path.join(__dirname, '.env') });
+// --- Fin de la Correction ---
+
+// Analyser les arguments de la ligne de commande (ex: --data-dir=...)
+const args = process.argv.slice(2).reduce((acc, arg) => {
+    const [key, value] = arg.split('=');
+    if (key && value) {
+        acc[key.replace(/^--/, '')] = value;
+    }
+    return acc;
+}, {});
+
+const config = {
+    // La hiérarchie reste la même : les arguments en ligne de commande écrasent le .env, qui écrase le défaut.
+    dataDir: args['data-dir'] || process.env.MCP_DATA_DIR || path.join(os.homedir(), '.config', 'mcp-orchestrator'),
+    syncTimeout: parseInt(args['sync-timeout'] || process.env.MCP_SYNC_TIMEOUT_S || '10', 10) * 1000,
+    defaultCommandTimeout: parseInt(process.env.MCP_DEFAULT_CMD_TIMEOUT_MS || '300000', 10),
+    interactiveCommandTimeout: parseInt(process.env.MCP_INTERACTIVE_CMD_TIMEOUT_MS || '120000', 10)
+};
+
+// Créer le dossier de données s'il n'existe pas
+fs.mkdirSync(config.dataDir, { recursive: true });
+
+export default config;

package/history.js

@@ -0,0 +1,44 @@
+import fs from 'fs/promises';
+import path from 'path';
+import config from './config.js';
+const HISTORY_FILE_PATH = path.join(config.dataDir, 'history.json');
+
+async function readHistory() {
+    try {
+        await fs.access(HISTORY_FILE_PATH);
+        const data = await fs.readFile(HISTORY_FILE_PATH, 'utf-8');
+        return JSON.parse(data);
+    } catch (error) {
+        return [];
+    }
+}
+
+async function writeHistory(history) {
+    await fs.writeFile(HISTORY_FILE_PATH, JSON.stringify(history, null, 2));
+}
+
+async function logTask(jobDetails) {
+    const history = await readHistory();
+    const logEntry = {
+        jobId: jobDetails.id,
+        timestamp: new Date().toISOString(),
+        type: jobDetails.type,
+        alias: jobDetails.alias,
+        command: jobDetails.type === 'ssh' ? jobDetails.cmd : `${jobDetails.direction} ${jobDetails.local} -> ${jobDetails.remote}`
+    };
+    history.unshift(logEntry); // Ajoute au début
+    if (history.length > 500) { // Garde les 500 dernières commandes
+        history.pop();
+    }
+    await writeHistory(history);
+}
+
+async function getHistory(filters = {}) {
+    let history = await readHistory();
+    if (filters.alias) {
+        history = history.filter(log => log.alias === filters.alias);
+    }
+    return history;
+}
+
+export default { logTask, getHistory };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@fkom13/mcp-sftp-orchestrator",
+  "version": "6.0.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"
+  },
+  "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"
+  },
+  "homepage": "https://github.com/fkom13/mcp-sftp-orchestrator#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.0",
+    "dotenv": "^16.4.5",
+    "glob": "^11.0.3",
+    "micromatch": "^4.0.5",
+    "ssh2": "^1.15.0",
+    "ssh2-sftp-client": "^9.1.0",
+    "uuid": "^9.0.1",
+    "zod": "^3.23.8"
+  }
+}

package/publish1github.md

@@ -0,0 +1,216 @@
+C'est un excellent projet ! Vous avez mis en place un orchestrateur MCP très complet avec un pool de connexions SSH, une file d'attente persistante, et une gestion avancée des tâches.
+
+Pour le publier sur GitHub et rédiger un bon README.md, voici une approche structurée et un modèle de README que vous pouvez copier-coller et adapter.
+
+1. Comment le Rendre Public sur GitHub
+"Rendre public" un projet MCP comme le vôtre signifie deux choses :
+
+Héberger le code source (pour que d'autres puissent le télécharger et l'exécuter).
+
+Rendre le serveur MCP "découvrable" (pour que les clients MCP, comme les LLM, puissent l'utiliser).
+
+Votre projet est un serveur stdio, ce qui signifie qu'il est conçu pour être exécuté localement par un client MCP (il communique via stdin/stdout, pas via un port réseau). Le "public" ici signifie que d'autres personnes peuvent cloner votre dépôt et l'exécuter localement pour gérer leurs propres serveurs.
+
+Étapes pour la Publication :
+Nettoyer le projet :
+
+Assurez-vous que votre fichier .gitignore inclut bien /node_modules, .env, et le contenu de votre dossier data/ (comme servers.json, queue.json, etc.) pour ne pas "commiter" vos secrets ou vos données personnelles.
+
+Un bon .gitignore pour ce projet :
+
+Extrait de code
+
+# Fichiers de dépendances
+node_modules/
+
+# Fichiers de configuration locaux
+.env
+
+# Données de l'application (contient des clés, l'historique, etc.)
+data/*.json
+data/*.backup.json
+# Gardez les fichiers .json d'exemple si vous en avez
+!data/servers.example.json
+Créer le dépôt GitHub :
+
+Allez sur GitHub et créez un nouveau dépôt public (par exemple, sftp-mcp-orchestrator).
+
+N'initialisez PAS avec un README ou .gitignore si vous avez déjà les vôtres.
+
+Lier et Pousser votre code :
+
+Dans votre dossier de projet local, exécutez ces commandes (en remplaçant l'URL par la vôtre) :
+
+Bash
+
+# Initialiser git (si ce n'est pas déjà fait)
+git init -b main
+git add .
+git commit -m "Initial commit: Ajout du serveur MCP Orchestrator"
+
+# Lier à votre dépôt distant
+git remote add origin https://github.com/VOTRE_NOM_UTILISATEUR/sftp-mcp-orchestrator.git
+
+# Pousser le code
+git push -u origin main
+Ajouter une Licence :
+
+Créez un fichier LICENSE à la racine. Pour un projet de ce type, MIT ou Apache 2.0 sont des choix courants et permissifs. Cela indique aux autres comment ils peuvent utiliser votre code.
+
+Rédiger le README.md :
+
+C'est l'étape la plus importante pour l'adoption. Créez un fichier README.md à la racine de votre projet.
+
+2. Modèle de Documentation README.md
+Voici un modèle complet pour votre README.md. Copiez-collez ce contenu dans un fichier README.md à la racine de votre projet et modifiez l'URL du dépôt.
+
+(Début du fichier README.md)
+
+🚀 sftp-mcp: Orchestrateur de Tâches Distantes
+Un serveur MCP (Model-Context-Protocol) puissant pour l'orchestration de tâches distantes. Il gère des connexions SSH et SFTP, une file d'attente de tâches persistante, et expose un ensemble riche d'outils pour la gestion de serveurs, le monitoring, et l'exécution de commandes via une interface stdio compatible avec les LLM.
+
+✨ Fonctionnalités Principales
+Gestion de Serveurs : Ajoutez, listez et supprimez des configurations de serveurs SSH/SFTP (stockées de manière sécurisée).
+
+Exécution de Tâches SSH :
+
+Exécution simple (task_exec).
+
+Exécution interactive avec gestion des prompts (task_exec_interactive).
+
+Exécution de séquences de commandes (task_exec_sequence).
+
+Transferts de Fichiers SFTP :
+
+Upload/Download de fichiers et dossiers (task_transfer).
+
+Support des patterns "glob" pour les transferts multiples (task_transfer_multi).
+
+File d'Attente (Queue) Intelligente :
+
+Hybride : Les tâches rapides retournent un résultat direct (synchrone) ; les tâches longues passent en arrière-plan (asynchrone).
+
+Persistante : La file d'attente est sauvegardée sur disque et restaurée au redémarrage.
+
+Reprise sur Erreur : Les tâches "crashées" (si le serveur redémarre) peuvent être relancées (task_retry).
+
+Pooling de Connexions : Gère un pool de connexions SSH persistantes pour une exécution ultra-rapide des commandes.
+
+Outils de Monitoring : Récupérez les ressources système, le statut des services (systemd, Docker, PM2) et le statut de Fail2Ban.
+
+Outils de Logs : Récupérez facilement les logs de PM2, de Docker, ou suivez la fin d'un fichier (tail).
+
+Catalogue d'API : Gérez et monitorez la santé de vos propres API externes.
+
+⚙️ Installation
+Clonez le dépôt :
+
+Bash
+
+git clone https://github.com/VOTRE_NOM_UTILISATEUR/sftp-mcp-orchestrator.git
+cd sftp-mcp-orchestrator
+Installez les dépendances :
+
+Bash
+
+npm install
+🛠️ Configuration
+Créez votre fichier .env :
+
+Bash
+
+cp .env.example .env
+Modifiez le .env (Optionnel) : Le script créera par défaut un dossier de données dans ~/.config/mcp-orchestrator. Vous pouvez changer ce comportement en modifiant MCP_DATA_DIR dans votre fichier .env.
+
+Extrait de code
+
+# Chemin où seront stockés servers.json, history.json, etc.
+MCP_DATA_DIR="/home/user/.config/mcp-orchestrator"
+
+# Délai en secondes avant qu'une tâche ne passe en arrière-plan
+MCP_SYNC_TIMEOUT_S=30
+Ajoutez votre premier serveur : Ce serveur n'est utile que s'il peut se connecter à d'autres machines. Vous devez ajouter des serveurs via un client MCP (comme un LLM ou un CLI) en utilisant l'outil server_add.
+
+Exemple d'appel (ce que vous demanderiez à votre LLM) :
+
+"Ajoute un serveur avec l'alias vps_prod, l'hôte 123.45.67.89, l'utilisateur admin et le chemin de clé /home/user/.ssh/id_rsa_prod."
+
+🏃 Lancement
+Ce projet est un serveur MCP stdio. Il n'expose pas de port HTTP. Il est conçu pour être lancé par un client MCP (comme un SDK ou un CLI) qui communique avec lui via l'entrée/sortie standard.
+
+Pour l'utiliser, vous devez enregistrer ce serveur auprès de votre client MCP. La commande de lancement est :
+
+Bash
+
+node /chemin/complet/vers/sftp-mcp-orchestrator/server.js
+🧰 Référence des Outils (API)
+Ce serveur expose une suite complète d'outils. Un client MCP compatible (comme un LLM) saura automatiquement quels paramètres sont requis en inspectant le schéma Zod de chaque outil.
+
+Gestion des Serveurs
+Outil	Description
+server_add	Enregistre ou met à jour les informations de connexion d'un serveur.
+server_list	Affiche la liste de tous les alias de serveurs configurés.
+server_remove	Supprime un alias de serveur de la configuration.
+
+Exporter vers Sheets
+
+Exécution de Tâches
+Outil	Description
+task_exec	Exécute une commande SSH (hybride synchrone/asynchrone).
+task_transfer	Transfère un fichier ou dossier (SFTP) (hybride synchrone/asynchrone).
+task_exec_interactive	Exécute une commande SSH interactive (gestion des prompts yes/no, etc.).
+task_exec_sequence	Exécute plusieurs commandes SSH en séquence sur le même serveur.
+task_transfer_multi	Transfère plusieurs fichiers/dossiers (SFTP) avec support de patterns glob.
+
+Exporter vers Sheets
+
+Monitoring & Diagnostics
+Outil	Description
+get_system_resources	Récupère les métriques système vitales (CPU, RAM, Disque) d'un serveur.
+get_services_status	Récupère le statut des services (systemd, Docker, PM2) sur un serveur.
+check_api_health	Vérifie la disponibilité et le temps de réponse d'un endpoint HTTP/S.
+get_fail2ban_status	Récupère les informations du service Fail2Ban.
+
+Exporter vers Sheets
+
+Récupération de Logs
+Outil	Description
+get_pm2_logs	Raccourci pour récupérer les logs PM2 d'une application.
+get_docker_logs	Raccourci pour récupérer les logs d'un container Docker.
+tail_file	Affiche les dernières lignes d'un fichier distant.
+
+Exporter vers Sheets
+
+Gestion de la File d'Attente (Queue)
+Outil	Description
+task_queue	Affiche le statut de toutes les tâches dans la file d'attente.
+task_status	Récupère les détails d'une seule tâche par son ID.
+task_history	Affiche les dernières tâches lancées (peut être filtré par alias).
+task_retry	Relance une tâche qui a échoué ou crashé.
+queue_stats	Affiche les statistiques détaillées de la queue de tâches.
+
+Exporter vers Sheets
+
+Gestion des APIs (Monitoring Externe)
+Outil	Description
+api_add	Ajoute ou met à jour une API dans le catalogue de monitoring.
+api_list	Affiche toutes les APIs configurées dans le catalogue.
+api_remove	Supprime une API du catalogue en utilisant son alias.
+api_check	Lance un test de santé sur une API du catalogue (via un serveur distant).
+
+Exporter vers Sheets
+
+Administration du Serveur MCP
+Outil	Description
+task_logs	Affiche les logs du système MCP lui-même.
+pool_stats	Affiche les statistiques du pool de connexions SSH persistantes.
+
+Exporter vers Sheets
+
+🤝 Contribution
+Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une Issue pour signaler un bug ou proposer une fonctionnalité, ou une Pull Request pour soumettre des modifications.
+
+📄 Licence
+Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de détails.
+
+(Fin du fichier README.md)