@edgible-team/cli 1.0.1

package/dist/utils/log-formatter.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * Utility functions for parsing and formatting journalctl logs
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJournalctlLine = parseJournalctlLine;
+exports.parseJournalctlOutput = parseJournalctlOutput;
+exports.formatLogEntryColored = formatLogEntryColored;
+exports.formatLogEntries = formatLogEntries;
+exports.formatLogEntriesColored = formatLogEntriesColored;
+exports.formatLogEntry = formatLogEntry;
+exports.filterByLevel = filterByLevel;
+exports.filterByModule = filterByModule;
+exports.matchesLevel = matchesLevel;
+exports.matchesModule = matchesModule;
+exports.processLogs = processLogs;
+exports.processLogLine = processLogLine;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Parse a single journalctl line to extract JSON log entry
+ * Handles systemd journal format: "timestamp hostname process: {json}"
+ * Example: "Nov 15 23:41:22 hostname node[123]: {\"timestamp\":...}"
+ */
+function parseJournalctlLine(line) {
+    if (!line.trim()) {
+        return null;
+    }
+    // Find the JSON part - look for the pattern ": {" which separates the systemd prefix from JSON
+    // We need to find the last colon before a '{' to handle timestamps that contain colons
+    const jsonStartIndex = line.indexOf(': {');
+    if (jsonStartIndex === -1) {
+        // Try to find just a colon followed by whitespace and then {
+        const colonIndex = line.lastIndexOf(':');
+        if (colonIndex === -1) {
+            return null;
+        }
+        const afterColon = line.substring(colonIndex + 1).trim();
+        if (!afterColon.startsWith('{')) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(afterColon);
+            return parsed;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    const jsonPart = line.substring(jsonStartIndex + 2).trim(); // +2 to skip ": "
+    if (!jsonPart.startsWith('{')) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(jsonPart);
+        return parsed;
+    }
+    catch (error) {
+        // Skip lines that aren't valid JSON
+        return null;
+    }
+}
+/**
+ * Parse journalctl output to extract JSON log entries
+ * Handles systemd journal format: "timestamp hostname process: {json}"
+ */
+function parseJournalctlOutput(rawLogs) {
+    const lines = rawLogs.split('\n');
+    const entries = [];
+    for (const line of lines) {
+        const entry = parseJournalctlLine(line);
+        if (entry) {
+            entries.push(entry);
+        }
+    }
+    return entries;
+}
+/**
+ * Get color for log level
+ */
+function getLevelColor(level) {
+    const levelUpper = level.toUpperCase();
+    switch (levelUpper) {
+        case 'ERROR':
+            return chalk_1.default.redBright.bold;
+        case 'WARN':
+            return chalk_1.default.yellowBright.bold;
+        case 'INFO':
+            return chalk_1.default.cyanBright.bold;
+        case 'DEBUG':
+            return chalk_1.default.gray;
+        default:
+            return chalk_1.default.whiteBright;
+    }
+}
+/**
+ * Get color for module name
+ */
+function getModuleColor(module) {
+    // Use vibrant, punchy colors for modules
+    const moduleColors = {
+        'agent': chalk_1.default.blueBright.bold,
+        'api-client': chalk_1.default.magentaBright.bold,
+        'caddy': chalk_1.default.greenBright.bold,
+        'haproxy': chalk_1.default.cyanBright.bold,
+        'firewall': chalk_1.default.redBright.bold,
+        'health': chalk_1.default.greenBright.bold,
+        'status': chalk_1.default.yellowBright.bold,
+        'update': chalk_1.default.cyanBright.bold,
+    };
+    const moduleLower = module.toLowerCase();
+    return moduleColors[moduleLower] || chalk_1.default.whiteBright.bold;
+}
+/**
+ * Format a single log entry with colors
+ */
+function formatLogEntryColored(entry, singleLine = false) {
+    const levelColor = getLevelColor(entry.level);
+    const moduleColor = getModuleColor(entry.module);
+    // Format timestamp
+    const timestamp = entry.timestamp ? new Date(entry.timestamp).toLocaleString() : '';
+    const timestampStr = chalk_1.default.gray.dim(timestamp);
+    // Format level with color
+    const levelStr = levelColor(`[${entry.level.toUpperCase().padEnd(5)}]`);
+    // Format module with color
+    const moduleStr = moduleColor(`[${entry.module}]`);
+    // Format message
+    const messageStr = chalk_1.default.whiteBright(entry.message);
+    // Build the formatted line
+    let formatted = `${timestampStr} ${levelStr} ${moduleStr} ${messageStr}`;
+    // Add data if present and not in single-line mode
+    if (!singleLine && entry.data !== undefined) {
+        const dataStr = JSON.stringify(entry.data, null, 2);
+        formatted += chalk_1.default.gray.dim(`\n  Data: ${dataStr}`);
+    }
+    // Add error trace if present and not in single-line mode
+    if (!singleLine && entry.errorTrace) {
+        formatted += chalk_1.default.redBright.bold(`\n  Error Trace:\n${entry.errorTrace}`);
+    }
+    return formatted;
+}
+/**
+ * Format log entries as single-line JSON (one per line)
+ */
+function formatLogEntries(entries) {
+    return entries.map(entry => JSON.stringify(entry)).join('\n');
+}
+/**
+ * Format log entries with colors
+ */
+function formatLogEntriesColored(entries, singleLine = false) {
+    return entries.map(entry => formatLogEntryColored(entry, singleLine)).join('\n');
+}
+/**
+ * Format a single log entry as single-line JSON
+ */
+function formatLogEntry(entry) {
+    return JSON.stringify(entry);
+}
+/**
+ * Filter log entries by level
+ * When filtering by a specific level, shows that level and all more severe levels above it
+ * - error: shows only error
+ * - warn: shows error and warn
+ * - info: shows error, warn, and info
+ * - debug: shows error, warn, info, and debug
+ * - all: shows everything (no filtering)
+ */
+function filterByLevel(entries, level) {
+    if (level === 'all') {
+        return entries;
+    }
+    const levelUpper = level.toUpperCase();
+    // Define level hierarchy: error(0) is most severe, debug(3) is most verbose
+    const levelHierarchy = {
+        'ERROR': 0,
+        'WARN': 1,
+        'INFO': 2,
+        'DEBUG': 3
+    };
+    const targetLevel = levelHierarchy[levelUpper];
+    if (targetLevel === undefined) {
+        // Unknown level, show all
+        return entries;
+    }
+    return entries.filter(entry => {
+        const entryLevel = entry.level?.toUpperCase() || '';
+        const entryLevelNum = levelHierarchy[entryLevel];
+        if (entryLevelNum === undefined) {
+            // Unknown entry level, include it
+            return true;
+        }
+        // Include entries at the target level or more severe (lower number)
+        // So if filtering for 'info' (2), show error(0), warn(1), and info(2), but not debug(3)
+        return entryLevelNum <= targetLevel;
+    });
+}
+/**
+ * Filter log entries by module(s) - supports comma-separated list
+ */
+function filterByModule(entries, module) {
+    const modules = module.split(',').map(m => m.trim().toLowerCase()).filter(m => m.length > 0);
+    if (modules.length === 0) {
+        return entries;
+    }
+    return entries.filter(entry => {
+        const entryModule = entry.module?.toLowerCase() || '';
+        return modules.includes(entryModule);
+    });
+}
+/**
+ * Check if a log entry matches the level filter
+ * When filtering by a specific level, shows that level and all more severe levels above it
+ */
+function matchesLevel(entry, level) {
+    if (level === 'all') {
+        return true;
+    }
+    const levelUpper = level.toUpperCase();
+    const levelHierarchy = {
+        'ERROR': 0,
+        'WARN': 1,
+        'INFO': 2,
+        'DEBUG': 3
+    };
+    const targetLevel = levelHierarchy[levelUpper];
+    if (targetLevel === undefined) {
+        // Unknown level, include it
+        return true;
+    }
+    const entryLevel = entry.level?.toUpperCase() || '';
+    const entryLevelNum = levelHierarchy[entryLevel];
+    if (entryLevelNum === undefined) {
+        // Unknown entry level, include it
+        return true;
+    }
+    // Include entries at the target level or more severe (lower number)
+    return entryLevelNum <= targetLevel;
+}
+/**
+ * Check if a log entry matches the module filter(s) - supports comma-separated list
+ */
+function matchesModule(entry, module) {
+    const modules = module.split(',').map(m => m.trim().toLowerCase()).filter(m => m.length > 0);
+    if (modules.length === 0) {
+        return true;
+    }
+    const entryModule = entry.module?.toLowerCase() || '';
+    return modules.includes(entryModule);
+}
+/**
+ * Parse, filter (if needed), and format journalctl logs
+ */
+function processLogs(rawLogs, options = {}) {
+    const entries = parseJournalctlOutput(rawLogs);
+    let filteredEntries = entries;
+    // Filter by level first (from JSON level field)
+    if (options.level) {
+        filteredEntries = filterByLevel(filteredEntries, options.level);
+    }
+    // Then filter by module
+    if (options.module) {
+        filteredEntries = filterByModule(filteredEntries, options.module);
+    }
+    if (options.colored !== false) {
+        return formatLogEntriesColored(filteredEntries, options.singleLine || false);
+    }
+    return formatLogEntries(filteredEntries);
+}
+/**
+ * Process logs line by line (for streaming/follow mode)
+ */
+function processLogLine(line, options = {}) {
+    const entry = parseJournalctlLine(line);
+    if (!entry) {
+        return null;
+    }
+    // Filter by level (from JSON level field)
+    if (options.level && !matchesLevel(entry, options.level)) {
+        return null;
+    }
+    // Filter by module
+    if (options.module && !matchesModule(entry, options.module)) {
+        return null;
+    }
+    if (options.colored !== false) {
+        return formatLogEntryColored(entry, options.singleLine || false);
+    }
+    return formatLogEntry(entry);
+}
+//# sourceMappingURL=log-formatter.js.map

