@aidalinfo/aegis-agent 0.1.0 → 0.2.0

package/dist/bin.js

@@ -31,81 +31,245 @@ function loadConfig(configPath = "/etc/aegis-agent/config.json") {
   });
 }
 
+// src/metrics/hostpaths.ts
+import { readFile, statfs } from "fs/promises";
+import { join } from "path";
+var HOST_PROC = process.env.AEGIS_HOST_PROC || "/proc";
+var HOST_SYS = process.env.AEGIS_HOST_SYS || "/sys";
+var HOST_ROOT = process.env.AEGIS_HOST_ROOT || "";
+function readProc(rel) {
+  return readFile(join(HOST_PROC, rel), "utf8");
+}
+function readHostFile(absPath) {
+  return readFile(HOST_ROOT ? join(HOST_ROOT, absPath) : absPath, "utf8");
+}
+function statHostFs(mount) {
+  return statfs(HOST_ROOT ? join(HOST_ROOT, mount) : mount);
+}
+
+// src/metrics/proc-parse.ts
+function parseProcStat(content) {
+  const line = content.split("\n").find((l) => l.startsWith("cpu "));
+  if (!line) return { idle: 0, total: 0 };
+  const nums = line.trim().split(/\s+/).slice(1).map(Number);
+  const idle = (nums[3] ?? 0) + (nums[4] ?? 0);
+  const total = nums.reduce((a, b) => a + (b || 0), 0);
+  return { idle, total };
+}
+function cpuPercent(prev3, cur) {
+  const dTotal = cur.total - prev3.total;
+  const dIdle = cur.idle - prev3.idle;
+  if (dTotal <= 0) return 0;
+  return Math.round((dTotal - dIdle) / dTotal * 1e3) / 10;
+}
+function parseMemInfo(content) {
+  const get = (key) => {
+    const m = content.match(new RegExp(`^${key}:\\s+(\\d+)`, "m"));
+    return m ? Number(m[1]) : 0;
+  };
+  return {
+    memTotalKb: get("MemTotal"),
+    memAvailableKb: get("MemAvailable"),
+    swapTotalKb: get("SwapTotal"),
+    swapFreeKb: get("SwapFree")
+  };
+}
+function memUsage(m) {
+  const totalMb = Math.round(m.memTotalKb / 1024);
+  const usedMb = Math.round((m.memTotalKb - m.memAvailableKb) / 1024);
+  return { totalMb, usedMb, usagePercent: totalMb === 0 ? 0 : Math.round(usedMb / totalMb * 1e3) / 10 };
+}
+function swapUsage(m) {
+  const totalMb = Math.round(m.swapTotalKb / 1024);
+  const usedMb = Math.round((m.swapTotalKb - m.swapFreeKb) / 1024);
+  return { totalMb, usedMb, usagePercent: totalMb === 0 ? 0 : Math.round(usedMb / totalMb * 1e3) / 10 };
+}
+function parseLoadAvg(content) {
+  const [a, b, c] = content.trim().split(/\s+/).map(Number);
+  return { "1m": a ?? 0, "5m": b ?? 0, "15m": c ?? 0 };
+}
+function parseUptime(content) {
+  return Math.round(Number(content.trim().split(/\s+/)[0] ?? 0));
+}
+function parseOsRelease(content) {
+  const m = content.match(/^PRETTY_NAME="?([^"\n]+)"?/m);
+  return m ? m[1] : null;
+}
+function parseNetDev(content) {
+  const out = [];
+  for (const line of content.split("\n")) {
+    const m = line.match(/^\s*([^:]+):\s*(.+)$/);
+    if (!m) continue;
+    const iface = m[1].trim();
+    if (iface === "lo") continue;
+    const f = m[2].trim().split(/\s+/).map(Number);
+    out.push({ iface, rxBytes: f[0] ?? 0, txBytes: f[8] ?? 0 });
+  }
+  return out;
+}
+function netRates(prev3, cur, dtSec) {
+  if (dtSec <= 0) return [];
+  const prevMap = new Map(prev3.map((p) => [p.iface, p]));
+  return cur.map((c) => {
+    const p = prevMap.get(c.iface);
+    const rx = p ? Math.max(0, c.rxBytes - p.rxBytes) : 0;
+    const tx = p ? Math.max(0, c.txBytes - p.txBytes) : 0;
+    return {
+      interface: c.iface,
+      rxBytesPerSec: Math.round(rx / dtSec),
+      txBytesPerSec: Math.round(tx / dtSec)
+    };
+  });
+}
+var PSEUDO_FS = /* @__PURE__ */ new Set([
+  "sysfs",
+  "proc",
+  "tmpfs",
+  "devtmpfs",
+  "devpts",
+  "cgroup",
+  "cgroup2",
+  "pstore",
+  "bpf",
+  "mqueue",
+  "debugfs",
+  "tracefs",
+  "securityfs",
+  "fusectl",
+  "configfs",
+  "overlay",
+  "autofs",
+  "hugetlbfs",
+  "squashfs",
+  "ramfs",
+  "nsfs",
+  "binfmt_misc",
+  "efivarfs"
+]);
+function parseMounts(content) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const line of content.split("\n")) {
+    const parts = line.split(/\s+/);
+    if (parts.length < 3) continue;
+    const [, mount, fstype] = parts;
+    if (PSEUDO_FS.has(fstype)) continue;
+    if (seen.has(mount)) continue;
+    seen.add(mount);
+    out.push(mount);
+  }
+  return out;
+}
+function parseDiskStats(content) {
+  let readSectors = 0;
+  let writeSectors = 0;
+  for (const line of content.split("\n")) {
+    const f = line.trim().split(/\s+/);
+    if (f.length < 11) continue;
+    const name = f[2];
+    if (/\d$/.test(name) || name.startsWith("loop") || name.startsWith("ram") || name.startsWith("dm-")) continue;
+    readSectors += Number(f[5]) || 0;
+    writeSectors += Number(f[9]) || 0;
+  }
+  return { readBytes: readSectors * 512, writeBytes: writeSectors * 512 };
+}
+function diskIoRates(prev3, cur, dtSec) {
+  if (dtSec <= 0) return { readBytesPerSec: 0, writeBytesPerSec: 0 };
+  return {
+    readBytesPerSec: Math.round(Math.max(0, cur.readBytes - prev3.readBytes) / dtSec),
+    writeBytesPerSec: Math.round(Math.max(0, cur.writeBytes - prev3.writeBytes) / dtSec)
+  };
+}
+
 // src/metrics/cpu.ts
