@sonde/packs 0.1.0 → 0.1.1

package/src/proxmox/probes/ha-status.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { HaStatusResult } from './ha-status.js';
+import { haStatus, parseHaStatus } from './ha-status.js';
+
+const SAMPLE_OUTPUT = `quorum OK
+master pve01 (192.168.1.1, 9dab1c9a)
+vm:100 started pve01 none
+vm:101 started pve02 none
+ct:200 started pve01 none`;
+
+describe('parseHaStatus', () => {
+  it('parses HA resource entries', () => {
+    const result = parseHaStatus(SAMPLE_OUTPUT);
+    expect(result.resources).toHaveLength(3);
+    expect(result.resources[0]).toEqual({
+      sid: 'vm:100',
+      state: 'started',
+      node: 'pve01',
+      request: 'none',
+    });
+    expect(result.resources[2]).toEqual({
+      sid: 'ct:200',
+      state: 'started',
+      node: 'pve01',
+      request: 'none',
+    });
+  });
+
+  it('flags error state', () => {
+    const output = `quorum OK
+vm:100 error pve01 none`;
+    const result = parseHaStatus(output);
+    expect(result.warnings).toContain('HA resource vm:100 in error state on pve01');
+  });
+
+  it('flags fence state', () => {
+    const output = `quorum OK
+vm:101 fence pve02 none`;
+    const result = parseHaStatus(output);
+    expect(result.warnings).toContain('HA resource vm:101 in fence state on pve02');
+  });
+
+  it('flags stopped resources', () => {
+    const output = `quorum OK
+vm:100 stopped pve01 none`;
+    const result = parseHaStatus(output);
+    expect(result.warnings).toContain('HA resource vm:100 is stopped');
+  });
+
+  it('returns empty for no resources', () => {
+    const result = parseHaStatus('quorum OK');
+    expect(result.resources).toHaveLength(0);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  it('skips master/quorum lines', () => {
+    const result = parseHaStatus(SAMPLE_OUTPUT);
+    const sids = result.resources.map((r) => r.sid);
+    expect(sids).not.toContain('quorum');
+    expect(sids).not.toContain('master');
+  });
+});
+
+describe('haStatus handler', () => {
+  it('calls ha-manager status and returns parsed result', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('ha-manager');
+      expect(args).toEqual(['status']);
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await haStatus(undefined, mockExec)) as HaStatusResult;
+    expect(result.resources).toHaveLength(3);
+  });
+});

package/src/proxmox/probes/ha-status.ts

@@ -0,0 +1,56 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface HaResource {
+  sid: string;
+  state: string;
+  node: string;
+  request: string;
+}
+
+export interface HaStatusResult {
+  resources: HaResource[];
+  warnings: string[];
+}
+
+/**
+ * Runs `ha-manager status` and parses the output.
+ * Format: "quorum OK\nsid state node request\n..."
+ */
+export const haStatus: ProbeHandler = async (_params, exec) => {
+  const stdout = await exec('ha-manager', ['status']);
+  return parseHaStatus(stdout);
+};
+
+export function parseHaStatus(stdout: string): HaStatusResult {
+  const lines = stdout.trim().split('\n').filter(Boolean);
+  const resources: HaResource[] = [];
+  const warnings: string[] = [];
+
+  for (const line of lines) {
+    // Skip header/quorum lines
+    if (line.startsWith('quorum') || line.startsWith('master')) continue;
+
+    // Resource lines: "vm:100 started pve01 none"
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 2) continue;
+
+    const sid = parts[0] ?? '';
+    // Skip if it doesn't look like a resource SID (e.g. vm:100, ct:200)
+    if (!sid.includes(':')) continue;
+
+    const state = parts[1] ?? '';
+    const node = parts[2] ?? '';
+    const request = parts[3] ?? 'none';
+
+    resources.push({ sid, state, node, request });
+
+    if (state === 'error' || state === 'fence') {
+      warnings.push(`HA resource ${sid} in ${state} state on ${node}`);
+    }
+    if (state === 'stopped') {
+      warnings.push(`HA resource ${sid} is stopped`);
+    }
+  }
+
+  return { resources, warnings };
+}

