@edgible-team/cli 1.2.13 → 1.2.17

package/dist/services/instances.js

@@ -7,15 +7,18 @@
  * Services are instantiated once and shared across the application.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.agentDeploymentService = exports.diagnosticsService = exports.managedGatewayService = exports.localAgentManager = exports.edgibleService = exports.gatewayService = exports.applicationService = exports.authService = exports.tokenManager = exports.configManager = exports.logger = void 0;
+exports.stackService = exports.agentDeploymentService = exports.diagnosticsService = exports.managedGatewayService = exports.edgibleService = exports.localAgentManager = exports.deviceService = exports.gatewayService = exports.applicationService = exports.authService = exports.tokenManager = exports.configManager = exports.logger = void 0;
+exports.getStackService = getStackService;
 exports.createConnectivityTester = createConnectivityTester;
 exports.createWorkloadDetector = createWorkloadDetector;
+exports.getServiceInstances = getServiceInstances;
 const console_logger_1 = require("../utils/console-logger");
 const config_1 = require("../state/config");
 const TokenManager_1 = require("./token/TokenManager");
 const AuthService_1 = require("./auth/AuthService");
 const ApplicationService_1 = require("./application/ApplicationService");
 const GatewayService_1 = require("./gateway/GatewayService");
+const DeviceService_1 = require("./device/DeviceService");
 const edgible_1 = require("./edgible");
 const LocalAgentManager_1 = require("./LocalAgentManager");
 const ConnectivityTester_1 = require("./ConnectivityTester");
@@ -23,6 +26,8 @@ const WorkloadDetector_1 = require("../detection/WorkloadDetector");
 const ManagedGatewayService_1 = require("./managedGateway/ManagedGatewayService");
 const DiagnosticsService_1 = require("./diagnostics/DiagnosticsService");
 const AgentDeploymentService_1 = require("./agentDeployment/AgentDeploymentService");
+const StackService_1 = require("./stack/StackService");
+const client_1 = require("../client");
 const app_config_1 = require("../config/app-config");
 const logger_1 = require("../utils/logger");
 // Get application configuration
