@edgible-team/cli 1.0.1

package/dist/services/application/ApplicationService.js

@@ -0,0 +1,299 @@
+"use strict";
+/**
+ * Application service
+ * Handles application management operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationServiceImpl = void 0;
+const client_1 = require("../../client");
+class ApplicationServiceImpl {
+    constructor(baseUrl, configRepository, authService, logger) {
+        this.applications = [];
+        this.baseUrl = baseUrl;
+        this.configRepository = configRepository;
+        this.authService = authService;
+        this.logger = logger;
+        this.apiClient = (0, client_1.createApiClient)(baseUrl);
+        this.restoreTokensFromApiClient();
+    }
+    restoreTokensFromApiClient() {
+        const accessToken = this.authService.getAccessToken();
+        const idToken = this.authService.getIdToken();
+        const refreshToken = this.authService.getRefreshToken();
+        if (accessToken) {
+            this.apiClient.setAccessToken(accessToken);
+        }
+        if (idToken) {
+            this.apiClient.setIdToken(idToken);
+        }
+        if (refreshToken) {
+            this.apiClient.setRefreshToken(refreshToken);
+        }
+    }
+    generateServingIp() {
+        // Generate a mock IP in the 10.x.x.x range
+        const octet1 = 10;
+        const octet2 = Math.floor(Math.random() * 255);
+        const octet3 = Math.floor(Math.random() * 255);
+        const octet4 = Math.floor(Math.random() * 254) + 1; // Avoid .0
+        return `${octet1}.${octet2}.${octet3}.${octet4}`;
+    }
+    async setupApplication(workload, port, protocol = 'http', description, gatewayId) {
+        try {
+            // Attempt auto re-login if tokens are missing but credentials are available
+            await this.authService.attemptAutoRelogin();
+            this.restoreTokensFromApiClient();
+            this.logger.info(`Setting up application for workload: ${workload.name}`);
+            // Get organization ID from config
+            const config = this.configRepository.getConfig();
+            if (!config.organizationId) {
+                throw new Error('No organization ID found. Please login first.');
+            }
+            // Generate a serving IP (in real implementation, this would come from the API)
+            const servingIp = this.generateServingIp();
+            const url = `${protocol}://${servingIp}:${port}`;
+            // Create application via API
+            const deviceIds = [config.deviceId || 'unknown'];
+            const createRequest = {
+                name: `${workload.name}-app`,
+                description: description || `Application for ${workload.name}`,
+                organizationId: config.organizationId,
+                configuration: {
+                    port: port,
+                    protocol: protocol,
+                    url,
+                },
+                deviceIds: deviceIds,
+                gatewayIds: gatewayId ? [gatewayId] : [],
+                subtype: 'local-preexisting',
+            };
+            const response = await this.apiClient.createApplication(createRequest);
+            // Validate API response
+            if (!response || !response.application) {
+                throw new Error('Invalid API response: missing application data');
+            }
+            if (!response.application.id) {
+                throw new Error('Invalid API response: missing application ID');
+            }
+            // Map API response to CLI Application format
+            const application = {
+                id: response.application.id,
+                name: `${workload.name}-app`,
+                workloadId: workload.id,
+                servingIp: servingIp,
+                port: port,
+                protocol: protocol,
+                status: 'active',
+                createdAt: new Date().toISOString(),
+                description: description || `Application for ${workload.name}`,
+            };
+            return application;
+        }
+        catch (error) {
+            this.logger.error('Error setting up application', error);
+            throw error;
+        }
+    }
+    async getApplications() {
+        try {
+            // Attempt auto re-login if tokens are missing but credentials are available
+            await this.authService.attemptAutoRelogin();
+            this.restoreTokensFromApiClient();
+            this.logger.debug('Getting applications');
+            const config = this.configRepository.getConfig();
+            let organizationId;
+            // Check if we have an organization ID in the config (device login)
+            if (config.organizationId) {
+                organizationId = config.organizationId;
+            }
+            else if (config.email) {
+                // User login - get their organizations first
+                this.logger.debug('Getting user organizations');
+                const userOrgs = await this.authService.getUserOrganizations(config.email);
+                // Filter for standard (non-billing) organizations only
+                const standardOrgs = userOrgs.organizations.filter((org) => org.organizationType !== 'billing');
+                if (standardOrgs.length === 0) {
+                    this.logger.warn('No standard organizations found for this user');
+                    return [];
+                }
+                // Use the first standard organization
+                organizationId = standardOrgs[0].organizationId;
+                this.logger.debug(`Using organization: ${standardOrgs[0].name}`);
+            }
+            else {
+                this.logger.warn('No organization ID or email found. Please login first.');
+                return [];
+            }
+            // Call the real API to get organization applications
+            const response = await this.apiClient.getOrganizationApplications(organizationId);
+            // Map API response to CLI Application format
+            const applications = response.applications.map((app) => {
+                // Parse URL/hostname safely
+                let servingIp = 'unknown';
+                let port = 80;
+                let protocol = 'http';
+                if (app.url) {
+                    try {
+                        // Check if it's a full URL or just a hostname
+                        if (app.url.startsWith('http://') || app.url.startsWith('https://')) {
+                            const url = new URL(app.url);
+                            servingIp = url.hostname;
+                            port = parseInt(url.port) || (url.protocol === 'https:' ? 443 : 80);
+                            protocol = url.protocol === 'https:' ? 'https' : 'http';
+                        }
+                        else {
+                            // It's just a hostname
+                            servingIp = app.url;
+                            // Get port and protocol from configuration if available
+                            if (app.configuration?.port) {
+                                port = typeof app.configuration.port === 'number'
+                                    ? app.configuration.port
+                                    : parseInt(String(app.configuration.port)) || 80;
+                            }
+                            if (app.configuration?.protocol) {
+                                const configProtocol = String(app.configuration.protocol).toLowerCase();
+                                if (configProtocol === 'https' || configProtocol === 'http' ||
+                                    configProtocol === 'tcp' || configProtocol === 'udp') {
+                                    protocol = configProtocol;
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        // If URL parsing fails, treat as hostname
+                        servingIp = app.url;
+                        // Get port and protocol from configuration
+                        if (app.configuration?.port) {
+                            port = typeof app.configuration.port === 'number'
+                                ? app.configuration.port
+                                : parseInt(String(app.configuration.port)) || 80;
+                        }
+                        if (app.configuration?.protocol) {
+                            const configProtocol = String(app.configuration.protocol).toLowerCase();
+                            if (configProtocol === 'https' || configProtocol === 'http' ||
+                                configProtocol === 'tcp' || configProtocol === 'udp') {
+                                protocol = configProtocol;
+                            }
+                        }
+                    }
+                }
+                else {
+                    // No URL, try to get from configuration
+                    if (app.configuration?.port) {
+                        port = typeof app.configuration.port === 'number'
+                            ? app.configuration.port
+                            : parseInt(String(app.configuration.port)) || 80;
+                    }
+                    if (app.configuration?.protocol) {
+                        const configProtocol = String(app.configuration.protocol).toLowerCase();
+                        if (configProtocol === 'https' || configProtocol === 'http' ||
+                            configProtocol === 'tcp' || configProtocol === 'udp') {
+                            protocol = configProtocol;
+                        }
+                    }
+                }
+                return {
+                    id: app.id,
+                    name: app.name,
+                    workloadId: app.deviceIds[0] || 'unknown', // Use first device ID as workload ID
+                    servingIp,
+                    port,
+                    protocol,
+                    status: app.status === 'running' ? 'active' : 'inactive',
+                    createdAt: app.createdAt,
+                    description: app.description,
+                };
+            });
+            return applications;
+        }
+        catch (error) {
+            this.logger.error('Error getting applications', error);
+            throw error;
+        }
+    }
+    async getApplication(id) {
+        try {
+            // Try to get from API first
+            try {
+                const response = await this.apiClient.getApplication(id);
+                const appData = response.application;
+                // Extract port and protocol from configuration if needed
+                const port = appData.configuration?.port || 3000;
+                const protocol = (appData.configuration?.protocol || 'http');
+                const workloadId = appData.configuration?.workloadId || '';
+                return {
+                    id: appData.id,
+                    name: appData.name,
+                    description: appData.description || '',
+                    servingIp: this.generateServingIp(),
+                    port: typeof port === 'number' ? port : 3000,
+                    protocol: protocol,
+                    status: appData.status === 'running' ? 'active' : 'inactive',
+                    workloadId: workloadId || undefined,
+                    createdAt: appData.createdAt || new Date().toISOString(),
+                    url: appData.url,
+                };
+            }
+            catch (apiError) {
+                // Fall back to local storage if API fails
+                const application = this.applications.find((app) => app.id === id);
+                if (application) {
+                    return application;
+                }
+                throw new Error(`Application not found: ${id}`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Error getting application', error);
+            throw error;
+        }
+    }
+    async deleteApplication(id) {
+        try {
+            // Attempt auto re-login if tokens are missing but credentials are available
+            await this.authService.attemptAutoRelogin();
+            this.restoreTokensFromApiClient();
+            this.logger.info(`Deleting application: ${id}`);
+            await this.apiClient.deleteApplication(id);
+            this.logger.info('Application deleted successfully', { applicationId: id });
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Error deleting application', error);
+            throw error;
+        }
+    }
+    async createApplicationProgrammatically(params) {
+        try {
+            // Attempt auto re-login if tokens are missing but credentials are available
+            await this.authService.attemptAutoRelogin();
+            this.restoreTokensFromApiClient();
+            const config = this.configRepository.getConfig();
+            if (!config.organizationId) {
+                throw new Error('Not logged in. Please run "edgible login" first.');
+            }
+            const createRequest = {
+                name: params.name,
+                description: params.description,
+                organizationId: config.organizationId,
+                configuration: { port: params.port, protocol: params.protocol },
+                hostnames: params.hostnames,
+                deviceIds: params.deviceIds,
+                gatewayIds: params.gatewayIds,
+                subtype: params.subtype,
+            };
+            // Add useManagedGateway if specified
+            if (params.useManagedGateway !== undefined) {
+                createRequest.useManagedGateway = params.useManagedGateway;
+            }
+            const response = await this.apiClient.createApplication(createRequest);
+            return response.application;
+        }
+        catch (error) {
+            this.logger.error('Failed to create application', error);
+            throw new Error(`Failed to create application: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}
+exports.ApplicationServiceImpl = ApplicationServiceImpl;
+//# sourceMappingURL=ApplicationService.js.map

package/dist/services/auth/AuthService.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * Authentication service
+ * Handles user and device authentication operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthServiceImpl = void 0;
+const client_1 = require("../../client");
+const passwordValidation_1 = require("../../utils/passwordValidation");
+class AuthServiceImpl {
+    constructor(baseUrl, configRepository, logger) {
+        this.baseUrl = baseUrl;
+        this.configRepository = configRepository;
+        this.logger = logger;
+        this.apiClient = (0, client_1.createApiClient)(baseUrl);
+        this.restoreTokensFromConfig();
+    }
+    restoreTokensFromConfig() {
+        const config = this.configRepository.getConfig();
+        if (config.accessToken) {
+            this.apiClient.setAccessToken(config.accessToken);
+        }
+        if (config.idToken) {
+            this.apiClient.setIdToken(config.idToken);
+        }
+        if (config.refreshToken) {
+            this.apiClient.setRefreshToken(config.refreshToken);
+        }
+        this.logger.debug('Token restoration', {
+            hasAccessToken: !!config.accessToken,
+            hasIdToken: !!config.idToken,
+            hasRefreshToken: !!config.refreshToken,
+            organizationId: config.organizationId,
+            deviceId: config.deviceId,
+        });
+    }
+    async attemptAutoRelogin() {
+        const config = this.configRepository.getConfig();
+        // If no tokens but we have device credentials, attempt automatic re-login
+        if (!config.idToken && !config.accessToken && config.deviceId && config.devicePassword) {
+            this.logger.debug('No tokens available, attempting automatic device re-login');
+            try {
+                await this.loginDevice(config.deviceId, config.devicePassword);
+                this.logger.debug('Automatic re-login successful');
+                return true;
+            }
+            catch (error) {
+                this.logger.warn('Automatic re-login failed', error instanceof Error ? error.message : String(error));
+                return false;
+            }
+        }
+        return false;
+    }
+    saveTokensToConfig() {
+        const accessToken = this.apiClient.getAccessToken();
+        const idToken = this.apiClient.getIdToken();
+        const refreshToken = this.apiClient.getRefreshToken();
+        this.logger.debug('Saving tokens', {
+            hasAccessToken: !!accessToken,
+            hasIdToken: !!idToken,
+            hasRefreshToken: !!refreshToken,
+        });
+        this.configRepository.updateConfig({
+            accessToken,
+            idToken,
+            refreshToken,
+        });
+    }
+    async loginUser(email, password) {
+        try {
+            const loginRequest = { email, password };
+            const response = await this.apiClient.login(loginRequest);
+            this.saveTokensToConfig();
+            return response;
+        }
+        catch (error) {
+            this.logger.error('Error logging in user', error);
+            throw error;
+        }
+    }
+    async createDeviceWithOrganization(deviceName, password, userEmail) {
+        try {
+            // Validate password meets Cognito requirements
+            const passwordValidation = (0, passwordValidation_1.validateCognitoPassword)(password);
+            if (!passwordValidation.isValid) {
+                throw new Error(`Password validation failed: ${passwordValidation.errors.join(', ')}`);
+            }
+            const request = {
+                name: deviceName,
+                description: `CLI device: ${deviceName}`,
+                type: 'laptop',
+                organizationName: `${deviceName} Organization`,
+                organizationDescription: `Organization created for device ${deviceName}`,
+                userEmail: userEmail,
+                password: password,
+            };
+            const response = await this.apiClient.createDeviceWithOrphanedOrganization(request);
+            return response;
+        }
+        catch (error) {
+            this.logger.error('Error creating device with organization', error);
+            throw error;
+        }
+    }
+    async checkAccount(email) {
+        try {
+            // Clear any existing tokens before checking account
+            this.apiClient.clearTokens();
+            try {
+                await this.apiClient.login({ email, password: 'dummy' });
+                this.apiClient.clearTokens();
+                return true;
+            }
+            catch (error) {
+                this.apiClient.clearTokens();
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('UserNotFoundException') || errorMessage.includes('NotAuthorizedException')) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        catch (error) {
+            this.apiClient.clearTokens();
+            this.logger.error('Error checking account', error);
+            return false;
+        }
+    }
+    async loginDevice(deviceId, password) {
+        try {
+            const loginRequest = { email: deviceId, password };
+            const response = await this.apiClient.login(loginRequest);
+            this.saveTokensToConfig();
+            return response;
+        }
+        catch (error) {
+            this.logger.error('Error logging in device', error);
+            throw error;
+        }
+    }
+    async verifyDeviceCredentials(deviceId, password) {
+        try {
+            // Save current user tokens to restore later
+            const currentAccessToken = this.apiClient.getAccessToken();
+            const currentIdToken = this.apiClient.getIdToken();
+            const currentRefreshToken = this.apiClient.getRefreshToken();
+            // Create a temporary API client for verification
+            const tempApiClient = (0, client_1.createApiClient)(this.baseUrl);
+            const loginRequest = { email: deviceId, password };
+            try {
+                await tempApiClient.login(loginRequest);
+                // Restore user tokens
+                if (currentAccessToken) {
+                    this.apiClient.setAccessToken(currentAccessToken);
+                }
+                if (currentIdToken) {
+                    this.apiClient.setIdToken(currentIdToken);
+                }
+                if (currentRefreshToken) {
+                    this.apiClient.setRefreshToken(currentRefreshToken);
+                }
+                return true;
+            }
+            catch (error) {
+                // Verification failed, but restore user tokens anyway
+                if (currentAccessToken) {
+                    this.apiClient.setAccessToken(currentAccessToken);
+                }
+                if (currentIdToken) {
+                    this.apiClient.setIdToken(currentIdToken);
+                }
+                if (currentRefreshToken) {
+                    this.apiClient.setRefreshToken(currentRefreshToken);
+                }
+                return false;
+            }
+        }
+        catch (error) {
+            this.logger.error('Error verifying device credentials', error);
+            return false;
+        }
+    }
+    async refreshToken(refreshToken) {
+        try {
+            const response = await this.apiClient.refreshToken({ refreshToken });
+            this.saveTokensToConfig();
+            return response;
+        }
+        catch (error) {
+            this.logger.error('Error refreshing token', error);
+            throw error;
+        }
+    }
+    getAccessToken() {
+        return this.apiClient.getAccessToken();
+    }
+    getIdToken() {
+        return this.apiClient.getIdToken();
+    }
+    getRefreshToken() {
+        return this.apiClient.getRefreshToken();
+    }
+    async getUserOrganizations(email) {
+        try {
+            return await this.apiClient.getUserOrganizations(email);
+        }
+        catch (error) {
+            this.logger.error('Error getting user organizations', error);
+            throw error;
+        }
+    }
+}
+exports.AuthServiceImpl = AuthServiceImpl;
+//# sourceMappingURL=AuthService.js.map