@camstack/addon-metrics-glances 0.1.1

package/dist/glances-metrics.addon.js

@@ -0,0 +1,412 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/glances-metrics.addon.ts
+var glances_metrics_addon_exports = {};
+__export(glances_metrics_addon_exports, {
+  default: () => GlancesMetricsAddon
+});
+module.exports = __toCommonJS(glances_metrics_addon_exports);
+var import_types = require("@camstack/types");
+
+// src/glances-client.ts
+var GlancesClient = class {
+  constructor(baseUrl, timeoutMs = 3e3) {
+    this.baseUrl = baseUrl;
+    this.timeoutMs = timeoutMs;
+  }
+  baseUrl;
+  timeoutMs;
+  /** Check if Glances is reachable. */
+  async isReachable() {
+    try {
+      const res = await this.fetch("/status");
+      return res !== null;
+    } catch {
+      return false;
+    }
+  }
+  async getCpu() {
+    return this.fetch("/cpu");
+  }
+  async getMem() {
+    return this.fetch("/mem");
+  }
+  async getDiskIo() {
+    return this.fetch("/diskio");
+  }
+  async getFs() {
+    return this.fetch("/fs");
+  }
+  async getNetwork() {
+    return this.fetch("/network");
+  }
+  async getSensors() {
+    return this.fetch("/sensors");
+  }
+  async getGpu() {
+    return this.fetch("/gpu");
+  }
+  async getLoad() {
+    return this.fetch("/load");
+  }
+  // ─── Internal ─────────────────────────────────────────────────────
+  async fetch(endpoint) {
+    try {
+      const url = `${this.baseUrl}/api/4${endpoint}`;
+      const res = await globalThis.fetch(url, {
+        signal: AbortSignal.timeout(this.timeoutMs),
+        headers: { "Accept": "application/json" }
+      });
+      if (!res.ok) return null;
+      return await res.json();
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/glances-metrics-provider.ts
+var GlancesMetricsProvider = class {
+  constructor(client, logger) {
+    this.client = client;
+    this.logger = logger;
+  }
+  client;
+  logger;
+  id = "glances";
+  cachedSnapshot = null;
+  samplingTimer = null;
+  // ─── Lifecycle (addon-owned, not on the cap contract) ───────────────
+  startSampling(intervalMs) {
+    this.collectSnapshot().then((s) => {
+      this.cachedSnapshot = s;
+    }).catch((err) => {
+      this.logger.warn("Initial Glances snapshot failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+    });
+    this.samplingTimer = setInterval(() => {
+      this.collectSnapshot().then((s) => {
+        this.cachedSnapshot = s;
+      }).catch(() => {
+      });
+    }, intervalMs);
+    if (this.samplingTimer.unref) this.samplingTimer.unref();
+  }
+  stopSampling() {
+    if (this.samplingTimer) {
+      clearInterval(this.samplingTimer);
+      this.samplingTimer = null;
+    }
+  }
+  // ─── Cap contract ───────────────────────────────────────────────────
+  async collectSnapshot() {
+    const snapshot = await this.collectFromGlances();
+    this.cachedSnapshot = snapshot;
+    return snapshot;
+  }
+  async getCached() {
+    return this.cachedSnapshot;
+  }
+  async getCurrent() {
+    const s = this.cachedSnapshot ?? await this.collectSnapshot();
+    const mb = (bytes) => Math.round(bytes / 1024 / 1024);
+    return {
+      cpuPercent: s.cpu.total,
+      memoryPercent: s.memory.percent,
+      memoryUsedMB: mb(s.memory.usedBytes),
+      memoryTotalMB: mb(s.memory.totalBytes),
+      temperature: s.cpuTemperature ?? void 0,
+      gpuPercent: s.gpu?.utilization,
+      gpuMemoryPercent: s.gpu && s.gpu.memoryTotalBytes > 0 ? Math.round(s.gpu.memoryUsedBytes / s.gpu.memoryTotalBytes * 1e3) / 10 : void 0
+    };
+  }
+  async getDiskSpace(input) {
+    const fsData = await this.client.getFs();
+    if (!fsData) throw new Error("Glances /fs endpoint returned no data");
+    const match = fsData.find((f) => input.dirPath.startsWith(f.mnt_point));
+    if (!match) throw new Error("Glances reported no filesystem matching path: " + input.dirPath);
+    return {
+      path: match.mnt_point,
+      totalBytes: match.size,
+      usedBytes: match.used,
+      availableBytes: match.free,
+      percent: match.percent
+    };
+  }
+  async getGpuInfo() {
+    const gpuData = await this.client.getGpu();
+    if (!gpuData || gpuData.length === 0) return null;
+    const gpu = gpuData[0];
+    return {
+      utilization: gpu.proc,
+      model: gpu.name,
+      memoryUsedBytes: 0,
+      memoryTotalBytes: 0,
+      temperature: gpu.temperature ?? null
+    };
+  }
+  async getCpuTemperature() {
+    const sensors = await this.client.getSensors();
+    if (!sensors) return null;
+    const cpuTemp = sensors.find(
+      (s) => s.type === "temperature_core" || s.label.toLowerCase().includes("cpu")
+    );
+    return cpuTemp ? Math.round(cpuTemp.value * 10) / 10 : null;
+  }
+  async getProcessStats(_input) {
+    return [];
+  }
+  // ─── Internal ───────────────────────────────────────────────────────
+  async collectFromGlances() {
+    const [cpuData, memData, diskIoData, networkData, loadData, sensorsData, gpuData] = await Promise.all([
+      this.client.getCpu(),
+      this.client.getMem(),
+      this.client.getDiskIo(),
+      this.client.getNetwork(),
+      this.client.getLoad(),
+      this.client.getSensors(),
+      this.client.getGpu()
+    ]);
+    if (!cpuData || !memData) {
+      throw new Error("Glances: core endpoints (cpu/mem) returned null");
+    }
+    const cpu = {
+      total: cpuData.total,
+      user: cpuData.user,
+      system: cpuData.system,
+      irq: cpuData.irq,
+      nice: cpuData.nice,
+      loadAvg: loadData ? [loadData.min1, loadData.min5, loadData.min15] : [0, 0, 0],
+      cores: cpuData.cpucore
+    };
+    const memory = {
+      percent: memData.percent,
+      totalBytes: memData.total,
+      usedBytes: memData.used,
+      availableBytes: memData.available,
+      swapUsedBytes: memData.swap_used ?? 0,
+      swapTotalBytes: memData.swap_total ?? 0
+    };
+    const disk = {
+      readBytes: diskIoData?.reduce((sum, d) => sum + (d.read_bytes ?? 0), 0) ?? 0,
+      writeBytes: diskIoData?.reduce((sum, d) => sum + (d.write_bytes ?? 0), 0) ?? 0,
+      readOps: diskIoData?.reduce((sum, d) => sum + (d.read_count ?? 0), 0) ?? 0,
+      writeOps: diskIoData?.reduce((sum, d) => sum + (d.write_count ?? 0), 0) ?? 0,
+      timestampMs: Date.now()
+    };
+    const network = {
+      rxBytes: networkData?.reduce((sum, n) => sum + (n.bytes_recv ?? 0), 0) ?? 0,
+      txBytes: networkData?.reduce((sum, n) => sum + (n.bytes_sent ?? 0), 0) ?? 0,
+      rxPackets: networkData?.reduce((sum, n) => sum + (n.packets_recv ?? 0), 0) ?? 0,
+      txPackets: networkData?.reduce((sum, n) => sum + (n.packets_sent ?? 0), 0) ?? 0,
+      rxErrors: networkData?.reduce((sum, n) => sum + (n.errin ?? 0), 0) ?? 0,
+      txErrors: networkData?.reduce((sum, n) => sum + (n.errout ?? 0), 0) ?? 0,
+      timestampMs: Date.now()
+    };
+    let gpu = null;
+    if (gpuData && gpuData.length > 0) {
+      const g = gpuData[0];
+      gpu = {
+        utilization: g.proc,
+        model: g.name,
+        memoryUsedBytes: 0,
+        memoryTotalBytes: 0,
+        temperature: g.temperature ?? null
+      };
+    }
+    let cpuTemperature = null;
+    if (sensorsData) {
+      const tempSensor = sensorsData.find(
+        (s) => s.type === "temperature_core" || s.label.toLowerCase().includes("cpu")
+      );
+      if (tempSensor) cpuTemperature = Math.round(tempSensor.value * 10) / 10;
+    }
+    const p = process;
+    const activeHandles = Array.isArray(p._getActiveHandles?.()) ? p._getActiveHandles().length : 0;
+    const activeRequests = Array.isArray(p._getActiveRequests?.()) ? p._getActiveRequests().length : 0;
+    const processInfo = {
+      openFds: 0,
+      threadCount: 0,
+      activeHandles,
+      activeRequests
+    };
+    return {
+      cpu,
+      memory,
+      gpu,
+      network,
+      disk,
+      pressure: { cpu: null, memory: null, io: null },
+      process: processInfo,
+      cpuTemperature,
+      timestampMs: Date.now()
+    };
+  }
+};
+
+// src/glances-metrics.addon.ts
+function narrowWorkerState(state) {
+  switch (state) {
+    case "starting":
+    case "running":
+    case "stopping":
+    case "stopped":
+    case "crashed":
+      return state;
+    default:
+      return "running";
+  }
+}
+var GlancesMetricsAddon = class extends import_types.BaseAddon {
+  provider = null;
+  startedAtMs = Date.now();
+  constructor() {
+    super({ glancesUrl: "http://localhost:61208", timeoutMs: 3e3, samplingIntervalMs: 5e3 });
+  }
+  async onInitialize() {
+    const client = new GlancesClient(this.config.glancesUrl, this.config.timeoutMs);
+    const provider = new GlancesMetricsProvider(client, this.ctx.logger);
+    provider.startSampling(this.config.samplingIntervalMs);
+    this.provider = provider;
+    this.startedAtMs = Date.now();
+    const reachable = await client.isReachable();
+    if (reachable) {
+      this.ctx.logger.info("Glances metrics connected", { meta: { url: this.config.glancesUrl } });
+    } else {
+      this.ctx.logger.warn("Glances unreachable \u2014 calls will throw until Glances is available", { meta: { url: this.config.glancesUrl } });
+    }
+    const composed = {
+      collectSnapshot: () => provider.collectSnapshot(),
+      getCached: () => provider.getCached(),
+      getCurrent: () => provider.getCurrent(),
+      getDiskSpace: (params) => provider.getDiskSpace(params),
+      getGpuInfo: () => provider.getGpuInfo(),
+      getCpuTemperature: () => provider.getCpuTemperature(),
+      getProcessStats: (params) => provider.getProcessStats(params),
+      listAddonInstances: () => this.listAddonInstances(),
+      getAddonStats: (params) => this.getAddonStats(params.addonId),
+      // Glances doesn't own the host's process table — ghost detection
+      // lives in the native-metrics addon (PPID + $process scan). Glances
+      // can still provide CPU/memory snapshots while native-metrics
+      // handles the process inspector surface.
+      listNodeProcesses: async () => [],
+      killProcess: async () => ({ success: false, reason: "not supported by glances provider" })
+    };
+    return [{ capability: import_types.metricsProviderCapability, provider: composed }];
+  }
+  async onShutdown() {
+    this.provider?.stopSampling();
+    this.provider = null;
+  }
+  async onConfigChanged() {
+    if (this.provider) {
+      this.provider.stopSampling();
+      this.provider.startSampling(this.config.samplingIntervalMs);
+    }
+  }
+  async listWorkerInstances() {
+    const broker = this.ctx.kernel.cluster?.broker;
+    if (!broker) return [];
+    try {
+      return await broker.call("$process.list");
+    } catch {
+      return [];
+    }
+  }
+  async listAddonInstances() {
+    const broker = this.ctx.kernel.cluster?.broker;
+    const hubNodeId = broker?.nodeID ?? "hub";
+    const uptimeSec = Math.max(0, Math.floor((Date.now() - this.startedAtMs) / 1e3));
+    const instances = [{
+      addonId: "$hub",
+      nodeId: hubNodeId,
+      role: "hub",
+      pid: process.pid,
+      state: "running",
+      uptimeSec
+    }];
+    const workers = await this.listWorkerInstances();
+    for (const w of workers) {
+      instances.push({
+        addonId: w.addonId,
+        nodeId: w.nodeId,
+        role: "worker",
+        pid: w.pid,
+        state: narrowWorkerState(w.state),
+        uptimeSec: w.uptimeSeconds
+      });
+    }
+    return instances;
+  }
+  async getAddonStats(addonId) {
+    const provider = this.provider;
+    if (!provider) return null;
+    if (addonId === "$hub") {
+      const stats2 = await provider.getProcessStats({ pids: [process.pid] });
+      return stats2[0] ?? null;
+    }
+    const workers = await this.listWorkerInstances();
+    const target = workers.find((w) => w.addonId === addonId);
+    if (!target) return null;
+    const stats = await provider.getProcessStats({ pids: [target.pid] });
+    return stats[0] ?? null;
+  }
+  globalSettingsSchema() {
+    return this.schema({
+      sections: [{
+        id: "glances-connection",
+        title: "Glances Metrics",
+        columns: 3,
+        fields: [
+          this.field({
+            type: "text",
+            key: "glancesUrl",
+            label: "Glances URL",
+            description: "Base URL of the Glances REST API",
+            placeholder: "http://localhost:61208",
+            default: "http://localhost:61208"
+          }),
+          this.field({
+            type: "number",
+            key: "timeoutMs",
+            label: "Request Timeout",
+            description: "Timeout for each Glances API request",
+            min: 500,
+            max: 1e4,
+            step: 500,
+            default: 3e3,
+            unit: "ms"
+          }),
+          this.field({
+            type: "number",
+            key: "samplingIntervalMs",
+            label: "Sampling Interval",
+            description: "How often to collect system metrics",
+            min: 1e3,
+            max: 6e4,
+            step: 1e3,
+            default: 5e3,
+            unit: "ms"
+          })
+        ]
+      }]
+    });
+  }
+};
+//# sourceMappingURL=glances-metrics.addon.js.map

package/dist/glances-metrics.addon.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/glances-metrics.addon.ts","../src/glances-client.ts","../src/glances-metrics-provider.ts"],"sourcesContent":["import type { AddonInstance, IMetricsProvider, ProviderRegistration } from '@camstack/types'\nimport { BaseAddon, metricsProviderCapability } from '@camstack/types'\nimport { GlancesClient } from './glances-client.js'\nimport { GlancesMetricsProvider } from './glances-metrics-provider.js'\n\ninterface GlancesConfig {\n  readonly glancesUrl: string\n  readonly timeoutMs: number\n  readonly samplingIntervalMs: number\n}\n\ninterface KernelProcessInfo {\n  readonly pid: number\n  readonly nodeId: string\n  readonly addonId: string\n  readonly state: string\n  readonly cpuPercent: number\n  readonly memoryRss: number\n  readonly uptimeSeconds: number\n}\n\ntype WorkerState = 'starting' | 'running' | 'stopping' | 'stopped' | 'crashed'\n\nfunction narrowWorkerState(state: string): WorkerState {\n  switch (state) {\n    case 'starting':\n    case 'running':\n    case 'stopping':\n    case 'stopped':\n    case 'crashed':\n      return state\n    default:\n      return 'running'\n  }\n}\n\n/**\n * Glances metrics — system metrics via the Glances REST API.\n *\n * No silent fallback: if Glances is unreachable the provider throws on every\n * call. Users wanting a Glances-free metrics source enable the native-metrics\n * addon instead.\n */\nexport default class GlancesMetricsAddon extends BaseAddon<GlancesConfig> {\n  private provider: GlancesMetricsProvider | null = null\n  private startedAtMs: number = Date.now()\n\n  constructor() {\n    super({ glancesUrl: 'http://localhost:61208', timeoutMs: 3000, samplingIntervalMs: 5000 })\n  }\n\n  protected async onInitialize(): Promise<ProviderRegistration[]> {\n    const client = new GlancesClient(this.config.glancesUrl, this.config.timeoutMs)\n    const provider = new GlancesMetricsProvider(client, this.ctx.logger)\n    provider.startSampling(this.config.samplingIntervalMs)\n    this.provider = provider\n    this.startedAtMs = Date.now()\n\n    const reachable = await client.isReachable()\n    if (reachable) {\n      this.ctx.logger.info('Glances metrics connected', { meta: { url: this.config.glancesUrl } })\n    } else {\n      this.ctx.logger.warn('Glances unreachable — calls will throw until Glances is available', { meta: { url: this.config.glancesUrl } })\n    }\n\n    const composed: IMetricsProvider = {\n      collectSnapshot: () => provider.collectSnapshot(),\n      getCached: () => provider.getCached(),\n      getCurrent: () => provider.getCurrent(),\n      getDiskSpace: (params) => provider.getDiskSpace(params),\n      getGpuInfo: () => provider.getGpuInfo(),\n      getCpuTemperature: () => provider.getCpuTemperature(),\n      getProcessStats: (params) => provider.getProcessStats(params),\n      listAddonInstances: () => this.listAddonInstances(),\n      getAddonStats: (params) => this.getAddonStats(params.addonId),\n      // Glances doesn't own the host's process table — ghost detection\n      // lives in the native-metrics addon (PPID + $process scan). Glances\n      // can still provide CPU/memory snapshots while native-metrics\n      // handles the process inspector surface.\n      listNodeProcesses: async () => [],\n      killProcess: async () => ({ success: false, reason: 'not supported by glances provider' }),\n    }\n    return [{ capability: metricsProviderCapability, provider: composed }]\n  }\n\n  protected async onShutdown(): Promise<void> {\n    this.provider?.stopSampling()\n    this.provider = null\n  }\n\n  protected async onConfigChanged(): Promise<void> {\n    if (this.provider) {\n      this.provider.stopSampling()\n      this.provider.startSampling(this.config.samplingIntervalMs)\n    }\n  }\n\n  private async listWorkerInstances(): Promise<readonly KernelProcessInfo[]> {\n    const broker = this.ctx.kernel.cluster?.broker\n    if (!broker) return []\n    try {\n      return await broker.call<void, readonly KernelProcessInfo[]>('$process.list')\n    } catch {\n      return []\n    }\n  }\n\n  private async listAddonInstances() {\n    const broker = this.ctx.kernel.cluster?.broker\n    const hubNodeId = broker?.nodeID ?? 'hub'\n    const uptimeSec = Math.max(0, Math.floor((Date.now() - this.startedAtMs) / 1000))\n    const instances: AddonInstance[] = [{\n      addonId: '$hub',\n      nodeId: hubNodeId,\n      role: 'hub',\n      pid: process.pid,\n      state: 'running',\n      uptimeSec,\n    }]\n    const workers = await this.listWorkerInstances()\n    for (const w of workers) {\n      instances.push({\n        addonId: w.addonId,\n        nodeId: w.nodeId,\n        role: 'worker',\n        pid: w.pid,\n        state: narrowWorkerState(w.state),\n        uptimeSec: w.uptimeSeconds,\n      })\n    }\n    return instances\n  }\n\n  private async getAddonStats(addonId: string) {\n    const provider = this.provider\n    if (!provider) return null\n    if (addonId === '$hub') {\n      const stats = await provider.getProcessStats({ pids: [process.pid] })\n      return stats[0] ?? null\n    }\n    const workers = await this.listWorkerInstances()\n    const target = workers.find((w) => w.addonId === addonId)\n    if (!target) return null\n    const stats = await provider.getProcessStats({ pids: [target.pid] })\n    return stats[0] ?? null\n  }\n\n  protected globalSettingsSchema() {\n    return this.schema({\n      sections: [{\n        id: 'glances-connection',\n        title: 'Glances Metrics',\n        columns: 3,\n        fields: [\n          this.field({\n            type: 'text', key: 'glancesUrl', label: 'Glances URL',\n            description: 'Base URL of the Glances REST API',\n            placeholder: 'http://localhost:61208', default: 'http://localhost:61208',\n          }),\n          this.field({\n            type: 'number', key: 'timeoutMs', label: 'Request Timeout',\n            description: 'Timeout for each Glances API request',\n            min: 500, max: 10000, step: 500, default: 3000, unit: 'ms',\n          }),\n          this.field({\n            type: 'number', key: 'samplingIntervalMs', label: 'Sampling Interval',\n            description: 'How often to collect system metrics',\n            min: 1000, max: 60000, step: 1000, default: 5000, unit: 'ms',\n          }),\n        ],\n      }],\n    })\n  }\n}\n","// ===========================================================================\n// GlancesClient — HTTP client for Glances REST API v4.\n// Endpoint reference: http://localhost:61208/api/4/\n// ===========================================================================\n\nexport interface GlancesCpuResponse {\n  total: number\n  user: number\n  system: number\n  idle: number\n  nice: number\n  irq: number\n  iowait?: number\n  steal?: number\n  guest?: number\n  cpucore: number\n}\n\nexport interface GlancesMemResponse {\n  total: number\n  available: number\n  percent: number\n  used: number\n  free: number\n  active?: number\n  inactive?: number\n  buffers?: number\n  cached?: number\n  shared?: number\n  swap_total?: number\n  swap_used?: number\n  swap_free?: number\n  swap_percent?: number\n}\n\nexport interface GlancesDiskIoItem {\n  disk_name: string\n  read_bytes: number\n  write_bytes: number\n  read_count: number\n  write_count: number\n  key: string\n}\n\nexport interface GlancesFsItem {\n  device_name: string\n  fs_type: string\n  mnt_point: string\n  size: number\n  used: number\n  free: number\n  percent: number\n  key: string\n}\n\nexport interface GlancesNetworkItem {\n  interface_name: string\n  bytes_recv: number\n  bytes_sent: number\n  packets_recv?: number\n  packets_sent?: number\n  errin?: number\n  errout?: number\n  key: string\n}\n\nexport interface GlancesSensorItem {\n  label: string\n  value: number\n  unit: string\n  type: string // 'temperature_core', 'fan_speed', 'battery', etc.\n  key: string\n}\n\nexport interface GlancesGpuItem {\n  gpu_id: number\n  name: string\n  mem: number      // memory usage %\n  proc: number     // processor usage %\n  temperature?: number\n  fan_speed?: number\n  key: string\n}\n\nexport interface GlancesLoadResponse {\n  min1: number\n  min5: number\n  min15: number\n  cpucore: number\n}\n\nexport class GlancesClient {\n  constructor(\n    private readonly baseUrl: string,\n    private readonly timeoutMs: number = 3000,\n  ) {}\n\n  /** Check if Glances is reachable. */\n  async isReachable(): Promise<boolean> {\n    try {\n      const res = await this.fetch('/status')\n      return res !== null\n    } catch {\n      return false\n    }\n  }\n\n  async getCpu(): Promise<GlancesCpuResponse | null> {\n    return this.fetch<GlancesCpuResponse>('/cpu')\n  }\n\n  async getMem(): Promise<GlancesMemResponse | null> {\n    return this.fetch<GlancesMemResponse>('/mem')\n  }\n\n  async getDiskIo(): Promise<GlancesDiskIoItem[] | null> {\n    return this.fetch<GlancesDiskIoItem[]>('/diskio')\n  }\n\n  async getFs(): Promise<GlancesFsItem[] | null> {\n    return this.fetch<GlancesFsItem[]>('/fs')\n  }\n\n  async getNetwork(): Promise<GlancesNetworkItem[] | null> {\n    return this.fetch<GlancesNetworkItem[]>('/network')\n  }\n\n  async getSensors(): Promise<GlancesSensorItem[] | null> {\n    return this.fetch<GlancesSensorItem[]>('/sensors')\n  }\n\n  async getGpu(): Promise<GlancesGpuItem[] | null> {\n    return this.fetch<GlancesGpuItem[]>('/gpu')\n  }\n\n  async getLoad(): Promise<GlancesLoadResponse | null> {\n    return this.fetch<GlancesLoadResponse>('/load')\n  }\n\n  // ─── Internal ─────────────────────────────────────────────────────\n\n  private async fetch<T>(endpoint: string): Promise<T | null> {\n    try {\n      const url = `${this.baseUrl}/api/4${endpoint}`\n      const res = await globalThis.fetch(url, {\n        signal: AbortSignal.timeout(this.timeoutMs),\n        headers: { 'Accept': 'application/json' },\n      })\n      if (!res.ok) return null\n      return await res.json() as T\n    } catch {\n      return null\n    }\n  }\n}\n","import type {\n  SystemResourceSnapshot,\n  CpuBreakdown,\n  MemoryInfo,\n  DiskSpaceInfo,\n  DiskIoSnapshot,\n  NetworkIoSnapshot,\n  MetricsGpuInfo,\n  ProcessResourceInfo,\n  PidResourceStats,\n  IScopedLogger,\n} from '@camstack/types'\nimport type { GlancesClient } from './glances-client.js'\n\n/**\n * GlancesMetricsProvider — IMetricsProvider backed by the Glances REST API.\n *\n * There is no silent fallback: if Glances is unreachable each method throws\n * so the caller sees the real failure. Users who want a non-Glances metrics\n * source enable the native-metrics addon instead.\n */\nexport class GlancesMetricsProvider {\n  readonly id = 'glances'\n\n  private cachedSnapshot: SystemResourceSnapshot | null = null\n  private samplingTimer: ReturnType<typeof setInterval> | null = null\n\n  constructor(\n    private readonly client: GlancesClient,\n    private readonly logger: IScopedLogger,\n  ) {}\n\n  // ─── Lifecycle (addon-owned, not on the cap contract) ───────────────\n\n  startSampling(intervalMs: number): void {\n    this.collectSnapshot().then((s) => { this.cachedSnapshot = s }).catch((err: unknown) => {\n      this.logger.warn('Initial Glances snapshot failed', { meta: { error: err instanceof Error ? err.message : String(err) } })\n    })\n\n    this.samplingTimer = setInterval(() => {\n      this.collectSnapshot().then((s) => { this.cachedSnapshot = s }).catch(() => { /* next tick */ })\n    }, intervalMs)\n    if (this.samplingTimer.unref) this.samplingTimer.unref()\n  }\n\n  stopSampling(): void {\n    if (this.samplingTimer) { clearInterval(this.samplingTimer); this.samplingTimer = null }\n  }\n\n  // ─── Cap contract ───────────────────────────────────────────────────\n\n  async collectSnapshot(): Promise<SystemResourceSnapshot> {\n    const snapshot = await this.collectFromGlances()\n    this.cachedSnapshot = snapshot\n    return snapshot\n  }\n\n  async getCached(): Promise<SystemResourceSnapshot | null> {\n    return this.cachedSnapshot\n  }\n\n  async getCurrent(): Promise<{\n    cpuPercent: number\n    memoryPercent: number\n    memoryUsedMB: number\n    memoryTotalMB: number\n    diskPercent?: number\n    temperature?: number\n    gpuPercent?: number\n    gpuMemoryPercent?: number\n  }> {\n    const s = this.cachedSnapshot ?? await this.collectSnapshot()\n    const mb = (bytes: number) => Math.round(bytes / 1024 / 1024)\n    return {\n      cpuPercent: s.cpu.total,\n      memoryPercent: s.memory.percent,\n      memoryUsedMB: mb(s.memory.usedBytes),\n      memoryTotalMB: mb(s.memory.totalBytes),\n      temperature: s.cpuTemperature ?? undefined,\n      gpuPercent: s.gpu?.utilization,\n      gpuMemoryPercent:\n        s.gpu && s.gpu.memoryTotalBytes > 0\n          ? Math.round((s.gpu.memoryUsedBytes / s.gpu.memoryTotalBytes) * 1000) / 10\n          : undefined,\n    }\n  }\n\n  async getDiskSpace(input: { dirPath: string }): Promise<DiskSpaceInfo> {\n    const fsData = await this.client.getFs()\n    if (!fsData) throw new Error('Glances /fs endpoint returned no data')\n    const match = fsData.find((f) => input.dirPath.startsWith(f.mnt_point))\n    if (!match) throw new Error('Glances reported no filesystem matching path: ' + input.dirPath)\n    return {\n      path: match.mnt_point,\n      totalBytes: match.size,\n      usedBytes: match.used,\n      availableBytes: match.free,\n      percent: match.percent,\n    }\n  }\n\n  async getGpuInfo(): Promise<MetricsGpuInfo | null> {\n    const gpuData = await this.client.getGpu()\n    if (!gpuData || gpuData.length === 0) return null\n    const gpu = gpuData[0]!\n    return {\n      utilization: gpu.proc,\n      model: gpu.name,\n      memoryUsedBytes: 0,\n      memoryTotalBytes: 0,\n      temperature: gpu.temperature ?? null,\n    }\n  }\n\n  async getCpuTemperature(): Promise<number | null> {\n    const sensors = await this.client.getSensors()\n    if (!sensors) return null\n    const cpuTemp = sensors.find((s) =>\n      s.type === 'temperature_core' || s.label.toLowerCase().includes('cpu'),\n    )\n    return cpuTemp ? Math.round(cpuTemp.value * 10) / 10 : null\n  }\n\n  async getProcessStats(_input: { pids: number[] }): Promise<PidResourceStats[]> {\n    // Glances does not expose per-PID CPU/mem the way this capability requires.\n    // Consumers wanting per-process stats enable the native-metrics addon.\n    return []\n  }\n\n  // ─── Internal ───────────────────────────────────────────────────────\n\n  private async collectFromGlances(): Promise<SystemResourceSnapshot> {\n    const [cpuData, memData, diskIoData, networkData, loadData, sensorsData, gpuData] = await Promise.all([\n      this.client.getCpu(),\n      this.client.getMem(),\n      this.client.getDiskIo(),\n      this.client.getNetwork(),\n      this.client.getLoad(),\n      this.client.getSensors(),\n      this.client.getGpu(),\n    ])\n\n    if (!cpuData || !memData) {\n      throw new Error('Glances: core endpoints (cpu/mem) returned null')\n    }\n\n    const cpu: CpuBreakdown = {\n      total: cpuData.total,\n      user: cpuData.user,\n      system: cpuData.system,\n      irq: cpuData.irq,\n      nice: cpuData.nice,\n      loadAvg: loadData\n        ? [loadData.min1, loadData.min5, loadData.min15]\n        : [0, 0, 0],\n      cores: cpuData.cpucore,\n    }\n\n    const memory: MemoryInfo = {\n      percent: memData.percent,\n      totalBytes: memData.total,\n      usedBytes: memData.used,\n      availableBytes: memData.available,\n      swapUsedBytes: memData.swap_used ?? 0,\n      swapTotalBytes: memData.swap_total ?? 0,\n    }\n\n    const disk: DiskIoSnapshot = {\n      readBytes: diskIoData?.reduce((sum, d) => sum + (d.read_bytes ?? 0), 0) ?? 0,\n      writeBytes: diskIoData?.reduce((sum, d) => sum + (d.write_bytes ?? 0), 0) ?? 0,\n      readOps: diskIoData?.reduce((sum, d) => sum + (d.read_count ?? 0), 0) ?? 0,\n      writeOps: diskIoData?.reduce((sum, d) => sum + (d.write_count ?? 0), 0) ?? 0,\n      timestampMs: Date.now(),\n    }\n\n    const network: NetworkIoSnapshot = {\n      rxBytes: networkData?.reduce((sum, n) => sum + (n.bytes_recv ?? 0), 0) ?? 0,\n      txBytes: networkData?.reduce((sum, n) => sum + (n.bytes_sent ?? 0), 0) ?? 0,\n      rxPackets: networkData?.reduce((sum, n) => sum + (n.packets_recv ?? 0), 0) ?? 0,\n      txPackets: networkData?.reduce((sum, n) => sum + (n.packets_sent ?? 0), 0) ?? 0,\n      rxErrors: networkData?.reduce((sum, n) => sum + (n.errin ?? 0), 0) ?? 0,\n      txErrors: networkData?.reduce((sum, n) => sum + (n.errout ?? 0), 0) ?? 0,\n      timestampMs: Date.now(),\n    }\n\n    let gpu: MetricsGpuInfo | null = null\n    if (gpuData && gpuData.length > 0) {\n      const g = gpuData[0]!\n      gpu = {\n        utilization: g.proc,\n        model: g.name,\n        memoryUsedBytes: 0,\n        memoryTotalBytes: 0,\n        temperature: g.temperature ?? null,\n      }\n    }\n\n    let cpuTemperature: number | null = null\n    if (sensorsData) {\n      const tempSensor = sensorsData.find((s) =>\n        s.type === 'temperature_core' || s.label.toLowerCase().includes('cpu'),\n      )\n      if (tempSensor) cpuTemperature = Math.round(tempSensor.value * 10) / 10\n    }\n\n    // Node.js internals _getActiveHandles / _getActiveRequests are undocumented\n    // but stable across all LTS versions.\n    const p = process as unknown as Record<string, (() => unknown[]) | undefined>\n    const activeHandles = Array.isArray(p._getActiveHandles?.()) ? (p._getActiveHandles!() as unknown[]).length : 0\n    const activeRequests = Array.isArray(p._getActiveRequests?.()) ? (p._getActiveRequests!() as unknown[]).length : 0\n    const processInfo: ProcessResourceInfo = {\n      openFds: 0,\n      threadCount: 0,\n      activeHandles,\n      activeRequests,\n    }\n\n    return {\n      cpu,\n      memory,\n      gpu,\n      network,\n      disk,\n      pressure: { cpu: null, memory: null, io: null },\n      process: processInfo,\n      cpuTemperature,\n      timestampMs: Date.now(),\n    }\n  }\n}\n"],"mappings":"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","names":["stats"]}

package/dist/glances-metrics.addon.mjs

@@ -0,0 +1,7 @@
+import {
+  GlancesMetricsAddon
+} from "./chunk-WLTPZ3KJ.mjs";
+export {
+  GlancesMetricsAddon as default
+};
+//# sourceMappingURL=glances-metrics.addon.mjs.map

package/dist/glances-metrics.addon.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.mts

@@ -0,0 +1,138 @@
+export { default as GlancesMetricsAddon } from './glances-metrics.addon.mjs';
+import { IScopedLogger, SystemResourceSnapshot, DiskSpaceInfo, MetricsGpuInfo, PidResourceStats } from '@camstack/types';
+
+interface GlancesCpuResponse {
+    total: number;
+    user: number;
+    system: number;
+    idle: number;
+    nice: number;
+    irq: number;
+    iowait?: number;
+    steal?: number;
+    guest?: number;
+    cpucore: number;
+}
+interface GlancesMemResponse {
+    total: number;
+    available: number;
+    percent: number;
+    used: number;
+    free: number;
+    active?: number;
+    inactive?: number;
+    buffers?: number;
+    cached?: number;
+    shared?: number;
+    swap_total?: number;
+    swap_used?: number;
+    swap_free?: number;
+    swap_percent?: number;
+}
+interface GlancesDiskIoItem {
+    disk_name: string;
+    read_bytes: number;
+    write_bytes: number;
+    read_count: number;
+    write_count: number;
+    key: string;
+}
+interface GlancesFsItem {
+    device_name: string;
+    fs_type: string;
+    mnt_point: string;
+    size: number;
+    used: number;
+    free: number;
+    percent: number;
+    key: string;
+}
+interface GlancesNetworkItem {
+    interface_name: string;
+    bytes_recv: number;
+    bytes_sent: number;
+    packets_recv?: number;
+    packets_sent?: number;
+    errin?: number;
+    errout?: number;
+    key: string;
+}
+interface GlancesSensorItem {
+    label: string;
+    value: number;
+    unit: string;
+    type: string;
+    key: string;
+}
+interface GlancesGpuItem {
+    gpu_id: number;
+    name: string;
+    mem: number;
+    proc: number;
+    temperature?: number;
+    fan_speed?: number;
+    key: string;
+}
+interface GlancesLoadResponse {
+    min1: number;
+    min5: number;
+    min15: number;
+    cpucore: number;
+}
+declare class GlancesClient {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    constructor(baseUrl: string, timeoutMs?: number);
+    /** Check if Glances is reachable. */
+    isReachable(): Promise<boolean>;
+    getCpu(): Promise<GlancesCpuResponse | null>;
+    getMem(): Promise<GlancesMemResponse | null>;
+    getDiskIo(): Promise<GlancesDiskIoItem[] | null>;
+    getFs(): Promise<GlancesFsItem[] | null>;
+    getNetwork(): Promise<GlancesNetworkItem[] | null>;
+    getSensors(): Promise<GlancesSensorItem[] | null>;
+    getGpu(): Promise<GlancesGpuItem[] | null>;
+    getLoad(): Promise<GlancesLoadResponse | null>;
+    private fetch;
+}
+
+/**
+ * GlancesMetricsProvider — IMetricsProvider backed by the Glances REST API.
+ *
+ * There is no silent fallback: if Glances is unreachable each method throws
+ * so the caller sees the real failure. Users who want a non-Glances metrics
+ * source enable the native-metrics addon instead.
+ */
+declare class GlancesMetricsProvider {
+    private readonly client;
+    private readonly logger;
+    readonly id = "glances";
+    private cachedSnapshot;
+    private samplingTimer;
+    constructor(client: GlancesClient, logger: IScopedLogger);
+    startSampling(intervalMs: number): void;
+    stopSampling(): void;
+    collectSnapshot(): Promise<SystemResourceSnapshot>;
+    getCached(): Promise<SystemResourceSnapshot | null>;
+    getCurrent(): Promise<{
+        cpuPercent: number;
+        memoryPercent: number;
+        memoryUsedMB: number;
+        memoryTotalMB: number;
+        diskPercent?: number;
+        temperature?: number;
+        gpuPercent?: number;
+        gpuMemoryPercent?: number;
+    }>;
+    getDiskSpace(input: {
+        dirPath: string;
+    }): Promise<DiskSpaceInfo>;
+    getGpuInfo(): Promise<MetricsGpuInfo | null>;
+    getCpuTemperature(): Promise<number | null>;
+    getProcessStats(_input: {
+        pids: number[];
+    }): Promise<PidResourceStats[]>;
+    private collectFromGlances;
+}
+
+export { GlancesClient, GlancesMetricsProvider };