@oussema_mili/test-pkg-123 1.1.22

package/LICENSE

@@ -0,0 +1,29 @@
+Copyright (c) 2025 Fenwave (Fenleap). All Rights Reserved.
+
+PROPRIETARY SOFTWARE LICENSE
+
+This software and associated documentation files (the "Software") are the
+proprietary property of Fenwave (Fenleap) and are protected by copyright law.
+
+TERMS AND CONDITIONS:
+
+1. LICENSE GRANT: Fenwave grants authorized customers a limited, non-exclusive,
+   non-transferable license to use the Software solely for their internal
+   business purposes in connection with Fenwave services.
+
+2. RESTRICTIONS: You may NOT:
+   - Copy, modify, or distribute the Software
+   - Reverse engineer, decompile, or disassemble the Software
+   - Create derivative works based on the Software
+   - Sublicense, rent, lease, or lend the Software
+   - Use the Software for any purpose other than as authorized by Fenwave
+
+3. OWNERSHIP: Fenwave retains all right, title, and interest in and to the
+   Software, including all intellectual property rights.
+
+4. NO WARRANTY: THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
+
+5. LIMITATION OF LIABILITY: IN NO EVENT SHALL FENWAVE BE LIABLE FOR ANY
+   DAMAGES ARISING FROM THE USE OF THIS SOFTWARE.
+
+For licensing inquiries, contact: support@fenwave.com

package/README.md

