@edgible-team/cli 1.2.13 → 1.2.15

package/dist/services/stack/StackService.js

@@ -0,0 +1,476 @@
+"use strict";
+/**
+ * Stack Service
+ * Main orchestration service for application stack operations
+ */
+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.StackService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const StackParser_1 = require("./StackParser");
+const DeviceResolver_1 = require("./DeviceResolver");
+const GatewayResolver_1 = require("./GatewayResolver");
+const DependencyGraphManager_1 = require("./DependencyGraphManager");
+const stack_errors_1 = require("../../utils/stack-errors");
+class StackService {
+    constructor(apiClient, applicationService, organizationId, logger) {
+        this.apiClient = apiClient;
+        this.applicationService = applicationService;
+        this.organizationId = organizationId;
+        this.logger = logger;
+        this.parser = new StackParser_1.StackParser(logger);
+        this.deviceResolver = new DeviceResolver_1.DeviceResolver(apiClient, organizationId, logger);
+        this.gatewayResolver = new GatewayResolver_1.GatewayResolver(apiClient, organizationId, logger);
+        this.dependencyManager = new DependencyGraphManager_1.DependencyGraphManager(logger);
+    }
+    /**
+     * Validate a stack file
+     * @param filePath Path to stack file
+     * @returns Validation result
+     */
+    async validateStack(filePath) {
+        this.logger.info('Validating stack file...');
+        try {
+            const result = await this.parser.validate(filePath);
+            if (result.valid) {
+                // Additional validation: check dependency graph
+                const stack = await this.parser.parseFile(filePath);
+                this.dependencyManager.validate(stack.applications);
+                // Check device names exist (optional, might be slow)
+                // Commented out for now to keep validation fast
+                // for (const app of stack.applications) {
+                //   await this.deviceResolver.resolveDevice(app.deviceName);
+                // }
+            }
+            return result;
+        }
+        catch (error) {
+            // Convert any thrown errors to validation errors
+            return {
+                valid: false,
+                errors: [{
+                        path: 'stack',
+                        message: error instanceof Error ? error.message : 'Unknown validation error',
+                    }],
+                warnings: [],
+            };
+        }
+    }
+    /**
+     * Deploy a stack
+     * @param options Deploy options
+     * @returns Deploy result
+     */
+    async deployStack(options) {
+        this.logger.info(`Deploying stack from: ${options.file}`);
+        const deployed = [];
+        const failed = [];
+        const skipped = [];
+        try {
+            // Parse and validate stack
+            const stack = await this.parser.parseFile(options.file);
+            this.logger.info(`Stack: ${stack.metadata.name} - ${stack.applications.length} applications`);
+            // Filter to single app if specified
+            let applicationsToDeploy = options.app
+                ? stack.applications.filter(app => app.name === options.app)
+                : stack.applications;
+            if (options.app && applicationsToDeploy.length === 0) {
+                throw new Error(`Application '${options.app}' not found in stack`);
+            }
+            // Validate dependency graph
+            this.dependencyManager.validate(applicationsToDeploy);
+            // Get deployment order
+            const deploymentOrder = this.dependencyManager.getDeploymentOrder(applicationsToDeploy);
+            this.logger.info(`Deployment order: ${deploymentOrder.join(' -> ')}`);
+            if (options.dryRun) {
+                this.logger.info('[DRY RUN] Would deploy applications in this order:');
+                for (const appName of deploymentOrder) {
+                    const app = applicationsToDeploy.find(a => a.name === appName);
+                    this.logger.info(`  - ${appName} (${app.subtype}) on ${app.deviceName}`);
+                }
+                return {
+                    success: true,
+                    deployed: [],
+                    failed: [],
+                    skipped: deploymentOrder,
+                };
+            }
+            // Resolve devices and gateways
+            const resolved = await this.resolveStack(stack, applicationsToDeploy);
+            // Deploy applications in order
+            const deployedSet = new Set();
+            for (const appName of deploymentOrder) {
+                const app = applicationsToDeploy.find(a => a.name === appName);
+                // Check if dependencies deployed
+                if (!options.skipDependencies && app.dependsOn) {
+                    const missingDeps = app.dependsOn.filter(dep => !deployedSet.has(dep));
+                    if (missingDeps.length > 0) {
+                        failed.push({
+                            name: appName,
+                            error: `Missing dependencies: ${missingDeps.join(', ')}`,
+                        });
+                        continue;
+                    }
+                }
+                try {
+                    this.logger.info(`Deploying application: ${appName}`);
+                    const result = await this.deployApplication(app, resolved);
+                    deployed.push(result);
+                    deployedSet.add(appName);
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                    this.logger.error(`Failed to deploy ${appName}: ${errorMsg}`);
+                    failed.push({
+                        name: appName,
+                        error: errorMsg,
+                    });
+                    // Stop deployment on first failure (fail-fast)
+                    if (!options.force) {
+                        break;
+                    }
+                }
+            }
+            const success = failed.length === 0;
+            this.logger.info(`Deployment ${success ? 'completed successfully' : 'completed with errors'}`);
+            this.logger.info(`  Deployed: ${deployed.length}`);
+            this.logger.info(`  Failed: ${failed.length}`);
+            return {
+                success,
+                deployed,
+                failed,
+                skipped,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Stack deployment failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error;
+        }
+    }
+    /**
+     * Teardown a stack
+     * @param options Teardown options
+     * @returns Teardown result
+     */
+    async teardownStack(options) {
+        this.logger.info(`Tearing down stack from: ${options.file}`);
+        const removed = [];
+        const failed = [];
+        const skipped = [];
+        try {
+            // Parse stack
+            const stack = await this.parser.parseFile(options.file);
+            // Filter to single app if specified
+            let applicationsToRemove = options.app
+                ? stack.applications.filter(app => app.name === options.app)
+                : stack.applications;
+            if (options.app && applicationsToRemove.length === 0) {
+                throw new Error(`Application '${options.app}' not found in stack`);
+            }
+            // Get teardown order (reverse of deployment)
+            const teardownOrder = this.dependencyManager.getTeardownOrder(applicationsToRemove);
+            this.logger.info(`Teardown order: ${teardownOrder.join(' -> ')}`);
+            // Get deployed applications
+            const deployedApps = await this.getDeployedApplications(applicationsToRemove);
+            // Remove applications in order
+            for (const appName of teardownOrder) {
+                const deployedApp = deployedApps.find(app => app.name === appName);
+                if (!deployedApp || !deployedApp.applicationId) {
+                    this.logger.debug(`Application ${appName} not deployed, skipping`);
+                    skipped.push(appName);
+                    continue;
+                }
+                try {
+                    this.logger.info(`Removing application: ${appName}`);
+                    await this.applicationService.deleteApplication(deployedApp.applicationId);
+                    removed.push(appName);
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                    this.logger.error(`Failed to remove ${appName}: ${errorMsg}`);
+                    failed.push({
+                        name: appName,
+                        error: errorMsg,
+                    });
+                    // Continue even on failure (best effort teardown)
+                }
+            }
+            const success = failed.length === 0;
+            this.logger.info(`Teardown ${success ? 'completed successfully' : 'completed with errors'}`);
+            this.logger.info(`  Removed: ${removed.length}`);
+            this.logger.info(`  Failed: ${failed.length}`);
+            this.logger.info(`  Skipped: ${skipped.length}`);
+            return {
+                success,
+                removed,
+                failed,
+                skipped,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Stack teardown failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error;
+        }
+    }
+    /**
+     * Get status of applications in a stack
+     * @param filePath Path to stack file
+     * @returns Stack status
+     */
+    async getStackStatus(filePath) {
+        this.logger.info('Getting stack status...');
+        const stack = await this.parser.parseFile(filePath);
+        const applicationStatuses = await this.getDeployedApplications(stack.applications);
+        return {
+            stackName: stack.metadata.name,
+            applications: applicationStatuses,
+        };
+    }
+    /**
+     * Get diff between stack definition and deployed state
+     * @param filePath Path to stack file
+     * @returns Stack diff
+     */
+    async diffStack(filePath) {
+        this.logger.info('Computing stack diff...');
+        const stack = await this.parser.parseFile(filePath);
+        const deployed = await this.getDeployedApplications(stack.applications);
+        const toCreate = [];
+        const toUpdate = [];
+        const toDelete = [];
+        const unchanged = [];
+        // Check each application in the stack
+        for (const app of stack.applications) {
+            const deployedApp = deployed.find(d => d.name === app.name);
+            if (!deployedApp || deployedApp.status === 'not-deployed') {
+                toCreate.push(app);
+            }
+            else {
+                // For MVP, consider as unchanged if deployed
+                // Future: implement proper field-by-field comparison
+                unchanged.push(app.name);
+            }
+        }
+        // Check for deployed apps not in stack (to delete)
+        for (const deployedApp of deployed) {
+            if (deployedApp.status === 'deployed') {
+                const inStack = stack.applications.find(a => a.name === deployedApp.name);
+                if (!inStack) {
+                    toDelete.push(deployedApp);
+                }
+            }
+        }
+        return {
+            toCreate,
+            toUpdate,
+            toDelete,
+            unchanged,
+        };
+    }
+    /**
+     * Resolve stack: resolve device names and gateways
+     * @param stack Application stack
+     * @param applications Applications to resolve (filtered subset)
+     * @returns Resolved stack
+     */
+    async resolveStack(stack, applications) {
+        this.logger.info('Resolving devices and gateways...');
+        // Get unique device names
+        const deviceNames = [...new Set(applications.map(app => app.deviceName))];
+        // Resolve devices
+        const devices = await this.deviceResolver.resolveDevices(deviceNames);
+        this.logger.info(`Resolved ${devices.size} devices`);
+        // Resolve gateways
+        const gateways = await this.gatewayResolver.resolveGateways(applications);
+        this.logger.info(`Resolved gateways for ${gateways.size} published applications`);
+        return {
+            ...stack,
+            applications: stack.applications,
+            resolved: {
+                devices,
+                gateways,
+                applications: new Map(),
+            },
+        };
+    }
+    /**
+     * Deploy a single application
+     * @param app Application to deploy
+     * @param resolved Resolved stack information
+     * @returns Deployed application info
+     */
+    async deployApplication(app, resolved) {
+        const deviceId = resolved.resolved.devices.get(app.deviceName);
+        if (!deviceId) {
+            throw new stack_errors_1.ApplicationDeploymentError(app.name, `Device '${app.deviceName}' not found`);
+        }
+        const gatewayIds = resolved.resolved.gateways.get(app.name) || [];
+        // Map subtype to ApplicationService format
+        let serviceSubtype;
+        switch (app.subtype) {
+            case 'existing':
+                serviceSubtype = 'local-preexisting';
+                break;
+            case 'docker-compose':
+                serviceSubtype = 'docker-compose';
+                break;
+            case 'managed-process':
+                serviceSubtype = 'managed-process';
+                break;
+            default:
+                throw new stack_errors_1.ApplicationDeploymentError(app.name, `Unsupported subtype: ${app.subtype}`);
+        }
+        // Build configuration based on subtype
+        const configuration = {};
+        if (app.subtype === 'docker-compose' && app.composeFile) {
+            // Read and encode docker-compose file to base64
+            const dockerComposePath = await this.encodeDockerComposeFile(app.composeFile);
+            configuration.dockerComposePath = dockerComposePath;
+            // Also set environment variables if provided
+            if (app.environment) {
+                configuration.env = app.environment;
+            }
+        }
+        else if (app.subtype === 'managed-process') {
+            if (app.command)
+                configuration.command = app.command;
+            if (app.workingDir)
+                configuration.workingDir = app.workingDir;
+            if (app.environment)
+                configuration.environment = app.environment;
+            if (app.logFile)
+                configuration.logFile = app.logFile;
+        }
+        try {
+            const result = await this.applicationService.createApplicationProgrammatically({
+                name: app.name,
+                description: app.description || '',
+                port: app.port,
+                protocol: app.protocol,
+                hostnames: app.hostnames,
+                deviceIds: [deviceId],
+                gatewayIds: gatewayIds.length > 0 ? gatewayIds : undefined,
+                useManagedGateway: app.published,
+                subtype: serviceSubtype,
+                configuration,
+                authModes: app.authModes,
+                allowedOrganizations: app.allowedOrganizations,
+            });
+            return {
+                name: app.name,
+                applicationId: result.applicationId || result.id || 'unknown',
+                urls: result.urls || [],
+            };
+        }
+        catch (error) {
+            throw new stack_errors_1.ApplicationDeploymentError(app.name, error instanceof Error ? error.message : 'Unknown error', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get deployed applications matching stack apps
+     * @param applications Stack applications to check
+     * @returns Array of application statuses
+     */
+    async getDeployedApplications(applications) {
+        try {
+            // Get all applications in the organization
+            const allApps = await this.applicationService.getApplications();
+            // Match by name
+            return applications.map(stackApp => {
+                const deployedApp = allApps.find((app) => app.name === stackApp.name);
+                if (deployedApp) {
+                    return {
+                        name: stackApp.name,
+                        status: 'deployed',
+                        applicationId: deployedApp.id,
+                        deviceName: stackApp.deviceName,
+                        published: stackApp.published || false,
+                        urls: deployedApp.urls || [],
+                    };
+                }
+                else {
+                    return {
+                        name: stackApp.name,
+                        status: 'not-deployed',
+                        deviceName: stackApp.deviceName,
+                        published: stackApp.published || false,
+                    };
+                }
+            });
+        }
+        catch (error) {
+            this.logger.error(`Failed to get deployed applications: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            // Return all as not-deployed on error
+            return applications.map(app => ({
+                name: app.name,
+                status: 'not-deployed',
+                deviceName: app.deviceName,
+                published: app.published || false,
+            }));
+        }
+    }
+    /**
+     * 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
+     */
+    async encodeDockerComposeFile(composeFilePath) {
+        try {
+            // Resolve path (could be absolute or relative)
+            const resolvedPath = path.isAbsolute(composeFilePath)
+                ? composeFilePath
+                : path.resolve(process.cwd(), composeFilePath);
+            this.logger.debug(`Reading docker-compose file: ${resolvedPath}`);
+            // Check if file exists
+            if (!fs.existsSync(resolvedPath)) {
+                throw new Error(`Docker compose file not found: ${resolvedPath}`);
+            }
+            // Read file contents
+            const fileContents = fs.readFileSync(resolvedPath, 'utf-8');
+            // Encode to base64
+            const base64Content = Buffer.from(fileContents, 'utf-8').toString('base64');
+            // Return with base64: prefix (matching existing pattern)
+            this.logger.debug(`Encoded docker-compose file to base64 (${base64Content.length} bytes)`);
+            return `base64:${base64Content}`;
+        }
+        catch (error) {
+            this.logger.error(`Failed to encode docker-compose file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to encode docker-compose file '${composeFilePath}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}
+exports.StackService = StackService;
+//# sourceMappingURL=StackService.js.map

package/dist/types/stack.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Application Stack type definitions
+ * Defines the structure for declarative application deployments
+ */
+/**
+ * Main application stack structure
+ */
+export interface ApplicationStack {
+    apiVersion: string;
+    kind: 'ApplicationStack';
+    metadata: StackMetadata;
+    applications: StackApplication[];
+}
+/**
+ * Stack metadata
+ */
+export interface StackMetadata {
+    name: string;
+    description?: string;
+}
+/**
+ * Application definition within a stack
+ */
+export interface StackApplication {
+    name: string;
+    description?: string;
+    port: number;
+    protocol: 'http' | 'https' | 'tcp' | 'udp';
+    subtype: ApplicationSubtype;
+    deviceName: string;
+    published?: boolean;
+    hostnames?: string[];
+    dependsOn?: string[];
+    authModes?: AuthMode[];
+    allowedOrganizations?: string[];
+    composeFile?: string;
+    command?: string;
+    workingDir?: string;
+    environment?: Record<string, string>;
+    logFile?: string;
+}
+/**
+ * Supported application subtypes
+ */
+export type ApplicationSubtype = 'existing' | 'docker-compose' | 'managed-process' | 'docker' | 'podman' | 'qemu';
+/**
+ * Authentication modes
+ */
+export type AuthMode = 'none' | 'org' | 'api-key';
+/**
+ * Stack with resolved device and gateway IDs
+ */
+export interface ResolvedStack extends ApplicationStack {
+    resolved: {
+        devices: Map<string, string>;
+        gateways: Map<string, string[]>;
+        applications: Map<string, string>;
+    };
+}
+/**
+ * Resolved application ready for deployment
+ */
+export interface ResolvedApplication extends StackApplication {
+    deviceId: string;
+    gatewayIds?: string[];
+    existingApplicationId?: string;
+}
+/**
+ * Stack validation result
+ */
+export interface StackValidationResult {
+    valid: boolean;
+    errors: StackValidationError[];
+    warnings: StackValidationWarning[];
+}
+/**
+ * Validation error
+ */
+export interface StackValidationError {
+    path: string;
+    message: string;
+    line?: number;
+}
+/**
+ * Validation warning
+ */
+export interface StackValidationWarning {
+    path: string;
+    message: string;
+}
+/**
+ * Options for deploy command
+ */
+export interface DeployOptions {
+    file: string;
+    app?: string;
+    dryRun?: boolean;
+    skipDependencies?: boolean;
+    force?: boolean;
+}
+/**
+ * Options for teardown command
+ */
+export interface TeardownOptions {
+    file: string;
+    app?: string;
+    force?: boolean;
+    keepDependencies?: boolean;
+}
+/**
+ * Deploy operation result
+ */
+export interface DeployResult {
+    success: boolean;
+    deployed: DeployedApplication[];
+    failed: FailedApplication[];
+    skipped: string[];
+}
+/**
+ * Successfully deployed application
+ */
+export interface DeployedApplication {
+    name: string;
+    applicationId: string;
+    urls?: string[];
+}
+/**
+ * Failed application deployment
+ */
+export interface FailedApplication {
+    name: string;
+    error: string;
+}
+/**
+ * Teardown operation result
+ */
+export interface TeardownResult {
+    success: boolean;
+    removed: string[];
+    failed: FailedApplication[];
+    skipped: string[];
+}
+/**
+ * Stack status information
+ */
+export interface StackStatus {
+    stackName: string;
+    applications: ApplicationStatus[];
+}
+/**
+ * Individual application status
+ */
+export interface ApplicationStatus {
+    name: string;
+    status: 'deployed' | 'not-deployed' | 'error';
+    applicationId?: string;
+    deviceName: string;
+    deviceId?: string;
+    published: boolean;
+    urls?: string[];
+    lastUpdated?: Date;
+    error?: string;
+}
+/**
+ * Stack diff result
+ */
+export interface StackDiff {
+    toCreate: StackApplication[];
+    toUpdate: ApplicationDiff[];
+    toDelete: ApplicationStatus[];
+    unchanged: string[];
+}
+/**
+ * Application diff details
+ */
+export interface ApplicationDiff {
+    name: string;
+    changes: {
+        field: string;
+        oldValue: any;
+        newValue: any;
+    }[];
+}
+/**
+ * Dependency graph node
+ */
+export interface DependencyNode {
+    name: string;
+    dependencies: string[];
+}
+//# sourceMappingURL=stack.d.ts.map

package/dist/types/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../src/types/stack.ts"],"names":[],"mappings":"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"}

package/dist/types/stack.js

@@ -0,0 +1,5 @@
+"use strict";
+// AUTO-GENERATED FILE - DO NOT EDIT
+// This file is copied from backend during build. Changes will be overwritten.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=stack.js.map