@edgible-team/cli 1.0.1

package/dist/utils/output.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputConfig = void 0;
+exports.success = success;
+exports.error = error;
+exports.warning = warning;
+exports.info = info;
+exports.gray = gray;
+exports.cyan = cyan;
+exports.white = white;
+exports.heading = heading;
+exports.section = section;
+exports.field = field;
+exports.formatOutput = formatOutput;
+exports.outputJSON = outputJSON;
+exports.detectColorSupport = detectColorSupport;
+exports.applyOutputConfig = applyOutputConfig;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Configuration for output formatting
+ */
+class OutputConfig {
+    constructor() {
+        this.colorEnabled = true;
+        this.plainMode = false;
+        this.emojiEnabled = true;
+    }
+    setNoColor() {
+        this.colorEnabled = false;
+        // Disable chalk colors
+        chalk_1.default.level = 0;
+    }
+    setPlainMode() {
+        this.plainMode = true;
+        this.emojiEnabled = false;
+        this.setNoColor();
+    }
+    reset() {
+        this.colorEnabled = true;
+        this.plainMode = false;
+        this.emojiEnabled = true;
+    }
+}
+exports.outputConfig = new OutputConfig();
+/**
+ * Format success message
+ */
+function success(message) {
+    if (exports.outputConfig.plainMode)
+        return `✓ ${message}`;
+    return exports.outputConfig.colorEnabled ? chalk_1.default.green(`✓ ${message}`) : `✓ ${message}`;
+}
+/**
+ * Format error message
+ */
+function error(message) {
+    if (exports.outputConfig.plainMode)
+        return `✗ ${message}`;
+    return exports.outputConfig.colorEnabled ? chalk_1.default.red(`✗ ${message}`) : `✗ ${message}`;
+}
+/**
+ * Format warning message
+ */
+function warning(message) {
+    if (exports.outputConfig.plainMode)
+        return `⚠ ${message}`;
+    return exports.outputConfig.colorEnabled ? chalk_1.default.yellow(`⚠ ${message}`) : `⚠ ${message}`;
+}
+/**
+ * Format info message
+ */
+function info(message) {
+    if (exports.outputConfig.plainMode)
+        return message;
+    return exports.outputConfig.colorEnabled ? chalk_1.default.blue(message) : message;
+}
+/**
+ * Format gray message
+ */
+function gray(message) {
+    if (exports.outputConfig.plainMode)
+        return message;
+    return exports.outputConfig.colorEnabled ? chalk_1.default.gray(message) : message;
+}
+/**
+ * Format cyan message
+ */
+function cyan(message) {
+    if (exports.outputConfig.plainMode)
+        return message;
+    return exports.outputConfig.colorEnabled ? chalk_1.default.cyan(message) : message;
+}
+/**
+ * Format white message
+ */
+function white(message) {
+    if (exports.outputConfig.plainMode)
+        return message;
+    return exports.outputConfig.colorEnabled ? chalk_1.default.white(message) : message;
+}
+/**
+ * Format heading
+ */
+function heading(message) {
+    if (exports.outputConfig.plainMode)
+        return `\n${message}\n`;
+    const border = exports.outputConfig.emojiEnabled ? '═'.repeat(60) : '='.repeat(60);
+    return exports.outputConfig.colorEnabled
+        ? chalk_1.default.blue.bold(`\n${border}\n${message}\n${border}`)
+        : `\n${message}\n`;
+}
+/**
+ * Format section header
+ */
+function section(title) {
+    if (exports.outputConfig.plainMode)
+        return `\n${title}:\n`;
+    return exports.outputConfig.colorEnabled ? chalk_1.default.blue(title) : title;
+}
+/**
+ * Format field label and value
+ */
+function field(label, value, highlight = false) {
+    const labelText = `${label}:`;
+    if (exports.outputConfig.plainMode)
+        return `  ${labelText} ${value}`;
+    const formattedLabel = exports.outputConfig.colorEnabled ? chalk_1.default.gray(labelText) : labelText;
+    const formattedValue = highlight && exports.outputConfig.colorEnabled
+        ? chalk_1.default.cyan.bold(value)
+        : exports.outputConfig.colorEnabled
+            ? chalk_1.default.white(value)
+            : value;
+    return `  ${formattedLabel} ${formattedValue}`;
+}
+/**
+ * Output structured data as formatted text
+ */
+function formatOutput(data) {
+    return Object.entries(data).map(([key, value]) => field(key, String(value)));
+}
+/**
+ * Output JSON
+ */
+function outputJSON(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+/**
+ * Detect if color should be enabled
+ */
+function detectColorSupport() {
+    // Support NO_COLOR environment variable
+    if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '') {
+        return false;
+    }
+    // Support --no-color flag
+    if (process.argv.includes('--no-color')) {
+        return false;
+    }
+    // Check if TTY supports color
+    if (!process.stdout.isTTY) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Apply global output configuration based on flags
+ */
+function applyOutputConfig(flags) {
+    if (flags.plain) {
+        exports.outputConfig.setPlainMode();
+    }
+    else if (flags.noColor) {
+        exports.outputConfig.setNoColor();
+    }
+    else {
+        exports.outputConfig.colorEnabled = detectColorSupport();
+    }
+}
+//# sourceMappingURL=output.js.map

package/dist/utils/passwordValidation.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Password validation utility for Cognito requirements
+ * Based on AWS Cognito password policy requirements
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCognitoPassword = validateCognitoPassword;
+exports.generateSecurePassword = generateSecurePassword;
+exports.validateEmail = validateEmail;
+exports.isEmail = isEmail;
+/**
+ * Validates password against Cognito password policy requirements
+ * @param password - Password to validate
+ * @returns PasswordValidationResult with validation status and errors
+ */
+function validateCognitoPassword(password) {
+    const errors = [];
+    // Minimum length requirement (8 characters)
+    if (password.length < 8) {
+        errors.push('Password must be at least 8 characters long');
+    }
+    // Maximum length requirement (128 characters)
+    if (password.length > 128) {
+        errors.push('Password must be no more than 128 characters long');
+    }
+    // Uppercase letter requirement
+    if (!/[A-Z]/.test(password)) {
+        errors.push('Password must contain at least one uppercase letter');
+    }
+    // Lowercase letter requirement
+    if (!/[a-z]/.test(password)) {
+        errors.push('Password must contain at least one lowercase letter');
+    }
+    // Number requirement
+    if (!/[0-9]/.test(password)) {
+        errors.push('Password must contain at least one number');
+    }
+    // Special character requirement
+    if (!/[!@#$%^&*()_+\-=\[\]{}|;:,.<>?]/.test(password)) {
+        errors.push('Password must contain at least one special character (!@#$%^&*()_+-=[]{}|;:,.<>?)');
+    }
+    // No spaces allowed
+    if (/\s/.test(password)) {
+        errors.push('Password cannot contain spaces');
+    }
+    return {
+        isValid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Generates a secure password that meets Cognito requirements
+ * @returns A secure password string
+ */
+function generateSecurePassword() {
+    const uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const lowercase = 'abcdefghijklmnopqrstuvwxyz';
+    const numbers = '0123456789';
+    const symbols = '!@#$%^&*()_+-=[]{}|;:,.<>?';
+    // Ensure at least one character from each required category
+    let password = '';
+    password += uppercase[Math.floor(Math.random() * uppercase.length)];
+    password += lowercase[Math.floor(Math.random() * lowercase.length)];
+    password += numbers[Math.floor(Math.random() * numbers.length)];
+    password += symbols[Math.floor(Math.random() * symbols.length)];
+    // Fill the rest with random characters from all categories
+    const allChars = uppercase + lowercase + numbers + symbols;
+    for (let i = 4; i < 12; i++) { // Minimum 8 chars, we'll have 12
+        password += allChars[Math.floor(Math.random() * allChars.length)];
+    }
+    // Shuffle the password
+    return password.split('').sort(() => Math.random() - 0.5).join('');
+}
+/**
+ * Validates email format
+ * @param email - Email to validate
+ * @returns boolean indicating if email is valid
+ */
+function validateEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+/**
+ * Determines if input is an email or device ID
+ * @param input - Input to check
+ * @returns boolean indicating if input is an email
+ */
+function isEmail(input) {
+    return validateEmail(input);
+}
+//# sourceMappingURL=passwordValidation.js.map

package/dist/utils/progress.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressBar = exports.Spinner = void 0;
+exports.spinner = spinner;
+exports.progressBar = progressBar;
+const chalk_1 = __importDefault(require("chalk"));
+const output_1 = require("./output");
+/**
+ * Simple spinner implementation for progress indication
+ */
+class Spinner {
+    constructor(message) {
+        this.interval = null;
+        this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        this.currentFrame = 0;
+        this.message = message;
+        this.startTime = new Date();
+    }
+    /**
+     * Start the spinner
+     */
+    start() {
+        if (output_1.outputConfig.plainMode) {
+            console.log(this.message);
+            return;
+        }
+        const writeMessage = () => {
+            const frame = output_1.outputConfig.colorEnabled
+                ? chalk_1.default.cyan(this.frames[this.currentFrame])
+                : this.frames[this.currentFrame];
+            process.stdout.write(`\r${frame} ${this.message}`);
+            this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+        };
+        writeMessage();
+        this.interval = setInterval(writeMessage, 80);
+    }
+    /**
+     * Update the spinner message
+     */
+    update(message) {
+        this.message = message;
+    }
+    /**
+     * Stop the spinner with success message
+     */
+    succeed(message) {
+        this.stop();
+        if (message) {
+            console.log(chalk_1.default.green(`✓ ${message}`));
+        }
+        else {
+            console.log(chalk_1.default.green(`✓ ${this.message}`));
+        }
+    }
+    /**
+     * Stop the spinner with failure message
+     */
+    fail(message) {
+        this.stop();
+        if (message) {
+            console.log(chalk_1.default.red(`✗ ${message}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`✗ ${this.message}`));
+        }
+    }
+    /**
+     * Stop the spinner with info message
+     */
+    info(message) {
+        this.stop();
+        if (message) {
+            console.log(chalk_1.default.blue(`ℹ ${message}`));
+        }
+        else {
+            console.log(chalk_1.default.blue(`ℹ ${this.message}`));
+        }
+    }
+    /**
+     * Stop the spinner without any message
+     */
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+            process.stdout.write('\r' + ' '.repeat(process.stdout.columns) + '\r');
+        }
+    }
+    /**
+     * Get elapsed time in milliseconds
+     */
+    elapsed() {
+        return Date.now() - this.startTime.getTime();
+    }
+}
+exports.Spinner = Spinner;
+/**
+ * Create and start a new spinner
+ */
+function spinner(message) {
+    const spinnerInstance = new Spinner(message);
+    spinnerInstance.start();
+    return spinnerInstance;
+}
+/**
+ * Progress bar implementation
+ */
+class ProgressBar {
+    constructor(total, filled = 0, message = '') {
+        this.current = 0;
+        this.width = 40;
+        this.total = total;
+        this.current = filled;
+        this.message = message;
+    }
+    /**
+     * Update progress and render
+     */
+    update(current) {
+        this.current = current;
+        this.render();
+    }
+    /**
+     * Increment progress and render
+     */
+    increment(amount = 1) {
+        this.current = Math.min(this.current + amount, this.total);
+        this.render();
+    }
+    /**
+     * Render the progress bar
+     */
+    render() {
+        const percentage = Math.min(100, (this.current / this.total) * 100);
+        const filled = Math.floor((this.current / this.total) * this.width);
+        const empty = this.width - filled;
+        const filledBar = '█'.repeat(filled);
+        const emptyBar = '░'.repeat(empty);
+        const bar = output_1.outputConfig.colorEnabled
+            ? chalk_1.default.green(filledBar) + chalk_1.default.gray(emptyBar)
+            : filledBar + emptyBar;
+        const text = `${this.message} ${bar} ${percentage.toFixed(0)}% (${this.current}/${this.total})`;
+        process.stdout.write('\r' + text);
+    }
+    /**
+     * Complete the progress bar
+     */
+    complete(message) {
+        this.current = this.total;
+        this.render();
+        console.log(''); // New line
+        if (message) {
+            console.log(message);
+        }
+    }
+}
+exports.ProgressBar = ProgressBar;
+/**
+ * Create a new progress bar
+ */
+function progressBar(total, message = '') {
+    return new ProgressBar(total, 0, message);
+}
+//# sourceMappingURL=progress.js.map

package/dist/utils/sudo-checker.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Utility to check if the current process is running with elevated permissions (sudo/root)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSudoPermissions = checkSudoPermissions;
+/**
+ * Check if the current process is running with elevated permissions
+ * @returns true if running as root/sudo, false otherwise
+ */
+function checkSudoPermissions() {
+    // On Unix-like systems, root user has UID 0
+    // On Windows, this will be undefined, so we return false
+    try {
+        const uid = process.getuid ? process.getuid() : undefined;
+        return uid === 0;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=sudo-checker.js.map

package/dist/utils/urls.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * URL utilities for building stage-based URLs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStage = getStage;
+exports.getDistributionUrl = getDistributionUrl;
+exports.getApiBaseUrl = getApiBaseUrl;
+/**
+ * Get the current stage from environment variables
+ * @returns Stage string (dev, staging, production, or default 'production')
+ */
+function getStage() {
+    return process.env['STAGE'] || process.env['SST_STAGE'] || 'prod';
+}
+/**
+ * Build the agent distribution URL based on stage
+ * @returns Distribution URL (e.g., https://distribution.production.edgible.com)
+ */
+function getDistributionUrl() {
+    const stage = getStage();
+    return `https://distribution.${stage}.edgible.com`;
+}
+/**
+ * Build the API base URL based on stage
+ * @returns API URL (e.g., https://api.v2.production.edgible.com)
+ */
+function getApiBaseUrl() {
+    const stage = getStage();
+    return `https://api.v2.${stage}.edgible.com`;
+}
+//# sourceMappingURL=urls.js.map

package/dist/utils/validation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEmail = validateEmail;
+exports.validateName = validateName;
+exports.isEmail = isEmail;
+/**
+ * Email validation utility
+ * @param email - Email address to validate
+ * @returns boolean indicating if email is valid
+ */
+function validateEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+/**
+ * Name validation utility
+ * @param name - Name to validate
+ * @returns boolean indicating if name is valid
+ */
+function validateName(name) {
+    return name.trim().length >= 2;
+}
+/**
+ * Determines if input is an email or device ID
+ * @param input - Input to check
+ * @returns boolean indicating if input is an email
+ */
+function isEmail(input) {
+    return validateEmail(input);
+}
+//# sourceMappingURL=validation.js.map

package/dist/validation/schemas.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Validation schemas using Zod
+ * Provides runtime validation for all command inputs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatewayLogsOptionsSchema = exports.createDeviceWithOrganizationRequestSchema = exports.deviceLoginRequestSchema = exports.loginRequestSchema = exports.createGatewayRequestSchema = exports.createApplicationRequestSchema = exports.urlSchema = exports.gatewayIdSchema = exports.applicationIdSchema = exports.deviceIdSchema = exports.awsProfileSchema = exports.awsInstanceTypeSchema = exports.awsRegionSchema = exports.gatewayNameSchema = exports.applicationNameSchema = exports.protocolSchema = exports.portSchema = exports.deviceNameSchema = exports.passwordSchema = exports.emailSchema = void 0;
+exports.validate = validate;
+exports.safeValidate = safeValidate;
+exports.formatValidationError = formatValidationError;
+const zod_1 = require("zod");
+/**
+ * Email validation schema
+ */
+exports.emailSchema = zod_1.z.string().email('Invalid email address').toLowerCase().trim();
+/**
+ * Password validation schema (Cognito requirements)
+ */
+exports.passwordSchema = zod_1.z
+    .string()
+    .min(8, 'Password must be at least 8 characters')
+    .max(128, 'Password must be at most 128 characters')
+    .regex(/[A-Z]/, 'Password must contain at least one uppercase letter')
+    .regex(/[a-z]/, 'Password must contain at least one lowercase letter')
+    .regex(/[0-9]/, 'Password must contain at least one number')
+    .regex(/[^A-Za-z0-9]/, 'Password must contain at least one special character');
+/**
+ * Device name schema
+ */
+exports.deviceNameSchema = zod_1.z
+    .string()
+    .min(1, 'Device name is required')
+    .max(100, 'Device name must be at most 100 characters')
+    .regex(/^[a-zA-Z0-9-_]+$/, 'Device name can only contain letters, numbers, hyphens, and underscores');
+/**
+ * Port number schema
+ */
+exports.portSchema = zod_1.z
+    .number()
+    .int('Port must be an integer')
+    .min(1, 'Port must be between 1 and 65535')
+    .max(65535, 'Port must be between 1 and 65535');
+/**
+ * Protocol schema
+ */
+exports.protocolSchema = zod_1.z.enum(['http', 'https', 'tcp', 'udp'], {
+    errorMap: () => ({ message: 'Protocol must be one of: http, https, tcp, udp' }),
+});
+/**
+ * Application name schema
+ */
+exports.applicationNameSchema = zod_1.z
+    .string()
+    .min(1, 'Application name is required')
+    .max(100, 'Application name must be at most 100 characters')
+    .regex(/^[a-zA-Z0-9-_]+$/, 'Application name can only contain letters, numbers, hyphens, and underscores');
+/**
+ * Gateway name schema
+ */
+exports.gatewayNameSchema = zod_1.z
+    .string()
+    .min(1, 'Gateway name is required')
+    .max(100, 'Gateway name must be at most 100 characters');
+/**
+ * AWS region schema
+ */
+exports.awsRegionSchema = zod_1.z.string().regex(/^[a-z0-9-]+$/, 'Invalid AWS region format');
+/**
+ * AWS instance type schema
+ */
+exports.awsInstanceTypeSchema = zod_1.z.string().regex(/^[a-z0-9.]+$/, 'Invalid AWS instance type format');
+/**
+ * AWS profile schema
+ */
+exports.awsProfileSchema = zod_1.z.string().min(1, 'AWS profile is required');
+/**
+ * Device ID schema (UUID format)
+ */
+exports.deviceIdSchema = zod_1.z.string().uuid('Device ID must be a valid UUID');
+/**
+ * Application ID schema (UUID format)
+ */
+exports.applicationIdSchema = zod_1.z.string().uuid('Application ID must be a valid UUID');
+/**
+ * Gateway ID schema (UUID format)
+ */
+exports.gatewayIdSchema = zod_1.z.string().uuid('Gateway ID must be a valid UUID');
+/**
+ * URL schema
+ */
+exports.urlSchema = zod_1.z.string().url('Invalid URL format');
+/**
+ * Create application request schema
+ */
+exports.createApplicationRequestSchema = zod_1.z.object({
+    name: exports.applicationNameSchema,
+    description: zod_1.z.string().max(500, 'Description must be at most 500 characters').optional(),
+    port: exports.portSchema,
+    protocol: exports.protocolSchema,
+    deviceId: exports.deviceIdSchema,
+    gatewayIds: zod_1.z.array(exports.gatewayIdSchema).optional(),
+    subtype: zod_1.z.enum(['local-preexisting', 'managed-docker', 'systemd', 'docker-compose']),
+});
+/**
+ * Create gateway request schema
+ */
+exports.createGatewayRequestSchema = zod_1.z.object({
+    name: exports.gatewayNameSchema,
+    description: zod_1.z.string().max(500, 'Description must be at most 500 characters').optional(),
+    awsProfile: exports.awsProfileSchema.optional(),
+    region: exports.awsRegionSchema.optional(),
+    instanceType: exports.awsInstanceTypeSchema.optional(),
+});
+/**
+ * Login request schema
+ */
+exports.loginRequestSchema = zod_1.z.object({
+    email: exports.emailSchema,
+    password: zod_1.z.string().min(1, 'Password is required'),
+});
+/**
+ * Device login request schema
+ */
+exports.deviceLoginRequestSchema = zod_1.z.object({
+    deviceId: exports.deviceIdSchema,
+    password: zod_1.z.string().min(1, 'Password is required'),
+});
+/**
+ * Create device with organization request schema
+ */
+exports.createDeviceWithOrganizationRequestSchema = zod_1.z.object({
+    deviceName: exports.deviceNameSchema,
+    password: exports.passwordSchema,
+    userEmail: exports.emailSchema.optional(),
+    deviceType: zod_1.z.enum(['serving', 'gateway']).optional(),
+});
+/**
+ * Gateway logs options schema
+ */
+exports.gatewayLogsOptionsSchema = zod_1.z.object({
+    gatewayId: exports.gatewayIdSchema.optional(),
+    lines: zod_1.z.number().int().min(1).max(10000).optional(),
+    follow: zod_1.z.boolean().optional(),
+    level: zod_1.z.enum(['error', 'warn', 'info', 'debug', 'all']).optional(),
+    comprehensive: zod_1.z.boolean().optional(),
+});
+/**
+ * Validate and parse data with schema
+ */
+function validate(schema, data) {
+    return schema.parse(data);
+}
+/**
+ * Safe validate - returns result instead of throwing
+ */
+function safeValidate(schema, data) {
+    const result = schema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    else {
+        return { success: false, error: result.error };
+    }
+}
+/**
+ * Format Zod error for user display
+ */
+function formatValidationError(error) {
+    const issues = error.issues.map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `${path}: ${issue.message}`;
+    });
+    return issues.join(', ');
+}
+//# sourceMappingURL=schemas.js.map