@edgible-team/cli 1.2.4 → 1.2.8

package/dist/commands/application/create-managed-process.js

@@ -0,0 +1,371 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApplicationCreateManagedProcess = handleApplicationCreateManagedProcess;
+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 input_parser_1 = require("../utils/input-parser");
+async function handleApplicationCreateManagedProcess(options) {
+    (0, config_validator_1.validateConfig)(instances_1.configManager, {
+        requireAuth: true,
+        requireOrganization: true,
+    });
+    // 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');
+    }
+    // Command
+    let command = options.command;
+    if (!command && !options.noInteractive) {
+        const { cmd } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'cmd',
+                message: 'Enter command to run:',
+                validate: (i) => !!i.trim() || 'Command is required',
+            },
+        ]);
+        command = cmd.trim();
+    }
+    if (!command) {
+        throw new Error('Command is required');
+    }
+    // Port
+    let port = options.port ? (0, input_parser_1.parsePort)(options.port) : undefined;
+    if (!port && !options.noInteractive) {
+        const { portInput } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'portInput',
+                message: 'Enter port number the process will listen on:',
+                default: '3000',
+                validate: (i) => {
+                    const p = parseInt(i, 10);
+                    return (p > 0 && p <= 65535) || 'Port must be between 1 and 65535';
+                },
+            },
+        ]);
+        port = (0, input_parser_1.parsePort)(portInput);
+    }
+    if (!port) {
+        throw new Error('Port is required');
+    }
+    // Working directory
+    let workingDirectory = options.workingDir;
+    if (!workingDirectory && !options.noInteractive) {
+        const { dir } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'dir',
+                message: 'Enter working directory (leave empty for current directory):',
+                default: process.cwd(),
+            },
+        ]);
+        workingDirectory = dir.trim();
+    }
+    // Environment variables
+    let env = {};
+    if (options.env) {
+        // Parse format: KEY=VALUE,KEY2=VALUE2
+        const pairs = options.env.split(',');
+        for (const pair of pairs) {
+            const [key, value] = pair.split('=');
+            if (key && value) {
+                env[key.trim()] = value.trim();
+            }
+        }
+    }
+    else if (!options.noInteractive) {
+        const { addEnv } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'addEnv',
+                message: 'Add environment variables?',
+                default: false,
+            },
+        ]);
+        if (addEnv) {
+            let continueAdding = true;
+            while (continueAdding) {
+                const { key, value } = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'key',
+                        message: 'Environment variable name:',
+                    },
+                    {
+                        type: 'input',
+                        name: 'value',
+                        message: 'Environment variable value:',
+                    },
+                ]);
+                if (key && value) {
+                    env[key.trim()] = value.trim();
+                }
+                const { more } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'more',
+                        message: 'Add another environment variable?',
+                        default: false,
+                    },
+                ]);
+                continueAdding = more;
+            }
+        }
+    }
+    // Log file
+    let logFile = options.logFile;
+    if (!logFile && !options.noInteractive) {
+        const { addLog } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'addLog',
+                message: 'Capture logs to file?',
+                default: false,
+            },
+        ]);
+        if (addLog) {
+            const { path: logPath } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'path',
+                    message: 'Log file path:',
+                    default: `/var/log/${appName}.log`,
+                },
+            ]);
+            logFile = logPath.trim();
+        }
+    }
+    // Description
+    const description = options.description || `Managed process application for ${appName}`;
+    // Protocol
+    const protocol = (0, input_parser_1.parseProtocol)(options.protocol);
+    // 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');
+    }
+    // Build configuration
+    const configuration = {
+        command,
+    };
+    if (workingDirectory) {
+        configuration.workingDirectory = workingDirectory;
+    }
+    if (Object.keys(env).length > 0) {
+        configuration.env = env;
+    }
+    if (logFile) {
+        configuration.logFile = logFile;
+    }
+    // Create application
+    instances_1.logger.info('Creating managed process application', {
+        name: appName,
+        port,
+        protocol,
+        command,
+        deviceId,
+        gatewayIds,
+        subtype: 'managed-process',
+    });
+    console.log(chalk_1.default.blue(`\nCreating managed process application: ${appName}`));
+    console.log(chalk_1.default.gray(`Command: ${command}`));
+    console.log(chalk_1.default.gray(`Port: ${port}`));
+    console.log(chalk_1.default.gray(`Protocol: ${protocol.toUpperCase()}`));
+    if (workingDirectory) {
+        console.log(chalk_1.default.gray(`Working directory: ${workingDirectory}`));
+    }
+    if (Object.keys(env).length > 0) {
+        console.log(chalk_1.default.gray(`Environment variables: ${Object.keys(env).length} variable(s)`));
+    }
+    if (logFile) {
+        console.log(chalk_1.default.gray(`Log file: ${logFile}`));
+    }
+    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,
+        protocol,
+        hostnames,
+        deviceIds: [deviceId],
+        gatewayIds: useManagedGateway ? undefined : gatewayIds,
+        useManagedGateway,
+        subtype: 'managed-process',
+        configuration,
+    });
+    console.log(chalk_1.default.green('\n✓ Managed process 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}`));
+    }
+    console.log(chalk_1.default.yellow('\n⚠ Note: The agent will start the process when it receives the configuration.'));
+}
+//# sourceMappingURL=create-managed-process.js.map

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

