@fenwave/agent 1.1.0

package/containerManager.js

@@ -0,0 +1,385 @@
+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();
+        }
+      );
+    });
+  }
+
+  /**
+   * Authenticate with AWS ECR
+   */
+  async authenticateECR() {
+    return new Promise((resolve, reject) => {
+      const awsRegion = config.awsRegion;
+      const awsAccountId = config.awsAccountId;
+
+      if (!awsRegion || !awsAccountId) {
+        console.log(chalk.yellow('⚠️  AWS ECR configuration not set, skipping ECR authentication'));
+        console.log(chalk.gray('   Run "fenwave init" to configure ECR settings'));
+        resolve();
+        return;
+      }
+
+      console.log(chalk.blue('🔐 Authenticating with AWS ECR...'));
+
+      const authProcess = spawn('aws', [
+        'ecr',
+        'get-login-password',
+        '--region',
+        awsRegion,
+      ]);
+
+      let authToken = '';
+      let errorOutput = '';
+
+      authProcess.stdout.on('data', (data) => {
+        authToken += data.toString();
+      });
+
+      authProcess.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      authProcess.on('close', (code) => {
+        if (code === 0) {
+          // Now login to Docker with the auth token
+          const loginProcess = spawn('docker', [
+            'login',
+            '--username',
+            'AWS',
+            '--password-stdin',
+            `${awsAccountId}.dkr.ecr.${awsRegion}.amazonaws.com`,
+          ]);
+
+          loginProcess.stdin.write(authToken.trim());
+          loginProcess.stdin.end();
+
+          let loginError = '';
+          loginProcess.stderr.on('data', (data) => {
+            loginError += data.toString();
+          });
+
+          loginProcess.on('close', (loginCode) => {
+            if (loginCode === 0) {
+              console.log(chalk.green('✅ Authenticated with ECR'));
+              resolve();
+            } else {
+              console.error(chalk.red('❌ Failed to login to Docker registry:'));
+              console.error(loginError);
+              reject(new Error('ECR Docker login failed'));
+            }
+          });
+        } else {
+          console.error(chalk.red('❌ Failed to get ECR auth token:'));
+          console.error(errorOutput);
+          reject(new Error('ECR authentication failed'));
+        }
+      });
+    });
+  }
+
+  /**
+   * 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 ECR
+   */
+  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 from ECR...'));
+        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();
+
+      // Authenticate with ECR
+      try {
+        await this.authenticateECR();
+      } catch (ecrError) {
+        console.log(chalk.yellow('⚠️  ECR authentication failed, attempting to use cached image...'));
+        // Continue with cached image if authentication fails
+      }
+
+      // Pull image from ECR
+      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 AWS credentials and 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;

package/convert-to-esm.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+# ES Module Conversion Script
+# Converts CommonJS files to ES modules
+
+echo "Converting CommonJS files to ES modules..."
+
+convert_file() {
+  local file="$1"
+
+  if [ ! -f "$file" ]; then
+    echo "Skipping $file (not found)"
+    return
+  fi
+
+  echo "Converting: $file"
+
+  # Backup original
+  cp "$file" "${file}.bak"
+
+  # Convert require to import
+  sed -i '' \
+    -e "s/const \(.*\) = require('\(.*\)');/import \1 from '\2';/g" \
+    -e "s/const { \([^}]*\) } = require('\(.*\)');/import { \1 } from '\2';/g" \
+    -e "s/require('dotenv').config();/import dotenv from 'dotenv';\ndotenv.config();/g" \
+    "$file"
+
+  # Convert module.exports
+  sed -i '' \
+    -e 's/module\.exports = {/export {/g' \
+    -e 's/module\.exports =/export default/g' \
+    "$file"
+
+  # Add export before function declarations that were in module.exports
+  # This is a simple heuristic - may need manual adjustment
+}
+
+# Convert store files
+for file in store/agentStore.js store/registryStore.js store/agentSessionStore.js; do
+  convert_file "$file"
+done
+
+# Convert docker-actions files
+for file in docker-actions/*.js; do
+  convert_file "$file"
+done
+
+# Convert root files
+for file in websocket-server.js auth.js containerManager.js cli-commands.js helper-functions.js; do
+  convert_file "$file"
+done
+
+echo ""
+echo "Conversion complete!"
+echo "Backup files created with .bak extension"
+echo ""
+echo "NOTE: Some manual fixes may be needed:"
+echo "  - Circular dependencies"
+echo "  - Complex module.exports patterns"
+echo "  - Dynamic requires"
+echo ""
+echo "Test with: npm run agent"