vme-mcp-server 0.1.6 → 0.1.8

package/dist/lib/api-utils.js

@@ -13,19 +13,32 @@ exports.api = axios_1.default.create({
         "Content-Type": "application/json"
     }
 });
-// Helper function to get available cluster nodes
+// Helper function to get available cluster nodes (hypervisor hosts, not VMs)
 async function getClusterNodes() {
     try {
+        // Get actual cluster hypervisor nodes from /clusters endpoint
         const clusters = await exports.api.get("/clusters");
-        const prodCluster = clusters.data.clusters.find((cluster) => cluster.name === "prod01");
-        if (prodCluster && prodCluster.servers) {
-            return prodCluster.servers.map((server) => server.id);
+        let allNodes = [];
+        if (clusters.data.clusters) {
+            for (const cluster of clusters.data.clusters) {
+                if (cluster.servers && Array.isArray(cluster.servers)) {
+                    const clusterNodes = cluster.servers.map((server) => server.id).filter((id) => id);
+                    allNodes.push(...clusterNodes);
+                }
+            }
+        }
+        // Remove duplicates and sort
+        const uniqueNodes = [...new Set(allNodes)].sort((a, b) => a - b);
+        if (uniqueNodes.length > 0) {
+            console.log(`Found ${uniqueNodes.length} cluster hypervisor nodes: ${uniqueNodes.join(', ')}`);
+            return uniqueNodes;
         }
     }
     catch (error) {
         console.error('Error getting cluster nodes:', error);
     }
-    // Fallback to known nodes if API fails
+    // Fallback to known hypervisor nodes if API fails
+    console.warn('Using fallback hypervisor nodes [1, 2, 3] - could not detect cluster hosts');
     return [1, 2, 3];
 }
 exports.getClusterNodes = getClusterNodes;

package/dist/lib/capability-cache.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityCache = exports.SmartCapabilityCache = void 0;
+const api_utils_js_1 = require("./api-utils.js");
+// Smart capability cache with field-level TTL
+class SmartCapabilityCache {
+    constructor() {
+        this.cache = new Map();
+        // TTL configuration based on VME resource change patterns
+        this.ttlConfig = {
+            zones: 3600, // Zones rarely change (1 hour)
+            clusters: 1800, // Cluster topology changes occasionally (30 min)
+            service_plans: 1800, // Plans change occasionally (30 min)
+            instance_types: 7200, // Instance types very stable (2 hours)
+            virtual_images: 900, // Images updated more frequently (15 min)
+            cluster_status: 300, // Node status changes often (5 min)
+            resource_pools: 1800, // Pool config changes occasionally (30 min)
+            networks: 3600, // Network config rarely changes (1 hour)
+            groups: 3600, // Groups rarely change (1 hour)
+        };
+        // Default TTL for unknown fields
+        this.defaultTTL = 600; // 10 minutes
+    }
+    /**
+     * Get data for a specific field, using cache if fresh or fetching if stale
+     */
+    async getField(fieldName, forceRefresh = false) {
+        const cached = this.cache.get(fieldName);
+        const now = Math.floor(Date.now() / 1000);
+        // Check if cache is fresh and not forcing refresh
+        if (!forceRefresh && cached && this.isFresh(cached, now)) {
+            return cached.data;
+        }
+        // Fetch fresh data from VME API
+        const endpoint = this.getEndpointForField(fieldName);
+        try {
+            const response = await api_utils_js_1.api.get(endpoint);
+            // Store in cache with appropriate TTL
+            const cacheEntry = {
+                data: response.data,
+                cached_at: now,
+                ttl_seconds: this.ttlConfig[fieldName] || this.defaultTTL,
+                endpoint: endpoint,
+                field_name: fieldName
+            };
+            this.cache.set(fieldName, cacheEntry);
+            return response.data;
+        }
+        catch (error) {
+            // If API fails and we have stale cache, return it with warning
+            if (cached) {
+                console.warn(`VME API failed for ${fieldName}, returning stale cache data`);
+                return cached.data;
+            }
+            // No cache and API failed - propagate error
+            throw new Error(`Failed to fetch ${fieldName}: ${error.message}`);
+        }
+    }
+    /**
+     * Get cache status for a specific field or all fields
+     */
+    getCacheStatus(fieldName) {
+        const now = Math.floor(Date.now() / 1000);
+        const statuses = [];
+        if (fieldName) {
+            const cached = this.cache.get(fieldName);
+            if (cached) {
+                statuses.push(this.buildCacheStatus(cached, now));
+            }
+        }
+        else {
+            // Return status for all cached fields
+            for (const cached of this.cache.values()) {
+                statuses.push(this.buildCacheStatus(cached, now));
+            }
+        }
+        return statuses;
+    }
+    /**
+     * Invalidate cache for specific field or all fields
+     */
+    invalidate(fieldName) {
+        if (fieldName) {
+            this.cache.delete(fieldName);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    /**
+     * Get cache hit rate statistics
+     */
+    getStatistics() {
+        // This would need hit/miss tracking - placeholder for now
+        return { hits: 0, misses: 0, hitRate: 0 };
+    }
+    // Private helper methods
+    isFresh(cached, now) {
+        return (now - cached.cached_at) < cached.ttl_seconds;
+    }
+    buildCacheStatus(cached, now) {
+        const age = now - cached.cached_at;
+        const expiresIn = cached.ttl_seconds - age;
+        return {
+            field_name: cached.field_name,
+            cached_at: cached.cached_at,
+            ttl_seconds: cached.ttl_seconds,
+            age_seconds: age,
+            is_fresh: this.isFresh(cached, now),
+            expires_in_seconds: Math.max(0, expiresIn),
+            endpoint: cached.endpoint
+        };
+    }
+    getEndpointForField(fieldName) {
+        // Map field names to VME API endpoints
+        const endpointMap = {
+            zones: "/zones",
+            clusters: "/clusters",
+            service_plans: "/service-plans",
+            instance_types: "/instance-types",
+            virtual_images: "/virtual-images",
+            resource_pools: "/resource-pools",
+            networks: "/networks",
+            groups: "/groups"
+        };
+        return endpointMap[fieldName] || `/${fieldName}`;
+    }
+}
+exports.SmartCapabilityCache = SmartCapabilityCache;
+// Global cache instance
+exports.capabilityCache = new SmartCapabilityCache();

package/dist/lib/capability-discovery.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityDiscovery = exports.CapabilityDiscoveryEngine = void 0;
+const capability_cache_js_1 = require("./capability-cache.js");
+// Capability discovery engine
+class CapabilityDiscoveryEngine {
+    /**
+     * Discover capabilities for specified domains
+     */
+    async discoverCapabilities(domains = ["all"], forceRefresh = false) {
+        const result = {
+            discovered_at: new Date().toISOString(),
+            cache_status: []
+        };
+        // Determine which domains to discover
+        const shouldDiscover = (domain) => domains.includes("all") || domains.includes(domain);
+        try {
+            // Discover capabilities in parallel for efficiency
+            const discoveries = await Promise.allSettled([
+                shouldDiscover("compute") ? this.discoverComputeCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("networking") ? this.discoverNetworkingCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("storage") ? this.discoverStorageCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("platform") ? this.discoverPlatformCapabilities(forceRefresh) : Promise.resolve(null),
+            ]);
+            // Process results
+            if (discoveries[0]?.status === "fulfilled" && discoveries[0].value) {
+                result.compute = discoveries[0].value;
+            }
+            if (discoveries[1]?.status === "fulfilled" && discoveries[1].value) {
+                result.networking = discoveries[1].value;
+            }
+            if (discoveries[2]?.status === "fulfilled" && discoveries[2].value) {
+                result.storage = discoveries[2].value;
+            }
+            if (discoveries[3]?.status === "fulfilled" && discoveries[3].value) {
+                result.platform = discoveries[3].value;
+            }
+            // Add cache status summary
+            result.cache_status = this.getCacheStatusSummary();
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Capability discovery failed: ${error.message}`);
+        }
+    }
+    /**
+     * Check if a specific capability is available
+     */
+    async checkCapability(question, capabilityType) {
+        // Simple natural language processing for capability questions
+        const questionLower = question.toLowerCase();
+        try {
+            // GPU support check
+            if (questionLower.includes("gpu") || capabilityType === "gpu_support") {
+                const compute = await this.discoverComputeCapabilities();
+                return {
+                    answer: compute.gpu_support,
+                    details: compute.gpu_support
+                        ? "GPU support is available in this VME environment"
+                        : "No GPU support detected in cluster nodes",
+                    confidence: 0.95
+                };
+            }
+            // Hypervisor checks
+            if (questionLower.includes("vmware") || questionLower.includes("kvm") || questionLower.includes("hypervisor")) {
+                const compute = await this.discoverComputeCapabilities();
+                const hypervisor = questionLower.includes("vmware") ? "VMware" :
+                    questionLower.includes("kvm") ? "KVM" : null;
+                if (hypervisor) {
+                    const available = compute.hypervisors.includes(hypervisor);
+                    return {
+                        answer: available,
+                        details: available
+                            ? `${hypervisor} hypervisor is available`
+                            : `${hypervisor} hypervisor not found. Available: ${compute.hypervisors.join(", ")}`,
+                        confidence: 0.9
+                    };
+                }
+            }
+            // CPU/Memory limit checks
+            if (questionLower.match(/\b(\d+)\s*(cpu|core|vcpu)/)) {
+                const compute = await this.discoverComputeCapabilities();
+                const requestedCPU = parseInt(questionLower.match(/\b(\d+)\s*(cpu|core|vcpu)/)?.[1] || "0");
+                const canSupport = requestedCPU <= compute.max_cpu_per_vm;
+                return {
+                    answer: canSupport,
+                    details: canSupport
+                        ? `${requestedCPU} CPU configuration is supported (max: ${compute.max_cpu_per_vm})`
+                        : `${requestedCPU} CPU exceeds maximum of ${compute.max_cpu_per_vm} per VM`,
+                    confidence: 0.85
+                };
+            }
+            // Generic fallback
+            return {
+                answer: false,
+                details: "Unable to determine capability from question. Try being more specific.",
+                confidence: 0.1
+            };
+        }
+        catch (error) {
+            return {
+                answer: false,
+                details: `Error checking capability: ${error.message}`,
+                confidence: 0.0
+            };
+        }
+    }
+    // Private discovery methods for each domain
+    async discoverComputeCapabilities(forceRefresh = false) {
+        const [clusters, servicePlans, instanceTypes, virtualImages] = await Promise.all([
+            capability_cache_js_1.capabilityCache.getField("clusters", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("service_plans", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("instance_types", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("virtual_images", forceRefresh),
+        ]);
+        // Derive hypervisors from cluster data
+        const hypervisors = new Set();
+        let maxCPU = 0;
+        let maxMemoryGB = 0;
+        let hasGPU = false;
+        if (clusters?.clusters) {
+            for (const cluster of clusters.clusters) {
+                if (cluster.servers) {
+                    for (const server of cluster.servers) {
+                        if (server.serverType) {
+                            hypervisors.add(server.serverType);
+                        }
+                        if (server.maxCpu && server.maxCpu > maxCPU) {
+                            maxCPU = server.maxCpu;
+                        }
+                        if (server.maxMemory && server.maxMemory > maxMemoryGB) {
+                            maxMemoryGB = Math.floor(server.maxMemory / (1024 * 1024 * 1024)); // Convert to GB
+                        }
+                        if (server.gpuCount && server.gpuCount > 0) {
+                            hasGPU = true;
+                        }
+                    }
+                }
+            }
+        }
+        // Process service plans for limits
+        const plans = servicePlans?.servicePlans?.map((plan) => ({
+            id: plan.id,
+            name: plan.name,
+            max_cpu: plan.maxCpu,
+            max_memory: plan.maxMemory,
+            max_storage: plan.maxStorage
+        })) || [];
+        // Process instance types
+        const instances = instanceTypes?.instanceTypes?.map((type) => ({
+            id: type.id,
+            name: type.name,
+            code: type.code
+        })) || [];
+        // Process virtual images
+        const images = virtualImages?.virtualImages?.map((img) => ({
+            id: img.id,
+            name: img.name,
+            os_type: img.osType?.name || "Unknown",
+            category: img.osType?.category || "unknown",
+            version: img.osType?.osVersion
+        })) || [];
+        return {
+            hypervisors: Array.from(hypervisors),
+            instance_types: instances,
+            service_plans: plans,
+            max_cpu_per_vm: maxCPU,
+            max_memory_per_vm: `${maxMemoryGB}GB`,
+            gpu_support: hasGPU,
+            available_images: images.slice(0, 10) // Limit to prevent token bloat
+        };
+    }
+    async discoverNetworkingCapabilities(forceRefresh = false) {
+        const [zones, networks] = await Promise.all([
+            capability_cache_js_1.capabilityCache.getField("zones", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("networks", forceRefresh).catch(() => null), // Optional
+        ]);
+        const zoneList = zones?.zones?.map((zone) => ({
+            id: zone.id,
+            name: zone.name,
+            description: zone.description
+        })) || [];
+        return {
+            zones: zoneList,
+            network_types: ["VLAN"], // Default for VME
+            load_balancer_support: false, // Would need to check features
+            firewall_support: false, // Would need to check features
+        };
+    }
+    async discoverStorageCapabilities(forceRefresh = false) {
+        // Get real data from VME API
+        const servicePlans = await capability_cache_js_1.capabilityCache.getField("service_plans", forceRefresh);
+        // Derive storage capabilities from actual service plans and other data
+        const storageTypes = new Set();
+        let maxVolumeSize = "1TB"; // Default
+        if (servicePlans?.servicePlans) {
+            for (const plan of servicePlans.servicePlans) {
+                // Look for storage-related info in service plans
+                if (plan.maxStorage) {
+                    const sizeGB = Math.floor(plan.maxStorage / (1024 * 1024 * 1024));
+                    if (sizeGB > parseInt(maxVolumeSize)) {
+                        maxVolumeSize = `${sizeGB}GB`;
+                    }
+                }
+            }
+        }
+        // Basic storage types - would need more VME API endpoints to get real storage info
+        storageTypes.add("Local"); // VME always has local storage
+        return {
+            storage_types: Array.from(storageTypes),
+            max_volume_size: maxVolumeSize,
+            snapshot_support: true, // VME typically supports snapshots
+            encryption_support: false, // Would need to check actual VME features
+        };
+    }
+    async discoverPlatformCapabilities(forceRefresh = false) {
+        const groups = await capability_cache_js_1.capabilityCache.getField("groups", forceRefresh);
+        const groupList = groups?.groups?.map((group) => ({
+            id: group.id,
+            name: group.name,
+            description: group.description
+        })) || [];
+        return {
+            api_version: "6.2.x", // Would get from API info endpoint
+            groups: groupList,
+            enabled_features: ["VM Provisioning", "Resource Management"], // Would derive from license/features
+        };
+    }
+    getCacheStatusSummary() {
+        const statuses = capability_cache_js_1.capabilityCache.getCacheStatus();
+        return statuses.map(status => ({
+            field: status.field_name,
+            fresh: status.is_fresh,
+            age_seconds: status.age_seconds
+        }));
+    }
+}
+exports.CapabilityDiscoveryEngine = CapabilityDiscoveryEngine;
+// Global discovery engine instance
+exports.capabilityDiscovery = new CapabilityDiscoveryEngine();

package/dist/lib/name-resolver.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameResolver = exports.NameResolver = void 0;
+const capability_discovery_js_1 = require("./capability-discovery.js");
+// Generic name->ID resolver using capability discovery data
+class NameResolver {
+    constructor() {
+        this.capabilitiesCache = null;
+        this.cacheTimestamp = 0;
+        this.CACHE_TTL = 300000; // 5 minutes
+    }
+    async getCapabilities() {
+        const now = Date.now();
+        if (!this.capabilitiesCache || (now - this.cacheTimestamp) > this.CACHE_TTL) {
+            this.capabilitiesCache = await capability_discovery_js_1.capabilityDiscovery.discoverCapabilities(['all']);
+            this.cacheTimestamp = now;
+        }
+        return this.capabilitiesCache;
+    }
+    async resolveNameToId(resourceType, name) {
+        if (!name)
+            return null;
+        const capabilities = await this.getCapabilities();
+        const nameLower = name.toLowerCase();
+        switch (resourceType) {
+            case 'virtualImage':
+            case 'image':
+                return this.resolveImageName(capabilities, nameLower);
+            case 'group':
+            case 'site':
+                return this.resolveGroupName(capabilities, nameLower);
+            case 'servicePlan':
+            case 'plan':
+                return this.resolvePlanName(capabilities, nameLower);
+            case 'zone':
+            case 'cloud':
+                return this.resolveZoneName(capabilities, nameLower);
+            case 'instanceType':
+                return this.resolveInstanceTypeName(capabilities, nameLower);
+            default:
+                return null;
+        }
+    }
+    resolveImageName(capabilities, nameLower) {
+        const images = capabilities.compute?.available_images || [];
+        // Try exact name match first
+        let found = images.find((img) => img.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial name match
+        found = images.find((img) => img.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        // Try category + version matching (e.g., "ubuntu 20.04" -> ubuntu-2004)
+        for (const img of images) {
+            const imgName = img.name?.toLowerCase() || '';
+            const category = img.category?.toLowerCase() || '';
+            const version = img.version?.toString() || '';
+            // Match patterns like "ubuntu 20.04" to "ubuntu-2004"
+            if (nameLower.includes(category) && nameLower.includes(version)) {
+                return img.id;
+            }
+            // Match patterns like "ubuntu" to first ubuntu image
+            if (nameLower === category) {
+                return img.id;
+            }
+        }
+        return null;
+    }
+    resolveGroupName(capabilities, nameLower) {
+        const groups = capabilities.platform?.groups || [];
+        // Try exact match
+        let found = groups.find((g) => g.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = groups.find((g) => g.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolvePlanName(capabilities, nameLower) {
+        const plans = capabilities.compute?.service_plans || [];
+        // Try exact match
+        let found = plans.find((p) => p.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try size-based matching
+        if (nameLower.includes('small') || nameLower.includes('1 cpu') || nameLower.includes('4gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('1 cpu') ||
+                p.name?.toLowerCase().includes('4gb') ||
+                p.max_cpu === 1);
+            if (found)
+                return found.id;
+        }
+        if (nameLower.includes('medium') || nameLower.includes('2 cpu') || nameLower.includes('8gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('2 cpu') ||
+                p.name?.toLowerCase().includes('8gb') ||
+                p.max_cpu === 2);
+            if (found)
+                return found.id;
+        }
+        if (nameLower.includes('large') || nameLower.includes('4 cpu') || nameLower.includes('16gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('4 cpu') ||
+                p.name?.toLowerCase().includes('16gb') ||
+                p.max_cpu === 4);
+            if (found)
+                return found.id;
+        }
+        // Try partial match
+        found = plans.find((p) => p.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolveZoneName(capabilities, nameLower) {
+        const zones = capabilities.networking?.zones || [];
+        // Try exact match
+        let found = zones.find((z) => z.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = zones.find((z) => z.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolveInstanceTypeName(capabilities, nameLower) {
+        const instanceTypes = capabilities.compute?.instance_types || [];
+        // Try exact match
+        let found = instanceTypes.find((t) => t.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try code match
+        found = instanceTypes.find((t) => t.code?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = instanceTypes.find((t) => t.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    // Helper method to get available names for a resource type
+    async getAvailableNames(resourceType) {
+        const capabilities = await this.getCapabilities();
+        switch (resourceType) {
+            case 'virtualImage':
+                return capabilities.compute?.available_images?.map((img) => img.name) || [];
+            case 'group':
+                return capabilities.platform?.groups?.map((g) => g.name) || [];
+            case 'servicePlan':
+                return capabilities.compute?.service_plans?.map((p) => p.name) || [];
+            case 'zone':
+                return capabilities.networking?.zones?.map((z) => z.name) || [];
+            case 'instanceType':
+                return capabilities.compute?.instance_types?.map((t) => t.name) || [];
+            default:
+                return [];
+        }
+    }
+    // Helper to resolve multiple resources at once
+    async resolveMultiple(resources) {
+        const results = {};
+        for (const resource of resources) {
+            const key = `${resource.type}_${resource.name}`;
+            results[key] = await this.resolveNameToId(resource.type, resource.name);
+        }
+        return results;
+    }
+}
+exports.NameResolver = NameResolver;
+// Global resolver instance
+exports.nameResolver = new NameResolver();

package/dist/lib/vm-parsing.js

@@ -3,10 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateNodeAssignments = exports.parseVMNames = void 0;
 // Helper function to parse VM name patterns
 function parseVMNames(nameInput, count) {
-    // Handle range patterns like "web01->web03" or "web01 -> web03"
-    const rangeMatch = nameInput.match(/^(.+?)(\d+)\s*->\s*(.+?)(\d+)$/);
-    if (rangeMatch) {
-        const [, prefix1, start, prefix2, end] = rangeMatch;
+    // Handle letter range patterns like "ws-a->ws-x" or "ws-a -> ws-x"
+    const letterRangeMatch = nameInput.match(/^(.+?)([a-z])\s*->\s*(.+?)([a-z])$/i);
+    if (letterRangeMatch) {
+        const [, prefix1, startLetter, prefix2, endLetter] = letterRangeMatch;
+        if (prefix1.trim() === prefix2.trim()) {
+            const basePrefix = prefix1.trim();
+            const startCode = startLetter.toLowerCase().charCodeAt(0);
+            const endCode = endLetter.toLowerCase().charCodeAt(0);
+            const names = [];
+            for (let i = startCode; i <= endCode; i++) {
+                const letter = String.fromCharCode(i);
+                names.push(`${basePrefix}${letter}`);
+            }
+            return names;
+        }
+    }
+    // Handle numeric range patterns like "web01->web03" or "web01 -> web03"
+    const numericRangeMatch = nameInput.match(/^(.+?)(\d+)\s*->\s*(.+?)(\d+)$/);
+    if (numericRangeMatch) {
+        const [, prefix1, start, prefix2, end] = numericRangeMatch;
         if (prefix1.trim() === prefix2.trim()) {
             const basePrefix = prefix1.trim();
             const startNum = parseInt(start);
@@ -57,21 +73,13 @@ function calculateNodeAssignments(vmNames, nodes, distribution) {
             nodeAssignments.push({ name: vmName, kvmHostId: nodeId });
         });
     }
-    else if (distribution && distribution !== 'auto') {
-        // Parse specific node assignments like "1,2,3" or "node1,node2,node3"
-        const specifiedNodes = distribution.split(',').map((n) => {
-            const trimmed = n.trim();
-            return trimmed.startsWith('node') ? parseInt(trimmed.replace('node', '')) : parseInt(trimmed);
-        }).filter((n) => !isNaN(n));
-        if (specifiedNodes.length > 0) {
-            vmNames.forEach((vmName, index) => {
-                const nodeId = specifiedNodes[index % specifiedNodes.length];
-                nodeAssignments.push({ name: vmName, kvmHostId: nodeId });
-            });
-        }
-        else {
-            nodeAssignments = vmNames.map(vmName => ({ name: vmName }));
-        }
+    else if (distribution && !['auto', 'spread'].includes(distribution)) {
+        // Distribution is a node/hypervisor name - signal that it needs resolution
+        // Return assignments with the node name for the calling function to resolve
+        nodeAssignments = vmNames.map(vmName => ({
+            name: vmName,
+            nodeNameToResolve: distribution
+        }));
     }
     else {
         // Auto-placement (no kvmHostId specified)