feat: fold traefik into the service widget type, remove the dedicated one

Traefik gets the same treatment as the other six services now instead
of a bespoke widget type: docker health merged with a single "Routes"
stat, via the same internal container-to-container API call
(http://traefik:8080/api/http/routers) it already used. No auth
needed, same as before.

Deleted lib/collectors/traefik.ts, lib/types/traefik-result.ts, and
components/widgets/traefik/ entirely - the generic service Widget.tsx
and ServiceWidgetResult shape cover it with zero new component code.

lib/collectors/scheduler.ts

@@ -5,7 +5,6 @@ import { parseDuration } from "@/lib/config/duration";
 import { collectDockerContainer, dockerLimit } from "./docker";
 import { collectSystem } from "./system";
 import { collectHttp } from "./http";
-import { collectTraefik } from "./traefik";
 import { collectService } from "./service";
 import type { WidgetResult } from "@/lib/types/widget-result";
 
@@ -20,14 +19,7 @@ interface Job {
   consecutiveFailures: number;
 }
 
-const COLLECTOR_TYPES = new Set<Widget["type"]>([
-  "docker",
-  "database",
-  "system",
-  "http",
-  "traefik",
-  "service",
-]);
+const COLLECTOR_TYPES = new Set<Widget["type"]>(["docker", "database", "system", "http", "service"]);
 
 function isCollectorWidget(widget: Widget): boolean {
   return COLLECTOR_TYPES.has(widget.type);
@@ -39,7 +31,6 @@ function getIntervalMs(widget: Widget): number {
     widget.type === "database" ||
     widget.type === "system" ||
     widget.type === "http" ||
-    widget.type === "traefik" ||
     widget.type === "service"
   ) {
     return parseDuration(widget.interval);
@@ -60,9 +51,6 @@ function sameTarget(a: Widget, b: Widget): boolean {
   if (a.type === "http" && b.type === "http") {
     return a.url === b.url && a.method === b.method && a.expect.status === b.expect.status;
   }
-  if (a.type === "traefik" && b.type === "traefik") {
-    return a.apiUrl === b.apiUrl;
-  }
   if (a.type === "service" && b.type === "service") {
     return a.containerName === b.containerName && a.service === b.service && a.showStats === b.showStats;
   }
@@ -88,10 +76,6 @@ async function collect(widget: Widget): Promise<WidgetResult> {
     );
     return { type: "http", data: { ...data, consecutiveFailures: 0 } };
   }
-  if (widget.type === "traefik") {
-    const data = await collectTraefik(widget.apiUrl);
-    return { type: "traefik", data };
-  }
   if (widget.type === "service") {
     const data = await collectService(widget);
     return { type: "service", data };

lib/collectors/service.ts

@@ -7,6 +7,7 @@ import { collectImmich } from "./services/immich";
 import { collectN8n } from "./services/n8n";
 import { collectUmami } from "./services/umami";
 import { collectHeadscale } from "./services/headscale";
+import { collectTraefikStat } from "./services/traefik";
 
 function collectServiceStat(widget: ServiceWidget): Promise<{ stats: ServiceStat[]; detail?: string[] }> {
   switch (widget.service) {
@@ -22,6 +23,8 @@ function collectServiceStat(widget: ServiceWidget): Promise<{ stats: ServiceStat
       return collectUmami(widget);
     case "headscale":
       return collectHeadscale(widget);
+    case "traefik":
+      return collectTraefikStat(widget);
   }
 }
 

lib/collectors/services/base-url.ts

@@ -7,6 +7,7 @@ const SERVICE_PORTS: Record<ServiceWidget["service"], number> = {
   n8n: 5678,
   umami: 3000,
   headscale: 8080,
+  traefik: 8080,
 };
 
 export function serviceBaseUrl(widget: ServiceWidget): string {

lib/collectors/services/traefik.ts

@@ -0,0 +1,17 @@
+import type { TraefikServiceWidget } from "@/lib/config/schema";
+import type { ServiceStat } from "@/lib/types/service-result";
+import { serviceBaseUrl } from "./base-url";
+
+interface RawRouter {
+  status: string;
+}
+
+export async function collectTraefikStat(widget: TraefikServiceWidget): Promise<{ stats: ServiceStat[] }> {
+  const base = serviceBaseUrl(widget);
+  const response = await fetch(`${base}/api/http/routers`, { signal: AbortSignal.timeout(5_000) });
+  if (!response.ok) {
+    throw new Error(`Traefik API returned ${response.status}`);
+  }
+  const routers = (await response.json()) as RawRouter[];
+  return { stats: [{ label: "Routes", value: String(routers.length) }] };
+}

lib/collectors/traefik.ts

@@ -1,48 +0,0 @@
-import type { TraefikResult } from "@/lib/types/traefik-result";
-
-interface RawRouter {
-  name: string;
-  rule: string;
-  service: string;
-  status: string;
-  tls?: unknown;
-  entryPoints?: string[];
-}
-
-interface RawEntrypoint {
-  name: string;
-  address: string;
-}
-
-async function fetchJson<T>(url: string): Promise<T | null> {
-  const response = await fetch(url, { signal: AbortSignal.timeout(5_000) });
-  if (!response.ok) return null;
-  return (await response.json()) as T;
-}
-
-export async function collectTraefik(apiUrl: string): Promise<TraefikResult> {
-  const base = apiUrl.replace(/\/$/, "");
-
-  const [routers, entrypoints, middlewares] = await Promise.all([
-    fetchJson<RawRouter[]>(`${base}/http/routers`),
-    fetchJson<RawEntrypoint[]>(`${base}/entrypoints`),
-    fetchJson<unknown[]>(`${base}/http/middlewares`),
-  ]);
-
-  if (routers === null) {
-    throw new Error(`Traefik API at ${base}/http/routers is unreachable or returned an error`);
-  }
-
-  return {
-    routers: routers.map((router) => ({
-      name: router.name,
-      rule: router.rule,
-      service: router.service,
-      status: router.status,
-      tls: Boolean(router.tls),
-      entryPoints: router.entryPoints ?? [],
-    })),
-    entrypoints: (entrypoints ?? []).map((ep) => ({ name: ep.name, address: ep.address })),
-    middlewaresCount: middlewares?.length ?? 0,
-  };
-}