@sonde/packs 0.1.0 → 0.1.1

package/dist/integrations/proxmox.test.js

@@ -0,0 +1,697 @@
+import { describe, expect, it, vi } from 'vitest';
+import { buildAuthHeaders, proxmoxGet, proxmoxPack, resolveNode } from './proxmox.js';
+const pveConfig = {
+    endpoint: 'https://pve01.local:8006',
+};
+const pveCreds = {
+    packName: 'proxmox',
+    authMethod: 'api_key',
+    credentials: { tokenId: 'sonde@pve!sonde-token', tokenSecret: 'secret-uuid' },
+};
+const handler = (name) => {
+    const h = proxmoxPack.handlers[name];
+    if (!h)
+        throw new Error(`Handler ${name} not found`);
+    return h;
+};
+function callArgs(fn, index) {
+    const args = fn.mock.calls[index];
+    if (!args)
+        throw new Error(`No call at index ${index}`);
+    return args;
+}
+function mockPveResponse(body, status = 200) {
+    return vi.fn().mockResolvedValue(new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+    }));
+}
+function mockFetchError(status) {
+    return vi.fn().mockResolvedValue(new Response('Error', { status, statusText: 'Error' }));
+}
+describe('proxmox pack', () => {
+    describe('auth headers', () => {
+        it('builds correct PVEAPIToken header', () => {
+            const headers = buildAuthHeaders(pveCreds);
+            expect(headers.Authorization).toBe('PVEAPIToken=sonde@pve!sonde-token=secret-uuid');
+        });
+        it('handles missing credentials gracefully', () => {
+            const emptyCreds = {
+                packName: 'proxmox',
+                authMethod: 'api_key',
+                credentials: {},
+            };
+            const headers = buildAuthHeaders(emptyCreds);
+            expect(headers.Authorization).toBe('PVEAPIToken==');
+        });
+    });
+    describe('proxmoxGet', () => {
+        it('constructs correct URL with /api2/json prefix', async () => {
+            const fetchFn = mockPveResponse({ data: {} });
+            await proxmoxGet('/cluster/status', pveConfig, pveCreds, fetchFn);
+            const [url] = callArgs(fetchFn, 0);
+            expect(url).toContain('https://pve01.local:8006/api2/json/cluster/status');
+        });
+        it('includes query params', async () => {
+            const fetchFn = mockPveResponse({ data: [] });
+            await proxmoxGet('/cluster/resources', pveConfig, pveCreds, fetchFn, { type: 'vm' });
+            const [url] = callArgs(fetchFn, 0);
+            expect(url).toContain('type=vm');
+        });
+        it('throws on non-200 response', async () => {
+            const fetchFn = mockFetchError(401);
+            await expect(proxmoxGet('/version', pveConfig, pveCreds, fetchFn)).rejects.toThrow('Proxmox API returned 401');
+        });
+    });
+    describe('testConnection', () => {
+        it('returns true on GET /version success', async () => {
+            const fetchFn = mockPveResponse({ data: { version: '8.1', release: '1', repoid: 'abc' } });
+            const result = await proxmoxPack.testConnection(pveConfig, pveCreds, fetchFn);
+            expect(result).toBe(true);
+            const [url] = callArgs(fetchFn, 0);
+            expect(url).toContain('/api2/json/version');
+        });
+        it('returns false on non-200', async () => {
+            const fetchFn = mockFetchError(401);
+            const result = await proxmoxPack.testConnection(pveConfig, pveCreds, fetchFn);
+            expect(result).toBe(false);
+        });
+        it('returns false on network error', async () => {
+            const fetchFn = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+            const result = await proxmoxPack.testConnection(pveConfig, pveCreds, fetchFn);
+            expect(result).toBe(false);
+        });
+    });
+    describe('resolveNode', () => {
+        it('finds a qemu VM', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    { vmid: 100, node: 'pve01', type: 'qemu' },
+                    { vmid: 200, node: 'pve02', type: 'lxc' },
+                ],
+            });
+            const result = await resolveNode(100, pveConfig, pveCreds, fetchFn);
+            expect(result).toEqual({ node: 'pve01', type: 'qemu' });
+        });
+        it('finds an LXC container', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    { vmid: 100, node: 'pve01', type: 'qemu' },
+                    { vmid: 200, node: 'pve02', type: 'lxc' },
+                ],
+            });
+            const result = await resolveNode(200, pveConfig, pveCreds, fetchFn);
+            expect(result).toEqual({ node: 'pve02', type: 'lxc' });
+        });
+        it('throws when VMID not found', async () => {
+            const fetchFn = mockPveResponse({ data: [] });
+            await expect(resolveNode(999, pveConfig, pveCreds, fetchFn)).rejects.toThrow('VM/container 999 not found in cluster');
+        });
+    });
+    describe('cluster.status', () => {
+        it('returns cluster info with quorum', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    { name: 'mycluster', type: 'cluster', quorate: 1 },
+                    { name: 'pve01', type: 'node', online: 1, ip: '10.0.0.1' },
+                    { name: 'pve02', type: 'node', online: 1, ip: '10.0.0.2' },
+                ],
+            });
+            const result = (await handler('cluster.status')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.clusterName).toBe('mycluster');
+            expect(result.quorate).toBe(true);
+            expect(result.nodes).toHaveLength(2);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('flags offline nodes and lost quorum', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    { name: 'mycluster', type: 'cluster', quorate: 0 },
+                    { name: 'pve01', type: 'node', online: 1 },
+                    { name: 'pve02', type: 'node', online: 0 },
+                ],
+            });
+            const result = (await handler('cluster.status')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings).toContain('Cluster has lost quorum');
+            expect(result.warnings).toContain('Node pve02 is offline');
+        });
+    });
+    describe('cluster.ha.status', () => {
+        it('returns HA status and resources', async () => {
+            let callCount = 0;
+            const fetchFn = vi.fn().mockImplementation(() => {
+                callCount++;
+                if (callCount === 1) {
+                    return Promise.resolve(new Response(JSON.stringify({
+                        data: [{ id: 'manager', type: 'manager', status: 'active' }],
+                    }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+                }
+                return Promise.resolve(new Response(JSON.stringify({
+                    data: [{ sid: 'vm:100', state: 'started', node: 'pve01', type: 'vm' }],
+                }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+            });
+            const result = (await handler('cluster.ha.status')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.managerStatus).toBe('active');
+            expect(result.resources).toHaveLength(1);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('flags error/fence states', async () => {
+            let callCount = 0;
+            const fetchFn = vi.fn().mockImplementation(() => {
+                callCount++;
+                if (callCount === 1) {
+                    return Promise.resolve(new Response(JSON.stringify({ data: [{ id: 'manager', type: 'manager', status: 'active' }] }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+                }
+                return Promise.resolve(new Response(JSON.stringify({
+                    data: [
+                        { sid: 'vm:100', state: 'error', node: 'pve01', type: 'vm' },
+                        { sid: 'vm:101', state: 'fence', node: 'pve02', type: 'vm' },
+                    ],
+                }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+            });
+            const result = (await handler('cluster.ha.status')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings).toContain('HA resource vm:100 in error state');
+            expect(result.warnings).toContain('HA resource vm:101 in fence state');
+        });
+    });
+    describe('nodes.list', () => {
+        it('returns node data', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    {
+                        node: 'pve01',
+                        status: 'online',
+                        uptime: 86400,
+                        cpu: 0.25,
+                        maxcpu: 8,
+                        mem: 4e9,
+                        maxmem: 16e9,
+                    },
+                    {
+                        node: 'pve02',
+                        status: 'online',
+                        uptime: 172800,
+                        cpu: 0.5,
+                        maxcpu: 8,
+                        mem: 8e9,
+                        maxmem: 16e9,
+                    },
+                ],
+            });
+            const result = (await handler('nodes.list')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.nodes).toHaveLength(2);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('flags offline nodes and high resource usage', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    { node: 'pve01', status: 'offline', cpu: 0.1, mem: 1e9, maxmem: 16e9 },
+                    { node: 'pve02', status: 'online', cpu: 0.95, mem: 15e9, maxmem: 16e9 },
+                ],
+            });
+            const result = (await handler('nodes.list')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings).toContain('Node pve01 is offline');
+            expect(result.warnings.some((w) => w.includes('pve02 CPU'))).toBe(true);
+            expect(result.warnings.some((w) => w.includes('pve02 memory'))).toBe(true);
+        });
+    });
+    describe('node.storage', () => {
+        it('returns storage pools', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    {
+                        storage: 'local',
+                        type: 'dir',
+                        total: 100e9,
+                        used: 40e9,
+                        avail: 60e9,
+                        enabled: 1,
+                        active: 1,
+                    },
+                    {
+                        storage: 'ceph-pool',
+                        type: 'rbd',
+                        total: 1e12,
+                        used: 200e9,
+                        avail: 800e9,
+                        shared: 1,
+                        enabled: 1,
+                        active: 1,
+                    },
+                ],
+            });
+            const result = (await handler('node.storage')({ node: 'pve01' }, pveConfig, pveCreds, fetchFn));
+            expect(result.storages).toHaveLength(2);
+            expect(result.storages[1]?.shared).toBe(true);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('requires node parameter', async () => {
+            const fetchFn = mockPveResponse({});
+            await expect(handler('node.storage')({}, pveConfig, pveCreds, fetchFn)).rejects.toThrow('node parameter is required');
+        });
+        it('flags high usage and disabled storage', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    {
+                        storage: 'local',
+                        type: 'dir',
+                        total: 100e9,
+                        used: 90e9,
+                        avail: 10e9,
+                        enabled: 1,
+                        active: 1,
+                    },
+                    {
+                        storage: 'nfs',
+                        type: 'nfs',
+                        total: 100e9,
+                        used: 10e9,
+                        avail: 90e9,
+                        enabled: 0,
+                        active: 0,
+                    },
+                ],
+            });
+            const result = (await handler('node.storage')({ node: 'pve01' }, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings.some((w) => w.includes('local') && w.includes('90%'))).toBe(true);
+            expect(result.warnings).toContain('Storage nfs is disabled');
+        });
+    });
+    describe('vm.status', () => {
+        it('returns VM status', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    {
+                        vmid: 100,
+                        name: 'web-01',
+                        status: 'running',
+                        node: 'pve01',
+                        type: 'qemu',
+                        uptime: 3600,
+                        cpu: 0.1,
+                        mem: 2e9,
+                        maxmem: 4e9,
+                    },
+                ],
+            });
+            const result = (await handler('vm.status')({ vmid: 100 }, pveConfig, pveCreds, fetchFn));
+            expect(result.vmid).toBe(100);
+            expect(result.name).toBe('web-01');
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('throws when VM not found', async () => {
+            const fetchFn = mockPveResponse({ data: [] });
+            await expect(handler('vm.status')({ vmid: 999 }, pveConfig, pveCreds, fetchFn)).rejects.toThrow('VM/container 999 not found');
+        });
+        it('requires vmid parameter', async () => {
+            const fetchFn = mockPveResponse({});
+            await expect(handler('vm.status')({}, pveConfig, pveCreds, fetchFn)).rejects.toThrow('vmid parameter is required');
+        });
+        it('flags stopped, locked, and HA error VMs', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    {
+                        vmid: 100,
+                        name: 'web-01',
+                        status: 'stopped',
+                        node: 'pve01',
+                        type: 'qemu',
+                        lock: 'backup',
+                        hastate: 'error',
+                    },
+                ],
+            });
+            const result = (await handler('vm.status')({ vmid: 100 }, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings).toContain('VM is stopped');
+            expect(result.warnings).toContain('VM has lock: backup');
+            expect(result.warnings).toContain('HA state: error');
+        });
+    });
+    describe('vm.config', () => {
+        it('parses disk entries from config', async () => {
+            // First call: resolveNode
+            // Second call: config
+            let callCount = 0;
+            const fetchFn = vi.fn().mockImplementation(() => {
+                callCount++;
+                if (callCount === 1) {
+                    return Promise.resolve(new Response(JSON.stringify({ data: [{ vmid: 100, node: 'pve01', type: 'qemu' }] }), {
+                        status: 200,
+                        headers: { 'Content-Type': 'application/json' },
+                    }));
+                }
+                return Promise.resolve(new Response(JSON.stringify({
+                    data: {
+                        name: 'web-01',
+                        memory: 4096,
+                        cores: 2,
+                        scsi0: 'local-lvm:vm-100-disk-0,size=32G',
+                        ide2: 'none,media=cdrom',
+                        net0: 'virtio=AA:BB:CC:DD:EE:FF,bridge=vmbr0',
+                    },
+                }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+            });
+            const result = (await handler('vm.config')({ vmid: 100 }, pveConfig, pveCreds, fetchFn));
+            expect(result.vmid).toBe(100);
+            expect(result.node).toBe('pve01');
+            expect(result.disks).toHaveLength(1);
+            expect(result.disks[0]?.storage).toBe('local-lvm');
+            expect(result.disks[0]?.size).toBe('32G');
+            expect(result.warnings).toContain('Disk scsi0 uses local storage (local-lvm) — not shared for HA');
+        });
+        it('uses provided node without resolving', async () => {
+            const fetchFn = mockPveResponse({
+                data: { name: 'web-01', memory: 4096 },
+            });
+            const result = (await handler('vm.config')({ vmid: 100, node: 'pve01' }, pveConfig, pveCreds, fetchFn));
+            expect(result.node).toBe('pve01');
+            // Only 1 call (no resolveNode)
+            expect(fetchFn).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('vm.snapshots', () => {
+        it('returns snapshots and filters "current"', async () => {
+            const now = Math.floor(Date.now() / 1000);
+            const fetchFn = mockPveResponse({
+                data: [
+                    { name: 'current', description: 'You are here!' },
+                    {
+                        name: 'pre-upgrade',
+                        description: 'Before upgrade',
+                        snaptime: now - 3600,
+                        parent: 'current',
+                    },
+                ],
+            });
+            const result = (await handler('vm.snapshots')({ vmid: 100, node: 'pve01' }, pveConfig, pveCreds, fetchFn));
+            expect(result.snapshots).toHaveLength(1);
+            expect(result.snapshots[0]?.name).toBe('pre-upgrade');
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('flags old snapshots', async () => {
+            const eightDaysAgo = Math.floor(Date.now() / 1000) - 8 * 24 * 60 * 60;
+            const fetchFn = mockPveResponse({
+                data: [{ name: 'old-snap', description: 'Old one', snaptime: eightDaysAgo }],
+            });
+            const result = (await handler('vm.snapshots')({ vmid: 100, node: 'pve01' }, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings.some((w) => w.includes('older than 7 days'))).toBe(true);
+        });
+    });
+    describe('storage.content', () => {
+        it('returns volumes', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    { volid: 'local-lvm:vm-100-disk-0', vmid: 100, size: 32e9, format: 'raw' },
+                    { volid: 'local-lvm:vm-101-disk-0', vmid: 101, size: 64e9, format: 'raw' },
+                ],
+            });
+            const result = (await handler('storage.content')({ node: 'pve01', storage: 'local-lvm' }, pveConfig, pveCreds, fetchFn));
+            expect(result.count).toBe(2);
+        });
+        it('filters by vmid', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    { volid: 'local-lvm:vm-100-disk-0', vmid: 100, size: 32e9 },
+                    { volid: 'local-lvm:vm-101-disk-0', vmid: 101, size: 64e9 },
+                ],
+            });
+            const result = (await handler('storage.content')({ node: 'pve01', storage: 'local-lvm', vmid: 100 }, pveConfig, pveCreds, fetchFn));
+            expect(result.count).toBe(1);
+        });
+        it('requires node and storage', async () => {
+            const fetchFn = mockPveResponse({});
+            await expect(handler('storage.content')({}, pveConfig, pveCreds, fetchFn)).rejects.toThrow('node parameter is required');
+            await expect(handler('storage.content')({ node: 'pve01' }, pveConfig, pveCreds, fetchFn)).rejects.toThrow('storage parameter is required');
+        });
+    });
+    describe('cluster.tasks', () => {
+        it('returns tasks', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    {
+                        upid: 'UPID:pve01:001',
+                        type: 'qmstart',
+                        status: 'OK',
+                        starttime: 1000,
+                        endtime: 1010,
+                        node: 'pve01',
+                        user: 'root@pam',
+                        id: '100',
+                    },
+                ],
+            });
+            const result = (await handler('cluster.tasks')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.tasks).toHaveLength(1);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('filters by vmid', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    { upid: 'UPID:1', type: 'qmstart', status: 'OK', node: 'pve01', id: '100', endtime: 1 },
+                    { upid: 'UPID:2', type: 'qmstart', status: 'OK', node: 'pve01', id: '101', endtime: 2 },
+                ],
+            });
+            const result = (await handler('cluster.tasks')({ vmid: 100 }, pveConfig, pveCreds, fetchFn));
+            expect(result.tasks).toHaveLength(1);
+        });
+        it('flags failed tasks and running migrations', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    {
+                        upid: 'UPID:1',
+                        type: 'qmstart',
+                        status: 'WARNINGS: something',
+                        node: 'pve01',
+                        endtime: 1,
+                    },
+                    { upid: 'UPID:2', type: 'qmigrate', status: '', node: 'pve02' },
+                ],
+            });
+            const result = (await handler('cluster.tasks')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings.some((w) => w.includes('failed'))).toBe(true);
+            expect(result.warnings.some((w) => w.includes('Migration in progress'))).toBe(true);
+        });
+    });
+    describe('node.lvm', () => {
+        it('returns volume groups', async () => {
+            const fetchFn = mockPveResponse({
+                data: [{ name: 'pve', size: 500e9, free: 200e9, pvs: 1, lvs: 3 }],
+            });
+            const result = (await handler('node.lvm')({ node: 'pve01' }, pveConfig, pveCreds, fetchFn));
+            expect(result.volumeGroups).toHaveLength(1);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('flags VGs with no free space', async () => {
+            const fetchFn = mockPveResponse({
+                data: [{ name: 'pve', size: 500e9, free: 0, pvs: 1, lvs: 5 }],
+            });
+            const result = (await handler('node.lvm')({ node: 'pve01' }, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings).toContain('Volume group pve has no free space');
+        });
+        it('requires node parameter', async () => {
+            const fetchFn = mockPveResponse({});
+            await expect(handler('node.lvm')({}, pveConfig, pveCreds, fetchFn)).rejects.toThrow('node parameter is required');
+        });
+    });
+    describe('lxc.status', () => {
+        it('returns container status', async () => {
+            // resolveNode call
+            let callCount = 0;
+            const fetchFn = vi.fn().mockImplementation(() => {
+                callCount++;
+                if (callCount === 1) {
+                    return Promise.resolve(new Response(JSON.stringify({ data: [{ vmid: 200, node: 'pve02', type: 'lxc' }] }), {
+                        status: 200,
+                        headers: { 'Content-Type': 'application/json' },
+                    }));
+                }
+                return Promise.resolve(new Response(JSON.stringify({
+                    data: {
+                        vmid: 200,
+                        name: 'ct-nginx',
+                        status: 'running',
+                        uptime: 7200,
+                        cpu: 0.05,
+                        mem: 256e6,
+                        maxmem: 512e6,
+                        disk: 1e9,
+                        maxdisk: 8e9,
+                        swap: 0,
+                        maxswap: 512e6,
+                    },
+                }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+            });
+            const result = (await handler('lxc.status')({ vmid: 200 }, pveConfig, pveCreds, fetchFn));
+            expect(result.vmid).toBe(200);
+            expect(result.name).toBe('ct-nginx');
+            expect(result.node).toBe('pve02');
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('rejects qemu VMID', async () => {
+            const fetchFn = mockPveResponse({
+                data: [{ vmid: 100, node: 'pve01', type: 'qemu' }],
+            });
+            await expect(handler('lxc.status')({ vmid: 100 }, pveConfig, pveCreds, fetchFn)).rejects.toThrow('not an LXC container');
+        });
+    });
+    describe('lxc.config', () => {
+        it('parses rootfs and mountpoints', async () => {
+            const fetchFn = mockPveResponse({
+                data: {
+                    hostname: 'ct-nginx',
+                    rootfs: 'local-lvm:subvol-200-disk-0,size=8G',
+                    mp0: 'local-lvm:subvol-200-disk-1,mp=/data,size=20G',
+                    cores: 2,
+                    memory: 512,
+                },
+            });
+            const result = (await handler('lxc.config')({ vmid: 200, node: 'pve02' }, pveConfig, pveCreds, fetchFn));
+            expect(result.rootfs).toEqual({ storage: 'local-lvm', size: '8G' });
+            expect(result.mountpoints).toHaveLength(1);
+            expect(result.mountpoints[0]?.mountpoint).toBe('/data');
+            expect(result.mountpoints[0]?.size).toBe('20G');
+        });
+    });
+    describe('ceph.status', () => {
+        it('returns ceph health and OSDs', async () => {
+            let callCount = 0;
+            const fetchFn = vi.fn().mockImplementation(() => {
+                callCount++;
+                if (callCount === 1) {
+                    // /cluster/ceph/status
+                    return Promise.resolve(new Response(JSON.stringify({
+                        data: {
+                            health: { status: 'HEALTH_OK' },
+                            osdmap: { osdmap: { num_osds: 6, num_up_osds: 6, num_in_osds: 6 } },
+                            pgmap: {
+                                pgs_by_state: [{ state_name: 'active+clean', count: 256 }],
+                                bytes_total: 6e12,
+                                bytes_used: 2e12,
+                                bytes_avail: 4e12,
+                            },
+                        },
+                    }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+                }
+                if (callCount === 2) {
+                    // /nodes
+                    return Promise.resolve(new Response(JSON.stringify({ data: [{ node: 'pve01', status: 'online' }] }), {
+                        status: 200,
+                        headers: { 'Content-Type': 'application/json' },
+                    }));
+                }
+                // /nodes/pve01/ceph/osd
+                return Promise.resolve(new Response(JSON.stringify({
+                    data: [
+                        { id: 0, name: 'osd.0', up: 1 },
+                        { id: 1, name: 'osd.1', up: 1 },
+                    ],
+                }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+            });
+            const result = (await handler('ceph.status')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.available).toBe(true);
+            expect(result.health).toBe('HEALTH_OK');
+            expect(result.osdCount).toBe(6);
+            expect(result.osds).toHaveLength(2);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('handles degraded ceph', async () => {
+            const fetchFn = vi.fn().mockImplementation(() => {
+                return Promise.resolve(new Response(JSON.stringify({
+                    data: {
+                        health: { status: 'HEALTH_WARN' },
+                        osdmap: { osdmap: { num_osds: 6, num_up_osds: 4, num_in_osds: 6 } },
+                        pgmap: { bytes_total: 6e12, bytes_used: 2e12, bytes_avail: 4e12 },
+                    },
+                }), { status: 200, headers: { 'Content-Type': 'application/json' } }));
+            });
+            const result = (await handler('ceph.status')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.warnings.some((w) => w.includes('HEALTH_WARN'))).toBe(true);
+            expect(result.warnings.some((w) => w.includes('2 OSD(s) down'))).toBe(true);
+        });
+        it('handles no ceph (404)', async () => {
+            const fetchFn = vi
+                .fn()
+                .mockResolvedValue(new Response('Not Found', { status: 404, statusText: 'Not Found' }));
+            const result = (await handler('ceph.status')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.available).toBe(false);
+            expect(result.warnings).toContain('Ceph is not configured on this cluster');
+        });
+    });
+    describe('cluster.resources', () => {
+        it('returns all VMs and containers', async () => {
+            const fetchFn = mockPveResponse({
+                data: [
+                    {
+                        vmid: 100,
+                        name: 'web-01',
+                        node: 'pve01',
+                        type: 'qemu',
+                        status: 'running',
+                        uptime: 3600,
+                        cpu: 0.1,
+                        mem: 2e9,
+                        maxmem: 4e9,
+                    },
+                    {
+                        vmid: 200,
+                        name: 'ct-db',
+                        node: 'pve02',
+                        type: 'lxc',
+                        status: 'running',
+                        uptime: 7200,
+                        cpu: 0.05,
+                        mem: 512e6,
+                        maxmem: 1e9,
+                    },
+                    { vmid: 101, name: 'stopped-vm', node: 'pve01', type: 'qemu', status: 'stopped' },
+                ],
+            });
+            const result = (await handler('cluster.resources')({}, pveConfig, pveCreds, fetchFn));
+            expect(result.resources).toHaveLength(3);
+            expect(result.resources[0]?.vmid).toBe(100);
+            expect(result.resources[0]?.type).toBe('qemu');
+            expect(result.resources[1]?.type).toBe('lxc');
+        });
+        it('calls /cluster/resources?type=vm', async () => {
+            const fetchFn = mockPveResponse({ data: [] });
+            await handler('cluster.resources')({}, pveConfig, pveCreds, fetchFn);
+            const [url] = callArgs(fetchFn, 0);
+            expect(url).toContain('/cluster/resources');
+            expect(url).toContain('type=vm');
+        });
+    });
+    describe('manifest', () => {
+        it('has correct name and 14 probes', () => {
+            expect(proxmoxPack.manifest.name).toBe('proxmox');
+            expect(proxmoxPack.manifest.probes).toHaveLength(14);
+        });
+        it('all handlers match manifest probes', () => {
+            const probeNames = proxmoxPack.manifest.probes.map((p) => p.name);
+            const handlerNames = Object.keys(proxmoxPack.handlers);
+            expect(handlerNames.sort()).toEqual(probeNames.sort());
+        });
+        it('has correct timeouts (30s for ceph, 15s for others)', () => {
+            const probeMap = new Map(proxmoxPack.manifest.probes.map((p) => [p.name, p.timeout]));
+            expect(probeMap.get('ceph.status')).toBe(30000);
+            for (const [name, timeout] of probeMap) {
+                if (name !== 'ceph.status') {
+                    expect(timeout).toBe(15000);
+                }
+            }
+        });
+        it('has virtualization runbook', () => {
+            expect(proxmoxPack.manifest.runbook).toEqual({
+                category: 'virtualization',
+                probes: ['cluster.status', 'nodes.list', 'ceph.status'],
+                parallel: true,
+            });
+        });
+    });
+    describe('error handling', () => {
+        it('throws on non-200 API response for probes', async () => {
+            const fetchFn = mockFetchError(403);
+            await expect(handler('nodes.list')({}, pveConfig, pveCreds, fetchFn)).rejects.toThrow('Proxmox API returned 403');
+        });
+    });
+});
+//# sourceMappingURL=proxmox.test.js.map