s9n-devops-agent 1.0.0 → 1.2.0

package/README.md

@@ -23,6 +23,7 @@ An intelligent Git automation system with multi-agent support, session managemen
 - **⚙️ VS Code Integration**: Seamlessly integrates with VS Code tasks
 - **🔐 Safe Concurrent Development**: Multiple agents can work simultaneously without conflicts
 - **🏷️ Smart Branching**: Automatic branch creation with configurable naming patterns
+- **🐋 Docker Auto-Restart**: Automatically restart Docker containers after code push (v1.2.0)
 
 ## Installation 📦
 
@@ -226,6 +227,30 @@ Add to `.vscode/tasks.json`:
 
 ## Advanced Features 🔬
 
+### Docker Container Auto-Restart (v1.2.0+)
+
+Automatically restart Docker containers after pushing code changes:
+
+```bash
+# During session creation, if docker-compose is detected:
+s9n-devops-agent start
+# -> Auto-restart Docker containers after push? (y/N): y
+# -> Rebuild containers on restart? (y/N): n
+# -> Specific service to restart (leave empty for all): app
+```
+
+**Features:**
+- Detects docker-compose files automatically
+- Optional container rebuild on restart
+- Target specific services or restart all
+- Non-blocking: Docker failures don't affect git workflow
+- Works with Docker Compose v1 and v2
+
+**Supported docker-compose files:**
+- docker-compose.yml / docker-compose.yaml
+- compose.yml / compose.yaml
+- docker-compose.dev.yml / docker-compose.local.yml
+
 ### Multi-Agent Collaboration
 
 Multiple AI assistants can work on different features simultaneously:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s9n-devops-agent",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "CS_DevOpsAgent - Intelligent Git Automation System with multi-agent support and session management",
   "type": "module",
   "main": "src/cs-devops-agent-worker.js",

package/src/cs-devops-agent-worker.js

@@ -113,6 +113,7 @@ import chokidar from "chokidar";
 import { execa } from "execa";
 import readline from "node:readline";
 import { stdin as input, stdout as output } from 'node:process';
+import { restartDockerContainers } from './docker-utils.js';
 
 // ============================================================================
 // CONFIGURATION SECTION - All settings can be overridden via environment vars
@@ -762,7 +763,12 @@ async function commitOnce(repoRoot, msgPath) {
     if (PUSH) {
       const ok = await pushBranch(BRANCH);
       log(`push ${ok ? "ok" : "failed"}`);
-      if (ok && CLEAR_MSG_WHEN === "push") clearMsgFile(msgPath);
+      if (ok) {
+        if (CLEAR_MSG_WHEN === "push") clearMsgFile(msgPath);
+        
+        // Handle Docker restart if configured
+        await handleDockerRestart();
+      }
     }
   } finally {
     busy = false;
@@ -782,6 +788,52 @@ function schedule(repoRoot, msgPath) {
   }, QUIET_MS);
 }
 
+// ============================================================================
+// DOCKER CONTAINER MANAGEMENT
+// ============================================================================
+
+/**
+ * Handle Docker container restart if configured in session
+ */
+async function handleDockerRestart() {
+  // Check if we're in a session with Docker configuration
+  const sessionConfigPath = path.join(process.cwd(), '.devops-session.json');
+  if (!fs.existsSync(sessionConfigPath)) {
+    return; // Not in a managed session
+  }
+  
+  try {
+    const sessionConfig = JSON.parse(fs.readFileSync(sessionConfigPath, 'utf8'));
+    
+    // Check if Docker restart is enabled
+    if (!sessionConfig.dockerConfig || !sessionConfig.dockerConfig.enabled) {
+      return;
+    }
+    
+    log('🐋 Docker restart configured - initiating container restart...');
+    
+    const dockerOptions = {
+      projectPath: process.cwd(),
+      composeFile: sessionConfig.dockerConfig.composeFile,
+      serviceName: sessionConfig.dockerConfig.service,
+      rebuild: sessionConfig.dockerConfig.rebuild,
+      forceRecreate: sessionConfig.dockerConfig.forceRecreate || false,
+      detach: true
+    };
+    
+    const result = await restartDockerContainers(dockerOptions);
+    
+    if (result.success) {
+      log('✅ Docker containers restarted successfully');
+    } else {
+      log(`⚠️ Docker restart failed: ${result.error}`);
+    }
+  } catch (error) {
+    // Don't fail the commit/push if Docker restart fails
+    dlog('Docker restart error:', error.message);
+  }
+}
+
 // ============================================================================
 // INFRASTRUCTURE CHANGE DETECTION
 // ============================================================================

