@sonde/packs 0.1.0 → 0.1.1

package/src/postgres/probes/query-slow.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { QuerySlowResult } from './query-slow.js';
+import { parseQuerySlow, querySlow } from './query-slow.js';
+
+const SAMPLE_OUTPUT =
+  '9876\tmyapp\tappuser\t5432\tactive\tSELECT * FROM large_table WHERE expensive_join';
+
+describe('parseQuerySlow', () => {
+  it('parses slow queries', () => {
+    const result = parseQuerySlow(SAMPLE_OUTPUT, 1000);
+    expect(result.count).toBe(1);
+    expect(result.thresholdMs).toBe(1000);
+    expect(result.queries[0]?.pid).toBe(9876);
+    expect(result.queries[0]?.query).toContain('expensive_join');
+  });
+
+  it('handles no slow queries', () => {
+    const result = parseQuerySlow('', 1000);
+    expect(result.count).toBe(0);
+    expect(result.queries).toEqual([]);
+  });
+});
+
+describe('querySlow handler', () => {
+  it('calls psql with threshold param', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('psql');
+      const query = args[args.length - 1];
+      expect(query).toContain('2000');
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await querySlow({ thresholdMs: 2000 }, mockExec)) as QuerySlowResult;
+    expect(result.thresholdMs).toBe(2000);
+  });
+});

package/src/postgres/probes/query-slow.ts

@@ -0,0 +1,55 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface SlowQueryInfo {
+  pid: number;
+  database: string;
+  user: string;
+  durationMs: number;
+  state: string;
+  query: string;
+}
+
+export interface QuerySlowResult {
+  queries: SlowQueryInfo[];
+  count: number;
+  thresholdMs: number;
+}
+
+export const querySlow: ProbeHandler = async (params, exec) => {
+  const host = (params?.host as string) ?? 'localhost';
+  const port = String((params?.port as number) ?? 5432);
+  const user = (params?.user as string) ?? 'postgres';
+  const thresholdMs = (params?.thresholdMs as number) ?? 1000;
+
+  const stdout = await exec('psql', [
+    '-h',
+    host,
+    '-p',
+    port,
+    '-U',
+    user,
+    '-t',
+    '-A',
+    '-F',
+    '\t',
+    '-c',
+    `SELECT pid, datname, usename, EXTRACT(EPOCH FROM (now() - query_start))::int * 1000, state, LEFT(query, 300) FROM pg_stat_activity WHERE state = 'active' AND pid <> pg_backend_pid() AND EXTRACT(EPOCH FROM (now() - query_start)) * 1000 > ${thresholdMs} ORDER BY query_start ASC`,
+  ]);
+  return parseQuerySlow(stdout, thresholdMs);
+};
+
+export function parseQuerySlow(stdout: string, thresholdMs: number): QuerySlowResult {
+  const lines = stdout.trim().split('\n').filter(Boolean);
+  const queries: SlowQueryInfo[] = lines.map((line) => {
+    const parts = line.split('\t');
+    return {
+      pid: Number(parts[0]) || 0,
+      database: parts[1] ?? '',
+      user: parts[2] ?? '',
+      durationMs: Number(parts[3]) || 0,
+      state: parts[4] ?? '',
+      query: parts[5] ?? '',
+    };
+  });
+  return { queries, count: queries.length, thresholdMs };
+}

package/src/proxmox/index.ts

@@ -0,0 +1,24 @@
+import type { Pack } from '../types.js';
+import { proxmoxAgentManifest } from './manifest.js';
+import { cephStatus } from './probes/ceph-status.js';
+import { clusterConfig } from './probes/cluster-config.js';
+import { haStatus } from './probes/ha-status.js';
+import { lvm } from './probes/lvm.js';
+import { lxcConfig } from './probes/lxc-config.js';
+import { lxcList } from './probes/lxc-list.js';
+import { vmConfig } from './probes/vm-config.js';
+import { vmLocks } from './probes/vm-locks.js';
+
+export const proxmoxAgentPack: Pack = {
+  manifest: proxmoxAgentManifest,
+  handlers: {
+    'proxmox-node.local.vm.config': vmConfig,
+    'proxmox-node.local.ha.status': haStatus,
+    'proxmox-node.local.lvm': lvm,
+    'proxmox-node.local.ceph.status': cephStatus,
+    'proxmox-node.local.lxc.config': lxcConfig,
+    'proxmox-node.local.lxc.list': lxcList,
+    'proxmox-node.local.cluster.config': clusterConfig,
+    'proxmox-node.local.vm.locks': vmLocks,
+  },
+};

