@oussema_mili/test-pkg-123 1.1.22

package/daemon/agentRunner.js

@@ -0,0 +1,429 @@
+import http from 'http';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import chalk from 'chalk';
+import axios from 'axios';
+import { v4 as uuidv4 } from 'uuid';
+
+import { setupWebSocketServer, readWsToken } from '../websocket-server.js';
+import containerManager from '../containerManager.js';
+import registryStore from '../store/registryStore.js';
+import agentStore from '../store/agentStore.js';
+import { loadConfig } from '../store/configStore.js';
+import { initializeAgentStartTime } from '../docker-actions/general.js';
+import { checkAppHasBeenRun } from '../docker-actions/apps.js';
+import {
+  loadSession,
+  isSessionValid,
+  handleSessionExpiry,
+  setupSessionWatcher,
+} from '../auth.js';
+import { findAvailablePort } from '../utils/portUtils.js';
+import {
+  saveDaemonState,
+  updateDaemonState,
+  clearDaemonState,
+  saveDaemonPid,
+  clearDaemonPid,
+  acquireLock,
+  releaseLock,
+} from '../store/daemonStore.js';
+import { createLogger, writeLog } from './logManager.js';
+
+// Load configuration
+const config = loadConfig();
+const BACKEND_URL = config.backendUrl;
+const CONTAINER_PORT = config.containerPort;
+
+// Store active connections
+const clients = new Map();
+
+// Server instances for cleanup
+let serverInstances = null;
+
+// Logger for daemon mode
+const logger = createLogger();
+
+/**
+ * Log message to both console and file
+ */
+function log(message, level = 'info') {
+  const coloredMessage =
+    level === 'error'
+      ? chalk.red(message)
+      : level === 'warn'
+      ? chalk.yellow(message)
+      : chalk.blue(message);
+
+  console.log(coloredMessage);
+  writeLog(message, level);
+}
+
+/**
+ * Acknowledge a version_published event
+ */
+async function acknowledgeVersionPublishedEvent(sessionToken, eventId, changeId) {
+  try {
+    await axios.post(
+      `${BACKEND_URL}/api/agent-cli/acknowledge-event`,
+      {
+        token: sessionToken,
+        eventId: eventId,
+        changeId: changeId,
+      },
+      {
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 5000,
+      }
+    );
+  } catch (error) {
+    log(`Failed to acknowledge event ${changeId}: ${error.message}`, 'warn');
+  }
+}
+
+/**
+ * Poll for app update events and broadcast to connected clients
+ */
+async function pollAppUpdates(sessionToken, wss) {
+  try {
+    const response = await axios.post(
+      `${BACKEND_URL}/api/agent-cli/poll-events`,
+      { token: sessionToken },
+      {
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 10000,
+      }
+    );
+
+    if (response.data?.events?.length > 0) {
+      const events = response.data.events;
+      let broadcastedCount = 0;
+
+      for (const event of events) {
+        const eventType = event.event_type || 'blueprint_changed';
+
+        if (eventType === 'blueprint_changed') {
+          const hasBeenRun = await checkAppHasBeenRun(event.app_name);
+          if (!hasBeenRun) {
+            acknowledgeVersionPublishedEvent(sessionToken, event.id, event.change_id);
+            continue;
+          }
+        }
+
+        broadcastedCount++;
+
+        const message = JSON.stringify({
+          type: eventType,
+          appId: event.app_id,
+          fwId: event.app_id,
+          appName: event.app_name,
+          version: event.version,
+          changeId: event.change_id,
+          timestamp: event.created_at,
+          actor: event.actor,
+          changedAt: event.created_at,
+        });
+
+        wss.clients.forEach((client) => {
+          if (client.readyState === 1) {
+            client.send(message);
+          }
+        });
+
+        if (eventType === 'version_published') {
+          setTimeout(() => {
+            acknowledgeVersionPublishedEvent(sessionToken, event.id, event.change_id);
+          }, 2000);
+        }
+      }
+
+      if (broadcastedCount > 0) {
+        log(
+          `Received ${broadcastedCount} app update ${broadcastedCount === 1 ? "event" : "events"}`,
+        );
+      }
+    }
+  } catch (error) {
+    if (error.response?.status !== 401) {
+      const isConnRefused =
+        error.message?.includes('ECONNREFUSED') || error.code === 'ECONNREFUSED';
+
+      if (isConnRefused) {
+        log('App update polling error: Please ensure Fenwave is running.', 'error');
+      } else {
+        log(`App update polling error: ${error.message}`, 'error');
+      }
+    }
+  }
+}
+
+/**
+ * Start periodic polling for app updates
+ */
+function startAppUpdatePolling(sessionToken, wss) {
+  const pollInterval = setInterval(() => {
+    pollAppUpdates(sessionToken, wss);
+  }, 30000);
+
+  log('Started polling for app updates (every 30 seconds)');
+  return pollInterval;
+}
+
+/**
+ * Enhanced graceful shutdown with connection draining
+ */
+async function gracefulShutdown(signal = 'SIGTERM', drainTimeout = 10000) {
+  log(`Agent received ${signal}, initiating graceful shutdown...`);
+
+  // Update daemon state to indicate shutdown
+  updateDaemonState({ status: 'shutting_down' });
+
+  if (serverInstances) {
+    // Clear polling interval
+    if (serverInstances.pollInterval) {
+      clearInterval(serverInstances.pollInterval);
+    }
+
+    // Close session watcher
+    if (serverInstances.sessionWatcher) {
+      serverInstances.sessionWatcher.close();
+    }
+
+    // Notify clients about shutdown with reconnect hint
+    if (serverInstances.wss) {
+      const shutdownMessage = JSON.stringify({
+        type: 'agent_shutdown',
+        message: 'Agent is shutting down',
+        reconnectAfter: 5000, // Hint to reconnect after 5 seconds
+      });
+
+      serverInstances.wss.clients.forEach((client) => {
+        try {
+          client.send(shutdownMessage);
+        } catch (e) {
+          // Ignore send errors during shutdown
+        }
+      });
+
+      // Wait for active operations to complete (connection draining)
+      log(`Waiting up to ${drainTimeout / 1000}s for active operations...`);
+
+      await new Promise((resolve) => {
+        const drainTimer = setTimeout(resolve, drainTimeout);
+
+        // Check if all clients have disconnected
+        const checkInterval = setInterval(() => {
+          if (serverInstances.wss.clients.size === 0) {
+            clearInterval(checkInterval);
+            clearTimeout(drainTimer);
+            resolve();
+          }
+        }, 500);
+      });
+
+      // Close remaining connections
+      serverInstances.wss.clients.forEach((client) => {
+        client.close();
+      });
+      serverInstances.wss.close();
+    }
+
+    // Close HTTP server
+    if (serverInstances.server) {
+      serverInstances.server.close();
+    }
+  }
+
+  // Clear agent info
+  try {
+    await agentStore.clearAgentInfo();
+  } catch (err) {
+    log(`Failed to clear agent info: ${err.message}`, 'warn');
+  }
+
+  // Stop container
+  try {
+    await containerManager.stopContainerGracefully();
+  } catch (error) {
+    log(`Error stopping container: ${error.message}`, 'warn');
+  }
+
+  // Clean up daemon files
+  clearDaemonState();
+  clearDaemonPid();
+  releaseLock();
+
+  log('Agent shutdown complete');
+  process.exit(0);
+}
+
+/**
+ * Run the agent in the current process
+ * @param {Object} options - Options
+ * @param {number} options.preferredPort - Preferred WebSocket port
+ * @param {boolean} options.isDaemon - Whether running as daemon
+ * @returns {Promise<Object>} Server instances
+ */
+export async function runAgent(options = {}) {
+  const { preferredPort = config.wsPort, isDaemon = false } = options;
+
+  // Check for existing session
+  log('Checking for existing session...');
+  const session = loadSession();
+
+  if (!session) {
+    log('No session found. Please run "fenwave login" first.', 'error');
+    throw new Error('No session found. Please run "fenwave login" first.');
+  }
+
+  if (!isSessionValid(session)) {
+    log('Session has expired. Please run "fenwave login" again.', 'error');
+    throw new Error('Session expired. Please run "fenwave login" again.');
+  }
+
+  log(`Found valid session for ${session.userEntityRef}`);
+
+  // Acquire lock for single instance enforcement
+  if (!acquireLock()) {
+    log('Another instance of the agent is already running.', 'error');
+    throw new Error('Another instance of the agent is already running.');
+  }
+
+  // Find available port
+  let actualPort;
+  try {
+    actualPort = await findAvailablePort(preferredPort);
+    if (actualPort !== preferredPort) {
+      log(`Port ${preferredPort} is in use, using port ${actualPort}`, 'warn');
+    }
+  } catch (error) {
+    releaseLock();
+    throw error;
+  }
+
+  // Initialize registry store
+  await registryStore.initialize();
+
+  // Start container
+  log('Starting container...');
+  try {
+    await containerManager.startContainer();
+    log('Container started successfully');
+  } catch (containerError) {
+    log(`Failed to start container: ${containerError.message}`, 'warn');
+    log('Starting agent without container...');
+  }
+
+  // Create HTTP server
+  const agentId = uuidv4();
+  const existingWsToken = readWsToken();
+  const server = http.createServer();
+
+  return new Promise((resolve, reject) => {
+    server.listen(actualPort, async () => {
+      try {
+        // Initialize agent start time
+        await initializeAgentStartTime();
+
+        // Save daemon state
+        saveDaemonPid(process.pid);
+        saveDaemonState({
+          pid: process.pid,
+          port: actualPort,
+          startTime: new Date().toISOString(),
+          status: 'running',
+          userEntityRef: session.userEntityRef,
+          isDaemon,
+        });
+
+        // Setup WebSocket server
+        const wss = setupWebSocketServer(
+          server,
+          clients,
+          agentId,
+          {
+            userEntityRef: session.userEntityRef,
+            expiresAt: session.expiresAt,
+          },
+          existingWsToken
+        );
+
+        // Setup session watcher
+        const sessionWatcher = setupSessionWatcher(handleSessionExpiry, server, wss);
+
+        // Start app update polling
+        const pollInterval = startAppUpdatePolling(session.token, wss);
+
+        // Store server instances for cleanup
+        serverInstances = {
+          server,
+          wss,
+          sessionToken: session.token,
+          userEntityRef: session.userEntityRef,
+          agentId,
+          sessionWatcher,
+          pollInterval,
+        };
+
+        // Display startup info
+        console.log(
+          chalk.green('\n' + '='.repeat(66))
+        );
+        console.log(chalk.green('  Fenwave Agent Started Successfully'));
+        console.log(chalk.green('='.repeat(66) + '\n'));
+        console.log(chalk.white('  Fenwave DevApp Dashboard:'));
+        console.log(chalk.cyan(`    http://localhost:${CONTAINER_PORT}\n`));
+        console.log(chalk.white('  WebSocket Server:'));
+        console.log(chalk.cyan(`    ws://localhost:${actualPort}\n`));
+        console.log(chalk.white('  User:'));
+        console.log(chalk.cyan(`    ${session.userEntityRef}\n`));
+        if (isDaemon) {
+          console.log(chalk.white('  Mode:'));
+          console.log(chalk.cyan('    Background daemon\n'));
+        }
+        console.log(chalk.green('='.repeat(66) + '\n'));
+
+        log('Agent is ready to receive connections');
+
+        resolve(serverInstances);
+      } catch (error) {
+        log(`Failed to setup WebSocket server: ${error.message}`, 'error');
+        releaseLock();
+        reject(error);
+      }
+    });
+
+    server.on('error', (error) => {
+      log(`Server error: ${error.message}`, 'error');
+      releaseLock();
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Setup signal handlers for graceful shutdown
+ */
+export function setupSignalHandlers() {
+  process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+  process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+}
+
+/**
+ * Get current server instances
+ * @returns {Object|null} Server instances
+ */
+export function getServerInstances() {
+  return serverInstances;
+}
+
+export { clients, gracefulShutdown };
+
+export default {
+  runAgent,
+  setupSignalHandlers,
+  getServerInstances,
+  gracefulShutdown,
+  clients,
+};

package/daemon/daemonEntry.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+/**
+ * Daemon Entry Point
+ *
+ * This script is spawned as a detached child process when running
+ * "fenwave service start". It runs the agent in daemon mode.
+ */
+
+import { runAgent, setupSignalHandlers } from './agentRunner.js';
+import { writeLog } from './logManager.js';
+import { loadConfig } from '../store/configStore.js';
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {};
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--port' && args[i + 1]) {
+      options.port = parseInt(args[i + 1], 10);
+      i++;
+    }
+  }
+
+  return options;
+}
+
+async function main() {
+  const options = parseArgs();
+  const config = loadConfig();
+
+  writeLog('Daemon starting...');
+  writeLog(`PID: ${process.pid}`);
+  writeLog(`Preferred port: ${options.port || config.wsPort}`);
+
+  // Setup signal handlers
+  setupSignalHandlers();
+
+  // Handle uncaught exceptions
+  process.on('uncaughtException', (error) => {
+    writeLog(`Uncaught exception: ${error.message}`, 'error');
+    writeLog(error.stack, 'error');
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', (reason, promise) => {
+    writeLog(`Unhandled rejection: ${reason}`, 'error');
+  });
+
+  try {
+    await runAgent({
+      preferredPort: options.port || config.wsPort,
+      isDaemon: true,
+    });
+
+    writeLog('Daemon started successfully');
+  } catch (error) {
+    writeLog(`Daemon failed to start: ${error.message}`, 'error');
+    process.exit(1);
+  }
+}
+
+main();