package/src/docker-utils.js

@@ -0,0 +1,290 @@
+/**
+ * ============================================================================
+ * DOCKER UTILITIES FOR DEVOPS AGENT
+ * ============================================================================
+ * 
+ * PURPOSE:
+ * Provides Docker container management functionality for automatic restarts
+ * after code pushes. Integrates with the DevOps agent session workflow.
+ * 
+ * ============================================================================
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execa } from 'execa';
+
+/**
+ * Check if Docker is installed and running
+ */
+export async function isDockerAvailable() {
+  try {
+    await execa('docker', ['version'], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if docker-compose is available
+ */
+export async function isDockerComposeAvailable() {
+  try {
+    // Try docker compose (v2)
+    await execa('docker', ['compose', 'version'], { stdio: 'pipe' });
+    return 'docker compose';
+  } catch {
+    try {
+      // Try docker-compose (v1)
+      await execa('docker-compose', ['version'], { stdio: 'pipe' });
+      return 'docker-compose';
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Find docker-compose files in the project
+ */
+export function findDockerComposeFiles(projectPath) {
+  const possibleFiles = [
+    'docker-compose.yml',
+    'docker-compose.yaml',
+    'compose.yml',
+    'compose.yaml',
+    'docker-compose.dev.yml',
+    'docker-compose.dev.yaml',
+    'docker-compose.local.yml',
+    'docker-compose.local.yaml'
+  ];
+  
+  const found = [];
+  for (const file of possibleFiles) {
+    const filePath = path.join(projectPath, file);
+    if (fs.existsSync(filePath)) {
+      found.push({
+        name: file,
+        path: filePath
+      });
+    }
+  }
+  
+  return found;
+}
+
+/**
+ * Check if project has Docker configuration
+ */
+export function hasDockerConfiguration(projectPath) {
+  const composeFiles = findDockerComposeFiles(projectPath);
+  const dockerfilePath = path.join(projectPath, 'Dockerfile');
+  
+  return {
+    hasCompose: composeFiles.length > 0,
+    hasDockerfile: fs.existsSync(dockerfilePath),
+    composeFiles: composeFiles
+  };
+}
+
+/**
+ * Restart Docker containers
+ */
+export async function restartDockerContainers(options = {}) {
+  const {
+    projectPath = process.cwd(),
+    composeFile = null,
+    serviceName = null,
+    forceRecreate = false,
+    rebuild = false,
+    detach = true
+  } = options;
+
+  console.log('\n🐋 Docker Container Restart');
+  console.log('━'.repeat(50));
+
+  try {
+    // Check if Docker is available
+    const dockerCmd = await isDockerComposeAvailable();
+    if (!dockerCmd) {
+      throw new Error('Docker Compose is not available');
+    }
+
+    // Determine compose file to use
+    let composeFilePath = composeFile;
+    if (!composeFilePath) {
+      const dockerConfig = hasDockerConfiguration(projectPath);
+      if (dockerConfig.hasCompose && dockerConfig.composeFiles.length > 0) {
+        composeFilePath = dockerConfig.composeFiles[0].path;
+      } else {
+        throw new Error('No docker-compose file found');
+      }
+    }
+
+    // Build command arguments
+    const isV2 = dockerCmd === 'docker compose';
+    const baseCmd = isV2 ? ['docker', 'compose'] : ['docker-compose'];
+    const fileArgs = ['-f', composeFilePath];
+
+    // Stop containers
+    console.log('📦 Stopping containers...');
+    const stopArgs = [...fileArgs, 'stop'];
+    if (serviceName) stopArgs.push(serviceName);
+    
+    const stopResult = await execa(baseCmd[0], [...baseCmd.slice(1), ...stopArgs], {
+      cwd: projectPath,
+      stdio: 'inherit'
+    });
+
+    // Optionally rebuild
+    if (rebuild) {
+      console.log('🔨 Rebuilding containers...');
+      const buildArgs = [...fileArgs, 'build'];
+      if (serviceName) buildArgs.push(serviceName);
+      
+      await execa(baseCmd[0], [...baseCmd.slice(1), ...buildArgs], {
+        cwd: projectPath,
+        stdio: 'inherit'
+      });
+    }
+
+    // Start containers
+    console.log('🚀 Starting containers...');
+    const upArgs = [...fileArgs, 'up'];
+    if (forceRecreate) upArgs.push('--force-recreate');
+    if (detach) upArgs.push('-d');
+    if (serviceName) upArgs.push(serviceName);
+
+    await execa(baseCmd[0], [...baseCmd.slice(1), ...upArgs], {
+      cwd: projectPath,
+      stdio: 'inherit'
+    });
+
+    console.log('✅ Docker containers restarted successfully');
+    console.log('━'.repeat(50));
+    return { success: true };
+
+  } catch (error) {
+    console.error('❌ Failed to restart Docker containers:', error.message);
+    console.log('━'.repeat(50));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Get Docker container status
+ */
+export async function getDockerStatus(projectPath = process.cwd(), composeFile = null) {
+  try {
+    const dockerCmd = await isDockerComposeAvailable();
+    if (!dockerCmd) {
+      return { running: false, services: [] };
+    }
+
+    let composeFilePath = composeFile;
+    if (!composeFilePath) {
+      const dockerConfig = hasDockerConfiguration(projectPath);
+      if (dockerConfig.hasCompose && dockerConfig.composeFiles.length > 0) {
+        composeFilePath = dockerConfig.composeFiles[0].path;
+      } else {
+        return { running: false, services: [] };
+      }
+    }
+
+    const isV2 = dockerCmd === 'docker compose';
+    const baseCmd = isV2 ? ['docker', 'compose'] : ['docker-compose'];
+    const psArgs = ['-f', composeFilePath, 'ps', '--format', 'json'];
+
+    const result = await execa(baseCmd[0], [...baseCmd.slice(1), ...psArgs], {
+      cwd: projectPath,
+      stdio: 'pipe'
+    });
+
+    // Parse the JSON output
+    const services = [];
+    if (result.stdout) {
+      const lines = result.stdout.split('\n').filter(line => line.trim());
+      for (const line of lines) {
+        try {
+          const service = JSON.parse(line);
+          services.push({
+            name: service.Service || service.Name,
+            state: service.State,
+            status: service.Status,
+            ports: service.Ports
+          });
+        } catch {
+          // Skip unparseable lines
+        }
+      }
+    }
+
+    return {
+      running: services.some(s => s.state === 'running'),
+      services: services
+    };
+
+  } catch (error) {
+    return { running: false, services: [], error: error.message };
+  }
+}
+
+/**
+ * Monitor Docker logs
+ */
+export async function tailDockerLogs(options = {}) {
+  const {
+    projectPath = process.cwd(),
+    composeFile = null,
+    serviceName = null,
+    lines = 50,
+    follow = true
+  } = options;
+
+  try {
+    const dockerCmd = await isDockerComposeAvailable();
+    if (!dockerCmd) {
+      throw new Error('Docker Compose is not available');
+    }
+
+    let composeFilePath = composeFile;
+    if (!composeFilePath) {
+      const dockerConfig = hasDockerConfiguration(projectPath);
+      if (dockerConfig.hasCompose && dockerConfig.composeFiles.length > 0) {
+        composeFilePath = dockerConfig.composeFiles[0].path;
+      } else {
+        throw new Error('No docker-compose file found');
+      }
+    }
+
+    const isV2 = dockerCmd === 'docker compose';
+    const baseCmd = isV2 ? ['docker', 'compose'] : ['docker-compose'];
+    const logsArgs = ['-f', composeFilePath, 'logs'];
+    
+    if (lines) logsArgs.push('--tail', lines.toString());
+    if (follow) logsArgs.push('-f');
+    if (serviceName) logsArgs.push(serviceName);
+
+    const proc = execa(baseCmd[0], [...baseCmd.slice(1), ...logsArgs], {
+      cwd: projectPath,
+      stdio: 'inherit'
+    });
+
+    return proc;
+
+  } catch (error) {
+    console.error('Failed to tail Docker logs:', error.message);
+    return null;
+  }
+}
+
+export default {
+  isDockerAvailable,
+  isDockerComposeAvailable,
+  findDockerComposeFiles,
+  hasDockerConfiguration,
+  restartDockerContainers,
+  getDockerStatus,
+  tailDockerLogs
+};

package/src/session-coordinator.js

@@ -19,9 +19,10 @@
 
 import fs from 'fs';
 import path from 'path';
-import { execSync, spawn, fork } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
+import { execSync, spawn } from 'child_process';
+import crypto from 'crypto';
+import readline from 'readline';
+import { hasDockerConfiguration } from './docker-utils.js';
 import crypto from 'crypto';
 import readline from 'readline';
 
@@ -367,7 +368,91 @@ class SessionCoordinator {
   }
   
   /**
-   * Prompt for merge configuration
+   * Prompt for Docker restart configuration
+   */
+  async promptForDockerConfig() {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    // Ask if they want automatic Docker restarts
+    const autoRestart = await new Promise((resolve) => {
+      rl.question('\nAuto-restart Docker containers after push? (y/N): ', (answer) => {
+        resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+      });
+    });
+    
+    if (!autoRestart) {
+      rl.close();
+      return { enabled: false };
+    }
+    
+    // Ask which compose file to use if multiple
+    const dockerInfo = hasDockerConfiguration(process.cwd());
+    let selectedComposeFile = null;
+    
+    if (dockerInfo.composeFiles.length > 1) {
+      console.log(`\n${CONFIG.colors.bright}Select docker-compose file:${CONFIG.colors.reset}`);
+      dockerInfo.composeFiles.forEach((file, index) => {
+        console.log(`  ${index + 1}) ${file.name}`);
+      });
+      
+      const fileChoice = await new Promise((resolve) => {
+        rl.question(`Choose file (1-${dockerInfo.composeFiles.length}) [1]: `, (answer) => {
+          const choice = parseInt(answer) || 1;
+          if (choice >= 1 && choice <= dockerInfo.composeFiles.length) {
+            resolve(dockerInfo.composeFiles[choice - 1]);
+          } else {
+            resolve(dockerInfo.composeFiles[0]);
+          }
+        });
+      });
+      
+      selectedComposeFile = fileChoice.path;
+    } else if (dockerInfo.composeFiles.length === 1) {
+      selectedComposeFile = dockerInfo.composeFiles[0].path;
+    }
+    
+    // Ask about rebuild preference
+    const rebuild = await new Promise((resolve) => {
+      rl.question('\nRebuild containers on restart? (y/N): ', (answer) => {
+        resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+      });
+    });
+    
+    // Ask about specific service
+    const specificService = await new Promise((resolve) => {
+      rl.question('\nSpecific service to restart (leave empty for all): ', (answer) => {
+        resolve(answer.trim() || null);
+      });
+    });
+    
+    rl.close();
+    
+    const config = {
+      enabled: true,
+      composeFile: selectedComposeFile,
+      rebuild: rebuild,
+      service: specificService,
+      forceRecreate: false
+    };
+    
+    console.log(`\n${CONFIG.colors.green}✓${CONFIG.colors.reset} Docker restart configuration:`);
+    console.log(`  ${CONFIG.colors.bright}Auto-restart:${CONFIG.colors.reset} Enabled`);
+    if (selectedComposeFile) {
+      console.log(`  ${CONFIG.colors.bright}Compose file:${CONFIG.colors.reset} ${path.basename(selectedComposeFile)}`);
+    }
+    console.log(`  ${CONFIG.colors.bright}Rebuild:${CONFIG.colors.reset} ${rebuild ? 'Yes' : 'No'}`);
+    if (specificService) {
+      console.log(`  ${CONFIG.colors.bright}Service:${CONFIG.colors.reset} ${specificService}`);
+    }
+    
+    return config;
+  }
+
+  /**
+   * Prompt for auto-merge configuration
    */
   async promptForMergeConfig() {
     const rl = readline.createInterface({
@@ -593,6 +678,27 @@ class SessionCoordinator {
     // Ask for auto-merge configuration
     const mergeConfig = await this.promptForMergeConfig();
     
+    // Check for Docker configuration and ask about restart preference
+    let dockerConfig = null;
+    const dockerInfo = hasDockerConfiguration(process.cwd());
+    
+    if (dockerInfo.hasCompose || dockerInfo.hasDockerfile) {
+      console.log(`\n${CONFIG.colors.yellow}Docker Configuration Detected${CONFIG.colors.reset}`);
+      
+      if (dockerInfo.hasCompose) {
+        console.log(`${CONFIG.colors.dim}Found docker-compose files:${CONFIG.colors.reset}`);
+        dockerInfo.composeFiles.forEach(file => {
+          console.log(`  • ${file.name}`);
+        });
+      }
+      
+      if (dockerInfo.hasDockerfile) {
+        console.log(`${CONFIG.colors.dim}Found Dockerfile${CONFIG.colors.reset}`);
+      }
+      
+      dockerConfig = await this.promptForDockerConfig();
+    }
+    
     // Create worktree with developer initials in the name
     const worktreeName = `${agentType}-${devInitials}-${sessionId}-${task.replace(/\s+/g, '-')}`;
     const worktreePath = path.join(this.worktreesPath, worktreeName);
@@ -615,7 +721,8 @@ class SessionCoordinator {
         status: 'active',
         pid: process.pid,
         developerInitials: devInitials,
-        mergeConfig: mergeConfig
+        mergeConfig: mergeConfig,
+        dockerConfig: dockerConfig
       };
       
       const lockFile = path.join(this.locksPath, `${sessionId}.lock`);