package/src/proxmox/probes/lvm.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { LvmResult } from './lvm.js';
+import { lvm, parseLvm } from './lvm.js';
+
+const LVS_OUTPUT = JSON.stringify({
+  report: [
+    {
+      lv: [
+        {
+          lv_name: 'data',
+          vg_name: 'pve',
+          lv_size: '200000000000B',
+          lv_attr: '-wi-a-----',
+          pool_lv: '',
+          data_percent: '',
+        },
+        {
+          lv_name: 'root',
+          vg_name: 'pve',
+          lv_size: '50000000000B',
+          lv_attr: '-wi-a-----',
+          pool_lv: '',
+          data_percent: '',
+        },
+        {
+          lv_name: 'thinpool',
+          vg_name: 'pve',
+          lv_size: '400000000000B',
+          lv_attr: 'twi-aotz--',
+          pool_lv: '',
+          data_percent: '92.50',
+        },
+      ],
+    },
+  ],
+});
+
+const VGS_OUTPUT = JSON.stringify({
+  report: [
+    {
+      vg: [
+        { vg_name: 'pve', vg_size: '500000000000B', vg_free: '0B', pv_count: '1', lv_count: '3' },
+      ],
+    },
+  ],
+});
+
+const PVS_OUTPUT = JSON.stringify({
+  report: [
+    {
+      pv: [
+        {
+          pv_name: '/dev/sda3',
+          vg_name: 'pve',
+          pv_size: '500000000000B',
+          pv_free: '0B',
+          pv_fmt: 'lvm2',
+        },
+      ],
+    },
+  ],
+});
+
+describe('parseLvm', () => {
+  it('parses LVM topology from JSON reports', () => {
+    const result = parseLvm(LVS_OUTPUT, VGS_OUTPUT, PVS_OUTPUT);
+
+    expect(result.logicalVolumes).toHaveLength(3);
+    expect(result.logicalVolumes[0]?.name).toBe('data');
+    expect(result.logicalVolumes[0]?.vgName).toBe('pve');
+
+    expect(result.volumeGroups).toHaveLength(1);
+    expect(result.volumeGroups[0]?.name).toBe('pve');
+
+    expect(result.physicalVolumes).toHaveLength(1);
+    expect(result.physicalVolumes[0]?.name).toBe('/dev/sda3');
+    expect(result.physicalVolumes[0]?.format).toBe('lvm2');
+  });
+
+  it('flags thin pool with high usage', () => {
+    const result = parseLvm(LVS_OUTPUT, VGS_OUTPUT, PVS_OUTPUT);
+    expect(result.warnings.some((w) => w.includes('thinpool') && w.includes('92.50'))).toBe(true);
+  });
+
+  it('flags VGs with no free space', () => {
+    const result = parseLvm(LVS_OUTPUT, VGS_OUTPUT, PVS_OUTPUT);
+    expect(result.warnings).toContain('Volume group pve has no free space');
+  });
+
+  it('does not flag healthy thin pools', () => {
+    const healthyLvs = JSON.stringify({
+      report: [
+        {
+          lv: [
+            {
+              lv_name: 'thinpool',
+              vg_name: 'pve',
+              lv_size: '400B',
+              lv_attr: 'twi-aotz--',
+              pool_lv: '',
+              data_percent: '50.00',
+            },
+          ],
+        },
+      ],
+    });
+    const healthyVgs = JSON.stringify({
+      report: [
+        {
+          vg: [{ vg_name: 'pve', vg_size: '500B', vg_free: '100B', pv_count: '1', lv_count: '1' }],
+        },
+      ],
+    });
+    const result = parseLvm(healthyLvs, healthyVgs, PVS_OUTPUT);
+    expect(result.warnings).toHaveLength(0);
+  });
+});
+
+describe('lvm handler', () => {
+  it('calls lvs, vgs, pvs with correct args', async () => {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    const mockExec: ExecFn = async (cmd, args) => {
+      calls.push({ cmd, args });
+      if (cmd === 'lvs') return LVS_OUTPUT;
+      if (cmd === 'vgs') return VGS_OUTPUT;
+      return PVS_OUTPUT;
+    };
+
+    const result = (await lvm(undefined, mockExec)) as LvmResult;
+    expect(result.logicalVolumes).toHaveLength(3);
+
+    expect(calls).toHaveLength(3);
+    expect(calls[0]?.cmd).toBe('lvs');
+    expect(calls[0]?.args).toContain('--reportformat');
+    expect(calls[0]?.args).toContain('json');
+    expect(calls[1]?.cmd).toBe('vgs');
+    expect(calls[2]?.cmd).toBe('pvs');
+  });
+});