@@ -0,0 +1,220 @@
+# Fenwave Agent
+
+The Fenwave Agent is a CLI tool for managing Docker containers and local development environments. It integrates with the Fenwave platform for seamless developer experience.
+
+## Prerequisites
+
+- **Docker Desktop** (version 20.10 or later)
+- **Node.js** (version 20 or later)
+- **Fenwave Platform Access** - Valid credentials from your organization
+
+## Installation
+
+```bash
+npm install -g @fenwave/agent
+```
+
+## Quick Start
+
+### 1. Initialize the Agent
+
+Get your registration token from the Fenwave platform, then run:
+
+```bash
+fenwave init --token <your-registration-token>
+```
+
+### 2. Authenticate
+
+```bash
+fenwave login
+```
+
+This opens a browser for authentication. After successful auth, you'll be prompted to start the agent.
+
+### 3. Start the Agent
+
+**Background mode (recommended for production):**
+```bash
+fenwave service start
+```
+
+**Foreground mode (for development):**
+```bash
+fenwave service run
+```
+
+### 4. Access the Dashboard
+
+Open your browser to `http://localhost:3003`
+
+## Commands
+
+### Authentication
+
+| Command | Description |
+|---------|-------------|
+| `fenwave login` | Authenticate with Backstage (does not start agent) |
+| `fenwave logout` | Clear session and stop agent if running |
+| `fenwave status` | Check agent and registration status |
+
+### Service Management
+
+| Command | Description |
+|---------|-------------|
+| `fenwave service start` | Start agent as background daemon |
+| `fenwave service run` | Run agent in foreground (for development) |
+| `fenwave service stop` | Stop the running daemon |
+| `fenwave service restart` | Restart the daemon |
+| `fenwave service status` | Show daemon status (PID, port, uptime) |
+| `fenwave service logs` | View daemon logs |
+| `fenwave service logs -f` | Follow daemon logs in real-time |
+
+### Setup & Configuration
+
+| Command | Description |
+|---------|-------------|
+| `fenwave init` | Interactive setup wizard |
+| `fenwave register` | Register device with Backstage |
+| `fenwave rotate-credentials` | Rotate device credentials |
+| `fenwave uninstall` | Uninstall agent and clean up |
+
+### Container Management
+
+| Command | Description |
+|---------|-------------|
+| `fenwave containers` | List containers |
+| `fenwave start <id>` | Start container(s) |
+| `fenwave stop <id>` | Stop container(s) |
+| `fenwave restart <id>` | Restart container(s) |
+| `fenwave rm <id>` | Remove container(s) |
+| `fenwave logs <id>` | View container logs |
+
+### Image & Volume Management
+
+| Command | Description |
+|---------|-------------|
+| `fenwave images` | List images |
+| `fenwave pull <tag>` | Pull image(s) |
+| `fenwave rmi <id>` | Remove image(s) |
+| `fenwave volumes` | List volumes |
+| `fenwave volume-create <name>` | Create volume(s) |
+| `fenwave volume-rm <name>` | Remove volume(s) |
+
+### Other Commands
+
+| Command | Description |
+|---------|-------------|
+| `fenwave info` | Display agent information |
+| `fenwave registries` | List connected registries |
+| `fenwave local-env` | Manage local-env container |
+| `fenwave --help` | Show all available commands |
+
+## Architecture
+
+The agent runs as a background daemon with the following features:
+
+- **Port Fallback**: Automatically finds available port (3001-3010)
+- **Single Instance**: Prevents multiple daemon instances
+- **Heartbeat**: WebSocket health checks every 30 seconds
+- **Graceful Shutdown**: Connection draining with client notification
+- **Log Rotation**: Automatic rotation at 10MB, keeps 5 files
+
+### File Locations
+
+```
+~/.fenwave/
+├── daemon/
+│   ├── state.json      # Daemon state (PID, port, status)
+│   ├── agent.pid       # Process ID file
+│   └── agent.lock      # Instance lock file
+├── logs/
+│   ├── agent.log       # Main log file
+│   └── agent.error.log # Error log file
+├── session/
+│   └── config.json     # Session credentials
+├── config/
+│   └── agent.json      # Agent configuration
+└── ws-token            # WebSocket auth token
+```
+
+## Dashboard Features
+
+- Container management (start, stop, restart, logs)
+- Docker image management
+- Volume management
+- Registry connections
+- Real-time metrics
+- Terminal access to containers
+
+## Troubleshooting
+
+**Agent won't start?**
+- Ensure Docker Desktop is running
+- Check if another instance is running: `fenwave service status`
+- Check logs: `fenwave service logs`
+- Try stopping and starting: `fenwave service stop && fenwave service start`
+
+**Port already in use?**
+- The agent will automatically try ports 3001-3010
+- Check which port is being used: `fenwave service status`
+
+**Authentication issues?**
+- Run `fenwave logout` then `fenwave login`
+- Ensure Backstage is running and accessible
+
+**View logs for debugging:**
+```bash
+fenwave service logs -f
+```
+
+**Need help?**
+- Run `fenwave --help` for command options
+- Contact your Fenwave administrator
+
+## Development
+
+### Local Testing
+
+To test the agent locally before publishing:
+
+```bash
+# Navigate to the agent directory
+cd fenwave-agent
+
+# Create a global symlink to this local package
+npm link
+
+# Now 'fenwave' command will use your local code
+fenwave init --token YOUR_TOKEN --backend-url http://localhost:7007
+```
+
+When you're done testing:
+
+```bash
+# Remove the global symlink
+npm unlink -g @fenwave/agent
+```
+
+### Running in Development Mode
+
+```bash
+# Run agent in foreground with debug output
+fenwave --debug service run
+```
+
+### Publishing
+
+To publish a new version:
+
+```bash
+# Bump version (patch/minor/major)
+npm version patch
+
+# Publish to npm
+npm publish --access public
+```
+
+## License
+
+Copyright 2025 Fenwave. All rights reserved. See [LICENSE](LICENSE) for details.

package/auth-callback.html

@@ -0,0 +1,97 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Authenticating...</title>
+    <style>
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        text-align: center;
+        padding: 50px;
+        background: #f5f5f5;
+      }
+      .container {
+        background: white;
+        padding: 40px;
+        border-radius: 8px;
+        max-width: 400px;
+        margin: 0 auto;
+        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+      }
+      .spinner {
+        border: 3px solid #f3f3f3;
+        border-top: 3px solid #3498db;
+        border-radius: 50%;
+        width: 40px;
+        height: 40px;
+        animation: spin 1s linear infinite;
+        margin: 20px auto;
+      }
+      @keyframes spin {
+        0% {
+          transform: rotate(0deg);
+        }
+        100% {
+          transform: rotate(360deg);
+        }
+      }
+      .error {
+        color: #dc2626;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <div class="spinner" id="spinner"></div>
+      <h2 id="status">Processing authentication...</h2>
+      <p id="message">Please wait while we complete the authentication.</p>
+    </div>
+    <script>
+      (function () {
+        // Read credentials from URL fragment
+        let jwt, entityRef;
+
+        const hash = window.location.hash.substring(1);
+        if (hash) {
+          const hashParams = new URLSearchParams(hash);
+          jwt = hashParams.get("jwt");
+          entityRef = hashParams.get("entityRef");
+        }
+
+        if (!jwt || !entityRef) {
+          document.getElementById("spinner").style.display = "none";
+          document.getElementById("status").className = "error";
+          document.getElementById("status").textContent =
+            "Authentication Failed";
+          document.getElementById("message").textContent =
+            "Missing credentials. Please try again.";
+          return;
+        }
+
+        // POST credentials to the server (keeps them out of URL/logs)
+        fetch("/auth-complete", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ jwt, entityRef }),
+        })
+          .then((response) => response.json())
+          .then((data) => {
+            if (data.success) {
+              // Redirect to success page
+              window.location.href = data.redirectUrl;
+            } else {
+              throw new Error(data.error || "Authentication failed");
+            }
+          })
+          .catch((error) => {
+            document.getElementById("spinner").style.display = "none";
+            document.getElementById("status").className = "error";
+            document.getElementById("status").textContent =
+              "Authentication Failed";
+            document.getElementById("message").textContent = error.message;
+          });
+      })();
+    </script>
+  </body>
+</html>