@@ -0,0 +1,4 @@
+export declare function handleApplicationCreateDocker(): Promise<void>;
+export declare function handleApplicationCreateQemu(): Promise<void>;
+export declare function handleApplicationCreatePodman(): Promise<void>;
+//# sourceMappingURL=create-stubs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-stubs.d.ts","sourceRoot":"","sources":["../../../src/commands/application/create-stubs.ts"],"names":[],"mappings":"AAEA,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnE;AAED,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC,CAEjE;AAED,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnE"}

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

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApplicationCreateDocker = handleApplicationCreateDocker;
+exports.handleApplicationCreateQemu = handleApplicationCreateQemu;
+exports.handleApplicationCreatePodman = handleApplicationCreatePodman;
+const chalk_1 = __importDefault(require("chalk"));
+async function handleApplicationCreateDocker() {
+    console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+}
+async function handleApplicationCreateQemu() {
+    console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+}
+async function handleApplicationCreatePodman() {
+    console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+}
+//# sourceMappingURL=create-stubs.js.map

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

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+export declare function createDockerCommand(): Command;
+export declare function createPodmanCommand(): Command;
+export declare function createAutoCommand(): Command;
+//# sourceMappingURL=create-workload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-workload.d.ts","sourceRoot":"","sources":["../../../src/commands/application/create-workload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,wBAAgB,mBAAmB,IAAI,OAAO,CAe7C;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAe7C;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAsB3C"}

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

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDockerCommand = createDockerCommand;
+exports.createPodmanCommand = createPodmanCommand;
+exports.createAutoCommand = createAutoCommand;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const command_wrapper_1 = require("../base/command-wrapper");
+function createDockerCommand() {
+    action((0, command_wrapper_1.wrapCommand)(async () => {
+        console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+    }, {
+        requireAuth: false,
+        requireOrganization: false,
+    }));
+    const createQemuCommand = new commander_1.Command('qemu')
+        .description('Create application from QEMU VM (not implemented)');
+}
+function createPodmanCommand() {
+    action((0, command_wrapper_1.wrapCommand)(async () => {
+        console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+    }, {
+        requireAuth: false,
+        requireOrganization: false,
+    }));
+    const createPodmanCommand = new commander_1.Command('podman')
+        .description('Create application from Podman container (not implemented)');
+}
+function createAutoCommand() {
+    action((0, command_wrapper_1.wrapCommand)(async () => {
+        console.log(chalk_1.default.yellow('This workload type is currently not implemented.'));
+    }, {
+        requireAuth: false,
+        requireOrganization: false,
+    }));
+    // Add all subcommands to create command
+    createCommand.addCommand(createExistingCommand);
+    createCommand.addCommand(createDockerComposeCommand);
+    createCommand.addCommand(createManagedProcessCommand);
+    createCommand.addCommand(createDockerCommand);
+    createCommand.addCommand(createQemuCommand);
+    createCommand.addCommand(createPodmanCommand);
+    appCommand;
+}
+//# sourceMappingURL=create-workload.js.map

