@edgible-team/cli 1.0.1

package/dist/utils/PathResolver.js

@@ -0,0 +1,235 @@
+"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.PathResolver = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * PathResolver provides centralized path management following industry standards:
+ * - XDG Base Directory specification on Linux
+ * - Platform-specific conventions on macOS and Windows
+ * - Proper handling of sudo contexts (preserves real user)
+ */
+class PathResolver {
+    /**
+     * Get the real user's home directory, even when running under sudo.
+     * Detects the actual user via SUDO_USER environment variable.
+     *
+     * @returns The real user's home directory path
+     */
+    static getRealUserHome() {
+        // Check if running under sudo
+        const sudoUser = process.env['SUDO_USER'];
+        if (sudoUser) {
+            // If current user is root but SUDO_USER is set, get the sudo user's home
+            if (process.getuid && process.getuid() === 0 && sudoUser) {
+                const fs = require('fs');
+                const { execSync } = require('child_process');
+                try {
+                    // Try to get the home directory using getent (Linux) or dscl (macOS)
+                    if (process.platform === 'linux') {
+                        try {
+                            const homeDir = execSync(`getent passwd ${sudoUser} | cut -d: -f6`, { encoding: 'utf8' }).trim();
+                            if (fs.existsSync(homeDir)) {
+                                return homeDir;
+                            }
+                        }
+                        catch {
+                            // Fall through to default path construction
+                        }
+                        // Fallback: construct path
+                        const homeDir = `/home/${sudoUser}`;
+                        if (fs.existsSync(homeDir)) {
+                            return homeDir;
+                        }
+                    }
+                    else if (process.platform === 'darwin') {
+                        try {
+                            const homeDir = execSync(`dscl . -read /Users/${sudoUser} NFSHomeDirectory | cut -d' ' -f2`, { encoding: 'utf8' }).trim();
+                            if (fs.existsSync(homeDir)) {
+                                return homeDir;
+                            }
+                        }
+                        catch {
+                            // Fall through to default path construction
+                        }
+                        // Fallback: construct path
+                        const homeDir = `/Users/${sudoUser}`;
+                        if (fs.existsSync(homeDir)) {
+                            return homeDir;
+                        }
+                    }
+                }
+                catch (error) {
+                    // Fall through to default behavior
+                }
+            }
+        }
+        // Default: use current user's home directory
+        return os.homedir();
+    }
+    /**
+     * Get the user-level data directory for CLI configuration and data.
+     * Follows XDG Base Directory spec on Linux, platform conventions elsewhere.
+     *
+     * @returns The user data directory path
+     */
+    static getUserDataPath() {
+        const platform = os.platform();
+        const realHome = this.getRealUserHome();
+        if (platform === 'linux') {
+            // Follow XDG Base Directory specification
+            const xdgDataHome = process.env['XDG_DATA_HOME'];
+            if (xdgDataHome) {
+                return path.join(xdgDataHome, 'edgible');
+            }
+            // Default: ~/.local/share/edgible
+            return path.join(realHome, '.local', 'share', 'edgible');
+        }
+        else if (platform === 'darwin') {
+            // macOS: ~/Library/Application Support/Edgible
+            return path.join(realHome, 'Library', 'Application Support', 'Edgible');
+        }
+        else if (platform === 'win32') {
+            // Windows: %APPDATA%\Edgible
+            const appData = process.env['APPDATA'] || path.join(realHome, 'AppData', 'Roaming');
+            return path.join(appData, 'Edgible');
+        }
+        else {
+            // Fallback for other platforms
+            return path.join(realHome, '.edgible');
+        }
+    }
+    /**
+     * Get the system-level data directory for agent services.
+     * Used when the agent runs as a system service (systemd, launchd, etc.)
+     *
+     * @returns The system data directory path
+     */
+    static getSystemDataPath() {
+        const platform = os.platform();
+        if (platform === 'linux') {
+            // Linux: /var/lib/edgible
+            return '/var/lib/edgible';
+        }
+        else if (platform === 'darwin') {
+            // macOS: /Library/Application Support/Edgible
+            return '/Library/Application Support/Edgible';
+        }
+        else if (platform === 'win32') {
+            // Windows: C:\ProgramData\Edgible
+            const programData = process.env['ProgramData'] || 'C:\\ProgramData';
+            return path.join(programData, 'Edgible');
+        }
+        else {
+            // Fallback for other platforms
+            return '/var/lib/edgible';
+        }
+    }
+    /**
+     * Get the agent configuration directory path.
+     * For CLI: returns user data path + '/agent'
+     * For system services: returns system data path + '/agent'
+     *
+     * @param useSystemPath - If true, use system path; otherwise use user path
+     * @returns The agent configuration directory path
+     */
+    static getAgentConfigPath(useSystemPath = false) {
+        const basePath = useSystemPath ? this.getSystemDataPath() : this.getUserDataPath();
+        return path.join(basePath, 'agent');
+    }
+    /**
+     * Get the CLI configuration file path.
+     *
+     * @returns The CLI config.json file path
+     */
+    static getCliConfigPath() {
+        const userDataPath = this.getUserDataPath();
+        return path.join(userDataPath, 'config.json');
+    }
+    /**
+     * Get the agent configuration file path.
+     *
+     * @param useSystemPath - If true, use system path; otherwise use user path
+     * @returns The agent.config.json file path
+     */
+    static getAgentConfigFilePath(useSystemPath = false) {
+        const agentConfigPath = this.getAgentConfigPath(useSystemPath);
+        return path.join(agentConfigPath, 'agent.config.json');
+    }
+    /**
+     * Get the agent status file path.
+     *
+     * @param useSystemPath - If true, use system path; otherwise use user path
+     * @returns The status.json file path
+     */
+    static getAgentStatusPath(useSystemPath = false) {
+        const agentConfigPath = this.getAgentConfigPath(useSystemPath);
+        return path.join(agentConfigPath, 'status.json');
+    }
+    /**
+     * Resolve the agent config path based on installation type.
+     * For systemd/launchd/windows-service: uses system path
+     * For docker/podman: uses system path (mounted in container)
+     * Otherwise: uses user path
+     *
+     * @param installationType - The agent installation type
+     * @returns The appropriate agent config path
+     */
+    static resolveAgentConfigPath(installationType) {
+        const useSystemPath = installationType === 'systemd' ||
+            installationType === 'launchd' ||
+            installationType === 'windows-service' ||
+            installationType === 'docker' ||
+            installationType === 'podman';
+        return this.getAgentConfigPath(useSystemPath);
+    }
+    /**
+     * Resolve the agent config file path based on installation type.
+     *
+     * @param installationType - The agent installation type
+     * @returns The appropriate agent config file path
+     */
+    static resolveAgentConfigFilePath(installationType) {
+        const useSystemPath = installationType === 'systemd' ||
+            installationType === 'launchd' ||
+            installationType === 'windows-service' ||
+            installationType === 'docker' ||
+            installationType === 'podman';
+        return this.getAgentConfigFilePath(useSystemPath);
+    }
+}
+exports.PathResolver = PathResolver;
+//# sourceMappingURL=PathResolver.js.map

