@calltelemetry/ct-lab-mcp 0.1.4 → 0.2.0

package/dist/src/hypervisors/proxmox/client.js

@@ -10,11 +10,13 @@ export class ProxmoxDriver {
     hostName;
     hypervisorType = "proxmox";
     hostConfig;
+    isMock;
     client;
     safetyEngine;
     constructor(hostConfig, clientOrPoller, safetyEngine = defaultSafetyGuardrailEngine) {
         this.hostConfig = hostConfig;
         this.hostName = hostConfig.id;
+        this.isMock = hostConfig.isMock === true;
         this.safetyEngine = safetyEngine;
         if (clientOrPoller && "listVms" in clientOrPoller) {
             this.client = clientOrPoller;
@@ -100,7 +102,8 @@ export class ProxmoxDriver {
                 },
                 endpoint: this.hostConfig.baseUrl,
                 runningVms,
-                totalVms
+                totalVms,
+                mock: this.isMock
             };
         }
         catch (err) {
@@ -122,7 +125,9 @@ export class ProxmoxDriver {
                     usedSlots: 0,
                     availableSlots: 0,
                     slotSizeBytes: (this.hostConfig.slotSizeMb || 8192) * 1024 * 1024
-                }
+                },
+                endpoint: this.hostConfig.baseUrl,
+                mock: this.isMock
             };
         }
     }
@@ -158,6 +163,7 @@ export class ProxmoxDriver {
         return found || null;
     }
     async cloneVm(params) {
+        const startTime = Date.now();
         const vms = await this.listVms();
         // 1. Resolve source template VM
         const sourceStr = String(params.sourceVmIdOrName).toLowerCase().trim();
@@ -209,7 +215,13 @@ export class ProxmoxDriver {
             slotClaimId: params.slotClaimId,
             taskRef: cloneResult.upid,
             taskUpid: cloneResult.upid,
-            createdAt: new Date().toISOString()
+            createdAt: new Date().toISOString(),
+            mock: this.isMock,
+            transportEvidence: {
+                endpoint: this.hostConfig.baseUrl,
+                elapsedMs: Date.now() - startTime,
+                real: !this.isMock
+            }
         };
     }
     async startVm(vmIdOrName) {
@@ -257,6 +269,554 @@ export class ProxmoxDriver {
             throw new Error(`Failed to destroy VM ${vmid}: ${res.error || res.exitStatus}`);
         }
     }
