Patch plans (Updates -> Patch plans): updates on a schedule, one server at a time, each by an ordinary update run, stopping at the first failure by default, silencing what depends on a server while it is updated, with one message at the end. Monthly report (Operations -> Monthly report, and optionally a message on a day of the month): availability, incidents, updates, restore tests, backups and renewals for a calendar month, printable. Backed by daily endpoint figures and a record of renewals. New ports: the first report with ports is the baseline; a TCP port that begins listening later and is not noted on the server's Ports card is a warning, cleared by Mark as expected. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
312 lines
12 KiB
TypeScript
312 lines
12 KiB
TypeScript
import { Router } from "express";
|
|
import { and, eq, inArray } from "drizzle-orm";
|
|
import { z } from "zod";
|
|
import { db } from "../db/client.js";
|
|
import { servers, serverPorts } from "../db/schema.js";
|
|
import { requireRole } from "../auth/middleware.js";
|
|
import { recordAudit } from "../services/audit.js";
|
|
import { beginScan, endScan, MAX_SCAN_SPAN, resolveScanTarget, scanPorts, toRanges } from "../services/portScan.js";
|
|
import { type AgentPort, groupAgentPorts, parseJson } from "../services/agentPorts.js";
|
|
import { newListeningPorts, parseBaseline, portKey } from "../services/newPorts.js";
|
|
import { getSettings } from "../services/settingsStore.js";
|
|
import { asyncHandler } from "../utils/asyncHandler.js";
|
|
|
|
// Mounted under /api/servers/:id/ports by the servers router, which has already required a signed-in user.
|
|
export const serverPortsRouter = Router({ mergeParams: true });
|
|
|
|
interface StoredScan {
|
|
at: string;
|
|
address: string;
|
|
from: number;
|
|
to: number;
|
|
open: number;
|
|
refused: number;
|
|
filtered: number;
|
|
responded: boolean;
|
|
}
|
|
|
|
export interface PortEntry {
|
|
/** Null for a port that's only known from the agent and has no note yet. */
|
|
id: number | null;
|
|
port: number;
|
|
protocol: "tcp" | "udp";
|
|
label: string | null;
|
|
comment: string | null;
|
|
/** The last scan from this app connected to it. */
|
|
scanOpen: boolean;
|
|
lastSeenOpenAt: string | null;
|
|
/** What the agent sees bound on the host, when it reports listening ports. */
|
|
agent: { addresses: string[]; process: string | null; localOnly: boolean } | null;
|
|
/** "open" if anything is using it; "reserved" if it only has a note. */
|
|
state: "open" | "reserved";
|
|
/** Began listening after the first report and nobody has noted it: a "new port" alert is on until it is noted or stops listening. */
|
|
isNew: boolean;
|
|
}
|
|
|
|
async function buildPortList(serverId: number) {
|
|
const [server] = await db.select().from(servers).where(eq(servers.id, serverId)).limit(1);
|
|
if (!server) return null;
|
|
const rows = await db.select().from(serverPorts).where(eq(serverPorts.serverId, serverId));
|
|
const agentRaw = parseJson<AgentPort[] | null>(server.listeningPorts, null);
|
|
const agent = groupAgentPorts(agentRaw ?? []);
|
|
|
|
// What is new: listening, reachable from outside, not in the baseline and not noted — the same rule the alert uses.
|
|
const expected = new Set(rows.filter((r) => r.label || r.comment).map((r) => portKey(r.protocol, r.port)));
|
|
const alerting = (await getSettings()).healthChecks.newPortAlerts;
|
|
const fresh = new Set(alerting ? newListeningPorts(agentRaw, parseBaseline(server.portBaseline), expected).map((p) => portKey(p.protocol, p.port)) : []);
|
|
|
|
const entries = new Map<string, PortEntry>();
|
|
for (const row of rows) {
|
|
const key = `${row.protocol}:${row.port}`;
|
|
entries.set(key, {
|
|
id: row.id,
|
|
port: row.port,
|
|
protocol: row.protocol,
|
|
label: row.label,
|
|
comment: row.comment,
|
|
scanOpen: row.open,
|
|
lastSeenOpenAt: row.lastSeenOpenAt,
|
|
agent: agent.get(key) ?? null,
|
|
state: "reserved",
|
|
isNew: fresh.has(key),
|
|
});
|
|
}
|
|
for (const [key, info] of agent) {
|
|
if (entries.has(key)) continue;
|
|
const [protocol, port] = key.split(":");
|
|
entries.set(key, {
|
|
id: null,
|
|
port: Number(port),
|
|
protocol: protocol as "tcp" | "udp",
|
|
label: null,
|
|
comment: null,
|
|
scanOpen: false,
|
|
lastSeenOpenAt: null,
|
|
agent: info,
|
|
state: "reserved",
|
|
isNew: fresh.has(key),
|
|
});
|
|
}
|
|
for (const entry of entries.values()) {
|
|
if (entry.scanOpen || entry.agent) entry.state = "open";
|
|
}
|
|
|
|
const ports = [...entries.values()].sort((a, b) => a.port - b.port || a.protocol.localeCompare(b.protocol));
|
|
return {
|
|
server,
|
|
ports,
|
|
agentReporting: agentRaw !== null,
|
|
agentReportedAt: agentRaw !== null ? server.lastSeenAt : null,
|
|
lastScan: parseJson<StoredScan | null>(server.lastPortScan, null),
|
|
};
|
|
}
|
|
|
|
function serverIdOf(req: { params: Record<string, string> }): number | null {
|
|
const id = Number(req.params.id);
|
|
return Number.isInteger(id) && id > 0 ? id : null;
|
|
}
|
|
|
|
serverPortsRouter.get("/", asyncHandler(async (req, res) => {
|
|
const id = serverIdOf(req);
|
|
if (!id) return res.status(400).json({ error: "invalid_id" });
|
|
const list = await buildPortList(id);
|
|
if (!list) return res.status(404).json({ error: "not_found" });
|
|
const { server: _server, ...out } = list;
|
|
res.json(out);
|
|
}));
|
|
|
|
const scanSchema = z
|
|
.object({
|
|
address: z.string().min(1).max(255),
|
|
from: z.number().int().min(1).max(65535),
|
|
to: z.number().int().min(1).max(65535),
|
|
})
|
|
.refine((d) => d.to >= d.from, { message: "The end of the range is before the start." })
|
|
.refine((d) => d.to - d.from + 1 <= MAX_SCAN_SPAN, { message: `Scan at most ${MAX_SCAN_SPAN} ports at a time.` });
|
|
|
|
serverPortsRouter.post("/scan", requireRole("operator"), asyncHandler(async (req, res) => {
|
|
const serverId = serverIdOf(req);
|
|
if (!serverId) return res.status(400).json({ error: "invalid_id" });
|
|
const parsed = scanSchema.safeParse(req.body);
|
|
if (!parsed.success) {
|
|
const message = parsed.error.issues[0]?.message ?? "Invalid scan request.";
|
|
return res.status(400).json({ error: "invalid_body", message, details: parsed.error.flatten() });
|
|
}
|
|
const { address, from, to } = parsed.data;
|
|
|
|
const [server] = await db.select({ id: servers.id, name: servers.name }).from(servers).where(eq(servers.id, serverId)).limit(1);
|
|
if (!server) return res.status(404).json({ error: "not_found" });
|
|
|
|
let target: string;
|
|
try {
|
|
target = await resolveScanTarget(address);
|
|
} catch (err) {
|
|
return res.status(400).json({ error: "invalid_address", message: err instanceof Error ? err.message : String(err) });
|
|
}
|
|
|
|
if (!beginScan(serverId)) {
|
|
return res.status(409).json({ error: "scan_in_progress", message: "A scan of this server is already running." });
|
|
}
|
|
|
|
let scan;
|
|
try {
|
|
scan = await scanPorts(target, from, to);
|
|
} finally {
|
|
endScan(serverId);
|
|
}
|
|
|
|
const now = new Date().toISOString();
|
|
// If nothing at all answered, the host is probably down or dropping everything — that says nothing about
|
|
// which ports are open, so leave what we knew before rather than marking it all closed.
|
|
const responded = scan.open.length + scan.refused.length > 0;
|
|
|
|
if (responded) {
|
|
const existing = await db
|
|
.select()
|
|
.from(serverPorts)
|
|
.where(and(eq(serverPorts.serverId, serverId), eq(serverPorts.protocol, "tcp")));
|
|
const inRange = existing.filter((r) => r.port >= from && r.port <= to);
|
|
const openSet = new Set(scan.open);
|
|
const known = new Set(existing.map((r) => r.port));
|
|
|
|
const newlyFound = scan.open.filter((p) => !known.has(p));
|
|
for (let i = 0; i < newlyFound.length; i += 50) {
|
|
await db.insert(serverPorts).values(
|
|
newlyFound.slice(i, i + 50).map((port) => ({ serverId, port, protocol: "tcp" as const, open: true, lastSeenOpenAt: now })),
|
|
);
|
|
}
|
|
const stillOpen = inRange.filter((r) => openSet.has(r.port)).map((r) => r.id);
|
|
if (stillOpen.length > 0) {
|
|
await db.update(serverPorts).set({ open: true, lastSeenOpenAt: now }).where(inArray(serverPorts.id, stillOpen));
|
|
}
|
|
// No longer open: keep it if someone wrote a note about it (it's now "reserved"), otherwise it carries no information.
|
|
const gone = inRange.filter((r) => r.open && !openSet.has(r.port));
|
|
const keep = gone.filter((r) => r.label || r.comment).map((r) => r.id);
|
|
const drop = gone.filter((r) => !(r.label || r.comment)).map((r) => r.id);
|
|
if (keep.length > 0) await db.update(serverPorts).set({ open: false }).where(inArray(serverPorts.id, keep));
|
|
if (drop.length > 0) await db.delete(serverPorts).where(inArray(serverPorts.id, drop));
|
|
}
|
|
|
|
const summary: StoredScan = {
|
|
at: now,
|
|
address: target,
|
|
from,
|
|
to,
|
|
open: scan.open.length,
|
|
refused: scan.refused.length,
|
|
filtered: scan.filtered,
|
|
responded,
|
|
};
|
|
await db.update(servers).set({ lastPortScan: JSON.stringify(summary) }).where(eq(servers.id, serverId));
|
|
|
|
// "Free" is what the host actively refused AND nobody has claimed — by a note, or by the agent seeing it bound
|
|
// (which catches services listening only on localhost, invisible to a scan from elsewhere).
|
|
const list = (await buildPortList(serverId))!;
|
|
const taken = new Set(list.ports.filter((p) => p.protocol === "tcp").map((p) => p.port));
|
|
const free = scan.refused.filter((p) => !taken.has(p));
|
|
|
|
await recordAudit({
|
|
actor: req.currentUser!,
|
|
category: "server",
|
|
action: "scan_ports",
|
|
targetType: "server",
|
|
targetId: serverId,
|
|
detail: { name: server.name, address: target, from, to, open: scan.open.length },
|
|
});
|
|
|
|
res.json({
|
|
scan: summary,
|
|
freeCount: free.length,
|
|
freeRanges: toRanges(free),
|
|
ports: list.ports,
|
|
agentReporting: list.agentReporting,
|
|
agentReportedAt: list.agentReportedAt,
|
|
});
|
|
}));
|
|
|
|
const noteSchema = z.object({
|
|
port: z.number().int().min(1).max(65535),
|
|
protocol: z.enum(["tcp", "udp"]).default("tcp"),
|
|
label: z.string().trim().max(100).nullish(),
|
|
comment: z.string().trim().max(500).nullish(),
|
|
});
|
|
|
|
serverPortsRouter.put("/", requireRole("operator"), asyncHandler(async (req, res) => {
|
|
const serverId = serverIdOf(req);
|
|
if (!serverId) return res.status(400).json({ error: "invalid_id" });
|
|
const parsed = noteSchema.safeParse(req.body);
|
|
if (!parsed.success) {
|
|
return res.status(400).json({ error: "invalid_body", message: "Invalid port note.", details: parsed.error.flatten() });
|
|
}
|
|
const { port, protocol } = parsed.data;
|
|
const label = parsed.data.label || null;
|
|
const comment = parsed.data.comment || null;
|
|
|
|
const [server] = await db.select({ id: servers.id, name: servers.name }).from(servers).where(eq(servers.id, serverId)).limit(1);
|
|
if (!server) return res.status(404).json({ error: "not_found" });
|
|
|
|
const [existing] = await db
|
|
.select()
|
|
.from(serverPorts)
|
|
.where(and(eq(serverPorts.serverId, serverId), eq(serverPorts.port, port), eq(serverPorts.protocol, protocol)))
|
|
.limit(1);
|
|
|
|
if (!existing && !label && !comment) {
|
|
return res.status(400).json({ error: "invalid_body", message: "Add a label or a comment to reserve a port." });
|
|
}
|
|
|
|
const now = new Date().toISOString();
|
|
if (existing) {
|
|
if (!label && !comment && !existing.open) {
|
|
await db.delete(serverPorts).where(eq(serverPorts.id, existing.id));
|
|
} else {
|
|
await db.update(serverPorts).set({ label, comment, updatedAt: now }).where(eq(serverPorts.id, existing.id));
|
|
}
|
|
} else {
|
|
await db.insert(serverPorts).values({ serverId, port, protocol, label, comment, updatedAt: now });
|
|
}
|
|
|
|
await recordAudit({
|
|
actor: req.currentUser!,
|
|
category: "server",
|
|
action: "set_port_note",
|
|
targetType: "server",
|
|
targetId: serverId,
|
|
detail: { name: server.name, port, protocol, label },
|
|
});
|
|
|
|
const list = (await buildPortList(serverId))!;
|
|
res.json({ ports: list.ports });
|
|
}));
|
|
|
|
serverPortsRouter.delete("/:portId", requireRole("operator"), asyncHandler(async (req, res) => {
|
|
const serverId = serverIdOf(req);
|
|
const portId = Number(req.params.portId);
|
|
if (!serverId || !Number.isInteger(portId)) return res.status(400).json({ error: "invalid_id" });
|
|
|
|
const [row] = await db
|
|
.select()
|
|
.from(serverPorts)
|
|
.where(and(eq(serverPorts.id, portId), eq(serverPorts.serverId, serverId)))
|
|
.limit(1);
|
|
if (!row) return res.status(404).json({ error: "not_found" });
|
|
|
|
// A port that's currently open stays listed — removing its note just blanks it. A reserved-only port disappears.
|
|
if (row.open) {
|
|
await db.update(serverPorts).set({ label: null, comment: null }).where(eq(serverPorts.id, portId));
|
|
} else {
|
|
await db.delete(serverPorts).where(eq(serverPorts.id, portId));
|
|
}
|
|
|
|
await recordAudit({
|
|
actor: req.currentUser!,
|
|
category: "server",
|
|
action: "remove_port_note",
|
|
targetType: "server",
|
|
targetId: serverId,
|
|
detail: { port: row.port, protocol: row.protocol, label: row.label },
|
|
});
|
|
|
|
res.status(204).end();
|
|
}));
|