@oussema_mili/test-pkg-123 1.1.32

package/docker-actions/containers.js

@@ -0,0 +1,355 @@
+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)
+      : "-";
+
+    // Extract app-related labels
+    const labels = containerInfo.Config.Labels || {};
+    const appName = labels["app.name"] || null;
+    const fwId = labels["app.fwId"] || labels["app.backstageId"] || null;
+
+    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(),
+      appName,
+      fwId,
+    };
+  } 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",
+      appName: null,
+      fwId: null,
+    };
+  }
+};
+
+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 };

package/docker-actions/general.js

@@ -0,0 +1,171 @@
+import os from 'os';
+import { formatUptime } from '../helper-functions.js';
+import { docker } from './containers.js';
+import agentStore from '../store/agentStore.js';
+import { loadSession } from '../auth.js';
+import agentSessionStore from '../store/agentSessionStore.js';
+
+// Version from package.json
+import packageJson from '../package.json' with { type: 'json' };
+const { version } = packageJson;
+
+// Agent informations - startTime will be loaded from store or set when server starts
+let agentStartTime = new Date();
+const agentInfo = {
+  version,
+  hostname: os.hostname(),
+  startTime: agentStartTime,
+  cpus: os.cpus().length,
+  memory: {
+    total: Math.round(os.totalmem() / (1024 * 1024)), // MB
+    free: Math.round(os.freemem() / (1024 * 1024)), // MB
+  },
+};
+
+/**
+ * Initialize agent start time - called when server actually starts
+ * Always creates a fresh start time when the server starts
+ */
+async function initializeAgentStartTime() {
+  try {
+    // Always create a fresh start time when the server starts
+    agentStartTime = new Date();
+    agentInfo.startTime = agentStartTime;
+    await agentStore.saveAgentStartTime(agentStartTime);
+  } catch (err) {
+    console.error('Failed to initialize agent start time:', err);
+  }
+}
+
+async function handleGeneralAction(ws, clientId, action, payload) {
+  switch (action) {
+    case 'getAgentInfo':
+      return await handleGetAgentInfo(ws, payload);
+    case 'getDockerInfo':
+      return await handleGetDockerInfo(ws, payload);
+    case 'execInContainer':
+      return await handleExecInContainer(ws, clientId, payload);
+    default:
+      throw new Error(`Unknown general action: ${action}`);
+  }
+}
+
+async function handleGetAgentInfo(ws, payload = {}) {
+  try {
+    const currentTime = Date.now();
+    const uptimeMs = currentTime - new Date(agentInfo.startTime).getTime();
+    const formattedUptime = formatUptime(uptimeMs);
+
+    // Get session info
+    const sessionInfo = agentSessionStore.getAgentSessionInfo();
+    const session = loadSession();
+
+    const info = {
+      ...agentInfo,
+      timestamp: Date.now(),
+      uptime: formattedUptime,
+      agentId: sessionInfo.agentId,
+      userEntityRef:
+        sessionInfo.userEntityRef || (session && session.userEntityRef),
+      sessionExpiresAt:
+        sessionInfo.sessionExpiresAt || (session && session.expiresAt),
+      status: 'connected', // Agent is connected if responding
+    };
+
+    ws.send(
+      JSON.stringify({
+        type: 'agentInfo',
+        info,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error getting agent info:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to get agent info: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleExecInContainer(ws, clientId, payload) {
+  try {
+    const { containerId, command, requestId } = payload;
+
+    const container = docker.getContainer(containerId);
+    const exec = await container.exec({
+      AttachStdin: false,
+      AttachStdout: true,
+      AttachStderr: true,
+      Tty: false,
+      Cmd: ['/bin/sh', '-c', command],
+    });
+
+    const stream = await exec.start({ hijack: true, stdin: false });
+    let output = '';
+
+    stream.on('data', (chunk) => {
+      output += chunk.toString();
+    });
+
+    stream.on('end', () => {
+      ws.send(
+        JSON.stringify({
+          type: 'execResult',
+          containerId,
+          output,
+          requestId,
+        })
+      );
+    });
+
+    stream.on('error', (err) => {
+      ws.send(
+        JSON.stringify({
+          type: 'error',
+          error: `Error executing command: ${err.message}`,
+          requestId,
+        })
+      );
+    });
+  } catch (error) {
+    console.error('Error executing command in container:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to execute command in container: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleGetDockerInfo(ws, payload = {}) {
+  try {
+    const info = await docker.info();
+
+    ws.send(
+      JSON.stringify({
+        type: 'dockerInfo',
+        info,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error getting Docker info:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to get Docker info: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+export default { handleGeneralAction, agentInfo, initializeAgentStartTime };
+
+export { handleGeneralAction, agentInfo, initializeAgentStartTime };