+    async listStorage() {
+        const nodeName = await this.ensureNodeName();
+        const rawList = await this.client.request("GET", `/nodes/${nodeName}/storage`);
+        return rawList.map((item) => ({
+            storage: item.storage,
+            type: item.type || "unknown",
+            totalBytes: item.total || 0,
+            usedBytes: item.used || 0,
+            availableBytes: item.avail || 0,
+            usedFraction: item.used_fraction || (item.total ? item.used / item.total : 0),
+            active: Boolean(item.active),
+            enabled: Boolean(item.enabled),
+            shared: Boolean(item.shared),
+            content: item.content || "",
+            hostName: this.hostName,
+            hypervisor: "proxmox"
+        }));
+    }
+    async listStorageContent(storage) {
+        const nodeName = await this.ensureNodeName();
+        const rawList = await this.client.request("GET", `/nodes/${nodeName}/storage/${storage}/content`);
+        return rawList.map((item) => ({
+            volid: item.volid,
+            storage: storage,
+            vmid: item.vmid,
+            sizeBytes: item.size || 0,
+            format: item.format,
+            content: item.content || "unknown",
+            notes: item.notes,
+            hostName: this.hostName,
+            hypervisor: "proxmox"
+        }));
+    }
+    async listSnapshots(vmIdOrName) {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm)
+            return [];
+        const nodeName = await this.ensureNodeName();
+        const vmid = Number(vm.id);
+        const rawList = await this.client.request("GET", `/nodes/${nodeName}/qemu/${vmid}/snapshot`);
+        return rawList
+            .filter((s) => s.name !== "current")
+            .map((s) => ({
+            name: s.name,
+            description: s.description,
+            snaptime: s.snaptime,
+            snapdate: s.snaptime ? new Date(s.snaptime * 1000).toISOString() : undefined,
+            vmstate: Boolean(s.vmstate),
+            vmId: vmid,
+            vmName: vm.name,
+            hostName: this.hostName,
+            hypervisor: "proxmox"
+        }));
+    }
+    async createSnapshot(vmIdOrName, snapName, description, includeRam = false) {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        const nodeName = await this.ensureNodeName();
+        const vmid = Number(vm.id);
+        const body = {
+            snapname: snapName,
+            description: description || "",
+            vmstate: includeRam ? 1 : 0
+        };
+        const task = await this.client.request("POST", `/nodes/${nodeName}/qemu/${vmid}/snapshot`, body);
+        if (task && typeof task === "string") {
+            try {
+                await defaultTaskPoller.waitForTask(this.client, nodeName, task);
+            }
+            catch (err) {
+                logger.debug(`Snapshot task wait: ${err.message}`);
+            }
+        }
+    }
+    async rollbackSnapshot(vmIdOrName, snapName) {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        if (vm.isProtected) {
+            throw new Error(`SAFETY_GUARDRAIL: Cannot rollback snapshot on protected infrastructure VM '${vm.name}' (${vm.id}).`);
+        }
+        const nodeName = await this.ensureNodeName();
+        const vmid = Number(vm.id);
+        const task = await this.client.request("POST", `/nodes/${nodeName}/qemu/${vmid}/snapshot/${snapName}/rollback`);
+        if (task && typeof task === "string") {
+            try {
+                await defaultTaskPoller.waitForTask(this.client, nodeName, task);
+            }
+            catch (err) {
+                logger.debug(`Snapshot rollback task wait: ${err.message}`);
+            }
+        }
+    }
+    async deleteSnapshot(vmIdOrName, snapName) {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        const nodeName = await this.ensureNodeName();
+        const vmid = Number(vm.id);
+        const task = await this.client.request("DELETE", `/nodes/${nodeName}/qemu/${vmid}/snapshot/${snapName}`);
+        if (task && typeof task === "string") {
+            try {
+                await defaultTaskPoller.waitForTask(this.client, nodeName, task);
+            }
+            catch (err) {
+                logger.debug(`Snapshot delete task wait: ${err.message}`);
+            }
+        }
+    }
+    async getVmStorage(vmIdOrName) {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        const nodeName = await this.ensureNodeName();
+        const vmid = Number(vm.id);
+        const config = await this.client.getVmConfig(vmid, nodeName);
+        const disks = [];
+        const cdroms = [];
+        for (const [key, val] of Object.entries(config)) {
+            if (key.startsWith("scsi") ||
+                key.startsWith("virtio") ||
+                key.startsWith("sata") ||
+                key.startsWith("ide")) {
+                if (typeof val !== "string")
+                    continue;
+                const parts = val.split(",");
+                const volid = parts[0] || "";
+                const [storage] = volid.split(":");
+                const isCdrom = val.includes("media=cdrom");
+                let sizeGb;
+                let sizeBytes;
+                const sizeMatch = val.match(/size=(\d+(?:\.\d+)?)([KMGTP]?)/i);
+                if (sizeMatch) {
+                    const num = parseFloat(sizeMatch[1]);
+                    const unit = (sizeMatch[2] || "G").toUpperCase();
+                    const multipliers = {
+                        K: 1024,
+                        M: 1024 * 1024,
+                        G: 1024 * 1024 * 1024,
+                        T: 1024 * 1024 * 1024 * 1024
+                    };
+                    sizeBytes = num * (multipliers[unit] || multipliers.G);
+                    sizeGb = sizeBytes / (1024 * 1024 * 1024);
+                }
+                const diskInfo = {
+                    drive: key,
+                    storage: storage || "unknown",
+                    volid,
+                    sizeBytes,
+                    sizeGb,
+                    format: volid.endsWith(".iso") ? "iso" : "raw",
+                    discard: val.includes("discard=on"),
+                    ssd: val.includes("ssd=1"),
+                    isCdrom,
+                    media: isCdrom ? "cdrom" : "disk"
+                };
+                if (isCdrom) {
+                    cdroms.push(diskInfo);
+                }
+                else {
+                    disks.push(diskInfo);
+                }
+            }
+        }
+        let guestFilesystems;
+        let guestAgentActive = false;
+        if (vm.status === "running") {
+            try {
+                const fsRes = await this.client.request("GET", `/nodes/${nodeName}/qemu/${vmid}/agent/get-fsinfo`);
+                const fsList = fsRes?.result || fsRes;
+                if (Array.isArray(fsList)) {
+                    guestAgentActive = true;
+                    guestFilesystems = fsList.map((fs) => {
+                        const total = Number(fs["total-bytes"] || fs.totalBytes || 0);
+                        const used = Number(fs["used-bytes"] || fs.usedBytes || 0);
+                        const avail = total > used ? total - used : 0;
+                        const pct = total > 0 ? Math.round((used / total) * 100) : 0;
+                        return {
+                            mountPoint: String(fs.mountpoint || fs.mountPoint || "/"),
+                            fsType: String(fs.type || fs.fsType || "unknown"),
+                            totalBytes: total,
+                            usedBytes: used,
+                            availableBytes: avail,
+                            usedPercent: pct,
+                            diskDevice: fs.name || fs.disk?.[0]?.dev || undefined
+                        };
+                    });
+                }
+            }
+            catch {
+                // Guest agent might be offline or not responding
+            }
+        }
+        return {
+            vmId: String(vmid),
+            vmName: vm.name,
+            hostName: this.hostName,
+            hypervisor: "proxmox",
+            status: vm.status,
+            disks,
+            cdroms,
+            guestFilesystems,
+            guestAgentActive
+        };
+    }
+    async mountIso(vmIdOrName, isoVolid, drive = "ide2") {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        const nodeName = await this.ensureNodeName();
+        const vmid = Number(vm.id);
+        const body = {
+            [drive]: `${isoVolid},media=cdrom`
+        };
+        await this.client.request("PUT", `/nodes/${nodeName}/qemu/${vmid}/config`, body);
+    }
+    async unmountIso(vmIdOrName, drive = "ide2") {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        const nodeName = await this.ensureNodeName();
+        const vmid = Number(vm.id);
+        const body = {
+            [drive]: "none,media=cdrom"
+        };
+        await this.client.request("PUT", `/nodes/${nodeName}/qemu/${vmid}/config`, body);
+    }
+    async deleteVolume(volumeId) {
+        const nodeName = await this.ensureNodeName();
+        const [storage] = volumeId.split(":");
+        if (!storage) {
+            throw new Error(`Invalid volume ID format: '${volumeId}'. Expected 'storage:path' (e.g. 'local:iso/foo.iso').`);
+        }
+        for (const protId of this.hostConfig.protectedVmids) {
+            if (volumeId.includes(`vm-${protId}-`)) {
+                throw new Error(`SAFETY_GUARDRAIL: Cannot delete volume '${volumeId}' because it belongs to protected VM ${protId}.`);
+            }
+        }
+        await this.client.request("DELETE", `/nodes/${nodeName}/storage/${storage}/content/${volumeId}`);
+    }
+    async getVmNetwork(vmIdOrName) {
+        const vmid = await this.resolveVmid(vmIdOrName);
+        const vm = await this.getVm(vmid);
+        const nodeName = await this.ensureNodeName();
+        const config = await this.client.getVmConfig(vmid, nodeName);
+        const nics = [];
+        for (const [key, value] of Object.entries(config)) {
+            if (/^net\d+$/.test(key) && typeof value === "string") {
+                const parts = value.split(",");
+                let model = "virtio";
+                let macAddress = "";
+                let bridge = "vmbr0";
+                let vlan;
+                let firewall = false;
+                let connected = true;
+                let rateLimitMbs;
+                for (const part of parts) {
+                    const [k, v] = part.split("=");
+                    if (["virtio", "e1000", "vmxnet3", "rtl8139"].includes(k)) {
+                        model = k;
+                        macAddress = v || "";
+                    }
+                    else if (k === "bridge") {
+                        bridge = v || "vmbr0";
+                    }
+                    else if (k === "tag") {
+                        vlan = Number(v);
+                    }
+                    else if (k === "firewall") {
+                        firewall = v === "1";
+                    }
+                    else if (k === "link_down") {
+                        connected = v !== "1";
+                    }
+                    else if (k === "rate") {
+                        rateLimitMbs = Number(v);
+                    }
+                }
+                nics.push({
+                    nic: key,
+                    model,
+                    macAddress,
+                    bridge,
+                    vlan,
+                    firewall,
+                    connected,
+                    rateLimitMbs
+                });
+            }
+        }
+        let guestInterfaces;
+        let guestAgentActive = false;
+        try {
+            const res = await this.client.request("GET", `/nodes/${nodeName}/qemu/${vmid}/agent/network-get-interfaces`);
+            if (res && Array.isArray(res.result)) {
+                guestAgentActive = true;
+                guestInterfaces = res.result.map((iface) => ({
+                    name: iface.name,
+                    macAddress: iface["hardware-address"],
+                    ipAddresses: (iface["ip-addresses"] || []).map((addr) => ({
+                        ip: addr["ip-address"],
+                        type: addr["ip-address-type"] === "ipv6" ? "ipv6" : "ipv4",
+                        prefix: addr.prefix
+                    }))
+                }));
+            }
+        }
+        catch {
+            // Guest agent offline or not responding
+        }
+        let primaryMac = nics[0]?.macAddress;
+        let primaryIp;
+        if (guestInterfaces && guestInterfaces.length > 0) {
+            if (primaryMac) {
+                const match = guestInterfaces.find((gi) => gi.macAddress?.toLowerCase() === primaryMac?.toLowerCase());
+                if (match) {
+                    const v4 = match.ipAddresses.find((a) => a.type === "ipv4" && !a.ip.startsWith("127."));
+                    if (v4)
+                        primaryIp = v4.ip;
+                }
+            }
+            if (!primaryIp) {
+                for (const gi of guestInterfaces) {
+                    if (gi.name.startsWith("docker") || gi.name.startsWith("br-") || gi.name.startsWith("veth") || gi.name === "lo") {
+                        continue;
+                    }
+                    const v4 = gi.ipAddresses.find((a) => a.type === "ipv4" && !a.ip.startsWith("127."));
+                    if (v4) {
+                        primaryIp = v4.ip;
+                        if (!primaryMac && gi.macAddress)
+                            primaryMac = gi.macAddress;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!primaryIp && vm?.ipAddresses && vm.ipAddresses.length > 0) {
+            primaryIp = vm.ipAddresses[0];
+        }
+        const sshCommand = primaryIp ? `ssh -p 2222 calltelemetry@${primaryIp}` : undefined;
+        return {
+            vmId: String(vmid),
+            vmName: vm?.name || `VM-${vmid}`,
+            hostName: this.hostName,
+            hypervisor: "proxmox",
+            primaryIp,
+            primaryMac,
+            sshCommand,
+            nics,
+            guestInterfaces,
+            guestAgentActive
+        };
+    }
+    async updateVmNic(vmIdOrName, nic, options) {
+        const vmid = await this.resolveVmid(vmIdOrName);
+        const nodeName = await this.ensureNodeName();
+        const config = await this.client.getVmConfig(vmid, nodeName);
+        const currentNicStr = config[nic];
+        if (!currentNicStr || typeof currentNicStr !== "string") {
+            throw new Error(`NIC '${nic}' does not exist on VM ${vmid}.`);
+        }
+        // Parse existing model and MAC (first token, e.g. virtio=BC:24:11:00:00:01)
+        const parts = currentNicStr.split(",");
+        const modelAndMac = parts[0];
+        let bridge = "vmbr0";
+        let vlan;
+        let firewall = false;
+        let linkDown = false;
+        let rate;
+        for (let i = 1; i < parts.length; i++) {
+            const [k, v] = parts[i].split("=");
+            if (k === "bridge")
+                bridge = v;
+            else if (k === "tag")
+                vlan = Number(v);
+            else if (k === "firewall")
+                firewall = v === "1";
+            else if (k === "link_down")
+                linkDown = v === "1";
+            else if (k === "rate")
+                rate = Number(v);
+        }
+        if (options.bridge !== undefined)
+            bridge = options.bridge;
+        if (options.vlan !== undefined)
+            vlan = options.vlan;
+        if (options.firewall !== undefined)
+            firewall = options.firewall;
+        if (options.connected !== undefined)
+            linkDown = !options.connected;
+        if (options.rateLimitMbs !== undefined)
+            rate = options.rateLimitMbs;
+        const newParts = [modelAndMac, `bridge=${bridge}`];
+        if (firewall)
+            newParts.push("firewall=1");
+        if (vlan !== undefined && vlan > 0)
+            newParts.push(`tag=${vlan}`);
+        if (linkDown)
+            newParts.push("link_down=1");
+        if (rate !== undefined && rate > 0)
+            newParts.push(`rate=${rate}`);
+        const updatedNicStr = newParts.join(",");
+        await this.client.request("PUT", `/nodes/${nodeName}/qemu/${vmid}/config`, { [nic]: updatedNicStr });
+    }
+    async getGuestAgentStatus(vmIdOrName) {
+        const vmid = await this.resolveVmid(vmIdOrName);
+        const vm = await this.getVm(vmid);
+        const nodeName = await this.ensureNodeName();
+        let isAlive = false;
+        let pingLatencyMs;
+        let agentVersion;
+        let osName;
+        let osVersion;
+        let kernelVersion;
+        let hostname;
+        let architecture;
+        const ipAddresses = [];
+        let guestInterfaces = [];
+        let supportedCommandsCount;
+        let error;
+        const start = Date.now();
+        try {
+            // 1. Ping
+            await this.client.request("POST", `/nodes/${nodeName}/qemu/${vmid}/agent/ping`);
+            pingLatencyMs = Date.now() - start;
+            isAlive = true;
+            // 2. Agent info
+            const infoRes = await this.client.request("GET", `/nodes/${nodeName}/qemu/${vmid}/agent/info`).catch(() => null);
+            if (infoRes && infoRes.result) {
+                agentVersion = infoRes.result.version;
+                supportedCommandsCount = infoRes.result["supported_commands"]?.length;
+            }
+            // 3. OS info
+            const osRes = await this.client.request("GET", `/nodes/${nodeName}/qemu/${vmid}/agent/get-osinfo`).catch(() => null);
+            if (osRes && osRes.result) {
+                osName = osRes.result["pretty-name"] || osRes.result.name;
+                osVersion = osRes.result.version;
+                kernelVersion = osRes.result["kernel-release"];
+                hostname = osRes.result.hostname;
+                architecture = osRes.result.machine;
+            }
+            // 4. Interfaces
+            const netRes = await this.client.request("GET", `/nodes/${nodeName}/qemu/${vmid}/agent/network-get-interfaces`).catch(() => null);
+            if (netRes && Array.isArray(netRes.result)) {
+                guestInterfaces = netRes.result.map((iface) => {
+                    const ips = (iface["ip-addresses"] || []).map((addr) => {
+                        const ip = addr["ip-address"];
+                        if (ip && !ip.startsWith("127.") && !ip.startsWith("::1") && !ip.startsWith("fe80::")) {
+                            ipAddresses.push(ip);
+                        }
+                        return {
+                            ip,
+                            type: addr["ip-address-type"] === "ipv6" ? "ipv6" : "ipv4",
+                            prefix: addr.prefix
+                        };
+                    });
+                    return {
+                        name: iface.name,
+                        macAddress: iface["hardware-address"],
+                        ipAddresses: ips
+                    };
+                });
+            }
+        }
+        catch (err) {
+            error = err instanceof Error ? err.message : String(err);
+            isAlive = false;
+        }
+        let primaryIp;
+        let primaryMac;
+        if (guestInterfaces && guestInterfaces.length > 0) {
+            for (const gi of guestInterfaces) {
+                if (gi.name.startsWith("docker") || gi.name.startsWith("br-") || gi.name.startsWith("veth") || gi.name === "lo") {
+                    continue;
+                }
+                const v4 = gi.ipAddresses.find((a) => a.type === "ipv4" && !a.ip.startsWith("127."));
+                if (v4) {
+                    primaryIp = v4.ip;
+                    if (gi.macAddress)
+                        primaryMac = gi.macAddress;
+                    break;
+                }
+            }
+        }
+        if (!primaryIp && vm?.ipAddresses && vm.ipAddresses.length > 0) {
+            primaryIp = vm.ipAddresses[0];
+        }
+        const sshCommand = primaryIp ? `ssh -p 2222 calltelemetry@${primaryIp}` : undefined;
+        return {
+            vmId: String(vmid),
+            vmName: vm?.name || `VM-${vmid}`,
+            hostName: this.hostName,
+            hypervisor: "proxmox",
+            primaryIp,
+            primaryMac,
+            sshCommand,
+            isAlive,
+            pingLatencyMs,
+            agentVersion,
+            osName,
+            osVersion,
+            kernelVersion,
+            hostname,
+            architecture,
+            ipAddresses: Array.from(new Set(ipAddresses)),
+            guestInterfaces,
+            supportedCommandsCount,
+            error
+        };
+    }
+    async shutdownVm(vmIdOrName, force = false) {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        const vmid = Number(vm.id);
+        this.safetyEngine.validateAction({ vmid, name: vm.name, template: vm.isTemplate, tags: vm.tags }, "shutdown", force);
+        const nodeName = await this.ensureNodeName();
+        const res = await this.client.shutdownVm(vmid, 60, nodeName);
+        if (!res.success) {
+            throw new Error(`Failed to shutdown VM ${vmid}: ${res.error || res.exitStatus}`);
+        }
+    }
+    async suspendVm(vmIdOrName) {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        const vmid = Number(vm.id);
+        const nodeName = await this.ensureNodeName();
+        await this.client.request("POST", `/nodes/${nodeName}/qemu/${vmid}/status/suspend`);
+    }
+    async resumeVm(vmIdOrName) {
+        const vm = await this.getVm(vmIdOrName);
+        if (!vm) {
+            throw new Error(`VM '${vmIdOrName}' not found on Proxmox host '${this.hostName}'.`);
+        }
+        const vmid = Number(vm.id);
+        const nodeName = await this.ensureNodeName();
+        await this.client.request("POST", `/nodes/${nodeName}/qemu/${vmid}/status/resume`);
+    }
     async resolveVmid(vmIdOrName) {
         if (typeof vmIdOrName === "number") {
             return vmIdOrName;