@oussema_mili/test-pkg-123 1.1.22

package/store/registryStore.js

@@ -0,0 +1,329 @@
+import os from "os";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import dotenv from "dotenv";
+dotenv.config();
+
+const fsPromises = fs.promises;
+
+const AGENT_ROOT_DIR = process.env.AGENT_ROOT_DIR || ".fenwave";
+const REGISTRIES_DIR = process.env.REGISTRIES_DIR || "registries";
+const REGISTRIES_FILE = process.env.REGISTRIES_FILE || "credentials.json";
+const REGISTRY_FILE = path.join(
+  os.homedir(),
+  AGENT_ROOT_DIR,
+  REGISTRIES_DIR,
+  REGISTRIES_FILE
+);
+
+const SCHEMA_VERSION = 1;
+
+/**
+ * Registry Store for managing registry credentials
+ */
+class RegistryStore {
+  constructor() {
+    this.registries = new Map();
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the store - load registries
+   */
+  async initialize() {
+    if (this.initialized) return;
+
+    try {
+      // Ensure directory exists
+      await this.ensureDirectory();
+
+      // Load existing registries
+      await this.loadRegistries();
+
+      this.initialized = true;
+    } catch (error) {
+      console.error(
+        chalk.red("❌ Failed to initialize registry store:", error.message)
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Ensure the .fenwave/registries directory exists
+   */
+  async ensureDirectory() {
+    const dir = path.dirname(REGISTRY_FILE);
+    try {
+      await fsPromises.mkdir(dir, { recursive: true, mode: 0o700 });
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Load registries from file
+   */
+  async loadRegistries() {
+    try {
+      const data = await fsPromises.readFile(REGISTRY_FILE, "utf8");
+      const parsed = JSON.parse(data);
+
+      if (parsed.version !== SCHEMA_VERSION) {
+        console.warn(
+          `⚠️ Registry file version mismatch. Expected ${SCHEMA_VERSION}, got ${parsed.version}`
+        );
+      }
+
+      // Load registries with plain text credentials
+      let hasActiveRegistry = false;
+
+      for (const registry of parsed.registries || []) {
+        try {
+          // Ensure active field exists (for backward compatibility)
+          if (registry.active === undefined) {
+            registry.active = false;
+          }
+
+          if (registry.active) {
+            hasActiveRegistry = true;
+          }
+
+          // Store registry with credentials directly
+          this.registries.set(registry.id, registry);
+        } catch (error) {
+          console.error(
+            chalk.red(`❌ Failed to load registry ${registry.id}:`),
+            error.message
+          );
+          // Skip this registry but continue with others
+        }
+      }
+
+      // If no registry is marked as active, make the first one active
+      if (!hasActiveRegistry && this.registries.size > 0) {
+        const firstRegistry = this.registries.values().next().value;
+        if (firstRegistry) {
+          firstRegistry.active = true;
+          firstRegistry.updatedAt = new Date().toISOString();
+          // Save the updated registries with the active flag
+          await this.saveRegistries();
+        }
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        // File doesn't exist yet, start with empty registries
+        return;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Save registries to file with plain text credentials
+   */
+  async saveRegistries() {
+    try {
+      const registriesToSave = [];
+
+      for (const [id, registry] of this.registries.entries()) {
+        // Save registry with credentials directly
+        registriesToSave.push(registry);
+      }
+
+      const data = {
+        version: SCHEMA_VERSION,
+        registries: registriesToSave,
+        updatedAt: new Date().toISOString(),
+      };
+
+      // Write atomically
+      const tempFile = REGISTRY_FILE + ".tmp";
+      await fsPromises.writeFile(tempFile, JSON.stringify(data, null, 2), {
+        mode: 0o600,
+      });
+      await fsPromises.rename(tempFile, REGISTRY_FILE);
+    } catch (error) {
+      console.error(chalk.red("❌ Failed to save registries:", error.message));
+      throw error;
+    }
+  }
+
+  /**
+   * Add or update a registry
+   */
+  async upsertRegistry(registryData) {
+    await this.initialize();
+
+    const { id, credentials, ...metadata } = registryData;
+
+    const registry = {
+      id,
+      ...metadata,
+      credentials,
+      updatedAt: new Date().toISOString(),
+    };
+
+    if (!this.registries.has(id)) {
+      registry.createdAt = registry.updatedAt;
+      // If this is the first registry, make it active by default
+      if (this.registries.size === 0) {
+        registry.active = true;
+      } else {
+        registry.active = false;
+      }
+    }
+
+    this.registries.set(id, registry);
+    await this.saveRegistries();
+
+    return registry;
+  }
+
+  /**
+   * Get all registries (returns metadata only, no credentials)
+   */
+  async getAllRegistries() {
+    await this.initialize();
+
+    const result = [];
+    for (const [id, registry] of this.registries.entries()) {
+      const { credentials, ...safeRegistry } = registry;
+
+      // Add type-specific safe metadata
+      const metadata = { ...safeRegistry };
+      if (registry.type === "ecr" && credentials) {
+        metadata.accessKeyId = credentials.accessKeyId;
+        metadata.region = registry.region;
+      } else if (registry.type === "gcr" && credentials?.serviceAccountJson) {
+        try {
+          const serviceAccount = JSON.parse(credentials.serviceAccountJson);
+          metadata.projectId = serviceAccount.project_id;
+        } catch (error) {
+          console.error("Error parsing service account JSON:", error);
+        }
+      } else if (credentials?.username) {
+        metadata.username = credentials.username;
+      }
+
+      // Ensure active field is included (default to false if not set)
+      metadata.active = registry.active || false;
+
+      result.push(metadata);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get registry with credentials (for agent operations)
+   */
+  async getRegistryWithCredentials(id) {
+    await this.initialize();
+    return this.registries.get(id);
+  }
+
+  /**
+   * Remove a registry
+   */
+  async removeRegistry(id) {
+    await this.initialize();
+
+    const registryToRemove = this.registries.get(id);
+    const deleted = this.registries.delete(id);
+
+    if (deleted) {
+      // If we removed the active registry, set another one as active
+      if (
+        registryToRemove &&
+        registryToRemove.active &&
+        this.registries.size > 0
+      ) {
+        // Set the first remaining registry as active
+        const firstRegistry = this.registries.values().next().value;
+        if (firstRegistry) {
+          firstRegistry.active = true;
+          firstRegistry.updatedAt = new Date().toISOString();
+        }
+      }
+
+      await this.saveRegistries();
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Get registry count
+   */
+  async getRegistryCount() {
+    await this.initialize();
+    return this.registries.size;
+  }
+
+  /**
+   * Clear all registries (for logout/cleanup)
+   */
+  async clearAll() {
+    await this.initialize();
+    this.registries.clear();
+    await this.saveRegistries();
+    console.log("🧹 All registries cleared");
+  }
+
+  /**
+   * Set active registry
+   */
+  async setActiveRegistry(id) {
+    await this.initialize();
+
+    // First, set all registries to inactive
+    for (const [registryId, registry] of this.registries.entries()) {
+      registry.active = false;
+    }
+
+    // Then set the specified registry as active
+    if (id && this.registries.has(id)) {
+      const registry = this.registries.get(id);
+      registry.active = true;
+      registry.updatedAt = new Date().toISOString();
+      await this.saveRegistries();
+      return registry;
+    }
+
+    // If no valid id provided, save anyway to clear all active states
+    await this.saveRegistries();
+    return null;
+  }
+
+  /**
+   * Get active registry
+   */
+  async getActiveRegistry() {
+    await this.initialize();
+
+    for (const [id, registry] of this.registries.entries()) {
+      if (registry.active) {
+        return registry;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get active registry ID
+   */
+  async getActiveRegistryId() {
+    const activeRegistry = await this.getActiveRegistry();
+    return activeRegistry ? activeRegistry.id : null;
+  }
+}
+
+// Singleton instance
+const registryStore = new RegistryStore();
+
+export default registryStore;

package/store/setupState.js

@@ -0,0 +1,147 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FENWAVE_DIR = path.join(os.homedir(), '.fenwave');
+const SETUP_DIR = path.join(FENWAVE_DIR, 'setup');
+const STATE_FILE = path.join(SETUP_DIR, 'state.json');
+
+/**
+ * Setup steps enum
+ */
+const SetupStep = {
+  PREREQUISITES: 'prerequisites',
+  REGISTRATION: 'registration',
+  DOCKER_REGISTRY: 'docker_registry',
+  PULL_IMAGE: 'pull_image',
+  NPM_CONFIG: 'npm_config',
+  START_AGENT: 'start_agent',
+  COMPLETE: 'complete',
+};
+
+/**
+ * Ensure setup directory exists
+ */
+function ensureSetupDir() {
+  if (!fs.existsSync(FENWAVE_DIR)) {
+    fs.mkdirSync(FENWAVE_DIR, { recursive: true, mode: 0o700 });
+  }
+  if (!fs.existsSync(SETUP_DIR)) {
+    fs.mkdirSync(SETUP_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Save setup progress
+ *
+ * @param {string} step - Current step
+ * @param {Object} data - Step data
+ */
+function saveSetupProgress(step, data = {}) {
+  ensureSetupDir();
+
+  const state = loadSetupProgress() || {
+    startedAt: new Date().toISOString(),
+    steps: {},
+  };
+
+  state.steps[step] = {
+    completedAt: new Date().toISOString(),
+    data,
+  };
+
+  state.currentStep = step;
+  state.updatedAt = new Date().toISOString();
+
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), {
+    mode: 0o600,
+  });
+}
+
+/**
+ * Load setup progress
+ *
+ * @returns {Object|null} Setup state or null if not found
+ */
+function loadSetupProgress() {
+  if (!fs.existsSync(STATE_FILE)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+  } catch (error) {
+    console.error('Failed to load setup progress:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Mark step as complete
+ *
+ * @param {string} step - Step to mark as complete
+ */
+function markStepComplete(step) {
+  saveSetupProgress(step);
+}
+
+/**
+ * Check if step is complete
+ *
+ * @param {string} step - Step to check
+ * @returns {boolean} True if step is complete
+ */
+function isStepComplete(step) {
+  const state = loadSetupProgress();
+  return state?.steps?.[step] !== undefined;
+}
+
+/**
+ * Get current step
+ *
+ * @returns {string|null} Current step or null
+ */
+function getCurrentStep() {
+  const state = loadSetupProgress();
+  return state?.currentStep || null;
+}
+
+/**
+ * Clear setup state
+ */
+function clearSetupState() {
+  if (fs.existsSync(STATE_FILE)) {
+    fs.unlinkSync(STATE_FILE);
+  }
+}
+
+/**
+ * Check if setup is in progress
+ *
+ * @returns {boolean} True if setup state exists
+ */
+function isSetupInProgress() {
+  return fs.existsSync(STATE_FILE);
+}
+
+/**
+ * Get completed steps
+ *
+ * @returns {Array<string>} List of completed step names
+ */
+function getCompletedSteps() {
+  const state = loadSetupProgress();
+  return state?.steps ? Object.keys(state.steps) : [];
+}
+
+export {
+  SetupStep,
+  saveSetupProgress,
+  loadSetupProgress,
+  markStepComplete,
+  isStepComplete,
+  getCurrentStep,
+  clearSetupState,
+  isSetupInProgress,
+  getCompletedSteps,
+};

package/styles.css

@@ -0,0 +1 @@
+@import "tailwindcss";

package/utils/appLogger.js

@@ -0,0 +1,223 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import chalk from "chalk";
+
+const LOGS_DIR = path.join(os.homedir(), ".fenwave", "logs");
+
+/**
+ * Ensure logs directory exists
+ */
+function ensureLogsDir() {
+  if (!fs.existsSync(LOGS_DIR)) {
+    fs.mkdirSync(LOGS_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Generate a log filename for an app
+ * @param {string} appName - Application name
+ * @param {string} version - Application version
+ * @returns {string} Log filename
+ */
+function generateLogFilename(appName, version) {
+  const sanitizedName = appName.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  return `${sanitizedName}-${version || "latest"}-${timestamp}.log`;
+}
+
+/**
+ * Create an app logger instance
+ * @param {string} appName - Application name
+ * @param {string} version - Application version
+ * @returns {Object} Logger instance with methods and logPath
+ */
+export function createAppLogger(appName, version) {
+  ensureLogsDir();
+
+  const filename = generateLogFilename(appName, version);
+  const logPath = path.join(LOGS_DIR, filename);
+
+  // Create log file with header
+  const header = `
+================================================================================
+  Fenwave App Startup Log
+================================================================================
+  Application: ${appName}
+  Version: ${version || "latest"}
+  Started: ${new Date().toISOString()}
+================================================================================
+
+`;
+
+  fs.writeFileSync(logPath, header, { mode: 0o600 });
+
+  return {
+    logPath,
+    filename,
+
+    /**
+     * Log an info message
+     * @param {string} message - Message to log
+     */
+    info(message) {
+      const timestamp = new Date().toISOString();
+      const line = `[${timestamp}] [INFO] ${message}\n`;
+      fs.appendFileSync(logPath, line);
+      console.log(chalk.blue(`ℹ️  ${message}`));
+    },
+
+    /**
+     * Log a success message
+     * @param {string} message - Message to log
+     */
+    success(message) {
+      const timestamp = new Date().toISOString();
+      const line = `[${timestamp}] [SUCCESS] ${message}\n`;
+      fs.appendFileSync(logPath, line);
+      console.log(chalk.green(`✅ ${message}`));
+    },
+
+    /**
+     * Log an error message
+     * @param {string} message - Message to log
+     */
+    error(message) {
+      const timestamp = new Date().toISOString();
+      const line = `[${timestamp}] [ERROR] ${message}\n`;
+      fs.appendFileSync(logPath, line);
+      console.error(chalk.red(`❌ ${message}`));
+    },
+
+    /**
+     * Log a warning message
+     * @param {string} message - Message to log
+     */
+    warn(message) {
+      const timestamp = new Date().toISOString();
+      const line = `[${timestamp}] [WARN] ${message}\n`;
+      fs.appendFileSync(logPath, line);
+      console.warn(chalk.yellow(`⚠️  ${message}`));
+    },
+
+    /**
+     * Log docker output (stdout/stderr)
+     * @param {string} output - Docker output
+     * @param {string} type - Output type ('stdout' or 'stderr')
+     */
+    docker(output, type = "stdout") {
+      if (!output || !output.trim()) return;
+
+      const timestamp = new Date().toISOString();
+      const prefix = type === "stderr" ? "[DOCKER STDERR]" : "[DOCKER]";
+      const lines = output.split("\n").filter(line => line.trim());
+
+      for (const line of lines) {
+        fs.appendFileSync(logPath, `[${timestamp}] ${prefix} ${line}\n`);
+      }
+    },
+
+    /**
+     * Log completion status
+     * @param {boolean} success - Whether the operation succeeded
+     * @param {string} message - Completion message
+     */
+    complete(success, message) {
+      const timestamp = new Date().toISOString();
+      const status = success ? "COMPLETED SUCCESSFULLY" : "FAILED";
+      const footer = `
+================================================================================
+  ${status}
+  ${message}
+  Finished: ${timestamp}
+================================================================================
+`;
+      fs.appendFileSync(logPath, footer);
+    }
+  };
+}
+
+/**
+ * Get recent logs for an app
+ * @param {string} appName - Application name (optional, filters by app)
+ * @param {number} limit - Number of logs to return
+ * @returns {Array} Array of log file info
+ */
+export function getRecentLogs(appName = null, limit = 20) {
+  ensureLogsDir();
+
+  try {
+    let files = fs.readdirSync(LOGS_DIR)
+      .filter(f => f.endsWith(".log"))
+      .map(f => {
+        const filePath = path.join(LOGS_DIR, f);
+        const stats = fs.statSync(filePath);
+        return {
+          filename: f,
+          path: filePath,
+          createdAt: stats.birthtime,
+          size: stats.size,
+        };
+      })
+      .sort((a, b) => b.createdAt - a.createdAt);
+
+    if (appName) {
+      const sanitizedName = appName.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+      files = files.filter(f => f.filename.startsWith(sanitizedName));
+    }
+
+    return files.slice(0, limit);
+  } catch (error) {
+    console.error("Error reading logs directory:", error);
+    return [];
+  }
+}
+
+/**
+ * Read a log file content
+ * @param {string} filename - Log filename
+ * @returns {string|null} Log content or null if not found
+ */
+export function readLogFile(filename) {
+  const logPath = path.join(LOGS_DIR, filename);
+
+  if (!fs.existsSync(logPath)) {
+    return null;
+  }
+
+  try {
+    return fs.readFileSync(logPath, "utf8");
+  } catch (error) {
+    console.error("Error reading log file:", error);
+    return null;
+  }
+}
+
+/**
+ * Clean up old logs (keep last N days)
+ * @param {number} daysToKeep - Number of days to keep logs
+ */
+export function cleanupOldLogs(daysToKeep = 7) {
+  ensureLogsDir();
+
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+
+  try {
+    const files = fs.readdirSync(LOGS_DIR);
+
+    for (const file of files) {
+      const filePath = path.join(LOGS_DIR, file);
+      const stats = fs.statSync(filePath);
+
+      if (stats.birthtime < cutoffDate) {
+        fs.unlinkSync(filePath);
+        console.log(chalk.gray(`🧹 Cleaned up old log: ${file}`));
+      }
+    }
+  } catch (error) {
+    console.error("Error cleaning up logs:", error);
+  }
+}
+
+export { LOGS_DIR };