@oussema_mili/test-pkg-123 1.1.42 → 1.1.44

package/containerManager.js

@@ -2,9 +2,11 @@ import os from 'os';
 import { spawn, exec } from 'child_process';
 import path from 'path';
 import chalk from 'chalk';
-import { loadConfig } from './store/configStore.js';
+import { loadConfig, DEFAULT_WS_PORT, DEFAULT_CONTAINER_PORT } from './store/configStore.js';
+import { getDaemonState } from './store/daemonStore.js';
+import { findAvailableContainerPort, isPortAvailable } from './utils/portUtils.js';
 
-// Load configuration
+// Load static configuration (ports are resolved dynamically)
 const config = loadConfig();
 const CONTAINER_NAME = config.containerName;
 const AGENT_ROOT_DIR = config.agentRootDir;
@@ -13,10 +15,24 @@ const HOST_DATA_DIR = path.join(os.homedir(), AGENT_ROOT_DIR, REGISTRIES_DIR);
 const HOST_FW_DIR = path.join(os.homedir(), AGENT_ROOT_DIR);
 const CONTAINER_DATA_DIR = config.containerDataDir;
 const CONTAINER_FW_DIR = '/app/.fenwave';
-const APP_PORT = config.containerPort;
-const WS_PORT = config.wsPort;
 const DOCKER_IMAGE = config.dockerImage;
 
+/**
+ * Get the current WebSocket port (from daemon state or config)
+ */
+function getCurrentWsPort() {
+  const state = getDaemonState();
+  return state?.port || config.wsPort || DEFAULT_WS_PORT;
+}
+
+/**
+ * Get the current container port (from daemon state or config)
+ */
+function getCurrentContainerPort() {
+  const state = getDaemonState();
+  return state?.containerPort || config.containerPort || DEFAULT_CONTAINER_PORT;
+}
+
 /**
  * Container Manager for Fenwave DevApp
  */
