@oussema_mili/test-pkg-123 1.1.41 → 1.1.43

package/cli-commands.js

@@ -893,27 +893,11 @@ function setupCLICommands(program, startServerFunction) {
           { timeout: 10000 },
         );
 
-        // Debug: Log the actual response
-        console.log(chalk.gray('\n   Debug - Backend response:'), JSON.stringify(response.data, null, 2));
-
-        // Try to get userEntityRef from backend, fallback to session, then "unknown"
-        let userEntityRef = response.data.userEntityRef;
-        
-        if (!userEntityRef || userEntityRef === 'unknown') {
-          const session = loadSession();
-          if (session && isSessionValid(session) && session.userEntityRef) {
-            userEntityRef = session.userEntityRef;
-            console.log(chalk.gray('   Using userEntityRef from session: ' + userEntityRef));
-          } else {
-            userEntityRef = "unknown";
-          }
-        }
-
         // Save credentials
         saveDeviceCredential({
           deviceId: response.data.deviceId,
           deviceCredential: response.data.deviceCredential,
-          userEntityRef: userEntityRef,
+          userEntityRef: response.data.userEntityRef || "unknown",
           deviceName: deviceMetadata.deviceName,
           platform: deviceMetadata.platform,
           agentVersion: deviceMetadata.agentVersion,

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 } 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,26 @@ 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);
+          console.log(chalk.blue(`📍 Auto-assigned container port: ${APP_PORT}`));
+        } catch (error) {
+          throw new Error(`Failed to find available container port: ${error.message}`);
+        }
+      }
+
       // Check Docker availability
       const dockerAvailable = await this.checkDockerAvailable();
       if (!dockerAvailable) {
@@ -223,13 +256,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 +309,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,14 +313,19 @@ export async function runAgent(options = {}) {
   // Initialize registry store
   await registryStore.initialize();
 
-  // Start container
+  // Start container with dynamic ports
   log('Starting container...');
+  let actualContainerPort = preferredContainerPort;
   try {
-    await containerManager.startContainer();
-    log('Container started successfully');
+    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('Starting agent without container...');
+    actualContainerPort = preferredContainerPort || DEFAULT_CONTAINER_PORT;
   }
 
   // Create HTTP server with download endpoint handler
@@ -393,6 +406,7 @@ export async function runAgent(options = {}) {
         saveDaemonState({
           pid: process.pid,
           port: actualPort,
+          containerPort: actualContainerPort,
           startTime: new Date().toISOString(),
           status: 'running',
           userEntityRef: session.userEntityRef,
@@ -435,7 +449,7 @@ export async function runAgent(options = {}) {
         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.41",
+  "version": "1.1.43",
   "description": "Fenwave Docker Agent and CLI",
   "keywords": [
     "fenwave",

package/setup/setupWizard.js

@@ -6,7 +6,6 @@ import {
   displayPrerequisites,
   getMissingPrerequisites,
 } from "../utils/prerequisites.js";
-import { loadSession, isSessionValid } from "../auth.js";
 import {
   promptRegistrationToken,
   promptConfirmation,
@@ -255,27 +254,11 @@ export class SetupWizard {
         { timeout: 10000 }
       );
 
-      // Debug: Log the actual response to understand what backend returns
-      console.log(chalk.gray('   Debug - Backend response:'), JSON.stringify(response.data, null, 2));
-
-      // Try to get userEntityRef from backend, fallback to session, then "unknown"
-      let userEntityRef = response.data.userEntityRef;
-      
-      if (!userEntityRef || userEntityRef === 'unknown') {
-        const session = loadSession();
-        if (session && isSessionValid(session) && session.userEntityRef) {
-          userEntityRef = session.userEntityRef;
-          console.log(chalk.gray('   Using userEntityRef from session: ' + userEntityRef));
-        } else {
-          userEntityRef = "unknown";
-        }
-      }
-
       return {
         deviceId: response.data.deviceId,
         deviceCredential: response.data.deviceCredential,
         registryConfig: response.data.registryConfig,
-        userEntityRef: userEntityRef,
+        userEntityRef: response.data.userEntityRef || "unknown",
       };
     } catch (error) {
       if (error.response?.status === 401) {
@@ -384,22 +367,11 @@ export class SetupWizard {
     console.log("");
     displayHeader("Setup Summary");
 
-    // Use session userEntityRef if device credential has unknown
-    let displayUser = registrationData.userEntityRef;
-    if (!displayUser || displayUser === "unknown") {
-      const session = loadSession();
-      if (session && isSessionValid(session) && session.userEntityRef) {
-        displayUser = session.userEntityRef;
-      } else {
-        displayUser = "N/A";
-      }
-    }
-
     displayKeyValue({
       "Device ID": registrationData.deviceId,
       "Device Name": registrationData.deviceName || "N/A",
       Platform: registrationData.platform || "N/A",
-      User: displayUser,
+      User: registrationData.userEntityRef || "N/A",
     });
 
     console.log("");

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,37 @@ 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 = 10) {
+  return findAvailablePort(startPort, maxAttempts);
+}
+
+/**
+ * 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": {},
-  },
-};