@oussema_mili/test-pkg-123 1.1.32

package/daemon/daemonManager.js

@@ -0,0 +1,266 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import chalk from 'chalk';
+
+import {
+  getDaemonPid,
+  getDaemonState,
+  clearDaemonPid,
+  clearDaemonState,
+  isDaemonRunning,
+} from '../store/daemonStore.js';
+import { getLogPath } from './logManager.js';
+
+// ES module helpers
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Path to the daemon entry script
+const DAEMON_SCRIPT = path.join(__dirname, 'daemonEntry.js');
+
+/**
+ * Start the agent as a background daemon
+ * @param {Object} options - Daemon options
+ * @param {number} options.port - Preferred WebSocket port
+ * @returns {Promise<Object>} Daemon info
+ */
+export async function startDaemon(options = {}) {
+  // Check if daemon is already running
+  if (isDaemonRunning()) {
+    const state = getDaemonState();
+    throw new Error(
+      `Agent is already running (PID: ${state?.pid}, Port: ${state?.port}). ` +
+        'Use "fenwave service stop" to stop it first.'
+    );
+  }
+
+  // Clean up any stale files
+  clearDaemonPid();
+  clearDaemonState();
+
+  // Prepare daemon arguments
+  const args = [];
+  if (options.port) {
+    args.push('--port', String(options.port));
+  }
+
+  // Get log file paths for stdout/stderr redirection
+  const logPath = getLogPath();
+  const errorLogPath = getLogPath('agent.error');
+
+  // Ensure log directory exists
+  const logDir = path.dirname(logPath);
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true, mode: 0o700 });
+  }
+
+  // Open log files for writing
+  const outFd = fs.openSync(logPath, 'a');
+  const errFd = fs.openSync(errorLogPath, 'a');
+
+  // Spawn daemon process
+  const daemon = spawn('node', [DAEMON_SCRIPT, ...args], {
+    detached: true,
+    stdio: ['ignore', outFd, errFd],
+    env: {
+      ...process.env,
+      FENWAVE_DAEMON: 'true',
+    },
+  });
+
+  // Unref to allow parent to exit
+  daemon.unref();
+
+  // Close file descriptors in parent
+  fs.closeSync(outFd);
+  fs.closeSync(errFd);
+
+  // Wait a moment for daemon to start and write state
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  // Check if daemon started successfully
+  const state = getDaemonState();
+  if (!state || state.status !== 'running') {
+    throw new Error(
+      'Daemon failed to start. Check logs with "fenwave service logs"'
+    );
+  }
+
+  return {
+    pid: state.pid,
+    port: state.port,
+    startTime: state.startTime,
+  };
+}
+
+/**
+ * Stop the running daemon
+ * @param {Object} options - Stop options
+ * @param {number} options.timeout - Timeout in ms to wait for graceful shutdown
+ * @returns {Promise<boolean>} True if stopped
+ */
+export async function stopDaemon(options = {}) {
+  const { timeout = 20000 } = options;
+
+  const pid = getDaemonPid();
+  if (!pid) {
+    console.log(chalk.yellow('No daemon PID file found'));
+    return false;
+  }
+
+  // Check if process is running
+  if (!isDaemonRunning()) {
+    console.log(chalk.yellow('Daemon process not running, cleaning up files...'));
+    clearDaemonPid();
+    clearDaemonState();
+    return false;
+  }
+
+  console.log(chalk.blue(`Stopping daemon (PID: ${pid})...`));
+
+  // Send SIGTERM for graceful shutdown
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (error) {
+    if (error.code === 'ESRCH') {
+      console.log(chalk.yellow('Process already terminated'));
+      clearDaemonPid();
+      clearDaemonState();
+      return true;
+    }
+    throw error;
+  }
+
+  // Wait for process to terminate
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      process.kill(pid, 0);
+      // Process still running, wait
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    } catch (error) {
+      // Process terminated
+      console.log(chalk.green('Daemon stopped successfully'));
+      clearDaemonPid();
+      clearDaemonState();
+      return true;
+    }
+  }
+
+  // Timeout reached, force kill (always happens automatically)
+  console.log(chalk.yellow('Graceful shutdown timed out, forcing stop...'));
+  try {
+    process.kill(pid, 'SIGKILL');
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    clearDaemonPid();
+    clearDaemonState();
+    console.log(chalk.green('Daemon stopped'));
+    return true;
+  } catch (error) {
+    if (error.code === 'ESRCH') {
+      clearDaemonPid();
+      clearDaemonState();
+      return true;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Restart the daemon
+ * @param {Object} options - Restart options
+ * @returns {Promise<Object>} New daemon info
+ */
+export async function restartDaemon(options = {}) {
+  const state = getDaemonState();
+  const port = options.port || state?.port;
+
+  // Stop existing daemon if running
+  if (isDaemonRunning()) {
+    await stopDaemon({ force: false, timeout: 10000 });
+    // Wait a moment before restarting
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+
+  // Start new daemon
+  return startDaemon({ port });
+}
+
+/**
+ * Get daemon status
+ * @returns {Object} Daemon status
+ */
+export function getDaemonStatus() {
+  const state = getDaemonState();
+  const pid = getDaemonPid();
+  const running = isDaemonRunning();
+
+  if (!running && state) {
+    // Daemon died, clean up
+    clearDaemonPid();
+    clearDaemonState();
+    return {
+      running: false,
+      status: 'not_running',
+    };
+  }
+
+  if (!state) {
+    return {
+      running: false,
+      status: 'not_running',
+    };
+  }
+
+  // Calculate uptime
+  let uptime = null;
+  if (state.startTime) {
+    uptime = Date.now() - new Date(state.startTime).getTime();
+  }
+
+  return {
+    running: true,
+    status: state.status || 'running',
+    pid: state.pid,
+    port: state.port,
+    startTime: state.startTime,
+    uptime,
+    userEntityRef: state.userEntityRef,
+  };
+}
+
+/**
+ * Format uptime in human readable format
+ * @param {number} ms - Uptime in milliseconds
+ * @returns {string} Formatted uptime
+ */
+export function formatUptime(ms) {
+  if (!ms) return 'N/A';
+
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) {
+    return `${days}d ${hours % 24}h ${minutes % 60}m`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+
+export default {
+  startDaemon,
+  stopDaemon,
+  restartDaemon,
+  getDaemonStatus,
+  formatUptime,
+};

package/daemon/logManager.js

@@ -0,0 +1,227 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FENWAVE_DIR = path.join(os.homedir(), '.fenwave');
+const LOGS_DIR = path.join(FENWAVE_DIR, 'logs');
+
+// Log rotation settings
+const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB
+const MAX_LOG_FILES = 5;
+
+/**
+ * Ensure logs directory exists
+ */
+function ensureLogsDir() {
+  if (!fs.existsSync(LOGS_DIR)) {
+    fs.mkdirSync(LOGS_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Get path to log file
+ * @param {string} name - Log file name (without extension)
+ * @returns {string} Full path to log file
+ */
+export function getLogPath(name = 'agent') {
+  ensureLogsDir();
+  return path.join(LOGS_DIR, `${name}.log`);
+}
+
+/**
+ * Get path to error log file
+ * @returns {string} Full path to error log file
+ */
+export function getErrorLogPath() {
+  return getLogPath('agent.error');
+}
+
+/**
+ * Rotate log files if necessary
+ * @param {string} logPath - Path to log file
+ */
+export function rotateLogIfNeeded(logPath) {
+  try {
+    if (!fs.existsSync(logPath)) return;
+
+    const stats = fs.statSync(logPath);
+    if (stats.size < MAX_LOG_SIZE) return;
+
+    // Rotate existing files
+    for (let i = MAX_LOG_FILES - 1; i >= 1; i--) {
+      const oldPath = `${logPath}.${i}`;
+      const newPath = `${logPath}.${i + 1}`;
+      if (fs.existsSync(oldPath)) {
+        if (i === MAX_LOG_FILES - 1) {
+          // Delete oldest file
+          fs.unlinkSync(oldPath);
+        } else {
+          fs.renameSync(oldPath, newPath);
+        }
+      }
+    }
+
+    // Rename current log to .1
+    fs.renameSync(logPath, `${logPath}.1`);
+  } catch (error) {
+    console.error('Failed to rotate log:', error.message);
+  }
+}
+
+/**
+ * Write to log file with rotation
+ * @param {string} message - Message to log
+ * @param {string} level - Log level (info, warn, error)
+ */
+export function writeLog(message, level = 'info') {
+  const logPath = getLogPath();
+  rotateLogIfNeeded(logPath);
+
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+
+  try {
+    fs.appendFileSync(logPath, logLine);
+  } catch (error) {
+    // If main log fails, try to at least write to console
+    console.error('Failed to write to log file:', error.message);
+  }
+
+  // Also write errors to error log
+  if (level === 'error') {
+    const errorLogPath = getErrorLogPath();
+    rotateLogIfNeeded(errorLogPath);
+    try {
+      fs.appendFileSync(errorLogPath, logLine);
+    } catch (e) {
+      // Ignore
+    }
+  }
+}
+
+/**
+ * Create a logger instance for daemon use
+ * @returns {Object} Logger with info, warn, error methods
+ */
+export function createLogger() {
+  return {
+    info: (message) => writeLog(message, 'info'),
+    warn: (message) => writeLog(message, 'warn'),
+    error: (message) => writeLog(message, 'error'),
+    debug: (message) => {
+      if (process.env.DEBUG === 'true') {
+        writeLog(message, 'debug');
+      }
+    },
+  };
+}
+
+/**
+ * Read log file contents
+ * @param {number} lines - Number of lines to read from end (0 = all)
+ * @param {boolean} includeRotated - Include rotated log files
+ * @returns {string} Log content
+ */
+export function readLogs(lines = 100, includeRotated = false) {
+  const logPath = getLogPath();
+  let content = '';
+
+  try {
+    // Read rotated files first if requested
+    if (includeRotated) {
+      for (let i = MAX_LOG_FILES; i >= 1; i--) {
+        const rotatedPath = `${logPath}.${i}`;
+        if (fs.existsSync(rotatedPath)) {
+          content += fs.readFileSync(rotatedPath, 'utf8');
+        }
+      }
+    }
+
+    // Read current log file
+    if (fs.existsSync(logPath)) {
+      content += fs.readFileSync(logPath, 'utf8');
+    }
+
+    if (lines > 0) {
+      const allLines = content.split('\n');
+      return allLines.slice(-lines).join('\n');
+    }
+
+    return content;
+  } catch (error) {
+    return `Error reading logs: ${error.message}`;
+  }
+}
+
+/**
+ * Clear all log files
+ */
+export function clearLogs() {
+  const logPath = getLogPath();
+  const errorLogPath = getErrorLogPath();
+
+  try {
+    // Clear main log and rotated files
+    for (const basePath of [logPath, errorLogPath]) {
+      if (fs.existsSync(basePath)) {
+        fs.unlinkSync(basePath);
+      }
+      for (let i = 1; i <= MAX_LOG_FILES; i++) {
+        const rotatedPath = `${basePath}.${i}`;
+        if (fs.existsSync(rotatedPath)) {
+          fs.unlinkSync(rotatedPath);
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Failed to clear logs:', error.message);
+  }
+}
+
+/**
+ * Get logs directory path
+ * @returns {string} Path to logs directory
+ */
+export function getLogsDir() {
+  ensureLogsDir();
+  return LOGS_DIR;
+}
+
+/**
+ * List all log files
+ * @returns {Array<Object>} Array of log file info
+ */
+export function listLogFiles() {
+  ensureLogsDir();
+
+  try {
+    const files = fs.readdirSync(LOGS_DIR);
+    return files
+      .filter((f) => f.endsWith('.log') || f.match(/\.log\.\d+$/))
+      .map((f) => {
+        const filePath = path.join(LOGS_DIR, f);
+        const stats = fs.statSync(filePath);
+        return {
+          name: f,
+          path: filePath,
+          size: stats.size,
+          modified: stats.mtime,
+        };
+      })
+      .sort((a, b) => b.modified - a.modified);
+  } catch (error) {
+    return [];
+  }
+}
+
+export default {
+  getLogPath,
+  getErrorLogPath,
+  rotateLogIfNeeded,
+  writeLog,
+  createLogger,
+  readLogs,
+  clearLogs,
+  getLogsDir,
+  listLogFiles,
+};