@sonde/packs 0.1.0 → 0.1.1

package/dist/integrations/proxmox.js

@@ -0,0 +1,733 @@
+// --- Auth helpers ---
+/** Build Proxmox PVEAPIToken auth header */
+export function buildAuthHeaders(credentials) {
+    const tokenId = credentials.credentials.tokenId ?? '';
+    const tokenSecret = credentials.credentials.tokenSecret ?? '';
+    return { Authorization: `PVEAPIToken=${tokenId}=${tokenSecret}` };
+}
+// --- Proxmox REST helper ---
+function proxmoxUrl(endpoint, path, params) {
+    const base = `${endpoint.replace(/\/$/, '')}/api2/json${path}`;
+    const url = new URL(base);
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            url.searchParams.set(key, value);
+        }
+    }
+    return url.toString();
+}
+/** GET a Proxmox API endpoint, returns parsed JSON */
+export async function proxmoxGet(path, config, credentials, fetchFn, params) {
+    const url = proxmoxUrl(config.endpoint, path, params);
+    const headers = {
+        Accept: 'application/json',
+        ...buildAuthHeaders(credentials),
+        ...config.headers,
+    };
+    const res = await fetchFn(url, { headers });
+    if (!res.ok)
+        throw new Error(`Proxmox API returned ${res.status}: ${res.statusText}`);
+    return res.json();
+}
+// --- Node resolver ---
+/** Resolve which node a VM/container lives on by querying cluster resources */
+export async function resolveNode(vmid, config, credentials, fetchFn) {
+    const data = (await proxmoxGet('/cluster/resources', config, credentials, fetchFn, {
+        type: 'vm',
+    }));
+    const entry = (data.data ?? []).find((r) => r.vmid === vmid);
+    if (!entry || !entry.node) {
+        throw new Error(`VM/container ${vmid} not found in cluster`);
+    }
+    return { node: entry.node, type: entry.type };
+}
+// --- Probe handlers ---
+const clusterStatus = async (_params, config, credentials, fetchFn) => {
+    const data = (await proxmoxGet('/cluster/status', config, credentials, fetchFn));
+    const entries = data.data ?? [];
+    const clusterEntry = entries.find((e) => e.type === 'cluster');
+    const nodeEntries = entries.filter((e) => e.type === 'node');
+    const warnings = [];
+    if (clusterEntry && !clusterEntry.quorate) {
+        warnings.push('Cluster has lost quorum');
+    }
+    for (const n of nodeEntries) {
+        if (!n.online) {
+            warnings.push(`Node ${n.name} is offline`);
+        }
+    }
+    return {
+        clusterName: clusterEntry?.name ?? null,
+        quorate: !!clusterEntry?.quorate,
+        nodes: nodeEntries.map((n) => ({
+            name: n.name,
+            online: !!n.online,
+            ip: n.ip ?? null,
+            type: n.type,
+        })),
+        warnings,
+    };
+};
+const clusterHaStatus = async (_params, config, credentials, fetchFn) => {
+    const [statusData, resourcesData] = await Promise.all([
+        proxmoxGet('/cluster/ha/status/current', config, credentials, fetchFn),
+        proxmoxGet('/cluster/ha/resources', config, credentials, fetchFn),
+    ]);
+    const statusEntries = statusData.data ?? [];
+    const managerEntry = statusEntries.find((e) => e.type === 'manager' || e.id === 'manager');
+    const resources = resourcesData.data ?? [];
+    const warnings = [];
+    for (const r of resources) {
+        if (r.state === 'error' || r.state === 'fence') {
+            warnings.push(`HA resource ${r.sid} in ${r.state} state`);
+        }
+    }
+    return {
+        managerStatus: managerEntry?.status ?? managerEntry?.state ?? null,
+        resources: resources.map((r) => ({
+            sid: r.sid,
+            state: r.state,
+            node: r.node,
+            type: r.type,
+            group: r.group ?? null,
+        })),
+        warnings,
+    };
+};
+const nodesList = async (_params, config, credentials, fetchFn) => {
+    const data = (await proxmoxGet('/nodes', config, credentials, fetchFn));
+    const nodes = data.data ?? [];
+    const warnings = [];
+    for (const n of nodes) {
+        if (n.status === 'offline') {
+            warnings.push(`Node ${n.node} is offline`);
+        }
+        if (n.cpu != null && n.cpu > 0.9) {
+            warnings.push(`Node ${n.node} CPU at ${Math.round(n.cpu * 100)}%`);
+        }
+        if (n.mem != null && n.maxmem != null && n.maxmem > 0 && n.mem / n.maxmem > 0.9) {
+            warnings.push(`Node ${n.node} memory at ${Math.round((n.mem / n.maxmem) * 100)}%`);
+        }
+    }
+    return {
+        nodes: nodes.map((n) => ({
+            node: n.node,
+            status: n.status,
+            uptime: n.uptime ?? 0,
+            cpu: n.cpu ?? 0,
+            maxcpu: n.maxcpu ?? 0,
+            mem: n.mem ?? 0,
+            maxmem: n.maxmem ?? 0,
+            loadavg: n.loadavg ?? null,
+        })),
+        warnings,
+    };
+};
+const nodeStorage = async (params, config, credentials, fetchFn) => {
+    const node = params?.node;
+    if (!node)
+        throw new Error('node parameter is required');
+    const data = (await proxmoxGet(`/nodes/${node}/storage`, config, credentials, fetchFn));
+    const storages = data.data ?? [];
+    const warnings = [];
+    for (const s of storages) {
+        if (s.total && s.used && s.total > 0 && s.used / s.total > 0.85) {
+            warnings.push(`Storage ${s.storage} is ${Math.round((s.used / s.total) * 100)}% used`);
+        }
+        if (s.enabled === 0) {
+            warnings.push(`Storage ${s.storage} is disabled`);
+        }
+        if (s.active === 0 && s.enabled !== 0) {
+            warnings.push(`Storage ${s.storage} is inactive`);
+        }
+    }
+    return {
+        storages: storages.map((s) => ({
+            storage: s.storage,
+            type: s.type,
+            total: s.total ?? 0,
+            used: s.used ?? 0,
+            avail: s.avail ?? 0,
+            shared: !!s.shared,
+            enabled: s.enabled !== 0,
+            active: s.active !== 0,
+        })),
+        warnings,
+    };
+};
+const vmStatus = async (params, config, credentials, fetchFn) => {
+    const vmid = params?.vmid;
+    if (vmid == null)
+        throw new Error('vmid parameter is required');
+    const data = (await proxmoxGet('/cluster/resources', config, credentials, fetchFn, {
+        type: 'vm',
+    }));
+    const vm = (data.data ?? []).find((r) => r.vmid === vmid);
+    if (!vm)
+        throw new Error(`VM/container ${vmid} not found in cluster`);
+    const warnings = [];
+    if (vm.status === 'stopped') {
+        warnings.push('VM is stopped');
+    }
+    if (vm.lock) {
+        warnings.push(`VM has lock: ${vm.lock}`);
+    }
+    if (vm.hastate && vm.hastate !== 'managed' && vm.hastate !== 'started') {
+        warnings.push(`HA state: ${vm.hastate}`);
+    }
+    return {
+        vmid: vm.vmid,
+        name: vm.name,
+        status: vm.status,
+        node: vm.node,
+        type: vm.type,
+        uptime: vm.uptime ?? 0,
+        cpu: vm.cpu ?? 0,
+        mem: vm.mem ?? 0,
+        maxmem: vm.maxmem ?? 0,
+        lock: vm.lock ?? null,
+        hastate: vm.hastate ?? null,
+        warnings,
+    };
+};
+const vmConfig = async (params, config, credentials, fetchFn) => {
+    const vmid = params?.vmid;
+    if (vmid == null)
+        throw new Error('vmid parameter is required');
+    let node = params?.node;
+    if (!node) {
+        const resolved = await resolveNode(vmid, config, credentials, fetchFn);
+        node = resolved.node;
+    }
+    const data = (await proxmoxGet(`/nodes/${node}/qemu/${vmid}/config`, config, credentials, fetchFn));
+    const cfg = data.data ?? {};
+    const diskKeys = ['scsi', 'ide', 'virtio', 'sata', 'efidisk', 'tpmstate'];
+    const disks = [];
+    for (const [key, value] of Object.entries(cfg)) {
+        if (typeof value !== 'string')
+            continue;
+        const matchesDisk = diskKeys.some((prefix) => key.startsWith(prefix));
+        if (!matchesDisk)
+            continue;
+        // Parse: "local-lvm:vm-100-disk-0,size=32G" or "local:iso/file.iso,media=cdrom"
+        const colonIdx = value.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const storage = value.slice(0, colonIdx);
+        const rest = value.slice(colonIdx + 1);
+        const commaIdx = rest.indexOf(',');
+        const volPart = commaIdx > -1 ? rest.slice(0, commaIdx) : rest;
+        const optsPart = commaIdx > -1 ? rest.slice(commaIdx + 1) : '';
+        // Extract format from volume name or options
+        let format = 'raw';
+        if (volPart.endsWith('.qcow2'))
+            format = 'qcow2';
+        else if (volPart.endsWith('.vmdk'))
+            format = 'vmdk';
+        else if (optsPart.includes('format=qcow2'))
+            format = 'qcow2';
+        else if (optsPart.includes('format=vmdk'))
+            format = 'vmdk';
+        else if (optsPart.includes('format=raw'))
+            format = 'raw';
+        // Extract size
+        const sizeMatch = optsPart.match(/size=(\S+)/);
+        const size = sizeMatch?.[1] ?? '';
+        disks.push({ key, storage, format, size });
+    }
+    const warnings = [];
+    // Warn if local storage on potentially HA-managed VM
+    for (const d of disks) {
+        if (d.storage === 'local' || d.storage === 'local-lvm') {
+            warnings.push(`Disk ${d.key} uses local storage (${d.storage}) — not shared for HA`);
+        }
+    }
+    return {
+        vmid,
+        node,
+        config: cfg,
+        disks,
+        warnings,
+    };
+};
+const vmSnapshots = async (params, config, credentials, fetchFn) => {
+    const vmid = params?.vmid;
+    if (vmid == null)
+        throw new Error('vmid parameter is required');
+    let node = params?.node;
+    if (!node) {
+        const resolved = await resolveNode(vmid, config, credentials, fetchFn);
+        node = resolved.node;
+    }
+    const data = (await proxmoxGet(`/nodes/${node}/qemu/${vmid}/snapshot`, config, credentials, fetchFn));
+    const snapshots = (data.data ?? []).filter((s) => s.name !== 'current');
+    const now = Date.now() / 1000;
+    const sevenDays = 7 * 24 * 60 * 60;
+    const warnings = [];
+    for (const s of snapshots) {
+        if (s.snaptime && now - s.snaptime > sevenDays) {
+            warnings.push(`Snapshot "${s.name}" is older than 7 days`);
+        }
+    }
+    return {
+        vmid,
+        node,
+        snapshots: snapshots.map((s) => ({
+            name: s.name,
+            description: s.description ?? '',
+            snaptime: s.snaptime ?? null,
+            parent: s.parent ?? null,
+        })),
+        warnings,
+    };
+};
+const storageContent = async (params, config, credentials, fetchFn) => {
+    const node = params?.node;
+    const storage = params?.storage;
+    if (!node)
+        throw new Error('node parameter is required');
+    if (!storage)
+        throw new Error('storage parameter is required');
+    const vmidFilter = params?.vmid;
+    const data = (await proxmoxGet(`/nodes/${node}/storage/${storage}/content`, config, credentials, fetchFn));
+    let volumes = data.data ?? [];
+    if (vmidFilter != null) {
+        volumes = volumes.filter((v) => v.vmid === vmidFilter);
+    }
+    return {
+        volumes: volumes.map((v) => ({
+            volid: v.volid,
+            vmid: v.vmid ?? null,
+            size: v.size ?? 0,
+            format: v.format ?? null,
+        })),
+        count: volumes.length,
+    };
+};
+const clusterTasks = async (params, config, credentials, fetchFn) => {
+    const vmidFilter = params?.vmid;
+    const limit = params?.limit || 50;
+    const data = (await proxmoxGet('/cluster/tasks', config, credentials, fetchFn));
+    let tasks = data.data ?? [];
+    if (vmidFilter != null) {
+        const vmidStr = String(vmidFilter);
+        tasks = tasks.filter((t) => t.id === vmidStr);
+    }
+    tasks = tasks.slice(0, limit);
+    const warnings = [];
+    for (const t of tasks) {
+        if (t.status && t.status !== 'OK' && t.status !== '' && t.endtime) {
+            warnings.push(`Task ${t.type} on ${t.node} failed: ${t.status}`);
+        }
+        if (t.type === 'qmigrate' && !t.endtime) {
+            warnings.push(`Migration in progress on ${t.node}`);
+        }
+    }
+    return {
+        tasks: tasks.map((t) => ({
+            upid: t.upid,
+            type: t.type,
+            status: t.status ?? null,
+            starttime: t.starttime ?? null,
+            endtime: t.endtime ?? null,
+            node: t.node,
+            user: t.user ?? null,
+        })),
+        warnings,
+    };
+};
+const nodeLvm = async (params, config, credentials, fetchFn) => {
+    const node = params?.node;
+    if (!node)
+        throw new Error('node parameter is required');
+    const data = (await proxmoxGet(`/nodes/${node}/disks/lvm`, config, credentials, fetchFn));
+    const volumeGroups = data.data ?? [];
+    const warnings = [];
+    for (const vg of volumeGroups) {
+        if (vg.free != null && vg.free === 0) {
+            warnings.push(`Volume group ${vg.name} has no free space`);
+        }
+    }
+    return {
+        volumeGroups: volumeGroups.map((vg) => ({
+            name: vg.name,
+            size: vg.size ?? 0,
+            free: vg.free ?? 0,
+            pvs: vg.pvs ?? 0,
+            lvs: vg.lvs ?? 0,
+        })),
+        warnings,
+    };
+};
+const lxcStatus = async (params, config, credentials, fetchFn) => {
+    const vmid = params?.vmid;
+    if (vmid == null)
+        throw new Error('vmid parameter is required');
+    let node = params?.node;
+    if (!node) {
+        const resolved = await resolveNode(vmid, config, credentials, fetchFn);
+        if (resolved.type !== 'lxc') {
+            throw new Error(`VMID ${vmid} is not an LXC container (type: ${resolved.type})`);
+        }
+        node = resolved.node;
+    }
+    const data = (await proxmoxGet(`/nodes/${node}/lxc/${vmid}/status/current`, config, credentials, fetchFn));
+    const ct = data.data ?? {};
+    const warnings = [];
+    if (ct.status === 'stopped') {
+        warnings.push('Container is stopped');
+    }
+    return {
+        vmid: ct.vmid ?? vmid,
+        name: ct.name ?? null,
+        status: ct.status ?? null,
+        node,
+        uptime: ct.uptime ?? 0,
+        cpu: ct.cpu ?? 0,
+        mem: ct.mem ?? 0,
+        maxmem: ct.maxmem ?? 0,
+        disk: ct.disk ?? 0,
+        maxdisk: ct.maxdisk ?? 0,
+        swap: ct.swap ?? 0,
+        maxswap: ct.maxswap ?? 0,
+        warnings,
+    };
+};
+const lxcConfig = async (params, config, credentials, fetchFn) => {
+    const vmid = params?.vmid;
+    if (vmid == null)
+        throw new Error('vmid parameter is required');
+    let node = params?.node;
+    if (!node) {
+        const resolved = await resolveNode(vmid, config, credentials, fetchFn);
+        node = resolved.node;
+    }
+    const data = (await proxmoxGet(`/nodes/${node}/lxc/${vmid}/config`, config, credentials, fetchFn));
+    const cfg = data.data ?? {};
+    // Parse rootfs: "local-lvm:subvol-200-disk-0,size=8G"
+    let rootfs = null;
+    if (typeof cfg.rootfs === 'string') {
+        const colonIdx = cfg.rootfs.indexOf(':');
+        if (colonIdx > -1) {
+            const storage = cfg.rootfs.slice(0, colonIdx);
+            const rest = cfg.rootfs.slice(colonIdx + 1);
+            const sizeMatch = rest.match(/size=(\S+)/);
+            rootfs = { storage, size: sizeMatch?.[1] ?? '' };
+        }
+    }
+    // Parse mp0–mp9 mountpoints
+    const mountpoints = [];
+    for (const [key, value] of Object.entries(cfg)) {
+        if (!/^mp\d+$/.test(key) || typeof value !== 'string')
+            continue;
+        const colonIdx = value.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const storage = value.slice(0, colonIdx);
+        const rest = value.slice(colonIdx + 1);
+        const mpMatch = rest.match(/mp=([^,]+)/);
+        const sizeMatch = rest.match(/size=(\S+)/);
+        mountpoints.push({
+            key,
+            storage,
+            mountpoint: mpMatch?.[1] ?? '',
+            size: sizeMatch?.[1] ?? '',
+        });
+    }
+    const warnings = [];
+    return {
+        vmid,
+        node,
+        config: cfg,
+        rootfs,
+        mountpoints,
+        warnings,
+    };
+};
+const clusterResources = async (_params, config, credentials, fetchFn) => {
+    const data = (await proxmoxGet('/cluster/resources', config, credentials, fetchFn, {
+        type: 'vm',
+    }));
+    const resources = data.data ?? [];
+    return {
+        resources: resources.map((r) => ({
+            vmid: r.vmid,
+            name: r.name ?? null,
+            node: r.node,
+            type: r.type,
+            status: r.status,
+            uptime: r.uptime ?? 0,
+            cpu: r.cpu ?? 0,
+            mem: r.mem ?? 0,
+            maxmem: r.maxmem ?? 0,
+            hastate: r.hastate ?? null,
+            lock: r.lock ?? null,
+        })),
+    };
+};
+const cephStatus = async (_params, config, credentials, fetchFn) => {
+    let statusData;
+    try {
+        statusData = (await proxmoxGet('/cluster/ceph/status', config, credentials, fetchFn));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('404') || msg.includes('501')) {
+            return {
+                available: false,
+                health: null,
+                warnings: ['Ceph is not configured on this cluster'],
+            };
+        }
+        throw err;
+    }
+    const ceph = statusData.data ?? {};
+    const osdmap = ceph.osdmap?.osdmap ?? {};
+    const pgmap = ceph.pgmap ?? {};
+    const health = ceph.health?.status ?? 'unknown';
+    const warnings = [];
+    if (health !== 'HEALTH_OK') {
+        warnings.push(`Ceph health: ${health}`);
+    }
+    const osdCount = osdmap.num_osds ?? 0;
+    const osdUp = osdmap.num_up_osds ?? 0;
+    if (osdCount > 0 && osdUp < osdCount) {
+        warnings.push(`${osdCount - osdUp} OSD(s) down`);
+    }
+    // Try to get OSD details from first node
+    let osds = [];
+    try {
+        // Get nodes list to find first available node
+        const nodesData = (await proxmoxGet('/nodes', config, credentials, fetchFn));
+        const firstNode = (nodesData.data ?? []).find((n) => n.status === 'online');
+        if (firstNode?.node) {
+            const osdData = (await proxmoxGet(`/nodes/${firstNode.node}/ceph/osd`, config, credentials, fetchFn));
+            osds = (osdData.data ?? []).map((o) => ({
+                id: o.id ?? 0,
+                name: o.name ?? `osd.${o.id ?? 0}`,
+                status: o.up ? 'up' : 'down',
+            }));
+        }
+    }
+    catch {
+        // OSD detail is best-effort
+    }
+    return {
+        available: true,
+        health,
+        osdCount,
+        osdUp,
+        osdIn: osdmap.num_in_osds ?? 0,
+        pgStates: (pgmap.pgs_by_state ?? []).map((p) => ({
+            state: p.state_name,
+            count: p.count,
+        })),
+        usage: {
+            total: pgmap.bytes_total ?? 0,
+            used: pgmap.bytes_used ?? 0,
+            avail: pgmap.bytes_avail ?? 0,
+        },
+        osds,
+        warnings,
+    };
+};
+// --- Pack definition ---
+export const proxmoxPack = {
+    manifest: {
+        name: 'proxmox',
+        type: 'integration',
+        version: '0.1.0',
+        description: 'Proxmox VE cluster — nodes, VMs, containers, storage, Ceph, and HA status',
+        requires: { groups: [], files: [], commands: [] },
+        probes: [
+            {
+                name: 'cluster.status',
+                description: 'Cluster status including quorum and node health',
+                capability: 'observe',
+                params: {},
+                timeout: 15000,
+            },
+            {
+                name: 'cluster.ha.status',
+                description: 'HA manager status and resource states',
+                capability: 'observe',
+                params: {},
+                timeout: 15000,
+            },
+            {
+                name: 'nodes.list',
+                description: 'List all nodes with CPU, memory, and status',
+                capability: 'observe',
+                params: {},
+                timeout: 15000,
+            },
+            {
+                name: 'node.storage',
+                description: 'Storage pools for a specific node',
+                capability: 'observe',
+                params: {
+                    node: { type: 'string', description: 'Node name', required: true },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'vm.status',
+                description: 'VM status by VMID (searches cluster-wide)',
+                capability: 'observe',
+                params: {
+                    vmid: { type: 'number', description: 'VM ID', required: true },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'vm.config',
+                description: 'VM configuration with parsed disk entries',
+                capability: 'observe',
+                params: {
+                    vmid: { type: 'number', description: 'VM ID', required: true },
+                    node: {
+                        type: 'string',
+                        description: 'Node name (auto-resolved if omitted)',
+                        required: false,
+                    },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'vm.snapshots',
+                description: 'VM snapshots with age warnings',
+                capability: 'observe',
+                params: {
+                    vmid: { type: 'number', description: 'VM ID', required: true },
+                    node: {
+                        type: 'string',
+                        description: 'Node name (auto-resolved if omitted)',
+                        required: false,
+                    },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'storage.content',
+                description: 'List volumes in a storage pool',
+                capability: 'observe',
+                params: {
+                    node: { type: 'string', description: 'Node name', required: true },
+                    storage: { type: 'string', description: 'Storage ID', required: true },
+                    vmid: {
+                        type: 'number',
+                        description: 'Filter by VM ID',
+                        required: false,
+                    },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'cluster.tasks',
+                description: 'Recent cluster tasks with failure detection',
+                capability: 'observe',
+                params: {
+                    vmid: {
+                        type: 'number',
+                        description: 'Filter by VM ID',
+                        required: false,
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max results (default: 50)',
+                        required: false,
+                    },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'node.lvm',
+                description: 'LVM volume groups on a node',
+                capability: 'observe',
+                params: {
+                    node: { type: 'string', description: 'Node name', required: true },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'lxc.status',
+                description: 'LXC container status with resource usage',
+                capability: 'observe',
+                params: {
+                    vmid: { type: 'number', description: 'Container VMID', required: true },
+                    node: {
+                        type: 'string',
+                        description: 'Node name (auto-resolved if omitted)',
+                        required: false,
+                    },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'lxc.config',
+                description: 'LXC container configuration with parsed mountpoints',
+                capability: 'observe',
+                params: {
+                    vmid: { type: 'number', description: 'Container VMID', required: true },
+                    node: {
+                        type: 'string',
+                        description: 'Node name (auto-resolved if omitted)',
+                        required: false,
+                    },
+                },
+                timeout: 15000,
+            },
+            {
+                name: 'ceph.status',
+                description: 'Ceph cluster health, OSD status, and usage',
+                capability: 'observe',
+                params: {},
+                timeout: 30000,
+            },
+            {
+                name: 'cluster.resources',
+                description: 'List all VMs and containers across the cluster',
+                capability: 'observe',
+                params: {},
+                timeout: 15000,
+            },
+        ],
+        runbook: {
+            category: 'virtualization',
+            probes: ['cluster.status', 'nodes.list', 'ceph.status'],
+            parallel: true,
+        },
+    },
+    handlers: {
+        'cluster.status': clusterStatus,
+        'cluster.ha.status': clusterHaStatus,
+        'nodes.list': nodesList,
+        'node.storage': nodeStorage,
+        'vm.status': vmStatus,
+        'vm.config': vmConfig,
+        'vm.snapshots': vmSnapshots,
+        'storage.content': storageContent,
+        'cluster.tasks': clusterTasks,
+        'node.lvm': nodeLvm,
+        'lxc.status': lxcStatus,
+        'lxc.config': lxcConfig,
+        'ceph.status': cephStatus,
+        'cluster.resources': clusterResources,
+    },
+    testConnection: async (config, credentials, fetchFn) => {
+        try {
+            const url = proxmoxUrl(config.endpoint, '/version');
+            const headers = {
+                Accept: 'application/json',
+                ...buildAuthHeaders(credentials),
+                ...config.headers,
+            };
+            const res = await fetchFn(url, { headers });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    },
+};
+//# sourceMappingURL=proxmox.js.map