@oussema_mili/test-pkg-123 1.1.32

package/docker-actions/setup-tasks.js

@@ -0,0 +1,859 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { exec } from "child_process";
+import dns from "dns";
+import crypto from "crypto";
+import { promisify } from "util";
+import chalk from "chalk";
+import { loadConfig } from "../store/configStore.js";
+import sslCertificates from "../utils/ssl-certificates.js";
+
+const execAsync = promisify(exec);
+const dnsResolve = promisify(dns.resolve);
+
+// Load configuration
+const config = loadConfig();
+const FENWAVE_CONFIG_DIR = path.join(os.homedir(), ".fenwave");
+const SETUP_DIR = path.join(FENWAVE_CONFIG_DIR, "setup");
+
+/**
+ * Ensure setup directory exists
+ */
+function ensureSetupDir() {
+  if (!fs.existsSync(SETUP_DIR)) {
+    fs.mkdirSync(SETUP_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Generate a hash of the setup wizard configuration
+ * This hash is used to determine if the setup tasks have changed
+ * Only includes task properties that affect execution (not order, title, description)
+ */
+function generateSetupConfigHash(tasks) {
+  if (!tasks || tasks.length === 0) {
+    return "empty";
+  }
+
+  // Extract only the properties that matter for execution
+  const taskSignatures = tasks.map(task => ({
+    id: task.id,
+    type: task.type,
+    config: task.config,
+    required: task.required,
+    outputVariable: task.outputVariable,
+    verification: task.verification ? {
+      type: task.verification.type,
+      target: task.verification.target,
+      command: task.verification.command,
+      expectedFiles: task.verification.expectedFiles,
+    } : undefined,
+  }));
+
+  const configString = JSON.stringify(taskSignatures);
+  return crypto.createHash("sha256").update(configString).digest("hex").substring(0, 16);
+}
+
+/**
+ * Get setup progress file path for an app (by hash)
+ */
+function getSetupFilePathByHash(appId, configHash) {
+  ensureSetupDir();
+  return path.join(SETUP_DIR, `${appId}-hash-${configHash}.json`);
+}
+
+/**
+ * Get setup progress file path for an app (legacy, by version)
+ */
+function getSetupFilePath(appId, version) {
+  ensureSetupDir();
+  const sanitizedVersion = version ? version.replace(/[^a-z0-9.-]/gi, "-") : "default";
+  return path.join(SETUP_DIR, `${appId}-${sanitizedVersion}.json`);
+}
+
+/**
+ * Load setup progress for an app
+ * Tries to find by configHash first, then falls back to version-based lookup
+ */
+function loadSetupProgress(appId, version, configHash = null) {
+  // First, try to load by config hash if provided
+  if (configHash) {
+    const hashFilePath = getSetupFilePathByHash(appId, configHash);
+    if (fs.existsSync(hashFilePath)) {
+      try {
+        const data = fs.readFileSync(hashFilePath, "utf8");
+        const progress = JSON.parse(data);
+        console.log(`✅ Found setup progress by config hash: ${configHash}`);
+        return progress;
+      } catch (error) {
+        console.warn(`⚠️  Failed to load setup progress by hash: ${error.message}`);
+      }
+    }
+  }
+
+  // Fall back to version-based lookup (for backwards compatibility)
+  const filePath = getSetupFilePath(appId, version);
+  if (fs.existsSync(filePath)) {
+    try {
+      const data = fs.readFileSync(filePath, "utf8");
+      const progress = JSON.parse(data);
+      console.log(`✅ Found setup progress by version: ${version}`);
+      return progress;
+    } catch (error) {
+      console.warn(`⚠️  Failed to load setup progress: ${error.message}`);
+    }
+  }
+
+  // Also scan for any matching hash-based progress for this app
+  if (!configHash) {
+    try {
+      const files = fs.readdirSync(SETUP_DIR);
+      const appHashFiles = files.filter(f => f.startsWith(`${appId}-hash-`) && f.endsWith('.json'));
+      if (appHashFiles.length > 0) {
+        // Return the most recently modified one
+        const sortedFiles = appHashFiles
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(SETUP_DIR, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        const latestFile = path.join(SETUP_DIR, sortedFiles[0].name);
+        const data = fs.readFileSync(latestFile, "utf8");
+        const progress = JSON.parse(data);
+        console.log(`✅ Found latest setup progress for app: ${sortedFiles[0].name}`);
+        return progress;
+      }
+    } catch (error) {
+      // Ignore scan errors
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Save setup progress for an app
+ * Saves by both configHash (primary) and version (for backwards compatibility)
+ */
+function saveSetupProgress(progress) {
+  ensureSetupDir();
+
+  try {
+    // Save by config hash if provided
+    if (progress.configHash) {
+      const hashFilePath = getSetupFilePathByHash(progress.appId, progress.configHash);
+      fs.writeFileSync(hashFilePath, JSON.stringify(progress, null, 2), "utf8");
+      console.log(`📝 Saved setup progress by hash: ${progress.configHash}`);
+    }
+
+    // Also save by version for backwards compatibility
+    const filePath = getSetupFilePath(progress.appId, progress.version);
+    fs.writeFileSync(filePath, JSON.stringify(progress, null, 2), "utf8");
+    console.log(`📝 Saved setup progress by version: ${progress.version}`);
+
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to save setup progress: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Clear setup progress for an app
+ */
+function clearSetupProgress(appId, version, configHash = null) {
+  let cleared = false;
+
+  // Clear by hash if provided
+  if (configHash) {
+    const hashFilePath = getSetupFilePathByHash(appId, configHash);
+    if (fs.existsSync(hashFilePath)) {
+      try {
+        fs.unlinkSync(hashFilePath);
+        cleared = true;
+      } catch (error) {
+        console.warn(`⚠️  Failed to clear setup progress by hash: ${error.message}`);
+      }
+    }
+  }
+
+  // Also clear by version
+  const filePath = getSetupFilePath(appId, version);
+  if (fs.existsSync(filePath)) {
+    try {
+      fs.unlinkSync(filePath);
+      cleared = true;
+    } catch (error) {
+      console.warn(`⚠️  Failed to clear setup progress: ${error.message}`);
+    }
+  }
+
+  return cleared;
+}
+
+// =============================================================================
+// Verification Functions
+// =============================================================================
+
+/**
+ * Verify a directory exists
+ */
+async function verifyDirExists(dirPath) {
+  try {
+    const stats = fs.statSync(dirPath);
+    return {
+      success: stats.isDirectory(),
+      message: stats.isDirectory()
+        ? `Directory exists: ${dirPath}`
+        : `Path is not a directory: ${dirPath}`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Directory not found: ${dirPath}`,
+    };
+  }
+}
+
+/**
+ * Verify a file exists
+ */
+async function verifyFileExists(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    return {
+      success: stats.isFile(),
+      message: stats.isFile()
+        ? `File exists: ${filePath}`
+        : `Path is not a file: ${filePath}`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `File not found: ${filePath}`,
+    };
+  }
+}
+
+/**
+ * Verify a directory contains specific files
+ */
+async function verifyContainsFiles(dirPath, expectedFiles) {
+  const dirResult = await verifyDirExists(dirPath);
+  if (!dirResult.success) {
+    return dirResult;
+  }
+
+  const missingFiles = [];
+  for (const file of expectedFiles) {
+    const filePath = path.join(dirPath, file);
+    if (!fs.existsSync(filePath)) {
+      missingFiles.push(file);
+    }
+  }
+
+  if (missingFiles.length > 0) {
+    return {
+      success: false,
+      message: `Missing files: ${missingFiles.join(", ")}`,
+      details: `Directory: ${dirPath}`,
+    };
+  }
+
+  return {
+    success: true,
+    message: `All required files found in ${dirPath}`,
+  };
+}
+
+/**
+ * Verify DNS resolution for a hostname
+ */
+async function verifyDnsResolve(hostname) {
+  try {
+    await dnsResolve(hostname);
+    return {
+      success: true,
+      message: `Hostname resolves: ${hostname}`,
+    };
+  } catch (error) {
+    // Also check /etc/hosts directly
+    try {
+      const hostsContent = fs.readFileSync("/etc/hosts", "utf8");
+      if (hostsContent.includes(hostname)) {
+        return {
+          success: true,
+          message: `Hostname found in /etc/hosts: ${hostname}`,
+        };
+      }
+    } catch (hostsError) {
+      // Ignore hosts file read errors
+    }
+
+    return {
+      success: false,
+      message: `Hostname does not resolve: ${hostname}`,
+      details: error.message,
+    };
+  }
+}
+
+/**
+ * Verify by running a command and checking exit code
+ */
+async function verifyCommand(command, workingDir) {
+  try {
+    const options = workingDir ? { cwd: workingDir } : {};
+    await execAsync(command, options);
+    return {
+      success: true,
+      message: "Command executed successfully",
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Command failed: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Verify mkcert is installed
+ */
+async function verifyMkcertInstalled(verification) {
+  const result = await sslCertificates.checkMkcertInstalled();
+
+  if (result.installed) {
+    return {
+      success: true,
+      message: verification.successMessage || `mkcert is installed (${result.version})`,
+      version: result.version,
+    };
+  }
+
+  return {
+    success: false,
+    message: verification.failureMessage || result.error,
+  };
+}
+
+/**
+ * Verify a setup task based on its verification config
+ */
+async function verifyTask(task, value) {
+  const { verification, config: taskConfig } = task;
+
+  if (!verification) {
+    // No verification required, auto-pass
+    return { success: true, message: "No verification required" };
+  }
+
+  switch (verification.type) {
+    case "dir_exists":
+      return await verifyDirExists(value || verification.target);
+
+    case "file_exists":
+      return await verifyFileExists(value || verification.target);
+
+    case "contains_file":
+      return await verifyContainsFiles(
+        value || verification.target,
+        verification.expectedFiles || []
+      );
+
+    case "dns_resolve":
+      return await verifyDnsResolve(taskConfig.hostname || verification.target);
+
+    case "command":
+      return await verifyCommand(
+        verification.command,
+        value || taskConfig.workingDir
+      );
+
+    case "mkcert_installed":
+      return await verifyMkcertInstalled(verification);
+
+    default:
+      return {
+        success: false,
+        message: `Unknown verification type: ${verification.type}`,
+      };
+  }
+}
+
+// =============================================================================
+// Task Execution Functions
+// =============================================================================
+
+/**
+ * Execute a file copy task
+ */
+async function executeFileCopy(task, workingDir) {
+  const { config: taskConfig } = task;
+  const destPath = taskConfig.destinationPath.startsWith("/")
+    ? taskConfig.destinationPath
+    : path.join(workingDir || os.homedir(), taskConfig.destinationPath);
+
+  try {
+    // Ensure destination directory exists
+    const destDir = path.dirname(destPath);
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
+    }
+
+    if (taskConfig.template) {
+      // Write template content
+      fs.writeFileSync(destPath, taskConfig.template, "utf8");
+    } else if (taskConfig.sourcePath) {
+      // Copy from source
+      const sourcePath = taskConfig.sourcePath.startsWith("/")
+        ? taskConfig.sourcePath
+        : path.join(workingDir || os.homedir(), taskConfig.sourcePath);
+      fs.copyFileSync(sourcePath, destPath);
+    }
+
+    return {
+      success: true,
+      message: `File created: ${destPath}`,
+      value: destPath,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to create file: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Execute a command task
+ */
+async function executeCommand(task) {
+  const { config: taskConfig } = task;
+
+  try {
+    const options = taskConfig.workingDir
+      ? { cwd: taskConfig.workingDir, timeout: 60000 }
+      : { timeout: 60000 };
+
+    const { stdout, stderr } = await execAsync(taskConfig.command, options);
+
+    return {
+      success: true,
+      message: stdout || stderr || "Command executed successfully",
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: error.stderr || error.message || "Command failed",
+    };
+  }
+}
+
+/**
+ * Execute an SSL certificate generation task
+ */
+async function executeSSLCertificate(task) {
+  const { config: taskConfig, outputVariable } = task;
+  const { domains, certName, installCA } = taskConfig;
+
+  // Check mkcert is installed
+  const mkcertCheck = await sslCertificates.checkMkcertInstalled();
+  if (!mkcertCheck.installed) {
+    return {
+      success: false,
+      message: mkcertCheck.error,
+    };
+  }
+
+  // Install CA if requested
+  if (installCA !== false) {
+    const caResult = await sslCertificates.installMkcertCA();
+    if (!caResult.success) {
+      console.warn(`⚠️  CA installation warning: ${caResult.message}`);
+      // Continue anyway, user might have already installed CA
+    }
+  }
+
+  // Generate certificates
+  const result = await sslCertificates.generateCertificates(domains, certName);
+
+  if (!result.success) {
+    return {
+      success: false,
+      message: result.message,
+    };
+  }
+
+  // Get CA path for the output variables
+  const caResult = await sslCertificates.getMkcertCAPath();
+
+  // Build output variables using the task's outputVariable as prefix
+  const prefix = outputVariable || "SSL";
+  const outputVariables = {
+    [`${prefix}_CERT_PATH`]: result.certPath,
+    [`${prefix}_KEY_PATH`]: result.keyPath,
+  };
+
+  // Only include CA path if available
+  if (caResult.success && caResult.caPath) {
+    outputVariables[`${prefix}_CA_PATH`] = caResult.caPath;
+  }
+
+  return {
+    success: true,
+    message: result.message,
+    value: result.certPath, // Primary value for backward compatibility
+    outputVariables, // Multiple variables for SSL task
+  };
+}
+
+/**
+ * Execute a setup task
+ */
+async function executeTask(task, params) {
+  switch (task.type) {
+    case "file_copy":
+    case "file_edit":
+      return await executeFileCopy(task, params?.workingDir);
+
+    case "command":
+      return await executeCommand(task);
+
+    case "ssl_certificate":
+      return await executeSSLCertificate(task);
+
+    default:
+      return {
+        success: false,
+        message: `Task type "${task.type}" does not support execution`,
+      };
+  }
+}
+
+// =============================================================================
+// WebSocket Handlers
+// =============================================================================
+
+/**
+ * Handle setup task actions
+ */
+async function handleSetupAction(ws, action, payload) {
+  switch (action) {
+    case "getSetupTasks":
+      return await handleGetSetupTasks(ws, payload);
+    case "getSetupStatus":
+      return await handleGetSetupStatus(ws, payload);
+    case "verifySetupTask":
+      return await handleVerifySetupTask(ws, payload);
+    case "executeSetupTask":
+      return await handleExecuteSetupTask(ws, payload);
+    case "saveSetupProgress":
+      return await handleSaveSetupProgress(ws, payload);
+    case "clearSetupProgress":
+      return await handleClearSetupProgress(ws, payload);
+    case "browseDirectory":
+      return await handleBrowseDirectory(ws, payload);
+    default:
+      ws.send(
+        JSON.stringify({
+          type: "error",
+          error: `Unknown setup action: ${action}`,
+          requestId: payload.requestId,
+        })
+      );
+  }
+}
+
+/**
+ * Get setup tasks from app's deployment config
+ * Note: This requires fetching the app config from Fenwave
+ */
+async function handleGetSetupTasks(ws, payload) {
+  const { appId, version, requestId } = payload;
+
+  try {
+    // For now, return a mock response
+    // In production, this would fetch from the app's deploymentConfig.localSetup
+    // This will be populated by the app-list.tsx which already has the app data
+
+    ws.send(
+      JSON.stringify({
+        type: "setupTasks",
+        localSetup: null, // Will be populated from app data on client side
+        requestId,
+      })
+    );
+  } catch (error) {
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: `Failed to get setup tasks: ${error.message}`,
+        requestId,
+      })
+    );
+  }
+}
+
+/**
+ * Get setup status/progress for an app
+ * If tasks are provided, generates a config hash for precise matching
+ */
+async function handleGetSetupStatus(ws, payload) {
+  const { appId, version, tasks, requestId } = payload;
+
+  try {
+    // Generate config hash if tasks are provided
+    const configHash = tasks ? generateSetupConfigHash(tasks) : null;
+
+    console.log(`🔍 Looking for setup progress: appId=${appId}, version=${version}, configHash=${configHash}`);
+
+    const progress = loadSetupProgress(appId, version, configHash);
+
+    // If we found progress, check if the config hash matches
+    let hashMatches = true;
+    if (progress && configHash && progress.configHash && progress.configHash !== configHash) {
+      console.log(`⚠️  Config hash mismatch: stored=${progress.configHash}, current=${configHash}`);
+      hashMatches = false;
+    }
+
+    ws.send(
+      JSON.stringify({
+        type: "setupStatus",
+        progress: hashMatches ? progress : null, // Return null if hash doesn't match
+        configHash, // Send back the current config hash
+        hashMatches,
+        requestId,
+      })
+    );
+  } catch (error) {
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: `Failed to get setup status: ${error.message}`,
+        requestId,
+      })
+    );
+  }
+}
+
+/**
+ * Verify a setup task
+ */
+async function handleVerifySetupTask(ws, payload) {
+  const { appId, taskId, value, task, requestId } = payload;
+
+  try {
+    // Task should be passed from client since we don't store tasks on agent
+    if (!task) {
+      ws.send(
+        JSON.stringify({
+          type: "verifyResult",
+          success: false,
+          message: "Task definition required for verification",
+          requestId,
+        })
+      );
+      return;
+    }
+
+    const result = await verifyTask(task, value);
+
+    ws.send(
+      JSON.stringify({
+        type: "verifyResult",
+        ...result,
+        requestId,
+      })
+    );
+  } catch (error) {
+    ws.send(
+      JSON.stringify({
+        type: "verifyResult",
+        success: false,
+        message: `Verification error: ${error.message}`,
+        requestId,
+      })
+    );
+  }
+}
+
+/**
+ * Execute a setup task
+ */
+async function handleExecuteSetupTask(ws, payload) {
+  const { appId, taskId, task, params, requestId } = payload;
+
+  try {
+    // Task should be passed from client
+    if (!task) {
+      ws.send(
+        JSON.stringify({
+          type: "executeResult",
+          success: false,
+          message: "Task definition required for execution",
+          requestId,
+        })
+      );
+      return;
+    }
+
+    const result = await executeTask(task, params);
+
+    ws.send(
+      JSON.stringify({
+        type: "executeResult",
+        ...result,
+        requestId,
+      })
+    );
+  } catch (error) {
+    ws.send(
+      JSON.stringify({
+        type: "executeResult",
+        success: false,
+        message: `Execution error: ${error.message}`,
+        requestId,
+      })
+    );
+  }
+}
+
+/**
+ * Save setup progress
+ */
+async function handleSaveSetupProgress(ws, payload) {
+  const { requestId, tasks, ...progress } = payload;
+
+  try {
+    // Generate config hash from tasks if provided
+    const configHash = tasks ? generateSetupConfigHash(tasks) : progress.configHash;
+
+    const progressWithHash = {
+      ...progress,
+      configHash,
+    };
+
+    console.log(`📝 Saving setup progress for appId=${progress.appId}, version=${progress.version}, configHash=${configHash}`);
+    console.log(`   Variables: ${JSON.stringify(progress.variables || {})}`);
+    console.log(`   Tasks: ${progress.tasks?.length || 0} task statuses`);
+
+    const success = saveSetupProgress(progressWithHash);
+
+    console.log(`   Save result: ${success ? 'SUCCESS' : 'FAILED'}`);
+
+    ws.send(
+      JSON.stringify({
+        type: "saveProgressResult",
+        success,
+        configHash,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error(`❌ Failed to save setup progress: ${error.message}`);
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: `Failed to save progress: ${error.message}`,
+        requestId,
+      })
+    );
+  }
+}
+
+/**
+ * Clear setup progress
+ */
+async function handleClearSetupProgress(ws, payload) {
+  const { appId, version, requestId } = payload;
+
+  try {
+    const success = clearSetupProgress(appId, version);
+
+    ws.send(
+      JSON.stringify({
+        type: "clearProgressResult",
+        success,
+        requestId,
+      })
+    );
+  } catch (error) {
+    ws.send(
+      JSON.stringify({
+        type: "error",
+        error: `Failed to clear progress: ${error.message}`,
+        requestId,
+      })
+    );
+  }
+}
+
+/**
+ * Browse for a directory (opens native dialog via AppleScript on macOS)
+ */
+async function handleBrowseDirectory(ws, payload) {
+  const { startPath, requestId } = payload;
+
+  try {
+    let selectedPath = null;
+
+    if (process.platform === "darwin") {
+      // macOS: Use AppleScript to open native folder picker
+      // choose folder is a Standard Additions command, returns POSIX path directly
+      const script = startPath
+        ? `osascript -e 'POSIX path of (choose folder with prompt "Select Directory" default location POSIX file "${startPath}")'`
+        : `osascript -e 'POSIX path of (choose folder with prompt "Select Directory")'`;
+
+      try {
+        const { stdout } = await execAsync(script);
+        selectedPath = stdout.trim();
+      } catch (error) {
+        // User cancelled or error
+        console.log("Directory browse cancelled or failed:", error.message);
+      }
+    } else if (process.platform === "linux") {
+      // Linux: Try zenity or kdialog
+      try {
+        const { stdout } = await execAsync(
+          `zenity --file-selection --directory --title="Select Directory"${startPath ? ` --filename="${startPath}"` : ""}`
+        );
+        selectedPath = stdout.trim();
+      } catch (error) {
+        // Zenity not available or cancelled
+        try {
+          const { stdout } = await execAsync(
+            `kdialog --getexistingdirectory ${startPath || "~"}`
+          );
+          selectedPath = stdout.trim();
+        } catch (kdialogError) {
+          console.log("Directory browse not available on this system");
+        }
+      }
+    }
+
+    ws.send(
+      JSON.stringify({
+        type: "browseResult",
+        path: selectedPath,
+        requestId,
+      })
+    );
+  } catch (error) {
+    ws.send(
+      JSON.stringify({
+        type: "browseResult",
+        path: null,
+        requestId,
+      })
+    );
+  }
+}
+
+export default {
+  handleSetupAction,
+  loadSetupProgress,
+  saveSetupProgress,
+  clearSetupProgress,
+  verifyTask,
+  executeTask,
+};