@edgible-team/cli 1.0.1

package/dist/commands/utils/config-validator.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Configuration validation utilities
+ * Centralizes config validation logic
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+exports.requireOrganizationId = requireOrganizationId;
+exports.requireDeviceId = requireDeviceId;
+exports.requireEmail = requireEmail;
+const errors_1 = require("../../utils/errors");
+/**
+ * Validate configuration based on requirements
+ */
+function validateConfig(configRepository, options = {}) {
+    const { requireAuth = false, requireOrganization = false, requireDeviceId = false, requireEmail = false, requireAwsProfile = false, } = options;
+    const config = configRepository.getConfig();
+    if (requireAuth) {
+        const hasTokens = !!(config.accessToken || config.idToken);
+        const hasDeviceCreds = !!(config.deviceId && config.devicePassword);
+        if (!hasTokens && !hasDeviceCreds) {
+            throw new errors_1.ConfigError('Not authenticated. Please run "edgible login" first.');
+        }
+    }
+    if (requireOrganization) {
+        if (!config.organizationId) {
+            throw new errors_1.ConfigError('No organization found. Please login first.');
+        }
+    }
+    if (requireDeviceId) {
+        if (!config.deviceId) {
+            throw new errors_1.ConfigError('No device ID found. Please login first.');
+        }
+    }
+    if (requireEmail) {
+        if (!config.email) {
+            throw new errors_1.ConfigError('No email found in configuration.');
+        }
+    }
+    if (requireAwsProfile) {
+        if (!config.awsProfile) {
+            throw new errors_1.ConfigError('No AWS profile configured. Please set AWS profile first.');
+        }
+    }
+}
+/**
+ * Get organization ID or throw error
+ */
+function requireOrganizationId(configRepository) {
+    const config = configRepository.getConfig();
+    if (!config.organizationId) {
+        throw new errors_1.ConfigError('No organization ID found. Please login first.');
+    }
+    return config.organizationId;
+}
+/**
+ * Get device ID or throw error
+ */
+function requireDeviceId(configRepository) {
+    const config = configRepository.getConfig();
+    if (!config.deviceId) {
+        throw new errors_1.ConfigError('No device ID found. Please login first.');
+    }
+    return config.deviceId;
+}
+/**
+ * Get email or throw error
+ */
+function requireEmail(configRepository) {
+    const config = configRepository.getConfig();
+    if (!config.email) {
+        throw new errors_1.ConfigError('No email found in configuration.');
+    }
+    return config.email;
+}
+//# sourceMappingURL=config-validator.js.map

