@calltelemetry/ct-lab-mcp 0.1.0

package/dist/src/slot/manager.js

@@ -0,0 +1,650 @@
+/**
+ * Global Slot Allocation & Capacity Partitioning Engine
+ * Manages 8GB appliance slots across Proxmox VE and VMware ESXi hosts with hard partition limits,
+ * atomic concurrency locking (AsyncMutex), TTL lease management, and candidate slot ranking.
+ */
+import { randomUUID } from "node:crypto";
+import { CapacityExceededError, GlobalCapacityExceededError, SlotNotFoundError, LeaseCeilingExceededError, InvalidSlotOperationError, DatastoreCapacityExceededError } from "./types.js";
+import { AsyncMutex } from "../utils/mutex.js";
+export * from "./types.js";
+const DEFAULT_HOST_CONFIGS = [
+    {
+        hostId: "proxmox-lab",
+        name: "Proxmox Lab (Primary)",
+        hypervisorType: "proxmox",
+        totalMemoryMb: 32768, // 32 GB
+        reservedHeadroomMb: 16384, // 16 GB reserved for CUCM and system
+        maxSlots: 2, // Hard limit: 2 slots (16 GB)
+        slotSizeMb: 8192, // 8 GB per slot
+        freeDiskGb: 280,
+        totalDiskGb: 500
+    },
+    {
+        hostId: "proxmox-mini",
+        name: "Proxmox Mini (Minisforum)",
+        hypervisorType: "proxmox",
+        totalMemoryMb: 65536, // 64 GB
+        reservedHeadroomMb: 32768, // 32 GB reserved
+        maxSlots: 4, // Hard limit: 4 slots (32 GB)
+        slotSizeMb: 8192, // 8 GB per slot
+        freeDiskGb: 650,
+        totalDiskGb: 1000
+    }
+];
+export const DEFAULT_ESXI_HOST_CONFIG = {
+    hostId: "esxi-intel-192-168-123-176",
+    name: "ESXi Intel Lab (192.168.123.176)",
+    hypervisorType: "esxi",
+    totalMemoryMb: 131072, // 128 GB
+    reservedHeadroomMb: 65536, // 64 GB reserved
+    maxSlots: 8, // 8 slots (64 GB)
+    slotSizeMb: 8192,
+    freeDiskGb: 1200,
+    totalDiskGb: 1860,
+    datastoreFreeBytes: 1200 * 1024 * 1024 * 1024
+};
+export class SlotManager {
+    hosts = new Map();
+    slots = new Map();
+    mutex = new AsyncMutex();
+    defaultDurationMinutes;
+    proxmoxManager;
+    constructor(options = {}) {
+        this.defaultDurationMinutes = options.defaultDurationMinutes ?? 60;
+        this.proxmoxManager = options.proxmoxManager;
+        const hostConfigs = options.hosts && options.hosts.length > 0
+            ? options.hosts
+            : [...DEFAULT_HOST_CONFIGS];
+        if (options.includeEsxi && !hostConfigs.some((h) => h.hostId === "esxi-intel-192-168-123-176")) {
+            hostConfigs.push(DEFAULT_ESXI_HOST_CONFIG);
+        }
+        for (const host of hostConfigs) {
+            this.registerHost(host);
+        }
+    }
+    /**
+     * Register a host and initialize its slot definitions.
+     */
+    registerHost(host) {
+        const normalizedId = this.normalizeHostId(host.hostId);
+        const normalizedHost = {
+            ...host,
+            hostId: normalizedId,
+            hypervisorType: host.hypervisorType || (normalizedId.startsWith("esxi") ? "esxi" : "proxmox")
+        };
+        this.hosts.set(normalizedId, normalizedHost);
+        for (let index = 1; index <= normalizedHost.maxSlots; index++) {
+            const slotId = `slot-${normalizedId}-${index}`;
+            if (!this.slots.has(slotId)) {
+                this.slots.set(slotId, {
+                    slotId,
+                    hostId: normalizedId,
+                    hostName: normalizedHost.name,
+                    hypervisorType: normalizedHost.hypervisorType,
+                    slotIndex: index,
+                    memoryMb: normalizedHost.slotSizeMb,
+                    allocatedMemoryMb: normalizedHost.slotSizeMb,
+                    allocatedMemoryBytes: normalizedHost.slotSizeMb * 1024 * 1024,
+                    status: "AVAILABLE",
+                    claimId: null,
+                    claimedAt: null,
+                    expiresAt: null,
+                    durationMinutes: null,
+                    ttlMinutes: null,
+                    ttlSeconds: null,
+                    tag: null,
+                    requester: null,
+                    linearIssue: null,
+                    sessionId: null,
+                    purpose: null,
+                    vmId: null,
+                    vmName: null,
+                    metadata: {}
+                });
+            }
+        }
+    }
+    /**
+     * Normalizes host ID strings (e.g. mapping aliases like proxmox-minis-lab -> proxmox-mini).
+     */
+    normalizeHostId(hostId) {
+        if (hostId === "proxmox-minis-lab")
+            return "proxmox-mini";
+        return hostId;
+    }
+    /**
+     * Internal lazy expiration sweep (must be called inside mutex or synchronous method).
+     */
+    sweepExpiredSlotsInternal(now = Date.now()) {
+        let expiredCount = 0;
+        for (const slot of this.slots.values()) {
+            if ((slot.status === "CLAIMED" || slot.status === "active") && slot.expiresAt) {
+                const expiresTime = new Date(slot.expiresAt).getTime();
+                if (expiresTime <= now) {
+                    slot.status = "AVAILABLE";
+                    slot.claimId = null;
+                    slot.claimedAt = null;
+                    slot.expiresAt = null;
+                    slot.durationMinutes = null;
+                    slot.ttlMinutes = null;
+                    slot.ttlSeconds = null;
+                    slot.tag = null;
+                    slot.requester = null;
+                    slot.linearIssue = null;
+                    slot.sessionId = null;
+                    slot.purpose = null;
+                    slot.vmId = null;
+                    slot.vmName = null;
+                    slot.metadata = {};
+                    expiredCount++;
+                }
+            }
+        }
+        return expiredCount;
+    }
+    /**
+     * Atomically claims an 8GB appliance slot.
+     */
+    async claimSlot(request) {
+        return this.mutex.runExclusive(async () => {
+            // 1. Reclaim any expired leases first
+            this.sweepExpiredSlotsInternal();
+            const tagInput = request.tag || request.linearIssue || request.requester;
+            if (!tagInput || typeof tagInput !== "string" || tagInput.trim() === "") {
+                throw new InvalidSlotOperationError("A valid non-empty 'tag', 'linearIssue', or 'requester' is required to claim a slot.");
+            }
+            const durationMinutes = request.durationMinutes ?? request.ttlMinutes ?? (request.ttlSeconds ? Math.ceil(request.ttlSeconds / 60) : this.defaultDurationMinutes);
+            if (durationMinutes < 1 || durationMinutes > 1440) {
+                throw new InvalidSlotOperationError(`Claim duration must be between 1 and 1440 minutes (requested: ${durationMinutes}).`);
+            }
+            const rawRequestedHost = request.host || request.targetHost;
+            const requestedHost = rawRequestedHost ? this.normalizeHostId(rawRequestedHost) : undefined;
+            const hypervisorTypePref = request.hypervisorType || "any";
+            // If requestedHost is ESXi and not yet registered, register default ESXi config
+            if (requestedHost === "esxi-intel-192-168-123-176" && !this.hosts.has("esxi-intel-192-168-123-176")) {
+                this.registerHost(DEFAULT_ESXI_HOST_CONFIG);
+            }
+            let targetSlot;
+            if (requestedHost && requestedHost !== "auto") {
+                // Specific host claim
+                const hostConfig = this.hosts.get(requestedHost);
+                if (!hostConfig) {
+                    const validHosts = Array.from(this.hosts.keys()).join(", ");
+                    throw new InvalidSlotOperationError(`Unknown host '${requestedHost}' for slot allocation. Available: [${validHosts}]`);
+                }
+                // ESXi Datastore check (>= 10GB free required)
+                if (hostConfig.hypervisorType === "esxi") {
+                    const freeDisk = hostConfig.freeDiskGb ?? 100;
+                    if (freeDisk < 10) {
+                        throw new DatastoreCapacityExceededError(requestedHost, 10, freeDisk);
+                    }
+                }
+                const hostSlots = Array.from(this.slots.values())
+                    .filter((s) => s.hostId === requestedHost)
+                    .sort((a, b) => a.slotIndex - b.slotIndex);
+                const availableSlot = hostSlots.find((s) => s.status === "AVAILABLE");
+                if (!availableSlot) {
+                    const allocatedCount = hostSlots.filter((s) => s.status === "CLAIMED" || s.status === "active").length;
+                    if (requestedHost === "proxmox-lab") {
+                        throw new CapacityExceededError(`Host 'proxmox-lab' has reached its hard quota limit of 2 concurrent 8GB slots (16GB allocated). 16GB is strictly reserved for CUCM and core lab infrastructure.`, "proxmox-lab", hostConfig.maxSlots, allocatedCount);
+                    }
+                    else if (requestedHost === "proxmox-mini") {
+                        throw new CapacityExceededError(`Host 'proxmox-mini' has reached its hard quota limit of 4 concurrent 8GB slots (32GB allocated).`, "proxmox-mini", hostConfig.maxSlots, allocatedCount);
+                    }
+                    else {
+                        throw new CapacityExceededError(`Host '${requestedHost}' has reached its hard quota limit of ${hostConfig.maxSlots} concurrent slots.`, requestedHost, hostConfig.maxSlots, allocatedCount);
+                    }
+                }
+                targetSlot = availableSlot;
+            }
+            else {
+                // Deterministic Auto-Placement
+                // If hypervisorType is specified as esxi, auto-register default ESXi if not present
+                if (hypervisorTypePref === "esxi" && !this.hosts.has("esxi-intel-192-168-123-176")) {
+                    this.registerHost(DEFAULT_ESXI_HOST_CONFIG);
+                }
+                // Filter candidate hosts based on hypervisor preference
+                const candidateHostConfigs = Array.from(this.hosts.values()).filter((h) => {
+                    if (hypervisorTypePref === "proxmox" && h.hypervisorType !== "proxmox")
+                        return false;
+                    if (hypervisorTypePref === "esxi" && h.hypervisorType !== "esxi")
+                        return false;
+                    return true;
+                });
+                // Evaluate available slots and datastore health per host
+                const hostStats = candidateHostConfigs.map((h) => {
+                    const hostSlots = Array.from(this.slots.values()).filter((s) => s.hostId === h.hostId);
+                    const availableSlots = hostSlots.filter((s) => s.status === "AVAILABLE").length;
+                    const freeDiskGb = h.freeDiskGb ?? 100;
+                    const datastoreOk = h.hypervisorType !== "esxi" || freeDiskGb >= 10;
+                    return { host: h, availableSlots, hostSlots, datastoreOk };
+                });
+                const totalAvailable = hostStats.reduce((sum, h) => sum + (h.datastoreOk ? h.availableSlots : 0), 0);
+                if (totalAvailable <= 0) {
+                    if (hypervisorTypePref === "proxmox") {
+                        throw new CapacityExceededError("All Proxmox cluster slots are currently allocated (2/2 on proxmox-lab, 4/4 on proxmox-mini).", "proxmox-cluster", 6, 6);
+                    }
+                    throw new GlobalCapacityExceededError("All 6 cluster slots are currently allocated (2/2 on proxmox-lab, 4/4 on proxmox-mini).", 6, 6);
+                }
+                // Sort candidates:
+                // 1. Only datastoreOk hosts with availableSlots > 0
+                // 2. Descending by availableSlots (least loaded first)
+                // 3. Tie-Breaker: prefer proxmox-mini if tied with proxmox-lab
+                const validCandidates = hostStats.filter((h) => h.datastoreOk && h.availableSlots > 0);
+                validCandidates.sort((a, b) => {
+                    if (b.availableSlots !== a.availableSlots) {
+                        return b.availableSlots - a.availableSlots;
+                    }
+                    // Tie breaker: prefer proxmox-mini
+                    if (a.host.hostId === "proxmox-mini" && b.host.hostId !== "proxmox-mini")
+                        return -1;
+                    if (b.host.hostId === "proxmox-mini" && a.host.hostId !== "proxmox-mini")
+                        return 1;
+                    return 0;
+                });
+                const winningHostStat = validCandidates[0];
+                if (!winningHostStat) {
+                    throw new GlobalCapacityExceededError("All 6 cluster slots are currently allocated (2/2 on proxmox-lab, 4/4 on proxmox-mini).", 6, 6);
+                }
+                const availableSlotsOnWinner = winningHostStat.hostSlots
+                    .filter((s) => s.status === "AVAILABLE")
+                    .sort((a, b) => a.slotIndex - b.slotIndex);
+                targetSlot = availableSlotsOnWinner[0];
+            }
+            if (!targetSlot) {
+                throw new GlobalCapacityExceededError("All 6 cluster slots are currently allocated (2/2 on proxmox-lab, 4/4 on proxmox-mini).", 6, 6);
+            }
+            // Assign claim details
+            const claimId = `claim-${randomUUID().substring(0, 8)}`;
+            const now = new Date();
+            const claimedAt = now.toISOString();
+            const expiresAt = new Date(now.getTime() + durationMinutes * 60 * 1000).toISOString();
+            targetSlot.status = "CLAIMED";
+            targetSlot.claimId = claimId;
+            targetSlot.claimedAt = claimedAt;
+            targetSlot.expiresAt = expiresAt;
+            targetSlot.durationMinutes = durationMinutes;
+            targetSlot.ttlMinutes = durationMinutes;
+            targetSlot.ttlSeconds = durationMinutes * 60;
+            targetSlot.tag = (request.tag || tagInput).trim();
+            targetSlot.requester = request.requester || request.tag || null;
+            targetSlot.linearIssue = request.linearIssue || (request.tag && request.tag.startsWith("CTUAT-") ? request.tag : null);
+            targetSlot.sessionId = request.sessionId || null;
+            targetSlot.purpose = request.purpose || null;
+            targetSlot.metadata = request.metadata || {};
+            return {
+                claimId,
+                slotId: targetSlot.slotId,
+                hostId: targetSlot.hostId,
+                hostName: targetSlot.hostName || targetSlot.hostId,
+                hypervisorType: targetSlot.hypervisorType || (targetSlot.hostId.startsWith("esxi") ? "esxi" : "proxmox"),
+                slotIndex: targetSlot.slotIndex,
+                memoryMb: targetSlot.memoryMb,
+                allocatedMemoryMb: targetSlot.memoryMb,
+                allocatedMemoryBytes: targetSlot.memoryMb * 1024 * 1024,
+                tag: targetSlot.tag,
+                requester: targetSlot.requester || undefined,
+                linearIssue: targetSlot.linearIssue || undefined,
+                claimedAt,
+                expiresAt,
+                durationMinutes,
+                ttlMinutes: durationMinutes,
+                ttlSeconds: durationMinutes * 60,
+                status: "active",
+                purpose: targetSlot.purpose || undefined,
+                sessionId: targetSlot.sessionId || undefined
+            };
+        });
+    }
+    /**
+     * Releases one or more slots matching claimId, tag, slotId, requester, or linearIssue.
+     */
+    async releaseSlot(optionsOrClaimId, destroyVmFlag) {
+        return this.mutex.runExclusive(async () => {
+            this.sweepExpiredSlotsInternal();
+            let claimId;
+            let tag;
+            let slotId;
+            let sessionId;
+            let requester;
+            let linearIssue;
+            let destroyVm = destroyVmFlag;
+            if (typeof optionsOrClaimId === "string") {
+                const str = optionsOrClaimId.trim();
+                if (str.startsWith("claim-") || str.includes("-")) {
+                    // Check if claimId exists first
+                    const existsAsClaim = Array.from(this.slots.values()).some((s) => s.claimId === str);
+                    if (existsAsClaim) {
+                        claimId = str;
+                    }
+                    else if (str.startsWith("CTUAT-")) {
+                        linearIssue = str;
+                    }
+                    else {
+                        claimId = str;
+                    }
+                }
+                else {
+                    tag = str;
+                }
+            }
+            else if (optionsOrClaimId && typeof optionsOrClaimId === "object") {
+                claimId = optionsOrClaimId.claimId;
+                tag = optionsOrClaimId.tag;
+                slotId = optionsOrClaimId.slotId;
+                sessionId = optionsOrClaimId.sessionId;
+                requester = optionsOrClaimId.requester;
+                linearIssue = optionsOrClaimId.linearIssue;
+                if (optionsOrClaimId.destroyVm !== undefined) {
+                    destroyVm = optionsOrClaimId.destroyVm;
+                }
+            }
+            if (!claimId && !tag && !slotId && !requester && !linearIssue) {
+                throw new InvalidSlotOperationError("Must specify claimId, tag, slotId, requester, or linearIssue to release a slot.");
+            }
+            const matchingSlots = [];
+            for (const slot of this.slots.values()) {
+                if (slot.status !== "CLAIMED" && slot.status !== "active")
+                    continue;
+                let match = false;
+                if (claimId && slot.claimId === claimId)
+                    match = true;
+                if (slotId && slot.slotId === slotId)
+                    match = true;
+                if (tag && slot.tag === tag)
+                    match = true;
+                if (requester && (slot.requester === requester || slot.tag === requester))
+                    match = true;
+                if (linearIssue && (slot.linearIssue === linearIssue || slot.tag === linearIssue))
+                    match = true;
+                if (match) {
+                    if (sessionId && slot.sessionId && slot.sessionId !== sessionId) {
+                        throw new InvalidSlotOperationError(`Unauthorized: session '${sessionId}' does not own slot '${slot.slotId}' (owned by '${slot.sessionId}').`);
+                    }
+                    matchingSlots.push(slot);
+                }
+            }
+            if (matchingSlots.length === 0 && claimId) {
+                throw new SlotNotFoundError(`No active claimed slot found matching claimId '${claimId}'.`);
+            }
+            const releasedSnapshots = [];
+            const releasedClaims = [];
+            const destroyedVms = [];
+            let freedMemoryMb = 0;
+            for (const slot of matchingSlots) {
+                releasedSnapshots.push({ ...slot, status: "RELEASED" });
+                if (slot.claimId) {
+                    releasedClaims.push(slot.claimId);
+                }
+                freedMemoryMb += slot.memoryMb;
+                if (destroyVm && slot.vmId !== null && slot.vmId !== undefined) {
+                    destroyedVms.push(slot.vmId);
+                }
+                slot.status = "AVAILABLE";
+                slot.claimId = null;
+                slot.claimedAt = null;
+                slot.expiresAt = null;
+                slot.durationMinutes = null;
+                slot.ttlMinutes = null;
+                slot.ttlSeconds = null;
+                slot.tag = null;
+                slot.requester = null;
+                slot.linearIssue = null;
+                slot.sessionId = null;
+                slot.purpose = null;
+                slot.vmId = null;
+                slot.vmName = null;
+                slot.metadata = {};
+            }
+            return {
+                releasedCount: releasedSnapshots.length,
+                releasedSlots: releasedSnapshots,
+                releasedClaims,
+                destroyedVms,
+                freedMemoryMb,
+                message: `Successfully released ${releasedSnapshots.length} slot(s).`
+            };
+        });
+    }
+    /**
+     * Extends the lease of an active slot up to the 24h cumulative ceiling.
+     */
+    async extendLease(claimId, additionalMinutes, sessionId) {
+        return this.mutex.runExclusive(async () => {
+            this.sweepExpiredSlotsInternal();
+            if (!claimId) {
+                throw new InvalidSlotOperationError("A valid 'claimId' is required to extend a lease.");
+            }
+            if (!additionalMinutes || additionalMinutes <= 0) {
+                throw new InvalidSlotOperationError(`additionalMinutes must be greater than 0 (requested: ${additionalMinutes}).`);
+            }
+            const slot = Array.from(this.slots.values()).find((s) => s.claimId === claimId && (s.status === "CLAIMED" || s.status === "active"));
+            if (!slot || !slot.claimedAt || !slot.expiresAt) {
+                throw new SlotNotFoundError(`Active slot with claimId '${claimId}' not found.`);
+            }
+            if (sessionId && slot.sessionId && slot.sessionId !== sessionId) {
+                throw new InvalidSlotOperationError(`Unauthorized: session '${sessionId}' does not match slot owner '${slot.sessionId}'.`);
+            }
+            const initialTime = new Date(slot.claimedAt).getTime();
+            const currentExpiresTime = new Date(slot.expiresAt).getTime();
+            const newExpiresTime = currentExpiresTime + additionalMinutes * 60 * 1000;
+            const totalDurationMinutes = Math.round((newExpiresTime - initialTime) / (60 * 1000));
+            if (totalDurationMinutes > 1440) {
+                throw new LeaseCeilingExceededError(`Lease extension of ${additionalMinutes}m would exceed maximum 24h (1440m) ceiling. Total requested: ${totalDurationMinutes}m.`, 1440);
+            }
+            const previousExpiresAt = slot.expiresAt;
+            const newExpiresAt = new Date(newExpiresTime).toISOString();
+            slot.expiresAt = newExpiresAt;
+            slot.durationMinutes = totalDurationMinutes;
+            slot.ttlMinutes = totalDurationMinutes;
+            slot.ttlSeconds = totalDurationMinutes * 60;
+            return {
+                claimId,
+                slotId: slot.slotId,
+                hostId: slot.hostId,
+                slotIndex: slot.slotIndex,
+                previousExpiresAt,
+                newExpiresAt,
+                extendedByMinutes: additionalMinutes,
+                totalDurationMinutes
+            };
+        });
+    }
+    /**
+     * List slots with optional filtering and computed remaining TTL.
+     */
+    async listSlots(options = {}) {
+        return this.mutex.runExclusive(async () => {
+            this.sweepExpiredSlotsInternal();
+            const now = Date.now();
+            const results = [];
+            const filterHost = options.host || options.targetHost;
+            const normalizedFilterHost = filterHost ? this.normalizeHostId(filterHost) : undefined;
+            for (const slot of this.slots.values()) {
+                if (normalizedFilterHost && slot.hostId !== normalizedFilterHost)
+                    continue;
+                if (options.tag && slot.tag !== options.tag)
+                    continue;
+                if (options.requester && slot.requester !== options.requester && slot.tag !== options.requester)
+                    continue;
+                if (options.linearIssue && slot.linearIssue !== options.linearIssue && slot.tag !== options.linearIssue)
+                    continue;
+                if (options.activeOnly && slot.status !== "CLAIMED" && slot.status !== "active")
+                    continue;
+                if (options.hypervisorType &&
+                    options.hypervisorType !== "any" &&
+                    options.hypervisorType !== "all" &&
+                    slot.hypervisorType !== options.hypervisorType) {
+                    continue;
+                }
+                let remainingTtlSeconds = null;
+                if ((slot.status === "CLAIMED" || slot.status === "active") && slot.expiresAt) {
+                    const diffMs = new Date(slot.expiresAt).getTime() - now;
+                    remainingTtlSeconds = Math.max(0, Math.floor(diffMs / 1000));
+                }
+                results.push({
+                    ...slot,
+                    remainingTtlSeconds
+                });
+            }
+            // Sort by hostId then slotIndex
+            return results.sort((a, b) => {
+                if (a.hostId !== b.hostId)
+                    return a.hostId.localeCompare(b.hostId);
+                return a.slotIndex - b.slotIndex;
+            });
+        });
+    }
+    /**
+     * List host capacities or global cluster summary.
+     */
+    async listHosts(hostId) {
+        return this.mutex.runExclusive(async () => {
+            this.sweepExpiredSlotsInternal();
+            const normalizedHostId = hostId && hostId !== "all" ? this.normalizeHostId(hostId) : hostId;
+            // If specific ESXi host requested and not registered, auto-register
+            if (normalizedHostId === "esxi-intel-192-168-123-176" && !this.hosts.has("esxi-intel-192-168-123-176")) {
+                this.registerHost(DEFAULT_ESXI_HOST_CONFIG);
+            }
+            const now = Date.now();
+            const hostsSummary = {};
+            let clusterMaxSlots = 0;
+            let clusterAllocatedSlots = 0;
+            let clusterAvailableSlots = 0;
+            for (const [id, config] of this.hosts.entries()) {
+                const hostSlots = Array.from(this.slots.values())
+                    .filter((s) => s.hostId === id)
+                    .map((s) => {
+                    let remainingTtlSeconds = null;
+                    if ((s.status === "CLAIMED" || s.status === "active") && s.expiresAt) {
+                        const diffMs = new Date(s.expiresAt).getTime() - now;
+                        remainingTtlSeconds = Math.max(0, Math.floor(diffMs / 1000));
+                    }
+                    return { ...s, remainingTtlSeconds };
+                })
+                    .sort((a, b) => a.slotIndex - b.slotIndex);
+                const activeSlots = hostSlots.filter((s) => s.status === "CLAIMED" || s.status === "active");
+                const allocatedSlots = activeSlots.length;
+                const availableSlots = config.maxSlots - allocatedSlots;
+                clusterMaxSlots += config.maxSlots;
+                clusterAllocatedSlots += allocatedSlots;
+                clusterAvailableSlots += availableSlots;
+                hostsSummary[id] = {
+                    hostId: id,
+                    name: config.name,
+                    hypervisorType: config.hypervisorType,
+                    totalMemoryMb: config.totalMemoryMb,
+                    reservedHeadroomMb: config.reservedHeadroomMb,
+                    maxSlots: config.maxSlots,
+                    allocatedSlots,
+                    availableSlots,
+                    slotSizeMb: config.slotSizeMb,
+                    freeDiskGb: config.freeDiskGb,
+                    totalDiskGb: config.totalDiskGb,
+                    datastoreFreeBytes: config.datastoreFreeBytes,
+                    activeSlots
+                };
+            }
+            if (normalizedHostId && normalizedHostId !== "all") {
+                const single = hostsSummary[normalizedHostId];
+                if (!single) {
+                    throw new InvalidSlotOperationError(`Host '${normalizedHostId}' not found.`);
+                }
+                return single;
+            }
+            return {
+                clusterMaxSlots,
+                clusterAllocatedSlots,
+                clusterAvailableSlots,
+                hosts: hostsSummary
+            };
+        });
+    }
+    /**
+     * Returns available slot capacity report conforming to ISlotManager.getAvailableSlots.
+     */
+    async getAvailableSlots(hostName) {
+        const summary = await this.listHosts(hostName);
+        if ("allocatedSlots" in summary) {
+            return summary;
+        }
+        return {
+            maxSlots: summary.clusterMaxSlots,
+            usedSlots: summary.clusterAllocatedSlots,
+            allocatedSlots: summary.clusterAllocatedSlots,
+            availableSlots: summary.clusterAvailableSlots,
+            slotSizeBytes: 8192 * 1024 * 1024,
+            slotSizeMb: 8192,
+            hosts: summary.hosts
+        };
+    }
+    /**
+     * Reclaim all expired slots and return count.
+     */
+    async reclaimExpired() {
+        return this.mutex.runExclusive(async () => {
+            return this.sweepExpiredSlotsInternal();
+        });
+    }
+    /**
+     * Attach a created VMID or VM name to a claimed slot.
+     */
+    async attachVm(claimId, vmId, vmName) {
+        return this.mutex.runExclusive(async () => {
+            this.sweepExpiredSlotsInternal();
+            const slot = Array.from(this.slots.values()).find((s) => s.claimId === claimId && (s.status === "CLAIMED" || s.status === "active"));
+            if (!slot) {
+                throw new SlotNotFoundError(`Active slot with claimId '${claimId}' not found.`);
+            }
+            slot.vmId = vmId;
+            if (vmName)
+                slot.vmName = vmName;
+            return { ...slot };
+        });
+    }
+    /**
+     * Lookup single slot by slotId.
+     */
+    async getSlot(slotId) {
+        return this.mutex.runExclusive(async () => {
+            this.sweepExpiredSlotsInternal();
+            const slot = this.slots.get(slotId);
+            return slot ? { ...slot } : null;
+        });
+    }
+    /**
+     * Lookup slot by active claimId.
+     */
+    async getSlotByClaimId(claimId) {
+        return this.mutex.runExclusive(async () => {
+            this.sweepExpiredSlotsInternal();
+            const slot = Array.from(this.slots.values()).find((s) => s.claimId === claimId && (s.status === "CLAIMED" || s.status === "active"));
+            return slot ? { ...slot } : null;
+        });
+    }
+    /**
+     * Clears all claims (primarily for test resets).
+     */
+    async clearAll() {
+        await this.mutex.runExclusive(async () => {
+            for (const slot of this.slots.values()) {
+                slot.status = "AVAILABLE";
+                slot.claimId = null;
+                slot.claimedAt = null;
+                slot.expiresAt = null;
+                slot.durationMinutes = null;
+                slot.ttlMinutes = null;
+                slot.ttlSeconds = null;
+                slot.tag = null;
+                slot.requester = null;
+                slot.linearIssue = null;
+                slot.sessionId = null;
+                slot.purpose = null;
+                slot.vmId = null;
+                slot.vmName = null;
+                slot.metadata = {};
+            }
+        });
+    }
+}
+//# sourceMappingURL=manager.js.map