@edgible-team/cli 1.2.4 → 1.2.8

package/dist/commands/managedGateway/haproxy-stats.js

@@ -0,0 +1,131 @@
+"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.handleManagedGatewayHaproxyStats = handleManagedGatewayHaproxyStats;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+async function handleManagedGatewayHaproxyStats(options) {
+    async (options) => {
+        (0, config_validator_1.validateConfig)(instances_1.configManager, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        // If no gateway ID provided, let user select
+        if (!gatewayId) {
+            const listResponse = await instances_1.managedGatewayService.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 outputFile = options.output || 'haproxy-stats.html';
+        const statsPort = options.port || '8404';
+        instances_1.logger.info('Downloading HAProxy stats', { gatewayId, outputFile, statsPort });
+        try {
+            if (!gatewayId) {
+                console.log(chalk_1.default.red('✗ Gateway ID is required'));
+                return;
+            }
+            // First check if HAProxy is running and stats are available
+            const checkCommand = `curl -s -o /dev/null -w "%{http_code}" http://localhost:${statsPort}/stats`;
+            const checkResult = await instances_1.diagnosticsService.executeManagedGatewayCommand(gatewayId, checkCommand);
+            if (!checkResult.success) {
+                console.log(chalk_1.default.red('✗ Failed to check HAProxy stats availability'));
+                if (checkResult.error) {
+                    console.log(chalk_1.default.red(`  Error: ${checkResult.error}`));
+                }
+                return;
+            }
+            const httpCode = checkResult.output.trim();
+            if (httpCode !== '200') {
+                console.log(chalk_1.default.red(`✗ HAProxy stats not accessible (HTTP ${httpCode})`));
+                console.log(chalk_1.default.yellow(`  Hint: Check if HAProxy stats are enabled on port ${statsPort}`));
+                console.log(chalk_1.default.yellow(`  Hint: Check HAPROXY_STATS_PORT environment variable on the gateway`));
+                console.log(chalk_1.default.yellow(`  Hint: Verify HAProxy is running: edgible managed-gateway ssh --id ${gatewayId}`));
+                return;
+            }
+            console.log(chalk_1.default.blue('📊 Downloading HAProxy stats...'));
+            // Download the stats HTML
+            const downloadCommand = `curl -s http://localhost:${statsPort}/stats`;
+            const result = await instances_1.diagnosticsService.executeManagedGatewayCommand(gatewayId, downloadCommand);
+            if (result.success) {
+                if (result.output.trim()) {
+                    // Write to file
+                    const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+                    await fs.writeFile(outputFile, result.output, 'utf8');
+                    console.log(chalk_1.default.green(`\n✓ HAProxy stats downloaded successfully!`));
+                    console.log(chalk_1.default.white(`  File: ${outputFile}`));
+                    console.log(chalk_1.default.white(`  Size: ${(result.output.length / 1024).toFixed(2)} KB`));
+                    console.log(chalk_1.default.blue(`\n💡 Open ${outputFile} in your browser to view the stats`));
+                }
+                else {
+                    console.log(chalk_1.default.yellow('⚠ No stats data received'));
+                    console.log(chalk_1.default.gray('  The stats page may be empty or HAProxy may not have any backends configured'));
+                }
+            }
+            else {
+                instances_1.logger.error('Failed to download HAProxy stats', { error: result.error });
+                console.log(chalk_1.default.red('✗ Failed to download HAProxy stats'));
+                if (result.error) {
+                    console.log(chalk_1.default.red(`  Error: ${result.error}`));
+                }
+            }
+        }
+        catch (error) {
+            instances_1.logger.error('Error downloading HAProxy stats', error);
+            console.log(chalk_1.default.red('✗ Error downloading HAProxy stats'));
+            throw error;
+        }
+    };
+}
+//# sourceMappingURL=haproxy-stats.js.map

package/dist/commands/managedGateway/list.d.ts

@@ -0,0 +1,4 @@
+export declare function handleManagedGatewayList(options: {
+    json?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/managedGateway/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/managedGateway/list.ts"],"names":[],"mappings":"AAKA,wBAAsB,wBAAwB,CAAC,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CzF"}

package/dist/commands/managedGateway/list.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleManagedGatewayList = handleManagedGatewayList;
+const chalk_1 = __importDefault(require("chalk"));
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+async function handleManagedGatewayList(options) {
+    wrapCommand(async (options) => {
+        (0, config_validator_1.validateConfig)(instances_1.configManager, {
+            requireAuth: true,
+        });
+        instances_1.logger.debug('Listing managed gateways');
+        const response = await instances_1.managedGatewayService.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()}`));
+        });
+    });
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/managedGateway/logs.d.ts

@@ -0,0 +1,10 @@
+export declare function handleManagedGatewayLogs(options: {
+    id?: string;
+    lines?: string;
+    follow?: boolean;
+    level?: string;
+    module?: string;
+    comprehensive?: boolean;
+    singleLine?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/commands/managedGateway/logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../../src/commands/managedGateway/logs.ts"],"names":[],"mappings":"AAMA,wBAAsB,wBAAwB,CAAC,OAAO,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAmGxM"}

package/dist/commands/managedGateway/logs.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleManagedGatewayLogs = handleManagedGatewayLogs;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+const log_formatter_1 = require("../../utils/log-formatter");
+async function handleManagedGatewayLogs(options) {
+    wrapCommand(async (options) => {
+        (0, config_validator_1.validateConfig)(instances_1.configManager, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await instances_1.managedGatewayService.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;
+        instances_1.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 instances_1.managedGatewayService.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 {
+                instances_1.logger.error('Failed to retrieve logs');
+                console.log(chalk_1.default.red('✗ Failed to retrieve logs'));
+            }
+        }
+        catch (error) {
+            instances_1.logger.error('Error retrieving managed gateway logs', error);
+            console.log(chalk_1.default.red('✗ Error retrieving logs'));
+        }
+    });
+}
+//# sourceMappingURL=logs.js.map

package/dist/commands/managedGateway/reboot.d.ts

@@ -0,0 +1,5 @@
+export declare function handleManagedGatewayReboot(options: {
+    id?: string;
+    force?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=reboot.d.ts.map

package/dist/commands/managedGateway/reboot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reboot.d.ts","sourceRoot":"","sources":["../../../src/commands/managedGateway/reboot.ts"],"names":[],"mappings":"AAKA,wBAAsB,0BAA0B,CAAC,OAAO,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA4FzG"}

package/dist/commands/managedGateway/reboot.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleManagedGatewayReboot = handleManagedGatewayReboot;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+async function handleManagedGatewayReboot(options) {
+    wrapCommand(async (options) => {
+        (0, config_validator_1.validateConfig)(instances_1.configManager, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await instances_1.managedGatewayService.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) {
+                instances_1.logger.info('Gateway reboot cancelled');
+                console.log(chalk_1.default.gray('Reboot cancelled'));
+                return;
+            }
+        }
+        instances_1.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 instances_1.diagnosticsService.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 {
+                instances_1.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 {
+                instances_1.logger.error('Error rebooting gateway', error);
+                console.log(chalk_1.default.red('✗ Error rebooting gateway'));
+                console.log(chalk_1.default.red(`  ${errorMessage}`));
+            }
+        }
+    });
+}
+//# sourceMappingURL=reboot.js.map

package/dist/commands/managedGateway/resync.d.ts

@@ -0,0 +1,10 @@
+export declare function handleManagedGatewayResync(options: {
+    id?: string;
+    version?: string;
+    local?: boolean;
+    installFromLocal?: boolean;
+    reboot?: boolean;
+    wipeLogs?: boolean;
+    debug?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=resync.d.ts.map

package/dist/commands/managedGateway/resync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resync.d.ts","sourceRoot":"","sources":["../../../src/commands/managedGateway/resync.ts"],"names":[],"mappings":"AAKA,wBAAsB,0BAA0B,CAAC,OAAO,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAwE9M"}

package/dist/commands/managedGateway/resync.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleManagedGatewayResync = handleManagedGatewayResync;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+async function handleManagedGatewayResync(options) {
+    wrapCommand(async (options) => {
+        // Map --local to installFromLocal for backward compatibility
+        const installFromLocal = options.local || options.installFromLocal;
+        (0, config_validator_1.validateConfig)(instances_1.configManager, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await instances_1.managedGatewayService.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;
+        }
+        instances_1.logger.info('Resyncing agent on managed gateway', {
+            gatewayId,
+            version: options.version,
+            installFromLocal,
+            reboot: options.reboot,
+            wipeLogs: options.wipeLogs,
+            debug: options.debug
+        });
+        const result = await instances_1.managedGatewayService.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)`));
+        }
+    });
+}
+//# sourceMappingURL=resync.js.map