package/src/proxmox/probes/lvm.ts

@@ -0,0 +1,121 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface LogicalVolume {
+  name: string;
+  vgName: string;
+  size: string;
+  attrs: string;
+  pool: string;
+  dataPercent: string;
+}
+
+export interface VolumeGroup {
+  name: string;
+  size: string;
+  free: string;
+  pvCount: number;
+  lvCount: number;
+}
+
+export interface PhysicalVolume {
+  name: string;
+  vgName: string;
+  size: string;
+  free: string;
+  format: string;
+}
+
+export interface LvmResult {
+  logicalVolumes: LogicalVolume[];
+  volumeGroups: VolumeGroup[];
+  physicalVolumes: PhysicalVolume[];
+  warnings: string[];
+}
+
+/**
+ * Runs lvs, vgs, pvs with --reportformat json and returns structured LVM topology.
+ */
+export const lvm: ProbeHandler = async (_params, exec) => {
+  const [lvsOut, vgsOut, pvsOut] = await Promise.all([
+    exec('lvs', [
+      '--reportformat',
+      'json',
+      '--units',
+      'b',
+      '-o',
+      'lv_name,vg_name,lv_size,lv_attr,pool_lv,data_percent',
+    ]),
+    exec('vgs', [
+      '--reportformat',
+      'json',
+      '--units',
+      'b',
+      '-o',
+      'vg_name,vg_size,vg_free,pv_count,lv_count',
+    ]),
+    exec('pvs', [
+      '--reportformat',
+      'json',
+      '--units',
+      'b',
+      '-o',
+      'pv_name,vg_name,pv_size,pv_free,pv_fmt',
+    ]),
+  ]);
+  return parseLvm(lvsOut, vgsOut, pvsOut);
+};
+
+export function parseLvm(lvsOut: string, vgsOut: string, pvsOut: string): LvmResult {
+  const warnings: string[] = [];
+
+  const lvsData = JSON.parse(lvsOut);
+  const logicalVolumes: LogicalVolume[] = (lvsData.report?.[0]?.lv ?? []).map(
+    (lv: Record<string, string>) => ({
+      name: lv.lv_name ?? '',
+      vgName: lv.vg_name ?? '',
+      size: lv.lv_size ?? '',
+      attrs: lv.lv_attr ?? '',
+      pool: lv.pool_lv ?? '',
+      dataPercent: lv.data_percent ?? '',
+    }),
+  );
+
+  const vgsData = JSON.parse(vgsOut);
+  const volumeGroups: VolumeGroup[] = (vgsData.report?.[0]?.vg ?? []).map(
+    (vg: Record<string, string>) => ({
+      name: vg.vg_name ?? '',
+      size: vg.vg_size ?? '',
+      free: vg.vg_free ?? '',
+      pvCount: Number(vg.pv_count ?? 0),
+      lvCount: Number(vg.lv_count ?? 0),
+    }),
+  );
+
+  const pvsData = JSON.parse(pvsOut);
+  const physicalVolumes: PhysicalVolume[] = (pvsData.report?.[0]?.pv ?? []).map(
+    (pv: Record<string, string>) => ({
+      name: pv.pv_name ?? '',
+      vgName: pv.vg_name ?? '',
+      size: pv.pv_size ?? '',
+      free: pv.pv_free ?? '',
+      format: pv.pv_fmt ?? '',
+    }),
+  );
+
+  // Flag thin pools with high usage
+  for (const lv of logicalVolumes) {
+    if (lv.dataPercent && Number.parseFloat(lv.dataPercent) > 85) {
+      warnings.push(`Thin pool ${lv.name} is ${lv.dataPercent}% used`);
+    }
+  }
+
+  // Flag VGs with no free space
+  for (const vg of volumeGroups) {
+    const freeBytes = Number.parseInt(vg.free, 10);
+    if (!Number.isNaN(freeBytes) && freeBytes === 0) {
+      warnings.push(`Volume group ${vg.name} has no free space`);
+    }
+  }
+
+  return { logicalVolumes, volumeGroups, physicalVolumes, warnings };
+}

