@oussema_mili/test-pkg-123 1.1.32

package/store/agentStore.js

@@ -0,0 +1,113 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from './configStore.js';
+
+const fsPromises = fs.promises;
+
+// Load configuration
+const config = loadConfig();
+const AGENT_ROOT_DIR = config.agentRootDir;
+const AGENT_INFO_DIR = 'agent';
+const AGENT_INFO_FILE = 'info.json';
+const AGENT_INFO_PATH = path.join(
+  os.homedir(),
+  AGENT_ROOT_DIR,
+  AGENT_INFO_DIR,
+  AGENT_INFO_FILE
+);
+
+/**
+ * Agent Store for managing persistent agent information
+ */
+class AgentStore {
+  constructor() {
+    this.agentInfo = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the store
+   */
+  async initialize() {
+    if (this.initialized) return;
+
+    try {
+      // Ensure directory exists
+      await fsPromises.mkdir(path.dirname(AGENT_INFO_PATH), { recursive: true });
+      this.initialized = true;
+    } catch (error) {
+      console.error('Failed to initialize agent store:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Save agent start time
+   */
+  async saveAgentStartTime(startTime) {
+    await this.initialize();
+
+    const agentInfo = {
+      startTime: startTime.toISOString(),
+      lastUpdated: new Date().toISOString(),
+    };
+
+    try {
+      await fsPromises.writeFile(AGENT_INFO_PATH, JSON.stringify(agentInfo, null, 2));
+      this.agentInfo = agentInfo;
+    } catch (error) {
+      console.error('Failed to save agent start time:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Load agent start time
+   */
+  async loadAgentStartTime() {
+    await this.initialize();
+
+    try {
+      const data = await fsPromises.readFile(AGENT_INFO_PATH, 'utf8');
+      const agentInfo = JSON.parse(data);
+      this.agentInfo = agentInfo;
+      return new Date(agentInfo.startTime);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // File doesn't exist - agent not running or first time
+        return null;
+      }
+      console.error('Failed to load agent start time:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Clear agent info (when agent stops)
+   */
+  async clearAgentInfo() {
+    await this.initialize();
+
+    try {
+      await fsPromises.unlink(AGENT_INFO_PATH);
+      this.agentInfo = null;
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.error('Failed to clear agent info:', error);
+      }
+    }
+  }
+
+  /**
+   * Check if agent is currently running based on stored info
+   */
+  async isAgentRunning() {
+    const startTime = await this.loadAgentStartTime();
+    return startTime !== null;
+  }
+}
+
+// Export singleton instance
+const agentStore = new AgentStore();
+export default agentStore;

package/store/configStore.js

@@ -0,0 +1,171 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const FENWAVE_DIR = path.join(os.homedir(), ".fenwave");
+const CONFIG_DIR = path.join(FENWAVE_DIR, "config");
+const CONFIG_FILE = path.join(CONFIG_DIR, "agent.json");
+
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+  // Fenwave URLs
+  backendUrl: "http://localhost:7007",
+  frontendUrl: "http://localhost:3000",
+
+  // Container Configuration
+  containerName: "fenwave-devapp",
+  containerPort: 3003,
+  wsPort: 3001,
+
+  // Directory Configuration
+  agentRootDir: ".fenwave",
+  registriesDir: "registries",
+  containerDataDir: "/data",
+
+  // Docker Image (GHCR - public registry, no auth required)
+  dockerImage: "ghcr.io/fenleap/fenwave/dev-app:latest",
+
+  // Other Settings
+  authTimeoutMs: 60000,
+};
+
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+  if (!fs.existsSync(FENWAVE_DIR)) {
+    fs.mkdirSync(FENWAVE_DIR, { recursive: true, mode: 0o700 });
+  }
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Load configuration from disk
+ * @returns {Object} Configuration object with defaults applied
+ */
+export function loadConfig() {
+  let config = { ...DEFAULT_CONFIG };
+
+  // Load from file if exists
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      const fileConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+      config = { ...config, ...fileConfig };
+    } catch (error) {
+      console.error("Failed to load agent config:", error.message);
+    }
+  }
+
+  // Fall back to environment variables if config values are not set
+  config.backendUrl =
+    config.backendUrl || process.env.BACKEND_URL || DEFAULT_CONFIG.backendUrl;
+  config.frontendUrl =
+    config.frontendUrl ||
+    process.env.FRONTEND_URL ||
+    DEFAULT_CONFIG.frontendUrl;
+  config.wsPort =
+    config.wsPort || Number(process.env.WS_PORT) || DEFAULT_CONFIG.wsPort;
+  config.containerPort =
+    config.containerPort ||
+    Number(process.env.CONTAINER_PORT) ||
+    DEFAULT_CONFIG.containerPort;
+
+  return config;
+}
+
+/**
+ * Save configuration to disk
+ * @param {Object} config - Configuration object to save
+ */
+export function saveConfig(config) {
+  ensureConfigDir();
+
+  const configToSave = {
+    ...config,
+    updatedAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(configToSave, null, 2), {
+    mode: 0o600,
+  });
+}
+
+/**
+ * Update specific configuration values
+ * @param {Object} updates - Configuration updates
+ */
+export function updateConfig(updates) {
+  const currentConfig = loadConfig();
+  const newConfig = { ...currentConfig, ...updates };
+  saveConfig(newConfig);
+  return newConfig;
+}
+
+/**
+ * Get a specific configuration value
+ * @param {string} key - Configuration key
+ * @param {any} defaultValue - Default value if key not found
+ * @returns {any} Configuration value
+ */
+export function getConfig(key, defaultValue = null) {
+  const config = loadConfig();
+  return config[key] !== undefined ? config[key] : defaultValue;
+}
+
+/**
+ * Check if configuration file exists
+ * @returns {boolean} True if config file exists
+ */
+export function configExists() {
+  return fs.existsSync(CONFIG_FILE);
+}
+
+/**
+ * Clear configuration file
+ */
+export function clearConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+  }
+}
+
+/**
+ * Get configuration file path
+ * @returns {string} Path to config file
+ */
+export function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+/**
+ * Initialize configuration with values from init wizard
+ * @param {Object} initConfig - Configuration from init wizard
+ */
+export function initializeConfig(initConfig) {
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...initConfig,
+    createdAt: new Date().toISOString(),
+  };
+
+  saveConfig(config);
+  return config;
+}
+
+export { DEFAULT_CONFIG };
+
+export default {
+  loadConfig,
+  saveConfig,
+  updateConfig,
+  getConfig,
+  configExists,
+  clearConfig,
+  getConfigPath,
+  initializeConfig,
+  DEFAULT_CONFIG,
+};

package/store/daemonStore.js

@@ -0,0 +1,217 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FENWAVE_DIR = path.join(os.homedir(), '.fenwave');
+const DAEMON_DIR = path.join(FENWAVE_DIR, 'daemon');
+const STATE_FILE = path.join(DAEMON_DIR, 'state.json');
+const PID_FILE = path.join(DAEMON_DIR, 'agent.pid');
+const LOCK_FILE = path.join(DAEMON_DIR, 'agent.lock');
+
+/**
+ * Ensure daemon directory exists
+ */
+function ensureDaemonDir() {
+  if (!fs.existsSync(DAEMON_DIR)) {
+    fs.mkdirSync(DAEMON_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Get daemon state
+ * @returns {Object|null} Daemon state or null if not found
+ */
+export function getDaemonState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      const data = fs.readFileSync(STATE_FILE, 'utf8');
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    // Ignore errors reading state
+  }
+  return null;
+}
+
+/**
+ * Save daemon state
+ * @param {Object} state - State object to save
+ */
+export function saveDaemonState(state) {
+  ensureDaemonDir();
+  const stateToSave = {
+    ...state,
+    updatedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(STATE_FILE, JSON.stringify(stateToSave, null, 2), {
+    mode: 0o600,
+  });
+}
+
+/**
+ * Update daemon state with partial updates
+ * @param {Object} updates - Partial state updates
+ */
+export function updateDaemonState(updates) {
+  const currentState = getDaemonState() || {};
+  const newState = { ...currentState, ...updates };
+  saveDaemonState(newState);
+  return newState;
+}
+
+/**
+ * Clear daemon state
+ */
+export function clearDaemonState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      fs.unlinkSync(STATE_FILE);
+    }
+  } catch (error) {
+    // Ignore errors
+  }
+}
+
+/**
+ * Get daemon PID
+ * @returns {number|null} PID or null if not found
+ */
+export function getDaemonPid() {
+  try {
+    if (fs.existsSync(PID_FILE)) {
+      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+      return isNaN(pid) ? null : pid;
+    }
+  } catch (error) {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Save daemon PID
+ * @param {number} pid - Process ID
+ */
+export function saveDaemonPid(pid) {
+  ensureDaemonDir();
+  fs.writeFileSync(PID_FILE, String(pid), { mode: 0o600 });
+}
+
+/**
+ * Clear daemon PID file
+ */
+export function clearDaemonPid() {
+  try {
+    if (fs.existsSync(PID_FILE)) {
+      fs.unlinkSync(PID_FILE);
+    }
+  } catch (error) {
+    // Ignore errors
+  }
+}
+
+/**
+ * Check if daemon process is running
+ * @returns {boolean} True if daemon is running
+ */
+export function isDaemonRunning() {
+  const pid = getDaemonPid();
+  if (!pid) return false;
+
+  try {
+    // Send signal 0 to check if process exists
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // Process doesn't exist
+    return false;
+  }
+}
+
+/**
+ * Acquire daemon lock
+ * @returns {boolean} True if lock acquired
+ */
+export function acquireLock() {
+  ensureDaemonDir();
+
+  try {
+    // Check if lock file exists and if process is still running
+    if (fs.existsSync(LOCK_FILE)) {
+      const lockData = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf8'));
+      try {
+        process.kill(lockData.pid, 0);
+        // Process still running, cannot acquire lock
+        return false;
+      } catch (e) {
+        // Process not running, remove stale lock
+        fs.unlinkSync(LOCK_FILE);
+      }
+    }
+
+    // Create lock file
+    fs.writeFileSync(
+      LOCK_FILE,
+      JSON.stringify({
+        pid: process.pid,
+        createdAt: new Date().toISOString(),
+      }),
+      { mode: 0o600, flag: 'wx' }
+    );
+    return true;
+  } catch (error) {
+    if (error.code === 'EEXIST') {
+      // Lock file was created between our check and write
+      return false;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Release daemon lock
+ */
+export function releaseLock() {
+  try {
+    if (fs.existsSync(LOCK_FILE)) {
+      const lockData = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf8'));
+      // Only remove if we own the lock
+      if (lockData.pid === process.pid) {
+        fs.unlinkSync(LOCK_FILE);
+      }
+    }
+  } catch (error) {
+    // Ignore errors
+  }
+}
+
+/**
+ * Get state file path (for external consumers like DevApp)
+ * @returns {string} Path to state file
+ */
+export function getStateFilePath() {
+  return STATE_FILE;
+}
+
+/**
+ * Get daemon directory path
+ * @returns {string} Path to daemon directory
+ */
+export function getDaemonDir() {
+  return DAEMON_DIR;
+}
+
+export default {
+  getDaemonState,
+  saveDaemonState,
+  updateDaemonState,
+  clearDaemonState,
+  getDaemonPid,
+  saveDaemonPid,
+  clearDaemonPid,
+  isDaemonRunning,
+  acquireLock,
+  releaseLock,
+  getStateFilePath,
+  getDaemonDir,
+};

package/store/deviceCredentialStore.js

@@ -0,0 +1,107 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { encrypt, decrypt } from '../utils/encryption.js';
+
+const FENWAVE_DIR = path.join(os.homedir(), '.fenwave');
+const DEVICE_DIR = path.join(FENWAVE_DIR, 'device');
+const CREDENTIAL_FILE = path.join(DEVICE_DIR, 'credential.json');
+
+/**
+ * Ensure device directory exists
+ */
+function ensureDeviceDir() {
+  if (!fs.existsSync(FENWAVE_DIR)) {
+    fs.mkdirSync(FENWAVE_DIR, { recursive: true, mode: 0o700 });
+  }
+  if (!fs.existsSync(DEVICE_DIR)) {
+    fs.mkdirSync(DEVICE_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Save device credential to disk (encrypted)
+ *
+ * @param {Object} credentialData - Device credential data
+ * @param {string} credentialData.deviceId - Device ID
+ * @param {string} credentialData.deviceCredential - Device credential
+ * @param {string} credentialData.userEntityRef - User entity reference
+ * @param {string} credentialData.deviceName - Device name
+ * @param {string} credentialData.platform - Platform
+ * @param {string} credentialData.agentVersion - Agent version
+ */
+export function saveDeviceCredential(credentialData) {
+  ensureDeviceDir();
+
+  const data = {
+    deviceId: credentialData.deviceId,
+    deviceCredential: encrypt(credentialData.deviceCredential), // Encrypt credential
+    userEntityRef: credentialData.userEntityRef,
+    deviceName: credentialData.deviceName,
+    platform: credentialData.platform,
+    agentVersion: credentialData.agentVersion,
+    registeredAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(CREDENTIAL_FILE, JSON.stringify(data, null, 2), {
+    mode: 0o600,
+  });
+}
+
+/**
+ * Load device credential from disk
+ *
+ * @returns {Object|null} Device credential data or null if not found
+ */
+export function loadDeviceCredential() {
+  if (!fs.existsSync(CREDENTIAL_FILE)) {
+    return null;
+  }
+
+  try {
+    const data = JSON.parse(fs.readFileSync(CREDENTIAL_FILE, 'utf8'));
+
+    // Decrypt the credential
+    const decryptedCredential = decrypt(data.deviceCredential);
+
+    return {
+      deviceId: data.deviceId,
+      deviceCredential: decryptedCredential,
+      userEntityRef: data.userEntityRef,
+      deviceName: data.deviceName,
+      platform: data.platform,
+      agentVersion: data.agentVersion,
+      registeredAt: data.registeredAt,
+    };
+  } catch (error) {
+    console.error('Failed to load device credential:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Check if device is registered
+ *
+ * @returns {boolean} True if device credential exists
+ */
+export function isDeviceRegistered() {
+  return fs.existsSync(CREDENTIAL_FILE);
+}
+
+/**
+ * Clear device credential (delete file)
+ */
+export function clearDeviceCredential() {
+  if (fs.existsSync(CREDENTIAL_FILE)) {
+    fs.unlinkSync(CREDENTIAL_FILE);
+  }
+}
+
+/**
+ * Get device credential file path
+ *
+ * @returns {string} Path to credential file
+ */
+export function getCredentialFilePath() {
+  return CREDENTIAL_FILE;
+}

package/store/npmTokenStore.js

@@ -0,0 +1,65 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FENWAVE_DIR = path.join(os.homedir(), '.fenwave');
+const NPM_DIR = path.join(FENWAVE_DIR, 'npm');
+const NPM_TOKEN_FILE = path.join(NPM_DIR, 'token');
+
+/**
+ * Ensure NPM directory exists
+ */
+function ensureNpmDir() {
+  if (!fs.existsSync(FENWAVE_DIR)) {
+    fs.mkdirSync(FENWAVE_DIR, { recursive: true, mode: 0o700 });
+  }
+  if (!fs.existsSync(NPM_DIR)) {
+    fs.mkdirSync(NPM_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Save NPM token to disk
+ *
+ * @param {string} token - NPM token
+ */
+export function saveNpmToken(token) {
+  ensureNpmDir();
+  fs.writeFileSync(NPM_TOKEN_FILE, token, { mode: 0o600 });
+}
+
+/**
+ * Load NPM token from disk
+ *
+ * @returns {string|null} NPM token or null if not found
+ */
+export function loadNpmToken() {
+  if (!fs.existsSync(NPM_TOKEN_FILE)) {
+    return null;
+  }
+
+  try {
+    return fs.readFileSync(NPM_TOKEN_FILE, 'utf8').trim();
+  } catch (error) {
+    console.error('Failed to load NPM token:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Check if NPM token exists
+ *
+ * @returns {boolean} True if NPM token is configured
+ */
+export function hasNpmToken() {
+  return fs.existsSync(NPM_TOKEN_FILE);
+}
+
+/**
+ * Clear NPM token (delete file)
+ */
+export function clearNpmToken() {
+  if (fs.existsSync(NPM_TOKEN_FILE)) {
+    fs.unlinkSync(NPM_TOKEN_FILE);
+  }
+}