@edgible-team/cli 1.2.4 → 1.2.8

package/dist/commands/application/create-docker-compose.js

@@ -0,0 +1,334 @@
+"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.handleApplicationCreateDockerCompose = handleApplicationCreateDockerCompose;
+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 instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+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");
+async function handleApplicationCreateDockerCompose(options) {
+    (0, config_validator_1.validateConfig)(instances_1.configManager, {
+        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) {
+                // Ask if they want to assign a gateway at all
+                const { assignGateway } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'assignGateway',
+                        message: 'Assign a gateway to this application? (No = local/internal access only)',
+                        default: true,
+                    },
+                ]);
+                if (assignGateway) {
+                    // Try to offer a list of gateways (via service), else fallback to manual input
+                    try {
+                        const gatewaysResp = await instances_1.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) {
+                        instances_1.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 (or leave empty for no gateway):',
+                                validate: (v) => true, // Allow empty input
+                            },
+                        ]);
+                        if (ans2.gatewayIds && ans2.gatewayIds.trim()) {
+                            gatewayIds = (0, input_parser_1.parseGatewayIds)(ans2.gatewayIds);
+                        }
+                    }
+                }
+                else {
+                    instances_1.logger.info('Application will be created without gateway assignment (local/internal access only)');
+                }
+            }
+        }
+        // Serving device selection
+        if (!deviceId) {
+            try {
+                const servingDevicesResp = await instances_1.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) {
+                instances_1.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) {
+        instances_1.logger.warn('No gateways assigned - application will only be accessible locally/internally');
+    }
+    // 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
+    instances_1.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 instances_1.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}`));
+    }
+}
+//# sourceMappingURL=create-docker-compose.js.map

package/dist/commands/application/create-existing.d.ts

@@ -0,0 +1,14 @@
+export declare function handleApplicationCreateExisting(options: {
+    name?: string;
+    description?: string;
+    port?: string;
+    protocol?: string;
+    httpsUpgrade?: boolean;
+    deviceId?: string;
+    gatewayIds?: string;
+    hostnames?: string;
+    requireOrgAuth?: boolean;
+    allowedOrgs?: string;
+    noInteractive?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=create-existing.d.ts.map

package/dist/commands/application/create-existing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-existing.d.ts","sourceRoot":"","sources":["../../../src/commands/application/create-existing.ts"],"names":[],"mappings":"AASA,wBAAsB,+BAA+B,CAAC,OAAO,EAAE;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuWhB"}