@oussema_mili/test-pkg-123 1.1.22

package/containerManager.js

@@ -0,0 +1,304 @@
+import os from 'os';
+import { spawn, exec } from 'child_process';
+import path from 'path';
+import chalk from 'chalk';
+import { loadConfig } from './store/configStore.js';
+
+// Load configuration
+const config = loadConfig();
+const CONTAINER_NAME = config.containerName;
+const AGENT_ROOT_DIR = config.agentRootDir;
+const REGISTRIES_DIR = config.registriesDir;
+const HOST_DATA_DIR = path.join(os.homedir(), AGENT_ROOT_DIR, REGISTRIES_DIR);
+const HOST_FW_DIR = path.join(os.homedir(), AGENT_ROOT_DIR);
+const CONTAINER_DATA_DIR = config.containerDataDir;
+const CONTAINER_FW_DIR = '/app/.fenwave';
+const APP_PORT = config.containerPort;
+const WS_PORT = config.wsPort;
+const DOCKER_IMAGE = config.dockerImage;
+
+/**
+ * Container Manager for Fenwave DevApp
+ */
+class ContainerManager {
+  constructor() {
+    this.isRunning = false;
+    this.containerProcess = null;
+  }
+
+  /**
+   * Check if Docker is available
+   */
+  async checkDockerAvailable() {
+    return new Promise((resolve) => {
+      exec('docker --version', (error) => {
+        resolve(!error);
+      });
+    });
+  }
+
+  /**
+   * Check if container is already running
+   */
+  async isContainerRunning() {
+    return new Promise((resolve) => {
+      exec(
+        `docker ps --filter name=${CONTAINER_NAME} --format "{{.Names}}"`,
+        (error, stdout) => {
+          if (error) {
+            resolve(false);
+            return;
+          }
+          resolve(stdout.trim() === CONTAINER_NAME);
+        }
+      );
+    });
+  }
+
+  /**
+   * Stop and remove existing container
+   */
+  async stopContainer() {
+    return new Promise((resolve) => {
+      exec(
+        `docker stop ${CONTAINER_NAME} && docker rm ${CONTAINER_NAME}`,
+        (error) => {
+          // Don't worry if container doesn't exist
+          resolve();
+        }
+      );
+    });
+  }
+
+  /**
+   * Check if image exists locally
+   */
+  async imageExistsLocally() {
+    return new Promise((resolve) => {
+      exec(
+        `docker images -q ${DOCKER_IMAGE}`,
+        (error, stdout) => {
+          resolve(stdout.trim().length > 0);
+        }
+      );
+    });
+  }
+
+  /**
+   * Pull the Fenwave DevApp image from GHCR
+   */
+  async pullImage() {
+    return new Promise(async (resolve, reject) => {
+      try {
+        // Check if image exists locally
+        const imageExists = await this.imageExistsLocally();
+        if (imageExists) {
+          console.log(chalk.green('✅ Image already exists locally, checking for updates...'));
+        }
+
+        console.log(chalk.blue('📥 Pulling Fenwave DevApp image...'));
+        console.log(chalk.gray(`   Image: ${DOCKER_IMAGE}`));
+
+        const pullProcess = spawn('docker', ['pull', DOCKER_IMAGE], {
+          stdio: 'pipe',
+        });
+
+        let output = '';
+        let errorOutput = '';
+
+        pullProcess.stdout.on('data', (data) => {
+          output += data.toString();
+          // Show pull progress for important lines
+          const lines = data
+            .toString()
+            .split('\n')
+            .filter((line) => line.trim());
+          lines.forEach((line) => {
+            if (
+              line.includes('Pulling from') ||
+              line.includes('Digest:') ||
+              line.includes('Status:') ||
+              line.includes('Downloaded')
+            ) {
+              console.log(chalk.gray(`   ${line.trim()}`));
+            }
+          });
+        });
+
+        pullProcess.stderr.on('data', (data) => {
+          errorOutput += data.toString();
+        });
+
+        pullProcess.on('close', (code) => {
+          if (code === 0) {
+            console.log(chalk.green('✅ Image pulled successfully'));
+            resolve();
+          } else {
+            console.error(chalk.red('❌ Failed to pull image:'));
+            console.error(errorOutput);
+            reject(new Error(`Pull failed with code ${code}`));
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Start the Fenwave DevApp container
+   */
+  async startContainer() {
+    try {
+      // Check Docker availability
+      const dockerAvailable = await this.checkDockerAvailable();
+      if (!dockerAvailable) {
+        throw new Error(
+          'Docker is not available. Please install Docker and try again.'
+        );
+      }
+
+      // Stop existing container if running
+      await this.stopContainer();
+
+      // Pull image from GHCR (public registry, no auth required)
+      try {
+        await this.pullImage();
+      } catch (pullError) {
+        console.log(chalk.yellow('⚠️  Image pull failed, checking for local image...'));
+        const imageExists = await this.imageExistsLocally();
+        if (!imageExists) {
+          throw new Error('No local image available and pull failed. Please check your network connection.');
+        }
+        console.log(chalk.green('✅ Using cached local image'));
+      }
+
+      // Determine WebSocket URL based on platform
+      let wsUrl = `ws://host.docker.internal:${WS_PORT}`;
+      if (os.platform() === 'linux') {
+        // On Linux, use host network or get host IP
+        wsUrl = `ws://172.17.0.1:${WS_PORT}`; // Docker default bridge IP
+      }
+
+      console.log(chalk.blue('🚀 Starting Fenwave DevApp container...'));
+
+      const runArgs = [
+        'run',
+        '-d', // Detached mode
+        '--name',
+        CONTAINER_NAME,
+        '-p',
+        `${APP_PORT}:${APP_PORT}`,
+        // Mount registry data directory
+        '-v',
+        `${HOST_DATA_DIR}:${CONTAINER_DATA_DIR}:rw`,
+        // Mount .fenwave directory for WebSocket token access
+        '-v',
+        `${HOST_FW_DIR}:${CONTAINER_FW_DIR}:ro`,
+        '-e',
+        `PORT=${APP_PORT}`,
+        '-e',
+        `NEXT_PUBLIC_WS_URL=${wsUrl}`,
+        '--restart',
+        'unless-stopped',
+        DOCKER_IMAGE,
+      ];
+
+      return new Promise((resolve, reject) => {
+        const runProcess = spawn('docker', runArgs, {
+          stdio: 'pipe',
+        });
+
+        let output = '';
+        let errorOutput = '';
+
+        runProcess.stdout.on('data', (data) => {
+          output += data.toString();
+        });
+
+        runProcess.stderr.on('data', (data) => {
+          errorOutput += data.toString();
+        });
+
+        runProcess.on('close', (code) => {
+          if (code === 0) {
+            this.isRunning = true;
+            console.log(chalk.green('✅ Container started successfully'));
+            console.log(chalk.gray(`   Image: ${DOCKER_IMAGE}`));
+            console.log(chalk.gray(`   Container: ${CONTAINER_NAME}`));
+            console.log(chalk.gray(`   Port: ${APP_PORT}`));
+            console.log(chalk.gray(`   Data volume: ${HOST_DATA_DIR} -> ${CONTAINER_DATA_DIR}`));
+            console.log(chalk.gray(`   Token volume: ${HOST_FW_DIR} -> ${CONTAINER_FW_DIR}`));
+            resolve();
+          } else {
+            console.error(chalk.red('❌ Failed to start container:'));
+            if (errorOutput) {
+              console.error(errorOutput);
+            }
+            reject(new Error(`Container start failed with code ${code}`));
+          }
+        });
+      });
+    } catch (error) {
+      console.error(
+        chalk.red('❌ Failed to start Fenwave DevApp:'),
+        error.message
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Stop the Fenwave DevApp container
+   */
+  async stopContainerGracefully() {
+    try {
+      const running = await this.isContainerRunning();
+      if (!running) {
+        console.log(chalk.yellow('ℹ️ Container is not running'));
+        return;
+      }
+
+      await this.stopContainer();
+      this.isRunning = false;
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to stop container:'), error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Get container status
+   */
+  async getStatus() {
+    const running = await this.isContainerRunning();
+    return {
+      isRunning: running,
+      containerName: CONTAINER_NAME,
+      port: APP_PORT,
+      dataDirectory: HOST_DATA_DIR,
+    };
+  }
+
+  /**
+   * Show container logs
+   */
+  showLogs(follow = false) {
+    const args = ['logs'];
+    if (follow) {
+      args.push('-f');
+    }
+    args.push(CONTAINER_NAME);
+
+    const logsProcess = spawn('docker', args, {
+      stdio: 'inherit',
+    });
+
+    return logsProcess;
+  }
+}
+
+// Singleton instance
+const containerManager = new ContainerManager();
+
+export default containerManager;