package/src/proxmox/manifest.ts

@@ -0,0 +1,76 @@
+import type { PackManifest } from '@sonde/shared';
+
+export const proxmoxAgentManifest: PackManifest = {
+  name: 'proxmox-node',
+  version: '0.1.0',
+  description: 'Proxmox VE node-local probes — VM/LXC config, HA status, LVM, Ceph, cluster',
+  requires: {
+    groups: [],
+    files: ['/etc/pve/'],
+    commands: ['qm', 'pct', 'ha-manager', 'pvesh', 'lvs', 'vgs', 'pvs', 'pvecm'],
+  },
+  probes: [
+    {
+      name: 'local.vm.config',
+      description: 'QEMU VM configuration via qm config',
+      capability: 'observe',
+      params: {
+        vmid: { type: 'number', description: 'VM ID', required: true },
+      },
+      timeout: 10_000,
+    },
+    {
+      name: 'local.ha.status',
+      description: 'HA manager resource states',
+      capability: 'observe',
+      timeout: 10_000,
+    },
+    {
+      name: 'local.lvm',
+      description: 'LVM topology — logical volumes, volume groups, physical volumes',
+      capability: 'observe',
+      timeout: 15_000,
+    },
+    {
+      name: 'local.ceph.status',
+      description: 'Ceph cluster health, OSD status, and PG states',
+      capability: 'observe',
+      timeout: 15_000,
+    },
+    {
+      name: 'local.lxc.config',
+      description: 'LXC container configuration via pct config',
+      capability: 'observe',
+      params: {
+        vmid: { type: 'number', description: 'Container VMID', required: true },
+      },
+      timeout: 10_000,
+    },
+    {
+      name: 'local.lxc.list',
+      description: 'List all LXC containers on this node',
+      capability: 'observe',
+      timeout: 10_000,
+    },
+    {
+      name: 'local.cluster.config',
+      description: 'Cluster membership, quorum, and vote status via pvecm',
+      capability: 'observe',
+      timeout: 10_000,
+    },
+    {
+      name: 'local.vm.locks',
+      description: 'Check for locked QEMU VMs via /run/lock/qemu-server/',
+      capability: 'observe',
+      timeout: 10_000,
+    },
+  ],
+  runbook: {
+    category: 'proxmox',
+    probes: ['local.ha.status', 'local.lvm', 'local.cluster.config'],
+    parallel: true,
+  },
+  detect: {
+    commands: ['qm', 'pct'],
+  },
+};

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

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { CephStatusResult } from './ceph-status.js';
+import { cephStatus, parseOsdTree } from './ceph-status.js';
+
+const CEPH_STATUS_JSON = JSON.stringify({
+  health: { status: 'HEALTH_OK' },
+  osdmap: { num_osds: 6, num_up_osds: 6, num_in_osds: 6 },
+  pgmap: {
+    pgs_by_state: [{ state_name: 'active+clean', count: 256 }],
+    bytes_total: 6000000000000,
+    bytes_used: 2000000000000,
+    bytes_avail: 4000000000000,
+  },
+});
+
+const OSD_TREE_JSON = JSON.stringify({
+  nodes: [
+    { id: -1, name: 'default', type: 'root' },
+    { id: -2, name: 'pve01', type: 'host' },
+    {
+      id: 0,
+      name: 'osd.0',
+      type: 'osd',
+      status: 'up',
+      crush_weight: 1.0,
+      reweight: 1.0,
+      host: 'pve01',
+    },
+    {
+      id: 1,
+      name: 'osd.1',
+      type: 'osd',
+      status: 'up',
+      crush_weight: 1.0,
+      reweight: 1.0,
+      host: 'pve01',
+    },
+    {
+      id: 2,
+      name: 'osd.2',
+      type: 'osd',
+      status: 'down',
+      crush_weight: 1.0,
+      reweight: 0,
+      host: 'pve02',
+    },
+  ],
+});
+
+describe('cephStatus handler', () => {
+  it('returns health, OSD counts, and PG states', async () => {
+    let callCount = 0;
+    const mockExec: ExecFn = async (cmd, args) => {
+      callCount++;
+      expect(cmd).toBe('ceph');
+      if (callCount === 1) {
+        expect(args).toEqual(['status', '--format', 'json']);
+        return CEPH_STATUS_JSON;
+      }
+      expect(args).toEqual(['osd', 'tree', '--format', 'json']);
+      return OSD_TREE_JSON;
+    };
+
+    const result = (await cephStatus(undefined, mockExec)) as CephStatusResult;
+    expect(result.available).toBe(true);
+    expect(result.health).toBe('HEALTH_OK');
+    expect(result.osdCount).toBe(6);
+    expect(result.osdUp).toBe(6);
+    expect(result.osdIn).toBe(6);
+    expect(result.pgStates).toHaveLength(1);
+    expect(result.pgStates[0]).toEqual({ state: 'active+clean', count: 256 });
+    expect(result.usage.total).toBe(6000000000000);
+    expect(result.osds).toHaveLength(3);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  it('flags degraded health', async () => {
+    const degraded = JSON.stringify({
+      health: { status: 'HEALTH_WARN' },
+      osdmap: { num_osds: 6, num_up_osds: 4, num_in_osds: 6 },
+      pgmap: { bytes_total: 0, bytes_used: 0, bytes_avail: 0 },
+    });
+
+    const mockExec: ExecFn = async (cmd, args) => {
+      if (args[0] === 'status') return degraded;
+      return '{"nodes":[]}';
+    };
+
+    const result = (await cephStatus(undefined, mockExec)) as CephStatusResult;
+    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 missing ceph binary gracefully', async () => {
+    const mockExec: ExecFn = async () => {
+      throw new Error('command not found: ceph');
+    };
+
+    const result = (await cephStatus(undefined, mockExec)) as { available: boolean };
+    expect(result.available).toBe(false);
+  });
+});
+
+describe('parseOsdTree', () => {
+  it('extracts only OSD nodes from the tree', () => {
+    const osds = parseOsdTree(OSD_TREE_JSON);
+    expect(osds).toHaveLength(3);
+    expect(osds[0]).toEqual({
+      id: 0,
+      name: 'osd.0',
+      type: 'osd',
+      status: 'up',
+      crush_weight: 1.0,
+      reweight: 1.0,
+      host: 'pve01',
+    });
+    expect(osds[2]?.status).toBe('down');
+  });
+
+  it('filters out non-OSD nodes', () => {
+    const osds = parseOsdTree(OSD_TREE_JSON);
+    const types = osds.map((o) => o.type);
+    expect(types.every((t) => t === 'osd')).toBe(true);
+  });
+});

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

@@ -0,0 +1,116 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface OsdNode {
+  id: number;
+  name: string;
+  type: string;
+  status: string;
+  crush_weight: number;
+  reweight: number;
+  host: string;
+}
+
+export interface CephStatusResult {
+  available: boolean;
+  health: string;
+  osdCount: number;
+  osdUp: number;
+  osdIn: number;
+  pgStates: Array<{ state: string; count: number }>;
+  usage: { total: number; used: number; avail: number };
+  osds: OsdNode[];
+  warnings: string[];
+}
+
+/**
+ * Runs `ceph status --format json` and `ceph osd tree --format json`.
+ * Gracefully handles missing ceph binary.
+ */
+export const cephStatus: ProbeHandler = async (_params, exec) => {
+  let statusOut: string;
+  try {
+    statusOut = await exec('ceph', ['status', '--format', 'json']);
+  } catch {
+    return {
+      available: false,
+      health: null,
+      warnings: ['Ceph is not installed or not accessible on this node'],
+    };
+  }
+
+  return parseCephStatus(statusOut, exec);
+};
+
+export async function parseCephStatus(
+  statusOut: string,
+  exec?: (cmd: string, args: string[]) => Promise<string>,
+): Promise<CephStatusResult> {
+  const data = JSON.parse(statusOut);
+  const warnings: string[] = [];
+
+  const health = data.health?.status ?? 'unknown';
+  const osdmap = data.osdmap ?? {};
+  const osdCount = osdmap.num_osds ?? 0;
+  const osdUp = osdmap.num_up_osds ?? 0;
+  const osdIn = osdmap.num_in_osds ?? 0;
+
+  if (health !== 'HEALTH_OK') {
+    warnings.push(`Ceph health: ${health}`);
+  }
+  if (osdCount > 0 && osdUp < osdCount) {
+    warnings.push(`${osdCount - osdUp} OSD(s) down`);
+  }
+
+  const pgmap = data.pgmap ?? {};
+  const pgStates: Array<{ state: string; count: number }> = (pgmap.pgs_by_state ?? []).map(
+    (p: { state_name?: string; count?: number }) => ({
+      state: p.state_name ?? '',
+      count: p.count ?? 0,
+    }),
+  );
+
+  const usage = {
+    total: pgmap.bytes_total ?? 0,
+    used: pgmap.bytes_used ?? 0,
+    avail: pgmap.bytes_avail ?? 0,
+  };
+
+  // OSD tree for placement info
+  let osds: OsdNode[] = [];
+  if (exec) {
+    try {
+      const treeOut = await exec('ceph', ['osd', 'tree', '--format', 'json']);
+      osds = parseOsdTree(treeOut);
+    } catch {
+      // OSD tree is best-effort
+    }
+  }
+
+  return { available: true, health, osdCount, osdUp, osdIn, pgStates, usage, osds, warnings };
+}
+
+export function parseOsdTree(stdout: string): OsdNode[] {
+  const data = JSON.parse(stdout);
+  const nodes = data.nodes ?? [];
+  return nodes
+    .filter((n: { type?: string }) => n.type === 'osd')
+    .map(
+      (n: {
+        id?: number;
+        name?: string;
+        type?: string;
+        status?: string;
+        crush_weight?: number;
+        reweight?: number;
+        host?: string;
+      }) => ({
+        id: n.id ?? 0,
+        name: n.name ?? '',
+        type: n.type ?? 'osd',
+        status: n.status ?? 'unknown',
+        crush_weight: n.crush_weight ?? 0,
+        reweight: n.reweight ?? 0,
+        host: n.host ?? '',
+      }),
+    );
+}

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

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { ClusterConfigResult } from './cluster-config.js';
+import { clusterConfig, parseClusterConfig } from './cluster-config.js';
+
+const SAMPLE_OUTPUT = `Cluster information
+~~~~~~~~~~~~~~~~~~
+Name:             mycluster
+Config Version:   3
+Transport:        knet
+Secure auth:      on
+
+Quorum information
+~~~~~~~~~~~~~~~~~~
+Date:             Mon Feb 17 10:00:00 2026
+Quorum provider:  corosync_votequorum
+Nodes:            3
+Node ID:          0x00000001
+Ring ID:          1.123
+Quorate:          Yes
+
+Votequorum information
+~~~~~~~~~~~~~~~~~~~~~~
+Expected votes:   3
+Highest expected: 3
+Total votes:      3
+Quorum:           2
+Flags:            Quorate
+
+Membership information
+~~~~~~~~~~~~~~~~~~~~~~
+    Nodeid      Votes Name
+         1          1 pve01 (local)
+         2          1 pve02
+         3          1 pve03`;
+
+describe('parseClusterConfig', () => {
+  it('extracts cluster name', () => {
+    const result = parseClusterConfig(SAMPLE_OUTPUT);
+    expect(result.clusterName).toBe('mycluster');
+  });
+
+  it('detects quorate status', () => {
+    const result = parseClusterConfig(SAMPLE_OUTPUT);
+    expect(result.quorate).toBe(true);
+  });
+
+  it('extracts vote counts', () => {
+    const result = parseClusterConfig(SAMPLE_OUTPUT);
+    expect(result.totalVotes).toBe(3);
+    expect(result.expectedVotes).toBe(3);
+  });
+
+  it('parses membership nodes', () => {
+    const result = parseClusterConfig(SAMPLE_OUTPUT);
+    expect(result.nodes).toHaveLength(3);
+    expect(result.nodes[0]).toEqual({
+      nodeId: '1',
+      name: 'pve01',
+      votes: 1,
+      local: true,
+    });
+    expect(result.nodes[1]).toEqual({
+      nodeId: '2',
+      name: 'pve02',
+      votes: 1,
+      local: false,
+    });
+  });
+
+  it('no warnings when quorate', () => {
+    const result = parseClusterConfig(SAMPLE_OUTPUT);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  it('warns when not quorate', () => {
+    const notQuorate = SAMPLE_OUTPUT.replace('Quorate:          Yes', 'Quorate:          No');
+    const result = parseClusterConfig(notQuorate);
+    expect(result.warnings).toContain('Cluster is not quorate');
+  });
+
+  it('handles single-node output', () => {
+    const singleNode = `Cluster information
+~~~~~~~~~~~~~~~~~~
+Name:             standalone
+
+Quorum information
+~~~~~~~~~~~~~~~~~~
+Quorate:          Yes
+
+Votequorum information
+~~~~~~~~~~~~~~~~~~~~~~
+Expected votes:   1
+Total votes:      1
+
+Membership information
+~~~~~~~~~~~~~~~~~~~~~~
+    Nodeid      Votes Name
+         1          1 pve01 (local)`;
+    const result = parseClusterConfig(singleNode);
+    expect(result.nodes).toHaveLength(1);
+    expect(result.nodes[0]?.local).toBe(true);
+  });
+});
+
+describe('clusterConfig handler', () => {
+  it('calls pvecm status and returns parsed result', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('pvecm');
+      expect(args).toEqual(['status']);
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await clusterConfig(undefined, mockExec)) as ClusterConfigResult;
+    expect(result.clusterName).toBe('mycluster');
+    expect(result.nodes).toHaveLength(3);
+  });
+});

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

@@ -0,0 +1,97 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface ClusterNode {
+  nodeId: string;
+  name: string;
+  votes: number;
+  local: boolean;
+}
+
+export interface ClusterConfigResult {
+  clusterName: string;
+  quorate: boolean;
+  totalVotes: number;
+  expectedVotes: number;
+  nodes: ClusterNode[];
+  warnings: string[];
+}
+
+/**
+ * Runs `pvecm status` and parses cluster membership.
+ * Output contains sections like:
+ *   Cluster information
+ *   ~~~~~~~~~~~~~~~~~~
+ *   Name:             mycluster
+ *   ...
+ *   Membership information
+ *   ~~~~~~~~~~~~~~~~~~~~~~
+ *   Nodeid  Votes Name
+ *   1       1     pve01 (local)
+ *   2       1     pve02
+ */
+export const clusterConfig: ProbeHandler = async (_params, exec) => {
+  const stdout = await exec('pvecm', ['status']);
+  return parseClusterConfig(stdout);
+};
+
+export function parseClusterConfig(stdout: string): ClusterConfigResult {
+  const lines = stdout.trim().split('\n');
+  const warnings: string[] = [];
+
+  let clusterName = '';
+  let quorate = false;
+  let totalVotes = 0;
+  let expectedVotes = 0;
+  const nodes: ClusterNode[] = [];
+
+  let inMembership = false;
+  let membershipHeaderSeen = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Key: Value pairs in cluster info section
+    if (trimmed.startsWith('Name:')) {
+      clusterName = trimmed.slice(5).trim();
+    }
+    if (trimmed.startsWith('Quorate:')) {
+      quorate = trimmed.toLowerCase().includes('yes');
+    }
+    if (trimmed.startsWith('Total votes:')) {
+      totalVotes = Number.parseInt(trimmed.slice('Total votes:'.length).trim(), 10) || 0;
+    }
+    if (trimmed.startsWith('Expected votes:')) {
+      expectedVotes = Number.parseInt(trimmed.slice('Expected votes:'.length).trim(), 10) || 0;
+    }
+
+    // Membership section detection
+    if (trimmed.startsWith('Membership information') || trimmed.startsWith('Nodeid')) {
+      inMembership = true;
+      if (trimmed.startsWith('Nodeid')) membershipHeaderSeen = true;
+      continue;
+    }
+    if (trimmed.startsWith('~~~')) continue;
+
+    // Parse node lines: "1       1     pve01 (local)"
+    if (inMembership && membershipHeaderSeen && trimmed) {
+      const parts = trimmed.split(/\s+/);
+      if (parts.length >= 3) {
+        const nodeId = parts[0] ?? '';
+        const votes = Number.parseInt(parts[1] ?? '', 10);
+        if (Number.isNaN(votes)) continue;
+
+        const nameAndFlags = parts.slice(2).join(' ');
+        const local = nameAndFlags.includes('(local)');
+        const name = nameAndFlags.replace('(local)', '').trim();
+
+        nodes.push({ nodeId, name, votes, local });
+      }
+    }
+  }
+
+  if (!quorate) {
+    warnings.push('Cluster is not quorate');
+  }
+
+  return { clusterName, quorate, totalVotes, expectedVotes, nodes, warnings };
+}