@edgible-team/cli 1.2.4 → 1.2.8

package/dist/commands/application/create-existing.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApplicationCreateExisting = handleApplicationCreateExisting;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const WorkloadDetector_1 = require("../../detection/WorkloadDetector");
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+const input_parser_1 = require("../utils/input-parser");
+async function handleApplicationCreateExisting(options) {
+    (0, config_validator_1.validateConfig)(instances_1.configManager, {
+        requireAuth: true,
+        requireOrganization: true,
+    });
+    instances_1.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)
+            : []);
+    // Organization auth settings
+    let requireOrgAuth = options.requireOrgAuth || false;
+    let allowedOrgs = [];
+    if (options.allowedOrgs) {
+        allowedOrgs = options.allowedOrgs.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 organization authentication
+        if (options.requireOrgAuth === undefined) {
+            const { enableOrgAuth } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'enableOrgAuth',
+                    message: 'Require organization authentication to access this application?',
+                    default: false,
+                },
+            ]);
+            requireOrgAuth = enableOrgAuth;
+            if (requireOrgAuth) {
+                const { allowOtherOrgs } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'allowOtherOrgs',
+                        message: 'Allow other organizations to access this application?',
+                        default: false,
+                    },
+                ]);
+                if (allowOtherOrgs) {
+                    const { orgIds } = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'orgIds',
+                            message: 'Enter comma-separated organization IDs to allow access:',
+                        },
+                    ]);
+                    if (orgIds && typeof orgIds === 'string') {
+                        allowedOrgs = orgIds.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 - fetch available serving devices from organization
+        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');
+    }
+    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) {
+            instances_1.logger.debug('Failed to detect workloads', error);
+        }
+    }
+    instances_1.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(', ')}`));
+    }
+    if (requireOrgAuth) {
+        console.log(chalk_1.default.gray(`Organization authentication: ${chalk_1.default.green('Enabled')}`));
+        if (allowedOrgs.length > 0) {
+            console.log(chalk_1.default.gray(`Allowed organizations: ${allowedOrgs.join(', ')}`));
+        }
+    }
+    const result = await instances_1.applicationService.createApplicationProgrammatically({
+        name: appName,
+        description,
+        port,
+        protocol: protocolUnion,
+        hostnames,
+        deviceIds: [deviceId],
+        gatewayIds: useManagedGateway ? undefined : gatewayIds,
+        useManagedGateway,
+        subtype,
+        requireOrgAuth,
+        allowedOrganizations: allowedOrgs.length > 0 ? allowedOrgs : undefined,
+    });
+    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-existing.js.map

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createInteractiveCommand(): Command;
+//# sourceMappingURL=create-interactive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-interactive.d.ts","sourceRoot":"","sources":["../../../src/commands/application/create-interactive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,wBAAgB,wBAAwB,IAAI,OAAO,CAqVlD"}