@@ -43,16 +48,39 @@ exports.authService = new AuthService_1.AuthServiceImpl(appConfig.apiBaseUrl, ex
 exports.applicationService = new ApplicationService_1.ApplicationServiceImpl(appConfig.apiBaseUrl, exports.configManager, exports.authService, exports.tokenManager, exports.logger);
 // Create gateway service
 exports.gatewayService = new GatewayService_1.GatewayServiceImpl(appConfig.apiBaseUrl, exports.configManager, exports.authService, exports.tokenManager, exports.logger);
+// Create device service
+exports.deviceService = new DeviceService_1.DeviceServiceImpl(appConfig.apiBaseUrl, exports.configManager, exports.authService, exports.tokenManager, exports.logger);
+// Create local agent manager (pass shared configManager)
+exports.localAgentManager = new LocalAgentManager_1.LocalAgentManager(exports.configManager);
 // Create Edgible service (legacy - being refactored in phases)
-exports.edgibleService = new edgible_1.EdgibleService(appConfig.apiBaseUrl, exports.configManager, exports.tokenManager, exports.logger);
-// Create local agent manager
-exports.localAgentManager = new LocalAgentManager_1.LocalAgentManager();
+exports.edgibleService = new edgible_1.EdgibleService(appConfig.apiBaseUrl, exports.configManager, exports.tokenManager, exports.logger, exports.localAgentManager);
 // Create managed gateway service
 exports.managedGatewayService = new ManagedGatewayService_1.ManagedGatewayServiceImpl(exports.edgibleService);
 // Create diagnostics service
 exports.diagnosticsService = new DiagnosticsService_1.DiagnosticsServiceImpl(exports.edgibleService);
 // Create agent deployment service
 exports.agentDeploymentService = new AgentDeploymentService_1.AgentDeploymentServiceImpl(exports.edgibleService);
+// Create stack service
+let _stackService = null;
+function getStackService() {
+    if (!_stackService) {
+        const config = exports.configManager.getConfig();
+        const organizationId = config.organizationId;
+        if (!organizationId) {
+            throw new Error('Organization ID not set. Please authenticate first.');
+        }
+        const apiClient = (0, client_1.createApiClient)(appConfig.apiBaseUrl);
+        exports.tokenManager.restoreTokensFromConfig(apiClient);
+        _stackService = new StackService_1.StackService(apiClient, exports.applicationService, organizationId, exports.logger);
+    }
+    return _stackService;
+}
+// Export stackService as a getter to ensure it's initialized with proper organizationId
+exports.stackService = {
+    get instance() {
+        return getStackService();
+    }
+};
 // Create connectivity tester (transient - create new instances as needed)
 function createConnectivityTester() {
     return new ConnectivityTester_1.ConnectivityTester();
@@ -61,4 +89,25 @@ function createConnectivityTester() {
 function createWorkloadDetector() {
     return new WorkloadDetector_1.WorkloadDetector();
 }
+/**
+ * Get all service instances
+ * Convenience function for commands that need multiple services
+ */
+function getServiceInstances() {
+    return {
+        logger: exports.logger,
+        configManager: exports.configManager,
+        tokenManager: exports.tokenManager,
+        authService: exports.authService,
+        applicationService: exports.applicationService,
+        gatewayService: exports.gatewayService,
+        deviceService: exports.deviceService,
+        edgibleService: exports.edgibleService,
+        localAgentManager: exports.localAgentManager,
+        managedGatewayService: exports.managedGatewayService,
+        diagnosticsService: exports.diagnosticsService,
+        agentDeploymentService: exports.agentDeploymentService,
+        stackService: getStackService(),
+    };
+}
 //# sourceMappingURL=instances.js.map

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

@@ -0,0 +1,69 @@
+/**
+ * Dependency Graph Manager
+ * Handles dependency resolution and topological sorting for application deployments
+ */
+import { StackApplication } from '../../types/stack';
+import { Logger } from '../../utils/logger';
+export declare class DependencyGraphManager {
+    private logger;
+    constructor(logger: Logger);
+    /**
+     * Build dependency graph from applications
+     * @param applications List of stack applications
+     * @returns Adjacency list representation of the graph
+     */
+    buildGraph(applications: StackApplication[]): Map<string, string[]>;
+    /**
+     * Detect circular dependencies in the graph
+     * @param applications List of stack applications
+     * @returns Array of application names forming a cycle, or null if no cycle
+     */
+    detectCycles(applications: StackApplication[]): string[] | null;
+    /**
+     * Get deployment order using topological sort
+     * Applications with no dependencies come first
+     * @param applications List of stack applications
+     * @returns Ordered list of application names for deployment
+     * @throws CircularDependencyError if cycle detected
+     */
+    getDeploymentOrder(applications: StackApplication[]): string[];
+    /**
+     * Get teardown order (reverse of deployment order)
+     * Applications with dependents are removed last
+     * @param applications List of stack applications
+     * @returns Ordered list of application names for teardown
+     */
+    getTeardownOrder(applications: StackApplication[]): string[];
+    /**
+     * Get direct dependencies for an application
+     * @param appName Application name
+     * @param applications List of stack applications
+     * @returns List of application names that this app depends on
+     */
+    getDependencies(appName: string, applications: StackApplication[]): string[];
+    /**
+     * Get all applications that depend on the given application (dependents)
+     * @param appName Application name
+     * @param applications List of stack applications
+     * @returns List of application names that depend on this app
+     */
+    getDependents(appName: string, applications: StackApplication[]): string[];
+    /**
+     * Check if an application can be deployed independently
+     * (has no dependencies or all dependencies are already deployed)
+     * @param appName Application name
+     * @param applications List of stack applications
+     * @param deployedApps Set of already deployed application names
+     * @returns True if app can be deployed
+     */
+    canDeploy(appName: string, applications: StackApplication[], deployedApps: Set<string>): boolean;
+    /**
+     * Validate dependency graph
+     * Checks for cycles and non-existent dependencies
+     * @param applications List of stack applications
+     * @throws CircularDependencyError if cycle detected
+     * @throws Error if dependency not found
+     */
+    validate(applications: StackApplication[]): void;
+}
+//# sourceMappingURL=DependencyGraphManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyGraphManager.d.ts","sourceRoot":"","sources":["../../../src/services/stack/DependencyGraphManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,qBAAa,sBAAsB;IACrB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;OAIG;IACH,UAAU,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAoBnE;;;;OAIG;IACH,YAAY,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI;IAwC/D;;;;;;OAMG;IACH,kBAAkB,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,MAAM,EAAE;IAqD9D;;;;;OAKG;IACH,gBAAgB,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,MAAM,EAAE;IAQ5D;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,gBAAgB,EAAE,GAAG,MAAM,EAAE;IAK5E;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,gBAAgB,EAAE,GAAG,MAAM,EAAE;IAY1E;;;;;;;OAOG;IACH,SAAS,CACP,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,gBAAgB,EAAE,EAChC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GACxB,OAAO;IAOV;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,IAAI;CAwBjD"}

package/dist/services/stack/DependencyGraphManager.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Dependency Graph Manager
+ * Handles dependency resolution and topological sorting for application deployments
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyGraphManager = void 0;
+const stack_errors_1 = require("../../utils/stack-errors");
+class DependencyGraphManager {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Build dependency graph from applications
+     * @param applications List of stack applications
+     * @returns Adjacency list representation of the graph
+     */
+    buildGraph(applications) {
+        const graph = new Map();
+        // Initialize all nodes
+        for (const app of applications) {
+            if (!graph.has(app.name)) {
+                graph.set(app.name, []);
+            }
+        }
+        // Add edges (dependencies)
+        for (const app of applications) {
+            if (app.dependsOn && app.dependsOn.length > 0) {
+                graph.set(app.name, [...app.dependsOn]);
+            }
+        }
+        return graph;
+    }
+    /**
+     * Detect circular dependencies in the graph
+     * @param applications List of stack applications
+     * @returns Array of application names forming a cycle, or null if no cycle
+     */
+    detectCycles(applications) {
+        const graph = this.buildGraph(applications);
+        const visited = new Set();
+        const recursionStack = new Set();
+        const path = [];
+        const dfs = (node) => {
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            const neighbors = graph.get(node) || [];
+            for (const neighbor of neighbors) {
+                if (!visited.has(neighbor)) {
+                    const cycle = dfs(neighbor);
+                    if (cycle)
+                        return cycle;
+                }
+                else if (recursionStack.has(neighbor)) {
+                    // Found a cycle
+                    const cycleStart = path.indexOf(neighbor);
+                    return [...path.slice(cycleStart), neighbor];
+                }
+            }
+            path.pop();
+            recursionStack.delete(node);
+            return null;
+        };
+        for (const app of applications) {
+            if (!visited.has(app.name)) {
+                const cycle = dfs(app.name);
+                if (cycle) {
+                    return cycle;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Get deployment order using topological sort
+     * Applications with no dependencies come first
+     * @param applications List of stack applications
+     * @returns Ordered list of application names for deployment
+     * @throws CircularDependencyError if cycle detected
+     */
+    getDeploymentOrder(applications) {
+        // First, check for cycles
+        const cycle = this.detectCycles(applications);
+        if (cycle) {
+            throw new stack_errors_1.CircularDependencyError(cycle);
+        }
+        const graph = this.buildGraph(applications);
+        const inDegree = new Map();
+        const result = [];
+        // Calculate in-degree for each node
+        for (const app of applications) {
+            inDegree.set(app.name, 0);
+        }
+        for (const app of applications) {
+            const deps = graph.get(app.name) || [];
+            for (const dep of deps) {
+                inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
+            }
+        }
+        // Queue of nodes with no dependencies
+        const queue = [];
+        for (const [node, degree] of inDegree.entries()) {
+            if (degree === 0) {
+                queue.push(node);
+            }
+        }
+        // Process queue (Kahn's algorithm)
+        while (queue.length > 0) {
+            const current = queue.shift();
+            result.push(current);
+            // Find all apps that depend on current
+            for (const app of applications) {
+                if (app.dependsOn && app.dependsOn.includes(current)) {
+                    const currentInDegree = inDegree.get(app.name) || 0;
+                    inDegree.set(app.name, currentInDegree - 1);
+                    if (inDegree.get(app.name) === 0) {
+                        queue.push(app.name);
+                    }
+                }
+            }
+        }
+        this.logger.debug(`Deployment order: ${result.join(' -> ')}`);
+        return result;
+    }
+    /**
+     * Get teardown order (reverse of deployment order)
+     * Applications with dependents are removed last
+     * @param applications List of stack applications
+     * @returns Ordered list of application names for teardown
+     */
+    getTeardownOrder(applications) {
+        const deploymentOrder = this.getDeploymentOrder(applications);
+        const teardownOrder = [...deploymentOrder].reverse();
+        this.logger.debug(`Teardown order: ${teardownOrder.join(' -> ')}`);
+        return teardownOrder;
+    }
+    /**
+     * Get direct dependencies for an application
+     * @param appName Application name
+     * @param applications List of stack applications
+     * @returns List of application names that this app depends on
+     */
+    getDependencies(appName, applications) {
+        const app = applications.find(a => a.name === appName);
+        return app?.dependsOn || [];
+    }
+    /**
+     * Get all applications that depend on the given application (dependents)
+     * @param appName Application name
+     * @param applications List of stack applications
+     * @returns List of application names that depend on this app
+     */
+    getDependents(appName, applications) {
+        const dependents = [];
+        for (const app of applications) {
+            if (app.dependsOn && app.dependsOn.includes(appName)) {
+                dependents.push(app.name);
+            }
+        }
+        return dependents;
+    }
+    /**
+     * Check if an application can be deployed independently
+     * (has no dependencies or all dependencies are already deployed)
+     * @param appName Application name
+     * @param applications List of stack applications
+     * @param deployedApps Set of already deployed application names
+     * @returns True if app can be deployed
+     */
+    canDeploy(appName, applications, deployedApps) {
+        const dependencies = this.getDependencies(appName, applications);
+        // Can deploy if all dependencies are already deployed
+        return dependencies.every(dep => deployedApps.has(dep));
+    }
+    /**
+     * Validate dependency graph
+     * Checks for cycles and non-existent dependencies
+     * @param applications List of stack applications
+     * @throws CircularDependencyError if cycle detected
+     * @throws Error if dependency not found
+     */
+    validate(applications) {
+        const appNames = new Set(applications.map(app => app.name));
+        // Check for non-existent dependencies
+        for (const app of applications) {
+            if (app.dependsOn) {
+                for (const dep of app.dependsOn) {
+                    if (!appNames.has(dep)) {
+                        throw new Error(`Application '${app.name}' depends on non-existent application '${dep}'`);
+                    }
+                }
+            }
+        }
+        // Check for cycles
+        const cycle = this.detectCycles(applications);
+        if (cycle) {
+            throw new stack_errors_1.CircularDependencyError(cycle);
+        }
+        this.logger.debug('Dependency graph validation passed');
+    }
+}
+exports.DependencyGraphManager = DependencyGraphManager;
+//# sourceMappingURL=DependencyGraphManager.js.map

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

@@ -0,0 +1,63 @@
+/**
+ * Device Resolver Service
+ * Resolves device names to device IDs by querying the organization's devices
+ */
+import { ApiClient } from '../../client';
+import { DeviceData } from '../../types/models/DeviceData';
+import { Logger } from '../../utils/logger';
+export interface DeviceResolutionResult {
+    deviceName: string;
+    deviceId: string;
+    device: DeviceData;
+}
+export declare class DeviceResolver {
+    private apiClient;
+    private organizationId;
+    private logger;
+    private deviceCache;
+    private cacheTimestamp;
+    private readonly CACHE_TTL_MS;
+    constructor(apiClient: ApiClient, organizationId: string, logger: Logger);
+    /**
+     * Resolve a device name to device ID
+     * @param deviceName Name of the device to resolve
+     * @returns DeviceResolutionResult with device ID and full device data
+     * @throws DeviceNotFoundError if device not found
+     * @throws DeviceAmbiguousError if multiple devices match
+     */
+    resolveDevice(deviceName: string): Promise<DeviceResolutionResult>;
+    /**
+     * Resolve multiple device names to IDs
+     * @param deviceNames Array of device names to resolve
+     * @returns Map of deviceName -> deviceId
+     * @throws DeviceNotFoundError or DeviceAmbiguousError for any device
+     */
+    resolveDevices(deviceNames: string[]): Promise<Map<string, string>>;
+    /**
+     * Get all devices in the organization (with caching)
+     * @returns Array of DeviceData
+     */
+    private getDevices;
+    /**
+     * Clear the device cache (useful for testing or forcing refresh)
+     */
+    clearCache(): void;
+    /**
+     * Check if a device exists by name
+     * @param deviceName Name of the device
+     * @returns True if device exists
+     */
+    deviceExists(deviceName: string): Promise<boolean>;
+    /**
+     * List all available device names
+     * @returns Array of device names
+     */
+    listDeviceNames(): Promise<string[]>;
+    /**
+     * Get device details by name
+     * @param deviceName Name of the device
+     * @returns DeviceData or null if not found
+     */
+    getDeviceByName(deviceName: string): Promise<DeviceData | null>;
+}
+//# sourceMappingURL=DeviceResolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceResolver.d.ts","sourceRoot":"","sources":["../../../src/services/stack/DeviceResolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAG5C,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;CACpB;AAED,qBAAa,cAAc;IAMvB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,MAAM;IAPhB,OAAO,CAAC,WAAW,CAA0C;IAC7D,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAG5B,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM;IAGxB;;;;;;OAMG;IACG,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA2BxE;;;;;OAKG;IACG,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAYzE;;;OAGG;YACW,UAAU;IAqCxB;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;;;OAIG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAYxD;;;OAGG;IACG,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAK1C;;;;OAIG;IACG,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;CAWtE"}

package/dist/services/stack/DeviceResolver.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Device Resolver Service
+ * Resolves device names to device IDs by querying the organization's devices
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceResolver = void 0;
+const stack_errors_1 = require("../../utils/stack-errors");
+class DeviceResolver {
+    constructor(apiClient, organizationId, logger) {
+        this.apiClient = apiClient;
+        this.organizationId = organizationId;
+        this.logger = logger;
+        this.deviceCache = null;
+        this.cacheTimestamp = null;
+        this.CACHE_TTL_MS = 60000; // 1 minute cache
+    }
+    /**
+     * Resolve a device name to device ID
+     * @param deviceName Name of the device to resolve
+     * @returns DeviceResolutionResult with device ID and full device data
+     * @throws DeviceNotFoundError if device not found
+     * @throws DeviceAmbiguousError if multiple devices match
+     */
+    async resolveDevice(deviceName) {
+        this.logger.debug(`Resolving device: ${deviceName}`);
+        const devices = await this.getDevices();
+        // Find devices with matching name (case-sensitive)
+        const matchingDevices = devices.filter(d => d.name === deviceName);
+        if (matchingDevices.length === 0) {
+            throw new stack_errors_1.DeviceNotFoundError(deviceName);
+        }
+        if (matchingDevices.length > 1) {
+            const deviceIds = matchingDevices.map(d => d.id);
+            throw new stack_errors_1.DeviceAmbiguousError(deviceName, deviceIds);
+        }
+        const device = matchingDevices[0];
+        this.logger.debug(`Resolved device '${deviceName}' to ID: ${device.id}`);
+        return {
+            deviceName,
+            deviceId: device.id,
+            device,
+        };
+    }
+    /**
+     * Resolve multiple device names to IDs
+     * @param deviceNames Array of device names to resolve
+     * @returns Map of deviceName -> deviceId
+     * @throws DeviceNotFoundError or DeviceAmbiguousError for any device
+     */
+    async resolveDevices(deviceNames) {
+        const uniqueNames = [...new Set(deviceNames)];
+        const result = new Map();
+        for (const name of uniqueNames) {
+            const resolution = await this.resolveDevice(name);
+            result.set(name, resolution.deviceId);
+        }
+        return result;
+    }
+    /**
+     * Get all devices in the organization (with caching)
+     * @returns Array of DeviceData
+     */
+    async getDevices() {
+        const now = Date.now();
+        // Return cached devices if still valid
+        if (this.deviceCache !== null &&
+            this.cacheTimestamp !== null &&
+            now - this.cacheTimestamp < this.CACHE_TTL_MS) {
+            const cached = this.deviceCache.get(this.organizationId);
+            if (cached) {
+                this.logger.debug('Using cached device list');
+                return cached;
+            }
+        }
+        // Fetch devices from API
+        this.logger.debug(`Fetching devices for organization: ${this.organizationId}`);
+        try {
+            const response = await this.apiClient.getOrganizationDevices(this.organizationId);
+            const devices = response.devices || [];
+            // Update cache
+            if (this.deviceCache === null) {
+                this.deviceCache = new Map();
+            }
+            this.deviceCache.set(this.organizationId, devices);
+            this.cacheTimestamp = now;
+            this.logger.debug(`Fetched ${devices.length} devices`);
+            return devices;
+        }
+        catch (error) {
+            this.logger.error(`Failed to fetch devices: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to fetch organization devices: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Clear the device cache (useful for testing or forcing refresh)
+     */
+    clearCache() {
+        this.deviceCache = null;
+        this.cacheTimestamp = null;
+        this.logger.debug('Device cache cleared');
+    }
+    /**
+     * Check if a device exists by name
+     * @param deviceName Name of the device
+     * @returns True if device exists
+     */
+    async deviceExists(deviceName) {
+        try {
+            await this.resolveDevice(deviceName);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof stack_errors_1.DeviceNotFoundError) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    /**
+     * List all available device names
+     * @returns Array of device names
+     */
+    async listDeviceNames() {
+        const devices = await this.getDevices();
+        return devices.map(d => d.name);
+    }
+    /**
+     * Get device details by name
+     * @param deviceName Name of the device
+     * @returns DeviceData or null if not found
+     */
+    async getDeviceByName(deviceName) {
+        try {
+            const result = await this.resolveDevice(deviceName);
+            return result.device;
+        }
+        catch (error) {
+            if (error instanceof stack_errors_1.DeviceNotFoundError) {
+                return null;
+            }
+            throw error;
+        }
+    }
+}
+exports.DeviceResolver = DeviceResolver;
+//# sourceMappingURL=DeviceResolver.js.map

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

@@ -0,0 +1,84 @@
+/**
+ * Gateway Resolver Service
+ * Resolves gateway requirements for published applications
+ */
+import { ApiClient } from '../../client';
+import { Logger } from '../../utils/logger';
+import { StackApplication } from '../../types/stack';
+export interface GatewayResolutionResult {
+    appName: string;
+    gatewayIds: string[];
+    gatewayCreated: boolean;
+}
+export interface ManagedGatewayInfo {
+    id: string;
+    name: string;
+    region: string;
+    status: string;
+    applicationsCount?: number;
+}
+export declare class GatewayResolver {
+    private apiClient;
+    private organizationId;
+    private logger;
+    private gatewayCache;
+    private cacheTimestamp;
+    private readonly CACHE_TTL_MS;
+    constructor(apiClient: ApiClient, organizationId: string, logger: Logger);
+    /**
+     * 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
+     */
+    resolveGateways(applications: StackApplication[], autoCreate?: boolean): Promise<Map<string, string[]>>;
+    /**
+     * 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)
+     */
+    resolveGateway(appName: string, published: boolean): Promise<string[]>;
+    /**
+     * List all managed gateways (with caching)
+     * @returns Array of managed gateway info
+     */
+    listManagedGateways(): Promise<ManagedGatewayInfo[]>;
+    /**
+     * Check if gateway creation is needed
+     * @param applications List of applications
+     * @returns True if any published app needs a gateway but none available
+     */
+    needsGatewayCreation(applications: StackApplication[]): Promise<boolean>;
+    /**
+     * 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
+     */
+    selectBestGateway(appName: string, deviceRegion?: string): Promise<string | null>;
+    /**
+     * Clear the gateway cache (useful for testing or forcing refresh)
+     */
+    clearCache(): void;
+    /**
+     * Get gateway details
+     * @param gatewayId Gateway ID
+     * @returns Gateway info or null if not found
+     */
+    getGateway(gatewayId: string): Promise<ManagedGatewayInfo | null>;
+    /**
+     * Check if a gateway exists and is available
+     * @param gatewayId Gateway ID
+     * @returns True if gateway exists and is active
+     */
+    gatewayAvailable(gatewayId: string): Promise<boolean>;
+}
+//# sourceMappingURL=GatewayResolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GatewayResolver.d.ts","sourceRoot":"","sources":["../../../src/services/stack/GatewayResolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,qBAAa,eAAe;IAMxB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,MAAM;IAPhB,OAAO,CAAC,YAAY,CAAqC;IACzD,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAG5B,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM;IAGxB;;;;;;OAMG;IACG,eAAe,CACnB,YAAY,EAAE,gBAAgB,EAAE,EAChC,UAAU,GAAE,OAAe,GAC1B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IA0CjC;;;;;OAKG;IACG,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,MAAM,EAAE,CAAC;IAqBpB;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAgD1D;;;;OAIG;IACG,oBAAoB,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAU9E;;;;;;;;;;;OAWG;IACG,iBAAiB,CACrB,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAYzB;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;;;OAIG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAKvE;;;;OAIG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAI5D"}