package/dist/commands/utils/gateway-prompt.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Shared gateway selection utilities
+ * Eliminates duplication across commands
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptGatewaySelection = promptGatewaySelection;
+exports.getGatewayId = getGatewayId;
+exports.validateGatewayExists = validateGatewayExists;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Prompt user to select a gateway from available gateways
+ */
+async function promptGatewaySelection(gatewayService, options = {}) {
+    const { allowNone = false, message = 'Select gateway:', required = true } = options;
+    try {
+        const response = await gatewayService.listGateways();
+        if (response.gateways.length === 0) {
+            if (allowNone) {
+                return null;
+            }
+            console.log(chalk_1.default.yellow('⚠ No gateways found'));
+            console.log(chalk_1.default.gray('Use "edgible gateway create" to create a gateway'));
+            if (required) {
+                throw new Error('No gateways available');
+            }
+            return null;
+        }
+        const gatewayChoices = response.gateways.map((gateway) => ({
+            name: `${gateway.device.name} (${gateway.device.id})`,
+            value: gateway.device.id,
+        }));
+        if (allowNone) {
+            gatewayChoices.push({
+                name: 'None',
+                value: '',
+            });
+        }
+        const answer = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'gatewayId',
+                message,
+                choices: gatewayChoices,
+            },
+        ]);
+        return answer.gatewayId === '' ? null : answer.gatewayId;
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Error listing gateways:'), error instanceof Error ? error.message : 'Unknown error');
+        throw error;
+    }
+}
+/**
+ * Get gateway by ID, or prompt if not provided
+ */
+async function getGatewayId(gatewayService, providedId, options = {}) {
+    if (providedId) {
+        return providedId;
+    }
+    return await promptGatewaySelection(gatewayService, options);
+}
+/**
+ * Validate gateway exists
+ */
+async function validateGatewayExists(gatewayService, gatewayId) {
+    try {
+        const response = await gatewayService.listGateways();
+        return response.gateways.some((gateway) => gateway.device.id === gatewayId);
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=gateway-prompt.js.map

package/dist/commands/utils/input-parser.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Input parsing utilities
+ * Converts string inputs to proper types and validates them
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePort = parsePort;
+exports.parseProtocol = parseProtocol;
+exports.parseDeviceId = parseDeviceId;
+exports.parseGatewayIds = parseGatewayIds;
+exports.parseBoolean = parseBoolean;
+exports.parseNumber = parseNumber;
+exports.parseCommandOptions = parseCommandOptions;
+const zod_1 = require("zod");
+const schemas_1 = require("../../validation/schemas");
+const errors_1 = require("../../utils/errors");
+/**
+ * Parse port from string
+ */
+function parsePort(value) {
+    if (typeof value === 'number') {
+        return schemas_1.portSchema.parse(value);
+    }
+    if (!value) {
+        throw new errors_1.ValidationError('Port is required');
+    }
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed)) {
+        throw new errors_1.ValidationError(`Invalid port number: ${value}`);
+    }
+    return schemas_1.portSchema.parse(parsed);
+}
+/**
+ * Parse protocol from string
+ */
+function parseProtocol(value) {
+    if (!value) {
+        return 'http'; // Default
+    }
+    return schemas_1.protocolSchema.parse(value.toLowerCase());
+}
+/**
+ * Parse device ID from string
+ */
+function parseDeviceId(value) {
+    if (!value) {
+        throw new errors_1.ValidationError('Device ID is required');
+    }
+    return schemas_1.deviceIdSchema.parse(value);
+}
+/**
+ * Parse gateway IDs from comma-separated string
+ */
+function parseGatewayIds(value) {
+    if (!value) {
+        return [];
+    }
+    const ids = value.split(',').map((id) => id.trim()).filter((id) => id.length > 0);
+    return ids.map((id) => schemas_1.gatewayIdSchema.parse(id));
+}
+/**
+ * Parse boolean from string or boolean
+ */
+function parseBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (!value) {
+        return false;
+    }
+    const lower = value.toLowerCase();
+    return lower === 'true' || lower === '1' || lower === 'yes';
+}
+/**
+ * Parse number from string with validation
+ */
+function parseNumber(value, min, max) {
+    if (typeof value === 'number') {
+        if (min !== undefined && value < min) {
+            throw new errors_1.ValidationError(`Value must be at least ${min}`);
+        }
+        if (max !== undefined && value > max) {
+            throw new errors_1.ValidationError(`Value must be at most ${max}`);
+        }
+        return value;
+    }
+    if (!value) {
+        throw new errors_1.ValidationError('Number is required');
+    }
+    const parsed = parseFloat(value);
+    if (isNaN(parsed)) {
+        throw new errors_1.ValidationError(`Invalid number: ${value}`);
+    }
+    if (min !== undefined && parsed < min) {
+        throw new errors_1.ValidationError(`Value must be at least ${min}`);
+    }
+    if (max !== undefined && parsed > max) {
+        throw new errors_1.ValidationError(`Value must be at most ${max}`);
+    }
+    return parsed;
+}
+/**
+ * Parse and validate command options
+ */
+function parseCommandOptions(schema, options) {
+    try {
+        return schema.parse(options);
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const issues = error.issues.map((issue) => {
+                const path = issue.path.length > 0 ? issue.path.join('.') : 'root';
+                return `${path}: ${issue.message}`;
+            });
+            throw new errors_1.ValidationError(`Invalid options: ${issues.join(', ')}`);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=input-parser.js.map

package/dist/commands/utils/output-formatter.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Output formatting utilities
+ * Provides consistent formatting across commands
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatApplication = formatApplication;
+exports.formatGateway = formatGateway;
+exports.formatList = formatList;
+exports.formatError = formatError;
+exports.formatSuccess = formatSuccess;
+exports.formatWarning = formatWarning;
+exports.formatInfo = formatInfo;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Format application output
+ */
+function formatApplication(app) {
+    const statusColor = app.status === 'active' ? chalk_1.default.green : chalk_1.default.red;
+    const statusIcon = app.status === 'active' ? '●' : '○';
+    let output = '';
+    output += `${statusIcon} ${app.name}\n`;
+    output += chalk_1.default.gray(`   ID: ${app.id}\n`);
+    output += chalk_1.default.gray(`   Serving IP: ${chalk_1.default.cyan.bold(app.servingIp)}\n`);
+    output += chalk_1.default.gray(`   Port: ${app.port}\n`);
+    output += chalk_1.default.gray(`   Protocol: ${app.protocol.toUpperCase()}\n`);
+    output += chalk_1.default.gray(`   Status: ${statusColor(app.status)}\n`);
+    if (app.workloadId) {
+        output += chalk_1.default.gray(`   Workload ID: ${app.workloadId}\n`);
+    }
+    output += chalk_1.default.gray(`   Created: ${new Date(app.createdAt).toLocaleString()}\n`);
+    if (app.description) {
+        output += chalk_1.default.gray(`   Description: ${app.description}\n`);
+    }
+    output += chalk_1.default.cyan(`   URL: ${app.protocol}://${app.servingIp}:${app.port}\n`);
+    return output;
+}
+/**
+ * Format gateway output
+ */
+function formatGateway(gateway) {
+    const statusColor = gateway.ec2Instance?.state === 'running' ? chalk_1.default.green : chalk_1.default.red;
+    const statusIcon = gateway.ec2Instance?.state === 'running' ? '●' : '○';
+    let output = '';
+    output += `${statusIcon} ${gateway.device.name}\n`;
+    output += chalk_1.default.gray(`   Device ID: ${gateway.device.id}\n`);
+    output += chalk_1.default.gray(`   Description: ${gateway.device.description || 'No description'}\n`);
+    if (gateway.applicationCount !== undefined) {
+        output += chalk_1.default.gray(`   Applications: ${gateway.applicationCount}\n`);
+    }
+    if (gateway.ec2Instance) {
+        output += chalk_1.default.gray(`   EC2 Instance: ${gateway.ec2Instance.instanceId}\n`);
+        output += chalk_1.default.gray(`   Public IP: ${chalk_1.default.cyan.bold(gateway.ec2Instance.publicIp)}\n`);
+        output += chalk_1.default.gray(`   Private IP: ${gateway.ec2Instance.privateIp}\n`);
+        output += chalk_1.default.gray(`   Region: ${gateway.ec2Instance.region}\n`);
+        output += chalk_1.default.gray(`   State: ${statusColor(gateway.ec2Instance.state)}\n`);
+    }
+    output += chalk_1.default.gray(`   Created: ${new Date(gateway.device.createdAt).toLocaleString()}\n`);
+    return output;
+}
+/**
+ * Format list of items as table-like output
+ */
+function formatList(items, formatItem, header, emptyMessage) {
+    if (items.length === 0) {
+        return emptyMessage ? chalk_1.default.yellow(`⚠ ${emptyMessage}`) : '';
+    }
+    let output = '';
+    if (header) {
+        output += chalk_1.default.blue.bold(`${header}\n\n`);
+    }
+    items.forEach((item, index) => {
+        output += formatItem(item, index);
+        output += '\n';
+    });
+    return output;
+}
+/**
+ * Format error message with context
+ */
+function formatError(message, suggestion) {
+    let output = chalk_1.default.red(`✗ ${message}\n`);
+    if (suggestion) {
+        output += chalk_1.default.gray(`   ${suggestion}\n`);
+    }
+    return output;
+}
+/**
+ * Format success message
+ */
+function formatSuccess(message) {
+    return chalk_1.default.green(`✓ ${message}\n`);
+}
+/**
+ * Format warning message
+ */
+function formatWarning(message) {
+    return chalk_1.default.yellow(`⚠ ${message}\n`);
+}
+/**
+ * Format info message
+ */
+function formatInfo(message) {
+    return chalk_1.default.blue(`${message}\n`);
+}
+//# sourceMappingURL=output-formatter.js.map

package/dist/config/app-config.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Application configuration management
+ * Centralizes all configuration loading and validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.validateConfig = validateConfig;
+exports.getConfig = getConfig;
+exports.resetConfig = resetConfig;
+const urls_1 = require("../utils/urls");
+// Production defaults - these are used when environment variables are not set
+const DEFAULT_REGION = 'us-east-1';
+const DEFAULT_INSTANCE_TYPE = 't3.micro';
+/**
+ * Load configuration from environment variables and defaults
+ *
+ * Environment variable precedence:
+ * 1. User's environment variables (process.env.*) - highest priority
+ * 2. Production defaults (constants above) - fallback
+ *
+ * Note: Environment variables are read directly from process.env at runtime.
+ * Users can set these via shell/system environment variables.
+ *
+ * Available environment variables:
+ * - LOG_LEVEL: Set log level (default: 'INFO')
+ * Note: API_BASE_URL is now hardcoded based on stage (STAGE or SST_STAGE env var)
+ * - NO_COLOR: Disable colored output (set to '1' or 'true')
+ * - PLAIN_OUTPUT: Enable plain text output (set to '1' or 'true')
+ * - DEFAULT_REGION: Default AWS region (default: 'us-east-1')
+ * - DEFAULT_INSTANCE_TYPE: Default EC2 instance type (default: 't3.micro')
+ */
+function loadConfig() {
+    const apiBaseUrl = (0, urls_1.getApiBaseUrl)();
+    const logLevel = process.env.LOG_LEVEL || 'INFO';
+    const colorEnabled = process.env.NO_COLOR !== '1' && process.env.NO_COLOR !== 'true';
+    const plain = process.env.PLAIN_OUTPUT === '1' || process.env.PLAIN_OUTPUT === 'true';
+    const defaultRegion = process.env.DEFAULT_REGION || DEFAULT_REGION;
+    const defaultInstanceType = process.env.DEFAULT_INSTANCE_TYPE || DEFAULT_INSTANCE_TYPE;
+    return {
+        apiBaseUrl,
+        logLevel,
+        colorEnabled,
+        plain,
+        defaultRegion,
+        defaultInstanceType,
+    };
+}
+/**
+ * Validate configuration
+ */
+function validateConfig(config) {
+    const errors = [];
+    // Validate API URL
+    try {
+        new URL(config.apiBaseUrl);
+    }
+    catch {
+        errors.push(`Invalid API base URL: ${config.apiBaseUrl}`);
+    }
+    // Validate log level
+    const validLogLevels = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE', 'SILENT'];
+    if (!validLogLevels.includes(config.logLevel.toUpperCase())) {
+        errors.push(`Invalid log level: ${config.logLevel}. Valid values: ${validLogLevels.join(', ')}`);
+    }
+    // Validate region format (basic check)
+    if (!/^[a-z0-9-]+$/.test(config.defaultRegion)) {
+        errors.push(`Invalid default region format: ${config.defaultRegion}`);
+    }
+    // Validate instance type format (basic check)
+    if (!/^[a-z0-9.]+$/.test(config.defaultInstanceType)) {
+        errors.push(`Invalid default instance type format: ${config.defaultInstanceType}`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Get configuration singleton
+ */
+let configInstance = null;
+function getConfig() {
+    if (!configInstance) {
+        configInstance = loadConfig();
+        const validation = validateConfig(configInstance);
+        if (!validation.valid) {
+            console.warn('Configuration validation warnings:', validation.errors);
+        }
+    }
+    return configInstance;
+}
+/**
+ * Reset configuration (useful for testing)
+ */
+function resetConfig() {
+    configInstance = null;
+}
+//# sourceMappingURL=app-config.js.map