@aidalinfo/aegis-agent 0.1.0

package/dist/bin.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { defineCommand, runMain } from "citty";
+import { execSync as execSync2 } from "child_process";
+
+// 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 }
+  });
+}
+
+// src/metrics/cpu.ts
+import si from "systeminformation";
+async function collectCpu() {
+  const load = await si.currentLoad();
+  return { usagePercent: Math.round(load.currentLoad * 10) / 10 };
+}
+
+// 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
+  };
+}
+
+// src/metrics/disk.ts
+import si3 from "systeminformation";
+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
+  }));
+}
+
+// src/metrics/network.ts
+import si4 from "systeminformation";
+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)
+  }));
+}
+
+// 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
+  };
+}
+
+// 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
+  };
+}
+
+// src/metrics/processes.ts
+import si6 from "systeminformation";
+async function collectProcesses() {
+  const { list } = await si6.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 si7 from "systeminformation";
+async function collectTemperature() {
+  try {
+    const temp = await si7.cpuTemperature();
+    return { cpuCelsius: temp.main !== null ? Math.round(temp.main * 10) / 10 : null };
+  } catch {
+    return { cpuCelsius: null };
+  }
+}
+
+// src/collector.ts
+async function collectMetrics(config) {
+  const [cpu, memory, disks] = await Promise.all([
+    collectCpu(),
+    collectMemory(),
+    collectDisk()
+  ]);
+  const metrics = { cpu, memory, disks };
+  if (config.mode === "full") {
+    const [network, swap, topProcesses, temperature] = await Promise.all([
+      collectNetwork(),
+      collectSwap(),
+      collectProcesses(),
+      collectTemperature()
+    ]);
+    Object.assign(metrics, {
+      network,
+      loadAverage: collectLoad(),
+      swap,
+      topProcesses,
+      temperature
+    });
+  }
+  return {
+    hostname: config.hostname,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: config.mode,
+    metrics
+  };
+}
+
+// src/pusher.ts
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function pushMetrics(payload, config) {
+  const url = `${config.endpoint.replace(/\/$/, "")}/api/agent/metrics`;
+  const body = JSON.stringify(payload);
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.apiKey}`
+  };
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const res = await fetch(url, { method: "POST", headers, body });
+      if (res.ok) return;
+      if (res.status === 401 || res.status === 403) {
+        console.error(`[aegis-agent] Auth error (${res.status}) \u2014 check your API key`);
+        return;
+      }
+      console.warn(`[aegis-agent] Push failed (${res.status}), attempt ${attempt + 1}/3`);
+    } catch (err) {
+      console.warn(`[aegis-agent] Network error, attempt ${attempt + 1}/3:`, err.message);
+    }
+    if (attempt < 2) await sleep(1e3 * 2 ** attempt);
+  }
+  console.error("[aegis-agent] All 3 push attempts failed \u2014 will retry next interval");
+}
+
+// src/systemd.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { execSync } from "child_process";
+function generateUnitFile(binaryPath) {
+  return `[Unit]
+Description=Aegis Monitoring Agent
+After=network.target
+StartLimitIntervalSec=0
+
+[Service]
+Type=simple
+Restart=always
+RestartSec=5
+ExecStart=${binaryPath} start
+WorkingDirectory=/etc/aegis-agent
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=aegis-agent
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+function installService(config, binaryPath) {
+  mkdirSync("/etc/aegis-agent", { recursive: true });
+  writeFileSync("/etc/aegis-agent/config.json", JSON.stringify(config, null, 2), { mode: 384 });
+  writeFileSync("/etc/systemd/system/aegis-agent.service", generateUnitFile(binaryPath));
+  execSync("systemctl daemon-reload");
+  execSync("systemctl enable --now aegis-agent");
+  console.log("[aegis-agent] Service installed and started \u2014 check status with: systemctl status aegis-agent");
+}
+function uninstallService() {
+  try {
+    execSync("systemctl disable --now aegis-agent", { stdio: "pipe" });
+  } catch {
+  }
+  try {
+    execSync("rm -f /etc/systemd/system/aegis-agent.service", { stdio: "pipe" });
+  } catch {
+  }
+  execSync("systemctl daemon-reload");
+  try {
+    execSync("rm -rf /etc/aegis-agent", { stdio: "pipe" });
+  } catch {
+  }
+  console.log("[aegis-agent] Service removed");
+}
+
+// src/bin.ts
+var start = defineCommand({
+  meta: { description: "Run the metrics collection loop (foreground)" },
+  async run() {
+    const config = loadConfig();
+    console.log(
+      `[aegis-agent] Starting \u2014 mode=${config.mode} interval=${config.interval}s endpoint=${config.endpoint}`
+    );
+    async function tick() {
+      try {
+        const payload = await collectMetrics(config);
+        await pushMetrics(payload, config);
+      } catch (err) {
+        console.error("[aegis-agent] Unexpected error during tick:", err);
+      }
+    }
+    await tick();
+    setInterval(tick, config.interval * 1e3);
+  }
+});
+var install = defineCommand({
+  meta: { description: "Install as a systemd service (requires root)" },
+  args: {
+    endpoint: { type: "string", required: true, description: "Aegis API base URL" },
+    "api-key": { type: "string", required: true, description: "Bearer token" },
+    interval: { type: "string", default: "30", description: "Push interval in seconds" },
+    mode: { type: "string", default: "core", description: "core or full" },
+    hostname: { type: "string", description: "Override hostname (auto-detected if omitted)" }
+  },
+  async run({ args }) {
+    let binaryPath;
+    try {
+      binaryPath = execSync2("which aegis-agent").toString().trim();
+    } catch {
+      binaryPath = process.argv[1];
+    }
+    const config = ConfigSchema.parse({
+      endpoint: args.endpoint,
+      apiKey: args["api-key"],
+      interval: Number(args.interval),
+      mode: args.mode,
+      ...args.hostname ? { hostname: args.hostname } : {}
+    });
+    installService(config, binaryPath);
+  }
+});
+var uninstall = defineCommand({
+  meta: { description: "Stop and remove the systemd service (requires root)" },
+  async run() {
+    uninstallService();
+  }
+});
+var main = defineCommand({
+  meta: { name: "aegis-agent", description: "Aegis monitoring agent" },
+  subCommands: { start, install, uninstall }
+});
+runMain(main);

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+
+declare const ConfigSchema: z.ZodObject<{
+    interval: z.ZodDefault<z.ZodNumber>;
+    endpoint: z.ZodString;
+    apiKey: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["core", "full"]>>;
+    hostname: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    interval: number;
+    endpoint: string;
+    apiKey: string;
+    mode: "core" | "full";
+    hostname: string;
+}, {
+    endpoint: string;
+    apiKey: string;
+    interval?: number | undefined;
+    mode?: "core" | "full" | undefined;
+    hostname?: string | undefined;
+}>;
+type Config = z.infer<typeof ConfigSchema>;
+
+interface MetricsPayload {
+    hostname: string;
+    timestamp: string;
+    mode: 'core' | 'full';
+    metrics: Record<string, unknown>;
+}
+
+export type { Config, MetricsPayload };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@aidalinfo/aegis-agent",
+  "version": "0.1.0",
+  "description": "Lightweight monitoring agent for Linux machines — pushes system metrics to Aegis",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "bin": {
+    "aegis-agent": "./dist/bin.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "release": "pnpm build && changelogen && npm publish && git push --follow-tags"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "systeminformation": "^5.23.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "changelogen": "^0.6.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.2.0"
+  }
+}