@edgible-team/cli 1.0.1

package/dist/commands/auth.js

@@ -0,0 +1,570 @@
+"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.setupAuthCommands = setupAuthCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const os = __importStar(require("os"));
+const validation_1 = require("../utils/validation");
+const passwordValidation_1 = require("../utils/passwordValidation");
+const ToolDetector_1 = require("../detection/ToolDetector");
+const command_wrapper_1 = require("./base/command-wrapper");
+const container_1 = require("../di/container");
+const types_1 = require("../di/types");
+function setupAuthCommands(program) {
+    const authCommand = program
+        .command('auth')
+        .description('Manage authentication');
+    authCommand
+        .command('login')
+        .description('Login with user account or create device login')
+        .addHelpText('after', `
+Examples:
+  $ edgible auth login
+  $ edgible auth login --device --device-name mydevice --email user@example.com
+  $ edgible auth login --device --device-name mydevice --email user@example.com --password "SecurePass123!"
+  `)
+        .option('--device', 'Login as a device')
+        .option('--device-name <name>', 'Device name (required for device login)')
+        .option('--device-type <type>', 'Device type: serving or gateway (default: serving)')
+        .option('--email <email>', 'Email address for invite (required for device login)')
+        .option('--password <password>', 'Device password (if not provided, will be generated)')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const authService = container.get(types_1.TYPES.AuthService);
+        const isFirstRun = configRepository.isFirstRun();
+        const savedEmail = configRepository.getEmail();
+        if (options.device) {
+            await handleDeviceLogin(configRepository, authService, savedEmail, isFirstRun, options, logger);
+            return;
+        }
+        // Interactive mode (existing logic)
+        if (isFirstRun) {
+            console.log(chalk_1.default.blue.bold('\n🎉 Welcome to Edgible CLI!'));
+            console.log(chalk_1.default.gray('This is your first time using the Edgible CLI.'));
+            console.log(chalk_1.default.gray('You can login in two ways:\n'));
+            console.log(chalk_1.default.cyan('1. User Login: Use your existing account email and password'));
+            console.log(chalk_1.default.cyan('2. Device Login: Create a device without an account (invite email will be sent)\n'));
+            // Detect available tools on first run
+            console.log(chalk_1.default.gray('Detecting available infrastructure tools...'));
+            const detectedTools = await ToolDetector_1.ToolDetector.detectTools();
+            ToolDetector_1.ToolDetector.displayDetectedTools(detectedTools);
+            // Store tool detection results in config
+            configRepository.updateConfig({
+                detectedTools: detectedTools.filter((t) => t.available).map((t) => t.name),
+                toolDetectionDate: new Date().toISOString(),
+            });
+        }
+        else {
+            console.log(chalk_1.default.blue('Welcome back to Edgible CLI!'));
+        }
+        // Choose login method
+        const loginMethod = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'method',
+                message: 'How would you like to login?',
+                choices: [
+                    { name: 'User Login (I have an account)', value: 'user' },
+                    { name: 'Device Login (Create device without account)', value: 'device' },
+                ],
+            },
+        ]);
+        if (loginMethod.method === 'user') {
+            await handleUserLogin(configRepository, authService, savedEmail, isFirstRun, logger);
+        }
+        else {
+            await handleDeviceLogin(configRepository, authService, savedEmail, isFirstRun, {}, logger);
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    authCommand
+        .command('logout')
+        .description('Log out of the Edgible service')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        configRepository.clearConfig();
+        logger.info('User logged out');
+        console.log(chalk_1.default.green('✓ You have been logged out.'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    authCommand
+        .command('select-org')
+        .description('Select active organization from your available organizations')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const authService = container.get(types_1.TYPES.AuthService);
+        const config = configRepository.getConfig();
+        // Check if user is logged in
+        if (!config.email) {
+            console.log(chalk_1.default.red('✗ You must be logged in to select an organization.'));
+            console.log(chalk_1.default.gray('Run "edgible auth login" to login first.'));
+            return;
+        }
+        console.log(chalk_1.default.blue('\n🏢 Select Organization\n'));
+        console.log(chalk_1.default.gray('Fetching your organizations...\n'));
+        try {
+            // Get user organizations
+            const userOrgs = await authService.getUserOrganizations(config.email);
+            // Filter for standard (non-billing) organizations only
+            const standardOrgs = userOrgs.organizations.filter((org) => org.organizationType !== 'billing');
+            if (standardOrgs.length === 0) {
+                console.log(chalk_1.default.yellow('⚠ No organizations found for your account.'));
+                logger.warn('No standard organizations found', { email: config.email });
+                return;
+            }
+            if (standardOrgs.length === 1) {
+                console.log(chalk_1.default.yellow('You only have access to one organization:'));
+                console.log(chalk_1.default.cyan(`  ${standardOrgs[0].name} (${standardOrgs[0].organizationId})`));
+                console.log(chalk_1.default.gray('\nThis organization is already active.'));
+                return;
+            }
+            // Show current organization
+            if (config.organizationId) {
+                const currentOrg = standardOrgs.find(org => org.organizationId === config.organizationId);
+                if (currentOrg) {
+                    console.log(chalk_1.default.gray(`Current organization: ${currentOrg.name}\n`));
+                }
+            }
+            // Create choices for inquirer
+            const orgChoices = standardOrgs.map((org) => {
+                const isCurrent = org.organizationId === config.organizationId;
+                return {
+                    name: `${org.name}${isCurrent ? chalk_1.default.gray(' (current)') : ''}${org.description ? chalk_1.default.gray(` - ${org.description}`) : ''}`,
+                    value: org.organizationId,
+                    short: org.name
+                };
+            });
+            // Prompt for organization selection
+            const { selectedOrgId } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedOrgId',
+                    message: 'Select organization:',
+                    choices: orgChoices,
+                    default: config.organizationId
+                }
+            ]);
+            // Check if same as current
+            if (selectedOrgId === config.organizationId) {
+                console.log(chalk_1.default.gray('\nNo change - this organization is already active.'));
+                return;
+            }
+            // Update config with selected organization
+            configRepository.updateConfig({ organizationId: selectedOrgId });
+            const selectedOrg = standardOrgs.find(org => org.organizationId === selectedOrgId);
+            logger.info('Organization changed', {
+                from: config.organizationId,
+                to: selectedOrgId,
+                organizationName: selectedOrg?.name
+            });
+            console.log(chalk_1.default.green(`\n✓ Active organization changed to: ${selectedOrg?.name}`));
+            console.log(chalk_1.default.gray(`Organization ID: ${selectedOrgId}`));
+        }
+        catch (error) {
+            logger.error('Error fetching organizations', error);
+            const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
+            console.error(chalk_1.default.red('\n✗ Failed to fetch organizations:'), errorMessage);
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+}
+async function handleUserLogin(configRepository, authService, savedEmail, isFirstRun, logger) {
+    // Check if we have a saved email
+    let email;
+    if (savedEmail && !isFirstRun) {
+        console.log(chalk_1.default.gray(`Using saved email: ${savedEmail}`));
+        const useSaved = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'useSaved',
+                message: 'Would you like to use this email address?',
+                default: true
+            }
+        ]);
+        if (useSaved.useSaved) {
+            email = savedEmail;
+        }
+        else {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'email',
+                    message: 'Enter your email address:',
+                    validate: (input) => {
+                        if (!input.trim()) {
+                            return 'Email address is required';
+                        }
+                        if (!(0, validation_1.validateEmail)(input)) {
+                            return 'Please enter a valid email address';
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            email = answers.email.trim().toLowerCase();
+        }
+    }
+    else {
+        console.log(chalk_1.default.gray('Please enter your email address to get started.'));
+        if (isFirstRun) {
+            console.log(chalk_1.default.yellow('💡 Don\'t worry if you don\'t have an account yet - you can create one later!'));
+        }
+        console.log('');
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'email',
+                message: 'Enter your email address:',
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return 'Email address is required';
+                    }
+                    if (!(0, validation_1.validateEmail)(input)) {
+                        return 'Please enter a valid email address';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        email = answers.email.trim().toLowerCase();
+    }
+    console.log(chalk_1.default.green(`\n✓ Email received: ${email}`));
+    console.log(chalk_1.default.gray('Checking account status...\n'));
+    // Save email to config
+    configRepository.setEmail(email);
+    // Check if account exists
+    logger.debug('Checking account existence', { email });
+    const accountExists = await authService.checkAccount(email);
+    if (accountExists) {
+        // Prompt for password
+        const passwordAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Enter your password:',
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return 'Password is required';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        try {
+            logger.info('Attempting user login', { email });
+            const loginResponse = await authService.loginUser(email, passwordAnswer.password);
+            console.log(chalk_1.default.green('✓ Login successful!'));
+            console.log(chalk_1.default.gray(`Welcome back, ${email}`));
+            // Get user organizations and store the first one (standard organizations only)
+            try {
+                const userOrgs = await authService.getUserOrganizations(email);
+                // Filter for standard (non-billing) organizations only
+                const standardOrgs = userOrgs.organizations.filter((org) => org.organizationType !== 'billing');
+                if (standardOrgs.length > 0) {
+                    configRepository.updateConfig({ organizationId: standardOrgs[0].organizationId });
+                    logger.info('Organization selected', { organizationId: standardOrgs[0].organizationId });
+                    console.log(chalk_1.default.gray(`Using organization: ${standardOrgs[0].name}`));
+                }
+                else {
+                    logger.warn('No standard organizations found for user', { email });
+                    console.log(chalk_1.default.yellow('⚠ No standard organizations found for this user'));
+                }
+            }
+            catch (orgError) {
+                logger.warn('Could not fetch organizations', orgError);
+                console.log(chalk_1.default.yellow('⚠ Could not fetch organizations, but login was successful'));
+            }
+            configRepository.setAccountStatus(true);
+            configRepository.setFirstRunComplete();
+            console.log(chalk_1.default.gray('Use "edgible --help" to see available commands.'));
+        }
+        catch (error) {
+            logger.error('Login failed', error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.log(chalk_1.default.red('✗ Login failed:'), errorMessage);
+            console.log(chalk_1.default.gray('Please check your email and password.'));
+        }
+    }
+    else {
+        logger.debug('No account found for email', { email });
+        console.log(chalk_1.default.yellow('⚠ No account found for this email.'));
+        configRepository.setAccountStatus(false);
+        if (isFirstRun) {
+            console.log(chalk_1.default.blue('\n🔧 No worries! You can create an account in a few ways:'));
+            console.log(chalk_1.default.gray('1. Use the "edgible signup" command'));
+            console.log(chalk_1.default.gray('2. Visit https://edgible.com/signup in your browser'));
+            console.log(chalk_1.default.gray('3. Use device login to create a device without an account'));
+            console.log(chalk_1.default.gray('4. Come back later and run "edgible login" again\n'));
+        }
+        else {
+            console.log(chalk_1.default.gray('You can create an account by visiting the Edgible website or using the signup command.'));
+        }
+        const createAccount = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'create',
+                message: 'Would you like to create an account now?',
+                default: true,
+            },
+        ]);
+        if (createAccount.create) {
+            console.log(chalk_1.default.blue('\nRedirecting to account creation...'));
+            console.log(chalk_1.default.gray('Please visit https://edgible.com/signup to create your account.'));
+            console.log(chalk_1.default.gray(`We\'ll remember your email: ${email}`));
+        }
+        configRepository.setFirstRunComplete();
+    }
+}
+async function handleDeviceLogin(configRepository, authService, savedEmail, isFirstRun, options, logger) {
+    if (options.deviceName && options.email) {
+        await handleDeviceLoginNonInteractive(configRepository, authService, options.deviceName, (options.deviceType || 'serving'), options.email, options.password, logger);
+        return;
+    }
+    console.log(chalk_1.default.blue('\n🔧 Device Login Setup'));
+    console.log(chalk_1.default.gray('This will create a device without requiring a user account.'));
+    console.log(chalk_1.default.gray('An invite email will be sent to you automatically.\n'));
+    // Get device name
+    const deviceNameAnswer = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'deviceName',
+            message: 'Enter a name for this device:',
+            default: `${os.hostname()}-${os.platform()}`,
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'Device name is required';
+                }
+                return true;
+            }
+        }
+    ]);
+    // Get device type
+    const deviceTypeAnswer = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'deviceType',
+            message: 'Select device type:',
+            choices: [
+                { name: 'Serving Device - Host applications and services', value: 'serving' },
+                { name: 'Gateway Device - Route traffic and manage firewall', value: 'gateway' }
+            ],
+            default: 'serving'
+        }
+    ]);
+    // API URL is now managed through AppConfig
+    // Get optional user email for invite
+    let userEmail;
+    if (savedEmail) {
+        const useSavedEmail = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'useSaved',
+                message: `Use saved email (${savedEmail}) for invite?`,
+                default: true
+            }
+        ]);
+        if (useSavedEmail.useSaved) {
+            userEmail = savedEmail;
+        }
+    }
+    if (!userEmail) {
+        const emailAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'email',
+                message: 'Enter your email address (for invite):',
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return 'Email address is required for invite';
+                    }
+                    if (!(0, validation_1.validateEmail)(input)) {
+                        return 'Please enter a valid email address';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        userEmail = emailAnswer.email.trim().toLowerCase();
+    }
+    // Generate or get password
+    const passwordChoice = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'choice',
+            message: 'Choose password option:',
+            choices: [
+                { name: 'Generate secure password automatically', value: 'generate' },
+                { name: 'Enter custom password', value: 'custom' }
+            ]
+        }
+    ]);
+    let password;
+    if (passwordChoice.choice === 'generate') {
+        password = (0, passwordValidation_1.generateSecurePassword)();
+        console.log(chalk_1.default.green(`\n✓ Generated secure password: ${password}`));
+        console.log(chalk_1.default.yellow('⚠ Please save this password securely! You will need it to login.'));
+    }
+    else {
+        const passwordAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Enter password (must meet security requirements):',
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return 'Password is required';
+                    }
+                    const validation = (0, passwordValidation_1.validateCognitoPassword)(input);
+                    if (!validation.isValid) {
+                        return `Password requirements not met: ${validation.errors.join(', ')}`;
+                    }
+                    return true;
+                }
+            }
+        ]);
+        password = passwordAnswer.password;
+    }
+    console.log(chalk_1.default.gray('\nCreating device and organization...'));
+    try {
+        logger.info('Creating device with organization', { deviceName: deviceNameAnswer.deviceName });
+        const response = await authService.createDeviceWithOrganization(deviceNameAnswer.deviceName, password, userEmail);
+        console.log(chalk_1.default.green('\n✓ Device created successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Device Details:'));
+        console.log(chalk_1.default.white(`  Device ID: ${response.device.id}`));
+        console.log(chalk_1.default.white(`  Device Name: ${response.device.name}`));
+        console.log(chalk_1.default.white(`  Organization: ${response.organization.name}`));
+        console.log(chalk_1.default.white(`  Password: ${password}`));
+        if (userEmail) {
+            console.log(chalk_1.default.white(`  Invite Email: ${userEmail}`));
+            console.log(chalk_1.default.yellow('\n📧 An invite email has been sent to your email address.'));
+        }
+        console.log(chalk_1.default.blue('\n🔐 Login Credentials:'));
+        console.log(chalk_1.default.cyan(`  Device ID: ${response.device.id}`));
+        console.log(chalk_1.default.cyan(`  Password: ${password}`));
+        console.log(chalk_1.default.gray('\nUse these credentials to login with "edgible device-login" in the future.'));
+        // Save device info to config
+        logger.info('Device created successfully', { deviceId: response.device.id });
+        configRepository.updateConfig({
+            deviceId: response.device.id,
+            deviceName: response.device.name,
+            devicePassword: password,
+            deviceType: deviceTypeAnswer.deviceType,
+            organizationId: response.organization.organizationId,
+            userEmail: userEmail,
+        });
+        configRepository.setFirstRunComplete();
+    }
+    catch (error) {
+        logger.error('Device creation failed', error);
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.log(chalk_1.default.red('✗ Device creation failed:'), errorMessage);
+        console.log(chalk_1.default.gray('Please try again or contact support.'));
+    }
+}
+async function handleDeviceLoginNonInteractive(configRepository, authService, deviceName, deviceType, userEmail, password, logger) {
+    console.log(chalk_1.default.gray('Creating device without requiring a user account.'));
+    console.log(chalk_1.default.gray('An invite email will be sent automatically.\n'));
+    // Generate password if not provided
+    let devicePassword;
+    if (password) {
+        // Validate provided password
+        const validation = (0, passwordValidation_1.validateCognitoPassword)(password);
+        if (!validation.isValid) {
+            logger.error('Password requirements not met', { errors: validation.errors });
+            throw new Error(`Password requirements not met: ${validation.errors.join(', ')}`);
+        }
+        devicePassword = password;
+        console.log(chalk_1.default.green(`✓ Using provided password`));
+    }
+    else {
+        devicePassword = (0, passwordValidation_1.generateSecurePassword)();
+        console.log(chalk_1.default.green(`✓ Generated secure password: ${devicePassword}`));
+    }
+    console.log(chalk_1.default.gray('\nCreating device and organization...'));
+    try {
+        logger.info('Creating device with organization (non-interactive)', { deviceName });
+        const response = await authService.createDeviceWithOrganization(deviceName, devicePassword, userEmail);
+        console.log(chalk_1.default.green('\n✓ Device created successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Device Details:'));
+        console.log(chalk_1.default.white(`  Device ID: ${response.device.id}`));
+        console.log(chalk_1.default.white(`  Device Name: ${response.device.name}`));
+        console.log(chalk_1.default.white(`  Organization: ${response.organization.name}`));
+        console.log(chalk_1.default.white(`  Password: ${devicePassword}`));
+        console.log(chalk_1.default.white(`  Invite Email: ${userEmail}`));
+        console.log(chalk_1.default.yellow('\n📧 An invite email has been sent to your email address.'));
+        console.log(chalk_1.default.blue('\n🔐 Login Credentials:'));
+        console.log(chalk_1.default.cyan(`  Device ID: ${response.device.id}`));
+        console.log(chalk_1.default.cyan(`  Password: ${devicePassword}`));
+        // Save device info to config
+        logger.info('Device created successfully (non-interactive)', { deviceId: response.device.id });
+        configRepository.updateConfig({
+            deviceId: response.device.id,
+            deviceName: response.device.name,
+            devicePassword: devicePassword,
+            deviceType: deviceType,
+            organizationId: response.organization.organizationId,
+            userEmail: userEmail,
+        });
+        configRepository.setFirstRunComplete();
+        // Output credentials in a format that can be easily parsed by scripts
+        const container = (0, container_1.getContainer)();
+        const appConfig = container.get(types_1.TYPES.AppConfig);
+        console.log(chalk_1.default.gray('\n--- CREDENTIALS FOR AUTOMATION ---'));
+        console.log(`DEVICE_ID=${response.device.id}`);
+        console.log(`DEVICE_PASSWORD=${devicePassword}`);
+        console.log(`API_BASE_URL=${appConfig.apiBaseUrl}`);
+        console.log('--- END CREDENTIALS ---');
+    }
+    catch (error) {
+        logger.error('Device creation failed (non-interactive)', error);
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.log(chalk_1.default.red('✗ Device creation failed:'), errorMessage);
+        throw error;
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/commands/base/BaseCommand.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Base command class
+ * Provides consistent command execution with middleware support
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+const errors_1 = require("../../utils/errors");
+/**
+ * Base command implementation with error handling and middleware
+ */
+class BaseCommand {
+    constructor(options) {
+        this.middlewares = [];
+        this.logger = options.logger;
+        this.configRepository = options.configRepository;
+        this.requireAuth = options.requireAuth ?? false;
+        this.requireOrganization = options.requireOrganization ?? false;
+    }
+    /**
+     * Add middleware to the command
+     */
+    use(middleware) {
+        this.middlewares.push(middleware);
+    }
+    /**
+     * Execute the command with middleware chain
+     */
+    async execute(context) {
+        try {
+            // Run middleware chain
+            await this.runMiddleware(context, 0);
+            // Execute the actual command
+            await this.doExecute(context);
+        }
+        catch (error) {
+            errors_1.ErrorHandler.handleError(error);
+        }
+    }
+    /**
+     * Run middleware chain
+     */
+    async runMiddleware(context, index) {
+        if (index >= this.middlewares.length) {
+            return;
+        }
+        const middleware = this.middlewares[index];
+        await middleware.process(context, async () => {
+            await this.runMiddleware(context, index + 1);
+        });
+    }
+    /**
+     * Override this method in subclasses to implement command logic
+     */
+    async doExecute(context) {
+        throw new Error('doExecute must be implemented by subclass');
+    }
+    /**
+     * Check if user is authenticated
+     */
+    ensureAuthenticated() {
+        if (!this.requireAuth) {
+            return;
+        }
+        const config = this.configRepository.getConfig();
+        const hasTokens = !!(config.accessToken || config.idToken);
+        const hasDeviceCreds = !!(config.deviceId && config.devicePassword);
+        if (!hasTokens && !hasDeviceCreds) {
+            throw new Error('Not authenticated. Please run "edgible login" first.');
+        }
+    }
+    /**
+     * Check if organization ID is available
+     */
+    ensureOrganization() {
+        if (!this.requireOrganization) {
+            return;
+        }
+        const config = this.configRepository.getConfig();
+        if (!config.organizationId) {
+            throw new Error('No organization found. Please login first.');
+        }
+    }
+    /**
+     * Validate and ensure authentication and organization
+     */
+    validateContext() {
+        this.ensureAuthenticated();
+        this.ensureOrganization();
+    }
+}
+exports.BaseCommand = BaseCommand;
+//# sourceMappingURL=BaseCommand.js.map

package/dist/commands/base/CommandHandler.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Command handler interface
+ * Defines the contract for command execution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=CommandHandler.js.map