@edgible-team/cli 1.0.1

package/dist/commands/application.js

@@ -0,0 +1,885 @@
+"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.setupApplicationCommands = setupApplicationCommands;
+const commander_1 = require("commander");
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const WorkloadDetector_1 = require("../detection/WorkloadDetector");
+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 input_parser_1 = require("./utils/input-parser");
+const sudo_checker_1 = require("../utils/sudo-checker");
+const docker_compose_parser_1 = require("../utils/docker-compose-parser");
+/**
+ * Application command group
+ */
+function setupApplicationCommands(program) {
+    const appCommand = program
+        .command('application')
+        .description('Manage applications')
+        .alias('app');
+    appCommand
+        .command('list')
+        .description('List all configured applications')
+        .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 applicationService = container.get(types_1.TYPES.ApplicationService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        logger.debug('Getting applications');
+        const applications = await applicationService.getApplications();
+        if (applications.length === 0) {
+            console.log(chalk_1.default.yellow('⚠ No applications configured'));
+            console.log(chalk_1.default.gray('Use "edgible application create" to create an application'));
+            return;
+        }
+        if (options.json) {
+            console.log(JSON.stringify({
+                applications: applications.map((app) => ({
+                    id: app.id,
+                    name: app.name,
+                    servingIp: app.servingIp,
+                    port: app.port,
+                    protocol: app.protocol,
+                    status: app.status,
+                    workloadId: app.workloadId,
+                    createdAt: app.createdAt,
+                    description: app.description || '',
+                })),
+            }, null, 2));
+            return;
+        }
+        console.log((0, output_formatter_1.formatList)(applications, (app, index) => `${index + 1}. ${(0, output_formatter_1.formatApplication)(app)}`, '📱 Configured Applications:', 'No applications configured'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    // Create parent command for application creation
+    const createCommand = appCommand
+        .command('create')
+        .description('Create a new application')
+        .alias('new');
+    // Existing workload subcommand
+    const createExistingCommand = new commander_1.Command('existing')
+        .description('Create application for an existing port that is open on the computer')
+        .addHelpText('after', `
+Examples:
+  $ edgible application create existing --name myapp --port 3000 --device-id <serving-device> --gateway-ids <gw1,gw2>
+  $ edgible application create existing --name myapp --port 8080 --protocol https --device-id <serving-device> --gateway-ids <gw>
+  $ edgible application create existing --name myapp --port 3000 --https-upgrade --device-id <serving-device> --gateway-ids <gw>
+  $ edgible application create existing --no-interactive
+  `)
+        .option('-n, --name <name>', 'Application name')
+        .option('-d, --description <description>', 'Application description')
+        .option('-p, --port <port>', 'Port number', '3000')
+        .option('--protocol <protocol>', 'Protocol (http, https, tcp, udp)', 'http')
+        .option('--https-upgrade', 'Upgrade HTTP protocol to HTTPS automatically')
+        .option('--device-id <id>', 'Serving device ID')
+        .option('--gateway-ids <ids>', 'Comma-separated gateway device IDs')
+        .option('--hostnames <hostnames>', 'Comma-separated additional hostnames to route to this app')
+        .option('--no-interactive', 'Run in non-interactive mode')
+        .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 applicationService = container.get(types_1.TYPES.ApplicationService);
+        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,
+        });
+        logger.debug('Creating application', { name: options.name });
+        // Name
+        let appName = options.name;
+        let useManagedGateway = false;
+        if (!appName && !options.noInteractive) {
+            const { name } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Enter application name:',
+                    validate: (i) => !!i.trim() || 'Application name is required',
+                },
+            ]);
+            appName = name.trim();
+        }
+        if (!appName) {
+            throw new Error('Application name is required');
+        }
+        // Description
+        let description = options.description || `Application for ${appName}`;
+        // Port (may be overridden by workload selection in interactive mode)
+        let port = (0, input_parser_1.parsePort)(options.port);
+        // Protocol
+        let protocolUnion = (0, input_parser_1.parseProtocol)(options.protocol);
+        // HTTPS upgrade: if --https-upgrade is set and protocol is http, change to https
+        if (options.httpsUpgrade && protocolUnion === 'http') {
+            protocolUnion = 'https';
+        }
+        // Device IDs (serving) and Gateway IDs
+        let deviceId = options.deviceId;
+        let gatewayIds = (0, input_parser_1.parseGatewayIds)(options.gatewayIds);
+        let hostnames = Array.isArray(options.hostnames)
+            ? options.hostnames
+            : (typeof options.hostnames === 'string' && options.hostnames.trim().length > 0
+                ? options.hostnames.split(',').map(s => s.trim()).filter(Boolean)
+                : []);
+        if (!options.noInteractive) {
+            // Prompt for HTTPS upgrade if protocol is http and --https-upgrade wasn't explicitly set
+            if (protocolUnion === 'http' && options.httpsUpgrade === undefined) {
+                const { upgradeToHttps } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'upgradeToHttps',
+                        message: 'Upgrade protocol from HTTP to HTTPS?',
+                        default: false,
+                    },
+                ]);
+                if (upgradeToHttps) {
+                    protocolUnion = 'https';
+                }
+            }
+            // Optional: prompt for additional hostnames
+            const { addHostnames } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'addHostnames',
+                    message: 'Additional hostnames (comma-separated, optional):',
+                    when: () => hostnames.length === 0,
+                },
+            ]);
+            if (addHostnames && typeof addHostnames === 'string') {
+                hostnames = addHostnames.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+            }
+            // Prompt for managed gateway option
+            if (gatewayIds.length === 0) {
+                const { useManaged } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'useManaged',
+                        message: 'Use Edgible managed gateway?',
+                        default: false,
+                    },
+                ]);
+                useManagedGateway = useManaged;
+                if (!useManagedGateway) {
+                    // Try to offer a list of gateways (via service), else fallback to manual input
+                    try {
+                        const gatewaysResp = await gatewayService.listGateways();
+                        const gatewayChoices = gatewaysResp.gateways.map((g) => ({
+                            name: `${g.device.name} (${g.device.id})`,
+                            value: g.device.id,
+                        }));
+                        if (gatewayChoices.length > 0) {
+                            const { selectedGateways } = await inquirer_1.default.prompt([
+                                {
+                                    type: 'checkbox',
+                                    name: 'selectedGateways',
+                                    message: 'Select gateway device(s):',
+                                    choices: gatewayChoices,
+                                    validate: (vals) => vals.length > 0 ? true : 'Select at least one gateway',
+                                },
+                            ]);
+                            gatewayIds = selectedGateways;
+                        }
+                    }
+                    catch (error) {
+                        logger.warn('Failed to list gateways', error);
+                    }
+                    if (gatewayIds.length === 0) {
+                        const ans2 = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'gatewayIds',
+                                message: 'Enter comma-separated gateway device IDs:',
+                                validate: (v) => v && v.split(',').map((s) => s.trim()).filter(Boolean).length > 0
+                                    ? true
+                                    : 'At least one gateway ID is required',
+                            },
+                        ]);
+                        gatewayIds = (0, input_parser_1.parseGatewayIds)(ans2.gatewayIds);
+                    }
+                }
+            }
+            // Serving device selection - fetch available serving devices from organization
+            if (!deviceId) {
+                try {
+                    const servingDevicesResp = await edgibleService.listServingDevices();
+                    const servingDeviceChoices = Array.isArray(servingDevicesResp?.devices)
+                        ? servingDevicesResp.devices.map((d) => ({
+                            name: `${d.name || d.id}${d.description ? ` - ${d.description}` : ''}`,
+                            value: d.id,
+                        }))
+                        : [];
+                    if (servingDeviceChoices.length > 0) {
+                        const { selectedDeviceId } = await inquirer_1.default.prompt([
+                            {
+                                type: 'list',
+                                name: 'selectedDeviceId',
+                                message: 'Select serving device:',
+                                choices: servingDeviceChoices,
+                            },
+                        ]);
+                        deviceId = selectedDeviceId;
+                    }
+                    else {
+                        // Fallback to manual input if no serving devices found
+                        const ans = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'deviceId',
+                                message: 'Enter serving device ID:',
+                                validate: (v) => v && v.trim().length > 0 ? true : 'Serving device ID is required',
+                            },
+                        ]);
+                        deviceId = String(ans.deviceId).trim();
+                    }
+                }
+                catch (error) {
+                    logger.warn('Failed to list serving devices', error);
+                    // Fallback to manual input if listing fails
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'deviceId',
+                            message: 'Enter serving device ID:',
+                            validate: (v) => v && v.trim().length > 0 ? true : 'Serving device ID is required',
+                        },
+                    ]);
+                    deviceId = String(ans.deviceId).trim();
+                }
+            }
+        }
+        if (!deviceId) {
+            throw new Error('--device-id (serving) is required');
+        }
+        if (!useManagedGateway && gatewayIds.length === 0) {
+            throw new Error('--gateway-ids is required (at least one) or use --use-managed-gateway');
+        }
+        const subtype = 'local-preexisting';
+        // If interactive, allow choosing a local workload
+        if (!options.noInteractive) {
+            try {
+                const workloads = await WorkloadDetector_1.WorkloadDetector.detectWorkloads();
+                const running = workloads.filter((w) => w.status === 'running');
+                if (running.length > 0) {
+                    const { selectedWorkloadId } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'selectedWorkloadId',
+                            message: 'Select local workload to associate:',
+                            choices: running.map((w) => ({ name: `${w.name} (${w.type})`, value: w.id })),
+                        },
+                    ]);
+                    // Attach to description so the backend can persist in configuration via service call
+                    description = description || '';
+                    description = `${description} [workloadId=${selectedWorkloadId}]`;
+                    // If the selected workload exposes ports, allow user to choose one to override the app port
+                    const selectedWorkload = running.find((w) => w.id === selectedWorkloadId);
+                    const availablePorts = Array.isArray(selectedWorkload?.ports)
+                        ? Array.from(new Set((selectedWorkload.ports || [])
+                            .map((p) => (typeof p.hostPort === 'number' ? p.hostPort : p.containerPort))
+                            .filter((n) => typeof n === 'number')))
+                        : [];
+                    if (availablePorts.length > 0) {
+                        const portChoices = [
+                            ...availablePorts.sort((a, b) => a - b).map((p) => ({ name: `${p}`, value: String(p) })),
+                            { name: 'Enter a custom port', value: 'custom' },
+                        ];
+                        const { chosenPort } = await inquirer_1.default.prompt([
+                            {
+                                type: 'list',
+                                name: 'chosenPort',
+                                message: 'Select port to expose for this application:',
+                                choices: portChoices,
+                                default: String(availablePorts[0]),
+                            },
+                        ]);
+                        if (chosenPort === 'custom') {
+                            const { customPort } = await inquirer_1.default.prompt([
+                                {
+                                    type: 'input',
+                                    name: 'customPort',
+                                    message: 'Enter custom port:',
+                                    validate: (v) => {
+                                        try {
+                                            (0, input_parser_1.parsePort)(v);
+                                            return true;
+                                        }
+                                        catch (e) {
+                                            return e.message;
+                                        }
+                                    },
+                                },
+                            ]);
+                            port = (0, input_parser_1.parsePort)(customPort);
+                        }
+                        else {
+                            port = (0, input_parser_1.parsePort)(chosenPort);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug('Failed to detect workloads', error);
+            }
+        }
+        logger.info('Creating application', {
+            name: appName,
+            port,
+            protocol: protocolUnion,
+            deviceId,
+            gatewayIds,
+            subtype,
+        });
+        console.log(chalk_1.default.blue(`\nCreating application: ${appName}`));
+        console.log(chalk_1.default.gray(`Port: ${port}`));
+        console.log(chalk_1.default.gray(`Protocol: ${protocolUnion.toUpperCase()}`));
+        console.log(chalk_1.default.gray(`Serving device: ${deviceId}`));
+        if (useManagedGateway) {
+            console.log(chalk_1.default.gray(`Using Edgible managed gateway`));
+        }
+        else {
+            console.log(chalk_1.default.gray(`Gateways: ${gatewayIds.join(', ')}`));
+        }
+        if (hostnames.length > 0) {
+            console.log(chalk_1.default.gray(`Additional hostnames: ${hostnames.join(', ')}`));
+        }
+        const result = await applicationService.createApplicationProgrammatically({
+            name: appName,
+            description,
+            port,
+            protocol: protocolUnion,
+            hostnames,
+            deviceIds: [deviceId],
+            gatewayIds: useManagedGateway ? undefined : gatewayIds,
+            useManagedGateway,
+            subtype,
+        });
+        console.log(chalk_1.default.green('\n✓ Application created successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Application Details:'));
+        if (result && typeof result === 'object' && 'name' in result) {
+            const app = result;
+            console.log(chalk_1.default.white(`  Name: ${app.name}`));
+            console.log(chalk_1.default.white(`  ID: ${app.id}`));
+            if (app.url)
+                console.log(chalk_1.default.white(`  URL: ${chalk_1.default.cyan.bold(app.url)}`));
+            console.log(chalk_1.default.white(`  Status: ${app.status}`));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    // Docker Compose subcommand
+    const createDockerComposeCommand = new commander_1.Command('docker-compose')
+        .description('Create application from docker-compose file (on device)')
+        .addHelpText('after', `
+Examples:
+  $ edgible application create docker-compose --name myapp --compose-file ./docker-compose.yml
+  $ edgible application create docker-compose --name myapp
+  $ edgible application create docker-compose --no-interactive --name myapp --compose-file ./docker-compose.yml
+  `)
+        .option('-n, --name <name>', 'Application name')
+        .option('-d, --description <description>', 'Application description')
+        .option('--compose-file <file>', 'Path to docker-compose.yml file')
+        .option('--device-id <id>', 'Serving device ID')
+        .option('--gateway-ids <ids>', 'Comma-separated gateway device IDs')
+        .option('--hostnames <hostnames>', 'Comma-separated additional hostnames to route to this app')
+        .option('--no-interactive', 'Run in non-interactive mode')
+        .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 applicationService = container.get(types_1.TYPES.ApplicationService);
+        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,
+        });
+        // Check sudo permissions
+        if (!(0, sudo_checker_1.checkSudoPermissions)()) {
+            console.log(chalk_1.default.yellow('⚠ Warning: Not running as sudo. Docker commands may fail without proper permissions.'));
+        }
+        // Find docker-compose file
+        let composeFilePath;
+        try {
+            composeFilePath = (0, docker_compose_parser_1.findDockerComposeFile)(options.composeFile);
+        }
+        catch (error) {
+            throw new Error(`Failed to find docker-compose file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        if (!composeFilePath) {
+            throw new Error('Docker compose file not found. Please provide --compose-file or ensure docker-compose.yml or docker-compose.yaml exists in the current directory.');
+        }
+        console.log(chalk_1.default.blue(`Using docker-compose file: ${composeFilePath}`));
+        console.log(chalk_1.default.gray('Note: Using Docker Compose v2 (docker compose command)'));
+        // Parse compose file
+        let composeData;
+        try {
+            composeData = (0, docker_compose_parser_1.parseDockerComposeFile)(composeFilePath);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse docker-compose file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        if (composeData.containers.length === 0) {
+            throw new Error('No containers with exposed ports found in docker-compose file');
+        }
+        // Build port selection choices
+        const portChoices = [];
+        for (const containerInfo of composeData.containers) {
+            for (const portInfo of containerInfo.ports) {
+                portChoices.push({
+                    name: `${containerInfo.name}:${portInfo.host}->${portInfo.container}/${portInfo.protocol}`,
+                    value: { container: containerInfo.name, port: portInfo.host },
+                });
+            }
+        }
+        if (portChoices.length === 0) {
+            throw new Error('No ports found in docker-compose file');
+        }
+        // Get application name
+        let appName = options.name;
+        if (!appName && !options.noInteractive) {
+            const { name } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Enter application name:',
+                    validate: (i) => !!i.trim() || 'Application name is required',
+                },
+            ]);
+            appName = name.trim();
+        }
+        if (!appName) {
+            throw new Error('Application name is required');
+        }
+        // Select port
+        let selectedPort;
+        let selectedContainer;
+        if (!options.noInteractive) {
+            const { selected } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select container and port to expose:',
+                    choices: portChoices,
+                },
+            ]);
+            selectedPort = selected.port;
+            selectedContainer = selected.container;
+        }
+        else {
+            // In non-interactive mode, use first available port
+            selectedPort = portChoices[0].value.port;
+            selectedContainer = portChoices[0].value.container;
+        }
+        // Description
+        const description = options.description || `Application for ${appName} (docker-compose: ${selectedContainer})`;
+        // Device IDs and Gateway IDs
+        let deviceId = options.deviceId;
+        let gatewayIds = (0, input_parser_1.parseGatewayIds)(options.gatewayIds);
+        let hostnames = Array.isArray(options.hostnames)
+            ? options.hostnames
+            : (typeof options.hostnames === 'string' && options.hostnames.trim().length > 0
+                ? options.hostnames.split(',').map(s => s.trim()).filter(Boolean)
+                : []);
+        let useManagedGateway = false;
+        if (!options.noInteractive) {
+            // Optional: prompt for additional hostnames
+            const { addHostnames } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'addHostnames',
+                    message: 'Additional hostnames (comma-separated, optional):',
+                    when: () => hostnames.length === 0,
+                },
+            ]);
+            if (addHostnames && typeof addHostnames === 'string') {
+                hostnames = addHostnames.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+            }
+            // Prompt for managed gateway option
+            if (gatewayIds.length === 0) {
+                const { useManaged } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'useManaged',
+                        message: 'Use Edgible managed gateway?',
+                        default: false,
+                    },
+                ]);
+                useManagedGateway = useManaged;
+                if (!useManagedGateway) {
+                    // Try to offer a list of gateways (via service), else fallback to manual input
+                    try {
+                        const gatewaysResp = await gatewayService.listGateways();
+                        const gatewayChoices = gatewaysResp.gateways.map((g) => ({
+                            name: `${g.device.name} (${g.device.id})`,
+                            value: g.device.id,
+                        }));
+                        if (gatewayChoices.length > 0) {
+                            const { selectedGateways } = await inquirer_1.default.prompt([
+                                {
+                                    type: 'checkbox',
+                                    name: 'selectedGateways',
+                                    message: 'Select gateway device(s):',
+                                    choices: gatewayChoices,
+                                    validate: (vals) => vals.length > 0 ? true : 'Select at least one gateway',
+                                },
+                            ]);
+                            gatewayIds = selectedGateways;
+                        }
+                    }
+                    catch (error) {
+                        logger.warn('Failed to list gateways', error);
+                    }
+                    if (gatewayIds.length === 0) {
+                        const ans2 = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'gatewayIds',
+                                message: 'Enter comma-separated gateway device IDs:',
+                                validate: (v) => v && v.split(',').map((s) => s.trim()).filter(Boolean).length > 0
+                                    ? true
+                                    : 'At least one gateway ID is required',
+                            },
+                        ]);
+                        gatewayIds = (0, input_parser_1.parseGatewayIds)(ans2.gatewayIds);
+                    }
+                }
+            }
+            // Serving device selection
+            if (!deviceId) {
+                try {
+                    const servingDevicesResp = await edgibleService.listServingDevices();
+                    const servingDeviceChoices = Array.isArray(servingDevicesResp?.devices)
+                        ? servingDevicesResp.devices.map((d) => ({
+                            name: `${d.name || d.id}${d.description ? ` - ${d.description}` : ''}`,
+                            value: d.id,
+                        }))
+                        : [];
+                    if (servingDeviceChoices.length > 0) {
+                        const { selectedDeviceId } = await inquirer_1.default.prompt([
+                            {
+                                type: 'list',
+                                name: 'selectedDeviceId',
+                                message: 'Select serving device:',
+                                choices: servingDeviceChoices,
+                            },
+                        ]);
+                        deviceId = selectedDeviceId;
+                    }
+                    else {
+                        // Fallback to manual input if no serving devices found
+                        const ans = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'deviceId',
+                                message: 'Enter serving device ID:',
+                                validate: (v) => v && v.trim().length > 0 ? true : 'Serving device ID is required',
+                            },
+                        ]);
+                        deviceId = String(ans.deviceId).trim();
+                    }
+                }
+                catch (error) {
+                    logger.warn('Failed to list serving devices', error);
+                    // Fallback to manual input if listing fails
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'deviceId',
+                            message: 'Enter serving device ID:',
+                            validate: (v) => v && v.trim().length > 0 ? true : 'Serving device ID is required',
+                        },
+                    ]);
+                    deviceId = String(ans.deviceId).trim();
+                }
+            }
+        }
+        if (!deviceId) {
+            throw new Error('--device-id (serving) is required');
+        }
+        if (!useManagedGateway && gatewayIds.length === 0) {
+            throw new Error('--gateway-ids is required (at least one) or use --use-managed-gateway');
+        }
+        // Run docker compose up
+        console.log(chalk_1.default.blue(`\nRunning docker compose up...`));
+        try {
+            const composeDir = path.dirname(composeFilePath);
+            const composeFileName = path.basename(composeFilePath);
+            (0, child_process_1.execSync)(`docker compose -f ${composeFileName} up -d`, {
+                cwd: composeDir,
+                stdio: 'inherit',
+            });
+            console.log(chalk_1.default.green('✓ Docker compose up completed successfully'));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red('✗ Docker compose up failed'));
+            throw new Error(`Failed to run docker compose up: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        // Create application
+        logger.info('Creating application', {
+            name: appName,
+            port: selectedPort,
+            protocol: 'https',
+            deviceId,
+            gatewayIds,
+            subtype: 'docker-compose',
+        });
+        console.log(chalk_1.default.blue(`\nCreating application: ${appName}`));
+        console.log(chalk_1.default.gray(`Port: ${selectedPort}`));
+        console.log(chalk_1.default.gray(`Protocol: HTTPS`));
+        console.log(chalk_1.default.gray(`Container: ${selectedContainer}`));
+        console.log(chalk_1.default.gray(`Serving device: ${deviceId}`));
+        if (useManagedGateway) {
+            console.log(chalk_1.default.gray(`Using Edgible managed gateway`));
+        }
+        else {
+            console.log(chalk_1.default.gray(`Gateways: ${gatewayIds.join(', ')}`));
+        }
+        if (hostnames.length > 0) {
+            console.log(chalk_1.default.gray(`Additional hostnames: ${hostnames.join(', ')}`));
+        }
+        const result = await applicationService.createApplicationProgrammatically({
+            name: appName,
+            description,
+            port: selectedPort,
+            protocol: 'https',
+            hostnames,
+            deviceIds: [deviceId],
+            gatewayIds: useManagedGateway ? undefined : gatewayIds,
+            useManagedGateway,
+            subtype: 'docker-compose',
+        });
+        console.log(chalk_1.default.green('\n✓ Application created successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Application Details:'));
+        if (result && typeof result === 'object' && 'name' in result) {
+            const app = result;
+            console.log(chalk_1.default.white(`  Name: ${app.name}`));
+            console.log(chalk_1.default.white(`  ID: ${app.id}`));
+            if (app.url)
+                console.log(chalk_1.default.white(`  URL: ${chalk_1.default.cyan.bold(app.url)}`));
+            console.log(chalk_1.default.white(`  Status: ${app.status}`));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    // Stub subcommands for unimplemented workload types
+    const createDockerCommand = new commander_1.Command('docker')
+        .description('Create application from Docker container (not implemented)')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: false,
+        requireOrganization: false,
+    }));
+    const createQemuCommand = new commander_1.Command('qemu')
+        .description('Create application from QEMU VM (not implemented)')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: false,
+        requireOrganization: false,
+    }));
+    const createPodmanCommand = new commander_1.Command('podman')
+        .description('Create application from Podman container (not implemented)')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: false,
+        requireOrganization: false,
+    }));
+    // Add all subcommands to create command
+    createCommand.addCommand(createExistingCommand);
+    createCommand.addCommand(createDockerComposeCommand);
+    createCommand.addCommand(createDockerCommand);
+    createCommand.addCommand(createQemuCommand);
+    createCommand.addCommand(createPodmanCommand);
+    appCommand
+        .command('get')
+        .description('Get status of a specific application')
+        .option('-i, --app-id <id>', 'Application ID')
+        .option('--json', 'Output as JSON')
+        .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 applicationService = container.get(types_1.TYPES.ApplicationService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        if (!options.appId) {
+            throw new Error('--app-id is required. Usage: edgible application get --app-id <id> [--json]');
+        }
+        logger.debug('Getting application', { appId: options.appId });
+        const app = await applicationService.getApplication(options.appId);
+        if (options.json) {
+            console.log(JSON.stringify({
+                id: app.id,
+                name: app.name,
+                description: app.description || '',
+                url: app.url || '',
+                servingIp: app.servingIp,
+                port: app.port,
+                protocol: app.protocol,
+                status: app.status,
+                workloadId: app.workloadId || '',
+                createdAt: app.createdAt,
+            }, null, 2));
+        }
+        else {
+            console.log((0, output_formatter_1.formatApplication)(app));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    appCommand
+        .command('update')
+        .description('Update an existing application')
+        .option('-i, --app-id <id>', 'Application ID')
+        .action(async (options) => {
+        console.log(chalk_1.default.yellow('Not yet implemented.'));
+    });
+    appCommand
+        .command('delete')
+        .description('Delete an application')
+        .option('-i, --app-id <id>', 'Application ID')
+        .option('-f, --force', 'Skip confirmation prompt')
+        .option('--no-interactive', 'Run in non-interactive mode')
+        .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 applicationService = container.get(types_1.TYPES.ApplicationService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        let appId = options.appId;
+        // Interactive mode: prompt for application if not provided
+        if (!appId && options.interactive !== false) {
+            logger.debug('Fetching applications for interactive selection');
+            const applications = await applicationService.getApplications();
+            if (applications.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No applications configured'));
+                console.log(chalk_1.default.gray('Use "edgible application create" to create an application'));
+                return;
+            }
+            const choices = applications.map((app) => ({
+                name: `${app.name} (${app.id})${app.description ? ` - ${app.description}` : ''}`,
+                value: app.id,
+            }));
+            const { selectedAppId } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedAppId',
+                    message: 'Select application to delete:',
+                    choices,
+                },
+            ]);
+            appId = selectedAppId;
+        }
+        if (!appId) {
+            throw new Error('--app-id is required in non-interactive mode. Usage: edgible application delete --app-id <id>');
+        }
+        logger.debug('Deleting application', { appId });
+        // Get application details for confirmation
+        let appName = appId;
+        let app;
+        try {
+            app = await applicationService.getApplication(appId);
+            appName = app.name;
+        }
+        catch (error) {
+            logger.debug('Could not fetch application details for confirmation', error);
+        }
+        // Confirm deletion unless --force is used
+        if (!options.force) {
+            const confirmMessage = app
+                ? `Are you sure you want to delete application "${appName}" (${appId})?`
+                : `Are you sure you want to delete application ${appId}?`;
+            const { confirm } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: confirmMessage,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                logger.info('Application deletion cancelled');
+                console.log(chalk_1.default.gray('Deletion cancelled'));
+                return;
+            }
+        }
+        await applicationService.deleteApplication(appId);
+        console.log(chalk_1.default.green('\n✓ Application deleted successfully!'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+}
+//# sourceMappingURL=application.js.map