package/auth.js

@@ -0,0 +1,276 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import axios from 'axios';
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const AGENT_ROOT_DIR = path.join(
+  os.homedir(),
+  process.env.AGENT_ROOT_DIR || '.fenwave'
+);
+const SESSION_DIR = process.env.SESSION_DIR || 'session';
+const SESSION_FILE = process.env.SESSION_FILE || 'config.json';
+const CONFIG_FILE = path.join(AGENT_ROOT_DIR, SESSION_DIR, SESSION_FILE);
+
+/**
+ * Ensures the configuration directory exists
+ */
+function ensureConfigDirectory() {
+  const sessionDir = path.dirname(CONFIG_FILE);
+  if (!fs.existsSync(sessionDir)) {
+    fs.mkdirSync(sessionDir, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Saves session data to local config file
+ * @param {string} token - Session token
+ * @param {string} expiresAt - Expiration timestamp
+ * @param {string} userEntityRef - User entity reference
+ * @param {string} backendUrl - Optional backend URL to save
+ */
+function saveSession(token, expiresAt, userEntityRef, backendUrl = null) {
+  ensureConfigDirectory();
+  const config = {
+    token,
+    expiresAt,
+    userEntityRef,
+  };
+
+  // Preserve existing backend URL or save new one
+  if (backendUrl) {
+    config.backendUrl = backendUrl;
+  } else {
+    const existingConfig = loadSession();
+    if (existingConfig && existingConfig.backendUrl) {
+      config.backendUrl = existingConfig.backendUrl;
+    }
+  }
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), {
+    mode: 0o600,
+  });
+}
+
+/**
+ * Loads session data from local config file
+ * @returns {Object|null} Session data or null if not found
+ */
+function loadSession() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return null;
+  }
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    return config;
+  } catch (error) {
+    console.error(chalk.red('❌ Error loading session config:'), error.message);
+    return null;
+  }
+}
+
+/**
+ * Checks if a session is still valid (not expired)
+ * @param {Object} session - Session data
+ * @returns {boolean} - True if session is valid
+ */
+function isSessionValid(session) {
+  if (!session || !session.token || !session.expiresAt) {
+    return false;
+  }
+  const now = new Date();
+  const expiresAt = new Date(session.expiresAt);
+  return now < expiresAt;
+}
+
+/**
+ * Handles session expiry by clearing session and exiting process
+ * @param {string} message - Optional message to display
+ * @param {Object} server - Optional WebSocket server to close
+ * @param {Object} wss - Optional WebSocket server instance to close
+ */
+function handleSessionExpiry(
+  message = 'Session has expired!',
+  server = null,
+  wss = null
+) {
+  console.log(chalk.red(`❌ ${message}`));
+  console.log(chalk.red('🔒 Fenwave Agent shutting down gracefully...'));
+
+  // Close WebSocket connections and server if provided
+  if (wss) {
+    wss.clients.forEach((client) => {
+      client.send(
+        JSON.stringify({
+          type: 'session_expired',
+          message: 'Session has expired. Please re-authenticate.',
+        })
+      );
+      client.close();
+    });
+    wss.close();
+  }
+
+  if (server) {
+    server.close();
+  }
+
+  clearSession();
+  console.log(chalk.yellow("💡 Please run 'fenwave login' to authenticate again."));
+  process.exit(1);
+}
+
+/**
+ * Creates a new session with the Fenwave backend
+ * @param {string} jwt - Token for authentication
+ * @param {string} backendUrl - Backend URL
+ * @returns {Object} Session data with token, userEntityRef and expiresAt
+ */
+async function createSession(jwt, backendUrl) {
+  try {
+    const response = await axios.post(
+      `${backendUrl}/api/agent-cli/create-session`,
+      {},
+      {
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+    console.log(chalk.green('✅ Session created successfully!'));
+    const { token, expiresAt } = response.data;
+    return { token, expiresAt };
+  } catch (error) {
+    console.error(
+      chalk.red('❌ Failed to create session: '),
+      error.response?.data || error.message
+    );
+    throw error;
+  }
+}
+
+/**
+ * Clears the stored session
+ */
+function clearSession() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Sets up a file watcher to monitor session file changes
+ * @param {Function} onSessionExpired - Callback function to handle session expiry
+ * @param {Object} server - WebSocket server instance
+ * @param {Object} wss - WebSocket server instance
+ * @returns {Object} File watcher instance
+ */
+function setupSessionWatcher(onSessionExpired, server = null, wss = null) {
+  let watcher = null;
+  let expiryTimer = null;
+
+  // Set up timer for natural expiry
+  const session = loadSession();
+  if (session && session.expiresAt) {
+    const expiryTime = new Date(session.expiresAt).getTime();
+    const currentTime = Date.now();
+    const timeUntilExpiry = expiryTime - currentTime;
+
+    if (timeUntilExpiry > 0) {
+      expiryTimer = setTimeout(() => {
+        clearSession();
+        onSessionExpired('Session expired !', server, wss);
+      }, timeUntilExpiry);
+    }
+  }
+
+  try {
+    // Watch the config file for changes/deletion
+    watcher = fs.watch(CONFIG_FILE, (eventType, filename) => {
+      // Clear the natural expiry timer since file changed
+      if (expiryTimer) {
+        clearTimeout(expiryTimer);
+        expiryTimer = null;
+      }
+
+      // Check if file was deleted or renamed (session revoked by logout)
+      if (eventType === 'rename' || !fs.existsSync(CONFIG_FILE)) {
+        if (watcher) {
+          watcher.close();
+        }
+        onSessionExpired('Session revoked !', server, wss);
+        return;
+      }
+    });
+    return {
+      close: () => {
+        if (watcher) watcher.close();
+        if (expiryTimer) clearTimeout(expiryTimer);
+      },
+    };
+  } catch (error) {
+    // Clear expiry timer if file watcher fails
+    if (expiryTimer) {
+      clearTimeout(expiryTimer);
+      expiryTimer = null;
+    }
+
+    // Fallback to periodic checking if file watching fails
+    const intervalId = setInterval(() => {
+      if (!fs.existsSync(CONFIG_FILE)) {
+        clearInterval(intervalId);
+        onSessionExpired('Session revoked !', server, wss);
+        return;
+      }
+
+      const currentSession = loadSession();
+      if (!currentSession || !isSessionValid(currentSession)) {
+        clearInterval(intervalId);
+        onSessionExpired('Session expired !', server, wss);
+      }
+    }, 30 * 1000); // Check every 30 seconds as fallback
+
+    return { close: () => clearInterval(intervalId) };
+  }
+}
+
+/**
+ * Loads backend URL from agent config or environment variable
+ * NOTE: This function loads synchronously from the config file
+ * @returns {string|undefined} Backend URL
+ */
+function loadBackendUrl() {
+  // Load directly from config file to avoid circular dependencies
+  const configPath = path.join(os.homedir(), '.fenwave', 'config', 'agent.json');
+
+  // Try to load from config file
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (config.backendUrl) {
+        return config.backendUrl;
+      }
+    } catch (error) {
+      // Fall through to env variable
+    }
+  }
+
+  // Fall back to environment variable
+  return process.env.BACKEND_URL || 'http://localhost:7007';
+}
+
+export {
+  saveSession,
+  loadSession,
+  isSessionValid,
+  handleSessionExpiry,
+  createSession,
+  clearSession,
+  setupSessionWatcher,
+  loadBackendUrl,
+};