@irsyadulibad/servermon 1.1.0 → 1.2.0

package/src/cli/index.ts

@@ -0,0 +1,284 @@
+import { Crust } from "@crustjs/core";
+import { helpPlugin, versionPlugin, didYouMeanPlugin } from "@crustjs/plugins";
+import {
+  loadConfig,
+  saveConfig,
+  configPath,
+  configFile,
+  listServers,
+  deleteConfig,
+} from "../config";
+import { printBanner } from "./banner";
+import { serviceCmd } from "./service";
+import pkg from "../../package.json";
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+async function interactiveSetup(name?: string): Promise<void> {
+  const tag = name ? ` [${name}]` : "";
+  console.log(`🖥  Server Monitor — First Time Setup${tag}`);
+  console.log(`   Config will be saved to: ${configFile(name)}\n`);
+
+  const token = prompt("🔑 Telegram Bot Token: ")?.trim();
+  if (!token) {
+    console.error("❌ Bot token is required. Get one from @BotFather on Telegram.");
+    process.exit(1);
+  }
+
+  if (!token.includes(":")) {
+    console.error("❌ Invalid bot token format. Should look like: 123456:ABC-DEF1234gh...");
+    process.exit(1);
+  }
+
+  console.log("\n⏱  Choose report interval:");
+  console.log("   1. Every 5 minutes");
+  console.log("   2. Every 1 hour");
+  console.log("   3. Every 3 hours");
+  console.log("   4. Every 6 hours");
+  console.log("   5. Every 12 hours");
+  console.log("   6. Custom (in seconds)");
+
+  const choice = prompt("   Pick [1-6] (default: 1): ")?.trim() || "1";
+
+  const intervals: Record<string, number> = {
+    "1": 300,
+    "2": 3600,
+    "3": 10800,
+    "4": 21600,
+    "5": 43200,
+  };
+
+  let interval: number;
+  if (choice === "6") {
+    const custom = prompt("   Enter interval in seconds: ")?.trim();
+    interval = Math.max(30, parseInt(custom || "300") || 300);
+  } else {
+    interval = intervals[choice] ?? 300;
+  }
+
+  const label =
+    interval >= 3600
+      ? `${(interval / 3600).toFixed(0)} hour(s)`
+      : `${(interval / 60).toFixed(0)} min`;
+
+  await saveConfig({ token, interval, name });
+  console.log(`\n✅ Config saved!`);
+  console.log(`   📁 ${configFile(name)}`);
+  console.log(`   ⏱  Interval: ${interval}s (${label})`);
+  const serverTag = name ? ` --name ${name}` : "";
+  console.log(
+    `\n📡 Next step: DM your bot once on Telegram, then run \`servermon start${serverTag}\`.`
+  );
+}
+
+/* ------------------------------------------------------------------ */
+/*  App definition                                                     */
+/* ------------------------------------------------------------------ */
+
+export function createApp(): Crust {
+  const app = new Crust("servermon")
+    .use(helpPlugin())
+    .use(versionPlugin(pkg.version))
+    .use(didYouMeanPlugin())
+    .meta({
+      description:
+        "Lightweight server monitoring daemon — collect system metrics and send structured reports to Telegram",
+    })
+    .flags({
+      name: {
+        type: "string",
+        description: "Server name",
+        short: "n",
+        inherit: true,
+      },
+    })
+    /* ---- setup ---- */
+    .command("setup", (cmd) =>
+      cmd
+        .meta({ description: "First-time setup (bot token + interval)" })
+        .run(async ({ flags }) => {
+          await interactiveSetup(flags.name);
+        })
+    )
+    /* ---- start ---- */
+    .command("start", (cmd) =>
+      cmd
+        .meta({ description: "Start the monitoring daemon" })
+        .run(async ({ flags }) => {
+          const name = flags.name;
+
+          if (name) {
+            const config = await loadConfig(name);
+            if (!config) {
+              console.error(
+                `❌ No config found for server "${name}". Run \`servermon setup --name ${name}\` first.`
+              );
+              process.exit(1);
+            }
+            process.env["TELEGRAM_BOT_TOKEN"] = config.token;
+            process.env["MONITOR_INTERVAL"] = String(config.interval);
+            if (config.chatId) process.env["TELEGRAM_CHAT_ID"] = config.chatId;
+            if (config.name) process.env["SERVER_NAME"] = config.name;
+
+            console.log(`📁 Config: ${configPath(config.name)}`);
+            console.log(`📡 Bot:    ...${config.token.slice(-8)}`);
+            if (config.chatId) console.log(`💬 Chat:   ${config.chatId}`);
+            if (config.name) console.log(`🏷  Name:   ${config.name}`);
+            console.log();
+
+            const { start } = await import("../daemon");
+            await start();
+          } else {
+            console.log("  🌐 Multi-server mode — monitoring all configured servers\n");
+            const { startAll } = await import("../daemon");
+            await startAll();
+          }
+        })
+    )
+
+    /* ---- report ---- */
+    .command("report", (cmd) =>
+      cmd
+        .meta({ description: "Send a one-time report without starting the daemon" })
+        .run(async ({ flags }) => {
+          const name = flags.name;
+          const config = await loadConfig(name);
+          if (!config) {
+            console.error(
+              name
+                ? `❌ No config found for server "${name}". Run \`servermon setup --name ${name}\` first.`
+                : "❌ No config found. Run `servermon setup` first."
+            );
+            process.exit(1);
+          }
+          if (!config.chatId) {
+            console.error("❌ Chat ID not set. Run `servermon start` first to auto-detect.");
+            process.exit(1);
+          }
+
+          console.log(`📤 Sending one-time report${name ? ` for [${name}]` : ""}...`);
+          console.log(`📡 Bot: ...${config.token.slice(-8)}  💬 ${config.chatId}\n`);
+
+          const { sendReport } = await import("../reporter");
+          const ok = await sendReport(config.token, config.chatId, config.name);
+          console.log(ok ? "✅ Report sent!" : "❌ Failed to send report");
+        })
+    )
+
+    /* ---- list ---- */
+    .command("list", (cmd) =>
+      cmd.meta({ description: "List all configured servers" }).run(async () => {
+        const servers = await listServers();
+        if (servers.length === 0) {
+          console.log("📭 No configured servers.");
+          console.log("   Run `servermon setup` or `servermon setup --name <name>` first.");
+          return;
+        }
+        console.log("📋 Configured Servers:");
+        for (const s of servers) {
+          const cfg = await loadConfig(s === "default" ? undefined : s);
+          const nameTag = cfg?.name ? ` (--name ${cfg.name})` : "";
+          const interval = cfg?.interval ?? "?";
+          const chatLabel = cfg?.chatId ? `  💬 ${cfg.chatId}` : "  ❌ not yet paired";
+          console.log(`   • ${s}${nameTag}`);
+          console.log(`     ⏱ ${interval}s  ${chatLabel}`);
+        }
+      })
+    )
+
+    /* ---- delete ---- */
+    .command("delete", (cmd) =>
+      cmd
+        .meta({ description: "Delete a configured server" })
+        .args([{ name: "name", type: "string", description: "Server name" }] as const)
+        .flags({
+          yes: {
+            type: "boolean",
+            description: "Skip confirmation",
+            short: "y",
+          },
+        })
+        .run(async ({ args, flags }) => {
+          const rawName = args.name ?? flags.name;
+          if (!rawName) {
+            console.error("❌ Usage: servermon delete <name>");
+            console.log("   Use `servermon list` to see available servers.");
+            process.exit(1);
+          }
+
+          const name = rawName === "default" ? undefined : rawName;
+          const cfg = await loadConfig(name);
+          if (!cfg) {
+            console.error(`❌ No server found with name "${rawName}".`);
+            process.exit(1);
+          }
+
+          console.log(`⚠️  You are about to delete server config: "${rawName}"`);
+          console.log(`   📁 ${configFile(name)}`);
+          console.log(`   🤖 Bot: ...${cfg.token.slice(-8)}`);
+          if (cfg.chatId) console.log(`   💬 Chat: ${cfg.chatId}`);
+          console.log("\n   This action cannot be undone.\n");
+
+          if (!flags.yes) {
+            const answer = prompt("   Type 'yes' to confirm: ")?.trim().toLowerCase();
+            if (answer !== "yes") {
+              console.log("❌ Cancelled.");
+              return;
+            }
+          }
+
+          const ok = await deleteConfig(name);
+          if (ok) {
+            console.log(`✅ Server "${rawName}" deleted.`);
+          } else {
+            console.error(`❌ Failed to delete server "${rawName}".`);
+            process.exit(1);
+          }
+        })
+    )
+
+    /* ---- service ---- */
+    .command("service", (cmd) => serviceCmd(cmd))
+
+    /* ---- deprecated aliases (hidden) ---- */
+    .command("install-service", (cmd) =>
+      cmd.meta({ hidden: true }).run(async () => {
+        console.log("ℹ️  This command is deprecated. Use: `servermon service install`");
+        const { serviceRouter } = await import("./service");
+        await serviceRouter(["install"]);
+      })
+    )
+    .command("--install-service", (cmd) =>
+      cmd.meta({ hidden: true }).run(async () => {
+        console.log("ℹ️  This command is deprecated. Use: `servermon service install`");
+        const { serviceRouter } = await import("./service");
+        await serviceRouter(["install"]);
+      })
+    )
+    .command("--setup-systemd", (cmd) =>
+      cmd.meta({ hidden: true }).run(async () => {
+        console.log("ℹ️  This command is deprecated. Use: `servermon service install`");
+        const { serviceRouter } = await import("./service");
+        await serviceRouter(["install"]);
+      })
+    );
+
+  return app;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Main entry point                                                   */
+/* ------------------------------------------------------------------ */
+
+export async function main(): Promise<void> {
+  printBanner();
+  const app = createApp();
+  // No args → show help
+  if (process.argv.length <= 2) {
+    await app.execute({ argv: ["--help"] });
+  } else {
+    await app.execute();
+  }
+}

package/src/cli/service.ts

@@ -0,0 +1,306 @@
+import type { Crust } from "@crustjs/core";
+import { loadConfig, configPath } from "../config";
+
+const HOME = process.env.HOME ?? "~";
+const SYSTEMD_DIR = `${HOME}/.config/systemd/user`;
+const SERVICE_NAME = "servermon.service";
+const SERVICE_PATH = `${SYSTEMD_DIR}/${SERVICE_NAME}`;
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+function sysctl(...args: string[]): { ok: boolean; out: string; err: string } {
+  const proc = Bun.spawnSync({
+    cmd: ["systemctl", "--user", ...args],
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return {
+    ok: proc.exitCode === 0,
+    out: new TextDecoder().decode(proc.stdout).trim(),
+    err: new TextDecoder().decode(proc.stderr).trim(),
+  };
+}
+
+async function ensureSystemdDir(): Promise<void> {
+  await Bun.write(`${SYSTEMD_DIR}/.gitkeep`, "");
+  try {
+    await (
+      Bun as unknown as { mkdir?: (p: string, o: { recursive: boolean }) => Promise<void> }
+    ).mkdir?.(SYSTEMD_DIR, { recursive: true });
+  } catch {
+    /* Bun.mkdir fallback */
+  }
+  try {
+    await import("node:fs").then((m) => m.mkdirSync(SYSTEMD_DIR, { recursive: true }));
+  } catch {
+    /* fs fallback */
+  }
+}
+
+function isInstalled(): boolean {
+  const { out } = sysctl("is-enabled", SERVICE_NAME);
+  return out !== "disabled" && out !== "";
+}
+
+function getServiceStatus(): string {
+  const { out } = sysctl("status", SERVICE_NAME, "--no-pager", "-l");
+  return out;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Subcommand handlers                                                */
+/* ------------------------------------------------------------------ */
+
+async function cmdInstall(): Promise<void> {
+  const config = await loadConfig();
+  if (!config) {
+    console.error("❌ No config found. Run `servermon setup` first.");
+    process.exit(1);
+  }
+
+  const bunPath = Bun.which("bun");
+  if (!bunPath) {
+    console.error("❌ bun not found in PATH");
+    process.exit(1);
+  }
+
+  const servermonPath = Bun.which("servermon");
+  if (!servermonPath) {
+    console.error("❌ servermon binary not found. Install with: bun i -g @irsyadulibad/servermon");
+    process.exit(1);
+  }
+
+  console.log(`🔍 bun:       ${bunPath}`);
+  console.log(`🔍 servermon: ${servermonPath}`);
+  console.log(`📁 Config:    ${configPath()}\n`);
+
+  await ensureSystemdDir();
+
+  const serviceContent = `[Unit]
+Description=Server Monitor — Telegram system health reports
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${servermonPath} start
+Restart=always
+RestartSec=30
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=default.target
+`;
+
+  await Bun.write(SERVICE_PATH, serviceContent);
+  console.log(`📄 Written: ${SERVICE_PATH}`);
+
+  const steps = [
+    ["daemon-reload"],
+    ["enable", SERVICE_NAME],
+    ["start", SERVICE_NAME],
+    ["status", SERVICE_NAME, "--no-pager", "-l"],
+  ];
+
+  for (const args of steps) {
+    const cmd = `systemctl --user ${args.join(" ")}`;
+    console.log(`\n🏃 ${cmd}`);
+    const { out, err, ok } = sysctl(...args);
+    if (out) console.log(out);
+    if (err && !ok) console.error(err);
+  }
+
+  console.log("\n✅ Systemd service installed and running!\n");
+  console.log("📌 Useful commands:");
+  console.log("   servermon service status    # check health");
+  console.log("   servermon service logs      # watch logs");
+  console.log("   servermon service stop      # stop daemon");
+  console.log("   servermon service restart   # restart daemon");
+  console.log("   servermon service uninstall # remove service\n");
+  console.log("📌 For auto-start at boot:");
+  console.log("   loginctl enable-linger");
+}
+
+function cmdStatus(): void {
+  if (!isInstalled()) {
+    console.log("📭 Systemd service is not installed.");
+    console.log("   Run `servermon service install` first.");
+    return;
+  }
+
+  const status = getServiceStatus();
+  console.log(status);
+
+  const { out: activeState } = sysctl("is-active", SERVICE_NAME);
+  const { out: enabledState } = sysctl("is-enabled", SERVICE_NAME);
+
+  const activeIcon = activeState === "active" ? "✅" : "❌";
+  const enabledIcon = enabledState === "enabled" ? "✅" : "❌";
+
+  console.log(`\n${activeIcon} Active:   ${activeState}`);
+  console.log(`${enabledIcon} Enabled:  ${enabledState}`);
+}
+
+function cmdStop(): void {
+  console.log("🛑 Stopping servermon service...");
+  const { ok, out, err } = sysctl("stop", SERVICE_NAME);
+  if (out) console.log(out);
+  if (err) console.error(err);
+  console.log(ok ? "✅ Service stopped." : "⚠️  Could not stop service.");
+}
+
+function cmdRestart(): void {
+  console.log("🔄 Restarting servermon service...");
+  const { ok, out, err } = sysctl("restart", SERVICE_NAME);
+  if (out) console.log(out);
+  if (err) console.error(err);
+  console.log(ok ? "✅ Service restarted." : "⚠️  Could not restart service.");
+}
+
+function cmdLogs(): void {
+  if (!isInstalled()) {
+    console.log("📭 Service not installed.");
+    return;
+  }
+
+  const args = ["--user", "-u", SERVICE_NAME, "-f", "-n", "50"];
+  const proc = Bun.spawn(["journalctl", ...args], { stdio: ["inherit", "inherit", "inherit"] });
+  proc.exited.then((code) => {
+    if (code !== 0 && code !== null) process.exit(code);
+  });
+}
+
+async function cmdUninstall(): Promise<void> {
+  console.log("🗑  Uninstalling servermon service...");
+
+  const steps = [
+    { args: ["stop", SERVICE_NAME], label: "Stopping" },
+    { args: ["disable", SERVICE_NAME], label: "Disabling" },
+  ];
+
+  for (const { args, label } of steps) {
+    const { ok, err } = sysctl(...args);
+    if (err) console.error(`⚠️  ${label}: ${err}`);
+    if (ok) console.log(`✅ ${label}`);
+  }
+
+  try {
+    await import("fs/promises").then((m) => m.unlink(SERVICE_PATH));
+    console.log("✅ Service file removed");
+  } catch {
+    console.log("⚠️  Service file not found or already removed");
+  }
+
+  sysctl("daemon-reload");
+  console.log("✅ Daemon reloaded");
+  console.log("\n✅ Service uninstalled.");
+}
+
+/* ------------------------------------------------------------------ */
+/*  CrustJS service command (exported for use in index.ts)             */
+/* ------------------------------------------------------------------ */
+
+export const serviceCmd: Parameters<Crust["command"]>[1] = (cmd) =>
+  cmd
+    .meta({ description: "Manage systemd service" })
+    .command("install", (sub) =>
+      sub
+        .meta({ description: "Install systemd service & start" })
+        .run(async () => {
+          await cmdInstall();
+        })
+    )
+    .command("status", (sub) =>
+      sub
+        .meta({ description: "Check service health" })
+        .run(() => {
+          cmdStatus();
+        })
+    )
+    .command("stop", (sub) =>
+      sub
+        .meta({ description: "Stop the service" })
+        .run(() => {
+          cmdStop();
+        })
+    )
+    .command("restart", (sub) =>
+      sub
+        .meta({ description: "Restart the service" })
+        .run(() => {
+          cmdRestart();
+        })
+    )
+    .command("logs", (sub) =>
+      sub
+        .meta({ description: "Follow real-time logs" })
+        .run(() => {
+          cmdLogs();
+        })
+    )
+    .command("uninstall", (sub) =>
+      sub
+        .meta({ description: "Stop, disable, & remove service" })
+        .flags({
+          yes: {
+            type: "boolean",
+            description: "Skip confirmation",
+            short: "y",
+          },
+        })
+        .run(async ({ flags }) => {
+          if (!flags.yes) {
+            console.log("⚠️  This will stop and remove the servermon service.");
+            console.log("   To confirm, run: `servermon service uninstall --yes`");
+            return;
+          }
+          await cmdUninstall();
+        })
+    );
+
+/* ------------------------------------------------------------------ */
+/*  Legacy router (kept for backward compat)                           */
+/* ------------------------------------------------------------------ */
+
+export async function serviceRouter(subs?: string[]): Promise<void> {
+  const sub = subs?.[0] ?? process.argv[3];
+
+  switch (sub) {
+    case "install":
+      await cmdInstall();
+      break;
+    case "status":
+      cmdStatus();
+      break;
+    case "stop":
+      cmdStop();
+      break;
+    case "restart":
+      cmdRestart();
+      break;
+    case "logs":
+      cmdLogs();
+      break;
+    case "uninstall":
+      await cmdUninstall();
+      break;
+    default:
+      console.log("Usage:  servermon service <subcommand>");
+      console.log();
+      console.log("Subcommands:");
+      console.log("  install             Install systemd service & start");
+      console.log("  status              Check service health");
+      console.log("  stop                Stop the service");
+      console.log("  restart             Restart the service");
+      console.log("  logs                Follow real-time logs");
+      console.log("  uninstall [--yes]   Stop, disable, & remove service");
+      console.log();
+      console.log("Examples:");
+      console.log("  servermon service install");
+      console.log("  servermon service status");
+      console.log("  servermon service logs");
+      console.log("  servermon service uninstall --yes");
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,84 @@
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, readdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import type { ServerMonConfig } from "../types";
+
+const CONFIG_DIR = join(homedir(), ".irsyadulibad", "servermon");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+export function configFile(name?: string): string {
+  return name ? join(CONFIG_DIR, `config-${name}.json`) : CONFIG_FILE;
+}
+
+export function configPath(name?: string): string {
+  return configFile(name);
+}
+
+export function configDir(): string {
+  return CONFIG_DIR;
+}
+
+/* ------------------------------------------------------------------ */
+/*  CRUD                                                               */
+/* ------------------------------------------------------------------ */
+
+export async function ensureConfigDir(): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true });
+}
+
+export async function loadConfig(name?: string): Promise<ServerMonConfig | null> {
+  try {
+    const file = Bun.file(configFile(name));
+    if (!(await file.exists())) return null;
+    const data = await file.json();
+    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,
+      name: data.name ? String(data.name) : name,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function saveConfig(config: ServerMonConfig): Promise<void> {
+  await ensureConfigDir();
+  await Bun.write(configFile(config.name), JSON.stringify(config, null, 2));
+}
+
+export async function deleteConfig(name?: string): Promise<boolean> {
+  const file = configFile(name);
+  if (!existsSync(file)) return false;
+  try {
+    await unlink(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Inventory                                                          */
+/* ------------------------------------------------------------------ */
+
+export async function listServers(): Promise<string[]> {
+  const names: string[] = [];
+  try {
+    const entries = await readdir(CONFIG_DIR);
+    for (const entry of entries) {
+      const match = entry.match(/^config-(.+)\.json$/);
+      if (match) names.push(match[1]!);
+    }
+  } catch {
+    // dir may not exist yet
+  }
+  if (existsSync(CONFIG_FILE)) names.unshift("default");
+  return names;
+}