import { Router } from "express"; import { eq, and, inArray } from "drizzle-orm"; import { z } from "zod"; import { db } from "../db/client.js"; import { servers, serverLinks, integrations, dnsRecordsCache, dnsZonesCache, dnsProviders } from "../db/schema.js"; import { requireAuth, requireRole } from "../auth/middleware.js"; import { generateApiToken } from "../services/tokens.js"; import { recordAudit } from "../services/audit.js"; import { loadParentRows, resolveParents, wouldLoop } from "../services/serverParents.js"; import { parsePendingUpdates } from "../services/pendingUpdates.js"; import { latestAgentVersions } from "../services/agentVersions.js"; import { getServerMetrics, RETENTION_DAYS } from "../services/serverMetrics.js"; import { getServerActivity } from "../services/serverActivity.js"; import { asyncHandler } from "../utils/asyncHandler.js"; import { ID_PATTERNS } from "../utils/pathSegment.js"; import { loadIntegrationConfig } from "../integrations/loadIntegration.js"; import { createProxmoxAdapter, type ProxmoxGuestType } from "../integrations/proxmox/adapter.js"; import { serverPortsRouter } from "./serverPorts.js"; import { InvalidTagError, normalizeTags, parseTags } from "../services/serverTags.js"; import { buildServerSummary } from "../services/serverSummary.js"; import { activeSubjects } from "../services/maintenance.js"; import { getSettings } from "../services/settingsStore.js"; export const serversRouter = Router(); /** A server row as the API returns it: no token hash, and tags as an array rather than the stored JSON. */ function publicServer(row: T) { const { apiTokenHash: _hash, tags, pendingUpdates, ...rest } = row; return { ...rest, tags: parseTags(tags), pendingUpdates: parsePendingUpdates(pendingUpdates) }; } serversRouter.use(requireAuth); serversRouter.use("/:id/ports", serverPortsRouter); const createServerSchema = z.object({ name: z.string().min(1).max(100), hostname: z.string().max(255).optional(), osType: z.enum(["linux", "windows"]).default("linux"), description: z.string().max(500).optional(), }); serversRouter.get("/", asyncHandler(async (_req, res) => { const rows = await db.query.servers.findMany({ orderBy: (s, { asc }) => [asc(s.name)] }); res.json({ servers: rows.map(publicServer), // What a new install would be, so the page can say which agents are behind. agentLatest: latestAgentVersions(), }); })); serversRouter.post("/", requireRole("admin"), asyncHandler(async (req, res) => { const parsed = createServerSchema.safeParse(req.body); if (!parsed.success) { return res.status(400).json({ error: "invalid_body", details: parsed.error.flatten() }); } const { token, prefix, hash } = generateApiToken(); const [created] = await db .insert(servers) .values({ name: parsed.data.name, hostname: parsed.data.hostname, osType: parsed.data.osType, description: parsed.data.description, apiTokenHash: hash, apiTokenPrefix: prefix, }) .returning(); await recordAudit({ actor: req.currentUser!, category: "server", action: "create", targetType: "server", targetId: created.id, detail: { name: created.name }, }); const serverOut = publicServer(created); // The full token is only ever shown once, at creation time. res.status(201).json({ server: serverOut, token }); })); serversRouter.post("/:id/rotate-token", requireRole("admin"), asyncHandler(async (req, res) => { const id = Number(req.params.id); if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" }); const { token, prefix, hash } = generateApiToken(); const [updated] = await db .update(servers) .set({ apiTokenHash: hash, apiTokenPrefix: prefix }) .where(eq(servers.id, id)) .returning(); if (!updated) return res.status(404).json({ error: "not_found" }); await recordAudit({ actor: req.currentUser!, category: "server", action: "rotate_token", targetType: "server", targetId: id, detail: { name: updated.name }, }); const serverOut = publicServer(updated); res.json({ server: serverOut, token }); })); const updateServerSchema = z .object({ name: z.string().min(1).max(100).optional(), hostname: z.string().max(255).optional(), description: z.string().max(500).optional(), proxmoxIntegrationId: z.number().int().nullable().optional(), proxmoxNode: z.string().regex(ID_PATTERNS.proxmoxNode, "Not a valid Proxmox node name.").nullable().optional(), proxmoxGuestType: z.enum(["qemu", "lxc"]).nullable().optional(), proxmoxVmid: z.number().int().nullable().optional(), hideProxmoxLink: z.boolean().optional(), // The server this one runs on. Null goes back to working it out from the Proxmox node. parentServerId: z.number().int().nullable().optional(), }) .refine( (data) => { const proxmoxFields = [data.proxmoxIntegrationId, data.proxmoxNode, data.proxmoxGuestType, data.proxmoxVmid]; if (proxmoxFields.every((f) => f === undefined)) return true; const allNull = proxmoxFields.every((f) => f === null); const allSet = proxmoxFields.every((f) => f !== undefined && f !== null); return allNull || allSet; }, { message: "proxmoxIntegrationId/proxmoxNode/proxmoxGuestType/proxmoxVmid must be set together or all cleared to null" }, ); serversRouter.patch("/:id", requireRole("admin"), asyncHandler(async (req, res) => { const id = Number(req.params.id); if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" }); const parsed = updateServerSchema.safeParse(req.body); if (!parsed.success) { return res.status(400).json({ error: "invalid_body", details: parsed.error.flatten() }); } const [existing] = await db.select().from(servers).where(eq(servers.id, id)).limit(1); if (!existing) return res.status(404).json({ error: "not_found" }); if (parsed.data.proxmoxIntegrationId) { const [integration] = await db .select() .from(integrations) .where(eq(integrations.id, parsed.data.proxmoxIntegrationId)) .limit(1); if (!integration || integration.type !== "proxmox") { return res.status(400).json({ error: "invalid_proxmox_integration" }); } } if (parsed.data.parentServerId !== undefined && parsed.data.parentServerId !== null) { const parentId = parsed.data.parentServerId; const rows = await loadParentRows(); if (parentId === id || !rows.some((r) => r.id === parentId)) { return res.status(400).json({ error: "invalid_parent", message: "Choose another server that exists." }); } if (wouldLoop(rows, id, parentId)) { return res.status(400).json({ error: "parent_loop", message: "That server already runs on this one, so each would be waiting for the other." }); } } const [updated] = await db.update(servers).set(parsed.data).where(eq(servers.id, id)).returning(); await recordAudit({ actor: req.currentUser!, category: "server", action: "update", targetType: "server", targetId: id, detail: { name: updated.name, ...(parsed.data.parentServerId !== undefined ? { parentServerId: parsed.data.parentServerId } : {}) }, }); const serverOut = publicServer(updated); res.json({ server: serverOut }); })); // For the dashboard widget. Computed here, with the health monitor's own rules and the thresholds from Settings // (which viewers can't read), so the widget and the alerts always agree about what "offline" and "full" mean. serversRouter.get("/summary", asyncHandler(async (_req, res) => { const rows = await db .select({ id: servers.id, name: servers.name, osType: servers.osType, lastSeenAt: servers.lastSeenAt, disks: servers.disks }) .from(servers); const { healthChecks } = await getSettings(); res.json(buildServerSummary(rows, healthChecks, Date.now(), await activeSubjects())); })); // What every server that reports through an agent says is waiting to be installed, for the Updates page. Servers whose agent hasn't // said (it predates this, or couldn't find out) are listed with no figures rather than left out. serversRouter.get("/updates", asyncHandler(async (_req, res) => { const rows = await db .select({ id: servers.id, name: servers.name, osType: servers.osType, lastSeenAt: servers.lastSeenAt, pendingUpdates: servers.pendingUpdates, updatesPendingSince: servers.updatesPendingSince, agentVersion: servers.agentVersion, }) .from(servers) .orderBy(servers.name); res.json({ servers: rows .filter((r) => r.lastSeenAt !== null) .map((r) => ({ id: r.id, name: r.name, osType: r.osType, lastSeenAt: r.lastSeenAt, updates: parsePendingUpdates(r.pendingUpdates), pendingSince: r.updatesPendingSince, agentVersion: r.agentVersion })), agentLatest: latestAgentVersions(), }); })); // For the Operations > Admin Links page — every server's admin bookmarks in one place, instead of visiting // each server's own detail page to find them. serversRouter.get("/links", asyncHandler(async (_req, res) => { const rows = await db .select({ id: serverLinks.id, serverId: serverLinks.serverId, serverName: servers.name, serverHostname: servers.hostname, label: serverLinks.label, url: serverLinks.url, }) .from(serverLinks) .innerJoin(servers, eq(serverLinks.serverId, servers.id)) .orderBy(servers.name, serverLinks.label); res.json({ links: rows }); })); // The recent history of an agent-reported server's load, memory and disks, for the trend lines on its page. serversRouter.get("/:id/metrics", asyncHandler(async (req, res) => { const id = Number(req.params.id); if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" }); const [server] = await db.select({ id: servers.id }).from(servers).where(eq(servers.id, id)).limit(1); if (!server) return res.status(404).json({ error: "not_found" }); const requested = Number(req.query.days); const days = Number.isFinite(requested) ? Math.min(RETENTION_DAYS, Math.max(1, Math.round(requested))) : 7; res.json({ days, series: await getServerMetrics(id, days) }); })); // What has happened to a server: changes to it, the health check seeing it stop reporting or a disk fill, and its maintenance // windows. Operators and above — the audit log it draws on is theirs to read. serversRouter.get("/:id/activity", requireRole("operator"), asyncHandler(async (req, res) => { const id = Number(req.params.id); if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" }); const [server] = await db.select({ id: servers.id }).from(servers).where(eq(servers.id, id)).limit(1); if (!server) return res.status(404).json({ error: "not_found" }); res.json({ events: await getServerActivity(id) }); })); serversRouter.get("/:id/detail", asyncHandler(async (req, res) => { const id = Number(req.params.id); if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" }); const [server] = await db.select().from(servers).where(eq(servers.id, id)).limit(1); if (!server) return res.status(404).json({ error: "not_found" }); let ipAddresses: string[] = []; let hardware: Record; if (server.proxmoxIntegrationId && server.proxmoxNode && server.proxmoxGuestType && server.proxmoxVmid !== null) { const loaded = await loadIntegrationConfig(server.proxmoxIntegrationId); if (!loaded || loaded.integration.type !== "proxmox") { hardware = { source: "proxmox", error: "The linked Proxmox integration no longer exists or has changed type." }; } else { try { const adapter = createProxmoxAdapter(loaded.config as { url: string; tokenId: string; tokenSecret: string; insecure?: boolean }); const detail = await adapter.getGuestDetail( server.proxmoxNode, server.proxmoxGuestType as ProxmoxGuestType, server.proxmoxVmid, ); ipAddresses = detail.ipAddresses; hardware = { source: "proxmox", integrationId: loaded.integration.id, integrationName: loaded.integration.name, status: detail.status, cpuCores: detail.cpuCores, cpuUsagePercent: detail.cpuUsagePercent, memTotalBytes: detail.memoryBytes, memUsedBytes: detail.memUsedBytes, diskBytes: detail.diskBytes, disks: detail.disks, uptime: detail.uptime, guestAgentAvailable: detail.guestAgentAvailable, }; } catch (err) { hardware = { source: "proxmox", error: err instanceof Error ? err.message : String(err) }; } } } else if (server.cpuModel || server.cpuCores || server.memTotalBytes || server.disks) { ipAddresses = server.ipAddresses ? JSON.parse(server.ipAddresses) : []; hardware = { source: "agent", cpuModel: server.cpuModel, cpuCores: server.cpuCores, cpuLoadPercent: server.cpuLoadPercent, memTotalBytes: server.memTotalBytes, memUsedBytes: server.memUsedBytes, disks: server.disks ? JSON.parse(server.disks) : [], }; } else { hardware = { source: "none" }; } let dnsMatches: { recordName: string; recordType: string; ip: string; zoneName: string | null; providerName: string; providerType: string }[] = []; if (ipAddresses.length > 0) { dnsMatches = await db .select({ recordName: dnsRecordsCache.name, recordType: dnsRecordsCache.type, ip: dnsRecordsCache.content, zoneName: dnsZonesCache.zoneName, providerName: dnsProviders.name, providerType: dnsProviders.providerType, }) .from(dnsRecordsCache) .innerJoin(dnsProviders, eq(dnsRecordsCache.providerId, dnsProviders.id)) .leftJoin( dnsZonesCache, and(eq(dnsZonesCache.providerId, dnsRecordsCache.providerId), eq(dnsZonesCache.zoneId, dnsRecordsCache.zoneId)), ) .where(inArray(dnsRecordsCache.content, ipAddresses)); } const links = await db .select({ id: serverLinks.id, label: serverLinks.label, url: serverLinks.url }) .from(serverLinks) .where(eq(serverLinks.serverId, id)) .orderBy(serverLinks.label); const { apiTokenHash: _apiTokenHash, tags: rawTags, ipAddresses: _rawIpAddresses, disks: _rawDisks, cpuModel: _cpuModel, cpuCores: _cpuCores, cpuLoadPercent: _cpuLoadPercent, memTotalBytes: _memTotalBytes, memUsedBytes: _memUsedBytes, listeningPorts: _listeningPorts, lastPortScan: _lastPortScan, pendingUpdates: rawUpdates, ...serverOut } = server; // What this server runs on, and what runs on it (set by hand, or worked out from its Proxmox node). const parentRows = await loadParentRows(); const links2 = resolveParents(parentRows); const nameOf = new Map(parentRows.map((r) => [r.id, r.name])); const parentLink = links2.get(id); const relations = { parent: parentLink ? { id: parentLink.parentId, name: nameOf.get(parentLink.parentId) ?? "", auto: parentLink.auto } : null, children: [...links2.entries()].filter(([, l]) => l.parentId === id).map(([childId, l]) => ({ id: childId, name: nameOf.get(childId) ?? "", auto: l.auto })).sort((a, b) => a.name.localeCompare(b.name)), }; res.json({ server: { ...serverOut, tags: parseTags(rawTags), pendingUpdates: parsePendingUpdates(rawUpdates) }, ipAddresses, hardware, dnsMatches, links, relations, agentLatest: latestAgentVersions() }); })); const tagsSchema = z.object({ tags: z.array(z.string().max(100)).max(50) }); // Tags are lightweight labels, edited by operators like port notes and admin links — not admin-only like renaming a server. serversRouter.put("/:id/tags", requireRole("operator"), asyncHandler(async (req, res) => { const id = Number(req.params.id); if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" }); const parsed = tagsSchema.safeParse(req.body); if (!parsed.success) { return res.status(400).json({ error: "invalid_body", message: "Tags must be a list of text.", details: parsed.error.flatten() }); } let tags: string[]; try { tags = normalizeTags(parsed.data.tags); } catch (err) { if (err instanceof InvalidTagError) return res.status(400).json({ error: "invalid_tag", message: err.message }); throw err; } const [existing] = await db.select().from(servers).where(eq(servers.id, id)).limit(1); if (!existing) return res.status(404).json({ error: "not_found" }); await db.update(servers).set({ tags: tags.length > 0 ? JSON.stringify(tags) : null }).where(eq(servers.id, id)); await recordAudit({ actor: req.currentUser!, category: "server", action: "set_tags", targetType: "server", targetId: id, detail: { name: existing.name, before: parseTags(existing.tags), after: tags }, }); res.json({ tags }); })); const linkSchema = z.object({ label: z.string().min(1).max(60), url: z .string() .url() .refine((u) => u.startsWith("http://") || u.startsWith("https://"), { message: "URL must start with http:// or https://" }), }); serversRouter.post("/:id/links", requireRole("operator"), asyncHandler(async (req, res) => { const serverId = Number(req.params.id); if (!Number.isInteger(serverId)) return res.status(400).json({ error: "invalid_id" }); const parsed = linkSchema.safeParse(req.body); if (!parsed.success) { return res.status(400).json({ error: "invalid_body", details: parsed.error.flatten() }); } 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 [created] = await db.insert(serverLinks).values({ serverId, ...parsed.data }).returning(); await recordAudit({ actor: req.currentUser!, category: "server", action: "add_link", targetType: "server", targetId: serverId, detail: { name: server.name, label: created.label, url: created.url }, }); res.status(201).json({ link: { id: created.id, label: created.label, url: created.url } }); })); serversRouter.patch("/:id/links/:linkId", requireRole("operator"), asyncHandler(async (req, res) => { const serverId = Number(req.params.id); const linkId = Number(req.params.linkId); if (!Number.isInteger(serverId) || !Number.isInteger(linkId)) return res.status(400).json({ error: "invalid_id" }); const parsed = linkSchema.partial().safeParse(req.body); if (!parsed.success) { return res.status(400).json({ error: "invalid_body", details: parsed.error.flatten() }); } const [updated] = await db .update(serverLinks) .set(parsed.data) .where(and(eq(serverLinks.id, linkId), eq(serverLinks.serverId, serverId))) .returning(); if (!updated) return res.status(404).json({ error: "not_found" }); const [owner] = await db.select({ name: servers.name }).from(servers).where(eq(servers.id, serverId)).limit(1); await recordAudit({ actor: req.currentUser!, category: "server", action: "update_link", targetType: "server", targetId: serverId, detail: { name: owner?.name, label: updated.label, url: updated.url }, }); res.json({ link: { id: updated.id, label: updated.label, url: updated.url } }); })); serversRouter.delete("/:id/links/:linkId", requireRole("operator"), asyncHandler(async (req, res) => { const serverId = Number(req.params.id); const linkId = Number(req.params.linkId); if (!Number.isInteger(serverId) || !Number.isInteger(linkId)) return res.status(400).json({ error: "invalid_id" }); const deleted = await db .delete(serverLinks) .where(and(eq(serverLinks.id, linkId), eq(serverLinks.serverId, serverId))) .returning(); if (deleted.length === 0) return res.status(404).json({ error: "not_found" }); const [owner] = await db.select({ name: servers.name }).from(servers).where(eq(servers.id, serverId)).limit(1); await recordAudit({ actor: req.currentUser!, category: "server", action: "remove_link", targetType: "server", targetId: serverId, detail: { name: owner?.name, label: deleted[0].label, url: deleted[0].url }, }); res.status(204).end(); })); serversRouter.delete("/:id", requireRole("admin"), asyncHandler(async (req, res) => { const id = Number(req.params.id); if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" }); // Servers that ran on this one go back to working out where they run (the link is a plain column, not a foreign key). await db.update(servers).set({ parentServerId: null }).where(eq(servers.parentServerId, id)); const deleted = await db.delete(servers).where(eq(servers.id, id)).returning(); if (deleted.length === 0) return res.status(404).json({ error: "not_found" }); await recordAudit({ actor: req.currentUser!, category: "server", action: "delete", targetType: "server", targetId: id, detail: { name: deleted[0].name }, }); res.status(204).end(); }));