@fenwave/agent 1.1.0

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,60 @@
+<!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>
+    <script src="https://cdn.tailwindcss.com"></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 return to your CLI.</p>
+      </div>
+    </div>
+  </body>
+</html>