-import si from "systeminformation";
+var prev = null;
 async function collectCpu() {
-  const load = await si.currentLoad();
-  return { usagePercent: Math.round(load.currentLoad * 10) / 10 };
+  const cur = parseProcStat(await readProc("stat"));
+  const usagePercent = prev ? cpuPercent(prev, cur) : 0;
+  prev = cur;
+  return { usagePercent };
 }
 
 // src/metrics/memory.ts
-import si2 from "systeminformation";
 async function collectMemory() {
-  const mem = await si2.mem();
-  const totalMb = Math.round(mem.total / 1048576);
-  const usedMb = Math.round(mem.used / 1048576);
-  return {
-    totalMb,
-    usedMb,
-    usagePercent: totalMb === 0 ? 0 : Math.round(usedMb / totalMb * 1e3) / 10
-  };
+  return memUsage(parseMemInfo(await readProc("meminfo")));
 }
 
 // src/metrics/disk.ts
-import si3 from "systeminformation";
+var prevIo = null;
+function normaliseMountForLabel(rawMount) {
+  if (!HOST_ROOT) return rawMount;
+  if (rawMount === HOST_ROOT) return "/";
+  const prefix = HOST_ROOT.endsWith("/") ? HOST_ROOT : HOST_ROOT + "/";
+  if (rawMount.startsWith(prefix)) return "/" + rawMount.slice(prefix.length);
+  return rawMount;
+}
 async function collectDisk() {
-  const [fsSizes, fsStats] = await Promise.all([si3.fsSize(), si3.fsStats()]);
-  const readBytesPerSec = Math.round(fsStats.rx_sec ?? 0);
-  const writeBytesPerSec = Math.round(fsStats.wx_sec ?? 0);
-  return fsSizes.map((fs) => ({
-    mount: fs.mount,
-    totalGb: Math.round(fs.size / 1073741824 * 10) / 10,
-    usedGb: Math.round(fs.used / 1073741824 * 10) / 10,
-    usagePercent: Math.round(fs.use * 10) / 10,
-    readBytesPerSec,
-    writeBytesPerSec
-  }));
+  const rawMounts = parseMounts(await readProc("mounts"));
+  const stats = parseDiskStats(await readProc("diskstats"));
+  const now = Date.now();
+  let io = { readBytesPerSec: 0, writeBytesPerSec: 0 };
+  if (prevIo) io = diskIoRates(prevIo.stats, stats, (now - prevIo.t) / 1e3);
+  prevIo = { stats, t: now };
+  const out = [];
+  const seenLabels = /* @__PURE__ */ new Set();
+  for (const rawMount of rawMounts) {
+    try {
+      const label = normaliseMountForLabel(rawMount);
+      if (seenLabels.has(label)) continue;
+      seenLabels.add(label);
+      const fs = await statHostFs(label);
+      const bsize = Number(fs.bsize);
+      const blocks = Number(fs.blocks);
+      const bfree = Number(fs.bfree);
+      const bavail = Number(fs.bavail);
+      if (!blocks) continue;
+      const totalBytes = blocks * bsize;
+      const usedBytes = (blocks - bfree) * bsize;
+      const denom = blocks - bfree + bavail;
+      out.push({
+        mount: label,
+        totalGb: Math.round(totalBytes / 1073741824 * 10) / 10,
+        usedGb: Math.round(usedBytes / 1073741824 * 10) / 10,
+        usagePercent: denom > 0 ? Math.round((blocks - bfree) / denom * 1e3) / 10 : 0,
+        readBytesPerSec: io.readBytesPerSec,
+        writeBytesPerSec: io.writeBytesPerSec
+      });
+    } catch {
+    }
+  }
+  return out;
 }
 
 // src/metrics/network.ts
