overmind-mcp 2.0.1 → 2.0.3

package/scripts/install-dependencies.mjs

@@ -3,9 +3,11 @@
  * ═══════════════════════════════════════════════════════════════════════════════
  * INSTALL-DEPENDENCIES SCRIPT
  * ═══════════════════════════════════════════════════════════════════════════════
- * Script qui installe PostgreSQL + pgvector automatiquement si absents
+ * Script cross-platform qui détecte et installe uniquement ce qui manque :
+ * - Docker Desktop / Docker Engine
+ * - PostgreSQL + pgvector (détecte si déjà en Docker)
  *
- * Ce script fait partie du setup automatique d'OverMind-MCP
+ * Supporte: Windows (Docker Desktop), Linux (Docker Engine), macOS (Docker Desktop)
  * ═══════════════════════════════════════════════════════════════════════════════
  */
 
@@ -29,6 +31,14 @@ function logSection(title) {
   console.log('╚══════════════════════════════════════════════════════════════════╝');
 }
 
+function runCommand(cmd, options = {}) {
+  try {
+    return execSync(cmd, { stdio: 'pipe', encoding: 'utf8', ...options });
+  } catch {
+    return null;
+  }
+}
+
 function runCommandAsync(cmd, description) {
   return new Promise((resolve, reject) => {
     console.log(`🔧 ${description}`);
@@ -64,74 +74,200 @@ function promptYesNo(question) {
       rl.close();
       resolve(answer.toLowerCase().startsWith('y'));
     });
-  };
+  });
+}
+
+function openUrl(url) {
+  const platform = process.platform;
+
+  if (platform === 'win32') {
+    runCommand(`start ${url}`, { stdio: 'ignore' });
+  } else if (platform === 'darwin') {
+    runCommand(`open ${url}`, { stdio: 'ignore' });
+  } else {
+    runCommand(`xdg-open ${url}`, { stdio: 'ignore' });
+  }
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// INSTALLATION STEPS
+// DOCKER DETECTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
-async function installDocker() {
+async function checkDocker() {
   logSection('VÉRIFICATION DOCKER');
 
-  try {
-    execSync('docker --version', { stdio: 'pipe' });
-    console.log('✅ Docker est installé');
-    return true;
-  } catch {
+  // Check if Docker is installed
+  const version = runCommand('docker --version');
+  if (!version) {
     console.log('❌ Docker non trouvé');
-    console.log('');
-    console.log('📥 Installation Docker Desktop requis:');
-    console.log('   - Windows: https://www.docker.com/products/docker-desktop/');
-    console.log('   - Mac: https://www.docker.com/products/docker-desktop/');
-    console.log('');
-    console.log('💡 Après installation de Docker, relancez ce script');
+    return null;
+  }
+
+  console.log('✅ Docker détecté:', version.trim());
+
+  // Detect Docker Desktop vs Docker Engine
+  const platform = process.platform;
+
+  if (platform === 'win32' || platform === 'darwin') {
+    // Windows/macOS: Check Docker Desktop
+    const desktopStatus = runCommand('docker info --format "{{.OperatingSystem}}"');
+    if (desktopStatus?.includes('Docker Desktop')) {
+      console.log('✅ Docker Desktop détecté');
+      return { type: 'desktop', platform };
+    }
+  } else if (platform === 'linux') {
+    // Linux: Docker Engine
+    console.log('✅ Docker Engine (Linux) détecté');
+    return { type: 'engine', platform };
+  }
+
+  return { type: 'unknown', platform };
+}
 
-    const answer = await promptYesNo('Voulez-vous ouvrir le site de téléchargement maintenant ?');
-    if (answer) {
-      const url = process.platform === 'win32'
-        ? 'https://www.docker.com/products/docker-desktop/'
-        : 'https://www.docker.com/products/docker-desktop/';
+async function installDockerIfNeeded() {
+  const dockerInfo = await checkDocker();
+
+  if (dockerInfo) {
+    return dockerInfo;
+  }
+
+  console.log('');
+  console.log('📥 Installation Docker requise:');
+  console.log('   • Windows: Docker Desktop for Windows');
+  console.log('   • macOS: Docker Desktop for Mac');
+  console.log('   • Linux: Docker Engine (apt/yum/dnf)');
+  console.log('');
+
+  const answer = await promptYesNo('Voulez-vous ouvrir le site de téléchargement ?');
+  if (answer) {
+    const url = 'https://www.docker.com/products/docker-desktop/';
+    openUrl(url);
+    console.log('✅ Navigateur ouvert. Installez Docker, puis relancez ce script.');
+  }
+
+  return null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// POSTGRESQL + PGVECTOR DETECTION & INSTALLATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function detectExistingPostgreSQL() {
+  logSection('DÉTECTION POSTGRESQL EXISTANT');
+
+  // 1. Check native PostgreSQL (psql command)
+  const nativePg = runCommand('psql --version');
+  if (nativePg) {
+    console.log('✅ PostgreSQL natif détecté:', nativePg.trim());
+
+    // Check if pgvector is installed
+    const pgvectorCheck = runCommand('psql -U postgres -t -c "SELECT extname FROM pg_extension WHERE extname = \'vector\';"');
+    if (pgvectorCheck?.includes('vector')) {
+      console.log('✅ pgvector est installé');
+      return { type: 'native', hasPgvector: true };
+    } else {
+      console.log('⚠️  pgvector NON installé (installation manuelle requise)');
+      return { type: 'native', hasPgvector: false };
+    }
+  }
+
+  // 2. Check Docker containers with pgvector (multiple detection methods)
+  console.log('🔍 Recherche containers PostgreSQL avec pgvector...');
+
+  // Method A: Check by image name (pgvector/pgvector)
+  let containers = runCommand('docker ps --filter "ancestor=pgvector/pgvector" --format "{{.Names}}"', {
+    stdio: 'pipe'
+  });
 
+  // Method B: Check all containers with "pgvector" or "postgres" in name
+  if (!containers) {
+    containers = runCommand('docker ps --format "{{.Names}}" | grep -E "(pgvector|postgres)"', {
+      stdio: 'pipe',
+      shell: true
+    });
+  }
+
+  if (containers) {
+    const containerList = containers.trim().split('\n').filter(Boolean);
+    console.log(`✅ ${containerList.length} container(s) PostgreSQL détecté(s):`);
+    containerList.forEach(name => console.log(`   • ${name}`));
+
+    // Check each container for pgvector
+    for (const container of containerList) {
       try {
-        execSync(`start ${url}`, { stdio: 'pipe' });
-        console.log('✅ Navigateur ouvert. Installez Docker, puis relancez.');
+        const pgvectorCheck = runCommand(
+          `docker exec ${container} psql -U postgres -t -c "SELECT extname FROM pg_extension WHERE extname = 'vector';" 2>&1`,
+          { stdio: 'pipe' }
+        );
+
+        if (pgvectorCheck?.includes('vector')) {
+          console.log(`✅ pgvector actif dans ${container}`);
+          return { type: 'docker', container, hasPgvector: true };
+        }
       } catch {
-        console.log(`   Ouvrez manuellement: ${url}`);
+        // Container might not be accessible, try next
       }
     }
 
-    return false;
+    console.log('⚠️  Containers trouvés mais SANS pgvector installé');
   }
-}
 
-async function installPostgreSQL() {
-  logSection('INSTALLATION POSTGRESQL + PGVECTOR');
+  // 3. Check for any PostgreSQL container (might not have pgvector)
+  const allContainers = runCommand('docker ps --format "{{.Names}}"', {
+    stdio: 'pipe'
+  });
 
-  // Check if already running
-  try {
-    const containers = execSync(
-      'docker ps --filter "name=postgres-pgvector" --format "{{.Names}}"',
-      { encoding: 'utf8', stdio: 'pipe' }
-    ).trim();
+  if (allContainers) {
+    const pgContainers = allContainers
+      .trim()
+      .split('\n')
+      .filter(name => name.toLowerCase().includes('postgres') || name.toLowerCase().includes('pgvector'));
+
+    if (pgContainers.length > 0) {
+      console.log(`⚠️  ${pgContainers.length} container(s) PostgreSQL détecté(s) SANS pgvector:`);
+      pgContainers.forEach(name => console.log(`   • ${name}`));
+      console.log('');
+      console.log('💡 Le script va créer un nouveau container dédié.');
+    }
+  }
 
-    if (containers) {
-      console.log('✅ PostgreSQL + pgvector déjà installé (Docker)');
-      console.log('   Container:', containers);
+  if (genericContainers) {
+    const containerList = genericContainers.trim().split('\n').filter(Boolean);
+    console.log(`⚠️  ${containerList.length} container(s) PostgreSQL détecté(s) SANS pgvector:`);
+    containerList.forEach(name => console.log(`   • ${name}`));
+    console.log('');
+    console.log('💡 Ces containers n\'ont PAS pgvector. Le script va créer un nouveau container dédié.');
+  }
+
+  return null;
+}
+
+async function waitForPostgreSQL(containerName, maxWait = 60) {
+  console.log(`⏳ Attente démarrage PostgreSQL (max ${maxWait}s)...`);
+
+  for (let i = 0; i < maxWait; i++) {
+    try {
+      execSync(
+        `docker exec ${containerName} pg_isready -U postgres`,
+        { stdio: 'pipe', encoding: 'utf8' }
+      );
+      console.log('✅ PostgreSQL prêt !');
       return true;
+    } catch {
+      process.stdout.write('.');
+      await new Promise(resolve => setTimeout(resolve, 1000));
     }
-  } catch {}
-
-  // Check native PostgreSQL
-  try {
-    execSync('psql --version', { stdio: 'pipe' });
-    console.log('✅ PostgreSQL déjà installé (natif)');
-    return true;
-  } catch {}
+  }
 
-  // Install PostgreSQL + pgvector in Docker
-  console.log('🐳 Installation PostgreSQL + pgvector en Docker...');
   console.log('');
+  console.log('❌ Timeout: PostgreSQL n\'a pas démarré à temps');
+  return false;
+}
+
+async function installPostgreSQLDocker() {
+  logSection('INSTALLATION POSTGRESQL + PGVECTOR (DOCKER)');
+
+  const containerName = 'overmind-postgres-pgvector';
 
   try {
     // Pull image
@@ -141,58 +277,62 @@ async function installPostgreSQL() {
       'Téléchargement image'
     );
 
-    // Check if container name already exists
+    // Remove existing container if present
     try {
-      execSync('docker inspect postgres-pgvector', { stdio: 'pipe' });
-      console.log('⚠️  Container postgres-pgvector existe déjà. Suppression...');
-      execSync('docker rm -f postgres-pgvector', { stdio: 'pipe' });
+      execSync(`docker inspect ${containerName}`, { stdio: 'pipe' });
+      console.log(`⚠️  Container ${containerName} existe déjà. Suppression...`);
+      execSync(`docker rm -f ${containerName}`, { stdio: 'pipe' });
     } catch {
       // Container doesn't exist, that's fine
     }
 
-    // Check if volume exists
+    // Create volume if doesn't exist
     try {
-      execSync('docker volume ls | grep postgres_data', { stdio: 'pipe' });
-      console.log('ℹ️  Volume postgres_data existe déjà (réutilisation)');
+      execSync('docker volume create overmind_postgres_data', { stdio: 'pipe' });
     } catch {
-      console.log('📦 Création volume postgres_data...');
+      // Volume might already exist
     }
 
     // Run container
     console.log('🚀 Démarrage container PostgreSQL...');
-    const runCommand = `docker run -d --name postgres-pgvector \\
-      -p 5432:5432 \\
-      -e POSTGRES_PASSWORD=overmind_temp_password_change_me \\
-      -e POSTGRES_USER=postgres \\
-      -v postgres_data:/var/lib/postgresql/data \\
-      --restart unless-stopped \\
-      pgvector/pgvector:pg16`;
+    const runCommand = [
+      'docker', 'run', '-d',
+      '--name', containerName,
+      '-p', '5432:5432',
+      '-e', 'POSTGRES_PASSWORD=overmind_temp_password_change_me',
+      '-e', 'POSTGRES_USER=postgres',
+      '-v', 'overmind_postgres_data:/var/lib/postgresql/data',
+      '--restart', 'unless-stopped',
+      'pgvector/pgvector:pg16'
+    ].join(' ');
 
     await runCommandAsync(runCommand, 'Démarrage PostgreSQL');
 
     // Wait for PostgreSQL to be ready
-    console.log('⏳ Attente démarrage PostgreSQL (30s)...');
-    await new Promise((resolve) => setTimeout(resolve, 30000));
+    const ready = await waitForPostgreSQL(containerName);
+    if (!ready) {
+      throw new Error('PostgreSQL n\'a pas démarré');
+    }
 
     // Test connection
     console.log('🔍 Test connexion PostgreSQL...');
     await runCommandAsync(
-      'docker exec postgres-pgvector psql -U postgres -c "SELECT version();"',
+      `docker exec ${containerName} psql -U postgres -c "SELECT version();"`,
       'Test connexion'
     );
 
     // Enable pgvector
     console.log('🔧 Activation extension pgvector...');
     await runCommandAsync(
-      'docker exec postgres-pgvector psql -U postgres -c "CREATE EXTENSION IF NOT EXISTS vector;"',
+      `docker exec ${containerName} psql -U postgres -c "CREATE EXTENSION IF NOT EXISTS vector;"`,
       'Activation pgvector'
     );
 
     // Verify pgvector
     console.log('✅ Vérification pgvector...');
-    const result = execSync(
-      'docker exec postgres-pgvector psql -U postgres -t',
-      { encoding: 'utf8', stdio: 'pipe'
+    const result = runCommand(
+      `docker exec ${containerName} psql -U postgres -t -c "SELECT extname FROM pg_extension WHERE extname = 'vector';"`,
+      { encoding: 'utf8', stdio: 'pipe' }
     ).trim();
 
     if (result.includes('vector')) {
@@ -205,26 +345,29 @@ async function installPostgreSQL() {
     console.log('🎉 PostgreSQL + pgvector installés !');
     console.log('');
     console.log('📋 Détails:');
-    console.log('   Container: postgres-pgvector');
+    console.log(`   Container: ${containerName}`);
     console.log('   Port: 5432');
     console.log('   User: postgres');
     console.log('   Password: overmind_temp_password_change_me (À CHANGER !)');
     console.log('   Extension: vector (pgvector)');
 
-    return true;
+    return { type: 'docker', container: containerName, hasPgvector: true };
 
   } catch (error) {
     console.error('❌ Erreur installation PostgreSQL:', error.message);
     console.error('');
     console.log('💡 Solution manuelle:');
-    console.log('   docker run -d --name postgres-pgvector \\');
+    console.log(`   docker run -d --name ${containerName} \\`);
     console.log('     -p 5432:5432 \\');
     console.log('     -e POSTGRES_PASSWORD=votre_pass \\');
     console.log('     -e POSTGRES_USER=postgres \\');
-    console.log('     -v postgres_data:/var/lib/postgresql/data \\');
+    console.log('     -v overmind_postgres_data:/var/lib/postgresql/data \\');
     console.log('     --restart unless-stopped \\');
     console.log('     pgvector/pgvector:pg16');
-    return false;
+    console.log('');
+    console.log('Ou en une ligne (Windows):');
+    console.log(`   docker run -d --name ${containerName} -p 5432:5432 -e POSTGRES_PASSWORD=votre_pass -e POSTGRES_USER=postgres -v overmind_postgres_data:/var/lib/postgresql/data --restart unless-stopped pgvector/pgvector:pg16`);
+    return null;
   }
 }
 
@@ -236,21 +379,52 @@ async function main() {
   console.log('╔══════════════════════════════════════════════════════════════════╗');
   console.log('║                                                                ║');
   console.log('║     🗄️️  INSTALLATION POSTGRESQL + PGVECTOR                          ║');
+  console.log('║     Détection & Installation Automatique                          ║');
   console.log('║                                                                ║');
   console.log('╚══════════════════════════════════════════════════════════════════╝');
   console.log('');
 
-  // Install Docker if needed
-  const dockerInstalled = await installDocker();
-  if (!dockerInstalled) {
+  // Step 1: Check/Install Docker
+  const dockerInfo = await installDockerIfNeeded();
+  if (!dockerInfo) {
     console.log('\n⚠️  Relancez ce script après avoir installé Docker.');
     process.exit(1);
   }
 
-  // Install PostgreSQL
-  const pgInstalled = await installPostgreSQL();
-  if (!pgInstalled) {
-    console.log('\n⚠️  Relancez ce script après avoir installé PostgreSQL.');
+  console.log('');
+  console.log(`📊 Plateforme: ${dockerInfo.type} (${dockerInfo.platform})`);
+  console.log('');
+
+  // Step 2: Detect existing PostgreSQL
+  const existingPg = await detectExistingPostgreSQL();
+
+  if (existingPg && existingPg.hasPgvector) {
+    console.log('');
+    console.log('✅ PostgreSQL + pgvector sont déjà installés !');
+
+    if (existingPg.type === 'docker') {
+      console.log(`   Container: ${existingPg.container}`);
+      console.log('   Port: 5432');
+      console.log('   User: postgres');
+      console.log('   Extension: vector (pgvector)');
+    } else if (existingPg.type === 'native') {
+      console.log('   Installation native détectée');
+      console.log('   Extension: vector (pgvector)');
+    }
+
+    console.log('');
+    console.log('🎉 Rien à installer !');
+
+    return;
+  }
+
+  // Step 3: Install PostgreSQL + pgvector
+  console.log('');
+  console.log('📦 Installation de PostgreSQL + pgvector requise...');
+
+  const installResult = await installPostgreSQLDocker();
+  if (!installResult) {
+    console.log('\n⚠️  Installation échouée. Vérifiez les erreurs ci-dessus.');
     process.exit(1);
   }
 
@@ -258,24 +432,29 @@ async function main() {
   logSection('✅ INSTALLATION TERMINÉE');
 
   console.log(`
-🎉 PostgreSQL + pgvector installés avec succès !
+🎉 PostgreSQL + pgvector sont prêts !
 
 📋 PROCHAINE ÉTAPE:
    → Relancez: overmind-setup --full
    Ou manuellement: overmind-setup
 
 💡 RAPPEL:
-   - Container: postgres-pgvector
-   - Port: 5432
-   - User: postgres
-   - Password: overmind_temp_password_change_me (CHANGEZ-LE !)
+   • Container: ${installResult.container}
+   • Port: 5432
+   • User: postgres
+   • Password: overmind_temp_password_change_me (CHANGEZ-LE !)
+   • Extension: vector (pgvector)
 
 ═════════════════════════════════════════════════════════════════════
 `);
 }
 
 // Run main
-if (import.meta.url === `file://${process.argv[1]}`) {
+// Check if this file is being run directly (not imported)
+const modulePath = fileURLToPath(import.meta.url);
+const isMainModule = process.argv[1] === modulePath;
+
+if (isMainModule) {
   main().catch((error) => {
     console.error('\n❌ ERREUR FATALE:', error.message);
     process.exit(1);