package/dist/commands/application/delete.d.ts

@@ -0,0 +1,6 @@
+export declare function handleApplicationDelete(options: {
+    appId?: string;
+    force?: boolean;
+    interactive?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/commands/application/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/commands/application/delete.ts"],"names":[],"mappings":"AAMA,wBAAsB,uBAAuB,CAAC,OAAO,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6EhI"}

package/dist/commands/application/delete.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApplicationDelete = handleApplicationDelete;
+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 handleApplicationDelete(options) {
+    (0, config_validator_1.validateConfig)(instances_1.configManager, {
+        requireAuth: true,
+        requireOrganization: true,
+    });
+    let appId = options.appId;
+    // Interactive mode: prompt for application if not provided
+    if (!appId && options.interactive !== false) {
+        instances_1.logger.debug('Fetching applications for interactive selection');
+        const applications = await instances_1.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>');
+    }
+    instances_1.logger.debug('Deleting application', { appId });
+    // Get application details for confirmation
+    let appName = appId;
+    let app;
+    try {
+        app = await instances_1.applicationService.getApplication(appId);
+        appName = app.name;
+    }
+    catch (error) {
+        instances_1.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) {
+            instances_1.logger.info('Application deletion cancelled');
+            console.log(chalk_1.default.gray('Deletion cancelled'));
+            return;
+        }
+    }
+    await instances_1.applicationService.deleteApplication(appId);
+    console.log(chalk_1.default.green('\n✓ Application deleted successfully!'));
+}
+//# sourceMappingURL=delete.js.map

package/dist/commands/application/get.d.ts

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

package/dist/commands/application/get.d.ts.map

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

package/dist/commands/application/get.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApplicationGet = handleApplicationGet;
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+const output_formatter_1 = require("../utils/output-formatter");
+async function handleApplicationGet(options) {
+    (0, config_validator_1.validateConfig)(instances_1.configManager, {
+        requireAuth: true,
+        requireOrganization: true,
+    });
+    if (!options.appId) {
+        throw new Error('--app-id is required. Usage: edgible application get --app-id <id> [--json]');
+    }
+    instances_1.logger.debug('Getting application', { appId: options.appId });
+    const app = await instances_1.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));
+    }
+}
+//# sourceMappingURL=get.js.map

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

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

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

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

package/dist/commands/application/list.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApplicationList = handleApplicationList;
+const chalk_1 = __importDefault(require("chalk"));
+const instances_1 = require("../../services/instances");
+const config_validator_1 = require("../utils/config-validator");
+const output_formatter_1 = require("../utils/output-formatter");
+async function handleApplicationList(options) {
+    (0, config_validator_1.validateConfig)(instances_1.configManager, {
+        requireAuth: true,
+        requireOrganization: true,
+    });
+    instances_1.logger.debug('Getting applications');
+    const applications = await instances_1.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'));
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/application/short-codes/create.d.ts

@@ -0,0 +1,7 @@
+export declare function handleShortCodesCreate(options: {
+    appId?: string;
+    name?: string;
+    expires?: string;
+    maxUses?: string;
+}): Promise<void>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/application/short-codes/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../src/commands/application/short-codes/create.ts"],"names":[],"mappings":"AAKA,wBAAsB,sBAAsB,CAAC,OAAO,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAkE1I"}