@@ -147,9 +163,37 @@ class ContainerManager {
 
   /**
    * Start the Fenwave DevApp container
+   * @param {Object} options - Start options
+   * @param {number} options.wsPort - WebSocket port to connect to
+   * @param {number} options.containerPort - Port to expose the container on (0 for auto-assign)
    */
-  async startContainer() {
+  async startContainer(options = {}) {
     try {
+      // Get ports - use provided values, daemon state, config, or defaults
+      const WS_PORT = options.wsPort || getCurrentWsPort();
+      let APP_PORT = options.containerPort || getCurrentContainerPort();
+
+      // If containerPort is 0, find an available port
+      if (APP_PORT === 0) {
+        try {
+          APP_PORT = await findAvailableContainerPort(DEFAULT_CONTAINER_PORT, 100, [WS_PORT]);
+          console.log(chalk.blue(`📍 Auto-assigned container port: ${APP_PORT}`));
+        } catch (error) {
+          throw new Error(`Failed to find available container port: ${error.message}`);
+        }
+      }
+
+      // If the desired container port conflicts with the WebSocket port or is unavailable, pick another port
+      if (APP_PORT === WS_PORT || !(await isPortAvailable(APP_PORT))) {
+        try {
+          const newPort = await findAvailableContainerPort(DEFAULT_CONTAINER_PORT, 100, [WS_PORT]);
+          console.log(chalk.yellow(`⚠️  Desired container port ${APP_PORT} is unavailable or conflicts with WebSocket port ${WS_PORT}. Using ${newPort} instead.`));
+          APP_PORT = newPort;
+        } catch (err) {
+          throw new Error(`Failed to resolve container port conflict: ${err.message}`);
+        }
+      }
+
       // Check Docker availability
       const dockerAvailable = await this.checkDockerAvailable();
       if (!dockerAvailable) {
@@ -223,13 +267,14 @@ class ContainerManager {
         runProcess.on('close', (code) => {
           if (code === 0) {
             this.isRunning = true;
+            this.currentContainerPort = APP_PORT; // Store the actual port used
             console.log(chalk.green('✅ Container started successfully'));
             console.log(chalk.gray(`   Image: ${DOCKER_IMAGE}`));
             console.log(chalk.gray(`   Container: ${CONTAINER_NAME}`));
             console.log(chalk.gray(`   Port: ${APP_PORT}`));
             console.log(chalk.gray(`   Data volume: ${HOST_DATA_DIR} -> ${CONTAINER_DATA_DIR}`));
             console.log(chalk.gray(`   Token volume: ${HOST_FW_DIR} -> ${CONTAINER_FW_DIR}`));
-            resolve();
+            resolve(APP_PORT); // Return the actual port used
           } else {
             console.error(chalk.red('❌ Failed to start container:'));
             if (errorOutput) {
@@ -275,11 +320,19 @@ class ContainerManager {
     return {
       isRunning: running,
       containerName: CONTAINER_NAME,
-      port: APP_PORT,
+      port: this.currentContainerPort || getCurrentContainerPort(),
       dataDirectory: HOST_DATA_DIR,
     };
   }
 
+  /**
+   * Get the current container port
+   * @returns {number} The current container port
+   */
+  getContainerPort() {
+    return this.currentContainerPort || getCurrentContainerPort();
+  }
+
   /**
    * Show container logs
    */

package/daemon/agentRunner.js

@@ -10,7 +10,7 @@ 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 { loadConfig, DEFAULT_WS_PORT, DEFAULT_CONTAINER_PORT } from '../store/configStore.js';
 import { initializeAgentStartTime } from '../docker-actions/general.js';
 import { checkAppHasBeenRun } from '../docker-actions/apps.js';
 import {
@@ -34,7 +34,6 @@ 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();
@@ -261,12 +260,17 @@ async function gracefulShutdown(signal = 'SIGTERM', drainTimeout = 10000) {
 /**
  * Run the agent in the current process
  * @param {Object} options - Options
- * @param {number} options.preferredPort - Preferred WebSocket port
+ * @param {number} options.preferredPort - Preferred WebSocket port (0 for auto-assign)
+ * @param {number} options.preferredContainerPort - Preferred container port (0 for auto-assign)
  * @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;
+  const { 
+    preferredPort = config.wsPort || DEFAULT_WS_PORT, 
+    preferredContainerPort = config.containerPort || DEFAULT_CONTAINER_PORT,
+    isDaemon = false 
+  } = options;
 
   // Check for existing session
   log('Checking for existing session...');
@@ -290,12 +294,16 @@ export async function runAgent(options = {}) {
     throw new Error('Another instance of the agent is already running.');
   }
 
-  // Find available port
+  // Find available port for WebSocket
   let actualPort;
   try {
-    actualPort = await findAvailablePort(preferredPort);
-    if (actualPort !== preferredPort) {
+    // If preferredPort is 0, find any available port starting from default
+    const startPort = preferredPort === 0 ? DEFAULT_WS_PORT : preferredPort;
+    actualPort = await findAvailablePort(startPort);
+    if (actualPort !== preferredPort && preferredPort !== 0) {
       log(`Port ${preferredPort} is in use, using port ${actualPort}`, 'warn');
+    } else if (preferredPort === 0) {
+      log(`Auto-assigned WebSocket port: ${actualPort}`);
     }
   } catch (error) {
     releaseLock();
@@ -305,16 +313,6 @@ export async function runAgent(options = {}) {
   // 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 with download endpoint handler
   const agentId = uuidv4();
   const existingWsToken = readWsToken();
@@ -388,13 +386,14 @@ export async function runAgent(options = {}) {
         // Initialize agent start time
         await initializeAgentStartTime();
 
-        // Save daemon state
+        // Save daemon pid and preliminary state (containerPort updated after container start)
         saveDaemonPid(process.pid);
         saveDaemonState({
           pid: process.pid,
           port: actualPort,
+          containerPort: null,
           startTime: new Date().toISOString(),
-          status: 'running',
+          status: 'starting',
           userEntityRef: session.userEntityRef,
           isDaemon,
         });
@@ -428,14 +427,34 @@ export async function runAgent(options = {}) {
           pollInterval,
         };
 
+        // Now that WebSocket is bound, start container (so it cannot take the WS port)
+        log('Starting container (after WebSocket bind)...');
+        let actualContainerPort = preferredContainerPort;
+        try {
+          actualContainerPort = await containerManager.startContainer({
+            wsPort: actualPort,
+            containerPort: preferredContainerPort,
+          });
+          log(`Container started successfully on port ${actualContainerPort}`);
+        } catch (containerError) {
+          log(`Failed to start container: ${containerError.message}`, 'warn');
+          log('Continuing without container...');
+          actualContainerPort = preferredContainerPort || DEFAULT_CONTAINER_PORT;
+        }
+
+        // Update daemon state now that containerPort is known
+        updateDaemonState({
+          port: actualPort,
+          containerPort: actualContainerPort,
+          status: 'running',
+        });
+
         // Display startup info
-        console.log(
-          chalk.green('\n' + '='.repeat(66))
-        );
+        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.cyan(`    http://localhost:${actualContainerPort}\n`));
         console.log(chalk.white('  WebSocket Server:'));
         console.log(chalk.cyan(`    ws://localhost:${actualPort}\n`));
         console.log(chalk.white('  User:'));

package/dist/styles.css

@@ -179,6 +179,9 @@
   .relative {
     position: relative;
   }
+  .static {
+    position: static;
+  }
   .container {
     width: 100%;
     @media (width >= 40rem) {

package/docker-actions/volumes.js

@@ -5,7 +5,7 @@ import util from 'util';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { loadConfig } from '../store/configStore.js';
+import { loadConfig, DEFAULT_WS_PORT } from '../store/configStore.js';
 import { getDaemonState } from '../store/daemonStore.js';
 
 const execPromise = util.promisify(exec);
@@ -23,7 +23,7 @@ function getAgentPort() {
     return state.port;
   }
   const config = loadConfig();
-  return config.wsPort || 3001;
+  return config.wsPort || DEFAULT_WS_PORT;
 }
 
 // Cache for docker system df result to avoid concurrent operations

package/index.html

@@ -12,6 +12,10 @@
     <script>
       // Store WebSocket token in localStorage for App Builder to use
       // These values are injected by the agent server
+      // Default ports: WS=3001, Container=3003 (may vary if ports are in use)
+      const DEFAULT_WS_PORT = "3001";
+      const DEFAULT_CONTAINER_PORT = "3003";
+      
       const wsToken = new URLSearchParams(window.location.search).get(
         "wsToken",
       );
@@ -22,8 +26,8 @@
 
       if (wsToken) {
         localStorage.setItem("fenwave-ws-token", wsToken);
-        localStorage.setItem("fenwave-ws-port", wsPort || "3001");
-        localStorage.setItem("fenwave-container-port", containerPort || "3003");
+        localStorage.setItem("fenwave-ws-port", wsPort || DEFAULT_WS_PORT);
+        localStorage.setItem("fenwave-container-port", containerPort || DEFAULT_CONTAINER_PORT);
       }
     </script>
     <style>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oussema_mili/test-pkg-123",
-  "version": "1.1.42",
+  "version": "1.1.44",
   "description": "Fenwave Docker Agent and CLI",
   "keywords": [
     "fenwave",

package/store/configStore.js

@@ -6,6 +6,13 @@ 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 port values (used when no port is specified)
+ * Set to 0 to use a random available port
+ */
+export const DEFAULT_WS_PORT = 3001;
+export const DEFAULT_CONTAINER_PORT = 3003;
+
 /**
  * Default configuration values
  */
@@ -16,16 +23,16 @@ const DEFAULT_CONFIG = {
 
   // Container Configuration
   containerName: "fenwave-devapp",
-  containerPort: 3003,
-  wsPort: 3001,
+  containerPort: DEFAULT_CONTAINER_PORT,
+  wsPort: DEFAULT_WS_PORT,
 
   // Directory Configuration
   agentRootDir: ".fenwave",
   registriesDir: "registries",
   containerDataDir: "/data",
 
-  // Docker Image (GHCR - public registry, no auth required)
-  dockerImage: "ghcr.io/fenleap/fenwave/dev-app:latest",
+  // Docker Image (Docker Hub - testing, will be moved to GHCR later)
+  dockerImage: "oussemamili/dev-app:latest",
 
   // Other Settings
   authTimeoutMs: 60000,

package/utils/envSetup.js

@@ -22,10 +22,13 @@ export function ensureEnvironmentFiles(agentDir, showFoundMessages = false) {
   // Check and create .env.agent for agent if not exists
   const agentEnvPath = path.join(fenwareConfigDir, ".env.agent");
   if (!fs.existsSync(agentEnvPath)) {
+    // Note: WS_PORT and CONTAINER_PORT can be set to 0 for auto-assignment
+    // or left empty to use defaults (3001 and 3003)
     const defaultAgentEnv = `BACKEND_URL=http://localhost:7007
 FRONTEND_URL=http://localhost:3000
-WS_PORT=3001
-CONTAINER_PORT=3003
+# Port configuration (leave empty for defaults: 3001/3003, set to 0 for random available port)
+WS_PORT=
+CONTAINER_PORT=
 AGENT_ROOT_DIR=.fenwave
 REGISTRIES_DIR=registries
 AUTH_TIMEOUT_MS=60000

package/utils/portUtils.js

@@ -1,5 +1,9 @@
 import net from 'net';
 
+// Default ports (can be overridden via environment or config)
+export const DEFAULT_WS_PORT = 3001;
+export const DEFAULT_CONTAINER_PORT = 3003;
+
 /**
  * Check if a port is available
  * @param {number} port - Port number to check
@@ -28,12 +32,12 @@ export async function isPortAvailable(port) {
 
 /**
  * Find an available port starting from a given port
- * @param {number} startPort - Starting port number (default: 3001)
+ * @param {number} startPort - Starting port number (default: DEFAULT_WS_PORT)
  * @param {number} maxAttempts - Maximum number of ports to try (default: 10)
  * @returns {Promise<number>} Available port number
  * @throws {Error} If no available port found in range
  */
-export async function findAvailablePort(startPort = 3001, maxAttempts = 10) {
+export async function findAvailablePort(startPort = DEFAULT_WS_PORT, maxAttempts = 10) {
   for (let i = 0; i < maxAttempts; i++) {
     const port = startPort + i;
     if (await isPortAvailable(port)) {
@@ -52,8 +56,44 @@ export async function isPortInUse(port) {
   return !(await isPortAvailable(port));
 }
 
+/**
+ * Find an available port for container, starting from a given port
+ * @param {number} startPort - Starting port number (default: DEFAULT_CONTAINER_PORT)
+ * @param {number} maxAttempts - Maximum number of ports to try (default: 10)
+ * @returns {Promise<number>} Available port number
+ */
+export async function findAvailableContainerPort(startPort = DEFAULT_CONTAINER_PORT, maxAttempts = 100, excludePorts = []) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (excludePorts && excludePorts.includes(port)) continue;
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available container port found in range ${startPort}-${startPort + maxAttempts - 1}`);
+}
+
+/**
+ * Find a random available port in the ephemeral range
+ * @returns {Promise<number>} Available port number
+ */
+export async function findRandomAvailablePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+    server.on('error', reject);
+  });
+}
+
 export default {
   isPortAvailable,
   findAvailablePort,
+  findAvailableContainerPort,
+  findRandomAvailablePort,
   isPortInUse,
+  DEFAULT_WS_PORT,
+  DEFAULT_CONTAINER_PORT,
 };

package/postcss.config.mjs

@@ -1,5 +0,0 @@
-export default {
-  plugins: {
-    "@tailwindcss/postcss": {},
-  },
-};