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.

app/globals.css

@@ -144,6 +144,7 @@ body {
 .pn-bento {
   display: grid;
   grid-template-columns: repeat(12, 1fr);
+  grid-auto-flow: dense;
 }
 
 @media (max-width: 860px) {

components/widgets/registry.ts

@@ -6,7 +6,6 @@ import { DockerWidget } from "./docker/Widget";
 import { DatabaseWidget } from "./database/Widget";
 import { SystemWidget } from "./system/Widget";
 import { HttpWidget } from "./http/Widget";
-import { TraefikWidget } from "./traefik/Widget";
 import { ServiceWidget } from "./service/Widget";
 
 type WidgetComponent<T extends Widget["type"]> = ComponentType<{
@@ -21,6 +20,5 @@ export const widgetRegistry: { [K in Widget["type"]]: WidgetComponent<K> } = {
   database: DatabaseWidget,
   system: SystemWidget,
   http: HttpWidget,
-  traefik: TraefikWidget,
   service: ServiceWidget,
 };

components/widgets/system/Widget.tsx

@@ -19,7 +19,7 @@ export function SystemWidget({ widget, widgetId }: { widget: SystemWidget; widge
   const errorMessage = result?.type === "error" ? result.message : null;
 
   return (
-    <WidgetCard span={5} rowSpan={2}>
+    <WidgetCard span={4} rowSpan={2}>
       <div className="text-[10px] tracking-[0.1em] text-accent uppercase">System</div>
       <span className="text-[15px] font-medium text-fg">{widget.name}</span>
       {errorMessage && <span className="text-xs text-status-down">{errorMessage}</span>}

components/widgets/traefik/Widget.tsx

@@ -1,53 +0,0 @@
-"use client";
-
-import { Lock } from "@phosphor-icons/react/ssr";
-import type { Widget } from "@/lib/config/schema";
-import { useWidgetSubscription } from "@/lib/ws/client";
-import { SkeletonLines } from "@/components/widgets/Skeleton";
-import { WidgetCard } from "@/components/widgets/WidgetCard";
-
-type TraefikWidget = Extract<Widget, { type: "traefik" }>;
-
-export function TraefikWidget({ widget, widgetId }: { widget: TraefikWidget; widgetId: string }) {
-  const result = useWidgetSubscription(widgetId);
-  const data = result?.type === "traefik" ? result.data : null;
-  const errorMessage = result?.type === "error" ? result.message : null;
-
-  return (
-    <WidgetCard span={4}>
-      <div className="flex items-center justify-between">
-        <span className="text-[15px] font-medium text-fg">{widget.name}</span>
-        {data && (
-          <span className="font-mono text-[11px] tabular-nums text-fg-muted">
-            {data.entrypoints.map((ep) => ep.address).join(" · ") || `${data.entrypoints.length} entrypoints`}
-          </span>
-        )}
-      </div>
-      {errorMessage && <span className="text-xs text-status-down">{errorMessage}</span>}
-      {!result && !errorMessage && <SkeletonLines count={3} />}
-      {data && (
-        <div className="flex flex-col">
-          {data.routers.map((router) => (
-            <div key={router.name} className="flex items-center justify-between gap-2 border-t border-border py-1.5 text-[13px] first:border-t-0">
-              <span className="truncate text-fg" title={router.rule}>
-                {router.name.replace(/@.*$/, "")}
-              </span>
-              <span className="flex items-center gap-1.5 text-[11px] text-fg-muted">
-                {router.tls && <Lock size={11} aria-label="TLS enabled" />}
-                <span
-                  className={`flex items-center gap-1.5 ${router.status === "enabled" ? "text-status-up" : "text-status-down"}`}
-                >
-                  <span className="h-1.5 w-1.5 rounded-full bg-current" />
-                  {router.status}
-                </span>
-              </span>
-            </div>
-          ))}
-          <span className="pt-2 text-[11px] text-fg-muted">
-            <span className="font-mono tabular-nums">{data.middlewaresCount}</span> middlewares
-          </span>
-        </div>
-      )}
-    </WidgetCard>
-  );
-}

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/coolify.ts

@@ -8,23 +8,33 @@ interface CoolifyProject {
   name: string;
 }
 
-export async function collectCoolify(
-  widget: CoolifyServiceWidget
-): Promise<{ stats: ServiceStat[]; detail?: string[] }> {
-  const base = serviceBaseUrl(widget);
-  const response = await fetch(`${base}/api/v1/projects`, {
-    headers: { Authorization: `Bearer ${widget.apiToken}` },
+async function fetchCoolify<T>(base: string, path: string, apiToken: string): Promise<T> {
+  const response = await fetch(`${base}${path}`, {
+    headers: { Authorization: `Bearer ${apiToken}` },
     signal: AbortSignal.timeout(5_000),
   });
   if (!response.ok) {
     throw new Error(`Coolify API returned ${response.status}`);
   }
-  const projects = (await response.json()) as CoolifyProject[];
+  return (await response.json()) as T;
+}
+
+export async function collectCoolify(
+  widget: CoolifyServiceWidget
+): Promise<{ stats: ServiceStat[]; detail?: string[] }> {
+  const base = serviceBaseUrl(widget);
+  const [projects, resources] = await Promise.all([
+    fetchCoolify<CoolifyProject[]>(base, "/api/v1/projects", widget.apiToken),
+    fetchCoolify<unknown[]>(base, "/api/v1/resources", widget.apiToken),
+  ]);
   const names = projects.slice(0, DETAIL_LIMIT).map((p) => p.name);
   if (projects.length > DETAIL_LIMIT) names.push(`+${projects.length - DETAIL_LIMIT} more`);
 
   return {
-    stats: [{ label: "Projects", value: String(projects.length) }],
+    stats: [
+      { label: "Projects", value: String(projects.length) },
+      { label: "Resources", value: String(resources.length) },
+    ],
     detail: names.length > 0 ? names : undefined,
   };
 }

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,
-  };
-}

lib/config/schema.ts

@@ -58,13 +58,6 @@ export const httpWidgetSchema = z.object({
     .default({ status: 200 }),
 });
 
-export const traefikWidgetSchema = z.object({
-  type: z.literal("traefik"),
-  name: z.string().default("Traefik"),
-  apiUrl: z.string().url(),
-  interval: durationSchema.default("15s"),
-});
-
 const serviceCommonFields = {
   type: z.literal("service") as z.ZodLiteral<"service">,
   name: z.string(),
@@ -114,6 +107,11 @@ export const headscaleServiceWidgetSchema = z.object({
   apiToken: z.string(),
 });
 
+export const traefikServiceWidgetSchema = z.object({
+  ...serviceCommonFields,
+  service: z.literal("traefik"),
+});
+
 export const serviceWidgetSchema = z.discriminatedUnion("service", [
   giteaServiceWidgetSchema,
   coolifyServiceWidgetSchema,
@@ -121,6 +119,7 @@ export const serviceWidgetSchema = z.discriminatedUnion("service", [
   n8nServiceWidgetSchema,
   umamiServiceWidgetSchema,
   headscaleServiceWidgetSchema,
+  traefikServiceWidgetSchema,
 ]);
 
 export const widgetSchema = z.discriminatedUnion("type", [
@@ -130,7 +129,6 @@ export const widgetSchema = z.discriminatedUnion("type", [
   databaseWidgetSchema,
   systemWidgetSchema,
   httpWidgetSchema,
-  traefikWidgetSchema,
   serviceWidgetSchema,
 ]);
 
@@ -192,3 +190,4 @@ export type ImmichServiceWidget = z.infer<typeof immichServiceWidgetSchema>;
 export type N8nServiceWidget = z.infer<typeof n8nServiceWidgetSchema>;
 export type UmamiServiceWidget = z.infer<typeof umamiServiceWidgetSchema>;
 export type HeadscaleServiceWidget = z.infer<typeof headscaleServiceWidgetSchema>;
+export type TraefikServiceWidget = z.infer<typeof traefikServiceWidgetSchema>;

lib/types/traefik-result.ts

@@ -1,19 +0,0 @@
-export interface TraefikRouterInfo {
-  name: string;
-  rule: string;
-  service: string;
-  status: string;
-  tls: boolean;
-  entryPoints: string[];
-}
-
-export interface TraefikEntrypointInfo {
-  name: string;
-  address: string;
-}
-
-export interface TraefikResult {
-  routers: TraefikRouterInfo[];
-  entrypoints: TraefikEntrypointInfo[];
-  middlewaresCount: number;
-}

lib/types/widget-result.ts

@@ -1,6 +1,5 @@
 import type { SystemResult } from "./system-result";
 import type { HttpCheckResult } from "./http-result";
-import type { TraefikResult } from "./traefik-result";
 import type { ServiceWidgetResult } from "./service-result";
 
 export interface DockerContainerResult {
@@ -20,6 +19,5 @@ export type WidgetResult =
   | { type: "database"; data: DockerContainerResult }
   | { type: "system"; data: SystemResult }
   | { type: "http"; data: HttpCheckResult }
-  | { type: "traefik"; data: TraefikResult }
   | { type: "service"; data: ServiceWidgetResult }
   | { type: "error"; message: string };