package/src/proxmox/probes/lxc-config.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { LxcConfigResult } from './lxc-config.js';
+import { lxcConfig, parseLxcConfig } from './lxc-config.js';
+
+const SAMPLE_OUTPUT = `arch: amd64
+cores: 2
+hostname: ct-nginx
+memory: 512
+mp0: local-lvm:subvol-200-disk-1,mp=/data,size=20G
+net0: name=eth0,bridge=vmbr0,firewall=1,hwaddr=AA:BB:CC:DD:EE:FF,ip=dhcp,type=veth
+ostype: debian
+rootfs: local-lvm:subvol-200-disk-0,size=8G
+swap: 256
+unprivileged: 1`;
+
+describe('parseLxcConfig', () => {
+  it('parses key: value pairs into config map', () => {
+    const result = parseLxcConfig(SAMPLE_OUTPUT, 200);
+    expect(result.vmid).toBe(200);
+    expect(result.config.hostname).toBe('ct-nginx');
+    expect(result.config.memory).toBe('512');
+    expect(result.config.cores).toBe('2');
+  });
+
+  it('parses rootfs storage and size', () => {
+    const result = parseLxcConfig(SAMPLE_OUTPUT, 200);
+    expect(result.rootfs).toEqual({ storage: 'local-lvm', size: '8G' });
+  });
+
+  it('parses mountpoints', () => {
+    const result = parseLxcConfig(SAMPLE_OUTPUT, 200);
+    expect(result.mountpoints).toHaveLength(1);
+    expect(result.mountpoints[0]).toEqual({
+      key: 'mp0',
+      storage: 'local-lvm',
+      volume: 'subvol-200-disk-1',
+      mountpoint: '/data',
+      size: '20G',
+    });
+  });
+
+  it('parses network interfaces', () => {
+    const result = parseLxcConfig(SAMPLE_OUTPUT, 200);
+    expect(result.network).toHaveLength(1);
+    expect(result.network[0]?.key).toBe('net0');
+    expect(result.network[0]?.raw).toContain('bridge=vmbr0');
+  });
+
+  it('handles no mountpoints', () => {
+    const output = `hostname: ct-simple
+rootfs: local-lvm:subvol-300-disk-0,size=4G`;
+    const result = parseLxcConfig(output, 300);
+    expect(result.mountpoints).toHaveLength(0);
+    expect(result.rootfs).toEqual({ storage: 'local-lvm', size: '4G' });
+  });
+
+  it('handles missing rootfs', () => {
+    const output = 'hostname: ct-minimal';
+    const result = parseLxcConfig(output, 400);
+    expect(result.rootfs).toBeNull();
+  });
+
+  it('handles empty output', () => {
+    const result = parseLxcConfig('', 200);
+    expect(result.config).toEqual({});
+    expect(result.rootfs).toBeNull();
+    expect(result.mountpoints).toHaveLength(0);
+  });
+});
+
+describe('lxcConfig handler', () => {
+  it('calls pct config with vmid and returns parsed result', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('pct');
+      expect(args).toEqual(['config', '200']);
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await lxcConfig({ vmid: 200 }, mockExec)) as LxcConfigResult;
+    expect(result.vmid).toBe(200);
+    expect(result.rootfs?.storage).toBe('local-lvm');
+  });
+
+  it('throws when vmid is missing', async () => {
+    const mockExec: ExecFn = async () => '';
+    await expect(lxcConfig({}, mockExec)).rejects.toThrow('vmid parameter is required');
+  });
+});

