@edgible-team/cli 1.0.1

package/dist/utils/docker-compose-parser.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Utility to parse docker-compose.yml files and extract container/port information
+ */
+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.parseDockerComposeFile = parseDockerComposeFile;
+exports.findDockerComposeFile = findDockerComposeFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+/**
+ * Parse a docker-compose file and extract container and port information
+ * @param filePath Path to the docker-compose.yml or docker-compose.yaml file
+ * @returns Structured data containing containers and their ports
+ */
+function parseDockerComposeFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Docker compose file not found: ${filePath}`);
+    }
+    const fileContent = fs.readFileSync(filePath, 'utf8');
+    let composeData;
+    try {
+        composeData = yaml.load(fileContent);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse docker-compose file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    if (!composeData || typeof composeData !== 'object') {
+        throw new Error('Invalid docker-compose file: root must be an object');
+    }
+    const services = composeData.services;
+    if (!services || typeof services !== 'object') {
+        throw new Error('Invalid docker-compose file: no services found');
+    }
+    const containers = [];
+    for (const [serviceName, serviceConfig] of Object.entries(services)) {
+        if (!serviceConfig || typeof serviceConfig !== 'object') {
+            continue;
+        }
+        const config = serviceConfig;
+        const ports = [];
+        // Parse ports from the ports array
+        if (Array.isArray(config.ports)) {
+            for (const portMapping of config.ports) {
+                const parsed = parsePortMapping(portMapping);
+                if (parsed) {
+                    ports.push(parsed);
+                }
+            }
+        }
+        else if (typeof config.ports === 'string') {
+            // Single port mapping as string
+            const parsed = parsePortMapping(config.ports);
+            if (parsed) {
+                ports.push(parsed);
+            }
+        }
+        // Also check expose array (internal ports, but we'll include them)
+        if (Array.isArray(config.expose)) {
+            for (const exposedPort of config.expose) {
+                const portStr = String(exposedPort);
+                const match = portStr.match(/^(\d+)(?:\/(tcp|udp))?$/);
+                if (match) {
+                    const containerPort = parseInt(match[1], 10);
+                    const protocol = match[2] || 'tcp';
+                    // For expose, we use the container port as the host port
+                    ports.push({
+                        host: containerPort,
+                        container: containerPort,
+                        protocol,
+                    });
+                }
+            }
+        }
+        if (ports.length > 0) {
+            containers.push({
+                name: serviceName,
+                ports,
+            });
+        }
+    }
+    return { containers };
+}
+/**
+ * Parse a port mapping string or object
+ * Supports formats:
+ * - "8080:80"
+ * - "8080:80/tcp"
+ * - "127.0.0.1:8080:80"
+ * - "127.0.0.1:8080:80/tcp"
+ * - { target: 80, published: 8080, protocol: 'tcp' }
+ */
+function parsePortMapping(portMapping) {
+    if (typeof portMapping === 'object' && portMapping !== null) {
+        // Docker Compose v3+ format: { target: 80, published: 8080, protocol: 'tcp' }
+        const mapping = portMapping;
+        if (typeof mapping.target === 'number' && typeof mapping.published === 'number') {
+            return {
+                host: mapping.published,
+                container: mapping.target,
+                protocol: mapping.protocol || 'tcp',
+            };
+        }
+        return null;
+    }
+    const portStr = String(portMapping);
+    // Match formats: "8080:80", "8080:80/tcp", "127.0.0.1:8080:80", "127.0.0.1:8080:80/tcp"
+    // Pattern: [IP:]HOST_PORT:CONTAINER_PORT[/PROTOCOL]
+    const match = portStr.match(/^(?:(\d+\.\d+\.\d+\.\d+):)?(\d+):(\d+)(?:\/(tcp|udp))?$/);
+    if (match) {
+        const hostPort = parseInt(match[2], 10);
+        const containerPort = parseInt(match[3], 10);
+        const protocol = match[4] || 'tcp';
+        return {
+            host: hostPort,
+            container: containerPort,
+            protocol,
+        };
+    }
+    return null;
+}
+/**
+ * Find docker-compose file in the current directory or specified path
+ * @param providedPath Optional path provided by user
+ * @returns Path to docker-compose file or null if not found
+ */
+function findDockerComposeFile(providedPath) {
+    if (providedPath) {
+        if (fs.existsSync(providedPath)) {
+            return providedPath;
+        }
+        throw new Error(`Docker compose file not found at: ${providedPath}`);
+    }
+    const currentDir = process.cwd();
+    const possibleFiles = [
+        path.join(currentDir, 'docker-compose.yml'),
+        path.join(currentDir, 'docker-compose.yaml'),
+    ];
+    for (const filePath of possibleFiles) {
+        if (fs.existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=docker-compose-parser.js.map

package/dist/utils/errors.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = exports.NetworkError = exports.ConfigError = exports.ValidationError = exports.CLIError = exports.ExitCode = void 0;
+exports.withErrorHandling = withErrorHandling;
+exports.wrapCommandAction = wrapCommandAction;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Exit codes following Unix conventions
+ */
+var ExitCode;
+(function (ExitCode) {
+    ExitCode[ExitCode["SUCCESS"] = 0] = "SUCCESS";
+    ExitCode[ExitCode["ERROR"] = 1] = "ERROR";
+    ExitCode[ExitCode["USAGE_ERROR"] = 2] = "USAGE_ERROR";
+    ExitCode[ExitCode["CONFIG_ERROR"] = 3] = "CONFIG_ERROR";
+    ExitCode[ExitCode["NETWORK_ERROR"] = 4] = "NETWORK_ERROR";
+})(ExitCode || (exports.ExitCode = ExitCode = {}));
+/**
+ * CLI Error classes for better error handling
+ */
+class CLIError extends Error {
+    constructor(message, exitCode = ExitCode.ERROR, showHelp = false) {
+        super(message);
+        this.exitCode = exitCode;
+        this.showHelp = showHelp;
+        this.name = 'CLIError';
+    }
+}
+exports.CLIError = CLIError;
+class ValidationError extends CLIError {
+    constructor(message) {
+        super(message, ExitCode.USAGE_ERROR);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class ConfigError extends CLIError {
+    constructor(message) {
+        super(message, ExitCode.CONFIG_ERROR);
+        this.name = 'ConfigError';
+    }
+}
+exports.ConfigError = ConfigError;
+class NetworkError extends CLIError {
+    constructor(message) {
+        super(message, ExitCode.NETWORK_ERROR);
+        this.name = 'NetworkError';
+    }
+}
+exports.NetworkError = NetworkError;
+/**
+ * Centralized error handler with consistent output
+ */
+class ErrorHandler {
+    /**
+     * Configure color output
+     */
+    static setColorEnabled(enabled) {
+        this.colorEnabled = enabled ? chalk_1.default.red : (text) => text;
+    }
+    /**
+     * Handle and display error with consistent format
+     */
+    static handleError(error) {
+        if (error instanceof CLIError) {
+            console.error(this.colorEnabled('Error:'), error.message);
+            if (error.showHelp) {
+                console.error('\nUse --help for usage information.');
+            }
+            process.exit(error.exitCode);
+        }
+        else if (error instanceof Error) {
+            console.error(this.colorEnabled('Error:'), error.message);
+            process.exit(ExitCode.ERROR);
+        }
+        else {
+            console.error(this.colorEnabled('Error:'), 'An unexpected error occurred');
+            process.exit(ExitCode.ERROR);
+        }
+    }
+    /**
+     * Display validation error
+     */
+    static handleValidationError(message) {
+        console.error(this.colorEnabled('Validation Error:'), message);
+        process.exit(ExitCode.USAGE_ERROR);
+    }
+    /**
+     * Display network error
+     */
+    static handleNetworkError(message) {
+        console.error(this.colorEnabled('Network Error:'), message);
+        console.error(chalk_1.default.gray('Please check your internet connection and try again.'));
+        process.exit(ExitCode.NETWORK_ERROR);
+    }
+    /**
+     * Display configuration error
+     */
+    static handleConfigError(message) {
+        console.error(this.colorEnabled('Configuration Error:'), message);
+        console.error(chalk_1.default.gray('Use "edgible config reset" to reset your configuration.'));
+        process.exit(ExitCode.CONFIG_ERROR);
+    }
+}
+exports.ErrorHandler = ErrorHandler;
+ErrorHandler.colorEnabled = (text) => chalk_1.default.red(text);
+/**
+ * Wrapper for async command handlers with error handling
+ */
+function withErrorHandling(handler) {
+    return async (...args) => {
+        try {
+            await handler(...args);
+        }
+        catch (error) {
+            ErrorHandler.handleError(error);
+        }
+    };
+}
+/**
+ * Wrap a command action with standardized error handling
+ * Use this for all command actions to ensure consistent error handling
+ */
+function wrapCommandAction(action) {
+    return withErrorHandling(action);
+}
+//# sourceMappingURL=errors.js.map

package/dist/utils/health-checker.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthChecker = void 0;
+const axios_1 = __importDefault(require("axios"));
+class HealthChecker {
+    /**
+     * Perform HTTP health check
+     */
+    static async checkHttpHealth(url, config, options = {}) {
+        const startTime = Date.now();
+        const timeout = options.timeout || config.timeout * 1000 || 5000;
+        try {
+            const response = await (0, axios_1.default)({
+                method: 'GET',
+                url,
+                timeout,
+                headers: {
+                    'User-Agent': 'Edgible-CLI-HealthCheck/1.0',
+                    ...config.headers,
+                    ...options.headers
+                },
+                validateStatus: () => true, // Don't throw on any status code
+                maxRedirects: options.followRedirects ? 5 : 0
+            });
+            const responseTime = Date.now() - startTime;
+            const success = this.evaluateHealthResponse(response, config, options);
+            return {
+                success,
+                url,
+                method: 'GET',
+                statusCode: response.status,
+                responseTime,
+                latency: responseTime,
+                headers: response.headers,
+                body: response.data,
+                host: new URL(url).hostname,
+                port: parseInt(new URL(url).port) || (url.startsWith('https') ? 443 : 80),
+                protocol: url.startsWith('https') ? 'tcp' : 'tcp',
+                timestamp: new Date(),
+                error: success ? undefined : this.generateHealthErrorMessage(response, config, options)
+            };
+        }
+        catch (error) {
+            const responseTime = Date.now() - startTime;
+            return {
+                success: false,
+                url,
+                method: 'GET',
+                host: new URL(url).hostname,
+                port: parseInt(new URL(url).port) || (url.startsWith('https') ? 443 : 80),
+                protocol: 'tcp',
+                timestamp: new Date(),
+                latency: responseTime,
+                error: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    /**
+     * Evaluate HTTP response for health check
+     */
+    static evaluateHealthResponse(response, config, options) {
+        // Check status code
+        const expectedStatus = options.expectedStatus || config.expectedStatus;
+        if (expectedStatus && response.status !== expectedStatus) {
+            return false;
+        }
+        // Check for successful status codes (2xx)
+        if (!expectedStatus && response.status < 200 || response.status >= 300) {
+            return false;
+        }
+        // Check response content
+        const expectedContent = options.expectedContent || config.expectedContent;
+        if (expectedContent && response.data) {
+            const body = typeof response.data === 'string' ? response.data : JSON.stringify(response.data);
+            if (!body.includes(expectedContent)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Generate error message for failed health check
+     */
+    static generateHealthErrorMessage(response, config, options) {
+        const expectedStatus = options.expectedStatus || config.expectedStatus;
+        const expectedContent = options.expectedContent || config.expectedContent;
+        if (expectedStatus && response.status !== expectedStatus) {
+            return `Expected status ${expectedStatus}, got ${response.status}`;
+        }
+        if (expectedContent && response.data) {
+            const body = typeof response.data === 'string' ? response.data : JSON.stringify(response.data);
+            if (!body.includes(expectedContent)) {
+                return `Expected content "${expectedContent}" not found in response`;
+            }
+        }
+        if (response.status >= 400) {
+            return `HTTP error: ${response.status} ${response.statusText}`;
+        }
+        return 'Health check failed';
+    }
+    /**
+     * Perform multiple health checks with retries
+     */
+    static async performHealthChecks(url, config, options = {}) {
+        const retries = options.retries || config.retries || 3;
+        const results = [];
+        for (let i = 0; i < retries; i++) {
+            const result = await this.checkHttpHealth(url, config, options);
+            results.push(result);
+            if (result.success) {
+                break; // Stop on first success
+            }
+            // Wait before retry (exponential backoff)
+            if (i < retries - 1) {
+                await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
+            }
+        }
+        return results;
+    }
+    /**
+     * Check if a service is responding to basic connectivity
+     */
+    static async checkBasicConnectivity(host, port, protocol = 'http') {
+        try {
+            const url = `${protocol}://${host}:${port}`;
+            const response = await axios_1.default.get(url, { timeout: 5000 });
+            return response.status >= 200 && response.status < 500;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Generate health check summary
+     */
+    static generateHealthSummary(results) {
+        const successful = results.filter(r => r.success);
+        const successRate = results.length > 0 ? (successful.length / results.length) * 100 : 0;
+        const averageResponseTime = successful.length > 0
+            ? successful.reduce((sum, r) => sum + (r.responseTime || 0), 0) / successful.length
+            : 0;
+        const errors = results.filter(r => !r.success).map(r => r.error || 'Unknown error');
+        return {
+            overall: successRate === 100,
+            successRate,
+            averageResponseTime,
+            errors
+        };
+    }
+}
+exports.HealthChecker = HealthChecker;
+//# sourceMappingURL=health-checker.js.map

