@edgible-team/cli 1.2.13 → 1.2.17

package/dist/services/stack/GatewayResolver.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Gateway Resolver Service
+ * Resolves gateway requirements for published applications
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayResolver = void 0;
+const stack_errors_1 = require("../../utils/stack-errors");
+class GatewayResolver {
+    constructor(apiClient, organizationId, logger) {
+        this.apiClient = apiClient;
+        this.organizationId = organizationId;
+        this.logger = logger;
+        this.gatewayCache = null;
+        this.cacheTimestamp = null;
+        this.CACHE_TTL_MS = 60000; // 1 minute cache
+    }
+    /**
+     * Resolve gateway requirements for applications
+     * For published apps, finds or suggests managed gateways
+     * @param applications List of applications to resolve gateways for
+     * @param autoCreate If true, will create gateways automatically (requires confirmation in caller)
+     * @returns Map of appName -> gatewayIds
+     */
+    async resolveGateways(applications, autoCreate = false) {
+        const result = new Map();
+        const publishedApps = applications.filter(app => app.published);
+        if (publishedApps.length === 0) {
+            this.logger.debug('No published applications, skipping gateway resolution');
+            return result;
+        }
+        this.logger.debug(`Resolving gateways for ${publishedApps.length} published applications`);
+        // Get available managed gateways
+        const managedGateways = await this.listManagedGateways();
+        if (managedGateways.length === 0 && !autoCreate) {
+            throw new stack_errors_1.GatewayProvisioningError(publishedApps[0].name, 'No managed gateways available and auto-create is disabled');
+        }
+        // For MVP: use the first available managed gateway for all published apps
+        // Future: implement proper gateway selection based on region, capacity, etc.
+        if (managedGateways.length > 0) {
+            const gateway = managedGateways[0];
+            this.logger.debug(`Using existing managed gateway: ${gateway.id} (${gateway.name})`);
+            for (const app of publishedApps) {
+                result.set(app.name, [gateway.id]);
+            }
+        }
+        else {
+            // No gateways available and autoCreate is true
+            // The caller (StackService) should handle gateway creation with user confirmation
+            this.logger.warn('No managed gateways available. Gateway creation required.');
+            for (const app of publishedApps) {
+                result.set(app.name, []); // Empty array signals gateway creation needed
+            }
+        }
+        return result;
+    }
+    /**
+     * Resolve gateway for a single application
+     * @param appName Application name
+     * @param published Whether the app should be published
+     * @returns Array of gateway IDs (empty if not published)
+     */
+    async resolveGateway(appName, published) {
+        if (!published) {
+            return [];
+        }
+        const managedGateways = await this.listManagedGateways();
+        if (managedGateways.length === 0) {
+            throw new stack_errors_1.GatewayProvisioningError(appName, 'No managed gateways available');
+        }
+        // Use the first available managed gateway
+        const gateway = managedGateways[0];
+        this.logger.debug(`Resolved gateway for '${appName}': ${gateway.id}`);
+        return [gateway.id];
+    }
+    /**
+     * List all managed gateways (with caching)
+     * @returns Array of managed gateway info
+     */
+    async listManagedGateways() {
+        const now = Date.now();
+        // Return cached gateways if still valid
+        if (this.gatewayCache !== null &&
+            this.cacheTimestamp !== null &&
+            now - this.cacheTimestamp < this.CACHE_TTL_MS) {
+            this.logger.debug('Using cached gateway list');
+            return this.gatewayCache;
+        }
+        // Fetch gateways from API
+        this.logger.debug('Fetching managed gateways');
+        try {
+            const response = await this.apiClient.listManagedGateways();
+            // Transform API response to our format
+            // Note: The actual response structure may vary based on API implementation
+            const gateways = (response.gateways || response.managedGateways || []).map((gw) => ({
+                id: gw.id || gw.gatewayId,
+                name: gw.name || gw.gatewayName || 'Unnamed Gateway',
+                region: gw.region || 'unknown',
+                status: gw.status || 'unknown',
+                applicationsCount: gw.applicationsCount || gw.applications?.length || 0,
+            }));
+            // Filter to only active gateways
+            const activeGateways = gateways.filter(gw => gw.status === 'active' || gw.status === 'running' || gw.status === 'online');
+            // Update cache
+            this.gatewayCache = activeGateways;
+            this.cacheTimestamp = now;
+            this.logger.debug(`Fetched ${activeGateways.length} active managed gateways`);
+            return activeGateways;
+        }
+        catch (error) {
+            this.logger.error(`Failed to fetch managed gateways: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            // If listing fails, it might be an API permission issue or no gateways exist
+            // Return empty array instead of throwing to allow graceful handling
+            return [];
+        }
+    }
+    /**
+     * Check if gateway creation is needed
+     * @param applications List of applications
+     * @returns True if any published app needs a gateway but none available
+     */
+    async needsGatewayCreation(applications) {
+        const hasPublishedApps = applications.some(app => app.published);
+        if (!hasPublishedApps) {
+            return false;
+        }
+        const managedGateways = await this.listManagedGateways();
+        return managedGateways.length === 0;
+    }
+    /**
+     * Select best gateway for an application
+     * Future enhancement: implement intelligent selection based on:
+     * - Region proximity to device
+     * - Current capacity/load
+     * - Application count
+     * - Performance metrics
+     *
+     * @param appName Application name
+     * @param deviceRegion Region where device is located
+     * @returns Gateway ID or null if none suitable
+     */
+    async selectBestGateway(appName, deviceRegion) {
+        const gateways = await this.listManagedGateways();
+        if (gateways.length === 0) {
+            return null;
+        }
+        // For MVP: just return the first gateway
+        // Future: implement smart selection logic
+        return gateways[0].id;
+    }
+    /**
+     * Clear the gateway cache (useful for testing or forcing refresh)
+     */
+    clearCache() {
+        this.gatewayCache = null;
+        this.cacheTimestamp = null;
+        this.logger.debug('Gateway cache cleared');
+    }
+    /**
+     * Get gateway details
+     * @param gatewayId Gateway ID
+     * @returns Gateway info or null if not found
+     */
+    async getGateway(gatewayId) {
+        const gateways = await this.listManagedGateways();
+        return gateways.find(gw => gw.id === gatewayId) || null;
+    }
+    /**
+     * Check if a gateway exists and is available
+     * @param gatewayId Gateway ID
+     * @returns True if gateway exists and is active
+     */
+    async gatewayAvailable(gatewayId) {
+        const gateway = await this.getGateway(gatewayId);
+        return gateway !== null;
+    }
+}
+exports.GatewayResolver = GatewayResolver;
+//# sourceMappingURL=GatewayResolver.js.map

package/dist/services/stack/StackParser.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Stack Parser Service
+ * Parses and validates application stack YAML files
+ */
+import { Logger } from '../../utils/logger';
+import { ApplicationStack, StackValidationResult } from '../../types/stack';
+export declare class StackParser {
+    private logger;
+    constructor(logger: Logger);
+    /**
+     * Parse a stack file from disk
+     * @param filePath Path to the stack YAML file
+     * @returns Parsed and validated ApplicationStack
+     */
+    parseFile(filePath: string): Promise<ApplicationStack>;
+    /**
+     * Substitute environment variables in content
+     * Supports ${VAR} and ${VAR:-default} syntax
+     * @param content File content with env var placeholders
+     * @param filePath Path to the stack file (for finding .env)
+     * @returns Content with substituted variables
+     */
+    private substituteEnvVars;
+    /**
+     * Parse .env file and set environment variables
+     * Does not overwrite existing environment variables
+     * @param content .env file content
+     */
+    private parseEnvFile;
+    /**
+     * Validate a stack file without fully parsing
+     * Returns validation result with errors and warnings
+     * @param filePath Path to the stack YAML file
+     * @returns Validation result
+     */
+    validate(filePath: string): Promise<StackValidationResult>;
+}
+//# sourceMappingURL=StackParser.d.ts.map

package/dist/services/stack/StackParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StackParser.d.ts","sourceRoot":"","sources":["../../../src/services/stack/StackParser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAS5E,qBAAa,WAAW;IACV,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;OAIG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA4D5D;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IA6BzB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IA2BpB;;;;;OAKG;IACG,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAoEjE"}

package/dist/services/stack/StackParser.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Stack Parser Service
+ * Parses and validates application stack YAML files
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackParser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const stack_schemas_1 = require("../../validation/stack-schemas");
+const stack_errors_1 = require("../../utils/stack-errors");
+class StackParser {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Parse a stack file from disk
+     * @param filePath Path to the stack YAML file
+     * @returns Parsed and validated ApplicationStack
+     */
+    async parseFile(filePath) {
+        this.logger.debug(`Parsing stack file: ${filePath}`);
+        // Resolve to absolute path
+        const absolutePath = path.resolve(filePath);
+        // Check if file exists
+        if (!fs.existsSync(absolutePath)) {
+            throw new stack_errors_1.StackFileNotFoundError(absolutePath);
+        }
+        // Read file content
+        let content;
+        try {
+            content = fs.readFileSync(absolutePath, 'utf-8');
+        }
+        catch (error) {
+            throw new stack_errors_1.StackParseError(`Failed to read stack file: ${error instanceof Error ? error.message : 'Unknown error'}`, absolutePath);
+        }
+        // Substitute environment variables
+        content = this.substituteEnvVars(content, absolutePath);
+        // Parse YAML
+        let rawStack;
+        try {
+            rawStack = yaml.load(content);
+        }
+        catch (error) {
+            const yamlError = error;
+            throw new stack_errors_1.StackParseError(`Invalid YAML: ${yamlError.message || 'Syntax error'}`, absolutePath, yamlError.mark?.line);
+        }
+        // Check if YAML is empty or null
+        if (!rawStack || typeof rawStack !== 'object') {
+            throw new stack_errors_1.StackParseError('Stack file is empty or invalid', absolutePath);
+        }
+        // Validate schema
+        const result = stack_schemas_1.applicationStackSchema.safeParse(rawStack);
+        if (!result.success) {
+            const errors = result.error.errors.map((err) => ({
+                path: err.path.join('.'),
+                message: err.message,
+            }));
+            throw new stack_errors_1.StackValidationError('Stack validation failed', errors);
+        }
+        this.logger.debug(`Successfully parsed stack: ${result.data.metadata.name}`);
+        return result.data;
+    }
+    /**
+     * Substitute environment variables in content
+     * Supports ${VAR} and ${VAR:-default} syntax
+     * @param content File content with env var placeholders
+     * @param filePath Path to the stack file (for finding .env)
+     * @returns Content with substituted variables
+     */
+    substituteEnvVars(content, filePath) {
+        // Load .env file if it exists in the same directory
+        const envFilePath = path.join(path.dirname(filePath), '.env');
+        if (fs.existsSync(envFilePath)) {
+            this.logger.debug(`Loading environment variables from ${envFilePath}`);
+            try {
+                const envContent = fs.readFileSync(envFilePath, 'utf-8');
+                this.parseEnvFile(envContent);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to load .env file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        // Replace ${VAR:-default} and ${VAR}
+        return content.replace(/\$\{([^}:]+)(?::-(.*?))?\}/g, (match, varName, defaultValue) => {
+            const value = process.env[varName];
+            if (value !== undefined) {
+                return value;
+            }
+            if (defaultValue !== undefined) {
+                return defaultValue;
+            }
+            throw new stack_errors_1.EnvironmentVariableError(varName);
+        });
+    }
+    /**
+     * Parse .env file and set environment variables
+     * Does not overwrite existing environment variables
+     * @param content .env file content
+     */
+    parseEnvFile(content) {
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip empty lines and comments
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            // Parse KEY=VALUE
+            const match = trimmed.match(/^([^=]+)=(.*)$/);
+            if (match) {
+                const key = match[1].trim();
+                const value = match[2].trim();
+                // Remove quotes if present
+                const unquoted = value.replace(/^["'](.*)["']$/, '$1');
+                // Only set if not already set
+                if (process.env[key] === undefined) {
+                    process.env[key] = unquoted;
+                }
+            }
+        }
+    }
+    /**
+     * Validate a stack file without fully parsing
+     * Returns validation result with errors and warnings
+     * @param filePath Path to the stack YAML file
+     * @returns Validation result
+     */
+    async validate(filePath) {
+        const errors = [];
+        const warnings = [];
+        try {
+            await this.parseFile(filePath);
+        }
+        catch (error) {
+            if (error instanceof stack_errors_1.StackValidationError) {
+                errors.push(...error.errors);
+            }
+            else if (error instanceof stack_errors_1.StackParseError) {
+                errors.push({
+                    path: 'file',
+                    message: error.message,
+                    line: error.line,
+                });
+            }
+            else if (error instanceof stack_errors_1.StackFileNotFoundError) {
+                errors.push({
+                    path: 'file',
+                    message: error.message,
+                });
+            }
+            else if (error instanceof stack_errors_1.EnvironmentVariableError) {
+                errors.push({
+                    path: 'environment',
+                    message: error.message,
+                });
+            }
+            else {
+                errors.push({
+                    path: 'unknown',
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                });
+            }
+        }
+        // Add warnings for best practices
+        if (errors.length === 0) {
+            try {
+                const stack = await this.parseFile(filePath);
+                // Warn if no dependencies specified but multiple apps
+                if (stack.applications.length > 1) {
+                    const hasAnyDependencies = stack.applications.some(app => app.dependsOn && app.dependsOn.length > 0);
+                    if (!hasAnyDependencies) {
+                        warnings.push({
+                            path: 'applications',
+                            message: 'No dependencies specified. Applications will be deployed in file order.',
+                        });
+                    }
+                }
+                // Warn if all applications are unpublished
+                const allUnpublished = stack.applications.every(app => !app.published);
+                if (allUnpublished) {
+                    warnings.push({
+                        path: 'applications',
+                        message: 'All applications are unpublished. They will not be accessible via public URLs.',
+                    });
+                }
+            }
+            catch (error) {
+                // Ignore errors during warning checks
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+}
+exports.StackParser = StackParser;
+//# sourceMappingURL=StackParser.js.map

package/dist/services/stack/StackService.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Stack Service
+ * Main orchestration service for application stack operations
+ */
+import { Logger } from '../../utils/logger';
+import { ApiClient } from '../../client';
+import { ApplicationService } from '../application/ApplicationService';
+import { StackValidationResult, DeployOptions, DeployResult, TeardownOptions, TeardownResult, StackStatus, StackDiff } from '../../types/stack';
+export declare class StackService {
+    private apiClient;
+    private applicationService;
+    private organizationId;
+    private logger;
+    private parser;
+    private deviceResolver;
+    private gatewayResolver;
+    private dependencyManager;
+    constructor(apiClient: ApiClient, applicationService: ApplicationService, organizationId: string, logger: Logger);
+    /**
+     * Validate a stack file
+     * @param filePath Path to stack file
+     * @returns Validation result
+     */
+    validateStack(filePath: string): Promise<StackValidationResult>;
+    /**
+     * Deploy a stack
+     * @param options Deploy options
+     * @returns Deploy result
+     */
+    deployStack(options: DeployOptions): Promise<DeployResult>;
+    /**
+     * Teardown a stack
+     * @param options Teardown options
+     * @returns Teardown result
+     */
+    teardownStack(options: TeardownOptions): Promise<TeardownResult>;
+    /**
+     * Get status of applications in a stack
+     * @param filePath Path to stack file
+     * @returns Stack status
+     */
+    getStackStatus(filePath: string): Promise<StackStatus>;
+    /**
+     * Get diff between stack definition and deployed state
+     * @param filePath Path to stack file
+     * @returns Stack diff
+     */
+    diffStack(filePath: string): Promise<StackDiff>;
+    /**
+     * Resolve stack: resolve device names and gateways
+     * @param stack Application stack
+     * @param applications Applications to resolve (filtered subset)
+     * @returns Resolved stack
+     */
+    private resolveStack;
+    /**
+     * Deploy a single application
+     * @param app Application to deploy
+     * @param resolved Resolved stack information
+     * @returns Deployed application info
+     */
+    private deployApplication;
+    /**
+     * Get deployed applications matching stack apps
+     * @param applications Stack applications to check
+     * @returns Array of application statuses
+     */
+    private getDeployedApplications;
+    /**
+     * Encode docker-compose file to base64
+     * @param composeFilePath Path to docker-compose file (relative to stack file or absolute)
+     * @returns Base64-prefixed compose content ready for API submission
+     */
+    private encodeDockerComposeFile;
+}
+//# sourceMappingURL=StackService.d.ts.map

package/dist/services/stack/StackService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StackService.d.ts","sourceRoot":"","sources":["../../../src/services/stack/StackService.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAKvE,OAAO,EAKL,qBAAqB,EACrB,aAAa,EACb,YAAY,EACZ,eAAe,EACf,cAAc,EACd,WAAW,EAEX,SAAS,EAGV,MAAM,mBAAmB,CAAC;AAO3B,qBAAa,YAAY;IAOrB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,MAAM;IAThB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,iBAAiB,CAAyB;gBAGxC,SAAS,EAAE,SAAS,EACpB,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM;IAQxB;;;;OAIG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAgCrE;;;;OAIG;IACG,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAoGhE;;;;OAIG;IACG,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAuEtE;;;;OAIG;IACG,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAY5D;;;;OAIG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IA0CrD;;;;;OAKG;YACW,YAAY;IA4B1B;;;;;OAKG;YACW,iBAAiB;IAiF/B;;;;OAIG;YACW,uBAAuB;IAyCrC;;;;OAIG;YACW,uBAAuB;CA4BtC"}