package/dist/utils/PlatformDetector.js

@@ -0,0 +1,277 @@
+"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.PlatformDetector = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const os = __importStar(require("os"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class PlatformDetector {
+    /**
+     * Get the current platform
+     */
+    static getPlatform() {
+        const platform = os.platform();
+        if (platform === 'darwin')
+            return 'darwin';
+        if (platform === 'win32')
+            return 'win32';
+        return 'linux';
+    }
+    /**
+     * Check if running as root/administrator
+     */
+    static async isRoot() {
+        const platform = this.getPlatform();
+        if (platform === 'win32') {
+            try {
+                // On Windows, try to access a protected directory
+                await execAsync('net session >nul 2>&1');
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        else {
+            // On Unix-like systems, check if UID is 0
+            return process.getuid !== undefined && process.getuid() === 0;
+        }
+    }
+    /**
+     * Check if systemd is available (Linux)
+     */
+    static async hasSystemd() {
+        if (this.getPlatform() !== 'linux')
+            return false;
+        try {
+            await execAsync('which systemctl');
+            // Check if systemd is running
+            const { stdout } = await execAsync('ps -p 1 -o comm=');
+            return stdout.trim() === 'systemd';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if launchd is available (macOS)
+     */
+    static async hasLaunchd() {
+        if (this.getPlatform() !== 'darwin')
+            return false;
+        try {
+            await execAsync('which launchctl');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if Docker is available
+     */
+    static async hasDocker() {
+        try {
+            await execAsync('docker --version');
+            // Also check if Docker daemon is running
+            await execAsync('docker ps');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if Podman is available
+     */
+    static async hasPodman() {
+        try {
+            await execAsync('podman --version');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if Node.js is available
+     */
+    static async hasNode() {
+        try {
+            await execAsync('node --version');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the path to Node.js executable
+     */
+    static async getNodePath() {
+        const platform = this.getPlatform();
+        try {
+            const command = platform === 'win32' ? 'where node' : 'which node';
+            const { stdout } = await execAsync(command);
+            return stdout.trim().split('\n')[0]; // Get first result
+        }
+        catch {
+            return platform === 'win32' ? 'node.exe' : 'node';
+        }
+    }
+    /**
+     * Get all available installation options for the current platform
+     */
+    static async getAvailableOptions() {
+        const platform = this.getPlatform();
+        const isRoot = await this.isRoot();
+        const hasSystemd = await this.hasSystemd();
+        const hasLaunchd = await this.hasLaunchd();
+        const hasDocker = await this.hasDocker();
+        const hasPodman = await this.hasPodman();
+        const options = [];
+        // Linux: systemd option
+        if (platform === 'linux') {
+            options.push({
+                type: 'systemd',
+                name: 'System Service (systemd)',
+                description: 'Run as a native Linux systemd service',
+                requires: ['systemd', 'root privileges'],
+                pros: ['Native performance', 'Direct system access', 'Integrated with system logs'],
+                cons: ['Requires root privileges', 'Platform-specific'],
+                bestFor: 'Production servers, bare metal deployments',
+                available: hasSystemd && isRoot,
+                requiresRoot: true
+            });
+        }
+        // macOS: launchd option
+        if (platform === 'darwin') {
+            options.push({
+                type: 'launchd',
+                name: 'System Service (launchd)',
+                description: 'Run as a native macOS launchd service',
+                requires: ['launchd', 'root privileges'],
+                pros: ['Native macOS integration', 'System-managed lifecycle', 'Integrated logs'],
+                cons: ['Requires root privileges', 'macOS-specific'],
+                bestFor: 'macOS servers, development machines',
+                available: hasLaunchd && isRoot,
+                requiresRoot: true
+            });
+        }
+        // Windows: Windows Service option
+        if (platform === 'win32') {
+            options.push({
+                type: 'windows-service',
+                name: 'Windows Service',
+                description: 'Run as a native Windows service',
+                requires: ['Administrator privileges'],
+                pros: ['Native Windows integration', 'System-managed lifecycle', 'Windows Event Log'],
+                cons: ['Requires administrator privileges', 'Windows-specific'],
+                bestFor: 'Windows servers, production deployments',
+                available: isRoot,
+                requiresRoot: true
+            });
+        }
+        // Docker option (all platforms)
+        options.push({
+            type: 'docker',
+            name: 'Docker Container',
+            description: 'Run as a Docker container with systemd/launchd wrapper',
+            requires: ['Docker', platform !== 'win32' ? 'root privileges' : 'Docker Desktop'],
+            pros: ['Isolated environment', 'Easy updates', 'Cross-platform', 'Reproducible'],
+            cons: ['Requires Docker daemon', 'Slight performance overhead', 'Needs privileged mode'],
+            bestFor: 'Containerized infrastructure, development, CI/CD',
+            available: hasDocker && (platform === 'win32' || isRoot),
+            requiresRoot: platform !== 'win32'
+        });
+        // Podman option (all platforms)
+        options.push({
+            type: 'podman',
+            name: 'Podman Container (Rootless)',
+            description: 'Run as a rootless Podman container',
+            requires: ['Podman'],
+            pros: ['Rootless operation', 'Container isolation', 'Docker-compatible', 'No daemon required'],
+            cons: ['Requires Podman', 'Some network limitations in rootless mode'],
+            bestFor: 'User-space deployments, restricted environments, development',
+            available: hasPodman,
+            requiresRoot: false
+        });
+        return options;
+    }
+    /**
+     * Get the recommended installation type for the current platform
+     */
+    static async getRecommendedType() {
+        const options = await this.getAvailableOptions();
+        const available = options.filter(opt => opt.available);
+        if (available.length === 0) {
+            return null;
+        }
+        // Prefer native options first, then containers
+        const platform = this.getPlatform();
+        if (platform === 'linux' && available.find(opt => opt.type === 'systemd')) {
+            return 'systemd';
+        }
+        if (platform === 'darwin' && available.find(opt => opt.type === 'launchd')) {
+            return 'launchd';
+        }
+        if (platform === 'win32' && available.find(opt => opt.type === 'windows-service')) {
+            return 'windows-service';
+        }
+        // Fall back to containers
+        if (available.find(opt => opt.type === 'docker')) {
+            return 'docker';
+        }
+        if (available.find(opt => opt.type === 'podman')) {
+            return 'podman';
+        }
+        return null;
+    }
+    /**
+     * Get installation requirements message for when not running as root
+     */
+    static getRootRequirementMessage() {
+        const platform = this.getPlatform();
+        if (platform === 'win32') {
+            return 'Please run this command as Administrator to use native Windows Service or Docker options.';
+        }
+        else {
+            return 'Please run this command with sudo to use native system service or Docker options.';
+        }
+    }
+}
+exports.PlatformDetector = PlatformDetector;
+//# sourceMappingURL=PlatformDetector.js.map

package/dist/utils/console-logger.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.ConsoleLogger = void 0;
+exports.getLogger = getLogger;
+exports.setLogger = setLogger;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("./logger");
+/**
+ * Console logger implementation
+ * Formats and outputs logs to console with colors and formatting
+ */
+class ConsoleLogger {
+    constructor(options = {}) {
+        this.level = logger_1.LogLevel.INFO;
+        this.colorEnabled = true;
+        this.plain = false;
+        this.level = options.level ?? logger_1.LogLevel.INFO;
+        this.colorEnabled = options.colorEnabled ?? true;
+        this.plain = options.plain ?? false;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    getLevel() {
+        return this.level;
+    }
+    setColorEnabled(enabled) {
+        this.colorEnabled = enabled;
+    }
+    setPlain(plain) {
+        this.plain = plain;
+    }
+    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(),
+            level,
+            message,
+            args,
+        };
+        if (this.plain) {
+            this.logPlain(entry);
+        }
+        else {
+            this.logFormatted(entry);
+        }
+    }
+    logPlain(entry) {
+        const levelName = (0, logger_1.getLogLevelName)(entry.level);
+        const formatted = `${levelName}: ${entry.message}`;
+        if (entry.args.length > 0) {
+            console.log(formatted, ...entry.args);
+        }
+        else {
+            console.log(formatted);
+        }
+    }
+    logFormatted(entry) {
+        const prefix = this.getPrefix(entry.level);
+        if (entry.args.length > 0) {
+            console.log(prefix, entry.message, ...entry.args);
+        }
+        else {
+            console.log(prefix, entry.message);
+        }
+    }
+    getPrefix(level) {
+        if (!this.colorEnabled) {
+            return `[${(0, logger_1.getLogLevelName)(level)}]`;
+        }
+        switch (level) {
+            case logger_1.LogLevel.DEBUG:
+                return chalk_1.default.gray('[DEBUG]');
+            case logger_1.LogLevel.INFO:
+                return chalk_1.default.blue('[INFO]');
+            case logger_1.LogLevel.WARN:
+                return chalk_1.default.yellow('[WARN]');
+            case logger_1.LogLevel.ERROR:
+                return chalk_1.default.red('[ERROR]');
+            default:
+                return `[${(0, logger_1.getLogLevelName)(level)}]`;
+        }
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+/**
+ * Default logger instance (can be replaced for testing)
+ */
+let defaultLogger = null;
+/**
+ * Get or create default logger instance
+ */
+function getLogger() {
+    if (!defaultLogger) {
+        defaultLogger = new ConsoleLogger();
+    }
+    return defaultLogger;
+}
+/**
+ * Set default logger instance (useful for testing)
+ */
+function setLogger(logger) {
+    defaultLogger = logger;
+}
+//# sourceMappingURL=console-logger.js.map