@orb44/cli 0.1.0

package/server/pulse.mjs

@@ -0,0 +1,704 @@
+import os from "node:os";
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
+import { t } from "./sat-i18n.mjs";
+
+const COMM_RE = /[^a-zA-Z0-9._+-]/g;
+
+export function sanitizeComm(raw) {
+  let s = String(raw || "").trim();
+  const base = s.split("/").filter(Boolean).pop();
+  if (base) s = base;
+  s = s.replace(COMM_RE, "").slice(0, 40);
+  return s || null;
+}
+
+export function decodeProcIp4(hex) {
+  const h = String(hex || "").padStart(8, "0").slice(0, 8);
+  if (!/^[0-9a-fA-F]{8}$/.test(h)) return null;
+  if (h === "00000000") return "0.0.0.0";
+  const b = h.match(/../g).map((x) => parseInt(x, 16));
+  return `${b[3]}.${b[2]}.${b[1]}.${b[0]}`;
+}
+
+export function parseProcNetTcp(table) {
+  const rows = [];
+  for (const line of String(table || "").split("\n").slice(1)) {
+    const p = line.trim().split(/\s+/);
+    if (p.length < 4 || p[3] !== "0A") continue;
+    const [ipHex, portHex] = String(p[1] || "").split(":");
+    const port = parseInt(portHex, 16);
+    const addr = decodeProcIp4(ipHex);
+    if (!addr || !Number.isFinite(port) || port <= 0) continue;
+    rows.push({ addr, port, comm: null });
+  }
+  return rows;
+}
+
+function memInfo() {
+  const memTotal = os.totalmem();
+  const memUsed = memTotal - os.freemem();
+  return { memTotal, memUsed };
+}
+
+function diskUsedPct(root = "/") {
+  try {
+    if (typeof fs.statfsSync !== "function") return null;
+    const s = fs.statfsSync(root);
+    const total = Number(s.blocks) * Number(s.bsize);
+    const free = Number(s.bavail) * Number(s.bsize);
+    if (!total) return null;
+    return Math.max(0, Math.min(100, Math.round((1 - free / total) * 100)));
+  } catch {
+    return null;
+  }
+}
+
+export function originAddrs(ifaces = os.networkInterfaces()) {
+  const out = [];
+  for (const rows of Object.values(ifaces || {})) {
+    for (const r of rows || []) {
+      const family = String(r.family);
+      if (r.internal) continue;
+      if (family !== "IPv4" && family !== "4") continue;
+      if (String(r.address || "").startsWith("169.254.")) continue;
+      out.push(r.address);
+    }
+  }
+  return [...new Set(out)].slice(0, 8);
+}
+
+function run(cmd, args) {
+  try {
+    return execFileSync(cmd, args, { encoding: "utf8", timeout: 3500, stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    return "";
+  }
+}
+
+const SKIP_TOP = new Set(["ps", "ss", "lsof"]);
+
+export function parsePsTop(text) {
+  const rows = [];
+  for (const line of String(text || "").split("\n")) {
+    const m = line.trim().match(/^(\d+)\s+([\d.]+)\s+(\d+)\s+(\S+)/);
+    if (!m) continue;
+    const comm = sanitizeComm(m[4]);
+    if (!comm || SKIP_TOP.has(comm)) continue;
+    rows.push({
+      comm,
+      cpuPct: Math.round(Number(m[2]) * 10) / 10,
+      rssMb: Math.round(Number(m[3]) / 1024),
+    });
+  }
+  rows.sort((a, b) => b.cpuPct - a.cpuPct || b.rssMb - a.rssMb);
+  const seen = new Set();
+  const out = [];
+  for (const r of rows) {
+    if (seen.has(r.comm)) continue;
+    seen.add(r.comm);
+    out.push(r);
+    if (out.length >= 8) break;
+  }
+  return out;
+}
+
+function splitHostPort(token) {
+  const raw = String(token || "");
+  const last = raw.lastIndexOf(":");
+  if (last < 0) return null;
+  const host = raw.slice(0, last).replace(/^\[|\]$/g, "");
+  const port = Number(raw.slice(last + 1));
+  if (!Number.isFinite(port) || port <= 0) return null;
+  const addr = host === "*" ? "0.0.0.0" : host;
+  return { addr, port };
+}
+
+export function parseLsofListen(text) {
+  const rows = [];
+  for (const line of String(text || "").split("\n").slice(1)) {
+    const name = /\s(\S+:\d+)\s+\(LISTEN\)/.exec(line)?.[1];
+    if (!name) continue;
+    const hp = splitHostPort(name);
+    if (!hp) continue;
+    const comm = sanitizeComm(line.trim().split(/\s+/)[0]);
+    rows.push({ ...hp, comm });
+  }
+  const key = (r) => `${r.addr}|${r.port}`;
+  const uniq = new Map();
+  for (const r of rows) uniq.set(key(r), r);
+  return [...uniq.values()].slice(0, 40);
+}
+
+export function parseSsListen(text) {
+  const rows = [];
+  for (const line of String(text || "").split("\n")) {
+    if (!/\bLISTEN\b/i.test(line)) continue;
+    const parts = line.trim().split(/\s+/);
+    const idx = parts.findIndex((p) => /^LISTEN$/i.test(p));
+    const local = idx >= 0 ? parts[idx + 3] : "";
+    const hp = splitHostPort(local);
+    if (!hp) continue;
+    const comm = sanitizeComm(/\(\("([^"]+)"/.exec(line)?.[1]);
+    rows.push({ ...hp, comm });
+  }
+  const key = (r) => `${r.addr}|${r.port}`;
+  const uniq = new Map();
+  for (const r of rows) uniq.set(key(r), r);
+  return [...uniq.values()].slice(0, 40);
+}
+
+function listenLinux() {
+  try {
+    const tcp = fs.readFileSync("/proc/net/tcp", "utf8");
+    return parseProcNetTcp(tcp);
+  } catch {
+    return [];
+  }
+}
+
+function listenTable() {
+  const ss = parseSsListen(run("ss", ["-lptn"]));
+  if (ss.length) return { listen: ss, named: ss.some((r) => r.comm) };
+  const lsof = parseLsofListen(run("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN"]));
+  if (lsof.length) return { listen: lsof, named: lsof.some((r) => r.comm) };
+  const linux = listenLinux();
+  if (linux.length) return { listen: linux, named: false };
+  return { listen: [], named: false };
+}
+
+function topTable() {
+  const text = run("ps", ["-axo", "pid=,pcpu=,rss=,comm="]);
+  return parsePsTop(text);
+}
+
+function okListenAddr(a) {
+  const s = String(a || "");
+  if (s === "0.0.0.0" || s === "::" || s === "::1") return true;
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(s)) return true;
+  return /^[0-9a-fA-F:]+$/.test(s) && s.includes(":");
+}
+
+export function sanitizePulse(raw = {}) {
+  const top = Array.isArray(raw.top)
+    ? raw.top
+        .slice(0, 8)
+        .map((r) => ({
+          comm: sanitizeComm(r.comm),
+          cpuPct: Math.max(0, Math.min(100, Number(r.cpuPct) || 0)),
+          rssMb: Math.max(0, Math.round(Number(r.rssMb) || 0)),
+        }))
+        .filter((r) => r.comm)
+    : [];
+  const listen = Array.isArray(raw.listen)
+    ? raw.listen
+        .slice(0, 40)
+        .map((r) => ({
+          addr: String(r.addr || "").slice(0, 45),
+          port: Number(r.port) || 0,
+          comm: sanitizeComm(r.comm),
+        }))
+        .filter((r) => r.port > 0 && r.port < 65536 && okListenAddr(r.addr))
+    : [];
+  const originA = Array.isArray(raw.originA)
+    ? raw.originA.map((x) => String(x || "")).filter((x) => /^\d{1,3}(\.\d{1,3}){3}$/.test(x)).slice(0, 8)
+    : [];
+  const fw = String(raw.hardening?.firewall || "");
+  const ban = String(raw.hardening?.fail2ban || "");
+  const sync = String(raw.hardening?.timesync || "");
+  const tri = (v) => (v === true || v === false ? v : null);
+  const hardening = {
+    firewall: ["ufw", "nftables", "firewalld", "iptables"].includes(fw) ? fw : null,
+    fail2ban: ["fail2ban", "sshguard"].includes(ban) ? ban : null,
+    fail2banBanned: Math.max(0, Math.min(99999, Number(raw.hardening?.fail2banBanned) || 0)),
+    updates: Boolean(raw.hardening?.updates),
+    sshPassword: tri(raw.hardening?.sshPassword),
+    sshRoot: tri(raw.hardening?.sshRoot),
+    sshWorld: Boolean(raw.hardening?.sshWorld),
+    rebootNeeded: Boolean(raw.hardening?.rebootNeeded),
+    timesync: ["chrony", "systemd-timesyncd", "ntp"].includes(sync) ? sync : null,
+    apparmor: tri(raw.hardening?.apparmor),
+    selinux: tri(raw.hardening?.selinux),
+    dockerApi: Boolean(raw.hardening?.dockerApi),
+    oomKills: Math.max(0, Math.min(999, Number(raw.hardening?.oomKills) || 0)),
+  };
+  const limited = Boolean(raw.limited);
+  const oom = Boolean(raw.oom) || hardening.oomKills > 0;
+  const base = {
+    ts: Number(raw.ts) || Date.now(),
+    hostname: sanitizeComm(raw.hostname) || os.hostname().slice(0, 40),
+    load1: Math.round((Number(raw.load1) || 0) * 100) / 100,
+    memUsed: Math.max(0, Math.round(Number(raw.memUsed) || 0)),
+    memTotal: Math.max(0, Math.round(Number(raw.memTotal) || 0)),
+    diskUsedPct: raw.diskUsedPct == null ? null : Math.max(0, Math.min(100, Math.round(Number(raw.diskUsedPct)))),
+    top,
+    listen,
+    originA,
+    failedUnit: raw.failedUnit ? String(raw.failedUnit).slice(0, 80) : null,
+    oom,
+    limited,
+    hardening,
+  };
+  return { ...base, gradeInside: gradeInside(base) };
+}
+
+const ADMIN_PORTS = new Set([2019, 2375, 2376, 3306, 5432, 6379, 27017, 9200, 11211, 15672, 8500, 2379, 6443, 9090, 5601, 7474, 7687, 1080, 6432]);
+
+const SERVICE_NAME = {
+  22: "SSH",
+  53: "DNS",
+  80: "HTTP",
+  443: "HTTPS",
+  1080: "SOCKS",
+  2019: "Caddy admin",
+  2375: "Docker",
+  2376: "Docker TLS",
+  2379: "etcd",
+  3000: "Node",
+  3306: "MySQL",
+  5432: "Postgres",
+  5601: "Kibana",
+  6379: "Redis",
+  6432: "PgBouncer",
+  6443: "kube-api",
+  7474: "Neo4j",
+  7687: "Bolt",
+  8500: "Consul",
+  8787: "туннель",
+  9090: "Prometheus",
+  9200: "Elasticsearch",
+  11211: "memcached",
+  15672: "RabbitMQ",
+  27017: "Mongo",
+};
+
+export function serviceName(port) {
+  return SERVICE_NAME[Number(port)] || null;
+}
+
+function exposed(addr) {
+  return addr === "0.0.0.0" || addr === "::" || addr === "*";
+}
+
+function runOk(cmd, args) {
+  try {
+    execFileSync(cmd, args, { encoding: "utf8", timeout: 2500, stdio: ["ignore", "pipe", "ignore"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runOut(cmd, args) {
+  try {
+    return execFileSync(cmd, args, { encoding: "utf8", timeout: 2500, stdio: ["ignore", "pipe", "ignore"] });
+  } catch (e) {
+    return e?.stdout ? String(e.stdout) : "";
+  }
+}
+
+export function parseUfwStatus(text) {
+  const t = String(text || "").toLowerCase();
+  if (t.includes("status: active")) return true;
+  if (t.includes("status: inactive")) return false;
+  return null;
+}
+
+export function parseSshdT(text) {
+  const get = (key) => {
+    const re = new RegExp(`^${key}\\s+(\\S+)`, "im");
+    return re.exec(String(text || ""))?.[1]?.toLowerCase() || "";
+  };
+  const pw = get("passwordauthentication");
+  const root = get("permitrootlogin");
+  return {
+    sshPassword: pw === "yes" ? true : pw === "no" ? false : null,
+    sshRoot: root === "yes" ? true : root ? false : null,
+  };
+}
+
+export function parseVmstatOom(text) {
+  const m = /(?:^|\n)oom_kill\s+(\d+)/.exec(String(text || ""));
+  return m ? Number(m[1]) : 0;
+}
+
+export function insideServiceWorldPorts(pulse) {
+  return [...new Set((pulse?.listen || []).filter((r) => exposed(r.addr) && ADMIN_PORTS.has(r.port)).map((r) => r.port))];
+}
+
+export function collectHardening(listen = []) {
+  const ufw = parseUfwStatus(runOut("ufw", ["status"]));
+  let firewall = null;
+  if (ufw === true) firewall = "ufw";
+  else if (runOk("systemctl", ["is-active", "nftables"])) firewall = "nftables";
+  else if (runOk("systemctl", ["is-active", "firewalld"])) firewall = "firewalld";
+  else {
+    const pol = runOut("iptables", ["-S", "INPUT"]);
+    if (/^-P INPUT (DROP|REJECT)/m.test(pol)) firewall = "iptables";
+  }
+  let fail2ban = null;
+  let fail2banBanned = 0;
+  if (runOk("systemctl", ["is-active", "fail2ban"])) fail2ban = "fail2ban";
+  else if (runOk("systemctl", ["is-active", "sshguard"])) fail2ban = "sshguard";
+  if (fail2ban === "fail2ban") {
+    const jail = runOut("fail2ban-client", ["status", "sshd"]) || runOut("fail2ban-client", ["status"]);
+    fail2banBanned = parseFail2banJail(jail).banned;
+  }
+  const updates = runOk("systemctl", ["is-active", "unattended-upgrades"]) || fs.existsSync("/etc/apt/apt.conf.d/20auto-upgrades");
+  const ssh = parseSshdT(runOut("sshd", ["-T"]) || runOut("/usr/sbin/sshd", ["-T"]));
+  const sshWorld = listen.some((r) => exposed(r.addr) && r.port === 22);
+  const dockerApi = listen.some((r) => exposed(r.addr) && (r.port === 2375 || r.port === 2376));
+  let timesync = null;
+  if (runOk("systemctl", ["is-active", "chrony"]) || runOk("systemctl", ["is-active", "chronyd"])) timesync = "chrony";
+  else if (runOk("systemctl", ["is-active", "systemd-timesyncd"])) timesync = "systemd-timesyncd";
+  else if (runOk("systemctl", ["is-active", "ntp"]) || runOk("systemctl", ["is-active", "ntpd"])) timesync = "ntp";
+  let apparmor = null;
+  if (fs.existsSync("/sys/kernel/security/apparmor")) apparmor = true;
+  else if (process.platform === "linux") apparmor = false;
+  let selinux = null;
+  try {
+    selinux = fs.readFileSync("/sys/fs/selinux/enforce", "utf8").trim() === "1";
+  } catch {
+    if (process.platform === "linux") selinux = false;
+  }
+  const rebootNeeded = fs.existsSync("/var/run/reboot-required");
+  let oomKills = 0;
+  try {
+    oomKills = parseVmstatOom(fs.readFileSync("/proc/vmstat", "utf8"));
+  } catch {
+    oomKills = 0;
+  }
+  return {
+    firewall,
+    fail2ban,
+    fail2banBanned,
+    updates: Boolean(updates),
+    ...ssh,
+    sshWorld,
+    rebootNeeded,
+    timesync,
+    apparmor,
+    selinux,
+    dockerApi,
+    oomKills,
+  };
+}
+
+export function parseFail2banJail(text) {
+  const banned = /Currently banned:\s*(\d+)/i.exec(String(text || ""));
+  const failed = /Currently failed:\s*(\d+)/i.exec(String(text || ""));
+  return {
+    banned: banned ? Number(banned[1]) : 0,
+    failed: failed ? Number(failed[1]) : 0,
+  };
+}
+
+export function gradeInside(pulse = {}) {
+  const listen = pulse.listen || [];
+  const h = pulse.hardening || {};
+  const exposedAdmin = listen.filter((r) => exposed(r.addr) && ADMIN_PORTS.has(r.port));
+  const fw = Boolean(h.firewall);
+  const ban = Boolean(h.fail2ban);
+  const updates = Boolean(h.updates);
+  const diskHigh = Number(pulse.diskUsedPct) >= 85;
+  const oom = Boolean(pulse.oom) || Number(h.oomKills) > 0;
+  if (h.dockerApi) return "D";
+  if (h.sshPassword && h.sshRoot && h.sshWorld) return "D";
+  if (!fw && exposedAdmin.length) return "D";
+  if (!fw && !ban) return "D";
+  if (exposedAdmin.length || h.sshPassword || h.sshRoot) return "C";
+  if (!fw || !ban) return "C";
+  if (diskHigh || oom || h.rebootNeeded || !h.timesync) return "C";
+  if (fw && ban && updates && h.timesync && !h.sshPassword && !h.sshRoot && !exposedAdmin.length && !h.dockerApi) return "A";
+  if (fw && ban && !exposedAdmin.length && !h.dockerApi) return "B";
+  return "C";
+}
+
+function labelPort(r) {
+  const svc = serviceName(r.port);
+  return svc ? `${svc} :${r.port}` : `:${r.port}`;
+}
+
+export function compareInside(pulse, rec = {}) {
+  const notes = [];
+  const listen = pulse?.listen || [];
+  const streetIp = rec.ticket?.ip || rec.watch?.current?.ip || null;
+  const incident = rec.incident?.code || rec.watch?.current?.incident || "";
+  const exposedAdmin = listen.filter((r) => exposed(r.addr) && ADMIN_PORTS.has(r.port));
+  const streetOpen = rec.watch?.current?.openPorts;
+  const hasStreet = Array.isArray(streetOpen);
+  if (exposedAdmin.length) {
+    const leaked = hasStreet ? exposedAdmin.filter((r) => streetOpen.includes(r.port)) : [];
+    const held = hasStreet ? exposedAdmin.filter((r) => !streetOpen.includes(r.port)) : exposedAdmin;
+    if (leaked.length) {
+      const names = [...new Set(leaked.map((r) => labelPort(r)))];
+      notes.push({
+        kind: "listen-leaked",
+        title: "Служебные порты отвечают и с улицы",
+        text: `Машина слушает ${names.join(", ")} на 0.0.0.0, и снимок с интернета на тех же портах получил ответ сервиса, не пустой SYN-ACK. Это уже не «файрвол, скорее всего, держит» — сокет открыт снаружи.`,
+        do: "Сначала закройте порт на файрволе панели и в docker-compose поставьте 127.0.0.1 перед номером. Orb44 файрвол сам не включает и compose не правит.",
+      });
+    }
+    if (held.length) {
+      const names = [...new Set(held.map((r) => labelPort(r)))];
+      notes.push({
+        kind: "listen-open",
+        title: hasStreet ? "Базы слушают сеть сервера, с улицы молчат" : "Базы слушают всю сеть сервера",
+        text: hasStreet
+          ? `Сейчас ${names.join(", ")} принимают подключения с любого сетевого адреса этой машины. Снимок с интернета на этих портах не получил баннер сервиса — файрвол держит. Если порт откроют в панели VPS, до базы доберётся любой, не только ваш сайт.`
+          : `Сейчас ${names.join(", ")} принимают подключения не только с программ на этой машине, а с любого её сетевого адреса. Из интернета их может быть не видно: файрвол на VPS эти порты, скорее всего, закрывает. Если порт откроют — до Redis или Postgres доберётся любой, не только ваш сайт.`,
+        do: "На кортадо в docker-compose у этих сервисов замените порты. Пример: было 6379:6379, нужно 127.0.0.1:6379:6379. Так же для 5432, 7474 и остальных оранжевых меток. Тогда к базе подключатся только программы на этом сервере. Orb44 файл сам не изменит.",
+      });
+    }
+  }
+  if (pulse?.originA?.length && streetIp && !pulse.originA.includes(streetIp)) {
+    notes.push({
+      kind: "origin-mismatch",
+      title: "Адрес машины не совпал со снимком",
+      text: `На машине ${pulse.originA.join(", ")}, снаружи A=${streetIp}. Другой ящик или серый щит.`,
+      do: "Сверьте DNS A с тем VPS, куда поставили сателлит. Если сайт за Cloudflare — это ожидаемо, не инцидент.",
+    });
+  }
+  const loadHigh = Number(pulse?.load1) >= Math.max(2, (os.cpus() || []).length);
+  const memHigh = pulse?.memTotal && pulse.memUsed / pulse.memTotal >= 0.9;
+  if (loadHigh || memHigh) {
+    const top = pulse.top?.[0];
+    const who = top ? `${top.comm} ${top.cpuPct}%` : "процесс в топе не виден";
+    if (/auth_hot|auth_open/.test(incident)) {
+      notes.push({
+        kind: "load-street",
+        title: "Нагрузка и открытый вход",
+        text: `Машина под нагрузкой, снаружи открыт вход — похоже бьют во вход. Топ: ${who}.`,
+        do: "Сначала вход на витрине, не процессы. Сателлит здесь только подтверждает, что CPU живой.",
+      });
+    } else {
+      notes.push({
+        kind: "load-local",
+        title: "Машина тяжёлая, витрина тихая",
+        text: `Нагрузка локальная, снаружи тихо — не атака витрины. Топ: ${who}.`,
+        do: "Смотрите процесс в топе (воркер, docker). WAF тут ни при чём.",
+      });
+    }
+  }
+  const h = pulse.hardening || {};
+  const fw = h.firewall;
+  const ban = h.fail2ban;
+  if (pulse.hardening) {
+    if (!fw && !ban) {
+      notes.push({
+        kind: "hardening",
+        title: "Минимум защиты не виден",
+        text: "Нет включённого файрвола и нет fail2ban. Лишние порты и подбор SSH никто не режет.",
+        do: "На кортадо включите ufw и fail2ban. Orb44 пакеты сам не ставит.",
+      });
+    } else if (!fw) {
+      notes.push({
+        kind: "hardening",
+        title: "Файрвол не виден",
+        text: "Не нашлось включённого ufw, nftables или firewalld. Тогда оранжевые порты баз — это не «закрыто файрволом», а открыто в сеть сервера.",
+        do: "Включите ufw и закройте лишние порты. Orb44 файрвол сам не включает.",
+      });
+    } else if (!ban) {
+      notes.push({
+        kind: "hardening",
+        title: "Нет защиты подбора SSH",
+        text: "fail2ban или sshguard не запущены. Повторные попытки входа по SSH ничем не режутся.",
+        do: "Поставьте и включите fail2ban на кортадо. Orb44 пакеты сам не ставит.",
+      });
+    }
+    const sshBits = [];
+    if (h.sshPassword) sshBits.push("вход по паролю включён");
+    if (h.sshRoot) sshBits.push("root может зайти по SSH");
+    if (h.sshWorld && (h.sshPassword || h.sshRoot)) sshBits.push("порт 22 слушает всю сеть");
+    if (sshBits.length) {
+      notes.push({
+        kind: "hardening",
+        title: "SSH слабее, чем нужно",
+        text: `${sshBits.join(". ")}. Пароли не подбираем — это живые настройки sshd, не /etc/shadow.`,
+        do: "В sshd: PasswordAuthentication no и PermitRootLogin no. Порт 22 лучше не светить всей сети. Orb44 sshd сам не правит.",
+      });
+    }
+    if (h.dockerApi) {
+      notes.push({
+        kind: "hardening",
+        title: "Docker API слушает сеть сервера",
+        text: "Порт 2375 или 2376 принимает подключения не только с этой машины. С улицы его может закрывать файрвол, но сокет уже не loopback.",
+        do: "Уберите публикацию Docker API наружу. Достаточно unix-сокета. Orb44 Docker сам не трогает.",
+      });
+    }
+    if (h.rebootNeeded) {
+      notes.push({
+        kind: "hardening",
+        title: "Ядро ждет перезагрузки",
+        text: "На диске есть /var/run/reboot-required — пакеты ядра встали, машина ещё на старом.",
+        do: "Запланируйте reboot в окно. Orb44 сервер сам не перезагружает.",
+      });
+    }
+    if (!h.timesync) {
+      notes.push({
+        kind: "hardening",
+        title: "Часы машины не синхронизируются",
+        text: "Не видно chrony, systemd-timesyncd или ntp. Кривые часы ломают TLS и разбор логов.",
+        do: "Включите systemd-timesyncd или chrony. Orb44 пакеты сам не ставит.",
+      });
+    }
+    if (h.apparmor === false && h.selinux === false) {
+      notes.push({
+        kind: "hardening",
+        title: "Нет AppArmor и SELinux",
+        text: "На Linux не видно ни AppArmor, ни enforcing SELinux. Это не дыра сама по себе, но процесс ничем не ограничен.",
+        do: "На Ubuntu обычно достаточно apparmor. Orb44 LSM сам не включает.",
+      });
+    }
+    if (Number(pulse.diskUsedPct) >= 85) {
+      notes.push({
+        kind: "hardening",
+        title: "Диск почти полный",
+        text: `Корневой раздел занят на ${pulse.diskUsedPct}%. Логи и апдейты начнут падать раньше, чем витрина.`,
+        do: "Почистите логи и неиспользуемые образы Docker. Orb44 файлы сам не удаляет.",
+      });
+    }
+    if (pulse.oom || Number(h.oomKills) > 0) {
+      notes.push({
+        kind: "hardening",
+        title: "Ядро убивало процессы по памяти",
+        text: Number(h.oomKills) > 0 ? `В vmstat oom_kill=${h.oomKills}. Кто-то уже упирался в RAM.` : "Пульс пометил OOM.",
+        do: "Смотрите топ по RAM и лимиты контейнеров. Orb44 процессы сам не убивает и не поднимает.",
+      });
+    }
+    const banned = Number(h.fail2banBanned) || 0;
+    if (banned > 0 && /auth_hot|auth_open/.test(incident)) {
+      notes.push({
+        kind: "stuffing",
+        title: "fail2ban копит баны, вход с улицы горячий",
+        text: `Сейчас в бане ${banned}. Пароли не подбираем — это чужой перебор, сателлит только считает.`,
+        do: "Смотрите fail2ban и форму входа на витрине. Orb44 пароли не перебирает.",
+      });
+    }
+  }
+  return notes;
+}
+
+export const INSIDE_ALERT_DEBOUNCE_MS = 6 * 3600 * 1000;
+
+function streetIncidentCode(rec = {}) {
+  return rec.incident?.code || rec.watch?.current?.incident || rec.watch?.last?.incident || "";
+}
+
+export function insideWatchReasons(pulse, prev, rec = {}) {
+  const notes = [];
+  const incident = String(streetIncidentCode(rec) || "");
+  const streetHot = /auth_hot|auth_open|l7_exhaustion/.test(incident);
+  const loadHigh = Number(pulse?.load1) >= 2;
+  const memHigh = pulse?.memTotal && pulse.memUsed / pulse.memTotal >= 0.85;
+  const top = pulse?.top?.[0];
+  const who = top ? `${top.comm} ${top.cpuPct}%` : "процесс в топе не виден";
+  if (loadHigh || memHigh) {
+    if (streetHot) {
+      notes.push({
+        kind: "stuffing",
+        title: "Нагрузка и открытый вход",
+        text: `Машина под нагрузкой, снаружи горячий вход — похоже бьют во вход, не локальный воркер. Топ: ${who}. Пароли не подбираем.`,
+      });
+    } else {
+      notes.push({
+        kind: "load-local",
+        title: "Машина тяжёлая, витрина тихая",
+        text: `Нагрузка локальная, с улицы не видно атаки. Топ: ${who}.`,
+      });
+    }
+  }
+  const banned = Number(pulse?.hardening?.fail2banBanned) || 0;
+  const prevBanned = Number(prev?.hardening?.fail2banBanned) || 0;
+  if (prev && banned > prevBanned) {
+    notes.push({
+      kind: "stuffing-ssh",
+      title: "fail2ban копит баны",
+      text: `Было ${prevBanned}, стало ${banned}. Это чужой перебор SSH. Пароли не подбираем.`,
+    });
+  }
+  if (prev) {
+    const nowPorts = insideServiceWorldPorts(pulse);
+    const prevPorts = new Set(insideServiceWorldPorts(prev));
+    const added = nowPorts.filter((p) => !prevPorts.has(p));
+    if (added.length) {
+      notes.push({
+        kind: "listen-new",
+        title: "Новый служебный порт на 0.0.0.0",
+        text: `Появились ${added.join(", ")}. С прошлого пульса их не было.`,
+      });
+    }
+  }
+  const streetIp = rec.ticket?.ip || rec.watch?.current?.ip || rec.watch?.last?.ip || null;
+  if (pulse?.originA?.length && streetIp && !pulse.originA.includes(streetIp)) {
+    notes.push({
+      kind: "origin-mismatch",
+      title: "Адрес машины не совпал со снимком",
+      text: `На машине ${pulse.originA.join(", ")}, снаружи A=${streetIp}.`,
+    });
+  }
+  return notes;
+}
+
+export function insideAlertDecision(row, reasons, now = Date.now(), debounceMs = INSIDE_ALERT_DEBOUNCE_MS) {
+  if (!reasons?.length) return { emit: false, key: null };
+  const key = [...new Set(reasons.map((r) => r.kind))].sort().join(",");
+  if (row?.lastInsideAlertKey === key && row?.lastInsideAlertAt && now - row.lastInsideAlertAt < debounceMs) {
+    return { emit: false, key };
+  }
+  return { emit: true, key };
+}
+
+export function collectPulse() {
+  const { memUsed, memTotal } = memInfo();
+  const { listen, named } = listenTable();
+  const top = topTable();
+  const hardening = collectHardening(listen);
+  const limited = listen.length > 0 && !named;
+  return sanitizePulse({
+    ts: Date.now(),
+    hostname: os.hostname(),
+    load1: os.loadavg()[0],
+    memUsed,
+    memTotal,
+    diskUsedPct: diskUsedPct("/"),
+    top,
+    listen,
+    originA: originAddrs(),
+    failedUnit: null,
+    oom: Number(hardening.oomKills) > 0,
+    limited,
+    hardening,
+  });
+}
+
+export function formatPulsePreview(pulse, lang = "en") {
+  const gb = (n) => (Number(n) / 1024 / 1024 / 1024).toFixed(1);
+  const none = t(lang, "preview_none");
+  const lines = [
+    t(lang, "preview_host", { h: pulse.hostname || "—" }),
+    t(lang, "preview_load", { load: pulse.load1, used: gb(pulse.memUsed), total: gb(pulse.memTotal), disk: pulse.diskUsedPct ?? "—" }),
+    t(lang, "preview_listen", {
+      list: (pulse.listen || []).slice(0, 12).map((r) => `${r.addr}:${r.port}${r.comm ? ` ${r.comm}` : ""}`).join(", ") || none,
+    }),
+    t(lang, "preview_top", {
+      list: (pulse.top || []).slice(0, 5).map((r) => `${r.comm} ${r.cpuPct}% ${r.rssMb}M`).join(", ") || none,
+    }),
+  ];
+  const h = pulse.hardening;
+  if (h) {
+    const ssh = h.sshPassword ? t(lang, "preview_ssh_pass") : h.sshPassword === false ? t(lang, "preview_ssh_key") : "?";
+    lines.push(
+      t(lang, "preview_guard", {
+        fw: h.firewall || t(lang, "preview_fw_no"),
+        ban: h.fail2ban || t(lang, "preview_ban_no"),
+        upd: h.updates ? t(lang, "preview_yes") : t(lang, "preview_no"),
+        sync: h.timesync || t(lang, "preview_no"),
+        ssh,
+        grade: pulse.gradeInside || "—",
+      })
+    );
+  }
+  if (pulse.limited) lines.push(t(lang, "preview_limited"));
+  return lines.join("\n");
+}