package/src/proxmox/probes/lxc-config.ts

@@ -0,0 +1,90 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface LxcMountpoint {
+  key: string;
+  storage: string;
+  volume: string;
+  mountpoint: string;
+  size: string;
+}
+
+export interface LxcConfigResult {
+  vmid: number;
+  config: Record<string, string>;
+  rootfs: { storage: string; size: string } | null;
+  mountpoints: LxcMountpoint[];
+  network: Array<{ key: string; raw: string }>;
+  warnings: string[];
+}
+
+/**
+ * Runs `pct config {vmid}` and parses key: value output.
+ * Identifies rootfs storage, mountpoints, network config.
+ */
+export const lxcConfig: ProbeHandler = async (params, exec) => {
+  const vmid = params?.vmid as number;
+  if (vmid == null) throw new Error('vmid parameter is required');
+
+  const stdout = await exec('pct', ['config', String(vmid)]);
+  return parseLxcConfig(stdout, vmid);
+};
+
+export function parseLxcConfig(stdout: string, vmid: number): LxcConfigResult {
+  const config: Record<string, string> = {};
+  const lines = stdout.trim().split('\n').filter(Boolean);
+
+  for (const line of lines) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    config[key] = value;
+  }
+
+  // Parse rootfs: "local-lvm:subvol-200-disk-0,size=8G"
+  let rootfs: { storage: string; size: string } | null = null;
+  if (config.rootfs) {
+    const colonIdx = config.rootfs.indexOf(':');
+    if (colonIdx > -1) {
+      const storage = config.rootfs.slice(0, colonIdx);
+      const rest = config.rootfs.slice(colonIdx + 1);
+      const sizeMatch = rest.match(/size=(\S+)/);
+      rootfs = { storage, size: sizeMatch?.[1] ?? '' };
+    }
+  }
+
+  // Parse mp0–mp255 mountpoints
+  const mountpoints: LxcMountpoint[] = [];
+  for (const [key, value] of Object.entries(config)) {
+    if (!/^mp\d+$/.test(key)) continue;
+    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 volume = commaIdx > -1 ? rest.slice(0, commaIdx) : rest;
+    const optsPart = commaIdx > -1 ? rest.slice(commaIdx + 1) : '';
+
+    const mpMatch = optsPart.match(/mp=([^,]+)/);
+    const sizeMatch = optsPart.match(/size=(\S+)/);
+    mountpoints.push({
+      key,
+      storage,
+      volume,
+      mountpoint: mpMatch?.[1] ?? '',
+      size: sizeMatch?.[1] ?? '',
+    });
+  }
+
+  // Parse network interfaces
+  const network: Array<{ key: string; raw: string }> = [];
+  for (const [key, value] of Object.entries(config)) {
+    if (/^net\d+$/.test(key)) {
+      network.push({ key, raw: value });
+    }
+  }
+
+  const warnings: string[] = [];
+  return { vmid, config, rootfs, mountpoints, network, warnings };
+}

