@fenwave/agent 1.1.0

package/utils/prompts.js

@@ -0,0 +1,318 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+
+/**
+ * Prompt for registration token
+ *
+ * @param {string} backstageUrl - Backstage URL to display
+ * @returns {Promise<string>} Registration token
+ */
+export async function promptRegistrationToken(backstageUrl) {
+  console.log(chalk.blue('\n📝 Registration Token Required\n'));
+  console.log(chalk.gray(`Get your token from: ${backstageUrl}/agent-installer\n`));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'token',
+      message: 'Enter your registration token:',
+      mask: '*',
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'Registration token is required';
+        }
+        if (input.length < 32) {
+          return 'Invalid token format';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  return answers.token.trim();
+}
+
+/**
+ * Prompt for confirmation
+ *
+ * @param {string} message - Confirmation message
+ * @param {boolean} defaultValue - Default value (true/false)
+ * @returns {Promise<boolean>} User's answer
+ */
+export async function promptConfirmation(message, defaultValue = true) {
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: defaultValue,
+    },
+  ]);
+
+  return answers.confirmed;
+}
+
+/**
+ * Prompt for Docker registry configuration
+ *
+ * @returns {Promise<Object>} Registry configuration
+ */
+export async function promptDockerRegistries() {
+  console.log(chalk.blue('\n🐳 Docker Registry Configuration\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'configureEcr',
+      message: 'Configure AWS ECR for Fenwave images?',
+      default: true,
+    },
+    {
+      type: 'input',
+      name: 'awsRegion',
+      message: 'AWS Region:',
+      default: 'eu-west-1',
+      when: (answers) => answers.configureEcr,
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'AWS Region is required';
+        }
+        return true;
+      },
+    },
+    {
+      type: 'confirm',
+      name: 'addCustomRegistry',
+      message: 'Add custom Docker registry?',
+      default: false,
+    },
+  ]);
+
+  const registries = [];
+
+  if (answers.configureEcr) {
+    registries.push({
+      type: 'ecr',
+      region: answers.awsRegion,
+    });
+  }
+
+  if (answers.addCustomRegistry) {
+    const customRegistry = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'url',
+        message: 'Registry URL:',
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Registry URL is required';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'input',
+        name: 'username',
+        message: 'Username:',
+      },
+      {
+        type: 'password',
+        name: 'password',
+        message: 'Password:',
+        mask: '*',
+      },
+    ]);
+
+    registries.push({
+      type: 'custom',
+      ...customRegistry,
+    });
+  }
+
+  return registries;
+}
+
+/**
+ * Prompt for choice from a list
+ *
+ * @param {string} message - Prompt message
+ * @param {Array} choices - Array of choices
+ * @param {string} defaultChoice - Default choice
+ * @returns {Promise<string>} Selected choice
+ */
+export async function promptChoice(message, choices, defaultChoice) {
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'choice',
+      message,
+      choices,
+      default: defaultChoice,
+    },
+  ]);
+
+  return answers.choice;
+}
+
+/**
+ * Prompt for text input
+ *
+ * @param {string} message - Prompt message
+ * @param {string} defaultValue - Default value
+ * @param {Function} validate - Validation function
+ * @returns {Promise<string>} User input
+ */
+export async function promptInput(message, defaultValue, validate) {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'input',
+      message,
+      default: defaultValue,
+      validate,
+    },
+  ]);
+
+  return answers.input;
+}
+
+/**
+ * Display progress with spinner
+ *
+ * @param {string} message - Progress message
+ * @param {Promise} promise - Promise to await
+ * @returns {Promise} Result of the promise
+ */
+export async function displayProgress(message, promise) {
+  const spinner = ora(message).start();
+
+  try {
+    const result = await promise;
+    spinner.succeed(chalk.green(message));
+    return result;
+  } catch (error) {
+    spinner.fail(chalk.red(`${message} - ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Display success message
+ *
+ * @param {string} message - Success message
+ */
+export function displaySuccess(message) {
+  console.log(chalk.green('✅ ' + message));
+}
+
+/**
+ * Display error message
+ *
+ * @param {string} message - Error message
+ */
+export function displayError(message) {
+  console.log(chalk.red('❌ ' + message));
+}
+
+/**
+ * Display warning message
+ *
+ * @param {string} message - Warning message
+ */
+export function displayWarning(message) {
+  console.log(chalk.yellow('⚠️  ' + message));
+}
+
+/**
+ * Display info message
+ *
+ * @param {string} message - Info message
+ */
+export function displayInfo(message) {
+  console.log(chalk.blue('ℹ️  ' + message));
+}
+
+/**
+ * Display header with decorative border
+ *
+ * @param {string} title - Header title
+ */
+export function displayHeader(title) {
+  const border = '━'.repeat(70);
+  console.log('\n' + chalk.cyan(border));
+  console.log(chalk.cyan.bold(`  ${title}`));
+  console.log(chalk.cyan(border) + '\n');
+}
+
+/**
+ * Display step indicator
+ *
+ * @param {number} current - Current step
+ * @param {number} total - Total steps
+ * @param {string} description - Step description
+ */
+export function displayStep(current, total, description) {
+  console.log(chalk.bold(`\nStep ${current}/${total}: ${description}`));
+}
+
+/**
+ * Display a list of items
+ *
+ * @param {Array} items - Items to display
+ * @param {string} prefix - Prefix for each item (default: '  • ')
+ */
+export function displayList(items, prefix = '  • ') {
+  items.forEach((item) => {
+    console.log(chalk.gray(prefix + item));
+  });
+}
+
+/**
+ * Display key-value pairs
+ *
+ * @param {Object} data - Data to display
+ * @param {string} indent - Indentation (default: '   ')
+ */
+export function displayKeyValue(data, indent = '   ') {
+  Object.entries(data).forEach(([key, value]) => {
+    console.log(chalk.gray(`${indent}${key}: `) + chalk.white(value));
+  });
+}
+
+/**
+ * Clear console
+ */
+export function clearConsole() {
+  console.clear();
+}
+
+/**
+ * Prompt for backend URL
+ *
+ * @param {string} defaultUrl - Default backend URL
+ * @returns {Promise<string>} Backend URL
+ */
+export async function promptBackendUrl(defaultUrl = 'http://localhost:7007') {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'url',
+      message: 'Backstage Backend URL:',
+      default: defaultUrl,
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'Backend URL is required';
+        }
+        try {
+          new URL(input);
+          return true;
+        } catch (error) {
+          return 'Invalid URL format';
+        }
+      },
+    },
+  ]);
+
+  return answers.url.trim();
+}

package/websocket-server.js

@@ -0,0 +1,364 @@
+import { WebSocketServer } from "ws";
+import { v4 as uuidv4 } from "uuid";
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import os from "os";
+import { loadConfig } from "./store/configStore.js";
+
+// Import handlers
+import containerHandlers from "./docker-actions/containers.js";
+import imageHandlers from "./docker-actions/images.js";
+import volumeHandlers from "./docker-actions/volumes.js";
+import appHandlers from "./docker-actions/apps.js";
+import registryHandlers from "./docker-actions/registry.js";
+import logHandlers from "./docker-actions/logs.js";
+import metricsHandlers from "./docker-actions/metrics.js";
+import terminalHandlers from "./docker-actions/terminal.js";
+import generalHandlers from "./docker-actions/general.js";
+import agentSessionStore from "./store/agentSessionStore.js";
+
+// Store active streams and sessions
+const activeStreams = new Map();
+const terminalSessions = new Map();
+
+// Load configuration
+const config = loadConfig();
+const AGENT_ROOT_DIR = path.join(os.homedir(), config.agentRootDir);
+const WS_TOKEN_FILE = path.join(AGENT_ROOT_DIR, "ws-token");
+const AUTH_TIMEOUT_MS = 30000; // 30 seconds to authenticate
+
+/**
+ * Generate a secure random WebSocket authentication token
+ * @returns {string} 64-character hex token
+ */
+function generateWsToken() {
+  return crypto.randomBytes(32).toString("hex");
+}
+
+/**
+ * Save WebSocket token to file for local-env app to read
+ * @param {string} token - The WebSocket authentication token
+ */
+function saveWsToken(token) {
+  // Ensure directory exists
+  if (!fs.existsSync(AGENT_ROOT_DIR)) {
+    fs.mkdirSync(AGENT_ROOT_DIR, { recursive: true, mode: 0o700 });
+  }
+
+  // Write token to file with restricted permissions (owner only)
+  fs.writeFileSync(WS_TOKEN_FILE, token, { mode: 0o600 });
+}
+
+/**
+ * Read WebSocket token from file
+ * @returns {string|null} The WebSocket token or null if not found
+ */
+function readWsToken() {
+  try {
+    if (fs.existsSync(WS_TOKEN_FILE)) {
+      return fs.readFileSync(WS_TOKEN_FILE, "utf-8").trim();
+    }
+  } catch (error) {
+    console.error("Error reading WS token:", error.message);
+  }
+  return null;
+}
+
+function setupWebSocketServer(
+  server,
+  clients,
+  agentId,
+  sessionInfo = {},
+  existingToken = null
+) {
+  // Store agent session info for use in handlers
+  agentSessionStore.setAgentSessionInfo({
+    agentId: agentId,
+    userEntityRef: sessionInfo.userEntityRef || null,
+    sessionExpiresAt: sessionInfo.expiresAt || null,
+  });
+
+  // Use existing token or generate a new one
+  const wsToken = existingToken || generateWsToken();
+  if (!existingToken) {
+    // Only save if we generated a new token
+    saveWsToken(wsToken);
+  }
+
+  const wss = new WebSocketServer({ server });
+
+  // Set up cleanup timer for inactive terminal sessions
+  setInterval(() => {
+    terminalHandlers.cleanupInactiveTerminalSessions(terminalSessions);
+  }, 15 * 60 * 1000); // Run every 15 minutes
+
+  wss.on("connection", (ws) => {
+    // Generate a unique client ID for each WebSocket connection
+    const clientId = uuidv4();
+    const connectionTime = Date.now();
+    let authenticated = false;
+
+    // Set authentication timeout
+    const authTimeout = setTimeout(() => {
+      if (!authenticated) {
+        ws.send(
+          JSON.stringify({
+            type: "auth_error",
+            error: "Authentication timeout. Connection closed.",
+          })
+        );
+        ws.close(4001, "Authentication timeout");
+      }
+    }, AUTH_TIMEOUT_MS);
+
+    // Send authentication challenge
+    ws.send(
+      JSON.stringify({
+        type: "auth_required",
+        message:
+          "Authentication required. Please send auth message with token.",
+        clientId,
+      })
+    );
+
+    // Handle messages from client
+    ws.on("message", async (message) => {
+      let data;
+      try {
+        data = JSON.parse(message);
+      } catch (parseError) {
+        console.error("Error parsing message: ", parseError);
+        ws.send(
+          JSON.stringify({
+            type: "error",
+            error: "Failed to parse message: " + parseError.message,
+          })
+        );
+        return;
+      }
+
+      // Handle authentication
+      if (!authenticated) {
+        if (data.type === "auth" && data.token) {
+          if (data.token === wsToken) {
+            // Authentication successful
+            authenticated = true;
+            clearTimeout(authTimeout);
+
+            // Store client info
+            clients.set(clientId, {
+              ws,
+              connectionTime,
+              lastActivity: Date.now(),
+              isActive: true,
+              authenticated: true,
+            });
+
+            console.log(`✅ Client authenticated: ${clientId}`);
+
+            // Send success response
+            ws.send(
+              JSON.stringify({
+                type: "auth_success",
+                clientId,
+                agentId: agentId,
+                message: "Successfully authenticated with Fenwave Agent",
+              })
+            );
+          } else {
+            // Invalid token
+            console.log(
+              chalk.red(
+                `❌ Invalid authentication token from client: ${clientId}`
+              )
+            );
+            ws.send(
+              JSON.stringify({
+                type: "auth_error",
+                error: "Invalid authentication token",
+              })
+            );
+            ws.close(4003, "Invalid authentication token");
+          }
+        } else {
+          // Not an auth message
+          ws.send(
+            JSON.stringify({
+              type: "auth_error",
+              error: "Authentication required before sending messages",
+            })
+          );
+        }
+        return;
+      }
+
+      // Update last activity time for authenticated clients
+      const client = clients.get(clientId);
+      if (client) {
+        client.lastActivity = Date.now();
+      }
+
+      console.log(`📨 Received message from client ${clientId}:`, data.action);
+
+      // Route messages to appropriate handlers
+      await routeMessage(ws, clientId, data);
+    });
+
+    // Handle client disconnect
+    ws.on("close", () => {
+      console.log(`🔴 Client disconnected: ${clientId}`);
+      clients.delete(clientId);
+
+      // Clean up any active streams for this client
+      for (const [streamId, stream] of activeStreams.entries()) {
+        if (streamId.startsWith(clientId)) {
+          if (stream.destroy) stream.destroy();
+          activeStreams.delete(streamId);
+        }
+      }
+    });
+  });
+
+  return wss;
+}
+
+async function routeMessage(ws, clientId, data) {
+  const { action, payload = {} } = data;
+
+  // Container actions
+  if (
+    action === "fetchContainers" ||
+    action === "startContainer" ||
+    action === "stopContainer" ||
+    action === "restartContainer" ||
+    action === "deleteContainer" ||
+    action === "createContainer" ||
+    action === "inspectContainer"
+  ) {
+    return await containerHandlers.handleContainerAction(ws, action, payload);
+  }
+
+  // Image actions
+  if (
+    action === "fetchImages" ||
+    action === "pullImage" ||
+    action === "pushImage" ||
+    action === "deleteImage" ||
+    action === "tagImage" ||
+    action === "inspectImage"
+  ) {
+    return await imageHandlers.handleImageAction(ws, action, payload);
+  }
+
+  // Volume actions
+  if (
+    action === "fetchVolumes" ||
+    action === "createVolume" ||
+    action === "deleteVolume" ||
+    action === "inspectVolume" ||
+    action === "getContainersUsingVolume" ||
+    action === "fetchImages" ||
+    action === "pullImage" ||
+    action === "backupVolume" ||
+    action === "listVolumeBackups" ||
+    action === "fetchImages" ||
+    action === "pullImage" ||
+    action === "restoreVolumeFromBackup" ||
+    action === "deleteVolumeBackup" ||
+    action === "getBackupDownloadUrl"
+  ) {
+    return await volumeHandlers.handleVolumeAction(ws, action, payload);
+  }
+
+  // App actions
+  if (
+    action === "fetchApps" ||
+    action === "fetchAppVersions" ||
+    action === "startApp" ||
+    action === "stopApp" ||
+    action === "restartApp" ||
+    action === "deleteApp" ||
+    action === "deleteAppVersions" ||
+    action === "createApp" ||
+    action === "validateCompose" ||
+    action === "syncApp" ||
+    action === "changeVersion"
+  ) {
+    return await appHandlers.handleAppAction(ws, action, payload);
+  }
+
+  // Registry actions
+  if (
+    action === "fetchRegistries" ||
+    action === "connectRegistry" ||
+    action === "disconnectRegistry" ||
+    action === "renameRegistry" ||
+    action === "fetchRegistryImages" ||
+    action === "setActiveRegistry"
+  ) {
+    return await registryHandlers.handleRegistryAction(ws, action, payload);
+  }
+
+  // Log actions
+  if (
+    action === "fetchContainerLogs" ||
+    action === "streamContainerLogs" ||
+    action === "stopStreamLogs"
+  ) {
+    return await logHandlers.handleLogAction(
+      ws,
+      clientId,
+      action,
+      payload,
+      activeStreams
+    );
+  }
+
+  // Metrics actions
+  if (
+    action === "fetchSystemMetrics" ||
+    action === "fetchContainerMetrics" ||
+    action === "systemMetrics"
+  ) {
+    return await metricsHandlers.handleMetricsAction(ws, action, payload);
+  }
+
+  // Terminal actions
+  if (
+    action === "openTerminalSession" ||
+    action === "closeTerminalSession" ||
+    action === "sendTerminalInput" ||
+    action === "resizeTerminal"
+  ) {
+    return await terminalHandlers.handleTerminalAction(
+      ws,
+      clientId,
+      action,
+      payload,
+      terminalSessions
+    );
+  }
+
+  // General actions
+  if (["getAgentInfo", "getDockerInfo", "execInContainer"].includes(action)) {
+    return await generalHandlers.handleGeneralAction(
+      ws,
+      clientId,
+      action,
+      payload
+    );
+  }
+
+  // Unknown action
+  ws.send(
+    JSON.stringify({
+      type: "error",
+      requestId: payload.requestId,
+      error: `Unknown action: ${action}`,
+    })
+  );
+}
+
+export { setupWebSocketServer, generateWsToken, saveWsToken, readWsToken };