@edgible-team/cli 1.0.1

package/dist/services/DependencyInstaller.js

@@ -0,0 +1,475 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyInstaller = void 0;
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+class DependencyInstaller {
+    /**
+     * Get the original user when running under sudo
+     * @returns The SUDO_USER if running as root via sudo, otherwise undefined
+     */
+    getSudoUser() {
+        const uid = process.getuid ? process.getuid() : undefined;
+        const sudoUser = process.env['SUDO_USER'];
+        // Only return SUDO_USER if we're actually running as root (uid 0)
+        if (uid === 0 && sudoUser) {
+            return sudoUser;
+        }
+        return undefined;
+    }
+    /**
+     * Execute a command, running as the original user if executed via sudo
+     * This is particularly important for Homebrew, which refuses to run as root
+     * @param command The command to execute
+     * @returns The stdout from execSync
+     */
+    execAsRealUser(command) {
+        const sudoUser = this.getSudoUser();
+        if (sudoUser) {
+            // Running under sudo - execute as the original user
+            // Use 'sudo -u' to run the command as the original user
+            // Pass through the HOME environment variable to ensure Homebrew works correctly
+            const wrappedCommand = `sudo -u ${sudoUser} HOME=$(eval echo ~${sudoUser}) ${command}`;
+            return (0, child_process_1.execSync)(wrappedCommand);
+        }
+        else {
+            // Not running under sudo - execute normally
+            return (0, child_process_1.execSync)(command);
+        }
+    }
+    async checkAndInstallDependencies(options = {}) {
+        console.log('Checking dependencies...');
+        const sudoUser = this.getSudoUser();
+        if (sudoUser) {
+            console.log(chalk_1.default.gray(`Running under sudo - package manager commands will execute as user: ${sudoUser}`));
+        }
+        const platform = os.platform();
+        const packageManager = await this.detectPackageManager(platform);
+        const dependencies = [
+            { name: 'WireGuard', check: this.isWireGuardInstalled.bind(this), install: this.installWireGuard.bind(this) },
+            { name: 'Caddy', check: this.isCaddyInstalled.bind(this), install: this.installCaddy.bind(this) },
+            { name: 'HAProxy', check: this.isHAProxyInstalled.bind(this), install: this.installHAProxy.bind(this) },
+        ];
+        if (options.includeIptables) {
+            dependencies.push({ name: 'iptables', check: this.isIptablesInstalled.bind(this), install: this.installIptables.bind(this) });
+        }
+        if (options.includeWireGuardGo) {
+            dependencies.push({ name: 'wireguard-go', check: this.isWireGuardGoInstalled.bind(this), install: this.installWireGuardGo.bind(this) });
+        }
+        for (const dep of dependencies) {
+            if (!(await dep.check(platform))) {
+                let install = false;
+                if (options.autoInstall) {
+                    install = true;
+                }
+                else {
+                    install = await this.promptForInstallation(dep.name);
+                }
+                if (install) {
+                    console.log(chalk_1.default.yellow(`${dep.name} is not installed. Attempting to install...`));
+                    await dep.install(platform, packageManager);
+                }
+            }
+            else {
+                console.log(chalk_1.default.green(`✓ ${dep.name} is already installed.`));
+            }
+        }
+    }
+    async promptForInstallation(dependencyName) {
+        const { install } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'install',
+                message: `Would you like to install ${dependencyName}?`,
+                default: true,
+            },
+        ]);
+        return install;
+    }
+    async detectPackageManager(platform) {
+        if (platform === 'darwin') {
+            try {
+                this.execAsRealUser('which brew');
+                return 'brew';
+            }
+            catch (error) {
+                return 'unknown';
+            }
+        }
+        if (platform === 'linux') {
+            try {
+                (0, child_process_1.execSync)('which apt-get');
+                return 'apt-get';
+            }
+            catch (error) {
+                // apt-get not found, check for dnf
+            }
+            try {
+                (0, child_process_1.execSync)('which dnf');
+                return 'dnf';
+            }
+            catch (error) {
+                // dnf not found, check for yum
+            }
+            try {
+                (0, child_process_1.execSync)('which yum');
+                return 'yum';
+            }
+            catch (error) {
+                return 'unknown';
+            }
+        }
+        if (platform === 'win32') {
+            try {
+                (0, child_process_1.execSync)('winget --version');
+                return 'winget';
+            }
+            catch (error) {
+                return 'unknown';
+            }
+        }
+        return 'unknown';
+    }
+    async isWireGuardInstalled(platform) {
+        try {
+            switch (platform) {
+                case 'linux':
+                case 'darwin':
+                    (0, child_process_1.execSync)('which wg');
+                    return true;
+                case 'win32':
+                    (0, child_process_1.execSync)('where wg');
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async isCaddyInstalled(platform) {
+        try {
+            switch (platform) {
+                case 'linux':
+                case 'darwin':
+                    (0, child_process_1.execSync)('which caddy');
+                    return true;
+                case 'win32':
+                    (0, child_process_1.execSync)('where caddy');
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async installWireGuard(platform, packageManager) {
+        console.log(`Installing WireGuard for ${platform} using ${packageManager}...`);
+        try {
+            switch (platform) {
+                case 'linux':
+                    if (packageManager === 'apt-get') {
+                        (0, child_process_1.execSync)('sudo apt-get update && sudo apt-get install -y wireguard');
+                    }
+                    else if (packageManager === 'dnf') {
+                        (0, child_process_1.execSync)('sudo dnf install -y wireguard-tools');
+                    }
+                    else if (packageManager === 'yum') {
+                        (0, child_process_1.execSync)('sudo yum install -y elrepo-release epel-release && sudo yum install -y kmod-wireguard wireguard-tools');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Unsupported package manager for Linux. Please install WireGuard manually.'));
+                    }
+                    break;
+                case 'darwin':
+                    if (packageManager === 'brew') {
+                        this.execAsRealUser('brew install wireguard-tools');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Homebrew not found. Please install Homebrew and try again, or install WireGuard manually.'));
+                    }
+                    break;
+                case 'win32':
+                    if (packageManager === 'winget') {
+                        (0, child_process_1.execSync)('winget install -e --id WireGuard.WireGuard');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('winget not found. Please install winget and try again, or install WireGuard manually.'));
+                    }
+                    break;
+                default:
+                    console.log(chalk_1.default.red(`Unsupported platform: ${platform}`));
+            }
+            console.log(chalk_1.default.green('WireGuard installed successfully.'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Failed to install WireGuard:'), error);
+            throw error;
+        }
+    }
+    async installCaddy(platform, packageManager) {
+        console.log(`Installing Caddy for ${platform} using ${packageManager}...`);
+        try {
+            switch (platform) {
+                case 'linux':
+                    if (packageManager === 'apt-get') {
+                        (0, child_process_1.execSync)('sudo apt-get update && sudo apt-get install -y caddy');
+                    }
+                    else if (packageManager === 'dnf') {
+                        (0, child_process_1.execSync)('sudo dnf install -y caddy');
+                    }
+                    else if (packageManager === 'yum') {
+                        (0, child_process_1.execSync)('sudo yum install -y caddy');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Unsupported package manager for Linux. Please install Caddy manually.'));
+                    }
+                    break;
+                case 'darwin':
+                    if (packageManager === 'brew') {
+                        this.execAsRealUser('brew install caddy');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Homebrew not found. Please install Homebrew and try again, or install Caddy manually.'));
+                    }
+                    break;
+                case 'win32':
+                    if (packageManager === 'winget') {
+                        (0, child_process_1.execSync)('winget install -e --id Caddy.Caddy');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('winget not found. Please install winget and try again, or install Caddy manually.'));
+                    }
+                    break;
+                default:
+                    console.log(chalk_1.default.red(`Unsupported platform: ${platform}`));
+            }
+            console.log(chalk_1.default.green('Caddy installed successfully.'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Failed to install Caddy:'), error);
+            throw error;
+        }
+    }
+    async isHAProxyInstalled(platform) {
+        try {
+            switch (platform) {
+                case 'linux':
+                case 'darwin':
+                    (0, child_process_1.execSync)('which haproxy');
+                    return true;
+                case 'win32':
+                    (0, child_process_1.execSync)('where haproxy');
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async installHAProxy(platform, packageManager) {
+        console.log(`Installing HAProxy for ${platform} using ${packageManager}...`);
+        try {
+            switch (platform) {
+                case 'linux':
+                    if (packageManager === 'apt-get') {
+                        (0, child_process_1.execSync)('sudo apt-get update && sudo apt-get install -y haproxy');
+                    }
+                    else if (packageManager === 'dnf') {
+                        (0, child_process_1.execSync)('sudo dnf install -y haproxy');
+                    }
+                    else if (packageManager === 'yum') {
+                        (0, child_process_1.execSync)('sudo yum install -y haproxy');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Unsupported package manager for Linux. Please install HAProxy manually.'));
+                    }
+                    break;
+                case 'darwin':
+                    if (packageManager === 'brew') {
+                        this.execAsRealUser('brew install haproxy');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Homebrew not found. Please install Homebrew and try again, or install HAProxy manually.'));
+                    }
+                    break;
+                case 'win32':
+                    console.log(chalk_1.default.yellow('HAProxy installation on Windows is not supported via this installer. Please install HAProxy manually.'));
+                    break;
+                default:
+                    console.log(chalk_1.default.red(`Unsupported platform: ${platform}`));
+            }
+            console.log(chalk_1.default.green('HAProxy installed successfully.'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Failed to install HAProxy:'), error);
+            throw error;
+        }
+    }
+    async isWireGuardGoInstalled(platform) {
+        try {
+            switch (platform) {
+                case 'linux':
+                case 'darwin':
+                    (0, child_process_1.execSync)('which wireguard-go');
+                    return true;
+                case 'win32':
+                    (0, child_process_1.execSync)('where wireguard-go');
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async installWireGuardGo(platform, packageManager) {
+        console.log(`Installing wireguard-go for ${platform} using ${packageManager}...`);
+        try {
+            switch (platform) {
+                case 'linux':
+                    if (packageManager === 'apt-get') {
+                        (0, child_process_1.execSync)('sudo apt-get update && sudo apt-get install -y wireguard-go');
+                    }
+                    else if (packageManager === 'dnf') {
+                        (0, child_process_1.execSync)('sudo dnf install -y wireguard-tools');
+                        // wireguard-go might be in a separate package or need to be built from source
+                        console.log(chalk_1.default.yellow('Note: wireguard-go may need to be installed from source on some distributions.'));
+                        console.log(chalk_1.default.yellow('See: https://git.zx2c4.com/wireguard-go/about/'));
+                    }
+                    else if (packageManager === 'yum') {
+                        (0, child_process_1.execSync)('sudo yum install -y wireguard-tools');
+                        console.log(chalk_1.default.yellow('Note: wireguard-go may need to be installed from source on some distributions.'));
+                        console.log(chalk_1.default.yellow('See: https://git.zx2c4.com/wireguard-go/about/'));
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Unsupported package manager for Linux. Please install wireguard-go manually.'));
+                        console.log(chalk_1.default.yellow('See: https://git.zx2c4.com/wireguard-go/about/'));
+                    }
+                    break;
+                case 'darwin':
+                    if (packageManager === 'brew') {
+                        this.execAsRealUser('brew install wireguard-go');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Homebrew not found. Please install Homebrew and try again, or install wireguard-go manually.'));
+                    }
+                    break;
+                case 'win32':
+                    console.log(chalk_1.default.yellow('wireguard-go installation on Windows is not supported via this installer. Please install wireguard-go manually.'));
+                    break;
+                default:
+                    console.log(chalk_1.default.red(`Unsupported platform: ${platform}`));
+            }
+            console.log(chalk_1.default.green('wireguard-go installed successfully.'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Failed to install wireguard-go:'), error);
+            console.log(chalk_1.default.yellow('You may need to install wireguard-go manually.'));
+            console.log(chalk_1.default.yellow('See: https://git.zx2c4.com/wireguard-go/about/'));
+            throw error;
+        }
+    }
+    async isIptablesInstalled(platform) {
+        try {
+            switch (platform) {
+                case 'linux':
+                    (0, child_process_1.execSync)('which iptables');
+                    return true;
+                case 'darwin':
+                    // macOS uses pfctl, not iptables
+                    return false;
+                case 'win32':
+                    // Windows doesn't use iptables
+                    return false;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async installIptables(platform, packageManager) {
+        console.log(`Installing iptables for ${platform} using ${packageManager}...`);
+        try {
+            switch (platform) {
+                case 'linux':
+                    if (packageManager === 'apt-get') {
+                        (0, child_process_1.execSync)('sudo apt-get update && sudo apt-get install -y iptables');
+                    }
+                    else if (packageManager === 'dnf') {
+                        (0, child_process_1.execSync)('sudo dnf install -y iptables');
+                    }
+                    else if (packageManager === 'yum') {
+                        (0, child_process_1.execSync)('sudo yum install -y iptables');
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Unsupported package manager for Linux. Please install iptables manually.'));
+                    }
+                    break;
+                case 'darwin':
+                    console.log(chalk_1.default.yellow('macOS uses pfctl instead of iptables. Firewall management may not work as expected.'));
+                    break;
+                case 'win32':
+                    console.log(chalk_1.default.yellow('Windows uses Windows Firewall instead of iptables. Firewall management may not work as expected.'));
+                    break;
+                default:
+                    console.log(chalk_1.default.red(`Unsupported platform: ${platform}`));
+            }
+            if (platform === 'linux') {
+                console.log(chalk_1.default.green('iptables installed successfully.'));
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Failed to install iptables:'), error);
+            throw error;
+        }
+    }
+}
+exports.DependencyInstaller = DependencyInstaller;
+//# sourceMappingURL=DependencyInstaller.js.map