package/dist/utils/logger.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Logger interface for abstracting logging operations
+ * Allows for different implementations (console, JSON, file, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+exports.parseLogLevel = parseLogLevel;
+exports.getLogLevelName = getLogLevelName;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Get log level from string
+ */
+function parseLogLevel(level) {
+    const upper = level.toUpperCase();
+    switch (upper) {
+        case 'DEBUG':
+            return LogLevel.DEBUG;
+        case 'INFO':
+            return LogLevel.INFO;
+        case 'WARN':
+        case 'WARNING':
+            return LogLevel.WARN;
+        case 'ERROR':
+            return LogLevel.ERROR;
+        case 'NONE':
+        case 'SILENT':
+            return LogLevel.NONE;
+        default:
+            return LogLevel.INFO;
+    }
+}
+/**
+ * Get log level name
+ */
+function getLogLevelName(level) {
+    switch (level) {
+        case LogLevel.DEBUG:
+            return 'DEBUG';
+        case LogLevel.INFO:
+            return 'INFO';
+        case LogLevel.WARN:
+            return 'WARN';
+        case LogLevel.ERROR:
+            return 'ERROR';
+        case LogLevel.NONE:
+            return 'NONE';
+        default:
+            return 'INFO';
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/utils/network-utils.js

@@ -0,0 +1,217 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkUtils = void 0;
+const net = __importStar(require("net"));
+const dns = __importStar(require("dns"));
+const util_1 = require("util");
+const dnsLookup = (0, util_1.promisify)(dns.lookup);
+class NetworkUtils {
+    /**
+     * Test TCP port connectivity
+     */
+    static async testTcpPort(host, port, timeout = 5000) {
+        return new Promise((resolve) => {
+            const startTime = Date.now();
+            const socket = new net.Socket();
+            const cleanup = () => {
+                socket.destroy();
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve({
+                    success: false,
+                    error: 'Connection timeout'
+                });
+            }, timeout);
+            socket.connect(port, host, () => {
+                const latency = Date.now() - startTime;
+                cleanup();
+                clearTimeout(timer);
+                resolve({
+                    success: true,
+                    latency
+                });
+            });
+            socket.on('error', (err) => {
+                cleanup();
+                clearTimeout(timer);
+                resolve({
+                    success: false,
+                    error: err.message
+                });
+            });
+        });
+    }
+    /**
+     * Test UDP port connectivity (basic check)
+     */
+    static async testUdpPort(host, port, timeout = 5000) {
+        return new Promise((resolve) => {
+            const startTime = Date.now();
+            const dgram = require('dgram');
+            const socket = dgram.createSocket('udp4');
+            const cleanup = () => {
+                socket.close();
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve({
+                    success: false,
+                    error: 'UDP connection timeout'
+                });
+            }, timeout);
+            socket.send('ping', port, host, (err) => {
+                if (err) {
+                    cleanup();
+                    clearTimeout(timer);
+                    resolve({
+                        success: false,
+                        error: err.message
+                    });
+                    return;
+                }
+                const latency = Date.now() - startTime;
+                cleanup();
+                clearTimeout(timer);
+                resolve({
+                    success: true,
+                    latency
+                });
+            });
+        });
+    }
+    /**
+     * Resolve hostname to IP address
+     */
+    static async resolveHostname(hostname) {
+        try {
+            const result = await dnsLookup(hostname);
+            return {
+                success: true,
+                ip: result.address
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'DNS resolution failed'
+            };
+        }
+    }
+    /**
+     * Check if a port is available locally
+     */
+    static async isPortAvailable(port, host = 'localhost') {
+        return new Promise((resolve) => {
+            const server = net.createServer();
+            server.listen(port, host, () => {
+                server.once('close', () => {
+                    resolve(true);
+                });
+                server.close();
+            });
+            server.on('error', () => {
+                resolve(false);
+            });
+        });
+    }
+    /**
+     * Get local IP addresses
+     */
+    static getLocalIPs() {
+        const interfaces = require('os').networkInterfaces();
+        const ips = [];
+        for (const name of Object.keys(interfaces)) {
+            for (const iface of interfaces[name]) {
+                if (iface.family === 'IPv4' && !iface.internal) {
+                    ips.push(iface.address);
+                }
+            }
+        }
+        return ips;
+    }
+    /**
+     * Format network error messages for user-friendly display
+     */
+    static formatNetworkError(error) {
+        if (error.includes('ECONNREFUSED')) {
+            return 'Connection refused - the service is not running or not accepting connections';
+        }
+        if (error.includes('ETIMEDOUT')) {
+            return 'Connection timeout - the service is not responding';
+        }
+        if (error.includes('ENOTFOUND')) {
+            return 'Host not found - check the hostname or IP address';
+        }
+        if (error.includes('EADDRNOTAVAIL')) {
+            return 'Address not available - check the IP address';
+        }
+        if (error.includes('EACCES')) {
+            return 'Permission denied - check firewall settings';
+        }
+        return error;
+    }
+    /**
+     * Validate IP address format
+     */
+    static isValidIP(ip) {
+        const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+        const ipv6Regex = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+        return ipv4Regex.test(ip) || ipv6Regex.test(ip);
+    }
+    /**
+     * Validate port number
+     */
+    static isValidPort(port) {
+        return Number.isInteger(port) && port > 0 && port <= 65535;
+    }
+    /**
+     * Generate network diagnostic information
+     */
+    static async generateNetworkDiagnostics(host, port) {
+        const dnsResult = await this.resolveHostname(host);
+        const tcpResult = await this.testTcpPort(host, port);
+        const localIPs = this.getLocalIPs();
+        return {
+            dnsResolution: dnsResult.success,
+            portConnectivity: tcpResult.success,
+            localIPs,
+            error: tcpResult.error
+        };
+    }
+}
+exports.NetworkUtils = NetworkUtils;
+//# sourceMappingURL=network-utils.js.map