@fenwave/agent 1.1.0

package/docker-actions/config-transformer.js

@@ -0,0 +1,380 @@
+/**
+ * Configuration Transformer
+ *
+ * Transforms platform-agnostic deployment configuration into platform-specific formats.
+ * Supports Docker Compose and Helm transformations.
+ */
+
+/**
+ * Transforms deployment config to Docker Compose format
+ * Splits environment variables by scope (container, host, secret)
+ *
+ * @param {Object} deploymentConfig - Universal deployment configuration
+ * @param {Array} deploymentConfig.environment - Environment variables with scopes
+ * @param {Object} deploymentConfig.resources - Resource limits (memory, cpu)
+ * @param {Object} deploymentConfig.scaling - Scaling config (replicas)
+ * @param {Object} deploymentConfig.volumes - Volume configurations
+ * @returns {Object} Docker Compose configuration with separated env vars
+ */
+export function toDockerComposeConfig(deploymentConfig) {
+  if (!deploymentConfig) {
+    return {
+      containerEnv: {},
+      hostEnv: {},
+      secretRefs: {},
+      resources: null,
+      replicas: 1,
+      volumes: null,
+    };
+  }
+
+  const result = {
+    containerEnv: {},
+    hostEnv: {},
+    secretRefs: {},
+    resources: null,
+    replicas: 1,
+    volumes: null,
+  };
+
+  // Process environment variables by scope
+  if (
+    deploymentConfig.environment &&
+    Array.isArray(deploymentConfig.environment)
+  ) {
+    for (const envVar of deploymentConfig.environment) {
+      const { name, value, scope } = envVar;
+
+      // Skip invalid entries
+      if (!name || !value) continue;
+
+      switch (scope) {
+        case "container":
+          result.containerEnv[name] = value;
+          break;
+
+        case "host":
+          result.hostEnv[name] = value;
+          break;
+
+        case "secret":
+          // Store secret references (e.g., "${SECRET_NAME}")
+          // These will be resolved from host environment at runtime
+          result.secretRefs[name] = value;
+          // Also add to container env so docker-compose can interpolate
+          result.containerEnv[name] = value;
+          break;
+
+        default:
+          // Default to container scope
+          result.containerEnv[name] = value;
+      }
+    }
+  }
+
+  // Process resource limits
+  if (deploymentConfig.resources) {
+    result.resources = {
+      memory: deploymentConfig.resources.memory || null,
+      cpu: deploymentConfig.resources.cpu || null,
+    };
+  }
+
+  // Process scaling
+  if (deploymentConfig.scaling && deploymentConfig.scaling.replicas) {
+    result.replicas = deploymentConfig.scaling.replicas;
+  }
+
+  // Process volumes
+  if (deploymentConfig.volumes) {
+    result.volumes = deploymentConfig.volumes;
+  }
+
+  return result;
+}
+
+/**
+ * Generates a bash script to export host environment variables
+ *
+ * @param {Object} hostEnv - Key-value pairs of host environment variables
+ * @returns {string} Bash script content
+ */
+export function generateHostEnvScript(hostEnv) {
+  if (!hostEnv || Object.keys(hostEnv).length === 0) {
+    return "#!/bin/bash\n# No host environment variables configured\n";
+  }
+
+  const lines = ["#!/bin/bash", "# Host environment variables", ""];
+
+  for (const [name, value] of Object.entries(hostEnv)) {
+    // Escape special characters in values
+    const escapedValue = value.replace(/"/g, '\\"').replace(/\$/g, "\\$");
+    lines.push(`export ${name}="${escapedValue}"`);
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+/**
+ * Generates Docker Compose deploy section for resources and replicas
+ *
+ * @param {Object} resources - Resource limits {memory, cpu}
+ * @param {number} replicas - Number of replicas
+ * @returns {Object|null} Docker Compose deploy configuration
+ */
+export function generateComposeDeploy(resources, replicas) {
+  const deploy = {};
+
+  // Add replicas
+  if (replicas && replicas > 1) {
+    deploy.replicas = replicas;
+  }
+
+  // Add resource limits
+  if (resources && (resources.memory || resources.cpu)) {
+    deploy.resources = {
+      limits: {},
+      reservations: {},
+    };
+
+    if (resources.memory) {
+      deploy.resources.limits.memory = resources.memory;
+      // Set reservations to 50% of limits
+      deploy.resources.reservations.memory = resources.memory;
+    }
+
+    if (resources.cpu) {
+      deploy.resources.limits.cpus = resources.cpu;
+      // Set reservations to 50% of limits
+      const cpuValue = parseFloat(resources.cpu);
+      if (!isNaN(cpuValue)) {
+        deploy.resources.reservations.cpus = (cpuValue * 0.5).toString();
+      }
+    }
+  }
+
+  return Object.keys(deploy).length > 0 ? deploy : null;
+}
+
+/**
+ * Generates .env file content for Docker Compose
+ * Includes both container and secret reference variables
+ *
+ * @param {Object} containerEnv - Container environment variables
+ * @param {Object} secretRefs - Secret reference variables
+ * @returns {string} .env file content
+ */
+export function generateEnvFile(containerEnv, secretRefs) {
+  const lines = ["# Environment variables for Docker Compose", ""];
+
+  // Add container environment variables
+  if (containerEnv && Object.keys(containerEnv).length > 0) {
+    lines.push("# Container environment variables");
+    for (const [name, value] of Object.entries(containerEnv)) {
+      // Skip secret refs (they're added separately)
+      if (secretRefs && secretRefs[name]) continue;
+      lines.push(`${name}=${value}`);
+    }
+    lines.push("");
+  }
+
+  // Add secret references with comments
+  if (secretRefs && Object.keys(secretRefs).length > 0) {
+    lines.push("# Secret references (resolved from host environment)");
+    for (const [name, value] of Object.entries(secretRefs)) {
+      lines.push(`${name}=${value}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Validates deployment configuration
+ *
+ * @param {Object} deploymentConfig - Universal deployment configuration
+ * @returns {Object} Validation result {valid: boolean, errors: string[]}
+ */
+export function validateDeploymentConfig(deploymentConfig) {
+  const errors = [];
+
+  if (!deploymentConfig) {
+    return { valid: true, errors: [] }; // Config is optional
+  }
+
+  // Validate environment variables
+  if (deploymentConfig.environment) {
+    if (!Array.isArray(deploymentConfig.environment)) {
+      errors.push("environment must be an array");
+    } else {
+      deploymentConfig.environment.forEach((envVar, index) => {
+        if (!envVar.name) {
+          errors.push(`environment[${index}]: name is required`);
+        }
+        if (!envVar.value) {
+          errors.push(`environment[${index}]: value is required`);
+        }
+        if (
+          !envVar.scope ||
+          !["container", "host", "secret"].includes(envVar.scope)
+        ) {
+          errors.push(
+            `environment[${index}]: scope must be 'container', 'host', or 'secret'`
+          );
+        }
+      });
+    }
+  }
+
+  // Validate resources
+  if (deploymentConfig.resources) {
+    const { memory, cpu } = deploymentConfig.resources;
+
+    if (memory && typeof memory !== "string") {
+      errors.push('resources.memory must be a string (e.g., "512Mi", "1Gi")');
+    }
+
+    if (cpu && typeof cpu !== "string") {
+      errors.push('resources.cpu must be a string (e.g., "500m", "1")');
+    }
+  }
+
+  // Validate scaling
+  if (deploymentConfig.scaling) {
+    const { replicas } = deploymentConfig.scaling;
+
+    if (replicas !== undefined) {
+      if (typeof replicas !== "number" || replicas < 1) {
+        errors.push("scaling.replicas must be a number >= 1");
+      }
+    }
+  }
+
+  // Validate volumes
+  if (deploymentConfig.volumes) {
+    if (typeof deploymentConfig.volumes !== "object") {
+      errors.push("volumes must be an object");
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Transforms deployment config to Helm values format
+ * (For future Kubernetes deployments)
+ *
+ * @param {Object} deploymentConfig - Universal deployment configuration
+ * @returns {Object} Helm values object
+ */
+export function toHelmValues(deploymentConfig) {
+  if (!deploymentConfig) {
+    return {};
+  }
+
+  const helmValues = {};
+
+  // Process environment variables
+  if (
+    deploymentConfig.environment &&
+    Array.isArray(deploymentConfig.environment)
+  ) {
+    helmValues.env = [];
+
+    for (const envVar of deploymentConfig.environment) {
+      const { name, value, scope } = envVar;
+
+      if (!name || !value) continue;
+
+      switch (scope) {
+        case "container":
+          // Direct environment variable
+          helmValues.env.push({
+            name,
+            value,
+          });
+          break;
+
+        case "secret":
+          // Secret reference - extract secret name and key
+          // Expected format: ${SECRET_NAME} or ${SECRET_NAME:KEY}
+          const secretMatch = value.match(/\$\{([^:}]+)(?::([^}]+))?\}/);
+          if (secretMatch) {
+            const secretName = secretMatch[1];
+            const secretKey = secretMatch[2] || name.toLowerCase();
+
+            helmValues.env.push({
+              name,
+              valueFrom: {
+                secretKeyRef: {
+                  name: secretName,
+                  key: secretKey,
+                },
+              },
+            });
+          } else {
+            // Invalid secret reference, treat as regular value
+            helmValues.env.push({ name, value });
+          }
+          break;
+
+        case "host":
+          // Host env vars don't apply to Kubernetes - skip or warn
+          console.warn(
+            `Host environment variable ${name} will not be included in Helm values`
+          );
+          break;
+
+        default:
+          helmValues.env.push({ name, value });
+      }
+    }
+  }
+
+  // Process resource limits
+  if (deploymentConfig.resources) {
+    helmValues.resources = {
+      limits: {},
+      requests: {},
+    };
+
+    if (deploymentConfig.resources.memory) {
+      helmValues.resources.limits.memory = deploymentConfig.resources.memory;
+      helmValues.resources.requests.memory = deploymentConfig.resources.memory;
+    }
+
+    if (deploymentConfig.resources.cpu) {
+      helmValues.resources.limits.cpu = deploymentConfig.resources.cpu;
+      // Request 50% of CPU limit
+      const cpuValue = parseFloat(deploymentConfig.resources.cpu);
+      if (!isNaN(cpuValue)) {
+        helmValues.resources.requests.cpu = (cpuValue * 0.5).toString();
+      }
+    }
+  }
+
+  // Process scaling
+  if (deploymentConfig.scaling && deploymentConfig.scaling.replicas) {
+    helmValues.replicaCount = deploymentConfig.scaling.replicas;
+  }
+
+  // Process volumes
+  if (deploymentConfig.volumes) {
+    helmValues.persistence = {};
+
+    for (const [name, size] of Object.entries(deploymentConfig.volumes)) {
+      helmValues.persistence[name] = {
+        enabled: true,
+        size,
+        accessMode: "ReadWriteOnce",
+      };
+    }
+  }
+
+  return helmValues;
+}

package/docker-actions/containers.js

@@ -0,0 +1,346 @@
+import Docker from "dockerode";
+import { formatUptime } from "../helper-functions.js";
+import os from "os";
+
+// Create Docker client
+let docker;
+try {
+  docker = new Docker();
+} catch (error) {
+  console.error(`Failed to connect to Docker daemon: ${error.message}`);
+  process.exit(1);
+}
+
+// Format container for response
+const formatContainer = async (container) => {
+  try {
+    const containerInfo = await container.inspect();
+    const stats = await container.stats({ stream: false });
+
+    // Calculate CPU usage percentage using a simpler approach
+    let cpuPercent = 0;
+    try {
+      const cpuDelta =
+        stats.cpu_stats.cpu_usage.total_usage -
+        stats.precpu_stats.cpu_usage.total_usage;
+      const systemCpuDelta =
+        stats.cpu_stats.system_cpu_usage - stats.precpu_stats.system_cpu_usage;
+      const cpuCores = stats.cpu_stats.online_cpus || os.cpus().length;
+
+      if (systemCpuDelta > 0 && cpuDelta > 0) {
+        cpuPercent = (cpuDelta / systemCpuDelta) * cpuCores * 100;
+      }
+    } catch (err) {
+      console.error("Error calculating CPU percentage:", err.message);
+    }
+
+    // Calculate memory usage percentage
+    let memoryPercent = 0;
+    try {
+      const memoryUsage = stats.memory_stats.usage || 0;
+      const memoryLimit = stats.memory_stats.limit || 1;
+      memoryPercent = (memoryUsage / memoryLimit) * 100;
+    } catch (err) {
+      console.error("Error calculating memory percentage:", err.message);
+    }
+
+    // Format ports
+    const ports = [];
+    if (containerInfo.NetworkSettings && containerInfo.NetworkSettings.Ports) {
+      Object.entries(containerInfo.NetworkSettings.Ports).forEach(
+        ([containerPort, hostBindings]) => {
+          if (hostBindings) {
+            hostBindings.forEach((binding) => {
+              ports.push(`${binding.HostPort}:${containerPort}`);
+            });
+          } else {
+            ports.push(containerPort);
+          }
+        }
+      );
+    }
+
+    // Calculate uptime
+    const startTime = new Date(containerInfo.State.StartedAt).getTime();
+    const uptime = containerInfo.State.Running
+      ? formatUptime(Date.now() - startTime)
+      : "-";
+
+    return {
+      id: container.id,
+      name: containerInfo.Name.replace(/^\//, ""), // Remove leading slash
+      image: containerInfo.Config.Image,
+      status: containerInfo.State.Running ? "running" : "stopped",
+      uptime,
+      ports,
+      cpu: isNaN(cpuPercent) ? 0 : Math.round(cpuPercent * 100) / 100,
+      memory: isNaN(memoryPercent) ? 0 : Math.round(memoryPercent * 100) / 100,
+      created: new Date(containerInfo.Created).toLocaleDateString(),
+    };
+  } catch (error) {
+    console.error("Error formatting container:", error.message);
+    return {
+      id: container.id,
+      name: "Unknown",
+      image: "Unknown",
+      status: "error",
+      uptime: "-",
+      ports: [],
+      cpu: 0,
+      memory: 0,
+      created: "Unknown",
+    };
+  }
+};
+
+async function handleContainerAction(ws, action, payload) {
+  switch (action) {
+    case "fetchContainers":
+      return await handleFetchContainers(ws, payload);
+    case "startContainer":
+      return await handleStartContainer(ws, payload);
+    case "stopContainer":
+      return await handleStopContainer(ws, payload);
+    case "restartContainer":
+      return await handleRestartContainer(ws, payload);
+    case "deleteContainer":
+      return await handleDeleteContainer(ws, payload);
+    case "createContainer":
+      return await handleCreateContainer(ws, payload);
+    case "inspectContainer":
+      return await handleInspectContainer(ws, payload);
+    default:
+      throw new Error(`Unknown container action: ${action}`);
+  }
+}
+
+async function handleFetchContainers(ws, payload = {}) {
+  try {
+    const containers = await docker.listContainers({ all: true });
+    const containerPromises = containers.map((container) =>
+      formatContainer(docker.getContainer(container.Id))
+    );
+    const formattedContainers = await Promise.all(containerPromises);
+
+    ws.send(
+      JSON.stringify({
+        type: "containers",
+        containers: formattedContainers,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error("Error fetching containers:", error);
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: "Failed to fetch containers: " + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleStartContainer(ws, payload) {
+  try {
+    const container = docker.getContainer(payload.id);
+    await container.start();
+    const formattedContainer = await formatContainer(container);
+
+    ws.send(
+      JSON.stringify({
+        type: "containerStarted",
+        container: formattedContainer,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error("Error starting container:", error);
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: "Failed to start container: " + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleStopContainer(ws, payload) {
+  try {
+    const container = docker.getContainer(payload.id);
+    await container.stop();
+    const formattedContainer = await formatContainer(container);
+
+    ws.send(
+      JSON.stringify({
+        type: "containerStopped",
+        container: formattedContainer,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error("Error stopping container:", error);
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: "Failed to stop container: " + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleRestartContainer(ws, payload) {
+  try {
+    const container = docker.getContainer(payload.id);
+    await container.restart();
+    const formattedContainer = await formatContainer(container);
+
+    ws.send(
+      JSON.stringify({
+        type: "containerRestarted",
+        container: formattedContainer,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error("Error restarting container:", error);
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: "Failed to restart container: " + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleDeleteContainer(ws, payload) {
+  try {
+    const container = docker.getContainer(payload.id);
+    await container.remove({ force: true });
+
+    ws.send(
+      JSON.stringify({
+        type: "containerDeleted",
+        id: payload.id,
+        success: true,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error("Error deleting container:", error);
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: "Failed to delete container: " + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleCreateContainer(ws, payload) {
+  try {
+    const options = payload.options;
+
+    // Format port bindings
+    const portBindings = {};
+    if (options.ports) {
+      const portMappings = options.ports.split(",").map((p) => p.trim());
+      portMappings.forEach((mapping) => {
+        const [hostPort, containerPort] = mapping.split(":");
+        portBindings[`${containerPort}/tcp`] = [{ HostPort: hostPort }];
+      });
+    }
+
+    // Format volumes
+    const volumes = {};
+    const binds = [];
+    if (options.volumes) {
+      const volumeMappings = options.volumes.split(",").map((v) => v.trim());
+      volumeMappings.forEach((mapping) => {
+        const [hostPath, containerPath] = mapping.split(":");
+        volumes[containerPath] = {};
+        binds.push(`${hostPath}:${containerPath}`);
+      });
+    }
+
+    // Format environment variables
+    const env = [];
+    if (options.environment) {
+      const envMappings = options.environment.split(",").map((e) => e.trim());
+      envMappings.forEach((mapping) => {
+        env.push(mapping);
+      });
+    }
+
+    // Create container
+    const container = await docker.createContainer({
+      name: options.name,
+      Image: options.image,
+      ExposedPorts: Object.keys(portBindings).reduce((acc, port) => {
+        acc[port] = {};
+        return acc;
+      }, {}),
+      HostConfig: {
+        PortBindings: portBindings,
+        Binds: binds,
+        RestartPolicy: {
+          Name: options.restart || "no",
+        },
+      },
+      Env: env,
+      Volumes: volumes,
+    });
+
+    const formattedContainer = await formatContainer(container);
+
+    ws.send(
+      JSON.stringify({
+        type: "containerCreated",
+        container: formattedContainer,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error("Error creating container:", error);
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: "Failed to create container: " + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleInspectContainer(ws, payload) {
+  try {
+    const { id, requestId } = payload;
+    const container = docker.getContainer(id);
+    const inspectionData = await container.inspect();
+
+    ws.send(
+      JSON.stringify({
+        type: "containerInspected",
+        data: inspectionData,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error("Error inspecting container:", error);
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: "Failed to inspect container: " + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+export default { handleContainerAction, formatContainer, docker };
+
+export { handleContainerAction, formatContainer, docker };