@oussema_mili/test-pkg-123 1.1.22

package/helper-functions.js

@@ -0,0 +1,193 @@
+import os from 'os';
+
+// Format container uptime in a human-readable format
+const formatUptime = (ms) => {
+  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} day${days > 1 ? 's' : ''}`;
+  if (hours > 0) return `${hours} hour${hours > 1 ? 's' : ''}`;
+  if (minutes > 0) return `${minutes} minute${minutes > 1 ? 's' : ''}`;
+  return `${seconds} second${seconds !== 1 ? 's' : ''}`;
+};
+
+// Format image size to human-readable format
+const formatSize = (size) => {
+  const kb = size / 1000;
+  if (kb < 1000) return `${Math.round(kb)} KB`;
+
+  const mb = size / 1_000_000;
+  if (mb < 1000) return `${Math.round(mb)} MB`;
+
+  const gb = size / 1_000_000_000;
+  return `${gb.toFixed(2)} GB`;
+};
+
+// Format image creation time to relative time
+const formatCreatedTime = (created) => {
+  const now = Date.now() / 1000;
+  const diff = now - created;
+
+  const minutes = Math.floor(diff / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(months / 12);
+
+  if (years > 0) return `${years} year${years > 1 ? 's' : ''} ago`;
+  if (months > 0) return `${months} month${months > 1 ? 's' : ''} ago`;
+  if (days > 0) return `${days} day${days > 1 ? 's' : ''} ago`;
+  if (hours > 0) return `${hours} hour${hours > 1 ? 's' : ''} ago`;
+  if (minutes > 0) return `${minutes} minute${minutes > 1 ? 's' : ''} ago`;
+  return 'Just now';
+};
+
+// Parse log line to extract timestamp, level, and message
+function parseLogLine(line, containerId) {
+  let rawLine = line.toString();
+
+  // Docker logs can contain binary headers (8 bytes) that need to be stripped
+  // The first byte indicates the stream type (1=stdout, 2=stderr)
+  // Bytes 1-3 are padding, bytes 4-7 contain the length
+  if (rawLine.length > 8) {
+    const firstByte = rawLine.charCodeAt(0);
+    // Check if this looks like a Docker log header
+    if (firstByte === 1 || firstByte === 2) {
+      // Skip the 8-byte header
+      rawLine = rawLine.substring(8);
+    }
+  }
+
+  let message = rawLine;
+  let timestamp = new Date().toISOString();
+  let level = 'INFO';
+  const service = 'container';
+  let isEmptyLine = false;
+
+  // Check if this is an empty line (only whitespace or completely empty)
+  if (rawLine.trim() === '') {
+    isEmptyLine = true;
+    message = ''; // Keep as empty for empty lines
+  } else {
+    // Extract Docker timestamp if present (format: 2025-09-12T14:44:10.598127086Z)
+    const timestampMatch = message.match(
+      /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)\s*(.*)$/
+    );
+    if (timestampMatch) {
+      timestamp = timestampMatch[1];
+      message = timestampMatch[2] || ''; // This is the actual log content after the Docker timestamp
+
+      // If after extracting timestamp, message is empty, mark as empty line
+      if (message.trim() === '') {
+        isEmptyLine = true;
+        message = '';
+      }
+    }
+
+    // Clean up any remaining malformed timestamp artifacts
+    message = message.replace(
+      /^-?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z\s*/,
+      ''
+    );
+
+    // Try to detect log level from content (only for non-empty lines)
+    if (!isEmptyLine) {
+      const lowerMessage = message.toLowerCase();
+      if (
+        lowerMessage.includes('"s":"e"') ||
+        lowerMessage.includes('error') ||
+        lowerMessage.includes('err') ||
+        lowerMessage.includes('fatal')
+      ) {
+        level = 'ERROR';
+      } else if (
+        lowerMessage.includes('"s":"w"') ||
+        lowerMessage.includes('warn')
+      ) {
+        level = 'WARN';
+      } else if (
+        lowerMessage.includes('"s":"d"') ||
+        lowerMessage.includes('debug')
+      ) {
+        level = 'DEBUG';
+      } else if (
+        lowerMessage.includes('"s":"i"') ||
+        lowerMessage.includes('info') ||
+        lowerMessage.includes('log:')
+      ) {
+        level = 'INFO';
+      }
+    }
+  }
+
+  return {
+    id: `log-${containerId}-${Date.now()}-${Math.random()
+      .toString(36)
+      .substring(2, 9)}`,
+    timestamp,
+    level,
+    service,
+    message,
+    isEmptyLine, // Add flag to identify empty lines
+  };
+}
+
+// Parse size strings like "10 GB" to bytes
+function parseSize(sizeStr) {
+  if (!sizeStr || typeof sizeStr !== 'string') return 0;
+
+  const match = sizeStr.match(/^(\d+(\.\d+)?)\s*([KMGT]?B)$/);
+  if (!match) return 0;
+
+  const size = Number.parseFloat(match[1]);
+  const unit = match[3];
+
+  switch (unit) {
+    case 'B':
+      return size;
+    case 'KB':
+      return size * 1024;
+    case 'MB':
+      return size * 1024 * 1024;
+    case 'GB':
+      return size * 1024 * 1024 * 1024;
+    case 'TB':
+      return size * 1024 * 1024 * 1024 * 1024;
+    default:
+      return size;
+  }
+}
+
+// Simple CPU usage estimation without native modules
+function estimateCpuUsage() {
+  try {
+    const cpus = os.cpus();
+    let idle = 0;
+    let total = 0;
+
+    for (const cpu of cpus) {
+      for (const type in cpu.times) {
+        total += cpu.times[type];
+      }
+      idle += cpu.times.idle;
+    }
+
+    // Calculate CPU usage as percentage of non-idle time
+    const usage = 100 - (idle / total) * 100;
+    return Math.round(usage * 100) / 100;
+  } catch (error) {
+    console.error('Error estimating CPU usage:', error.message);
+    return 0;
+  }
+}
+
+export {
+  formatUptime,
+  formatSize,
+  formatCreatedTime,
+  parseLogLine,
+  parseSize,
+  estimateCpuUsage,
+};

package/index.html

@@ -0,0 +1,83 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Authorization Successful</title>
+    <link
+      rel="icon"
+      href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><circle cx='50' cy='50' r='45' fill='%2322c55e'/><path d='M30 50l15 15 25-30' stroke='white' stroke-width='8' fill='none' stroke-linecap='round' stroke-linejoin='round'/></svg>"
+    />
+    <link href="/dist/styles.css" rel="stylesheet" />
+    <script>
+      // Store WebSocket token in localStorage for App Builder to use
+      // These values are injected by the agent server
+      const wsToken = new URLSearchParams(window.location.search).get(
+        "wsToken",
+      );
+      const wsPort = new URLSearchParams(window.location.search).get("wsPort");
+      const containerPort = new URLSearchParams(window.location.search).get(
+        "containerPort",
+      );
+
+      if (wsToken) {
+        localStorage.setItem("fenwave-ws-token", wsToken);
+        localStorage.setItem("fenwave-ws-port", wsPort || "3001");
+        localStorage.setItem("fenwave-container-port", containerPort || "3006");
+      }
+    </script>
+    <style>
+      @keyframes fadeIn {
+        from {
+          opacity: 0;
+        }
+        to {
+          opacity: 1;
+        }
+      }
+      .fade-in {
+        animation: fadeIn 0.5s ease-in-out;
+      }
+    </style>
+  </head>
+  <body class="bg-gray-50 min-h-screen">
+    <div class="flex justify-center items-center min-h-[80vh]">
+      <div
+        class="fade-in max-w-sm mx-auto mt-8 p-8 text-center bg-white rounded-lg shadow-lg"
+      >
+        <!-- Success Icon Circle -->
+        <div
+          class="w-16 h-16 mx-auto mb-6 flex items-center justify-center rounded-full bg-green-500 text-white"
+        >
+          <svg
+            class="w-8 h-8"
+            fill="currentColor"
+            viewBox="0 0 20 20"
+            xmlns="http://www.w3.org/2000/svg"
+          >
+            <path
+              fill-rule="evenodd"
+              d="M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z"
+              clip-rule="evenodd"
+            ></path>
+          </svg>
+        </div>
+
+        <!-- Main Heading -->
+        <h2 class="text-2xl font-medium text-gray-900 mb-4">
+          Authorization Successful
+        </h2>
+
+        <!-- Description Text -->
+        <p class="text-base text-gray-600 mb-8">
+          Your agent has been successfully authorized.
+        </p>
+
+        <!-- Footer Text -->
+        <p class="text-sm text-gray-500">
+          You may now close this window and return to your CLI.
+        </p>
+      </div>
+    </div>
+  </body>
+</html>

package/index.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import chalk from "chalk";
+import { program } from "commander";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import dotenv from "dotenv";
+
+// ES module helpers
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Ensure environment files exist
+import { ensureEnvironmentFiles } from "./utils/envSetup.js";
+const agentEnvPath = ensureEnvironmentFiles(__dirname);
+
+// Load environment variables from .env.agent
+dotenv.config({ path: agentEnvPath });
+
+// Load environment variables
+dotenv.config();
+
+// Import ES modules
+import { setupCLICommands } from "./cli-commands.js";
+
+// Version from package.json
+const packageJson = JSON.parse(
+  fs.readFileSync(new URL("./package.json", import.meta.url), "utf8")
+);
+const { version } = packageJson;
+
+// Initialize the CLI
+program
+  .name("fenwave")
+  .description("Fenwave - Developer Platform CLI")
+  .version(version)
+  .option('--debug', 'Enable debug mode for verbose logging')
+  .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.debug) {
+      process.env.DEBUG = 'true';
+      console.log(chalk.yellow('Debug mode enabled'));
+    }
+  });
+
+// Setup CLI commands (startServer function is no longer needed - using agentRunner instead)
+setupCLICommands(program, null);
+
+// Custom unknown command handler
+program.on("command:*", ([cmd]) => {
+  console.error(`error: unknown command '${cmd}'`);
+
+  const available = program.commands.map((c) => c.name());
+
+  // First, try prefix matches
+  let matches = available.filter((c) => c.startsWith(cmd));
+
+  // If no prefix matches, try bidirectional substring matches
+  if (matches.length === 0) {
+    matches = available.filter((c) => cmd.includes(c) || c.includes(cmd));
+  }
+
+  if (matches.length > 0) {
+    if (matches.length === 1) {
+      console.error(`(Did you mean '${matches[0]}'?)`);
+    } else {
+      console.error(`(Did you mean one of ${matches.join(", ")}?)`);
+    }
+  }
+
+  process.exit(1);
+});
+
+// Pre-process arguments to handle incomplete options before Commander.js
+function preprocessArguments() {
+  const args = process.argv.slice(2);
+
+  if (args.length >= 2) {
+    const commandName = args[0];
+    const lastArg = args[args.length - 1];
+
+    // Check if user typed incomplete option (just - or --)
+    if (lastArg === "-" || lastArg === "--") {
+      // Find the command
+      const command = program.commands.find(
+        (cmd) =>
+          cmd.name() === commandName || cmd.aliases().includes(commandName)
+      );
+
+      if (command) {
+        console.error(`error: unknown option '${lastArg}'`);
+
+        // Get all options for this command
+        const options = command.options || [];
+        const availableOptions = [];
+
+        // Add command-specific options
+        options.forEach((option) => {
+          if (option.short) availableOptions.push(option.short);
+          if (option.long) availableOptions.push(option.long);
+        });
+
+        // Always add help option
+        if (!availableOptions.includes("-h")) availableOptions.push("-h");
+        if (!availableOptions.includes("--help"))
+          availableOptions.push("--help");
+
+        let suggestions = [];
+
+        if (lastArg === "--") {
+          // User typed just '--', suggest all long options
+          suggestions = availableOptions.filter((opt) => opt.startsWith("--"));
+        } else if (lastArg === "-") {
+          // User typed just '-', suggest all short options with their long equivalents
+          const shortOpts = availableOptions.filter(
+            (opt) => opt.startsWith("-") && !opt.startsWith("--")
+          );
+          const longOpts = availableOptions.filter((opt) =>
+            opt.startsWith("--")
+          );
+
+          // Pair short and long options
+          suggestions = shortOpts.map((shortOpt) => {
+            const longEquivalent = longOpts.find(
+              (longOpt) =>
+                longOpt.substring(2) === shortOpt.substring(1) ||
+                (shortOpt === "-h" && longOpt === "--help") ||
+                (shortOpt === "-a" && longOpt === "--all") ||
+                (shortOpt === "-f" &&
+                  (longOpt === "--force" || longOpt === "--follow")) ||
+                (shortOpt === "-d" && longOpt === "--driver") ||
+                (shortOpt === "-p" && longOpt === "--port") ||
+                (shortOpt === "-t" && longOpt === "--tail")
+            );
+            return longEquivalent ? `${shortOpt}, ${longEquivalent}` : shortOpt;
+          });
+        }
+
+        if (suggestions.length > 0) {
+          const formattedSuggestions = suggestions.map((suggestion) => {
+            // Add argument placeholder for options that require arguments
+            let displaySuggestion = suggestion;
+
+            // Find the matching option object to check if it requires an argument
+            const option = options.find(
+              (opt) =>
+                opt.long === suggestion ||
+                opt.short === suggestion ||
+                (suggestion.includes(opt.long) && opt.long) ||
+                (suggestion.includes(opt.short) && opt.short)
+            );
+
+            if (option && option.required) {
+              // Use a more descriptive argument name based on the option's own description
+              let argName = "<value>";
+              if (option.argChoices) {
+                argName = `<${option.argChoices.join("|")}>`;
+              } else if (option.long) {
+                // Map common option names to better argument descriptions
+                const optName = option.long.replace("--", "");
+                const argNameMap = {
+                  tail: "lines",
+                  port: "port",
+                  driver: "driver",
+                  "backend-url": "url",
+                  "frontend-url": "url",
+                  token: "token",
+                  "aws-region": "region",
+                  "aws-account-id": "id",
+                };
+                argName = `<${argNameMap[optName] || optName}>`;
+              }
+              displaySuggestion = `${suggestion} ${argName}`;
+            }
+
+            return `'${displaySuggestion}'`;
+          });
+
+          console.error(`(Did you mean ${formattedSuggestions.join(", ")}?)`);
+        }
+
+        process.exit(1);
+      }
+    }
+  }
+}
+
+// Run preprocessing before parsing
+preprocessArguments();
+
+// Handle unknown options
+program.exitOverride((err) => {
+  if (err.code === "commander.unknownOption") {
+    const args = process.argv.slice(2);
+    const commandName = args[0];
+    const invalidOption = err.message.match(/unknown option '([^']+)'/)?.[1];
+
+    if (invalidOption) {
+      // Find the command
+      const command = program.commands.find(
+        (cmd) =>
+          cmd.name() === commandName || cmd.aliases().includes(commandName)
+      );
+
+      if (command) {
+        console.error(`error: unknown option '${invalidOption}'`);
+
+        // Get all options for this command
+        const options = command.options || [];
+        const availableOptions = [];
+
+        // Add command-specific options
+        options.forEach((option) => {
+          if (option.short) availableOptions.push(option.short);
+          if (option.long) availableOptions.push(option.long);
+        });
+
+        // Always add help option
+        if (!availableOptions.includes("-h")) availableOptions.push("-h");
+        if (!availableOptions.includes("--help"))
+          availableOptions.push("--help");
+
+        // Find suggestions for partial/incorrect options
+        const suggestions = availableOptions.filter(
+          (opt) =>
+            opt.startsWith(invalidOption) ||
+            opt.includes(invalidOption.replace(/^-+/, "")) ||
+            invalidOption.includes(opt.replace(/^-+/, ""))
+        );
+
+        if (suggestions.length > 0) {
+          // Group short and long options together
+          const pairedSuggestions = [];
+          const processed = new Set();
+
+          suggestions.forEach((suggestion) => {
+            if (processed.has(suggestion)) return;
+
+            const option = options.find(
+              (opt) => opt.long === suggestion || opt.short === suggestion
+            );
+
+            if (option) {
+              let displaySuggestion = "";
+
+              // Check if both short and long forms are in suggestions
+              const hasShort =
+                option.short && suggestions.includes(option.short);
+              const hasLong = option.long && suggestions.includes(option.long);
+
+              if (hasShort && hasLong) {
+                displaySuggestion = `${option.short}, ${option.long}`;
+                processed.add(option.short);
+                processed.add(option.long);
+              } else if (hasShort) {
+                // If only short form matched, still pair it with long form if available
+                displaySuggestion = option.long
+                  ? `${option.short}, ${option.long}`
+                  : option.short;
+                processed.add(option.short);
+                if (option.long) processed.add(option.long);
+              } else if (hasLong) {
+                // If only long form matched, still pair it with short form if available
+                displaySuggestion = option.short
+                  ? `${option.short}, ${option.long}`
+                  : option.long;
+                if (option.short) processed.add(option.short);
+                processed.add(option.long);
+              }
+
+              // Add argument placeholder for options that require arguments
+              if (option.required) {
+                let argName = "<value>";
+                if (option.argChoices) {
+                  argName = `<${option.argChoices.join("|")}>`;
+                } else if (option.long) {
+                  const optName = option.long.replace("--", "");
+                  const argNameMap = {
+                    tail: "lines",
+                    port: "port",
+                    driver: "driver",
+                    "backend-url": "url",
+                    "frontend-url": "url",
+                    token: "token",
+                    "aws-region": "region",
+                    "aws-account-id": "id",
+                  };
+                  argName = `<${argNameMap[optName] || optName}>`;
+                }
+                displaySuggestion = `${displaySuggestion} ${argName}`;
+              }
+
+              pairedSuggestions.push(`'${displaySuggestion}'`);
+            } else {
+              // Fallback for options without Option object (like help)
+              processed.add(suggestion);
+
+              // Pair -h with --help
+              if (suggestion === "-h" && suggestions.includes("--help")) {
+                pairedSuggestions.push(`'${suggestion}, --help'`);
+                processed.add("--help");
+              } else if (
+                suggestion === "--help" &&
+                suggestions.includes("-h")
+              ) {
+                // Skip, already handled
+              } else {
+                pairedSuggestions.push(`'${suggestion}'`);
+              }
+            }
+          });
+
+          console.error(`(Did you mean ${pairedSuggestions.join(", ")}?)`);
+        }
+      }
+    }
+
+    process.exit(1);
+  }
+
+  // For other errors (like help), exit normally with the error's exit code
+  process.exit(err.exitCode || 1);
+});
+
+// Parse command line arguments
+program.parse(process.argv);
+
+// If no arguments, show help
+if (process.argv.length === 2) {
+  program.help();
+}
+
+// Process error handling
+process.on("uncaughtException", (error) => {
+  console.error("Uncaught exception:", error);
+});
+
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("Unhandled rejection at:", promise, "reason:", reason);
+});

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@oussema_mili/test-pkg-123",
+  "version": "1.1.22",
+  "description": "Fenwave Docker Agent and CLI",
+  "keywords": [
+    "fenwave",
+    "fenleap",
+    "fenwave-idp"
+  ],
+  "homepage": "https://github.com/fenleap/fenwave-agent#readme",
+  "bugs": {
+    "url": "https://github.com/fenleap/fenwave-agent/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fenleap/fenwave-agent.git"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Fenleap",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "fenwave": "index.js"
+  },
+  "files": [
+    "index.js",
+    "index.html",
+    "auth-callback.html",
+    "dist/",
+    "styles.css",
+    "postcss.config.mjs",
+    "cli-commands.js",
+    "auth.js",
+    "containerManager.js",
+    "helper-functions.js",
+    "websocket-server.js",
+    "daemon/",
+    "docker-actions/",
+    "scripts/",
+    "setup/",
+    "store/",
+    "utils/",
+    "completion/"
+  ],
+  "scripts": {
+    "start": "node index.js server",
+    "agent": "node index.js",
+    "build:css": "postcss styles.css -o dist/styles.css",
+    "watch:css": "postcss styles.css -o dist/styles.css --watch",
+    "prepare": "npm run build:css",
+    "release": "bash scripts/release.sh",
+    "release:patch": "bash scripts/release.sh patch",
+    "release:minor": "bash scripts/release.sh minor",
+    "release:major": "bash scripts/release.sh major"
+  },
+  "dependencies": {
+    "@aws-sdk/client-ecr": "^3.879.0",
+    "@aws-sdk/client-sts": "^3.879.0",
+    "@tailwindcss/postcss": "^4.1.18",
+    "axios": "^1.11.0",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.3",
+    "commander": "^11.0.0",
+    "dockerode": "^4.0.0",
+    "dotenv": "^16.0.3",
+    "google-auth-library": "^9.0.0",
+    "inquirer": "^8.2.5",
+    "js-yaml": "^4.1.0",
+    "open": "^11.0.0",
+    "ora": "^5.4.1",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.1.18",
+    "uuid": "^9.0.1",
+    "ws": "^8.15.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "devDependencies": {
+    "postcss-cli": "^11.0.1"
+  }
+}