package/dist/utils/json-logger.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonLogger = void 0;
+const logger_1 = require("./logger");
+/**
+ * JSON logger implementation for scripting and automation
+ * Outputs structured JSON logs that can be easily parsed
+ */
+class JsonLogger {
+    constructor(options = {}) {
+        this.level = logger_1.LogLevel.INFO;
+        this.level = options.level ?? logger_1.LogLevel.INFO;
+        this.outputStream = options.outputStream ?? process.stderr;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    getLevel() {
+        return this.level;
+    }
+    debug(message, ...args) {
+        if (this.shouldLog(logger_1.LogLevel.DEBUG)) {
+            this.log(logger_1.LogLevel.DEBUG, message, args);
+        }
+    }
+    info(message, ...args) {
+        if (this.shouldLog(logger_1.LogLevel.INFO)) {
+            this.log(logger_1.LogLevel.INFO, message, args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.shouldLog(logger_1.LogLevel.WARN)) {
+            this.log(logger_1.LogLevel.WARN, message, args);
+        }
+    }
+    error(message, ...args) {
+        if (this.shouldLog(logger_1.LogLevel.ERROR)) {
+            this.log(logger_1.LogLevel.ERROR, message, args);
+        }
+    }
+    shouldLog(level) {
+        return level >= this.level;
+    }
+    log(level, message, args) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level: this.getLevelName(level),
+            message,
+            ...(args.length > 0 && { data: args.length === 1 ? args[0] : args }),
+        };
+        const json = JSON.stringify(entry);
+        this.outputStream.write(json + '\n');
+    }
+    getLevelName(level) {
+        switch (level) {
+            case logger_1.LogLevel.DEBUG:
+                return 'DEBUG';
+            case logger_1.LogLevel.INFO:
+                return 'INFO';
+            case logger_1.LogLevel.WARN:
+                return 'WARN';
+            case logger_1.LogLevel.ERROR:
+                return 'ERROR';
+            case logger_1.LogLevel.NONE:
+                return 'NONE';
+            default:
+                return 'INFO';
+        }
+    }
+}
+exports.JsonLogger = JsonLogger;
+//# sourceMappingURL=json-logger.js.map