@sonde/packs 0.1.2 → 0.1.3

package/src/integrations/thousandeyes.ts

@@ -0,0 +1,353 @@
+import type {
+  FetchFn,
+  IntegrationConfig,
+  IntegrationCredentials,
+  IntegrationPack,
+  IntegrationProbeHandler,
+} from '@sonde/shared';
+
+// --- Auth helpers ---
+
+function buildAuthHeaders(credentials: IntegrationCredentials): Record<string, string> {
+  const token = credentials.credentials.token ?? '';
+  return { Authorization: `Bearer ${token}` };
+}
+
+// --- REST helper ---
+
+async function teGet<T>(
+  path: string,
+  config: IntegrationConfig,
+  credentials: IntegrationCredentials,
+  fetchFn: FetchFn,
+  params?: Record<string, string>,
+): Promise<T> {
+  const base = `${config.endpoint.replace(/\/$/, '')}/v7${path}`;
+  const url = new URL(base);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+
+  const headers: Record<string, string> = {
+    Accept: 'application/json',
+    ...buildAuthHeaders(credentials),
+    ...config.headers,
+  };
+
+  const res = await fetchFn(url.toString(), { headers });
+  if (!res.ok) {
+    throw new Error(`ThousandEyes API returned ${res.status}: ${res.statusText}`);
+  }
+  return (await res.json()) as T;
+}
+
+// --- Probe handlers ---
+
+const alertsActive: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const queryParams: Record<string, string> = {};
+  const window = params?.window as string | undefined;
+  if (window) queryParams.window = window;
+
+  const data = await teGet<{
+    alerts?: Array<{
+      id?: string;
+      type?: string;
+      severity?: string;
+      state?: string;
+      startDate?: string;
+      violationCount?: number;
+      duration?: number;
+    }>;
+  }>('/alerts', config, credentials, fetchFn, queryParams);
+
+  const alerts = data.alerts ?? [];
+  return {
+    alerts: alerts.map((a) => ({
+      id: a.id ?? null,
+      type: a.type ?? null,
+      severity: a.severity ?? null,
+      state: a.state ?? null,
+      startDate: a.startDate ?? null,
+      violationCount: a.violationCount ?? 0,
+      duration: a.duration ?? 0,
+    })),
+    count: alerts.length,
+  };
+};
+
+const testsList: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const queryParams: Record<string, string> = {};
+  const type = params?.type as string | undefined;
+  if (type) queryParams.type = type;
+
+  const data = await teGet<{
+    tests?: Array<{
+      testId?: string;
+      testName?: string;
+      type?: string;
+      enabled?: boolean;
+      server?: string;
+      interval?: number;
+      agents?: Array<{ agentId?: string; agentName?: string }>;
+    }>;
+  }>('/tests', config, credentials, fetchFn, queryParams);
+
+  const tests = data.tests ?? [];
+  return {
+    tests: tests.map((t) => ({
+      testId: t.testId ?? null,
+      testName: t.testName ?? null,
+      type: t.type ?? null,
+      enabled: t.enabled ?? false,
+      server: t.server ?? null,
+      interval: t.interval ?? 0,
+      agents: t.agents ?? [],
+    })),
+    count: tests.length,
+  };
+};
+
+const networkMetrics: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const testId = params?.testId as string;
+  if (!testId) throw new Error('testId parameter is required');
+
+  const queryParams: Record<string, string> = {};
+  const window = params?.window as string | undefined;
+  if (window) queryParams.window = window;
+
+  const data = await teGet<{
+    results?: Array<{
+      agent?: { agentId?: string; agentName?: string; location?: string };
+      avgLatency?: number;
+      loss?: number;
+      jitter?: number;
+      serverIp?: string;
+    }>;
+  }>(`/test-results/${encodeURIComponent(testId)}/network`, config, credentials, fetchFn, queryParams);
+
+  const results = data.results ?? [];
+  return {
+    metrics: results.map((r) => ({
+      agentId: r.agent?.agentId ?? null,
+      agentName: r.agent?.agentName ?? null,
+      location: r.agent?.location ?? null,
+      avgLatency: r.avgLatency ?? null,
+      loss: r.loss ?? null,
+      jitter: r.jitter ?? null,
+      serverIp: r.serverIp ?? null,
+    })),
+    count: results.length,
+  };
+};
+
+const networkPathVis: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const testId = params?.testId as string;
+  if (!testId) throw new Error('testId parameter is required');
+
+  const queryParams: Record<string, string> = {};
+  const window = params?.window as string | undefined;
+  if (window) queryParams.window = window;
+
+  const data = await teGet<{
+    results?: Array<{
+      agent?: { agentId?: string; agentName?: string };
+      pathTraces?: Array<{
+        ipAddress?: string;
+        responseTime?: number;
+        numberOfHops?: number;
+      }>;
+    }>;
+  }>(`/test-results/${encodeURIComponent(testId)}/path-vis`, config, credentials, fetchFn, queryParams);
+
+  const results = data.results ?? [];
+  return {
+    pathVisualizations: results.map((r) => ({
+      agentId: r.agent?.agentId ?? null,
+      agentName: r.agent?.agentName ?? null,
+      pathTraces: (r.pathTraces ?? []).map((hop) => ({
+        ipAddress: hop.ipAddress ?? null,
+        responseTime: hop.responseTime ?? null,
+        numberOfHops: hop.numberOfHops ?? null,
+      })),
+    })),
+    count: results.length,
+  };
+};
+
+const agentsList: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const data = await teGet<{
+    agents?: Array<{
+      agentId?: string;
+      agentName?: string;
+      agentType?: string;
+      location?: string;
+      countryId?: string;
+      enabled?: boolean;
+    }>;
+  }>('/agents', config, credentials, fetchFn);
+
+  const agents = data.agents ?? [];
+  return {
+    agents: agents.map((a) => ({
+      agentId: a.agentId ?? null,
+      agentName: a.agentName ?? null,
+      agentType: a.agentType ?? null,
+      location: a.location ?? null,
+      country: a.countryId ?? null,
+      enabled: a.enabled ?? false,
+    })),
+    count: agents.length,
+  };
+};
+
+const outagesNetwork: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const queryParams: Record<string, string> = {};
+  const window = params?.window as string | undefined;
+  if (window) queryParams.window = window;
+
+  const data = await teGet<{
+    outages?: Array<{
+      type?: string;
+      scope?: string;
+      startDate?: string;
+      endDate?: string;
+      affectedTests?: number[];
+    }>;
+  }>('/internet-insights/outages/network', config, credentials, fetchFn, queryParams);
+
+  const outages = data.outages ?? [];
+  return {
+    outages: outages.map((o) => ({
+      type: o.type ?? null,
+      scope: o.scope ?? null,
+      startDate: o.startDate ?? null,
+      endDate: o.endDate ?? null,
+      affectedTests: o.affectedTests ?? [],
+    })),
+    count: outages.length,
+  };
+};
+
+// --- Pack definition ---
+
+export const thousandeyesPack: IntegrationPack = {
+  manifest: {
+    name: 'thousandeyes',
+    type: 'integration',
+    version: '0.1.0',
+    description: 'ThousandEyes — network path analysis, latency metrics, and outage detection',
+    requires: { groups: [], files: [], commands: [] },
+    probes: [
+      {
+        name: 'alerts.active',
+        description: 'List active alerts with severity and violation details',
+        capability: 'observe',
+        params: {
+          window: {
+            type: 'string',
+            description: 'Time window for alerts (e.g. "12h")',
+            required: false,
+          },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'tests.list',
+        description: 'List configured tests with type, interval, and assigned agents',
+        capability: 'observe',
+        params: {
+          type: {
+            type: 'string',
+            description: 'Filter by test type (e.g. "agent-to-server")',
+            required: false,
+          },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'network.metrics',
+        description: 'Get per-agent network metrics (latency, loss, jitter) for a test',
+        capability: 'observe',
+        params: {
+          testId: {
+            type: 'string',
+            description: 'ThousandEyes test ID',
+            required: true,
+          },
+          window: {
+            type: 'string',
+            description: 'Time window for results (e.g. "1h")',
+            required: false,
+          },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'network.path-vis',
+        description: 'Get hop-by-hop path visualization for a test',
+        capability: 'observe',
+        params: {
+          testId: {
+            type: 'string',
+            description: 'ThousandEyes test ID',
+            required: true,
+          },
+          window: {
+            type: 'string',
+            description: 'Time window for results (e.g. "1h")',
+            required: false,
+          },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'agents.list',
+        description: 'List ThousandEyes agents with type, location, and status',
+        capability: 'observe',
+        params: {},
+        timeout: 15000,
+      },
+      {
+        name: 'outages.network',
+        description: 'List detected internet outages affecting tests',
+        capability: 'observe',
+        params: {
+          window: {
+            type: 'string',
+            description: 'Time window for outages (e.g. "24h")',
+            required: false,
+          },
+        },
+        timeout: 15000,
+      },
+    ],
+    runbook: {
+      category: 'network',
+      probes: ['alerts.active', 'agents.list'],
+      parallel: true,
+    },
+  },
+
+  handlers: {
+    'alerts.active': alertsActive,
+    'tests.list': testsList,
+    'network.metrics': networkMetrics,
+    'network.path-vis': networkPathVis,
+    'agents.list': agentsList,
+    'outages.network': outagesNetwork,
+  },
+
+  testConnection: async (config, credentials, fetchFn) => {
+    const url = `${config.endpoint.replace(/\/$/, '')}/v7/agents`;
+    const headers: Record<string, string> = {
+      Accept: 'application/json',
+      ...buildAuthHeaders(credentials),
+      ...config.headers,
+    };
+
+    const res = await fetchFn(url, { headers });
+    return res.ok;
+  },
+};

package/src/integrations/vcenter.ts

@@ -0,0 +1,261 @@
+import type {
+  FetchFn,
+  IntegrationConfig,
+  IntegrationCredentials,
+  IntegrationPack,
+  IntegrationProbeHandler,
+} from '@sonde/shared';
+
+// --- Session-based auth ---
+
+/** Session token cache: token + expiry timestamp */
+let cachedSession: { token: string; expiresAt: number } | null = null;
+
+/** Acquire a vCenter session token via POST /api/session */
+async function getSessionToken(
+  config: IntegrationConfig,
+  credentials: IntegrationCredentials,
+  fetchFn: FetchFn,
+): Promise<string> {
+  const now = Date.now();
+  if (cachedSession && cachedSession.expiresAt > now) {
+    return cachedSession.token;
+  }
+
+  const { username, password } = credentials.credentials;
+  if (!username || !password) {
+    throw new Error('vCenter requires username and password credentials');
+  }
+
+  const encoded = Buffer.from(`${username}:${password}`).toString('base64');
+  const url = `${config.endpoint.replace(/\/$/, '')}/api/session`;
+  const res = await fetchFn(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Basic ${encoded}`,
+      Accept: 'application/json',
+      ...config.headers,
+    },
+  });
+
+  if (!res.ok) {
+    throw new Error(`vCenter session auth failed: ${res.status} ${res.statusText}`);
+  }
+
+  const token = ((await res.json()) as string).replace(/^"|"$/g, '');
+  cachedSession = { token, expiresAt: now + 5 * 60 * 1000 };
+  return token;
+}
+
+// --- REST helper ---
+
+async function vcenterGet<T>(
+  path: string,
+  config: IntegrationConfig,
+  credentials: IntegrationCredentials,
+  fetchFn: FetchFn,
+  params?: Record<string, string>,
+): Promise<T> {
+  const token = await getSessionToken(config, credentials, fetchFn);
+  const base = `${config.endpoint.replace(/\/$/, '')}${path}`;
+  const url = new URL(base);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+
+  const headers: Record<string, string> = {
+    Accept: 'application/json',
+    'vmware-api-session-id': token,
+    ...config.headers,
+  };
+
+  const res = await fetchFn(url.toString(), { headers });
+  if (!res.ok) {
+    throw new Error(`vCenter API returned ${res.status}: ${res.statusText}`);
+  }
+  return (await res.json()) as T;
+}
+
+// --- Probe handlers ---
+
+const vmList: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const vms = await vcenterGet<
+    Array<{
+      vm: string;
+      name: string;
+      power_state: string;
+      cpu_count?: number;
+      memory_size_MiB?: number;
+    }>
+  >('/api/vcenter/vm', config, credentials, fetchFn);
+
+  return {
+    vms: vms.map((vm) => ({
+      vm: vm.vm,
+      name: vm.name,
+      powerState: vm.power_state,
+      cpuCount: vm.cpu_count ?? null,
+      memorySizeMiB: vm.memory_size_MiB ?? null,
+    })),
+    count: vms.length,
+  };
+};
+
+const vmDetail: IntegrationProbeHandler = async (params, config, credentials, fetchFn) => {
+  const vm = params?.vm as string;
+  if (!vm) throw new Error('vm parameter is required (VM identifier)');
+
+  return vcenterGet(`/api/vcenter/vm/${vm}`, config, credentials, fetchFn);
+};
+
+const hostList: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const hosts = await vcenterGet<
+    Array<{
+      host: string;
+      name: string;
+      connection_state: string;
+      power_state?: string;
+    }>
+  >('/api/vcenter/host', config, credentials, fetchFn);
+
+  return {
+    hosts: hosts.map((h) => ({
+      host: h.host,
+      name: h.name,
+      connectionState: h.connection_state,
+      powerState: h.power_state ?? null,
+    })),
+    count: hosts.length,
+  };
+};
+
+const datastoreList: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const datastores = await vcenterGet<
+    Array<{
+      datastore: string;
+      name: string;
+      type: string;
+      capacity?: number;
+      free_space?: number;
+    }>
+  >('/api/vcenter/datastore', config, credentials, fetchFn);
+
+  return {
+    datastores: datastores.map((ds) => ({
+      datastore: ds.datastore,
+      name: ds.name,
+      type: ds.type,
+      capacity: ds.capacity ?? 0,
+      freeSpace: ds.free_space ?? 0,
+    })),
+    count: datastores.length,
+  };
+};
+
+const clusterList: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  const clusters = await vcenterGet<
+    Array<{
+      cluster: string;
+      name: string;
+      ha_enabled?: boolean;
+      drs_enabled?: boolean;
+    }>
+  >('/api/vcenter/cluster', config, credentials, fetchFn);
+
+  return {
+    clusters: clusters.map((cl) => ({
+      cluster: cl.cluster,
+      name: cl.name,
+      haEnabled: cl.ha_enabled ?? false,
+      drsEnabled: cl.drs_enabled ?? false,
+    })),
+    count: clusters.length,
+  };
+};
+
+const health: IntegrationProbeHandler = async (_params, config, credentials, fetchFn) => {
+  return vcenterGet('/api/vcenter/system/health', config, credentials, fetchFn);
+};
+
+// --- Pack definition ---
+
+export const vcenterPack: IntegrationPack = {
+  manifest: {
+    name: 'vcenter',
+    type: 'integration',
+    version: '0.1.0',
+    description: 'VMware vCenter — VMs, ESXi hosts, datastores, clusters, and health status',
+    requires: { groups: [], files: [], commands: [] },
+    probes: [
+      {
+        name: 'vm.list',
+        description: 'List all VMs with power state, CPU, and memory',
+        capability: 'observe',
+        params: {},
+        timeout: 15000,
+      },
+      {
+        name: 'vm.detail',
+        description: 'Detailed info for a single VM by identifier',
+        capability: 'observe',
+        params: {
+          vm: { type: 'string', description: 'VM identifier (e.g. vm-42)', required: true },
+        },
+        timeout: 15000,
+      },
+      {
+        name: 'host.list',
+        description: 'List ESXi hosts with connection state',
+        capability: 'observe',
+        params: {},
+        timeout: 15000,
+      },
+      {
+        name: 'datastore.list',
+        description: 'List datastores with capacity and free space',
+        capability: 'observe',
+        params: {},
+        timeout: 15000,
+      },
+      {
+        name: 'cluster.list',
+        description: 'List clusters with HA and DRS status',
+        capability: 'observe',
+        params: {},
+        timeout: 15000,
+      },
+      {
+        name: 'health',
+        description: 'Overall vCenter health status',
+        capability: 'observe',
+        params: {},
+        timeout: 15000,
+      },
+    ],
+    runbook: {
+      category: 'vmware',
+      probes: ['health', 'host.list', 'vm.list'],
+      parallel: true,
+    },
+  },
+
+  handlers: {
+    'vm.list': vmList,
+    'vm.detail': vmDetail,
+    'host.list': hostList,
+    'datastore.list': datastoreList,
+    'cluster.list': clusterList,
+    health,
+  },
+
+  testConnection: async (config, credentials, fetchFn) => {
+    try {
+      await getSessionToken(config, credentials, fetchFn);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+};

package/src/system/index.ts

@@ -2,8 +2,12 @@ import type { Pack } from '../types.js';
 import { systemManifest } from './manifest.js';
 import { cpuUsage } from './probes/cpu-usage.js';
 import { diskUsage } from './probes/disk-usage.js';
+import { logsDmesg } from './probes/logs-dmesg.js';
+import { logsJournal } from './probes/logs-journal.js';
+import { logsTail } from './probes/logs-tail.js';
 import { memoryUsage } from './probes/memory-usage.js';
 import { ping } from './probes/ping.js';
+import { traceroute } from './probes/traceroute.js';
 
 export const systemPack: Pack = {
   manifest: systemManifest,
@@ -12,5 +16,9 @@ export const systemPack: Pack = {
     'system.memory.usage': memoryUsage,
     'system.cpu.usage': cpuUsage,
     'system.network.ping': ping,
+    'system.logs.journal': logsJournal,
+    'system.logs.dmesg': logsDmesg,
+    'system.logs.tail': logsTail,
+    'system.network.traceroute': traceroute,
   },
 };