package/dist/commands/managedGateway/ssh.d.ts

@@ -0,0 +1,4 @@
+export declare function handleManagedGatewaySsh(options: {
+    id?: string;
+}): Promise<void>;
+//# sourceMappingURL=ssh.d.ts.map

package/dist/commands/managedGateway/ssh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssh.d.ts","sourceRoot":"","sources":["../../../src/commands/managedGateway/ssh.ts"],"names":[],"mappings":"AAKA,wBAAsB,uBAAuB,CAAC,OAAO,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuIrF"}

package/dist/commands/managedGateway/ssh.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.handleManagedGatewaySsh = handleManagedGatewaySsh;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+async function handleManagedGatewaySsh(options) {
+    wrapCommand(async (options) => {
+        (0, config_validator_1.validateConfig)(instances_1.configManager, {
+            requireAuth: true,
+        });
+        let gatewayId = options.id;
+        if (!gatewayId) {
+            // List gateways first to allow selection
+            const listResponse = await instances_1.managedGatewayService.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;
+        }
+        instances_1.logger.info('Connecting to managed gateway via SSH', { gatewayId });
+        // Get managed gateway details
+        const gatewayDetails = await instances_1.managedGatewayService.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 instances_1.managedGatewayService.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) => {
+                instances_1.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) {
+                    instances_1.logger.debug('SSH session ended normally');
+                    console.log(chalk_1.default.gray('\nSSH session ended'));
+                }
+                else {
+                    instances_1.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) {
+            instances_1.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
+                instances_1.logger.debug('Failed to cleanup temp SSH key file', cleanupError);
+            }
+        }
+    });
+}
+//# sourceMappingURL=ssh.js.map

package/dist/commands/managedGateway/wipe-logs.d.ts

@@ -0,0 +1,4 @@
+export declare function handleManagedGatewayWipeLogs(options: {
+    id?: string;
+}): Promise<void>;
+//# sourceMappingURL=wipe-logs.d.ts.map

package/dist/commands/managedGateway/wipe-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wipe-logs.d.ts","sourceRoot":"","sources":["../../../src/commands/managedGateway/wipe-logs.ts"],"names":[],"mappings":"AAKA,wBAAsB,4BAA4B,CAAC,OAAO,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAgE1F"}