@irsyadulibad/servermon 1.1.1 → 1.2.1

package/src/daemon/index.ts

@@ -0,0 +1,198 @@
+import { sendReport } from "../reporter";
+import { saveConfig, loadConfig, listServers } from "../config";
+import type { ServerEntry, NamedConfig } from "../types";
+
+/* ------------------------------------------------------------------ */
+/*  Environment variables (set by cli/)                                */
+/* ------------------------------------------------------------------ */
+
+const botToken = process.env["TELEGRAM_BOT_TOKEN"] ?? "";
+let chatId = process.env["TELEGRAM_CHAT_ID"] ?? "";
+const rawInterval = process.env["MONITOR_INTERVAL"] ?? "300";
+const intervalSec = Math.max(30, parseInt(rawInterval) || 300);
+const serverName = process.env["SERVER_NAME"] ?? "";
+
+/* ------------------------------------------------------------------ */
+/*  Auto-detect Telegram chat ID                                       */
+/* ------------------------------------------------------------------ */
+
+async function autoDetectChatId(token: string): Promise<string | null> {
+  try {
+    const resp = await fetch(`https://api.telegram.org/bot${token}/getUpdates?limit=5`);
+    const data = (await resp.json()) as {
+      ok: boolean;
+      result?: Array<{
+        message?: { chat?: { id: number; title?: string; first_name?: string } };
+        channel_post?: { chat?: { id: number; title?: string } };
+      }>;
+    };
+    if (!data.ok || !data.result?.length) return null;
+
+    const chatIds = new Set<string>();
+    for (const update of data.result.reverse()) {
+      const chat = update.message?.chat || update.channel_post?.chat;
+      if (chat?.id) chatIds.add(String(chat.id));
+    }
+    if (chatIds.size === 0) return null;
+
+    const id = [...chatIds][0]!;
+    const chatInfo = data.result.find(
+      (u) => String(u.message?.chat?.id || u.channel_post?.chat?.id) === id
+    );
+    const chatName =
+      chatInfo?.message?.chat?.title ||
+      chatInfo?.message?.chat?.first_name ||
+      chatInfo?.channel_post?.chat?.title ||
+      "Unknown";
+    console.log(`🔍 Auto-detected chat: ${chatName} (ID: ${id})`);
+    return id;
+  } catch {
+    return null;
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Persist chat ID to config file                                     */
+/* ------------------------------------------------------------------ */
+
+async function persistChatId(id: string, name?: string): Promise<void> {
+  try {
+    const entry = await loadConfig(name);
+    if (entry) {
+      entry.chatId = id;
+      await saveConfig({ ...entry, name });
+      console.log("💾 Chat ID saved to config");
+    }
+  } catch {
+    // ok
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Single-server daemon                                               */
+/* ------------------------------------------------------------------ */
+
+export async function start(): Promise<void> {
+  if (!botToken) {
+    console.error("❌ TELEGRAM_BOT_TOKEN not set. Run `servermon` first to configure.");
+    process.exit(1);
+  }
+
+  if (!chatId) {
+    console.log("🔍 TELEGRAM_CHAT_ID not set — auto-detecting...");
+    let detected = await autoDetectChatId(botToken);
+
+    if (!detected) {
+      console.log("⏳ Waiting for you to DM the bot on Telegram...");
+      console.log("   (polling every 10s — no restart needed)\n");
+
+      const POLL_INTERVAL_MS = 10_000;
+      while (!detected) {
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+        detected = await autoDetectChatId(botToken);
+      }
+    }
+
+    chatId = detected;
+    await persistChatId(chatId, serverName || undefined);
+  }
+
+  console.log(`⏱  Interval: ${intervalSec}s (${(intervalSec / 60).toFixed(0)} menit)`);
+  console.log(`📡 Bot:      ...${botToken.slice(-8)}`);
+  console.log(`💬 Chat:     ${chatId}`);
+  if (serverName) console.log(`🏷  Server:   ${serverName}`);
+  console.log();
+
+  async function tick() {
+    const start2 = Date.now();
+    const ok = await sendReport(botToken, chatId, serverName || undefined);
+    const elapsed = Date.now() - start2;
+    const ts = new Date().toLocaleString("id-ID", { timeZone: "Asia/Jakarta" });
+    console.log(`[${ts}] ${ok ? "✅" : "❌"} ${elapsed}ms`);
+  }
+
+  await tick();
+  setInterval(tick, intervalSec * 1000);
+
+  process.on("SIGINT", () => {
+    console.log("\n👋 Shutting down...");
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    console.log("\n👋 Shutting down...");
+    process.exit(0);
+  });
+}
+
+/* ------------------------------------------------------------------ */
+/*  Multi-server daemon (runs all configured servers)                  */
+/* ------------------------------------------------------------------ */
+
+export async function startAll(): Promise<void> {
+  const servers = await listServers();
+  if (servers.length === 0) {
+    console.error("❌ No configured servers found. Run `servermon setup` first.");
+    process.exit(1);
+  }
+
+  console.log(`📋 Found ${servers.length} server(s) to monitor:\n`);
+
+  const configs: NamedConfig[] = [];
+  for (const name of servers) {
+    const entry = await loadConfig(name);
+    if (!entry) {
+      console.log(`   ⚠️  ${name}: config unreadable, skipping`);
+      continue;
+    }
+    if (!entry.chatId) {
+      if (configs.length === 0) {
+        console.log(`🔍 ${name}: Chat ID not set — auto-detecting...`);
+        const detected = await autoDetectChatId(entry.token);
+        if (detected) {
+          entry.chatId = detected;
+          await saveConfig({ ...entry, name });
+          console.log(`💾 ${name}: Chat ID ${detected} saved`);
+        } else {
+          console.log(`   ❌ ${name}: no chat ID yet. DM your bot first then restart.`);
+          continue;
+        }
+      } else {
+        console.log(`   ❌ ${name}: no chat ID. Run 'servermon start --name ${name}' first.`);
+        continue;
+      }
+    }
+    configs.push({ name, cfg: entry });
+  }
+
+  if (configs.length === 0) {
+    console.error("❌ No servers ready to monitor.");
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(`🔄 Monitoring ${configs.length} server(s) — reports every ${intervalSec}s`);
+  console.log();
+
+  async function tickAll() {
+    const ts = new Date().toLocaleString("id-ID", { timeZone: "Asia/Jakarta" });
+    for (const { name, cfg } of configs) {
+      if (!cfg.chatId) continue;
+      const start2 = Date.now();
+      const ok = await sendReport(cfg.token, cfg.chatId, name === "default" ? undefined : name);
+      const elapsed = Date.now() - start2;
+      console.log(`[${ts}] ${ok ? "✅" : "❌"} ${name} — ${elapsed}ms`);
+    }
+  }
+
+  await tickAll();
+  setInterval(tickAll, intervalSec * 1000);
+
+  process.on("SIGINT", () => {
+    console.log("\n👋 Shutting down...");
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    console.log("\n👋 Shutting down...");
+    process.exit(0);
+  });
+}

package/src/{monitor.ts → monitor/index.ts}

@@ -1,56 +1,41 @@
 import * as os from "os";
+import type { DiskInfo, ProcInfo, SystemMetrics } from "../types";
 
-export interface CPUMetrics {
-  model: string;
-  cores: number;
-  loadAvg: { "1min": number; "5min": number; "15min": number };
-  usagePercent: number;
-}
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
 
-export interface MemoryMetrics {
-  total: number;
-  used: number;
-  free: number;
-  usagePercent: number;
-  swapTotal: number;
-  swapUsed: number;
-  swapUsagePercent: number;
+export function formatBytes(bytes: number): string {
+  if (bytes >= 1_073_741_824) return `${(bytes / 1_073_741_824).toFixed(1)} GiB`;
+  if (bytes >= 1_048_576) return `${(bytes / 1_048_576).toFixed(1)} MiB`;
+  if (bytes >= 1_024) return `${(bytes / 1_024).toFixed(1)} KiB`;
+  return `${bytes} B`;
 }
 
-export interface DiskInfo {
-  mount: string;
-  total: number;
-  used: number;
-  available: number;
-  usagePercent: number;
+export function formatRate(bytesPerSec: number): string {
+  if (bytesPerSec >= 1_048_576) return `${(bytesPerSec / 1_048_576).toFixed(2)} MB/s`;
+  if (bytesPerSec >= 1_024) return `${(bytesPerSec / 1_024).toFixed(1)} KB/s`;
+  return `${bytesPerSec} B/s`;
 }
 
-export interface NetworkMetrics {
-  rxRate: number; // bytes/sec
-  txRate: number;
-  rxTotal: number;
-  txTotal: number;
+export function formatUptime(seconds: number): string {
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor((seconds % 86400) / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const parts: string[] = [];
+  if (d > 0) parts.push(`${d}d`);
+  if (h > 0) parts.push(`${h}h`);
+  parts.push(`${m}m`);
+  return parts.join(" ");
 }
 
-export interface ProcInfo {
-  pid: number;
-  name: string;
-  cpuPercent: number;
-  memPercent: number;
+function cpuTicks(stat: string): number[] {
+  return stat.split(/\s+/).slice(1).map(Number);
 }
 
-export interface SystemMetrics {
-  hostname: string;
-  platform: string;
-  arch: string;
-  uptime: number;
-  cpu: CPUMetrics;
-  memory: MemoryMetrics;
-  disks: DiskInfo[];
-  network: NetworkMetrics;
-  topProcs: ProcInfo[];
-  temperature: number | null; // celsius
-}
+/* ------------------------------------------------------------------ */
+/*  Low-level collectors                                               */
+/* ------------------------------------------------------------------ */
 
 async function exec(cmd: string): Promise<string> {
   const proc = Bun.spawn(["bash", "-c", cmd], { stdout: "pipe" });
@@ -77,9 +62,7 @@ async function readNetDev(): Promise<{ rx: number; tx: number }> {
   for (const line of data.split("\n")) {
     if (!line.includes(":")) continue;
     const ifname = line.split(":")[0]!.trim();
-    // Skip loopback
     if (ifname === "lo") continue;
-    // Skip veth, docker
     if (ifname.startsWith("veth") || ifname.startsWith("docker") || ifname.startsWith("br-"))
       continue;
     const parts = line.split(":")[1]!.trim().split(/\s+/);
@@ -95,14 +78,6 @@ async function readTemperature(): Promise<number | null> {
       `for z in /sys/class/thermal/thermal_zone*/temp; do [ -r "$z" ] && echo "$z=$(cat "$z")"; done 2>/dev/null`
     );
     if (!zones) return null;
-    let best = Number.MAX_VALUE;
-    for (const line of zones.split("\n")) {
-      const val = parseInt(line.split("=")[1]!);
-      // thermal_zone0 often the CPU package; pick the highest non-zero temp
-      if (val > 0 && val < best) best = val;
-      // Actually we want the HIGHEST, not lowest
-    }
-    // Reread — pick highest
     let highest = -Infinity;
     for (const line of zones.split("\n")) {
       const val = parseInt(line.split("=")[1]!);
@@ -114,6 +89,10 @@ async function readTemperature(): Promise<number | null> {
   }
 }
 
+/* ------------------------------------------------------------------ */
+/*  Public API                                                         */
+/* ------------------------------------------------------------------ */
+
 export async function collectMetrics(): Promise<SystemMetrics> {
   // --- disk ---
   const dfOutput = await exec("df -P -B1 / /home 2>/dev/null");
@@ -141,9 +120,6 @@ export async function collectMetrics(): Promise<SystemMetrics> {
   await new Promise((r) => setTimeout(r, 500));
   const stat2 = await exec("cat /proc/stat | grep '^cpu '");
 
-  function cpuTicks(stat: string): number[] {
-    return stat.split(/\s+/).slice(1).map(Number);
-  }
   const t1 = cpuTicks(stat1);
   const t2 = cpuTicks(stat2);
   let usagePercent = 0;
@@ -161,7 +137,7 @@ export async function collectMetrics(): Promise<SystemMetrics> {
   const net1 = await readNetDev();
   await new Promise((r) => setTimeout(r, 1000));
   const net2 = await readNetDev();
-  const rxRate = Math.max(0, net2.rx - net1.rx); // bytes/sec
+  const rxRate = Math.max(0, net2.rx - net1.rx);
   const txRate = Math.max(0, net2.tx - net1.tx);
 
   // --- top processes ---
@@ -210,27 +186,3 @@ export async function collectMetrics(): Promise<SystemMetrics> {
     temperature,
   };
 }
-
-export function formatBytes(bytes: number): string {
-  if (bytes >= 1_073_741_824) return `${(bytes / 1_073_741_824).toFixed(1)} GiB`;
-  if (bytes >= 1_048_576) return `${(bytes / 1_048_576).toFixed(1)} MiB`;
-  if (bytes >= 1_024) return `${(bytes / 1_024).toFixed(1)} KiB`;
-  return `${bytes} B`;
-}
-
-export function formatRate(bytesPerSec: number): string {
-  if (bytesPerSec >= 1_048_576) return `${(bytesPerSec / 1_048_576).toFixed(2)} MB/s`;
-  if (bytesPerSec >= 1_024) return `${(bytesPerSec / 1_024).toFixed(1)} KB/s`;
-  return `${bytesPerSec} B/s`;
-}
-
-export function formatUptime(seconds: number): string {
-  const d = Math.floor(seconds / 86400);
-  const h = Math.floor((seconds % 86400) / 3600);
-  const m = Math.floor((seconds % 3600) / 60);
-  const parts: string[] = [];
-  if (d > 0) parts.push(`${d}d`);
-  if (h > 0) parts.push(`${h}h`);
-  parts.push(`${m}m`);
-  return parts.join(" ");
-}

package/src/{reporter.ts → reporter/index.ts}

@@ -1,11 +1,14 @@
-import { formatBytes, formatRate, formatUptime, type SystemMetrics } from "./monitor";
+import type { SystemMetrics } from "../types";
+import { collectMetrics, formatBytes, formatRate, formatUptime } from "../monitor";
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
 
-// HTML escape
 function esc(s: string): string {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
-// Bar chart with inline colored blocks
 function bar(percent: number, w = 10): string {
   const filled = Math.min(w, Math.max(0, Math.round((percent / 100) * w)));
   const empty = w - filled;
@@ -17,7 +20,6 @@ function pad(n: number, dp = 1): string {
   return n.toFixed(dp).padStart(5);
 }
 
-// Overall health
 function healthTag(m: SystemMetrics): string {
   const d = m.disks.length ? Math.max(...m.disks.map((x) => x.usagePercent)) : 0;
   if (m.cpu.usagePercent > 85 || m.memory.usagePercent > 95 || d > 95) return "🚨 CRITICAL";
@@ -25,7 +27,11 @@ function healthTag(m: SystemMetrics): string {
   return "✅ HEALTHY";
 }
 
-export function formatReportHTML(m: SystemMetrics): string {
+/* ------------------------------------------------------------------ */
+/*  Formatter                                                          */
+/* ------------------------------------------------------------------ */
+
+export function formatReportHTML(m: SystemMetrics, serverName?: string): string {
   const now = new Date().toLocaleString("id-ID", {
     timeZone: "Asia/Jakarta",
     day: "numeric",
@@ -36,21 +42,19 @@ export function formatReportHTML(m: SystemMetrics): string {
   });
 
   const tempStr = m.temperature !== null ? `  🌡 ${m.temperature.toFixed(0)}°C` : "";
+  const nameTag = serverName ? `  [${esc(serverName)}]` : "";
 
-  // ── Header ──
   const header = [
-    `<b>🖥  ${esc(m.hostname)}</b>  —  ${healthTag(m)}`,
+    `<b>🖥  ${esc(m.hostname)}</b>${nameTag}  —  ${healthTag(m)}`,
     `📅 ${esc(now)}  │  ⏱ ${esc(formatUptime(m.uptime))}${tempStr}`,
     `🐧 ${esc(m.platform)} ${esc(m.arch)}  │  ${esc(m.cpu.model)}  (${m.cpu.cores}c)`,
   ];
 
-  // ── CPU card ──
   const cpu = [
     `<b>💻 CPU</b>  <code>${pad(m.cpu.usagePercent)}%</code>  ${bar(m.cpu.usagePercent)}`,
     `   Load: <code>${m.cpu.loadAvg["1min"].toFixed(2)}</code> / <code>${m.cpu.loadAvg["5min"].toFixed(2)}</code> / <code>${m.cpu.loadAvg["15min"].toFixed(2)}</code>`,
   ];
 
-  // ── Memory card ──
   const mem = [
     `<b>🧠 RAM</b>   <code>${pad(m.memory.usagePercent)}%</code>  ${bar(m.memory.usagePercent)}`,
     `   <code>${esc(formatBytes(m.memory.used))}</code> / <code>${esc(formatBytes(m.memory.total))}</code>`,
@@ -59,7 +63,6 @@ export function formatReportHTML(m: SystemMetrics): string {
       : "",
   ].filter(Boolean);
 
-  // ── Disk card ──
   const disks = [`<b>💾 DISK</b>`];
   for (const d of m.disks) {
     disks.push(
@@ -70,13 +73,11 @@ export function formatReportHTML(m: SystemMetrics): string {
     );
   }
 
-  // ── Network card ──
   const net = [
     `<b>🌐 NET</b>`,
     `   ↓ <code>${esc(formatRate(m.network.rxRate))}</code>   ↑ <code>${esc(formatRate(m.network.txRate))}</code>`,
   ];
 
-  // ── Top processes ──
   const procLines: string[] = [];
   if (m.topProcs.length > 0) {
     procLines.push(`<b>📊 TOP PROCESSES</b>`);
@@ -87,7 +88,6 @@ export function formatReportHTML(m: SystemMetrics): string {
     }
   }
 
-  // ── Alerts ──
   const alerts: string[] = [];
   if (m.cpu.usagePercent > 85) alerts.push(`🔴 CPU tinggi: ${m.cpu.usagePercent.toFixed(1)}%`);
   if (m.memory.usagePercent > 90)
@@ -98,10 +98,7 @@ export function formatReportHTML(m: SystemMetrics): string {
     if (d.usagePercent > 90)
       alerts.push(`🔴 Disk <code>${esc(d.mount)}</code>: ${d.usagePercent}%`);
   }
-
-  if (alerts.length > 0) {
-    alerts.unshift(`<b>⚠️ ALERTS</b>`);
-  }
+  if (alerts.length > 0) alerts.unshift(`<b>⚠️ ALERTS</b>`);
 
   return [
     ...header,
@@ -122,6 +119,10 @@ export function formatReportHTML(m: SystemMetrics): string {
     .join("\n");
 }
 
+/* ------------------------------------------------------------------ */
+/*  Telegram sender                                                    */
+/* ------------------------------------------------------------------ */
+
 async function sendMessage(botToken: string, chatId: string, text: string): Promise<Response> {
   return fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
     method: "POST",
@@ -135,14 +136,18 @@ async function sendMessage(botToken: string, chatId: string, text: string): Prom
   });
 }
 
-export async function sendReport(botToken: string, chatId: string): Promise<boolean> {
+export async function sendReport(
+  botToken: string,
+  chatId: string,
+  serverName?: string
+): Promise<boolean> {
   if (!botToken || !chatId) {
     console.error("❌ TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID are required.");
     return false;
   }
 
-  const m = await import("./monitor").then((x) => x.collectMetrics());
-  const report = formatReportHTML(m);
+  const m = await collectMetrics();
+  const report = formatReportHTML(m, serverName);
 
   // Telegram 4096 char limit — split on double newlines
   if (report.length > 4000) {

package/src/types/index.ts

@@ -0,0 +1,75 @@
+/** CPU metrics */
+export interface CPUMetrics {
+  model: string;
+  cores: number;
+  loadAvg: { "1min": number; "5min": number; "15min": number };
+  usagePercent: number;
+}
+
+/** Memory & swap metrics */
+export interface MemoryMetrics {
+  total: number;
+  used: number;
+  free: number;
+  usagePercent: number;
+  swapTotal: number;
+  swapUsed: number;
+  swapUsagePercent: number;
+}
+
+/** Per-mount disk info */
+export interface DiskInfo {
+  mount: string;
+  total: number;
+  used: number;
+  available: number;
+  usagePercent: number;
+}
+
+/** Network throughput */
+export interface NetworkMetrics {
+  rxRate: number; // bytes/sec
+  txRate: number;
+  rxTotal: number;
+  txTotal: number;
+}
+
+/** Single process info */
+export interface ProcInfo {
+  pid: number;
+  name: string;
+  cpuPercent: number;
+  memPercent: number;
+}
+
+/** Full system snapshot returned by collectMetrics() */
+export interface SystemMetrics {
+  hostname: string;
+  platform: string;
+  arch: string;
+  uptime: number;
+  cpu: CPUMetrics;
+  memory: MemoryMetrics;
+  disks: DiskInfo[];
+  network: NetworkMetrics;
+  topProcs: ProcInfo[];
+  temperature: number | null; // celsius
+}
+
+/** A single server entry in the config */
+export interface ServerEntry {
+  token: string;
+  interval: number;
+  chatId?: string;
+}
+
+/** Top-level config persisted to disk — single file, multiple servers */
+export interface ServerMonConfig {
+  servers: Record<string, ServerEntry>;
+}
+
+/** A named config loaded at runtime — internal for multi-server loop */
+export interface NamedConfig {
+  name: string;
+  cfg: ServerEntry;
+}

package/src/config.ts

@@ -1,46 +0,0 @@
-import { homedir } from "os";
-import { join } from "path";
-import { mkdir } from "fs/promises";
-
-const CONFIG_DIR = join(homedir(), ".irsyadulibad", "servermon");
-const CONFIG_FILE = join(CONFIG_DIR, "config.json");
-
-export interface ServerMonConfig {
-  token: string;
-  interval: number;
-  chatId?: string;
-}
-
-export async function ensureConfigDir(): Promise<void> {
-  await mkdir(CONFIG_DIR, { recursive: true });
-}
-
-export async function loadConfig(): Promise<ServerMonConfig | null> {
-  try {
-    const file = Bun.file(CONFIG_FILE);
-    if (!(await file.exists())) return null;
-    const data = await file.json();
-    // Minimal validation
-    if (!data?.token) return null;
-    return {
-      token: String(data.token),
-      interval: Math.max(30, parseInt(String(data.interval)) || 300),
-      chatId: data.chatId ? String(data.chatId) : undefined,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export async function saveConfig(config: ServerMonConfig): Promise<void> {
-  await ensureConfigDir();
-  await Bun.write(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-
-export function configPath(): string {
-  return CONFIG_FILE;
-}
-
-export function configDir(): string {
-  return CONFIG_DIR;
-}