overmind-mcp 0.0.2-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeaMoN888
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,137 @@
+# 🧠 OverMind-MCP
+
+_Orchestrateur universel agents IA multi-modeles via MCP pour piloter Claude-Code, Gemini-cli, QwenCli, Nous Hermes, Kilo/Cline, OpenClaw, GLM, Minimax, Kimi, Ollama et plus sans limite._
+
+![OverMind-MCP Banner](assets/overmind_mcp_banner_slim.png)
+
+<p align="center">
+  <a href="https://discord.gg/4AR82phtBz"><img src="https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white" alt="Discord"></a>
+  <a href="https://deamondev888.github.io/overmind-mcp/"><img src="https://img.shields.io/badge/Documentation-Live-00fff5?style=for-the-badge&logo=google-chrome&logoColor=white" alt="Live Doc"></a>
+</p>
+
+## 👋 C'est quoi ?
+
+**OverMind-MCP** est une conscience supérieure conçue pour orchestrer, commander et automatiser une flotte illimitée d'agents IA. Compatible avec **Claude-Code, Gemini-cli, QwenCli, Nous Hermes, Kilo/Cline, OpenClaw**, et prêt pour **GLM, Minimax, Kimi, Ollama** et bien d'autres. Plus qu'un simple runner, c'est le **Cortex Central** de votre infrastructure IA.
+
+Il transforme les outils CLI isolés en une force coordonnée, pilotable par API ou par MCP, capable d'exécuter des missions complexes en 2 secondes chrono. de creer et d orchestrer des pipeline de plusieurs agent. il est expert en outils MCP et peu etre scripté pour les faire fonctionner ensemble et les mettre en productions
+
+## ✨ Ce que ça fait
+
+- 🔌 **Contrôle Total** : Lancez des missions complexes via MCP ou directement via le code (Claude, Gemini, QwenCli, Hermes).
+- 🏗️ **Architecture Pro** : Basé sur des services (`AgentManager`, `ClaudeRunner`, `PromptManager`) pour une stabilité maximale.
+- 🧠 **Mémoire Haute-Performance (4096D)** : Système RAG intégré via PostgreSQL + `pgvector` supportant les embeddings SOTA (Qwen 8B).
+- 🕵️ **Auto-Diagnostic CLI** : Détecte automatiquement les runners manquants et fournit les instructions/liens officiels pour l'installation.
+- 🛡️ **Mémoire Ségréguée** : Chaque agent peut posséder ses propres souvenirs isolés tout en ayant accès au socle de connaissances global.
+- 🛠️ **Capacités Étendues** : L'agent piloté peut utiliser VOS outils (Base de données, Scrapers, etc.).
+- 🤖 **Multi-Agents** : Créez, configurez et gérez des personnalités d'agents isolées (Prompts & Settings dédiés).
+- 📦 **Prêt pour l'Intégration** : Importable comme un module NPM dans vos autres projets.
+
+---
+
+## 🚀 Commencer (Guide Facile)
+
+### Option 1 : Utilisation Globale ou Package distant NPM
+
+Si vous souhaitez l'installer globalement sans cloner de repo, vous pouvez utiliser :
+
+```bash
+npm install -g overmind-mcp
+```
+
+**Configuration MCP (Client) pour l'Option 1 :**
+Pour connecter l'orchestrateur distant à un client ou à Cursor,Antigravity ou Claude Code, pointez simplement via `npx` :
+
+```json
+{
+  "mcpServers": {
+    "overmind": {
+      "command": "npx",
+      "args": ["-y", "overmind-mcp@latest"]
+    }
+  }
+}
+```
+
+---
+
+### Option 2 : Installation Locale (Développement ou hébergement précis)
+
+```bash
+# 1. Cloner le repo localement
+git clone https://github.com/DeamonDev888/overmind-mcp overmind-mcp
+cd overmind-mcp
+
+# 2. Installer les dépendances
+pnpm install
+
+# 3. Build le projet
+pnpm run build
+```
+
+Pour que l'agent puisse voir vos autres serveurs MCP locaux, copiez le fichier d'exemple :
+
+```bash
+cp .mcp.json.example .mcp.json
+```
+
+**Configuration MCP (Client) pour l'Option 2 :**
+Pour connecter ce runner à un client en pointant vers votre version locale compilée :
+
+```json
+{
+  "mcpServers": {
+    "overmind": {
+      "command": "node",
+      "args": ["/LE_CHEMIN_ABSOLU_VERS_LE_DOSSIER_CLONE/dist/bin/cli.js"]
+    }
+  }
+}
+```
+
+---
+
+## 📦 Utilisation comme Bibliothèque
+
+Vous pouvez désormais importer le moteur du runner dans vos propres scripts :
+
+```typescript
+import { runAgent, AgentManager, updateConfig } from 'overmind-mcp';
+
+// 1. Initialisation
+updateConfig('./settings.json', './mcp.local.json');
+
+// 2. Gestion des agents
+const manager = new AgentManager();
+await manager.createAgent('expert-seo', 'Tu es un expert SEO...', 'claude-3-5-sonnet');
+
+// 3. Lancer une exécution via l'Orchestrateur Unifié
+const { content, isError } = await runAgent({
+  runner: 'claude',
+  agentName: 'expert-seo',
+  prompt: 'Analyse le site example.com',
+  autoResume: true,
+});
+
+if (!isError) {
+  console.log('🤖 Résultat:', content[0].text);
+}
+```
+
+---
+
+## 📂 Structure du Projet
+
+- `src/services/` : Le cœur du système (Logique métier isolée en services).
+- `src/tools/` : Les outils MCP qui appellent les services.
+- `src/bin/cli.ts` : Le point d'entrée exécutable pour le terminal.
+- `src/server.ts` : La définition du serveur FastMCP.
+- `src/index.ts` : Les exports publics (API de la bibliothèque).
+- `.claude/` : Stockage des agents (Prompts `.md` et Settings `.json`).
+
+---
+
+![Aperçu du Terminal](https://cdn.jsdelivr.net/npm/overmind-mcp@1.0.8/assets/terminal_preview.png)
+
+_Note : L'**OverMind** punit et martyrise les **OpenClaw** qui n'écoutent pas._ 😈
+
+_Projet propulsé par DeaMoN888 - 2026_

package/dist/bin/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/bin/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/bin/cli.ts"],"names":[],"mappings":""}

package/dist/bin/cli.js

@@ -0,0 +1,481 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { PassThrough } from 'stream';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Helper to manually parse .env without any noisy console.logs from external packages (dotenvx corrupts MCP JSON streams)
+function loadEnvQuietly(envPath) {
+    try {
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, 'utf8');
+            content.split('\n').forEach((line) => {
+                const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
+                if (match) {
+                    const key = match[1];
+                    let value = match[2] || '';
+                    value = value.replace(/\s*#.*$/, '').trim();
+                    if (value.startsWith('"') && value.endsWith('"'))
+                        value = value.slice(1, -1);
+                    else if (value.startsWith("'") && value.endsWith("'"))
+                        value = value.slice(1, -1);
+                    if (!process.env[key])
+                        process.env[key] = value;
+                }
+            });
+        }
+    }
+    catch (_e) {
+        // Ignore silently
+    }
+}
+// 🪄 Auto-formatteur de .env — Classifie tous les providers connus, préserve les valeurs
+function autoFormatEnvFile(envPath) {
+    try {
+        if (!fs.existsSync(envPath))
+            return;
+        const content = fs.readFileSync(envPath, 'utf8');
+        // Parser robuste : ignore commentaires, lit les lignes KEY=VALUE (valeur peut contenir '=')
+        const envVars = {};
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            const value = trimmed.slice(eqIdx + 1).trim();
+            if (key)
+                envVars[key] = value;
+        }
+        if (Object.keys(envVars).length === 0)
+            return;
+        const usedKeys = new Set();
+        // Tri naturel pour les clés avec suffixes numériques (KEY, KEY_2, KEY_3…)
+        function naturalSort(pairs) {
+            return pairs.sort((a, b) => a[0].localeCompare(b[0], undefined, { numeric: true, sensitivity: 'base' }));
+        }
+        function extract(prefix, exactMatch = false) {
+            const res = [];
+            const prefixes = Array.isArray(prefix) ? prefix : [prefix];
+            for (const key of Object.keys(envVars)) {
+                if (usedKeys.has(key))
+                    continue;
+                const matches = exactMatch
+                    ? prefixes.includes(key)
+                    : prefixes.some((p) => key.startsWith(p));
+                if (matches) {
+                    res.push([key, envVars[key]]);
+                    usedKeys.add(key);
+                }
+            }
+            return naturalSort(res);
+        }
+        // ─── SECTIONS ──────────────────────────────────────────────────────────────
+        const sections = [
+            // ── Overmind Infrastructure ──
+            {
+                title: '🌐 OVERMIND CORE & INFRASTRUCTURE',
+                vars: extract(['OVERMIND_WORKSPACE', 'OVERMIND_MEMORY_TYPE'], true),
+            },
+            { title: '⚙️  GLOBAL SETTINGS', vars: extract(['API_TIMEOUT_MS'], true) },
+            { title: '🗄️  DATABASE (PostgreSQL / pgvector)', vars: extract('POSTGRES_') },
+            { title: '🧠 EMBEDDINGS & VECTOR MEMORY', vars: extract('OVERMIND_EMBEDDING_') },
+            // ── LLM Providers (Europe / USA) ──
+            { title: '🤖 LLM PROVIDER - Mistral AI 🇫🇷', vars: extract('MISTRAL_') },
+            { title: '🤖 LLM PROVIDER - OpenAI 🇺🇸', vars: extract('OPENAI_') },
+            { title: '🤖 LLM PROVIDER - Anthropic 🇺🇸', vars: extract('ANTHROPIC_') },
+            {
+                title: '🤖 LLM PROVIDER - Google Gemini 🇺🇸',
+                vars: extract(['GEMINI_API_KEY', 'GEMINI_MODEL', 'GOOGLE_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY'], true),
+            },
+            {
+                title: '🤖 LLM PROVIDER - NVIDIA NIM 🇺🇸',
+                vars: [
+                    ...extract(['NVAPI_KEY', 'NVIDIA_API_KEY', 'NVIDIA_API_BASE'], true),
+                    ...extract('NVIDIA_'),
+                ],
+            },
+            {
+                title: '🤖 LLM PROVIDER - OpenRouter 🇺🇸',
+                vars: extract(['OPENROUTER_API_KEY', 'OPENROUTER_BASE_URL', 'OPENROUTER_MODEL'], true),
+            },
+            {
+                title: '🤖 LLM PROVIDER - xAI / Grok 🇺🇸',
+                vars: extract(['XAI_API_KEY', 'XAI_BASE_URL', 'GROK_API_KEY', 'GROK_MODEL'], true),
+            },
+            { title: '🤖 LLM PROVIDER - Groq 🇺🇸', vars: extract('GROQ_') },
+            { title: '🤖 LLM PROVIDER - Together AI 🇺🇸', vars: extract('TOGETHER_') },
+            { title: '🤖 LLM PROVIDER - Cohere 🇺🇸', vars: extract('COHERE_') },
+            { title: '🤖 LLM PROVIDER - Replicate 🇺🇸', vars: extract('REPLICATE_') },
+            {
+                title: '🤖 LLM PROVIDER - HuggingFace 🇺🇸',
+                vars: extract(['HUGGINGFACE_API_KEY', 'HF_TOKEN', 'HUGGING_FACE_HUB_TOKEN'], true),
+            },
+            { title: '🤖 LLM PROVIDER - Perplexity 🇺🇸', vars: extract('PERPLEXITY_') },
+            { title: '🤖 LLM PROVIDER - SambaNova 🇺🇸', vars: extract('SAMBANOVA_') },
+            {
+                title: '🤖 LLM PROVIDER - Azure OpenAI ☁️',
+                vars: extract([
+                    'AZURE_API_KEY',
+                    'AZURE_API_BASE',
+                    'AZURE_OPENAI_API_KEY',
+                    'AZURE_OPENAI_ENDPOINT',
+                    'AZURE_OPENAI_API_VERSION',
+                ], true),
+            },
+            {
+                title: '🤖 LLM PROVIDER - ElevenLabs 🎙️',
+                vars: extract(['ELEVENLABS_API_KEY', 'ELEVENLABS_VOICE_ID', 'ELEVENLABS_MODEL_ID'], true),
+            },
+            {
+                title: '🤖 LLM PROVIDER - AWS Bedrock ☁️',
+                vars: extract([
+                    'AWS_ACCESS_KEY_ID',
+                    'AWS_SECRET_ACCESS_KEY',
+                    'AWS_SESSION_TOKEN',
+                    'AWS_REGION',
+                    'AWS_DEFAULT_REGION',
+                    'AWS_ENDPOINT_URL',
+                ], true),
+            },
+            // ── LLM Providers (Chine / Asie) ──
+            { title: '🤖 LLM PROVIDER - DeepSeek 🇨🇳', vars: extract('DEEPSEEK_') },
+            { title: '🤖 LLM PROVIDER - Alibaba DashScope 🇨🇳', vars: extract('ALIBABA_') },
+            {
+                title: '🤖 LLM PROVIDER - Qwen (DashScope) 🇨🇳',
+                vars: extract([
+                    'QWEN_API_KEY',
+                    'QWEN_BASE_URL',
+                    'QWEN_MODEL',
+                    'DASHSCOPE_API_KEY',
+                    'DASHSCOPE_BASE_URL',
+                ], true),
+            },
+            { title: '🤖 LLM PROVIDER - SiliconFlow 🇨🇳', vars: extract('SILICONFLOW_') },
+            {
+                title: '🤖 LLM PROVIDER - Minimax 🇨🇳',
+                vars: [...extract('MINIMAXI_'), ...extract('MINIMAX_')],
+            },
+            { title: '🤖 LLM PROVIDER - Ilmu AI / Z.AI 🇨🇳', vars: extract('Z_AI_') },
+            {
+                title: '🤖 LLM PROVIDER - Moonshot / Kimi 🇨🇳',
+                vars: extract(['MOONSHOT_API_KEY', 'MOONSHOT_BASE_URL', 'MOONSHOT_MODEL', 'KIMI_API_KEY'], true),
+            },
+            {
+                title: '🤖 LLM PROVIDER - Baidu / ERNIE 🇨🇳',
+                vars: extract(['BAIDU_API_KEY', 'ERNIE_API_KEY', 'WENXIN_API_KEY'], true),
+            },
+            {
+                title: '🤖 LLM PROVIDER - ZhipuAI / GLM 🇨🇳',
+                vars: [...extract(['ZHIPU_API_KEY', 'GLM_API_KEY'], true), ...extract('ZHIPUAI_')],
+            },
+            // ── Services & Intégrations ──
+            {
+                title: '💬 SERVICE - Discord',
+                vars: extract([
+                    'DISCORD_TOKEN',
+                    'DISCORD_BOT_TOKEN',
+                    'DISCORD_CHANNEL_ID',
+                    'DISCORD_GUILD_ID',
+                    'DISCORD_WEBHOOK_URL',
+                    'DISCORD_CLIENT_ID',
+                    'DISCORD_CLIENT_SECRET',
+                ], true),
+            },
+            {
+                title: '🐦 SERVICE - Twitter / X',
+                vars: extract([
+                    'TWITTER_API_KEY',
+                    'TWITTER_API_SECRET',
+                    'TWITTER_ACCESS_TOKEN',
+                    'TWITTER_ACCESS_SECRET',
+                    'TWITTER_BEARER_TOKEN',
+                    'X_API_KEY',
+                    'X_BEARER_TOKEN',
+                    'X_API_SECRET',
+                    'X_ACCESS_TOKEN',
+                    'X_ACCESS_SECRET',
+                ], true),
+            },
+            {
+                title: '📱 SERVICE - Telegram',
+                vars: extract(['TELEGRAM_BOT_TOKEN', 'TELEGRAM_CHAT_ID'], true),
+            },
+            {
+                title: '📱 SERVICE - Twilio / SMS',
+                vars: extract([
+                    'TWILIO_ACCOUNT_SID',
+                    'TWILIO_AUTH_TOKEN',
+                    'TWILIO_PHONE_NUMBER',
+                    'TWILIO_API_KEY',
+                    'TWILIO_API_SECRET',
+                ], true),
+            },
+            {
+                title: '🐙 SERVICE - GitHub',
+                vars: extract([
+                    'GITHUB_TOKEN',
+                    'GITHUB_API_KEY',
+                    'GH_TOKEN',
+                    'GITHUB_CLIENT_ID',
+                    'GITHUB_CLIENT_SECRET',
+                ], true),
+            },
+            {
+                title: '▲ SERVICE - Vercel',
+                vars: extract([
+                    'VERCEL_TOKEN',
+                    'VERCEL_API_TOKEN',
+                    'VERCEL_PROJECT_ID',
+                    'VERCEL_ORG_ID',
+                    'VERCEL_TEAM_ID',
+                ], true),
+            },
+            {
+                title: '🔺 SERVICE - Supabase',
+                vars: extract(['SUPABASE_URL', 'SUPABASE_ANON_KEY', 'SUPABASE_SERVICE_ROLE_KEY', 'SUPABASE_JWT_SECRET'], true),
+            },
+            { title: '🎮 SERVICE - Riot Games', vars: extract(['RIOT_API_KEY', 'RIOT_REGION'], true) },
+            {
+                title: '🔍 SERVICE - Search (Serper/Tavily)',
+                vars: extract(['SERPER_API_KEY', 'TAVILY_API_KEY', 'SERPAPI_KEY', 'BRAVE_SEARCH_API_KEY'], true),
+            },
+            {
+                title: '📰 SERVICE - Market Data & News',
+                vars: extract([
+                    'FINNHUB_API_KEY',
+                    'NEWSAPI_KEY',
+                    'ALPHAVANTAGE_API_KEY',
+                    'POLYGON_API_KEY',
+                    'TIINGO_API_KEY',
+                ], true),
+            },
+        ];
+        // Clés restantes non classifiées → section fourre-tout
+        const uncategorized = [];
+        for (const key of Object.keys(envVars)) {
+            if (!usedKeys.has(key))
+                uncategorized.push([key, envVars[key]]);
+        }
+        if (uncategorized.length > 0) {
+            sections.push({ title: '📁 AUTRES / NON-CLASSIFIÉS', vars: naturalSort(uncategorized) });
+        }
+        // ─── RENDU ──────────────────────────────────────────────────────────────────
+        let newContent = '';
+        for (const section of sections) {
+            if (section.vars.length > 0) {
+                newContent += `# ==========================================\n`;
+                newContent += `# ${section.title}\n`;
+                newContent += `# ==========================================\n`;
+                for (const [k, v] of section.vars) {
+                    newContent += `${k}=${v}\n`;
+                }
+                newContent += `\n`;
+            }
+        }
+        // N'écrire sur le disque que si quelque chose a changé (optimisation I/O)
+        if (content.trim() !== newContent.trim()) {
+            fs.writeFileSync(envPath, newContent.trim() + '\n', 'utf8');
+        }
+    }
+    catch (_e) {
+        // Ignorer silencieusement pour ne pas crasher le boot
+    }
+}
+const localEnvPath = path.resolve(__dirname, '../../.env');
+// Auto-détection et injection de OVERMIND_WORKSPACE s'il est manquant — NE PAS écraser s'il existe déjà
+try {
+    if (!fs.existsSync(localEnvPath)) {
+        const workspacePath = path.resolve(__dirname, '../../');
+        fs.writeFileSync(localEnvPath, `OVERMIND_WORKSPACE=${workspacePath}\n`, 'utf8');
+    }
+    else {
+        const currentContent = fs.readFileSync(localEnvPath, 'utf8');
+        // Vérifier que OVERMIND_WORKSPACE n'existe pas OU n'a pas de valeur (ligne vide)
+        const match = currentContent.match(/^OVERMIND_WORKSPACE=(.*)$/m);
+        if (!match || !match[1]?.trim()) {
+            const workspacePath = path.resolve(__dirname, '../../');
+            if (!currentContent.includes('OVERMIND_WORKSPACE=')) {
+                fs.appendFileSync(localEnvPath, `\nOVERMIND_WORKSPACE=${workspacePath}\n`, 'utf8');
+            }
+            else {
+                // Remplacer la ligne vide/videuse
+                const newContent = currentContent.replace(/^OVERMIND_WORKSPACE=.*$/m, `OVERMIND_WORKSPACE=${workspacePath}`);
+                fs.writeFileSync(localEnvPath, newContent, 'utf8');
+            }
+        }
+        // Si OVERMIND_WORKSPACE a déjà une valeur → ne rien faire, ne pas écraser
+    }
+}
+catch (_e) {
+    // Ignorer l'erreur silencieusement
+}
+// Classifie et réorganise automatiquement le .env à chaque démarrage d'Overmind
+autoFormatEnvFile(localEnvPath);
+// Load OverMind's specific environment variables
+loadEnvQuietly(localEnvPath);
+// Inherit PostgreSQL Server environment variables (Database credentials, Embeddings)
+loadEnvQuietly(path.resolve(__dirname, '../../../serveur_PostGreSQL/.env'));
+// 🔍 Vérification des configurations critiques
+function checkMissingConfigs() {
+    const missingCore = [];
+    const missingDb = [];
+    // Vérification CORE
+    if (!process.env.OVERMIND_WORKSPACE)
+        missingCore.push('OVERMIND_WORKSPACE');
+    if (!process.env.OVERMIND_MEMORY_TYPE)
+        missingCore.push('OVERMIND_MEMORY_TYPE');
+    // Vérification DB
+    if (!process.env.POSTGRES_HOST)
+        missingDb.push('POSTGRES_HOST');
+    if (!process.env.POSTGRES_DATABASE)
+        missingDb.push('POSTGRES_DATABASE');
+    if (!process.env.POSTGRES_USER)
+        missingDb.push('POSTGRES_USER');
+    if (!process.env.POSTGRES_PASSWORD)
+        missingDb.push('POSTGRES_PASSWORD');
+    if (missingCore.length > 0) {
+        console.error(`\n[Overmind] ⚠️ ATTENTION : Configuration 'CORE & INFRASTRUCTURE' incomplète !`);
+        console.error(`[Overmind] ❌ Il manque : ${missingCore.join(', ')}\n`);
+    }
+    if (missingDb.length > 0) {
+        console.error(`\n[Overmind] ⚠️ ATTENTION : Configuration 'DATABASE' incomplète (Imported from postgresql-server) !`);
+        console.error(`[Overmind] ❌ Il manque : ${missingDb.join(', ')}\n`);
+    }
+}
+checkMissingConfigs();
+import { rootLogger } from '../lib/logger.js';
+// 💥 ERROR HANDLING: Catch everything to avoid silent EOFs
+process.on('uncaughtException', (err) => {
+    rootLogger.fatal({ err }, '💥 UNCAUGHT EXCEPTION');
+    rootLogger.flush();
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    rootLogger.fatal({ reason, promise }, '💥 UNHANDLED REJECTION');
+    rootLogger.flush();
+});
+// Ensure logs are flushed on exit
+process.on('SIGINT', () => {
+    rootLogger.info('🛑 Received SIGINT, flushing logs...');
+    rootLogger.flush();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    rootLogger.info('🛑 Received SIGTERM, flushing logs...');
+    rootLogger.flush();
+    process.exit(0);
+});
+// 🛡️ SHIELD: Prevent any library from logging to stdout during initialization
+// This is critical for MCP servers because any non-JSON output on stdout kills the handshake (EOF).
+console.log = (...args) => rootLogger.info(args.length > 1 ? { args } : args[0]);
+console.info = (...args) => rootLogger.info(args.length > 1 ? { args } : args[0]);
+console.warn = (...args) => rootLogger.warn(args.length > 1 ? { args } : args[0]);
+console.error = (...args) => rootLogger.error(args.length > 1 ? { args } : args[0]);
+// 🛡️ ULTIMATE SHIELD: Proxy process.stdout.write to redirect non-JSON data to stderr
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+process.stdout.write = function (chunk, encoding, callback) {
+    const str = typeof chunk === 'string' ? chunk : chunk.toString();
+    const trimmed = str.trim();
+    // Handle overload: if encoding is a function, it's actually the callback
+    if (typeof encoding === 'function') {
+        callback = encoding;
+        encoding = undefined;
+    }
+    // Skip empty chunks or pure whitespace (often used as delimiters/keep-alive)
+    if (trimmed === '') {
+        return originalStdoutWrite(chunk, encoding, callback);
+    }
+    // Allow JSON-RPC (starts with { or [)
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            // BLOCK ARRAYS on stdout (Batch responses are not standard in MCP)
+            if (Array.isArray(parsed)) {
+                rootLogger.warn({ raw: str }, '🛡️ [SHIELD] Blocked array-as-JSON-RPC on stdout');
+                return process.stderr.write(chunk, encoding, callback);
+            }
+            // Check for JSON-RPC (Response or Notification)
+            if (parsed.jsonrpc === '2.0') {
+                return originalStdoutWrite(chunk, encoding, callback);
+            }
+            // Block non-RPC JSON
+            rootLogger.warn({ raw: str }, '🛡️ [SHIELD] Blocked non-JSON-RPC (Object) on stdout');
+            return process.stderr.write(chunk, encoding, callback);
+        }
+        catch (e) {
+            // Malformed JSON-like content
+            rootLogger.debug({ raw: str, err: e.message }, '🛡️ [SHIELD] Blocked malformed JSON-like content on stdout');
+            return process.stderr.write(chunk, encoding, callback);
+        }
+    }
+    // Redirect everything else to stderr (via Pino)
+    rootLogger.debug({ raw: trimmed }, '🛡️ [SHIELD] Intercepted non-JSON stdout write');
+    return process.stderr.write(chunk, encoding, callback);
+};
+// 🛡️ STDIN INTERCEPTOR: Detect and unroll JSON-RPC Batches [req1, req2]
+// FastMCP/Zod only support single objects. Intercepting before FastMCP starts.
+const originalStdin = process.stdin;
+const stdinProxy = new PassThrough();
+originalStdin.on('data', (chunk) => {
+    const str = chunk.toString();
+    const trimmed = str.trim();
+    // 🔍 [DEBUG] Log every incoming chunk that looks like JSON
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        rootLogger.debug({
+            length: trimmed.length,
+            preview: trimmed.substring(0, 100),
+            isBatch: trimmed.startsWith('['),
+        }, '[SHIELD] STDIN chunk received');
+    }
+    // If it's a batch, unroll it into separate JSON chunks
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                rootLogger.warn({ count: parsed.length }, '[SHIELD] Unrolling JSON-RPC BATCH on STDIN');
+                for (const item of parsed) {
+                    stdinProxy.write(JSON.stringify(item) + '\n');
+                }
+                return;
+            }
+        }
+        catch (_e) {
+            // Not a valid batch or partial JSON, pass through as-is
+        }
+    }
+    stdinProxy.write(chunk);
+});
+// Hijack process.stdin for FastMCP and any other consumers
+Object.defineProperty(process, 'stdin', {
+    value: stdinProxy,
+    writable: false,
+    configurable: true,
+});
+// Setup completed - Dynamically import server components AFTER process.env is configured
+const { createServer } = await import('../server.js');
+const { updateConfig } = await import('../lib/config.js');
+const cliArgs = process.argv.slice(2);
+let settingsPath, mcpPath;
+for (let i = 0; i < cliArgs.length; i++) {
+    if (cliArgs[i] === '--settings' && cliArgs[i + 1]) {
+        settingsPath = cliArgs[i + 1];
+        i++;
+    }
+    else if (cliArgs[i] === '--mcp-config' && cliArgs[i + 1]) {
+        mcpPath = cliArgs[i + 1];
+        i++;
+    }
+}
+if (settingsPath || mcpPath) {
+    updateConfig(settingsPath, mcpPath);
+    // Do NOT log to stderr during MCP initialization as it can cause EOF errors in some clients
+}
+const server = createServer();
+rootLogger.info('[Overmind] [START] Démarrage du serveur...');
+server.start({ transportType: 'stdio' });
+rootLogger.info('[Overmind] [READY] Serveur prêt sur STDIO.');
+//# sourceMappingURL=cli.js.map