@tradejs/cli 1.0.9 → 1.0.10

package/dist/scripts/serverHealth.js

@@ -0,0 +1,588 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/serverHealth.ts
+var serverHealth_exports = {};
+__export(serverHealth_exports, {
+  buildAlertMessage: () => buildAlertMessage,
+  buildRecoveryMessage: () => buildRecoveryMessage,
+  buildServerHealthDiagnostics: () => buildServerHealthDiagnostics,
+  collectServerHealthSnapshot: () => collectServerHealthSnapshot,
+  evaluateServerHealth: () => evaluateServerHealth,
+  main: () => main,
+  resolveServerHealthThresholds: () => resolveServerHealthThresholds
+});
+module.exports = __toCommonJS(serverHealth_exports);
+var import_config = require("dotenv/config");
+var import_node_child_process = require("child_process");
+var import_node_os = __toESM(require("os"));
+var import_node_fs = require("fs");
+var import_args = __toESM(require("args"));
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/telegramReports.ts
+var import_cli = require("@tradejs/node/cli");
+var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
+var buildPartHeader = (index, total) => `\u{1F4E9} <b>Part ${index}/${total}</b>`;
+var splitLongLine = (line, limit) => {
+  const chunks = [];
+  for (let index = 0; index < line.length; index += limit) {
+    chunks.push(line.slice(index, index + limit));
+  }
+  return chunks;
+};
+var splitTelegramReport = (message, limit = TELEGRAM_REPORT_CHUNK_LIMIT) => {
+  const normalizedLimit = Math.max(100, Math.floor(limit));
+  if (message.length <= normalizedLimit) {
+    return [message];
+  }
+  const chunks = [];
+  let current = "";
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    chunks.push(current);
+    current = "";
+  };
+  for (const line of message.split("\n")) {
+    const next = current ? `${current}
+${line}` : line;
+    if (next.length <= normalizedLimit) {
+      current = next;
+      continue;
+    }
+    flush();
+    if (line.length <= normalizedLimit) {
+      current = line;
+      continue;
+    }
+    chunks.push(...splitLongLine(line, normalizedLimit));
+  }
+  flush();
+  return chunks;
+};
+var sendTelegramReport = async (message, options = {}) => {
+  const chunks = splitTelegramReport(message);
+  const sendAttachments = async () => {
+    for (const attachment of options.attachments || []) {
+      await (0, import_cli.sendDocumentToTG)(attachment, {
+        userName: options.userName
+      });
+    }
+  };
+  if (chunks.length === 1) {
+    await (0, import_cli.sendTextToTG)(chunks[0], options);
+    await sendAttachments();
+    return chunks.length;
+  }
+  for (const [index, chunk] of chunks.entries()) {
+    const header = buildPartHeader(index + 1, chunks.length);
+    await (0, import_cli.sendTextToTG)(`${header}
+
+${chunk}`, {
+      userName: options.userName,
+      markup: index === chunks.length - 1 ? options.markup : void 0
+    });
+  }
+  await sendAttachments();
+  return chunks.length;
+};
+
+// src/scripts/serverHealth.ts
+var DEFAULT_STATE = {
+  status: "healthy",
+  lastAlertAt: null,
+  lastOkAt: null,
+  activeIssueCodes: []
+};
+var DEFAULT_THRESHOLDS = {
+  loadPerCpuWarn: 0.9,
+  loadPerCpuRecover: 0.7,
+  memoryWarnPct: 92,
+  memoryRecoverPct: 88,
+  diskWarnPct: 95,
+  diskRecoverPct: 92
+};
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var formatPctValue = (value) => `${value.toFixed(1)}%`;
+var formatLoadPerCore = (value) => value.toFixed(2);
+var formatGiB = (bytes) => `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+var formatDuration = (uptimeSec) => {
+  const total = Math.max(0, Math.floor(uptimeSec));
+  const days = Math.floor(total / 86400);
+  const hours = Math.floor(total % 86400 / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  if (days > 0) {
+    return `${days}d ${hours}h ${minutes}m`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  return `${minutes}m`;
+};
+var readDiskUsage = (path) => {
+  try {
+    const stats = (0, import_node_fs.statfsSync)(path);
+    const totalBlocks = Number(stats.blocks ?? 0);
+    const availableBlocks = Number(stats.bavail ?? 0);
+    if (totalBlocks <= 0) {
+      return { path, usedPct: null };
+    }
+    const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
+    return {
+      path,
+      usedPct: Number.isFinite(usedPct) ? usedPct : null
+    };
+  } catch {
+    return { path, usedPct: null };
+  }
+};
+var parseMeminfoBytes = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const [amountRaw, unitRaw = "kB"] = trimmed.split(/\s+/, 2);
+  const amount = Number(amountRaw);
+  if (!Number.isFinite(amount)) {
+    return null;
+  }
+  const unit = unitRaw.toLowerCase();
+  if (unit === "kb") {
+    return Math.round(amount * 1024);
+  }
+  if (unit === "mb") {
+    return Math.round(amount * 1024 ** 2);
+  }
+  if (unit === "gb") {
+    return Math.round(amount * 1024 ** 3);
+  }
+  return Math.round(amount);
+};
+var readMemorySnapshot = () => {
+  const totalMem = import_node_os.default.totalmem();
+  const freeMem = import_node_os.default.freemem();
+  try {
+    const meminfo = (0, import_node_fs.readFileSync)("/proc/meminfo", "utf8");
+    const values = /* @__PURE__ */ new Map();
+    for (const line of meminfo.split("\n")) {
+      const match = line.match(/^([^:]+):\s*(.+)$/);
+      if (!match) {
+        continue;
+      }
+      const parsed = parseMeminfoBytes(match[2]);
+      if (parsed != null) {
+        values.set(match[1], parsed);
+      }
+    }
+    return {
+      totalBytes: values.get("MemTotal") ?? totalMem,
+      availableBytes: values.get("MemAvailable") ?? freeMem,
+      freeBytes: values.get("MemFree") ?? freeMem,
+      buffersBytes: values.get("Buffers") ?? null,
+      cachedBytes: values.get("Cached") ?? null,
+      shmemBytes: values.get("Shmem") ?? null,
+      slabBytes: values.get("Slab") ?? null,
+      reclaimableBytes: values.get("SReclaimable") ?? null
+    };
+  } catch {
+    return {
+      totalBytes: totalMem,
+      availableBytes: freeMem,
+      freeBytes: freeMem,
+      buffersBytes: null,
+      cachedBytes: null,
+      shmemBytes: null,
+      slabBytes: null,
+      reclaimableBytes: null
+    };
+  }
+};
+var runDiagnosticCommand = (command, args2) => {
+  const output = (0, import_node_child_process.execFileSync)(command, args2, {
+    encoding: "utf8",
+    timeout: 5e3,
+    maxBuffer: 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+  return output || "no output";
+};
+var runDiagnosticCommands = (commands, fallbackLabel) => {
+  const errors = [];
+  for (const candidate of commands) {
+    try {
+      return runDiagnosticCommand(candidate.command, candidate.args);
+    } catch (error) {
+      errors.push(
+        `${candidate.command} ${candidate.args.join(" ")} -> ${String(error)}`
+      );
+    }
+  }
+  return `${fallbackLabel}: ${errors.join("\n")}`;
+};
+var collectServerHealthSnapshot = (diskPath) => {
+  const [load1, load5, load15] = import_node_os.default.loadavg();
+  const cpuCount = Math.max(1, import_node_os.default.cpus().length);
+  const memory = readMemorySnapshot();
+  const usedMemPct = memory.totalBytes > 0 ? (memory.totalBytes - memory.availableBytes) / memory.totalBytes * 100 : 0;
+  return {
+    hostname: import_node_os.default.hostname(),
+    timestamp: Date.now(),
+    cpuCount,
+    load1,
+    load5,
+    load15,
+    loadPerCpu1: load1 / cpuCount,
+    loadPerCpu5: load5 / cpuCount,
+    memoryUsedPct: usedMemPct,
+    memory,
+    uptimeSec: import_node_os.default.uptime(),
+    disk: readDiskUsage(diskPath)
+  };
+};
+var buildHumanSummaryLines = (snapshot) => {
+  const usedMem = Math.max(
+    0,
+    snapshot.memory.totalBytes - snapshot.memory.availableBytes
+  );
+  return [
+    `\u2022 vCPU: <b>${escapeHtml(formatPctValue(Math.min(100, snapshot.loadPerCpu1 * 100)))}</b>`,
+    `\u2022 RAM: <b>${escapeHtml(formatPctValue(snapshot.memoryUsedPct))}</b> (${escapeHtml(
+      `${formatGiB(usedMem)} / ${formatGiB(snapshot.memory.totalBytes)}`
+    )})`,
+    `\u2022 Storage: <b>${escapeHtml(
+      snapshot.disk.usedPct == null ? "n/a" : formatPctValue(snapshot.disk.usedPct)
+    )}</b>`
+  ];
+};
+var evaluateServerHealth = (snapshot, thresholds) => {
+  const issues = [];
+  if (snapshot.loadPerCpu1 >= thresholds.loadPerCpuWarn) {
+    issues.push({
+      code: "load",
+      summary: `CPU load high: 1m/core=${formatLoadPerCore(
+        snapshot.loadPerCpu1
+      )} (${snapshot.load1.toFixed(2)} on ${snapshot.cpuCount} cores), 5m/core=${formatLoadPerCore(snapshot.loadPerCpu5)}`
+    });
+  }
+  if (snapshot.memoryUsedPct >= thresholds.memoryWarnPct) {
+    issues.push({
+      code: "memory",
+      summary: `Memory high: used=${formatPctValue(snapshot.memoryUsedPct)}`
+    });
+  }
+  if (snapshot.disk.usedPct != null && snapshot.disk.usedPct >= thresholds.diskWarnPct) {
+    issues.push({
+      code: "disk",
+      summary: `Disk high: ${snapshot.disk.path} used=${formatPctValue(snapshot.disk.usedPct)}`
+    });
+  }
+  return {
+    snapshot,
+    issues,
+    isHealthy: issues.length === 0
+  };
+};
+var shouldRecover = (snapshot, thresholds) => snapshot.loadPerCpu1 < thresholds.loadPerCpuRecover && snapshot.memoryUsedPct < thresholds.memoryRecoverPct && (snapshot.disk.usedPct == null || snapshot.disk.usedPct < thresholds.diskRecoverPct);
+var buildAlertMessage = ({
+  evaluation,
+  prevState,
+  reminder
+}) => {
+  const { snapshot, issues } = evaluation;
+  const title = reminder ? "\u{1F6A8} <b>TradeJS server still unhealthy</b>" : "\u{1F6A8} <b>TradeJS server health alert</b>";
+  return [
+    title,
+    "",
+    `Host: <b>${escapeHtml(snapshot.hostname)}</b>`,
+    `Time: <b>${escapeHtml(new Date(snapshot.timestamp).toISOString())}</b>`,
+    `Uptime: <b>${escapeHtml(formatDuration(snapshot.uptimeSec))}</b>`,
+    "",
+    "Summary:",
+    ...buildHumanSummaryLines(snapshot),
+    "",
+    "Issues:",
+    ...issues.map((issue) => `\u2022 ${escapeHtml(issue.summary)}`),
+    "",
+    "Pressure:",
+    `\u2022 Load avg: <b>${snapshot.load1.toFixed(2)} / ${snapshot.load5.toFixed(2)} / ${snapshot.load15.toFixed(2)}</b>`,
+    `\u2022 Load per core: <b>${formatLoadPerCore(
+      snapshot.loadPerCpu1
+    )}</b> (1m), <b>${formatLoadPerCore(snapshot.loadPerCpu5)}</b> (5m)`,
+    prevState.lastAlertAt ? `\u2022 Previous alert: <b>${escapeHtml(new Date(prevState.lastAlertAt).toISOString())}</b>` : "\u2022 Previous alert: <b>none</b>"
+  ].join("\n");
+};
+var buildRecoveryMessage = ({
+  snapshot,
+  prevState
+}) => [
+  "\u2705 <b>TradeJS server health recovered</b>",
+  "",
+  `Host: <b>${escapeHtml(snapshot.hostname)}</b>`,
+  `Time: <b>${escapeHtml(new Date(snapshot.timestamp).toISOString())}</b>`,
+  `Uptime: <b>${escapeHtml(formatDuration(snapshot.uptimeSec))}</b>`,
+  "",
+  "Summary:",
+  ...buildHumanSummaryLines(snapshot),
+  "",
+  "Pressure:",
+  `\u2022 Load avg: <b>${snapshot.load1.toFixed(2)} / ${snapshot.load5.toFixed(2)} / ${snapshot.load15.toFixed(2)}</b>`,
+  `\u2022 Load per core: <b>${formatLoadPerCore(
+    snapshot.loadPerCpu1
+  )}</b> (1m), <b>${formatLoadPerCore(snapshot.loadPerCpu5)}</b> (5m)`,
+  prevState.lastAlertAt ? `\u2022 Alert started: <b>${escapeHtml(new Date(prevState.lastAlertAt).toISOString())}</b>` : "\u2022 Alert started: <b>unknown</b>"
+].join("\n");
+var buildServerHealthDiagnostics = ({
+  snapshot,
+  diskPath
+}) => {
+  const topCpu = runDiagnosticCommands(
+    [
+      {
+        command: "ps",
+        args: [
+          "axo",
+          "pid,ppid,%cpu,%mem,etime,state,comm,args",
+          "--sort=-%cpu"
+        ]
+      },
+      {
+        command: "sh",
+        args: [
+          "-lc",
+          "ps -o pid,ppid,%cpu,%mem,etime,state,comm,args | sort -k3 -nr | head -20"
+        ]
+      }
+    ],
+    "ps cpu failed"
+  );
+  const topMemory = runDiagnosticCommands(
+    [
+      {
+        command: "ps",
+        args: [
+          "axo",
+          "pid,ppid,%mem,%cpu,etime,state,comm,args",
+          "--sort=-%mem"
+        ]
+      },
+      {
+        command: "sh",
+        args: [
+          "-lc",
+          "ps -o pid,ppid,%mem,%cpu,etime,state,comm,args | sort -k3 -nr | head -20"
+        ]
+      }
+    ],
+    "ps memory failed"
+  );
+  const freeMemory = runDiagnosticCommands(
+    [{ command: "free", args: ["-m"] }],
+    "free failed"
+  );
+  const diskUsage = runDiagnosticCommands(
+    [{ command: "df", args: ["-h", diskPath] }],
+    "df failed"
+  );
+  const uptimeText = runDiagnosticCommands(
+    [{ command: "uptime", args: [] }],
+    "uptime failed"
+  );
+  const memoryDetails = [
+    `total: ${formatGiB(snapshot.memory.totalBytes)}`,
+    `available: ${formatGiB(snapshot.memory.availableBytes)}`,
+    `free: ${formatGiB(snapshot.memory.freeBytes)}`,
+    snapshot.memory.buffersBytes == null ? null : `buffers: ${formatGiB(snapshot.memory.buffersBytes)}`,
+    snapshot.memory.cachedBytes == null ? null : `cached: ${formatGiB(snapshot.memory.cachedBytes)}`,
+    snapshot.memory.shmemBytes == null ? null : `shmem: ${formatGiB(snapshot.memory.shmemBytes)}`,
+    snapshot.memory.reclaimableBytes == null ? null : `sreclaimable: ${formatGiB(snapshot.memory.reclaimableBytes)}`,
+    snapshot.memory.slabBytes == null ? null : `slab: ${formatGiB(snapshot.memory.slabBytes)}`
+  ].filter(Boolean).join("\n");
+  return [
+    `TradeJS server health diagnostics`,
+    `host: ${snapshot.hostname}`,
+    `time: ${new Date(snapshot.timestamp).toISOString()}`,
+    `uptime: ${formatDuration(snapshot.uptimeSec)}`,
+    `load: ${snapshot.load1.toFixed(2)} / ${snapshot.load5.toFixed(2)} / ${snapshot.load15.toFixed(2)}`,
+    `load_per_core: ${formatLoadPerCore(snapshot.loadPerCpu1)} (1m), ${formatLoadPerCore(snapshot.loadPerCpu5)} (5m)`,
+    `memory_used: ${formatPctValue(snapshot.memoryUsedPct)}`,
+    `disk_used: ${snapshot.disk.usedPct == null ? `${snapshot.disk.path} n/a` : `${snapshot.disk.path} ${formatPctValue(snapshot.disk.usedPct)}`}`,
+    "",
+    "=== uptime ===",
+    uptimeText,
+    "",
+    "=== free -m ===",
+    freeMemory,
+    "",
+    "=== memory breakdown ===",
+    memoryDetails,
+    "",
+    `=== df -h ${diskPath} ===`,
+    diskUsage,
+    "",
+    "=== top processes by cpu ===",
+    topCpu,
+    "",
+    "=== top processes by memory ===",
+    topMemory,
+    ""
+  ].join("\n");
+};
+var getStateKey = (userName, hostname) => `ops:server-health:${userName}:${hostname}`;
+var toFiniteNumber = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var resolveServerHealthThresholds = (raw) => {
+  const loadPerCpuWarn = toFiniteNumber(raw.loadPerCpuWarn);
+  const loadPerCpuRecover = toFiniteNumber(raw.loadPerCpuRecover);
+  const memoryWarnPct = toFiniteNumber(raw.memoryWarnPct);
+  const memoryRecoverPct = toFiniteNumber(raw.memoryRecoverPct);
+  const diskWarnPct = toFiniteNumber(raw.diskWarnPct);
+  const diskRecoverPct = toFiniteNumber(raw.diskRecoverPct);
+  return {
+    loadPerCpuWarn: loadPerCpuWarn != null && loadPerCpuWarn > 0 ? loadPerCpuWarn : DEFAULT_THRESHOLDS.loadPerCpuWarn,
+    loadPerCpuRecover: loadPerCpuRecover != null && loadPerCpuRecover > 0 ? loadPerCpuRecover : DEFAULT_THRESHOLDS.loadPerCpuRecover,
+    memoryWarnPct: memoryWarnPct != null && memoryWarnPct > 0 ? memoryWarnPct : DEFAULT_THRESHOLDS.memoryWarnPct,
+    memoryRecoverPct: memoryRecoverPct != null && memoryRecoverPct > 0 ? memoryRecoverPct : DEFAULT_THRESHOLDS.memoryRecoverPct,
+    diskWarnPct: diskWarnPct != null && diskWarnPct > 0 ? diskWarnPct : DEFAULT_THRESHOLDS.diskWarnPct,
+    diskRecoverPct: diskRecoverPct != null && diskRecoverPct > 0 ? diskRecoverPct : DEFAULT_THRESHOLDS.diskRecoverPct
+  };
+};
+import_args.default.option(["u", "user"], "Use user config", "root");
+import_args.default.option(["P", "printOnly"], "Print report instead of Telegram", false);
+import_args.default.option(
+  ["d", "diskPath"],
+  "Filesystem path to inspect for disk pressure",
+  "/"
+);
+import_args.default.option(
+  ["c", "cooldownSec"],
+  "Minimum seconds between repeated unhealthy reminders",
+  900
+);
+import_args.default.option(
+  ["l", "loadPerCpuWarn"],
+  "Alert when 1m load per CPU reaches this value",
+  String(DEFAULT_THRESHOLDS.loadPerCpuWarn)
+);
+import_args.default.option(
+  ["L", "loadPerCpuRecover"],
+  "Recovery threshold for 1m load per CPU",
+  String(DEFAULT_THRESHOLDS.loadPerCpuRecover)
+);
+import_args.default.option(
+  ["m", "memoryWarnPct"],
+  "Alert when memory used percent reaches this value",
+  String(DEFAULT_THRESHOLDS.memoryWarnPct)
+);
+import_args.default.option(
+  ["M", "memoryRecoverPct"],
+  "Recovery threshold for memory used percent",
+  String(DEFAULT_THRESHOLDS.memoryRecoverPct)
+);
+import_args.default.option(
+  ["D", "diskWarnPct"],
+  "Alert when disk used percent reaches this value",
+  String(DEFAULT_THRESHOLDS.diskWarnPct)
+);
+import_args.default.option(
+  ["R", "diskRecoverPct"],
+  "Recovery threshold for disk used percent",
+  String(DEFAULT_THRESHOLDS.diskRecoverPct)
+);
+var main = async () => {
+  const flags = import_args.default.parse(process.argv);
+  const thresholds = resolveServerHealthThresholds(flags);
+  const diskPath = String(flags.diskPath || "/");
+  const snapshot = collectServerHealthSnapshot(diskPath);
+  const stateKey = getStateKey(String(flags.user), snapshot.hostname);
+  const prevState = await (0, import_redis.getData)(stateKey, DEFAULT_STATE) ?? DEFAULT_STATE;
+  const evaluation = evaluateServerHealth(snapshot, thresholds);
+  const cooldownMs = Math.max(60, Number(flags.cooldownSec)) * 1e3;
+  const now = snapshot.timestamp;
+  if (!evaluation.isHealthy) {
+    const reminder = prevState.status === "alerting" && typeof prevState.lastAlertAt === "number" && now - prevState.lastAlertAt < cooldownMs ? false : prevState.status === "alerting";
+    const shouldSend = prevState.status !== "alerting" || !prevState.lastAlertAt || now - prevState.lastAlertAt >= cooldownMs;
+    const nextState2 = {
+      status: "alerting",
+      lastAlertAt: shouldSend ? now : prevState.lastAlertAt,
+      lastOkAt: prevState.lastOkAt,
+      activeIssueCodes: evaluation.issues.map((issue) => issue.code)
+    };
+    await (0, import_redis.setData)(stateKey, nextState2, { expire: 0 });
+    if (shouldSend) {
+      const message = buildAlertMessage({
+        evaluation,
+        prevState,
+        reminder
+      });
+      if (flags.printOnly) {
+        console.log(message);
+        console.log("");
+        console.log(
+          buildServerHealthDiagnostics({
+            snapshot,
+            diskPath
+          })
+        );
+      } else {
+        await sendTelegramReport(message, { userName: flags.user });
+      }
+    }
+    return;
+  }
+  const recovered = prevState.status === "alerting" && shouldRecover(snapshot, thresholds);
+  const nextState = {
+    status: "healthy",
+    lastAlertAt: prevState.lastAlertAt,
+    lastOkAt: now,
+    activeIssueCodes: []
+  };
+  await (0, import_redis.setData)(stateKey, nextState, { expire: 0 });
+  if (recovered) {
+    const message = buildRecoveryMessage({ snapshot, prevState });
+    if (flags.printOnly) {
+      console.log(message);
+    } else {
+      await sendTelegramReport(message, { userName: flags.user });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAlertMessage,
+  buildRecoveryMessage,
+  buildServerHealthDiagnostics,
+  collectServerHealthSnapshot,
+  evaluateServerHealth,
+  main,
+  resolveServerHealthThresholds
+});