@edgible-team/cli 1.0.1

package/dist/commands/managedGateway.js

@@ -0,0 +1,787 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupManagedGatewayCommands = setupManagedGatewayCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const command_wrapper_1 = require("./base/command-wrapper");
+const container_1 = require("../di/container");
+const types_1 = require("../di/types");
+const config_validator_1 = require("./utils/config-validator");
+const log_formatter_1 = require("../utils/log-formatter");
+/**
+ * Managed Gateway debug command group (admin only)
+ */
+function setupManagedGatewayCommands(program) {
+    const managedGatewayCommand = program
+        .command('managed-gateway')
+        .description('Debug commands for managing Edgible-managed gateways (admin only)')
+        .alias('mgw');
+    managedGatewayCommand
+        .command('create')
+        .description('Create a new managed gateway')
+        .addHelpText('after', `
+Examples:
+  $ edgible managed-gateway create --name mygateway --region us-east-1
+  $ edgible managed-gateway create --name mygateway --region us-east-1 --instance-type t3.micro
+  `)
+        .option('-n, --name <name>', 'Gateway name')
+        .option('-r, --region <region>', 'AWS region', 'ap-southeast-2')
+        .option('-t, --instance-type <type>', 'EC2 instance type', 't3.micro')
+        .alias('new')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayName = options.name;
+        const region = options.region || 'ap-southeast-2';
+        const instanceType = options.instanceType || 't3.micro';
+        if (!gatewayName) {
+            const nameAnswer = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Enter gateway name:',
+                    validate: (input) => {
+                        if (!input.trim()) {
+                            return 'Gateway name is required';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            gatewayName = nameAnswer.name.trim();
+        }
+        logger.info('Creating managed gateway', { name: gatewayName, region, instanceType });
+        const result = await edgibleService.createManagedGateway({
+            name: gatewayName,
+            region,
+            instanceType
+        });
+        console.log(chalk_1.default.green('\n✓ Managed gateway created successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Gateway Details:'));
+        console.log(chalk_1.default.white(`  ID: ${result.gateway.id}`));
+        console.log(chalk_1.default.white(`  Name: ${result.gateway.name}`));
+        console.log(chalk_1.default.white(`  IP Address: ${result.gateway.ipAddress || 'N/A'}`));
+        console.log(chalk_1.default.white(`  Status: ${result.gateway.status || 'N/A'}`));
+        console.log(chalk_1.default.white(`  Created: ${new Date(result.gateway.createdAt).toLocaleString()}`));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('list')
+        .description('List all managed gateways')
+        .option('--json', 'Output as JSON')
+        .alias('ls')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        logger.debug('Listing managed gateways');
+        const response = await edgibleService.listManagedGateways();
+        if (!response.success || !response.gateways || response.gateways.length === 0) {
+            console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+            return;
+        }
+        if (options.json) {
+            console.log(JSON.stringify({
+                gateways: response.gateways.map((gateway) => ({
+                    id: gateway.id,
+                    name: gateway.name,
+                    description: gateway.description,
+                    ipAddress: gateway.ipAddress,
+                    status: gateway.status,
+                    lastSeen: gateway.lastSeen,
+                    createdAt: gateway.createdAt,
+                    organizationId: gateway.organizationId,
+                })),
+            }, null, 2));
+            return;
+        }
+        console.log(chalk_1.default.blue('\n🌐 Managed Gateways:'));
+        response.gateways.forEach((gateway) => {
+            console.log(chalk_1.default.white(`\n  ID: ${gateway.id}`));
+            console.log(chalk_1.default.white(`  Name: ${gateway.name}`));
+            if (gateway.description) {
+                console.log(chalk_1.default.gray(`  Description: ${gateway.description}`));
+            }
+            console.log(chalk_1.default.white(`  IP Address: ${gateway.ipAddress || 'N/A'}`));
+            console.log(chalk_1.default.white(`  Status: ${gateway.status || 'N/A'}`));
+            console.log(chalk_1.default.white(`  Last Seen: ${gateway.lastSeen ? new Date(gateway.lastSeen).toLocaleString() : 'N/A'}`));
+            console.log(chalk_1.default.white(`  Created: ${new Date(gateway.createdAt).toLocaleString()}`));
+        });
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('get')
+        .description('Get details of a specific managed gateway')
+        .option('-i, --id <id>', 'Gateway ID')
+        .alias('status')
+        .alias('info')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await edgibleService.listManagedGateways();
+            if (!listResponse.success || !listResponse.gateways || listResponse.gateways.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+                return;
+            }
+            const choices = listResponse.gateways.map((gateway) => ({
+                name: `${gateway.name} (${gateway.id})`,
+                value: gateway.id,
+            }));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gatewayId',
+                    message: 'Select managed gateway:',
+                    choices,
+                },
+            ]);
+            gatewayId = answer.gatewayId;
+        }
+        logger.info('Getting managed gateway details', { gatewayId });
+        const response = await edgibleService.getManagedGateway(gatewayId);
+        if (!response.success || !response.gateway) {
+            console.log(chalk_1.default.red('✗ Managed gateway not found'));
+            return;
+        }
+        const gateway = response.gateway;
+        console.log(chalk_1.default.blue('\n📋 Managed Gateway Details:'));
+        console.log(chalk_1.default.white(`  ID: ${gateway.id}`));
+        console.log(chalk_1.default.white(`  Name: ${gateway.name}`));
+        if (gateway.description) {
+            console.log(chalk_1.default.gray(`  Description: ${gateway.description}`));
+        }
+        console.log(chalk_1.default.white(`  IP Address: ${gateway.ipAddress || 'N/A'}`));
+        console.log(chalk_1.default.white(`  Status: ${gateway.status || 'N/A'}`));
+        console.log(chalk_1.default.white(`  Last Seen: ${gateway.lastSeen ? new Date(gateway.lastSeen).toLocaleString() : 'N/A'}`));
+        console.log(chalk_1.default.white(`  Created: ${new Date(gateway.createdAt).toLocaleString()}`));
+        console.log(chalk_1.default.white(`  Organization ID: ${gateway.organizationId}`));
+        if (gateway.capacity) {
+            console.log(chalk_1.default.blue('\n📊 Capacity:'));
+            console.log(chalk_1.default.white(`  Current Applications: ${gateway.capacity.currentApps}`));
+            console.log(chalk_1.default.white(`  Max Applications: ${gateway.capacity.maxApps}`));
+            const usagePercent = (gateway.capacity.currentApps / gateway.capacity.maxApps) * 100;
+            console.log(chalk_1.default.white(`  Usage: ${usagePercent.toFixed(1)}%`));
+        }
+        if (gateway.health) {
+            console.log(chalk_1.default.blue('\n🏥 Health:'));
+            console.log(chalk_1.default.white(`  Healthy: ${gateway.health.healthy ? chalk_1.default.green('Yes') : chalk_1.default.red('No')}`));
+            console.log(chalk_1.default.white(`  Last Seen: ${gateway.health.lastSeen ? new Date(gateway.health.lastSeen).toLocaleString() : 'N/A'}`));
+            console.log(chalk_1.default.white(`  Application Count: ${gateway.health.applicationCount}`));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('delete')
+        .description('Delete a managed gateway')
+        .option('-i, --id <id>', 'Gateway ID to delete')
+        .option('-f, --force', 'Force delete even if applications exist')
+        .alias('rm')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await edgibleService.listManagedGateways();
+            if (!listResponse.success || !listResponse.gateways || listResponse.gateways.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+                return;
+            }
+            const choices = listResponse.gateways.map((gateway) => ({
+                name: `${gateway.name} (${gateway.id})`,
+                value: gateway.id,
+            }));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gatewayId',
+                    message: 'Select managed gateway to delete:',
+                    choices,
+                },
+            ]);
+            gatewayId = answer.gatewayId;
+        }
+        // Confirm deletion
+        const confirm = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Are you sure you want to delete managed gateway ${gatewayId}?`,
+                default: false,
+            },
+        ]);
+        if (!confirm.confirm) {
+            logger.info('Managed gateway deletion cancelled');
+            console.log(chalk_1.default.gray('Deletion cancelled'));
+            return;
+        }
+        logger.info('Deleting managed gateway', { gatewayId, force: options.force || false });
+        await edgibleService.deleteManagedGateway(gatewayId, options.force || false);
+        console.log(chalk_1.default.green('✓ Managed gateway deleted successfully!'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('resync')
+        .description('Resync agent code on a managed gateway')
+        .option('-i, --id <id>', 'Gateway ID to resync')
+        .option('-v, --version <version>', 'Agent version to deploy')
+        .option('--local', 'Upload agent from local dist directory instead of downloading from S3')
+        .option('--install-from-local', 'Upload agent from local dist directory instead of downloading from S3')
+        .option('--reboot', 'Reboot the gateway after resync completes')
+        .option('--wipe-logs', 'Wipe agent logs before resync')
+        .option('--debug', 'Set agent log level to debug')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        // Map --local to installFromLocal for backward compatibility
+        const installFromLocal = options.local || options.installFromLocal;
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await edgibleService.listManagedGateways();
+            if (!listResponse.success || !listResponse.gateways || listResponse.gateways.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+                return;
+            }
+            const choices = listResponse.gateways.map((gateway) => ({
+                name: `${gateway.name} (${gateway.id})`,
+                value: gateway.id,
+            }));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gatewayId',
+                    message: 'Select managed gateway to resync:',
+                    choices,
+                },
+            ]);
+            gatewayId = answer.gatewayId;
+        }
+        logger.info('Resyncing agent on managed gateway', {
+            gatewayId,
+            version: options.version,
+            installFromLocal,
+            reboot: options.reboot,
+            wipeLogs: options.wipeLogs,
+            debug: options.debug
+        });
+        const result = await edgibleService.resyncManagedGatewayAgent(gatewayId, options.version, installFromLocal, options.reboot, options.wipeLogs, options.debug);
+        console.log(chalk_1.default.green('\n✓ Agent resynced successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Resync Details:'));
+        console.log(chalk_1.default.white(`  Gateway ID: ${gatewayId}`));
+        if (result.agentVersion) {
+            console.log(chalk_1.default.white(`  Agent Version: ${result.agentVersion}`));
+        }
+        if (result.syncTimestamp) {
+            console.log(chalk_1.default.white(`  Sync Time: ${new Date(result.syncTimestamp).toLocaleString()}`));
+        }
+        if (options.debug) {
+            console.log(chalk_1.default.cyan(`  Log Level: Debug (enabled)`));
+        }
+        if (options.wipeLogs && result.logsWiped) {
+            console.log(chalk_1.default.yellow(`  Logs: Wiped before resync`));
+        }
+        if (options.reboot && result.rebooted) {
+            console.log(chalk_1.default.yellow(`  Reboot: Command sent (gateway is rebooting)`));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('logs')
+        .description('Retrieve agent logs from a managed gateway')
+        .option('-i, --id <id>', 'Gateway ID to get logs from')
+        .option('-n, --lines <number>', 'Number of log lines', '50')
+        .option('-f, --follow', 'Follow logs in real-time')
+        .option('-l, --level <level>', 'Log level filter', 'all')
+        .option('-m, --module <module>', 'Filter logs by module name (comma-separated for multiple modules, e.g., "agent,caddy")')
+        .option('-c, --comprehensive', 'Show comprehensive diagnostics (status, system info, WireGuard, Caddy, etc.)')
+        .option('--single-line', 'Exclude data and error traces from output (single line per log entry)')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await edgibleService.listManagedGateways();
+            if (!listResponse.success || !listResponse.gateways || listResponse.gateways.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+                return;
+            }
+            const choices = listResponse.gateways.map((gateway) => ({
+                name: `${gateway.name} (${gateway.id})`,
+                value: gateway.id,
+            }));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gatewayId',
+                    message: 'Select managed gateway:',
+                    choices,
+                },
+            ]);
+            gatewayId = answer.gatewayId;
+        }
+        const lines = parseInt(options.lines || '50') || 50;
+        const follow = options.follow || false;
+        const level = options.level || 'all';
+        const module = options.module;
+        const comprehensive = options.comprehensive || false;
+        logger.info('Retrieving managed gateway logs', {
+            gatewayId,
+            lines: follow ? undefined : lines,
+            follow,
+            level,
+            module,
+            comprehensive,
+        });
+        // Use the dedicated getManagedGatewayLogs method
+        try {
+            if (!gatewayId) {
+                console.log(chalk_1.default.red('✗ Gateway ID is required'));
+                return;
+            }
+            const result = await edgibleService.getManagedGatewayLogs(gatewayId, {
+                lines: follow ? undefined : lines,
+                follow: follow,
+                level: level,
+                comprehensive: comprehensive,
+            });
+            if (result.success) {
+                // For comprehensive mode, just output raw logs
+                if (comprehensive) {
+                    console.log(result.logs);
+                }
+                else {
+                    // Parse and format JSON logs nicely
+                    const formattedLogs = (0, log_formatter_1.processLogs)(result.logs, {
+                        module: module,
+                        level: level,
+                        singleLine: options.singleLine || false
+                    });
+                    if (formattedLogs.trim()) {
+                        console.log(formattedLogs);
+                    }
+                    else {
+                        if (module) {
+                            console.log(chalk_1.default.yellow(`No logs found for module(s): ${module}`));
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow('No logs found'));
+                        }
+                    }
+                }
+            }
+            else {
+                logger.error('Failed to retrieve logs');
+                console.log(chalk_1.default.red('✗ Failed to retrieve logs'));
+            }
+        }
+        catch (error) {
+            logger.error('Error retrieving managed gateway logs', error);
+            console.log(chalk_1.default.red('✗ Error retrieving logs'));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('wireguard')
+        .description('Show WireGuard status on a managed gateway')
+        .alias('wg')
+        .option('-i, --id <id>', 'Gateway ID to show WireGuard status for')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await edgibleService.listManagedGateways();
+            if (!listResponse.success || !listResponse.gateways || listResponse.gateways.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+                return;
+            }
+            const choices = listResponse.gateways.map((gateway) => ({
+                name: `${gateway.name} (${gateway.id})`,
+                value: gateway.id,
+            }));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gatewayId',
+                    message: 'Select managed gateway:',
+                    choices,
+                },
+            ]);
+            gatewayId = answer.gatewayId;
+        }
+        logger.info('Retrieving WireGuard status', { gatewayId });
+        try {
+            if (!gatewayId) {
+                console.log(chalk_1.default.red('✗ Gateway ID is required'));
+                return;
+            }
+            const result = await edgibleService.executeManagedGatewayCommand(gatewayId, 'sudo wg show');
+            if (result.success) {
+                if (result.output.trim()) {
+                    console.log(result.output);
+                }
+                else {
+                    console.log(chalk_1.default.yellow('No WireGuard interfaces found'));
+                }
+            }
+            else {
+                logger.error('Failed to retrieve WireGuard status', { error: result.error });
+                console.log(chalk_1.default.red('✗ Failed to retrieve WireGuard status'));
+                if (result.error) {
+                    console.log(chalk_1.default.red(`  Error: ${result.error}`));
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Error retrieving WireGuard status', error);
+            console.log(chalk_1.default.red('✗ Error retrieving WireGuard status'));
+            console.log(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('reboot')
+        .description('Reboot a managed gateway')
+        .option('-i, --id <id>', 'Gateway ID to reboot')
+        .option('-f, --force', 'Force reboot without confirmation')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await edgibleService.listManagedGateways();
+            if (!listResponse.success || !listResponse.gateways || listResponse.gateways.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+                return;
+            }
+            const choices = listResponse.gateways.map((gateway) => ({
+                name: `${gateway.name} (${gateway.id})`,
+                value: gateway.id,
+            }));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gatewayId',
+                    message: 'Select managed gateway to reboot:',
+                    choices,
+                },
+            ]);
+            gatewayId = answer.gatewayId;
+        }
+        // Confirm reboot unless force flag is set
+        if (!options.force) {
+            const confirm = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Are you sure you want to reboot managed gateway ${gatewayId}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm.confirm) {
+                logger.info('Gateway reboot cancelled');
+                console.log(chalk_1.default.gray('Reboot cancelled'));
+                return;
+            }
+        }
+        logger.info('Rebooting managed gateway', { gatewayId });
+        try {
+            if (!gatewayId) {
+                console.log(chalk_1.default.red('✗ Gateway ID is required'));
+                return;
+            }
+            console.log(chalk_1.default.blue(`Rebooting gateway ${gatewayId}...`));
+            // Execute reboot command (this will disconnect SSH, which is expected)
+            const result = await edgibleService.executeManagedGatewayCommand(gatewayId, 'sudo reboot');
+            // Note: The command may not return successfully because the gateway reboots
+            // and disconnects the SSH session. We check if we got an error that suggests
+            // the connection was lost (which is expected during reboot)
+            if (result.success || (result.error && result.error.includes('ECONNRESET'))) {
+                console.log(chalk_1.default.green('✓ Reboot command sent successfully'));
+                console.log(chalk_1.default.yellow('⚠ Gateway is rebooting. SSH connection will be lost.'));
+                console.log(chalk_1.default.gray('  The gateway should be back online in a few minutes.'));
+            }
+            else {
+                logger.error('Failed to reboot gateway', { error: result.error });
+                console.log(chalk_1.default.red('✗ Failed to send reboot command'));
+                if (result.error) {
+                    console.log(chalk_1.default.red(`  Error: ${result.error}`));
+                }
+            }
+        }
+        catch (error) {
+            // If the error is a connection reset, that's expected during reboot
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('ECONNRESET') || errorMessage.includes('connection')) {
+                console.log(chalk_1.default.green('✓ Reboot command sent successfully'));
+                console.log(chalk_1.default.yellow('⚠ Gateway is rebooting. SSH connection was lost (expected).'));
+                console.log(chalk_1.default.gray('  The gateway should be back online in a few minutes.'));
+            }
+            else {
+                logger.error('Error rebooting gateway', error);
+                console.log(chalk_1.default.red('✗ Error rebooting gateway'));
+                console.log(chalk_1.default.red(`  ${errorMessage}`));
+            }
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('ssh')
+        .description('Connect to a managed gateway via SSH (interactive shell)')
+        .option('-i, --id <id>', 'Gateway ID to connect to')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await edgibleService.listManagedGateways();
+            if (!listResponse.success || !listResponse.gateways || listResponse.gateways.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+                return;
+            }
+            const choices = listResponse.gateways.map((gateway) => ({
+                name: `${gateway.name} (${gateway.id})`,
+                value: gateway.id,
+            }));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gatewayId',
+                    message: 'Select managed gateway:',
+                    choices,
+                },
+            ]);
+            gatewayId = answer.gatewayId;
+        }
+        logger.info('Connecting to managed gateway via SSH', { gatewayId });
+        // Get managed gateway details
+        const gatewayDetails = await edgibleService.getManagedGateway(gatewayId);
+        if (!gatewayDetails.success || !gatewayDetails.gateway) {
+            console.log(chalk_1.default.red('✗ Managed gateway not found'));
+            return;
+        }
+        const gateway = gatewayDetails.gateway;
+        const ipAddress = gateway.ipAddress;
+        if (!ipAddress) {
+            console.log(chalk_1.default.red('✗ Gateway IP address not available'));
+            return;
+        }
+        // Get SSH key from backend
+        console.log(chalk_1.default.gray('Fetching SSH key from backend...'));
+        const sshKeyResponse = await edgibleService.apiClient.getManagedGatewaySSHKey({ gatewayId });
+        if (!sshKeyResponse.success || !sshKeyResponse.sshPrivateKey) {
+            console.log(chalk_1.default.red('✗ Failed to retrieve SSH key for managed gateway'));
+            return;
+        }
+        const sshPrivateKey = sshKeyResponse.sshPrivateKey;
+        // Create temporary SSH key file
+        const os = require('os');
+        const path = require('path');
+        const fs = require('fs');
+        const tempKeyPath = path.join(os.tmpdir(), `edgible-mgw-ssh-${gatewayId}-${Date.now()}.pem`);
+        try {
+            // Write SSH key to temp file with proper permissions
+            fs.writeFileSync(tempKeyPath, sshPrivateKey, { mode: 0o600 });
+            console.log(chalk_1.default.blue(`\nConnecting to managed gateway: ${gatewayId}`));
+            console.log(chalk_1.default.gray(`Public IP: ${ipAddress}`));
+            console.log(chalk_1.default.gray(`Region: ${gateway.organizationId || 'N/A'}`));
+            console.log(chalk_1.default.yellow('\nOpening SSH connection...\n'));
+            // Build SSH command
+            const sshCommand = `ssh -i "${tempKeyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null ec2-user@${ipAddress}`;
+            console.log(chalk_1.default.green('✓ Opening interactive SSH session...'));
+            console.log(chalk_1.default.gray('─'.repeat(80)));
+            console.log(chalk_1.default.gray('Tip: Type "exit" to disconnect from the gateway\n'));
+            // Execute SSH using child_process
+            const { spawn } = require('child_process');
+            const sshProcess = spawn('sh', ['-c', sshCommand], {
+                stdio: 'inherit',
+                shell: false,
+            });
+            sshProcess.on('error', (error) => {
+                logger.error('SSH connection error', error);
+                console.error(chalk_1.default.red('✗ SSH connection error:'), error.message);
+                console.log(chalk_1.default.yellow('\nMake sure SSH is installed and the key file has correct permissions'));
+                throw error;
+            });
+            sshProcess.on('exit', (code) => {
+                if (code === 0) {
+                    logger.debug('SSH session ended normally');
+                    console.log(chalk_1.default.gray('\nSSH session ended'));
+                }
+                else {
+                    logger.warn('SSH session ended with non-zero code', { code });
+                    console.log(chalk_1.default.yellow(`\nSSH session ended with code: ${code}`));
+                }
+            });
+            // Wait for process to exit
+            await new Promise((resolve, reject) => {
+                sshProcess.on('exit', (code) => {
+                    if (code === 0 || code === null) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`SSH session exited with code ${code}`));
+                    }
+                });
+                sshProcess.on('error', reject);
+            });
+        }
+        catch (error) {
+            logger.error('Error connecting to managed gateway via SSH', error);
+            console.error(chalk_1.default.red('✗ Error connecting to managed gateway:'), error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        finally {
+            // Clean up temp key file
+            try {
+                if (fs.existsSync(tempKeyPath)) {
+                    fs.unlinkSync(tempKeyPath);
+                }
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors
+                logger.debug('Failed to cleanup temp SSH key file', cleanupError);
+            }
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+    managedGatewayCommand
+        .command('wipe-logs')
+        .description('Clear agent log file on a managed gateway')
+        .option('-i, --id <id>', 'Gateway ID to wipe logs for')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await edgibleService.listManagedGateways();
+            if (!listResponse.success || !listResponse.gateways || listResponse.gateways.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No managed gateways found'));
+                return;
+            }
+            const choices = listResponse.gateways.map((gateway) => ({
+                name: `${gateway.name} (${gateway.id})`,
+                value: gateway.id,
+            }));
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gatewayId',
+                    message: 'Select managed gateway:',
+                    choices,
+                },
+            ]);
+            gatewayId = answer.gatewayId;
+        }
+        logger.info('Wiping managed gateway logs', { gatewayId });
+        // Confirm action
+        const confirm = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Are you sure you want to clear all logs on managed gateway ${gatewayId}?`,
+                default: false,
+            },
+        ]);
+        if (!confirm.confirm) {
+            logger.info('Log wipe cancelled');
+            console.log(chalk_1.default.gray('Log wipe cancelled'));
+            return;
+        }
+        // Get managed gateway logs and wipe them
+        const result = await edgibleService.wipeManagedGatewayLogs(gatewayId);
+        if (result.success) {
+            console.log(chalk_1.default.green('✓ Managed gateway logs cleared successfully!'));
+            console.log(chalk_1.default.gray(`  Log file: ${result.logFile || 'agent.log'}`));
+        }
+        else {
+            console.log(chalk_1.default.red('✗ Failed to clear logs'));
+            if (result.message) {
+                console.log(chalk_1.default.yellow(result.message));
+            }
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+    }));
+}
+//# sourceMappingURL=managedGateway.js.map