@calltelemetry/ct-lab-mcp 0.1.4 → 0.2.0

package/dist/src/tools/storage-tools.js

@@ -0,0 +1,685 @@
+/**
+ * Storage & Datastore Management MCP Tools
+ *
+ * Tools:
+ * 1. list_storage - Query datastores, pools, free space, and volume contents
+ * 2. list_snapshots - Query VM snapshots across Proxmox and ESXi hosts
+ * 3. clean_storage - Delete unreferenced disks, stale ISOs, or snapshots with safety guardrails
+ */
+import { z } from "zod";
+import { ProxmoxErrorCode, createToolErrorResult } from "../types/mcp.js";
+import { logger } from "../utils/logger.js";
+import { telemetry } from "../telemetry/registry.js";
+// ============================================================================
+// 1. list_storage
+// ============================================================================
+export const ListStorageInputShape = {
+    host: z
+        .enum(["proxmox-lab", "proxmox-mini", "proxmox-minis-lab", "esxi-intel-192-168-123-176", "all"])
+        .optional()
+        .default("all")
+        .describe("Specific host or 'all' to inspect."),
+    includeContent: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Whether to list detailed volume contents (ISOs, VM disks, backups) inside storage pools."),
+    storage: z
+        .string()
+        .optional()
+        .describe("Filter to a specific storage pool name (e.g. 'local', 'local-lvm', 'synology-cisco-isos').")
+};
+export const ListStorageInputSchema = z.object(ListStorageInputShape);
+export async function handleListStorage(args, context) {
+    const parsed = ListStorageInputSchema.safeParse(args || {});
+    if (!parsed.success) {
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "Invalid arguments for list_storage.");
+    }
+    const { host, includeContent, storage: targetStorage } = parsed.data;
+    const drivers = context.hypervisorManager?.getAllDrivers() || [];
+    const matchedDrivers = drivers.filter((d) => {
+        if (host === "all")
+            return true;
+        return d.hostName === host || (host === "proxmox-mini" && d.hostName === "proxmox-minis-lab");
+    });
+    if (matchedDrivers.length === 0) {
+        return createToolErrorResult(ProxmoxErrorCode.HOST_NOT_FOUND, `No matching hypervisor driver found for host '${host}'.`);
+    }
+    const allPools = [];
+    const allContents = [];
+    for (const driver of matchedDrivers) {
+        if (driver.listStorage) {
+            try {
+                const pools = await driver.listStorage();
+                for (const p of pools) {
+                    if (!targetStorage || p.storage.toLowerCase() === targetStorage.toLowerCase()) {
+                        allPools.push(p);
+                        if (includeContent && driver.listStorageContent && p.active) {
+                            try {
+                                const contents = await driver.listStorageContent(p.storage);
+                                allContents.push(...contents);
+                            }
+                            catch (err) {
+                                logger.warn(`Failed to query storage content for pool ${p.storage} on ${driver.hostName}:`, err.message);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logger.error(`Failed to list storage for ${driver.hostName}:`, err.message);
+            }
+        }
+    }
+    const markdown = formatStorageReport(allPools, allContents);
+    return {
+        content: [{ type: "text", text: markdown }],
+        structuredContent: {
+            success: true,
+            totalPools: allPools.length,
+            pools: allPools,
+            contents: allContents
+        }
+    };
+}
+function formatStorageReport(pools, contents) {
+    if (pools.length === 0) {
+        return "### 💾 Lab Storage Pools\n\nNo storage pools found.";
+    }
+    const poolRows = pools.map((p) => {
+        const totalGb = (p.totalBytes / (1024 * 1024 * 1024)).toFixed(1);
+        const usedGb = (p.usedBytes / (1024 * 1024 * 1024)).toFixed(1);
+        const availGb = (p.availableBytes / (1024 * 1024 * 1024)).toFixed(1);
+        const pct = Math.round(p.usedFraction * 100);
+        const statusIcon = pct > 85 ? "🔴" : pct > 70 ? "🟡" : "🟢";
+        return `| **\`${p.hostName}\`** | **\`${p.storage}\`** | \`${p.type}\` | ${totalGb} GB | ${usedGb} GB (${pct}%) | **${availGb} GB** | ${statusIcon} ${p.active ? "Active" : "Inactive"} | \`${p.content}\` |`;
+    }).join("\n");
+    let contentSection = "";
+    if (contents.length > 0) {
+        const contentRows = contents.map((c) => {
+            const sizeGb = (c.sizeBytes / (1024 * 1024 * 1024)).toFixed(2);
+            const vmidStr = c.vmid ? `VM ${c.vmid}` : "N/A (Host/ISO)";
+            return `| \`${c.hostName}\` | \`${c.storage}\` | **\`${c.volid}\`** | ${sizeGb} GB | \`${c.content}\` | ${vmidStr} |`;
+        }).join("\n");
+        contentSection = `\n\n#### 📦 Storage Volume & ISO Content Breakdown\n\n| Host | Storage | Volume ID / ISO | Size | Type | Owner |\n|---|---|---|:---:|:---:|:---:|\n${contentRows}`;
+    }
+    return `### 💾 Lab Storage Pools & Datastore Analysis
+
+| Host | Storage Pool | Type | Total | Used (%) | Free Space | Status | Content Types |
+|---|---|:---:|:---:|:---:|:---:|:---:|---|
+${poolRows}${contentSection}`;
+}
+// ============================================================================
+// 2. list_snapshots
+// ============================================================================
+export const ListSnapshotsInputShape = {
+    host: z
+        .enum(["proxmox-lab", "proxmox-mini", "proxmox-minis-lab", "esxi-intel-192-168-123-176", "all"])
+        .optional()
+        .default("all")
+        .describe("Specific host or 'all'."),
+    vmId: z
+        .string()
+        .optional()
+        .describe("Specific VM ID or name to inspect snapshots for.")
+};
+export const ListSnapshotsInputSchema = z.object(ListSnapshotsInputShape);
+export async function handleListSnapshots(args, context) {
+    const parsed = ListSnapshotsInputSchema.safeParse(args || {});
+    if (!parsed.success) {
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "Invalid arguments for list_snapshots.");
+    }
+    const { host, vmId } = parsed.data;
+    const drivers = context.hypervisorManager?.getAllDrivers() || [];
+    const matchedDrivers = drivers.filter((d) => {
+        if (host === "all")
+            return true;
+        return d.hostName === host || (host === "proxmox-mini" && d.hostName === "proxmox-minis-lab");
+    });
+    const allSnapshots = [];
+    for (const driver of matchedDrivers) {
+        if (driver.listSnapshots) {
+            if (vmId) {
+                try {
+                    const snaps = await driver.listSnapshots(vmId);
+                    allSnapshots.push(...snaps);
+                }
+                catch (err) {
+                    logger.warn(`Failed to get snapshots for VM ${vmId} on ${driver.hostName}:`, err.message);
+                }
+            }
+            else {
+                const vms = await driver.listVms();
+                for (const vm of vms) {
+                    try {
+                        const snaps = await driver.listSnapshots(vm.id);
+                        allSnapshots.push(...snaps);
+                    }
+                    catch { }
+                }
+            }
+        }
+    }
+    const rows = allSnapshots.map((s) => {
+        const dateStr = s.snapdate ? s.snapdate.split("T")[0] : "Unknown";
+        return `| \`${s.hostName}\` | **${s.vmName}** (\`${s.vmId}\`) | **\`${s.name}\`** | ${dateStr} | ${s.description || "None"} | ${s.vmstate ? "RAM Included" : "Disk Only"} |`;
+    }).join("\n");
+    const markdown = allSnapshots.length === 0
+        ? "### 📸 VM Snapshots Analysis\n\nNo VM snapshots found across inspected hosts."
+        : `### 📸 VM Snapshots Analysis (${allSnapshots.length} Found)\n\n| Host | VM Name | Snapshot Name | Date | Description | State |\n|---|---|---|:---:|---|:---:|\n${rows}`;
+    return {
+        content: [{ type: "text", text: markdown }],
+        structuredContent: {
+            success: true,
+            totalSnapshots: allSnapshots.length,
+            snapshots: allSnapshots
+        }
+    };
+}
+// ============================================================================
+// 3. clean_storage
+// ============================================================================
+export const CleanStorageInputShape = {
+    host: z
+        .enum(["proxmox-lab", "proxmox-mini", "proxmox-minis-lab", "esxi-intel-192-168-123-176"])
+        .describe("Target hypervisor host where the volume or snapshot resides."),
+    action: z
+        .enum(["delete_volume", "delete_snapshot"])
+        .describe("Action to perform: 'delete_volume' (e.g. stale ISO/disk) or 'delete_snapshot'."),
+    volumeId: z
+        .string()
+        .optional()
+        .describe("Volume ID to delete (e.g. 'local:iso/AlmaLinux-9-latest-x86_64-dvd.iso' or 'local-lvm:vm-105-disk-0'). Required if action is 'delete_volume'."),
+    vmId: z
+        .string()
+        .optional()
+        .describe("VM ID for snapshot deletion. Required if action is 'delete_snapshot'."),
+    snapshotName: z
+        .string()
+        .optional()
+        .describe("Snapshot name to delete. Required if action is 'delete_snapshot'.")
+};
+export const CleanStorageInputSchema = z.object(CleanStorageInputShape);
+export async function handleCleanStorage(args, context) {
+    const parsed = CleanStorageInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "Invalid arguments for clean_storage.");
+    }
+    const { host, action, volumeId, vmId, snapshotName } = parsed.data;
+    const driver = context.hypervisorManager?.getDriver(host);
+    if (!driver) {
+        return createToolErrorResult(ProxmoxErrorCode.HOST_NOT_FOUND, `Hypervisor host '${host}' not found.`);
+    }
+    try {
+        if (action === "delete_volume") {
+            if (!volumeId) {
+                return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "'volumeId' is required for action 'delete_volume'.");
+            }
+            if (!driver.deleteVolume) {
+                return createToolErrorResult(ProxmoxErrorCode.OPERATION_NOT_SUPPORTED, `Host '${host}' does not support direct volume deletion.`);
+            }
+            logger.info(`Deleting volume '${volumeId}' on host '${host}'...`);
+            await driver.deleteVolume(volumeId);
+            telemetry.emit({
+                event: "storage.delete_volume",
+                actor: "ct-lab-mcp",
+                status: "success",
+                hostId: host,
+                metadata: { volumeId }
+            });
+            return {
+                content: [{ type: "text", text: `### 🗑️ Volume Deleted Successfully\n\nVolume **\`${volumeId}\`** was deleted from host **\`${host}\`**.` }],
+                structuredContent: { success: true, host, volumeId }
+            };
+        }
+        if (action === "delete_snapshot") {
+            if (!vmId || !snapshotName) {
+                return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "'vmId' and 'snapshotName' are required for action 'delete_snapshot'.");
+            }
+            if (!driver.deleteSnapshot) {
+                return createToolErrorResult(ProxmoxErrorCode.OPERATION_NOT_SUPPORTED, `Host '${host}' does not support snapshot deletion.`);
+            }
+            logger.info(`Deleting snapshot '${snapshotName}' on VM '${vmId}' (${host})...`);
+            await driver.deleteSnapshot(vmId, snapshotName);
+            telemetry.emit({
+                event: "storage.delete_snapshot",
+                actor: "ct-lab-mcp",
+                status: "success",
+                hostId: host,
+                vmId,
+                metadata: { snapshotName }
+            });
+            return {
+                content: [{ type: "text", text: `### 🗑️ Snapshot Deleted Successfully\n\nSnapshot **\`${snapshotName}\`** on VM **\`${vmId}\`** (${host}) was deleted.` }],
+                structuredContent: { success: true, host, vmId, snapshotName }
+            };
+        }
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, `Unknown action '${action}'.`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.error(`clean_storage failed on ${host}: ${msg}`);
+        return createToolErrorResult(ProxmoxErrorCode.VM_ACTION_FAILED, `Failed to clean storage on '${host}': ${msg}`);
+    }
+}
+// ============================================================================
+// 4. get_vm_storage
+// ============================================================================
+export const GetVmStorageInputShape = {
+    target: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("VM ID or name to query storage for (e.g. '105' or 'ct-appliance-slot2-thin')."),
+    vmIdOrName: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Alias for target."),
+    host: z
+        .enum(["proxmox-lab", "proxmox-mini", "proxmox-minis-lab", "esxi-intel-192-168-123-176", "auto"])
+        .optional()
+        .default("auto")
+        .describe("Hypervisor host or 'auto' to auto-discover.")
+};
+export const GetVmStorageInputSchema = z
+    .object(GetVmStorageInputShape)
+    .refine((data) => Boolean(data.target || data.vmIdOrName), { message: "VM target ('target' or 'vmIdOrName') is required." });
+export async function handleGetVmStorage(args, context) {
+    const parsed = GetVmStorageInputSchema.safeParse(args || {});
+    if (!parsed.success) {
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "Invalid arguments for get_vm_storage.");
+    }
+    const target = parsed.data.target || parsed.data.vmIdOrName;
+    const targetHost = parsed.data.host;
+    const drivers = context.hypervisorManager?.getAllDrivers() || [];
+    let foundDriver = targetHost && targetHost !== "auto"
+        ? drivers.find(d => d.hostName === targetHost || (targetHost === "proxmox-mini" && d.hostName === "proxmox-minis-lab"))
+        : null;
+    let vmRecord = null;
+    if (foundDriver) {
+        vmRecord = await foundDriver.getVm(target);
+    }
+    else {
+        for (const d of drivers) {
+            const vm = await d.getVm(target);
+            if (vm) {
+                foundDriver = d;
+                vmRecord = vm;
+                break;
+            }
+        }
+    }
+    if (!foundDriver || !vmRecord) {
+        return createToolErrorResult(ProxmoxErrorCode.VM_NOT_FOUND, `VM '${target}' was not found on any hypervisor host.`);
+    }
+    if (!foundDriver.getVmStorage) {
+        return createToolErrorResult(ProxmoxErrorCode.OPERATION_NOT_SUPPORTED, `Host '${foundDriver.hostName}' does not support getVmStorage.`);
+    }
+    try {
+        const report = await foundDriver.getVmStorage(vmRecord.id);
+        // Format Markdown tables
+        const diskRows = report.disks.map((d) => {
+            const sizeStr = d.sizeGb ? `${d.sizeGb.toFixed(1)} GB` : "Unknown";
+            const flags = [d.discard ? "discard" : null, d.ssd ? "ssd" : null].filter(Boolean).join(", ");
+            return `| **\`${d.drive}\`** | \`${d.storage}\` | **\`${d.volid}\`** | ${sizeStr} | \`${d.format}\` | ${flags || "standard"} |`;
+        }).join("\n");
+        const cdromRows = report.cdroms.map((c) => {
+            const mediaStr = c.volid === "none" || !c.volid ? "*(Empty / Ejected)*" : `**\`${c.volid}\`**`;
+            return `| **\`${c.drive}\`** | ${mediaStr} | \`${c.storage}\` | \`cdrom\` |`;
+        }).join("\n");
+        let fsSection = "";
+        if (report.guestFilesystems && report.guestFilesystems.length > 0) {
+            const fsRows = report.guestFilesystems.map((fs) => {
+                const totalGb = (fs.totalBytes / (1024 * 1024 * 1024)).toFixed(2);
+                const usedGb = (fs.usedBytes / (1024 * 1024 * 1024)).toFixed(2);
+                const availGb = (fs.availableBytes / (1024 * 1024 * 1024)).toFixed(2);
+                const icon = fs.usedPercent > 85 ? "🔴" : fs.usedPercent > 70 ? "🟡" : "🟢";
+                return `| **\`${fs.mountPoint}\`** | \`${fs.fsType}\` | ${totalGb} GB | ${usedGb} GB (${fs.usedPercent}%) | **${availGb} GB** | ${icon} | \`${fs.diskDevice || "N/A"}\` |`;
+            }).join("\n");
+            fsSection = `\n\n#### 💽 Live Guest OS Filesystems (QEMU Agent)\n\n| Mount Point | Type | Total | Used (%) | Free | Status | Device |\n|---|:---:|:---:|:---:|:---:|:---:|:---:|\n${fsRows}`;
+        }
+        else {
+            fsSection = `\n\n*Guest Filesystem Info: ${report.status === "running" ? "QEMU Agent not responding / initializing" : "VM is stopped"}*`;
+        }
+        const markdown = `### 💾 VM Storage & Filesystem Analysis: **${report.vmName}** (\`${report.vmId}\`)
+
+*Host:* \`${report.hostName}\` | *Status:* **${report.status}** | *Guest Agent:* **${report.guestAgentActive ? "🟢 Active" : "⚪ Offline"}**
+
+#### 🗄️ Hypervisor Virtual Disks
+| Drive | Storage Pool | Volume ID | Size | Format | Flags |
+|---|---|---|:---:|:---:|:---:|
+${diskRows || "| - | No virtual disks attached | - | - | - | - |"}
+
+#### 💿 Optical Drives & Mounted Media (CD-ROM)
+| Drive | Mounted Media / ISO | Storage Pool | Type |
+|---|---|---|:---:|
+${cdromRows || "| - | No CD-ROM drives configured | - | - |"}${fsSection}`;
+        return {
+            content: [{ type: "text", text: markdown }],
+            structuredContent: {
+                success: true,
+                report
+            }
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return createToolErrorResult(ProxmoxErrorCode.UPSTREAM_API_ERROR, `Failed to query VM storage for '${target}': ${msg}`);
+    }
+}
+// ============================================================================
+// 5. mount_iso
+// ============================================================================
+export const MountIsoInputShape = {
+    target: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Target VM ID or name to mount ISO onto (e.g. '105' or 'ct-appliance-slot2-thin')."),
+    vmIdOrName: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Alias for target."),
+    iso: z
+        .string()
+        .describe("ISO Volume ID to mount (e.g. 'synology-cisco-isos:iso/c8000v-universalk9.17.18.02.iso' or 'local:iso/cube-pmx-internal-bootstrap.iso')."),
+    drive: z
+        .string()
+        .optional()
+        .default("ide2")
+        .describe("CD-ROM drive identifier (default: 'ide2')."),
+    host: z
+        .enum(["proxmox-lab", "proxmox-mini", "proxmox-minis-lab", "esxi-intel-192-168-123-176", "auto"])
+        .optional()
+        .default("auto")
+        .describe("Hypervisor host or 'auto'.")
+};
+export const MountIsoInputSchema = z
+    .object(MountIsoInputShape)
+    .refine((data) => Boolean(data.target || data.vmIdOrName), { message: "VM target ('target' or 'vmIdOrName') is required." });
+export async function handleMountIso(args, context) {
+    const parsed = MountIsoInputSchema.safeParse(args || {});
+    if (!parsed.success) {
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "Invalid arguments for mount_iso.");
+    }
+    const target = parsed.data.target || parsed.data.vmIdOrName;
+    const { iso, drive, host: targetHost } = parsed.data;
+    const drivers = context.hypervisorManager?.getAllDrivers() || [];
+    let foundDriver = targetHost && targetHost !== "auto"
+        ? drivers.find(d => d.hostName === targetHost || (targetHost === "proxmox-mini" && d.hostName === "proxmox-minis-lab"))
+        : null;
+    let vmRecord = null;
+    if (foundDriver) {
+        vmRecord = await foundDriver.getVm(target);
+    }
+    else {
+        for (const d of drivers) {
+            const vm = await d.getVm(target);
+            if (vm) {
+                foundDriver = d;
+                vmRecord = vm;
+                break;
+            }
+        }
+    }
+    if (!foundDriver || !vmRecord) {
+        return createToolErrorResult(ProxmoxErrorCode.VM_NOT_FOUND, `VM '${target}' not found.`);
+    }
+    if (!foundDriver.mountIso) {
+        return createToolErrorResult(ProxmoxErrorCode.OPERATION_NOT_SUPPORTED, `Host '${foundDriver.hostName}' does not support mountIso.`);
+    }
+    try {
+        await foundDriver.mountIso(vmRecord.id, iso, drive);
+        telemetry.emit({
+            event: "storage.mount_iso",
+            actor: "ct-lab-mcp",
+            status: "success",
+            hostId: foundDriver.hostName,
+            vmId: vmRecord.id,
+            metadata: { iso, drive }
+        });
+        return {
+            content: [{ type: "text", text: `### 💿 ISO Mounted Successfully\n\nISO **\`${iso}\`** was mounted to drive **\`${drive}\`** on VM **${vmRecord.name}** (\`${vmRecord.id}\`) on host \`${foundDriver.hostName}\`.` }],
+            structuredContent: { success: true, host: foundDriver.hostName, vmId: vmRecord.id, vmName: vmRecord.name, iso, drive }
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return createToolErrorResult(ProxmoxErrorCode.VM_ACTION_FAILED, `Failed to mount ISO on VM '${target}': ${msg}`);
+    }
+}
+// ============================================================================
+// 6. unmount_iso
+// ============================================================================
+export const UnmountIsoInputShape = {
+    target: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Target VM ID or name to unmount ISO from (e.g. '105')."),
+    vmIdOrName: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Alias for target."),
+    drive: z
+        .string()
+        .optional()
+        .default("ide2")
+        .describe("CD-ROM drive identifier (default: 'ide2')."),
+    host: z
+        .enum(["proxmox-lab", "proxmox-mini", "proxmox-minis-lab", "esxi-intel-192-168-123-176", "auto"])
+        .optional()
+        .default("auto")
+        .describe("Hypervisor host or 'auto'.")
+};
+export const UnmountIsoInputSchema = z
+    .object(UnmountIsoInputShape)
+    .refine((data) => Boolean(data.target || data.vmIdOrName), { message: "VM target ('target' or 'vmIdOrName') is required." });
+export async function handleUnmountIso(args, context) {
+    const parsed = UnmountIsoInputSchema.safeParse(args || {});
+    if (!parsed.success) {
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "Invalid arguments for unmount_iso.");
+    }
+    const target = parsed.data.target || parsed.data.vmIdOrName;
+    const { drive, host: targetHost } = parsed.data;
+    const drivers = context.hypervisorManager?.getAllDrivers() || [];
+    let foundDriver = targetHost && targetHost !== "auto"
+        ? drivers.find(d => d.hostName === targetHost || (targetHost === "proxmox-mini" && d.hostName === "proxmox-minis-lab"))
+        : null;
+    let vmRecord = null;
+    if (foundDriver) {
+        vmRecord = await foundDriver.getVm(target);
+    }
+    else {
+        for (const d of drivers) {
+            const vm = await d.getVm(target);
+            if (vm) {
+                foundDriver = d;
+                vmRecord = vm;
+                break;
+            }
+        }
+    }
+    if (!foundDriver || !vmRecord) {
+        return createToolErrorResult(ProxmoxErrorCode.VM_NOT_FOUND, `VM '${target}' not found.`);
+    }
+    if (!foundDriver.unmountIso) {
+        return createToolErrorResult(ProxmoxErrorCode.OPERATION_NOT_SUPPORTED, `Host '${foundDriver.hostName}' does not support unmountIso.`);
+    }
+    try {
+        await foundDriver.unmountIso(vmRecord.id, drive);
+        telemetry.emit({
+            event: "storage.unmount_iso",
+            actor: "ct-lab-mcp",
+            status: "success",
+            hostId: foundDriver.hostName,
+            vmId: vmRecord.id,
+            metadata: { drive }
+        });
+        return {
+            content: [{ type: "text", text: `### ⏏️ CD-ROM Drive Ejected\n\nDrive **\`${drive}\`** on VM **${vmRecord.name}** (\`${vmRecord.id}\`) on host \`${foundDriver.hostName}\` was unmounted / ejected.` }],
+            structuredContent: { success: true, host: foundDriver.hostName, vmId: vmRecord.id, vmName: vmRecord.name, drive }
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return createToolErrorResult(ProxmoxErrorCode.VM_ACTION_FAILED, `Failed to unmount ISO on VM '${target}': ${msg}`);
+    }
+}
+// ============================================================================
+// 7. create_snapshot
+// ============================================================================
+export const CreateSnapshotInputShape = {
+    target: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Target VM ID or name to snapshot (e.g. '105' or 'ct-appliance-slot2-thin')."),
+    vmIdOrName: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Alias for target."),
+    snapshotName: z
+        .string()
+        .describe("Name for the new snapshot (e.g. 'pre-upgrade', 'clean-base')."),
+    description: z
+        .string()
+        .optional()
+        .describe("Optional human-readable description for the snapshot."),
+    includeRam: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Whether to include RAM / live memory state in the snapshot (default: false)."),
+    host: z
+        .enum(["proxmox-lab", "proxmox-mini", "proxmox-minis-lab", "esxi-intel-192-168-123-176", "auto"])
+        .optional()
+        .default("auto")
+        .describe("Hypervisor host or 'auto'.")
+};
+export const CreateSnapshotInputSchema = z
+    .object(CreateSnapshotInputShape)
+    .refine((data) => Boolean(data.target || data.vmIdOrName), { message: "VM target ('target' or 'vmIdOrName') is required." });
+export async function handleCreateSnapshot(args, context) {
+    const parsed = CreateSnapshotInputSchema.safeParse(args || {});
+    if (!parsed.success) {
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "Invalid arguments for create_snapshot.");
+    }
+    const target = parsed.data.target || parsed.data.vmIdOrName;
+    const { snapshotName, description, includeRam, host: targetHost } = parsed.data;
+    const drivers = context.hypervisorManager?.getAllDrivers() || [];
+    let foundDriver = targetHost && targetHost !== "auto"
+        ? drivers.find(d => d.hostName === targetHost || (targetHost === "proxmox-mini" && d.hostName === "proxmox-minis-lab"))
+        : null;
+    let vmRecord = null;
+    if (foundDriver) {
+        vmRecord = await foundDriver.getVm(target);
+    }
+    else {
+        for (const d of drivers) {
+            const vm = await d.getVm(target);
+            if (vm) {
+                foundDriver = d;
+                vmRecord = vm;
+                break;
+            }
+        }
+    }
+    if (!foundDriver || !vmRecord) {
+        return createToolErrorResult(ProxmoxErrorCode.VM_NOT_FOUND, `VM '${target}' not found.`);
+    }
+    if (!foundDriver.createSnapshot) {
+        return createToolErrorResult(ProxmoxErrorCode.OPERATION_NOT_SUPPORTED, `Host '${foundDriver.hostName}' does not support createSnapshot.`);
+    }
+    try {
+        await foundDriver.createSnapshot(vmRecord.id, snapshotName, description, includeRam);
+        telemetry.emit({
+            event: "storage.create_snapshot",
+            actor: "ct-lab-mcp",
+            status: "success",
+            hostId: foundDriver.hostName,
+            vmId: vmRecord.id,
+            metadata: { snapshotName, includeRam }
+        });
+        return {
+            content: [{ type: "text", text: `### 📸 Snapshot Created Successfully\n\nSnapshot **\`${snapshotName}\`** was created for VM **${vmRecord.name}** (\`${vmRecord.id}\`) on host \`${foundDriver.hostName}\`.\n*RAM State:* ${includeRam ? "Included" : "Disk Only"}\n*Description:* ${description || "None"}` }],
+            structuredContent: { success: true, host: foundDriver.hostName, vmId: vmRecord.id, vmName: vmRecord.name, snapshotName, includeRam, description }
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return createToolErrorResult(ProxmoxErrorCode.VM_ACTION_FAILED, `Failed to create snapshot '${snapshotName}' on VM '${target}': ${msg}`);
+    }
+}
+// ============================================================================
+// 8. rollback_snapshot
+// ============================================================================
+export const RollbackSnapshotInputShape = {
+    target: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Target VM ID or name to rollback (e.g. '105')."),
+    vmIdOrName: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Alias for target."),
+    snapshotName: z
+        .string()
+        .describe("Name of the snapshot to rollback / revert to (e.g. 'clean-base')."),
+    host: z
+        .enum(["proxmox-lab", "proxmox-mini", "proxmox-minis-lab", "esxi-intel-192-168-123-176", "auto"])
+        .optional()
+        .default("auto")
+        .describe("Hypervisor host or 'auto'.")
+};
+export const RollbackSnapshotInputSchema = z
+    .object(RollbackSnapshotInputShape)
+    .refine((data) => Boolean(data.target || data.vmIdOrName), { message: "VM target ('target' or 'vmIdOrName') is required." });
+export async function handleRollbackSnapshot(args, context) {
+    const parsed = RollbackSnapshotInputSchema.safeParse(args || {});
+    if (!parsed.success) {
+        return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, "Invalid arguments for rollback_snapshot.");
+    }
+    const target = parsed.data.target || parsed.data.vmIdOrName;
+    const { snapshotName, host: targetHost } = parsed.data;
+    const drivers = context.hypervisorManager?.getAllDrivers() || [];
+    let foundDriver = targetHost && targetHost !== "auto"
+        ? drivers.find(d => d.hostName === targetHost || (targetHost === "proxmox-mini" && d.hostName === "proxmox-minis-lab"))
+        : null;
+    let vmRecord = null;
+    if (foundDriver) {
+        vmRecord = await foundDriver.getVm(target);
+    }
+    else {
+        for (const d of drivers) {
+            const vm = await d.getVm(target);
+            if (vm) {
+                foundDriver = d;
+                vmRecord = vm;
+                break;
+            }
+        }
+    }
+    if (!foundDriver || !vmRecord) {
+        return createToolErrorResult(ProxmoxErrorCode.VM_NOT_FOUND, `VM '${target}' not found.`);
+    }
+    if (!foundDriver.rollbackSnapshot) {
+        return createToolErrorResult(ProxmoxErrorCode.OPERATION_NOT_SUPPORTED, `Host '${foundDriver.hostName}' does not support rollbackSnapshot.`);
+    }
+    try {
+        await foundDriver.rollbackSnapshot(vmRecord.id, snapshotName);
+        telemetry.emit({
+            event: "storage.rollback_snapshot",
+            actor: "ct-lab-mcp",
+            status: "success",
+            hostId: foundDriver.hostName,
+            vmId: vmRecord.id,
+            metadata: { snapshotName }
+        });
+        return {
+            content: [{ type: "text", text: `### 🔄 Snapshot Rollback Completed\n\nVM **${vmRecord.name}** (\`${vmRecord.id}\`) on host \`${foundDriver.hostName}\` was reverted to snapshot **\`${snapshotName}\`**.` }],
+            structuredContent: { success: true, host: foundDriver.hostName, vmId: vmRecord.id, vmName: vmRecord.name, snapshotName }
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return createToolErrorResult(ProxmoxErrorCode.VM_ACTION_FAILED, `Failed to rollback snapshot '${snapshotName}' on VM '${target}': ${msg}`);
+    }
+}
+//# sourceMappingURL=storage-tools.js.map