-import si4 from "systeminformation";
+var prev2 = null;
 async function collectNetwork() {
-  const stats = await si4.networkStats();
-  return stats.filter((s) => s.iface && s.rx_sec !== null).map((s) => ({
-    interface: s.iface,
-    rxBytesPerSec: Math.round(s.rx_sec ?? 0),
-    txBytesPerSec: Math.round(s.tx_sec ?? 0)
-  }));
+  const counters = parseNetDev(await readProc("net/dev"));
+  const now = Date.now();
+  if (!prev2) {
+    prev2 = { counters, t: now };
+    return counters.map((c) => ({ interface: c.iface, rxBytesPerSec: 0, txBytesPerSec: 0 }));
+  }
+  const dtSec = (now - prev2.t) / 1e3;
+  const rates = netRates(prev2.counters, counters, dtSec);
+  prev2 = { counters, t: now };
+  return rates;
 }
 
 // src/metrics/load.ts
-import { loadavg } from "os";
-function collectLoad() {
-  const [l1, l5, l15] = loadavg();
-  return {
-    "1m": Math.round(l1 * 100) / 100,
-    "5m": Math.round(l5 * 100) / 100,
-    "15m": Math.round(l15 * 100) / 100
-  };
+async function collectLoad() {
+  return parseLoadAvg(await readProc("loadavg"));
 }
 
 // src/metrics/swap.ts
-import si5 from "systeminformation";
 async function collectSwap() {
-  const mem = await si5.mem();
-  const totalMb = Math.round(mem.swaptotal / 1048576);
-  const usedMb = Math.round(mem.swapused / 1048576);
-  return {
-    totalMb,
-    usedMb,
-    usagePercent: totalMb === 0 ? 0 : Math.round(usedMb / totalMb * 1e3) / 10
-  };
+  return swapUsage(parseMemInfo(await readProc("meminfo")));
 }
 
 // src/metrics/processes.ts
-import si6 from "systeminformation";
+import si from "systeminformation";
 async function collectProcesses() {
-  const { list } = await si6.processes();
+  const { list } = await si.processes();
   return list.sort((a, b) => b.cpu - a.cpu).slice(0, 5).map((p) => ({
     pid: p.pid,
     name: p.name,
@@ -115,38 +279,51 @@ async function collectProcesses() {
 }
 
 // src/metrics/temperature.ts
-import si7 from "systeminformation";
+import si2 from "systeminformation";
 async function collectTemperature() {
   try {
-    const temp = await si7.cpuTemperature();
+    const temp = await si2.cpuTemperature();
     return { cpuCelsius: temp.main !== null ? Math.round(temp.main * 10) / 10 : null };
   } catch {
     return { cpuCelsius: null };
   }
 }
 
+// src/metrics/system.ts
+async function collectUptime() {
+  try {
+    return parseUptime(await readProc("uptime"));
+  } catch {
+    return 0;
+  }
+}
+async function collectOs() {
+  try {
+    return parseOsRelease(await readHostFile("/etc/os-release"));
+  } catch {
+    return null;
+  }
+}
+
 // src/collector.ts
 async function collectMetrics(config) {
-  const [cpu, memory, disks] = await Promise.all([
+  const [cpu, memory, disks, uptimeSeconds, os] = await Promise.all([
     collectCpu(),
     collectMemory(),
-    collectDisk()
+    collectDisk(),
+    collectUptime(),
+    collectOs()
   ]);
-  const metrics = { cpu, memory, disks };
+  const metrics = { cpu, memory, disks, os, uptimeSeconds };
   if (config.mode === "full") {
-    const [network, swap, topProcesses, temperature] = await Promise.all([
+    const [network, swap, topProcesses, temperature, loadAverage] = await Promise.all([
       collectNetwork(),
       collectSwap(),
       collectProcesses(),
-      collectTemperature()
+      collectTemperature(),
+      collectLoad()
     ]);
-    Object.assign(metrics, {
-      network,
-      loadAverage: collectLoad(),
-      swap,
-      topProcesses,
-      temperature
-    });
+    Object.assign(metrics, { network, loadAverage, swap, topProcesses, temperature });
   }
   return {
     hostname: config.hostname,
@@ -264,9 +441,18 @@ var install = defineCommand({
   async run({ args }) {
     let binaryPath;
     try {
-      binaryPath = execSync2("which aegis-agent").toString().trim();
+      binaryPath = execSync2("which aegis-agent", { stdio: "pipe" }).toString().trim();
     } catch {
-      binaryPath = process.argv[1];
+      console.log("[aegis-agent] Not found in PATH \u2014 installing globally via npm...");
+      try {
+        execSync2("npm install -g @aidalinfo/aegis-agent", { stdio: "inherit" });
+        binaryPath = execSync2("which aegis-agent", { stdio: "pipe" }).toString().trim();
+      } catch {
+        console.error(
+          "[aegis-agent] Global install failed.\nRun manually: npm install -g @aidalinfo/aegis-agent\nThen: aegis-agent install ..."
+        );
+        process.exit(1);
+      }
     }
     const config = ConfigSchema.parse({
       endpoint: args.endpoint,

package/dist/index.d.ts

@@ -20,6 +20,7 @@ declare const ConfigSchema: z.ZodObject<{
     hostname?: string | undefined;
 }>;
 type Config = z.infer<typeof ConfigSchema>;
+declare function loadConfig(configPath?: string): Config;
 
 interface MetricsPayload {
     hostname: string;
@@ -27,5 +28,6 @@ interface MetricsPayload {
     mode: 'core' | 'full';
     metrics: Record<string, unknown>;
 }
+declare function collectMetrics(config: Config): Promise<MetricsPayload>;
 
-export type { Config, MetricsPayload };
+export { type Config, ConfigSchema, type MetricsPayload, collectMetrics, loadConfig };

package/dist/index.js

@@ -0,0 +1,333 @@
+// src/metrics/hostpaths.ts
+import { readFile, statfs } from "fs/promises";
+import { join } from "path";
+var HOST_PROC = process.env.AEGIS_HOST_PROC || "/proc";
+var HOST_SYS = process.env.AEGIS_HOST_SYS || "/sys";
+var HOST_ROOT = process.env.AEGIS_HOST_ROOT || "";
+function readProc(rel) {
+  return readFile(join(HOST_PROC, rel), "utf8");
+}
+function readHostFile(absPath) {
+  return readFile(HOST_ROOT ? join(HOST_ROOT, absPath) : absPath, "utf8");
+}
+function statHostFs(mount) {
+  return statfs(HOST_ROOT ? join(HOST_ROOT, mount) : mount);
+}
+
+// src/metrics/proc-parse.ts
+function parseProcStat(content) {
+  const line = content.split("\n").find((l) => l.startsWith("cpu "));
+  if (!line) return { idle: 0, total: 0 };
+  const nums = line.trim().split(/\s+/).slice(1).map(Number);
+  const idle = (nums[3] ?? 0) + (nums[4] ?? 0);
+  const total = nums.reduce((a, b) => a + (b || 0), 0);
+  return { idle, total };
+}
+function cpuPercent(prev3, cur) {
+  const dTotal = cur.total - prev3.total;
+  const dIdle = cur.idle - prev3.idle;
+  if (dTotal <= 0) return 0;
+  return Math.round((dTotal - dIdle) / dTotal * 1e3) / 10;
+}
+function parseMemInfo(content) {
+  const get = (key) => {
+    const m = content.match(new RegExp(`^${key}:\\s+(\\d+)`, "m"));
+    return m ? Number(m[1]) : 0;
+  };
+  return {
+    memTotalKb: get("MemTotal"),
+    memAvailableKb: get("MemAvailable"),
+    swapTotalKb: get("SwapTotal"),
+    swapFreeKb: get("SwapFree")
+  };
+}
+function memUsage(m) {
+  const totalMb = Math.round(m.memTotalKb / 1024);
+  const usedMb = Math.round((m.memTotalKb - m.memAvailableKb) / 1024);
+  return { totalMb, usedMb, usagePercent: totalMb === 0 ? 0 : Math.round(usedMb / totalMb * 1e3) / 10 };
+}
+function swapUsage(m) {
+  const totalMb = Math.round(m.swapTotalKb / 1024);
+  const usedMb = Math.round((m.swapTotalKb - m.swapFreeKb) / 1024);
+  return { totalMb, usedMb, usagePercent: totalMb === 0 ? 0 : Math.round(usedMb / totalMb * 1e3) / 10 };
+}
+function parseLoadAvg(content) {
+  const [a, b, c] = content.trim().split(/\s+/).map(Number);
+  return { "1m": a ?? 0, "5m": b ?? 0, "15m": c ?? 0 };
+}
+function parseUptime(content) {
+  return Math.round(Number(content.trim().split(/\s+/)[0] ?? 0));
+}
+function parseOsRelease(content) {
+  const m = content.match(/^PRETTY_NAME="?([^"\n]+)"?/m);
+  return m ? m[1] : null;
+}
+function parseNetDev(content) {
+  const out = [];
+  for (const line of content.split("\n")) {
+    const m = line.match(/^\s*([^:]+):\s*(.+)$/);
+    if (!m) continue;
+    const iface = m[1].trim();
+    if (iface === "lo") continue;
+    const f = m[2].trim().split(/\s+/).map(Number);
+    out.push({ iface, rxBytes: f[0] ?? 0, txBytes: f[8] ?? 0 });
+  }
+  return out;
+}
+function netRates(prev3, cur, dtSec) {
+  if (dtSec <= 0) return [];
+  const prevMap = new Map(prev3.map((p) => [p.iface, p]));
+  return cur.map((c) => {
+    const p = prevMap.get(c.iface);
+    const rx = p ? Math.max(0, c.rxBytes - p.rxBytes) : 0;
+    const tx = p ? Math.max(0, c.txBytes - p.txBytes) : 0;
+    return {
+      interface: c.iface,
+      rxBytesPerSec: Math.round(rx / dtSec),
+      txBytesPerSec: Math.round(tx / dtSec)
+    };
+  });
+}
+var PSEUDO_FS = /* @__PURE__ */ new Set([
+  "sysfs",
+  "proc",
+  "tmpfs",
+  "devtmpfs",
+  "devpts",
+  "cgroup",
+  "cgroup2",
+  "pstore",
+  "bpf",
+  "mqueue",
+  "debugfs",
+  "tracefs",
+  "securityfs",
+  "fusectl",
+  "configfs",
+  "overlay",
+  "autofs",
+  "hugetlbfs",
+  "squashfs",
+  "ramfs",
+  "nsfs",
+  "binfmt_misc",
+  "efivarfs"
+]);
+function parseMounts(content) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const line of content.split("\n")) {
+    const parts = line.split(/\s+/);
+    if (parts.length < 3) continue;
+    const [, mount, fstype] = parts;
+    if (PSEUDO_FS.has(fstype)) continue;
+    if (seen.has(mount)) continue;
+    seen.add(mount);
+    out.push(mount);
+  }
+  return out;
+}
+function parseDiskStats(content) {
+  let readSectors = 0;
+  let writeSectors = 0;
+  for (const line of content.split("\n")) {
+    const f = line.trim().split(/\s+/);
+    if (f.length < 11) continue;
+    const name = f[2];
+    if (/\d$/.test(name) || name.startsWith("loop") || name.startsWith("ram") || name.startsWith("dm-")) continue;
+    readSectors += Number(f[5]) || 0;
+    writeSectors += Number(f[9]) || 0;
+  }
+  return { readBytes: readSectors * 512, writeBytes: writeSectors * 512 };
+}
+function diskIoRates(prev3, cur, dtSec) {
+  if (dtSec <= 0) return { readBytesPerSec: 0, writeBytesPerSec: 0 };
+  return {
+    readBytesPerSec: Math.round(Math.max(0, cur.readBytes - prev3.readBytes) / dtSec),
+    writeBytesPerSec: Math.round(Math.max(0, cur.writeBytes - prev3.writeBytes) / dtSec)
+  };
+}
+
+// src/metrics/cpu.ts
+var prev = null;
+async function collectCpu() {
+  const cur = parseProcStat(await readProc("stat"));
+  const usagePercent = prev ? cpuPercent(prev, cur) : 0;
+  prev = cur;
+  return { usagePercent };
+}
+
+// src/metrics/memory.ts
+async function collectMemory() {
+  return memUsage(parseMemInfo(await readProc("meminfo")));
+}
+
+// src/metrics/disk.ts
+var prevIo = null;
+function normaliseMountForLabel(rawMount) {
+  if (!HOST_ROOT) return rawMount;
+  if (rawMount === HOST_ROOT) return "/";
+  const prefix = HOST_ROOT.endsWith("/") ? HOST_ROOT : HOST_ROOT + "/";
+  if (rawMount.startsWith(prefix)) return "/" + rawMount.slice(prefix.length);
+  return rawMount;
+}
+async function collectDisk() {
+  const rawMounts = parseMounts(await readProc("mounts"));
+  const stats = parseDiskStats(await readProc("diskstats"));
+  const now = Date.now();
+  let io = { readBytesPerSec: 0, writeBytesPerSec: 0 };
+  if (prevIo) io = diskIoRates(prevIo.stats, stats, (now - prevIo.t) / 1e3);
+  prevIo = { stats, t: now };
+  const out = [];
+  const seenLabels = /* @__PURE__ */ new Set();
+  for (const rawMount of rawMounts) {
+    try {
+      const label = normaliseMountForLabel(rawMount);
+      if (seenLabels.has(label)) continue;
+      seenLabels.add(label);
+      const fs = await statHostFs(label);
+      const bsize = Number(fs.bsize);
+      const blocks = Number(fs.blocks);
+      const bfree = Number(fs.bfree);
+      const bavail = Number(fs.bavail);
+      if (!blocks) continue;
+      const totalBytes = blocks * bsize;
+      const usedBytes = (blocks - bfree) * bsize;
+      const denom = blocks - bfree + bavail;
+      out.push({
+        mount: label,
+        totalGb: Math.round(totalBytes / 1073741824 * 10) / 10,
+        usedGb: Math.round(usedBytes / 1073741824 * 10) / 10,
+        usagePercent: denom > 0 ? Math.round((blocks - bfree) / denom * 1e3) / 10 : 0,
+        readBytesPerSec: io.readBytesPerSec,
+        writeBytesPerSec: io.writeBytesPerSec
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/metrics/network.ts
+var prev2 = null;
+async function collectNetwork() {
+  const counters = parseNetDev(await readProc("net/dev"));
+  const now = Date.now();
+  if (!prev2) {
+    prev2 = { counters, t: now };
+    return counters.map((c) => ({ interface: c.iface, rxBytesPerSec: 0, txBytesPerSec: 0 }));
+  }
+  const dtSec = (now - prev2.t) / 1e3;
+  const rates = netRates(prev2.counters, counters, dtSec);
+  prev2 = { counters, t: now };
+  return rates;
+}
+
+// src/metrics/load.ts
+async function collectLoad() {
+  return parseLoadAvg(await readProc("loadavg"));
+}
+
+// src/metrics/swap.ts
+async function collectSwap() {
+  return swapUsage(parseMemInfo(await readProc("meminfo")));
+}
+
+// src/metrics/processes.ts
+import si from "systeminformation";
+async function collectProcesses() {
+  const { list } = await si.processes();
+  return list.sort((a, b) => b.cpu - a.cpu).slice(0, 5).map((p) => ({
+    pid: p.pid,
+    name: p.name,
+    cpuPercent: Math.round(p.cpu * 10) / 10,
+    memPercent: Math.round(p.mem * 10) / 10
+  }));
+}
+
+// src/metrics/temperature.ts
+import si2 from "systeminformation";
+async function collectTemperature() {
+  try {
+    const temp = await si2.cpuTemperature();
+    return { cpuCelsius: temp.main !== null ? Math.round(temp.main * 10) / 10 : null };
+  } catch {
+    return { cpuCelsius: null };
+  }
+}
+
+// src/metrics/system.ts
+async function collectUptime() {
+  try {
+    return parseUptime(await readProc("uptime"));
+  } catch {
+    return 0;
+  }
+}
+async function collectOs() {
+  try {
+    return parseOsRelease(await readHostFile("/etc/os-release"));
+  } catch {
+    return null;
+  }
+}
+
+// src/collector.ts
+async function collectMetrics(config) {
+  const [cpu, memory, disks, uptimeSeconds, os] = await Promise.all([
+    collectCpu(),
+    collectMemory(),
+    collectDisk(),
+    collectUptime(),
+    collectOs()
+  ]);
+  const metrics = { cpu, memory, disks, os, uptimeSeconds };
+  if (config.mode === "full") {
+    const [network, swap, topProcesses, temperature, loadAverage] = await Promise.all([
+      collectNetwork(),
+      collectSwap(),
+      collectProcesses(),
+      collectTemperature(),
+      collectLoad()
+    ]);
+    Object.assign(metrics, { network, loadAverage, swap, topProcesses, temperature });
+  }
+  return {
+    hostname: config.hostname,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: config.mode,
+    metrics
+  };
+}
+
+// src/config.ts
+import { z } from "zod";
+import { readFileSync } from "fs";
+import { hostname } from "os";
+var ConfigSchema = z.object({
+  interval: z.coerce.number().int().min(5).default(30),
+  endpoint: z.string().url(),
+  apiKey: z.string().min(1),
+  mode: z.enum(["core", "full"]).default("core"),
+  hostname: z.string().default(hostname())
+});
+function loadConfig(configPath = "/etc/aegis-agent/config.json") {
+  let fileConfig = {};
+  try {
+    fileConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+  }
+  return ConfigSchema.parse({
+    ...fileConfig,
+    ...process.env.AEGIS_INTERVAL !== void 0 && { interval: process.env.AEGIS_INTERVAL },
+    ...process.env.AEGIS_ENDPOINT !== void 0 && { endpoint: process.env.AEGIS_ENDPOINT },
+    ...process.env.AEGIS_API_KEY !== void 0 && { apiKey: process.env.AEGIS_API_KEY },
+    ...process.env.AEGIS_MODE !== void 0 && { mode: process.env.AEGIS_MODE },
+    ...process.env.AEGIS_HOSTNAME !== void 0 && { hostname: process.env.AEGIS_HOSTNAME }
+  });
+}
+export {
+  ConfigSchema,
+  collectMetrics,
+  loadConfig
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aidalinfo/aegis-agent",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Lightweight monitoring agent for Linux machines — pushes system metrics to Aegis",
   "license": "MIT",
   "type": "module",