@edgible-team/cli 1.0.1

package/dist/commands/examples/migrated-command-example.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Example of a migrated command using all the new infrastructure
+ * This demonstrates how to use:
+ * - Dependency injection
+ * - Logger abstraction
+ * - Validation with Zod
+ * - Command wrapper
+ * - Shared utilities
+ * - Proper TypeScript types
+ *
+ * This is a reference implementation for migrating other commands
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupExampleGatewayCreateCommand = setupExampleGatewayCreateCommand;
+const container_1 = require("../../di/container");
+const types_1 = require("../../di/types");
+const command_wrapper_1 = require("../base/command-wrapper");
+const validator_1 = require("../../validation/validator");
+const schemas_1 = require("../../validation/schemas");
+const gateway_prompt_1 = require("../utils/gateway-prompt");
+const output_formatter_1 = require("../utils/output-formatter");
+const config_validator_1 = require("../utils/config-validator");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Example: Migrated gateway create command
+ * This shows the pattern for all command migrations
+ */
+function setupExampleGatewayCreateCommand(program) {
+    const gatewayCommand = program
+        .command('gateway')
+        .description('Manage gateways')
+        .alias('gw');
+    gatewayCommand
+        .command('create')
+        .description('Create a new gateway device and EC2 instance')
+        .option('-n, --name <name>', 'Gateway name')
+        .option('-d, --description <description>', 'Gateway description')
+        .option('-p, --profile <profile>', 'AWS profile to use')
+        .option('-r, --region <region>', 'AWS region')
+        .option('-t, --instance-type <type>', 'EC2 instance type', 't3.micro')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        // Get dependencies from container
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const gatewayService = container.get(types_1.TYPES.GatewayService);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        // Validate configuration
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        // Validate and parse options using Zod
+        const validatedOptions = (0, validator_1.validateOptions)(schemas_1.createGatewayRequestSchema, {
+            name: options.name,
+            description: options.description,
+            awsProfile: options.profile,
+            region: options.region,
+            instanceType: options.instanceType,
+        });
+        // Log command execution
+        logger.info('Creating gateway', { name: validatedOptions.name });
+        // Use the service
+        const result = await gatewayService.createGateway({
+            name: validatedOptions.name,
+            description: validatedOptions.description,
+            awsProfile: validatedOptions.awsProfile,
+            region: validatedOptions.region,
+            instanceType: validatedOptions.instanceType,
+        });
+        // Format output
+        console.log((0, output_formatter_1.formatSuccess)('Gateway created successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Gateway Details:'));
+        console.log((0, output_formatter_1.formatGateway)({
+            device: result.gateway,
+            ec2Instance: result.ec2Instance,
+        }));
+        logger.debug('Gateway creation completed', { gatewayId: result.gateway.id });
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    /**
+     * Example: Migrated gateway list command
+     */
+    gatewayCommand
+        .command('list')
+        .description('List all gateway devices')
+        .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 gatewayService = container.get(types_1.TYPES.GatewayService);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        logger.debug('Listing gateways');
+        const response = await gatewayService.listGateways();
+        if (options.json) {
+            console.log(JSON.stringify({
+                gateways: response.gateways.map((gateway) => ({
+                    id: gateway.device.id,
+                    name: gateway.device.name,
+                    description: gateway.device.description,
+                    ec2Instance: gateway.ec2Instance?.instanceId,
+                    publicIp: gateway.ec2Instance?.publicIp,
+                    privateIp: gateway.ec2Instance?.privateIp,
+                    region: gateway.ec2Instance?.region,
+                    state: gateway.ec2Instance?.state,
+                    createdAt: gateway.device.createdAt,
+                })),
+            }, null, 2));
+            return;
+        }
+        if (response.gateways.length === 0) {
+            console.log(chalk_1.default.yellow('⚠ No gateways found'));
+            console.log(chalk_1.default.gray('Use "edgible gateway create" to create a gateway'));
+            return;
+        }
+        console.log(chalk_1.default.blue.bold('🌐 Gateway Devices:\n'));
+        response.gateways.forEach((gateway) => {
+            console.log((0, output_formatter_1.formatGateway)(gateway));
+        });
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    /**
+     * Example: Migrated gateway delete command using shared utilities
+     */
+    gatewayCommand
+        .command('delete')
+        .description('Delete a gateway device and EC2 instance')
+        .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 gatewayService = container.get(types_1.TYPES.GatewayService);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        // Use shared utility to get gateway ID
+        const gatewayId = await (0, gateway_prompt_1.getGatewayId)(gatewayService, options.id, { required: true });
+        if (!gatewayId) {
+            throw new Error('Gateway ID is required');
+        }
+        logger.info('Deleting gateway', { gatewayId });
+        await gatewayService.deleteGateway(gatewayId, options.force || false);
+        console.log((0, output_formatter_1.formatSuccess)('Gateway deleted successfully!'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+}
+/**
+ * Migration checklist:
+ *
+ * ✅ Use DI container to get services
+ * ✅ Use logger instead of console.log
+ * ✅ Validate inputs with Zod schemas
+ * ✅ Use wrapCommand for error handling
+ * ✅ Use shared utilities for common operations
+ * ✅ Use proper TypeScript types (no any)
+ * ✅ Validate configuration before execution
+ * ✅ Format output consistently
+ */
+//# sourceMappingURL=migrated-command-example.js.map

package/dist/commands/gateway.js

@@ -0,0 +1,494 @@
+"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.setupGatewayCommands = setupGatewayCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+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 output_formatter_1 = require("./utils/output-formatter");
+const gateway_prompt_1 = require("./utils/gateway-prompt");
+/**
+ * Gateway command group
+ */
+function setupGatewayCommands(program) {
+    const gatewayCommand = program
+        .command('gateway')
+        .description('Manage gateways')
+        .alias('gw');
+    gatewayCommand
+        .command('create')
+        .description('Create a new gateway device and EC2 instance')
+        .addHelpText('after', `
+Examples:
+  $ edgible gateway create --name mygateway --region us-east-1
+  $ edgible gateway create --name mygateway --profile default --instance-type t3.micro
+  `)
+        .option('-n, --name <name>', 'Gateway name')
+        .option('-d, --description <description>', 'Gateway description')
+        .option('-p, --profile <profile>', 'AWS profile to use')
+        .option('-r, --region <region>', 'AWS region')
+        .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 gatewayService = container.get(types_1.TYPES.GatewayService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        let gatewayName = options.name;
+        let description = options.description;
+        let awsProfile = options.profile;
+        let region = options.region;
+        let instanceType = options.instanceType || 't3.micro';
+        // If not provided via options, prompt for input
+        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();
+        }
+        if (!description) {
+            const descAnswer = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'description',
+                    message: 'Enter gateway description (optional):',
+                    default: `Gateway: ${gatewayName}`,
+                },
+            ]);
+            description = descAnswer.description.trim();
+        }
+        if (!awsProfile) {
+            // Check available AWS profiles
+            const { AWSService } = await Promise.resolve().then(() => __importStar(require('../services/aws')));
+            const awsService = new AWSService();
+            const awsCheck = await awsService.checkAWSCLI();
+            if (!awsCheck.available) {
+                logger.error('AWS CLI is not installed or not available');
+                console.log(chalk_1.default.red('✗ AWS CLI is not installed or not available'));
+                console.log(chalk_1.default.gray('Please install AWS CLI and configure credentials'));
+                return;
+            }
+            const profileChoices = awsCheck.profiles.map((profile) => ({
+                name: profile,
+                value: profile,
+            }));
+            if (profileChoices.length === 0) {
+                logger.error('No AWS profiles found');
+                console.log(chalk_1.default.red('✗ No AWS profiles found'));
+                console.log(chalk_1.default.gray('Please run "aws configure" to set up your AWS credentials'));
+                return;
+            }
+            const profileAnswer = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'profile',
+                    message: 'Select AWS profile:',
+                    choices: profileChoices,
+                },
+            ]);
+            awsProfile = profileAnswer.profile;
+        }
+        if (!region) {
+            const regionAnswer = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'region',
+                    message: 'Enter AWS region:',
+                    default: 'us-east-1',
+                    validate: (input) => {
+                        if (!input.trim()) {
+                            return 'AWS region is required';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            region = regionAnswer.region.trim();
+        }
+        logger.info('Creating gateway', { name: gatewayName, region, instanceType });
+        const createConfig = {
+            name: gatewayName,
+        };
+        if (description && description.trim())
+            createConfig.description = description;
+        if (awsProfile && awsProfile.trim())
+            createConfig.awsProfile = awsProfile;
+        if (region && region.trim())
+            createConfig.region = region;
+        if (instanceType && instanceType.trim())
+            createConfig.instanceType = instanceType;
+        const result = await gatewayService.createGateway(createConfig);
+        console.log(chalk_1.default.green('\n✓ Gateway created successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Gateway Details:'));
+        console.log((0, output_formatter_1.formatGateway)({
+            device: result.gateway,
+            ec2Instance: result.ec2Instance,
+        }));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    gatewayCommand
+        .command('list')
+        .description('List all gateway devices')
+        .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 gatewayService = container.get(types_1.TYPES.GatewayService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        logger.debug('Listing gateways');
+        const response = await gatewayService.listGateways();
+        if (response.gateways.length === 0) {
+            console.log(chalk_1.default.yellow('⚠ No gateways found'));
+            console.log(chalk_1.default.gray('Use "edgible gateway create" to create a gateway'));
+            return;
+        }
+        if (options.json) {
+            console.log(JSON.stringify({
+                gateways: response.gateways.map((gateway) => ({
+                    id: gateway.device.id,
+                    name: gateway.device.name,
+                    description: gateway.device.description,
+                    ec2Instance: gateway.ec2Instance?.instanceId,
+                    publicIp: gateway.ec2Instance?.publicIp,
+                    privateIp: gateway.ec2Instance?.privateIp,
+                    region: gateway.ec2Instance?.region,
+                    state: gateway.ec2Instance?.state,
+                    createdAt: gateway.device.createdAt,
+                })),
+            }, null, 2));
+            return;
+        }
+        console.log((0, output_formatter_1.formatList)(response.gateways, (gateway) => (0, output_formatter_1.formatGateway)(gateway), '🌐 Gateway Devices:', 'No gateways found'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    gatewayCommand
+        .command('get')
+        .description('Get status of a specific gateway')
+        .option('-i, --id <id>', 'Gateway ID')
+        .alias('status')
+        .alias('info')
+        .action(async (options) => {
+        console.log(chalk_1.default.yellow('Not yet implemented.'));
+    });
+    gatewayCommand
+        .command('update')
+        .description('Update an existing gateway')
+        .option('-i, --id <id>', 'Gateway ID')
+        .action(async (options) => {
+        console.log(chalk_1.default.yellow('Not yet implemented.'));
+    });
+    gatewayCommand
+        .command('delete')
+        .description('Delete a gateway device and EC2 instance')
+        .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 gatewayService = container.get(types_1.TYPES.GatewayService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        const gatewayId = await (0, gateway_prompt_1.getGatewayId)(gatewayService, options.id, { required: true });
+        if (!gatewayId) {
+            throw new Error('Gateway ID is required');
+        }
+        // Confirm deletion
+        const confirm = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Are you sure you want to delete gateway ${gatewayId}?`,
+                default: false,
+            },
+        ]);
+        if (!confirm.confirm) {
+            logger.info('Gateway deletion cancelled');
+            console.log(chalk_1.default.gray('Deletion cancelled'));
+            return;
+        }
+        logger.info('Deleting gateway', { gatewayId, force: options.force || false });
+        await gatewayService.deleteGateway(gatewayId, options.force || false);
+        console.log(chalk_1.default.green('✓ Gateway deleted successfully!'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    gatewayCommand
+        .command('resync')
+        .description('Resync agent code on a 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')
+        .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 gatewayService = container.get(types_1.TYPES.GatewayService);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        const gatewayId = await (0, gateway_prompt_1.getGatewayId)(gatewayService, options.id, { required: true });
+        if (!gatewayId) {
+            throw new Error('Gateway ID is required');
+        }
+        logger.info('Resyncing agent on gateway', { gatewayId, version: options.version, installFromLocal });
+        // TODO: Extract resyncGatewayAgent to GatewaySshService
+        const result = await edgibleService.resyncGatewayAgent(gatewayId, options.version, installFromLocal);
+        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}`));
+        console.log(chalk_1.default.white(`  Agent Version: ${result.agentVersion}`));
+        console.log(chalk_1.default.white(`  Sync Time: ${new Date(result.syncTimestamp).toLocaleString()}`));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    gatewayCommand
+        .command('logs')
+        .description('Retrieve agent logs from a 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('-c, --comprehensive', 'Show comprehensive diagnostics (status, system info, WireGuard, Caddy, etc.)')
+        .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 gatewayService = container.get(types_1.TYPES.GatewayService);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        const gatewayId = await (0, gateway_prompt_1.getGatewayId)(gatewayService, options.id, { required: true });
+        if (!gatewayId) {
+            throw new Error('Gateway ID is required');
+        }
+        const lines = parseInt(options.lines || '50') || 50;
+        const follow = options.follow || false;
+        const level = options.level || 'all';
+        const comprehensive = options.comprehensive || false;
+        logger.info('Retrieving gateway logs', {
+            gatewayId,
+            lines: follow ? undefined : lines,
+            follow,
+            level,
+            comprehensive,
+        });
+        // TODO: Extract getGatewayLogs to GatewayDiagnosticsService
+        const result = await edgibleService.getGatewayLogs(gatewayId, {
+            lines: follow ? undefined : lines,
+            follow: follow,
+            level: level,
+            comprehensive: comprehensive,
+        });
+        if (result.success) {
+            console.log(result.logs);
+        }
+        else {
+            logger.error('Failed to retrieve logs');
+            console.log(chalk_1.default.red('✗ Failed to retrieve logs'));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    gatewayCommand
+        .command('ssh')
+        .description('Connect to a 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 gatewayRepository = container.get(types_1.TYPES.GatewayRepository);
+        const gatewayService = container.get(types_1.TYPES.GatewayService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        const gatewayId = await (0, gateway_prompt_1.getGatewayId)(gatewayService, options.id, { required: true });
+        if (!gatewayId) {
+            throw new Error('Gateway ID is required');
+        }
+        const gatewayInfo = gatewayRepository.getGateway(gatewayId);
+        if (!gatewayInfo) {
+            throw new Error('Gateway not found in local configuration');
+        }
+        logger.info('Connecting to gateway via SSH', { gatewayId, publicIp: gatewayInfo.publicIp });
+        console.log(chalk_1.default.blue(`\nConnecting to gateway: ${gatewayId}`));
+        console.log(chalk_1.default.gray(`Public IP: ${gatewayInfo.publicIp}`));
+        console.log(chalk_1.default.gray(`Region: ${gatewayInfo.region}`));
+        console.log(chalk_1.default.yellow('\nOpening SSH connection...\n'));
+        // Get SSH key path
+        const { AWSService } = await Promise.resolve().then(() => __importStar(require('../services/aws')));
+        const awsService = new AWSService(configRepository.getAWSProfile(), gatewayInfo.region);
+        // Wait for instance to be ready
+        console.log(chalk_1.default.gray('Waiting for instance to be ready...'));
+        const isReady = await awsService.waitForSSHReady(gatewayInfo.ec2InstanceId);
+        if (!isReady) {
+            logger.error('Instance is not ready for SSH connections', { instanceId: gatewayInfo.ec2InstanceId });
+            console.log(chalk_1.default.red('✗ Instance is not ready for SSH connections'));
+            return;
+        }
+        // Build SSH command
+        const sshKeyPath = gatewayInfo.keyPath;
+        const sshCommand = `ssh -i "${sshKeyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null ec2-user@${gatewayInfo.publicIp}`;
+        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 sshProcess = (0, child_process_1.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 (chmod 600)'));
+            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}`));
+            }
+        });
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    gatewayCommand
+        .command('wipe-logs')
+        .description('Clear agent log file on a 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 gatewayService = container.get(types_1.TYPES.GatewayService);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        const gatewayId = await (0, gateway_prompt_1.getGatewayId)(gatewayService, options.id, { required: true });
+        if (!gatewayId) {
+            throw new Error('Gateway ID is required');
+        }
+        logger.info('Wiping 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 gateway ${gatewayId}?`,
+                default: false,
+            },
+        ]);
+        if (!confirm.confirm) {
+            logger.info('Log wipe cancelled');
+            console.log(chalk_1.default.gray('Log wipe cancelled'));
+            return;
+        }
+        // Get gateway logs and wipe them
+        const result = await edgibleService.wipeGatewayLogs(gatewayId);
+        if (result.success) {
+            console.log(chalk_1.default.green('✓ 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,
+        requireOrganization: true,
+    }));
+}
+//# sourceMappingURL=gateway.js.map