package/src/proxmox/probes/lxc-list.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { LxcListResult } from './lxc-list.js';
+import { lxcList, parseLxcList } from './lxc-list.js';
+
+const SAMPLE_OUTPUT = `VMID       Status     Lock         Name
+200        running                 ct-nginx
+201        stopped    backup       ct-db
+202        running                 ct-redis`;
+
+describe('parseLxcList', () => {
+  it('parses container list output', () => {
+    const result = parseLxcList(SAMPLE_OUTPUT);
+    expect(result.containers).toHaveLength(3);
+  });
+
+  it('extracts VMID, status, and name', () => {
+    const result = parseLxcList(SAMPLE_OUTPUT);
+    expect(result.containers[0]).toEqual({
+      vmid: 200,
+      status: 'running',
+      lock: '',
+      name: 'ct-nginx',
+    });
+  });
+
+  it('extracts lock status when present', () => {
+    const result = parseLxcList(SAMPLE_OUTPUT);
+    expect(result.containers[1]).toEqual({
+      vmid: 201,
+      status: 'stopped',
+      lock: 'backup',
+      name: 'ct-db',
+    });
+  });
+
+  it('handles empty output', () => {
+    const result = parseLxcList('');
+    expect(result.containers).toHaveLength(0);
+  });
+
+  it('handles header-only output', () => {
+    const result = parseLxcList('VMID       Status     Lock         Name');
+    expect(result.containers).toHaveLength(0);
+  });
+});
+
+describe('lxcList handler', () => {
+  it('calls pct list and returns parsed result', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('pct');
+      expect(args).toEqual(['list']);
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await lxcList(undefined, mockExec)) as LxcListResult;
+    expect(result.containers).toHaveLength(3);
+    expect(result.containers[0]?.vmid).toBe(200);
+  });
+});

package/src/proxmox/probes/lxc-list.ts

@@ -0,0 +1,67 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface LxcContainer {
+  vmid: number;
+  status: string;
+  lock: string;
+  name: string;
+}
+
+export interface LxcListResult {
+  containers: LxcContainer[];
+}
+
+/**
+ * Runs `pct list` and parses the tabular output.
+ * Format:
+ *   VMID       Status     Lock         Name
+ *   200        running                 ct-nginx
+ *   201        stopped    backup       ct-db
+ */
+export const lxcList: ProbeHandler = async (_params, exec) => {
+  const stdout = await exec('pct', ['list']);
+  return parseLxcList(stdout);
+};
+
+export function parseLxcList(stdout: string): LxcListResult {
+  const lines = stdout.trim().split('\n').filter(Boolean);
+  const containers: LxcContainer[] = [];
+
+  // Skip header line
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const parts = line.trim().split(/\s+/);
+
+    // "VMID Status Lock Name" — but Lock may be empty
+    // With lock: "200 running backup ct-nginx" (4 parts)
+    // Without lock: "200 running ct-nginx" (3 parts, lock column is blank)
+
+    // pct list uses fixed-width columns. Parse by position.
+    // VMID is first number, Status is second word.
+    // If there are 4+ parts and part[2] looks like a lock (not a hostname), it's a lock.
+    const vmid = Number.parseInt(parts[0] ?? '', 10);
+    if (Number.isNaN(vmid)) continue;
+
+    const status = parts[1] ?? '';
+
+    // Determine if part[2] is a lock or the name.
+    // Lock values are: backup, snapshot, suspended, migrate, etc.
+    // Names are typically longer/different. But the safest approach:
+    // If there are 4+ parts, the 3rd is lock and 4th+ is name.
+    // If there are 3 parts, lock is empty and 3rd is name.
+    let lock = '';
+    let name = '';
+
+    if (parts.length >= 4) {
+      lock = parts[2] ?? '';
+      name = parts.slice(3).join(' ');
+    } else if (parts.length === 3) {
+      name = parts[2] ?? '';
+    }
+
+    containers.push({ vmid, status, lock, name });
+  }
+
+  return { containers };
+}