merge latest widget catalog updates

packages/api/src/router/widgets/index.ts

@@ -44,4 +44,5 @@ export const widgetRouter = createTRPCRouter({
   traefik: lazy(() => import("./traefik").then((mod) => mod.traefikRouter)),
   customApi: lazy(() => import("./custom-api").then((mod) => mod.customApiRouter)),
   secrets: lazy(() => import("./widget-secrets").then((mod) => mod.widgetSecretsRouter)),
+  wud: lazy(() => import("./wud").then((mod) => mod.wudRouter)),
 });

packages/api/src/router/widgets/wud.ts

@@ -0,0 +1,25 @@
+import { wudStatsRequestHandler } from "@homarr/request-handler/wud";
+
+import { createOneIntegrationMiddleware } from "../../middlewares/integration";
+import { createTRPCRouter, publicProcedure } from "../../trpc";
+
+export const wudRouter = createTRPCRouter({
+  getStats: publicProcedure
+    .meta({
+      mcp: {
+        enabled: true,
+        description:
+          "Returns monitored-container counts and available updates from a What's Up Docker integration. REQUIRED: integrationId from integration_all. The caller needs query permission for that integration.",
+      },
+    })
+    .concat(createOneIntegrationMiddleware("query", "wud"))
+    .query(async ({ ctx }) => {
+      const handler = wudStatsRequestHandler.handler(ctx.integration, {});
+      const { data, timestamp } = await handler.getDataAsync();
+
+      return {
+        stats: data,
+        updatedAt: timestamp,
+      };
+    }),
+});

packages/definitions/src/docs/homarr-docs-sitemap.ts

@@ -330,6 +330,7 @@ export type HomarrDocumentationPath =
   | "/docs/integrations/peanut"
   | "/docs/integrations/beszel"
   | "/docs/integrations/traefik"
+  | "/docs/integrations/whats-up-docker"
   | "/docs/widgets/clock"
   | "/docs/widgets/weather"
   | "/docs/widgets/app"
@@ -383,4 +384,5 @@ export type HomarrDocumentationPath =
   | "/docs/widgets/beszel-system-stats"
   | "/docs/widgets/traefik"
   | "/docs/widgets/custom-api"
-  | "/docs/widgets/assistant";
+  | "/docs/widgets/assistant"
+  | "/docs/widgets/whats-up-docker";

packages/definitions/src/docs/integration-doc-slugs.ts

@@ -54,5 +54,6 @@ export const integrationDocSlugs: Record<IntegrationKind, string | null> = {
   beszel: "beszel",
   traefik: "traefik",
   archiveTeamWarrior: null,
+  wud: "whats-up-docker",
   mock: null,
 };

packages/definitions/src/docs/widget-doc-slugs.ts

@@ -56,4 +56,5 @@ export const widgetDocSlugs: Record<WidgetKind, string | null> = {
   traefik: "traefik",
   customApi: "custom-api",
   assistant: "assistant",
+  wud: "whats-up-docker",
 };

packages/definitions/src/integration.ts

@@ -468,6 +468,14 @@ export const integrationDefs = {
     category: ["archiving"],
     documentationUrl: null,
   },
+  wud: {
+    name: "What's Up Docker",
+    secretKinds: [[], ["username", "password"]],
+    iconUrl: "https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons@master/svg/whats-up-docker.svg",
+    category: ["healthMonitoring"],
+    documentationUrl: createDocumentationLink("/docs/integrations/whats-up-docker"),
+    defaultPort: 3000,
+  },
   // This integration only returns mock data, it is used during development (but can also be used in production by directly going to the create page)
   mock: {
     name: "Mock",

packages/definitions/src/widget-integration-map.ts

@@ -24,7 +24,9 @@ export const widgetIntegrationSupport: Partial<Record<WidgetKind, readonly Integ
   networkControllerSummary: getIntegrationKindsByCategory("networkController"),
   networkControllerStatus: getIntegrationKindsByCategory("networkController"),
   indexerManager: getIntegrationKindsByCategory("indexerManager"),
-  healthMonitoring: getIntegrationKindsByCategory("healthMonitoring").filter((kind) => kind !== "patchmon"),
+  healthMonitoring: getIntegrationKindsByCategory("healthMonitoring").filter(
+    (kind) => kind !== "patchmon" && kind !== "wud",
+  ),
   firewall: getIntegrationKindsByCategory("firewall"),
   notifications: getIntegrationKindsByCategory("notifications"),
   mediaReleases: ["mock", "emby", "jellyfin", "plex"],
@@ -50,6 +52,7 @@ export const widgetIntegrationSupport: Partial<Record<WidgetKind, readonly Integ
   archiveTeamWarrior: ["archiveTeamWarrior"],
   anchorNote: ["anchor"],
   traefik: ["traefik"],
+  wud: ["wud"],
 };
 
 /** Widgets that remain useful without a configured integration. */

packages/definitions/src/widget.ts

@@ -54,6 +54,7 @@ export const widgetKinds = [
   "traefik",
   "customApi",
   "assistant",
+  "wud",
 ] as const;
 export type WidgetKind = (typeof widgetKinds)[number];
 

packages/integrations/src/base/creator.ts

@@ -54,6 +54,7 @@ import { UmamiIntegration } from "../umami/umami-integration";
 import { UptimeKumaIntegration } from "../uptime-kuma/uptime-kuma-integration";
 import { UnifiControllerIntegration } from "../unifi-controller/unifi-controller-integration";
 import { UnraidIntegration } from "../unraid/unraid-integration";
+import { WudIntegration } from "../wud/wud-integration";
 import type { Integration, IntegrationInput } from "./integration";
 
 export const createIntegrationAsync = async <TKind extends keyof typeof integrationCreators>(
@@ -133,6 +134,7 @@ export const integrationCreators = {
   beszel: BeszelIntegration,
   bazarr: BazarrIntegration,
   traefik: TraefikIntegration,
+  wud: WudIntegration,
 } satisfies Record<IntegrationKind, IntegrationInstance | [(input: IntegrationInput) => Promise<Integration>]>;
 
 type IntegrationInstanceOfKind<TKind extends keyof typeof integrationCreators> = {

packages/integrations/src/index.ts

@@ -1,5 +1,6 @@
 // General integrations
 export { ArchiveTeamWarriorIntegration } from "./archive-team-warrior/archive-team-warrior-integration";
+export { WudIntegration } from "./wud/wud-integration";
 export { AdGuardHomeIntegration } from "./adguard-home/adguard-home-integration";
 export { TechnitiumDnsIntegration } from "./technitium/technitium-integration";
 export { AnchorIntegration } from "./anchor/anchor-integration";
@@ -92,6 +93,7 @@ export type {
   ArchiveTeamWarriorItem,
   ArchiveTeamWarriorStatus,
 } from "./archive-team-warrior/archive-team-warrior-types";
+export type { WudStats, WudContainerUpdate } from "./wud/wud-types";
 
 // Schemas
 export { anchorNotesListInputSchema } from "./anchor/anchor-types";

packages/integrations/src/wud/test/wud-integration.spec.ts

@@ -0,0 +1,269 @@
+// @vitest-environment node
+import { ParseError } from "@homarr/common/server";
+import { Response } from "undici";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+vi.hoisted(() => {
+  process.env.SKIP_ENV_VALIDATION = "true";
+  process.env.SECRET_ENCRYPTION_KEY = "ff3f4f7ce30e870c9630de9e5d244ffa81101a24ed0dfe5f064beb53a7e684f1";
+});
+
+import { fetchWithTrustedCertificatesAsync } from "@homarr/core/infrastructure/http";
+
+import type { IntegrationTestingInput } from "../../base/integration";
+import { IntegrationParseError } from "../../base/errors/parse/integration-parse-error";
+import type { IntegrationSecret } from "../../base/types";
+import { WudIntegration } from "../wud-integration";
+
+vi.mock("@homarr/core/infrastructure/http", () => ({
+  fetchWithTrustedCertificatesAsync: vi.fn(),
+}));
+
+const TEST_URL = "https://wud.example.com";
+const TEST_USERNAME = "user";
+const TEST_PASSWORD = "p@ss";
+
+const mockFetch = vi.mocked(fetchWithTrustedCertificatesAsync);
+
+const sampleContainersResponse = [
+  {
+    id: "1",
+    name: "homeassistant",
+    displayName: "Home Assistant",
+    updateAvailable: true,
+    link: "https://github.com/home-assistant/core/releases/tag/2024.1.0",
+    image: { tag: { value: "2023.12.0" } },
+    updateKind: { remoteValue: "2024.1.0" },
+  },
+  { id: "2", name: "traefik", updateAvailable: false },
+  {
+    id: "3",
+    name: "grafana",
+    updateAvailable: true,
+    image: { tag: { value: "10.0.0" } },
+    result: { tag: "10.1.0" },
+  },
+];
+
+const sampleUpdates = [
+  {
+    id: "1",
+    name: "Home Assistant",
+    currentVersion: "2023.12.0",
+    newVersion: "2024.1.0",
+    link: "https://github.com/home-assistant/core/releases/tag/2024.1.0",
+  },
+  {
+    id: "3",
+    name: "grafana",
+    currentVersion: "10.0.0",
+    newVersion: "10.1.0",
+    link: null,
+  },
+];
+
+const createIntegration = (decryptedSecrets: IntegrationSecret[] = []) =>
+  new WudIntegration({
+    id: "test-wud",
+    name: "Test WUD",
+    url: TEST_URL,
+    externalUrl: null,
+    decryptedSecrets,
+  });
+
+const createIntegrationWithBasicAuth = () =>
+  createIntegration([
+    { kind: "username", value: TEST_USERNAME },
+    { kind: "password", value: TEST_PASSWORD },
+  ]);
+
+beforeEach(() => {
+  mockFetch.mockReset();
+});
+
+describe("WudIntegration getStatsAsync", () => {
+  test("computes total and available-update counts from the containers list", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify(sampleContainersResponse), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    const stats = await createIntegration().getStatsAsync();
+
+    expect(stats).toStrictEqual({ totalContainers: 3, updatesAvailable: 2, updates: sampleUpdates });
+  });
+
+  test("returns zero counts for an empty containers list", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify([]), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    const stats = await createIntegration().getStatsAsync();
+
+    expect(stats).toStrictEqual({ totalContainers: 0, updatesAvailable: 0, updates: [] });
+  });
+
+  test("maps container updates using displayName, falling back to result.tag and null link", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify(sampleContainersResponse), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    const stats = await createIntegration().getStatsAsync();
+
+    expect(stats.updates).toStrictEqual(sampleUpdates);
+  });
+
+  test("throws ParseError when API response is not valid JSON", async () => {
+    mockFetch.mockResolvedValue(
+      new Response("not-json", {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    await expect(createIntegration().getStatsAsync()).rejects.toSatisfy((error) => {
+      if (!(error instanceof IntegrationParseError)) return false;
+
+      const cause = error.cause;
+      return cause instanceof ParseError && cause.message.includes("Invalid WUD containers response");
+    });
+  });
+
+  test("throws ParseError when API response does not match schema", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify({ invalid: true }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    await expect(createIntegration().getStatsAsync()).rejects.toSatisfy((error) => {
+      if (!(error instanceof IntegrationParseError)) return false;
+
+      const cause = error.cause;
+      return cause instanceof ParseError && cause.message.includes("Invalid WUD containers response");
+    });
+  });
+
+  test("throws when API returns an error", async () => {
+    mockFetch.mockResolvedValue(
+      new Response("Unauthorized", {
+        status: 401,
+        headers: { "content-type": "text/plain" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    await expect(createIntegration().getStatsAsync()).rejects.toThrow();
+  });
+});
+
+describe("WudIntegration authentication", () => {
+  test("sends no Authorization header when no credentials are configured", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify(sampleContainersResponse), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    await createIntegration().getStatsAsync();
+
+    const [, requestInit] = mockFetch.mock.calls[0] ?? [];
+    const headers = (requestInit?.headers ?? {}) as Record<string, string>;
+    expect(headers.Authorization).toBeUndefined();
+  });
+
+  test("sends a Basic auth header when username and password are configured", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify(sampleContainersResponse), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    await createIntegrationWithBasicAuth().getStatsAsync();
+
+    const expected = `Basic ${Buffer.from(`${TEST_USERNAME}:${TEST_PASSWORD}`).toString("base64")}`;
+    const [url, requestInit] = mockFetch.mock.calls[0] ?? [];
+    expect(String(url)).toContain("/api/containers");
+    expect(requestInit?.headers).toMatchObject({ Authorization: expected });
+    expect(requestInit?.timeout).toBe(10_000);
+  });
+
+  test("does not send credentials over a non-HTTPS URL", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(JSON.stringify(sampleContainersResponse), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }) as unknown as Awaited<ReturnType<typeof fetchWithTrustedCertificatesAsync>>,
+    );
+
+    const integration = new WudIntegration({
+      id: "test-wud-http",
+      name: "Test WUD HTTP",
+      url: "http://wud.example.com",
+      externalUrl: null,
+      decryptedSecrets: [
+        { kind: "username", value: TEST_USERNAME },
+        { kind: "password", value: TEST_PASSWORD },
+      ],
+    });
+
+    await integration.getStatsAsync();
+
+    const [, requestInit] = mockFetch.mock.calls[0] ?? [];
+    const headers = (requestInit?.headers ?? {}) as Record<string, string>;
+    expect(headers.Authorization).toBeUndefined();
+  });
+});
+
+describe("WudIntegration testing endpoint", () => {
+  type TestingFn = (input: IntegrationTestingInput) => Promise<{ success: boolean }>;
+
+  const invokeTesting = (integration: WudIntegration, input: IntegrationTestingInput) => {
+    const testing = (integration as unknown as { testingAsync: TestingFn }).testingAsync.bind(integration);
+    return testing(input);
+  };
+
+  const makeInput = (response: Response): IntegrationTestingInput =>
+    ({
+      fetchAsync: vi.fn().mockResolvedValue(response),
+    }) as unknown as IntegrationTestingInput;
+
+  test("returns success when /api/app responds 200", async () => {
+    const input = makeInput(new Response(JSON.stringify({ name: "wud", version: "5.0.0" }), { status: 200 }));
+
+    const result = await invokeTesting(createIntegration(), input);
+
+    expect(result.success).toBe(true);
+  });
+
+  test("returns a status-code failure when /api/app responds non-OK", async () => {
+    const input = makeInput(new Response("unauthorized", { status: 401 }));
+
+    const result = await invokeTesting(createIntegration(), input);
+
+    expect(result.success).toBe(false);
+  });
+
+  test("passes the Basic auth header through to fetchAsync when configured", async () => {
+    const response = new Response(JSON.stringify({ name: "wud", version: "5.0.0" }), { status: 200 });
+    const input = makeInput(response);
+
+    await invokeTesting(createIntegrationWithBasicAuth(), input);
+
+    const fetchAsyncMock = vi.mocked(input.fetchAsync);
+    const init = fetchAsyncMock.mock.calls[0]?.[1];
+    const headers = (init?.headers ?? {}) as Record<string, string>;
+    const expected = `Basic ${Buffer.from(`${TEST_USERNAME}:${TEST_PASSWORD}`).toString("base64")}`;
+    expect(headers.Authorization).toBe(expected);
+  });
+});

packages/integrations/src/wud/wud-integration.ts

@@ -0,0 +1,68 @@
+import { Buffer } from "node:buffer";
+
+import { ParseError, ResponseError } from "@homarr/common/server";
+import { fetchWithTrustedCertificatesAsync } from "@homarr/core/infrastructure/http";
+
+import type { IntegrationTestingInput } from "../base/integration";
+import { Integration } from "../base/integration";
+import { TestConnectionError } from "../base/test-connection/test-connection-error";
+import type { TestingResult } from "../base/test-connection/test-connection-service";
+import type { WudStats } from "./wud-types";
+import { mapWudStats, parseWudContainersResponseAsync } from "./wud-types";
+
+const CONTAINERS_REQUEST_TIMEOUT_MS = 10_000;
+
+export class WudIntegration extends Integration {
+  protected async testingAsync(input: IntegrationTestingInput): Promise<TestingResult> {
+    const response = await input.fetchAsync(this.url("/api/app"), {
+      headers: this.getAuthHeaders(),
+    });
+
+    if (!response.ok) {
+      return TestConnectionError.StatusResult(response);
+    }
+
+    try {
+      await response.json();
+    } catch (error) {
+      return TestConnectionError.ParseResult(
+        new ParseError("Invalid WUD app response", {
+          cause: error instanceof Error ? error : new Error(String(error)),
+        }),
+      );
+    }
+
+    return { success: true };
+  }
+
+  public async getStatsAsync(): Promise<WudStats> {
+    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/containers"), {
+      headers: this.getAuthHeaders(),
+      timeout: CONTAINERS_REQUEST_TIMEOUT_MS,
+    });
+
+    if (!response.ok) {
+      throw new ResponseError(response);
+    }
+
+    const containers = await parseWudContainersResponseAsync(response);
+
+    return mapWudStats(containers);
+  }
+
+  private getAuthHeaders(): Record<string, string> | undefined {
+    if (!this.hasSecretValue("username") || !this.hasSecretValue("password")) {
+      return undefined;
+    }
+
+    if (this.url("/api/app").protocol !== "https:") {
+      return undefined;
+    }
+
+    const credentials = Buffer.from(`${this.getSecretValue("username")}:${this.getSecretValue("password")}`).toString(
+      "base64",
+    );
+
+    return { Authorization: `Basic ${credentials}` };
+  }
+}

packages/integrations/src/wud/wud-types.ts

@@ -0,0 +1,81 @@
+import { ParseError } from "@homarr/common/server";
+import { z } from "zod/v4";
+
+const WUD_CONTAINERS_PARSE_ERROR_MESSAGE = "Invalid WUD containers response";
+
+export const wudContainerSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  displayName: z.string().nullable().optional(),
+  updateAvailable: z.boolean(),
+  link: z.string().nullable().optional(),
+  image: z
+    .object({
+      tag: z
+        .object({
+          value: z.string().nullable().optional(),
+        })
+        .optional(),
+    })
+    .optional(),
+  updateKind: z
+    .object({
+      remoteValue: z.string().nullable().optional(),
+    })
+    .optional(),
+  result: z
+    .object({
+      tag: z.string().nullable().optional(),
+    })
+    .optional(),
+});
+
+export const wudContainersResponseSchema = z.array(wudContainerSchema);
+
+export interface WudContainerUpdate {
+  id: string;
+  name: string;
+  currentVersion: string | null;
+  newVersion: string | null;
+  link: string | null;
+}
+
+export interface WudStats {
+  totalContainers: number;
+  updatesAvailable: number;
+  updates: WudContainerUpdate[];
+}
+
+export const parseWudContainersResponseAsync = async (response: {
+  json: () => Promise<unknown>;
+}): Promise<z.infer<typeof wudContainersResponseSchema>> => {
+  let json: unknown;
+  try {
+    json = await response.json();
+  } catch (error) {
+    throw new ParseError(WUD_CONTAINERS_PARSE_ERROR_MESSAGE, {
+      cause: error instanceof Error ? error : new Error(String(error)),
+    });
+  }
+
+  const parseResult = await wudContainersResponseSchema.safeParseAsync(json);
+  if (!parseResult.success) {
+    throw new ParseError(WUD_CONTAINERS_PARSE_ERROR_MESSAGE, { cause: parseResult.error });
+  }
+
+  return parseResult.data;
+};
+
+const mapContainerUpdate = (container: z.infer<typeof wudContainerSchema>): WudContainerUpdate => ({
+  id: container.id,
+  name: container.displayName ?? container.name,
+  currentVersion: container.image?.tag?.value ?? null,
+  newVersion: container.updateKind?.remoteValue ?? container.result?.tag ?? null,
+  link: container.link ?? null,
+});
+
+export const mapWudStats = (containers: z.infer<typeof wudContainersResponseSchema>): WudStats => ({
+  totalContainers: containers.length,
+  updatesAvailable: containers.filter((container) => container.updateAvailable).length,
+  updates: containers.filter((container) => container.updateAvailable).map(mapContainerUpdate),
+});

packages/request-handler/src/health-monitoring.ts

@@ -6,7 +6,7 @@ import { createIntegrationRequestHandler } from "./lib/integration-request-handl
 
 export const systemInfoRequestHandler = createIntegrationRequestHandler<
   SystemHealthMonitoring,
-  Exclude<IntegrationKindByCategory<"healthMonitoring">, "proxmox" | "coolify" | "beszel" | "patchmon">,
+  Exclude<IntegrationKindByCategory<"healthMonitoring">, "proxmox" | "coolify" | "beszel" | "patchmon" | "wud">,
   Record<string, never>
 >({
   async requestAsync(integration, _input) {

packages/request-handler/src/wud.ts

@@ -0,0 +1,11 @@
+import { createIntegrationAsync } from "@homarr/integrations";
+import type { WudStats } from "@homarr/integrations";
+
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
+
+export const wudStatsRequestHandler = createIntegrationRequestHandler<WudStats, "wud", Record<string, never>>({
+  async requestAsync(integration) {
+    const integrationInstance = await createIntegrationAsync(integration);
+    return await integrationInstance.getStatsAsync();
+  },
+});

packages/translation/src/lang/en.json

@@ -1797,6 +1797,10 @@
       "name": "Traefik",
       "description": "Cloud-native reverse proxy and load balancer"
     },
+    "wud": {
+      "name": "What's Up Docker",
+      "description": "Monitor which of your Docker containers have image updates available"
+    },
     "paperlessNgx": {
       "name": "Paperless-ngx",
       "description": "Document management system for archiving and organizing scanned documents"
@@ -2648,6 +2652,38 @@
         "unknown": "Unknown"
       }
     },
+    "wud": {
+      "name": "What's Up Docker",
+      "description": "Show how many watched containers have updates available.",
+      "title": "What's Up Docker",
+      "monitored": "Monitored",
+      "updatesAvailable": "{count, plural, one {# update available} other {# updates available}}",
+      "updateAvailable": "Update available",
+      "openReleaseNotes": "Open release notes",
+      "option": {
+        "showTitle": {
+          "label": "Show title"
+        },
+        "showRing": {
+          "label": "Show update ring"
+        },
+        "layout": {
+          "label": "Layout",
+          "option": {
+            "horizontal": {
+              "label": "Horizontal"
+            },
+            "vertical": {
+              "label": "Vertical"
+            }
+          }
+        },
+        "showUpdateList": {
+          "label": "Show container update list",
+          "description": "Lists each monitored container that has an image update available"
+        }
+      }
+    },
     "dnsHoleSummary": {
       "name": "DNS Hole Summary",
       "description": "Displays the summary of your DNS Hole",

packages/widgets/src/catalog.ts

@@ -109,4 +109,5 @@ export const widgetCatalogIcons: Record<WidgetKind, TablerIcon> = {
   beszelSystemStats: IconChartAreaLine,
   traefik: IconRoute,
   customApi: IconApi,
+  wud: IconBrandDocker,
 };

packages/widgets/src/health-monitoring/index.ts

@@ -114,7 +114,9 @@ export const { definition, componentLoader } = createWidgetDefinition("healthMon
       },
     );
   },
-  supportedIntegrations: getIntegrationKindsByCategory("healthMonitoring").filter((kind) => kind !== "patchmon"),
+  supportedIntegrations: getIntegrationKindsByCategory("healthMonitoring").filter(
+    (kind) => kind !== "patchmon" && kind !== "wud",
+  ),
   errors: {
     INTERNAL_SERVER_ERROR: {
       icon: IconServerOff,

packages/widgets/src/index.tsx

@@ -65,6 +65,7 @@ import * as video from "./video";
 import * as weather from "./weather";
 import * as customApi from "./custom-api";
 import * as assistant from "./assistant";
+import * as wud from "./wud";
 
 export type {
   NormalizedWidgetQuery,
@@ -146,6 +147,7 @@ export const widgetImports = {
   traefik,
   customApi,
   assistant,
+  wud,
 } satisfies WidgetImportRecord;
 
 export type WidgetImports = typeof widgetImports;

packages/widgets/src/manifest.ts

@@ -77,6 +77,7 @@ const moduleLoaders: Record<WidgetKind, () => Promise<WidgetModule>> = {
   beszelSystemStats: () => import("./beszel-system-stats") as Promise<WidgetModule>,
   traefik: () => import("./traefik") as Promise<WidgetModule>,
   customApi: () => import("./custom-api") as Promise<WidgetModule>,
+  wud: () => import("./wud") as Promise<WidgetModule>,
 };
 
 // Keep these imports explicit so Turbopack can create one discoverable chunk per
@@ -139,6 +140,7 @@ const componentLoaders: Record<WidgetKind, () => Promise<WidgetComponentModule>>
   beszelSystemStats: () => import("./beszel-system-stats/component") as Promise<WidgetComponentModule>,
   traefik: () => import("./traefik/component") as Promise<WidgetComponentModule>,
   customApi: () => import("./custom-api/component") as Promise<WidgetComponentModule>,
+  wud: () => import("./wud/component") as Promise<WidgetComponentModule>,
 };
 
 const definitionPromises = new Map<WidgetKind, Promise<WidgetDefinition>>();

packages/widgets/src/refetch-intervals.ts

@@ -32,4 +32,5 @@ export const widgetQueryRefetchIntervals = [
   { queryKey: [["widget", "umami", "getTopPages"]], intervalSeconds: null },
   { queryKey: [["widget", "umami", "getTopReferrers"]], intervalSeconds: null },
   { queryKey: [["widget", "vpn"]], intervalSeconds: null },
+  { queryKey: [["widget", "wud"]], intervalSeconds: null },
 ] as const;

packages/widgets/src/wud/component.module.css

@@ -0,0 +1,7 @@
+[data-mantine-color-scheme="light"] .card {
+  background-color: var(--mantine-color-gray-1);
+}
+
+[data-mantine-color-scheme="dark"] .card {
+  background-color: var(--mantine-color-dark-7);
+}

packages/widgets/src/wud/component.tsx

@@ -0,0 +1,222 @@
+"use client";
+
+import { ActionIcon, Avatar, Badge, Card, Center, Group, RingProgress, Stack, Text, Tooltip } from "@mantine/core";
+import { IconBrandDocker, IconExternalLink, IconServer } from "@tabler/icons-react";
+import combineClasses from "clsx";
+
+import { clientApi } from "@homarr/api/client";
+import { useRequiredBoard } from "@homarr/boards/context";
+import { getIconUrl } from "@homarr/definitions";
+import type { WudContainerUpdate } from "@homarr/integrations";
+import { useScopedI18n } from "@homarr/translation/client";
+
+import { WidgetEmptyState } from "../common/empty-state";
+import type { WidgetComponentProps } from "../definition";
+import classes from "./component.module.css";
+
+export default function WudWidget({ integrationIds, options, width }: WidgetComponentProps<"wud">) {
+  const integrationId = integrationIds[0];
+  if (!integrationId) return null;
+  return <WudWidgetContent integrationId={integrationId} options={options} width={width} />;
+}
+
+const WudWidgetContent = ({
+  integrationId,
+  options,
+  width,
+}: {
+  integrationId: string;
+  options: WidgetComponentProps<"wud">["options"];
+  width: number;
+}) => {
+  const t = useScopedI18n("widget.wud");
+  const [data] = clientApi.widget.wud.getStats.useSuspenseQuery({ integrationId });
+  const board = useRequiredBoard();
+
+  const isTiny = width < 256;
+  const stats = data.stats;
+
+  if (stats.totalContainers === 0) return <WidgetEmptyState />;
+
+  const updatePercentage = Math.round((stats.updatesAvailable / stats.totalContainers) * 100);
+  const badgeColor = stats.updatesAvailable === 0 ? "green" : progressColor(updatePercentage);
+  const showUpdateList = options.showUpdateList && stats.updates.length > 0;
+
+  const ring = (
+    <RingProgress
+      roundCaps
+      size={isTiny ? 50 : 100}
+      thickness={isTiny ? 4 : 8}
+      label={
+        <Center style={{ flexDirection: "column" }}>
+          <Text size={isTiny ? "8px" : "xs"} fw={700}>
+            {updatePercentage}%
+          </Text>
+          <IconBrandDocker size={isTiny ? 8 : 16} />
+        </Center>
+      }
+      sections={[{ value: updatePercentage, color: progressColor(updatePercentage) }]}
+    />
+  );
+
+  const summary = (
+    <Stack gap={4} align={options.layout === "vertical" ? "center" : "flex-start"}>
+      <Group gap={4} wrap="nowrap">
+        <IconServer size="1rem" />
+        <Text size="xs" c="dimmed">
+          {stats.totalContainers} {t("monitored")}
+        </Text>
+      </Group>
+      <Badge color={badgeColor} variant="light">
+        {t("updatesAvailable", { count: stats.updatesAvailable })}
+      </Badge>
+    </Stack>
+  );
+
+  const tinyContent = options.showRing ? (
+    <Tooltip
+      label={
+        <Stack gap={2}>
+          <Text size="xs">
+            {stats.totalContainers} {t("monitored")}
+          </Text>
+          <Text size="xs">{t("updatesAvailable", { count: stats.updatesAvailable })}</Text>
+        </Stack>
+      }
+      events={{ hover: true, focus: true, touch: false }}
+    >
+      <Center
+        tabIndex={0}
+        aria-label={`${stats.totalContainers} ${t("monitored")}, ${t("updatesAvailable", { count: stats.updatesAvailable })}`}
+      >
+        {ring}
+      </Center>
+    </Tooltip>
+  ) : (
+    <Center>
+      <Badge color={badgeColor} variant="light">
+        {t("updatesAvailable", { count: stats.updatesAvailable })}
+      </Badge>
+    </Center>
+  );
+
+  return (
+    <Stack p="xs" gap="xs" h="100%">
+      {options.showTitle && !isTiny && (
+        <Group gap="xs" wrap="nowrap" justify="space-between" miw={0}>
+          <Group gap="xs" wrap="nowrap" miw={0}>
+            <Avatar size={20} radius="sm" src={getIconUrl("wud")} />
+            <Text size="sm" c="dimmed" lineClamp={1}>
+              {t("title")}
+            </Text>
+          </Group>
+          {stats.updatesAvailable > 0 && (
+            <Badge color={badgeColor} variant="filled" circle={stats.updatesAvailable < 10}>
+              {stats.updatesAvailable}
+            </Badge>
+          )}
+        </Group>
+      )}
+
+      {isTiny ? (
+        tinyContent
+      ) : options.layout === "horizontal" ? (
+        <Group justify="center" wrap="nowrap" gap="md">
+          {options.showRing && ring}
+          {summary}
+        </Group>
+      ) : (
+        <Stack align="center" gap="xs">
+          {options.showRing && ring}
+          {summary}
+        </Stack>
+      )}
+
+      {showUpdateList && (
+        <Stack gap={4} style={{ flex: 1, minHeight: 0, overflowY: "auto" }}>
+          {stats.updates.map((update) => (
+            <UpdateCard key={update.id} update={update} radius={board.itemRadius} className={classes.card} />
+          ))}
+        </Stack>
+      )}
+    </Stack>
+  );
+};
+
+const progressColor = (percentage: number) => {
+  if (percentage < 40) return "green";
+  else if (percentage < 60) return "yellow";
+  else if (percentage < 90) return "orange";
+  else return "red";
+};
+
+const SHA256_DIGEST_PREFIX = "sha256:";
+const SHA256_DIGEST_LENGTH = SHA256_DIGEST_PREFIX.length + 64;
+const GENERIC_MAX_LENGTH = 20;
+const GENERIC_DISPLAY_LENGTH = 17;
+
+const isDigestVersion = (value: string | null): boolean =>
+  value !== null && value.startsWith(SHA256_DIGEST_PREFIX) && value.length === SHA256_DIGEST_LENGTH;
+
+const truncateVersion = (value: string | null): string | null => {
+  if (!value) return value;
+
+  if (value.length > GENERIC_MAX_LENGTH) {
+    return `${value.slice(0, GENERIC_DISPLAY_LENGTH)}…`;
+  }
+
+  return value;
+};
+
+const buildVersionText = (currentVersion: string | null, newVersion: string | null) =>
+  currentVersion && newVersion ? `${currentVersion} → ${newVersion}` : newVersion;
+
+const UpdateCard = ({
+  update,
+  radius,
+  className,
+}: {
+  update: WudContainerUpdate;
+  radius: string | undefined;
+  className: string | undefined;
+}) => {
+  const t = useScopedI18n("widget.wud");
+  const isDigestUpdate = isDigestVersion(update.newVersion);
+  const fullVersionText = buildVersionText(update.currentVersion, update.newVersion);
+  const versionText = isDigestUpdate
+    ? t("updateAvailable")
+    : buildVersionText(truncateVersion(update.currentVersion), truncateVersion(update.newVersion));
+
+  return (
+    <Card className={combineClasses(className)} radius={radius} p="xs" style={{ overflow: "visible" }}>
+      <Group justify="space-between" wrap="nowrap" gap="xs" miw={0}>
+        <Text size="xs" fw={500} lineClamp={1} miw={0}>
+          {update.name}
+        </Text>
+        <Group gap={4} wrap="nowrap" style={{ flexShrink: 0 }}>
+          {versionText && (
+            <Tooltip label={fullVersionText} disabled={isDigestUpdate || versionText === fullVersionText}>
+              <Badge size="xs" variant="light" color="gray" style={{ whiteSpace: "nowrap" }}>
+                {versionText}
+              </Badge>
+            </Tooltip>
+          )}
+          {update.link && (
+            <ActionIcon
+              component="a"
+              href={update.link}
+              target="_blank"
+              rel="noreferrer noopener"
+              variant="subtle"
+              color="gray"
+              size="sm"
+              aria-label={t("openReleaseNotes")}
+            >
+              <IconExternalLink size="0.9rem" />
+            </ActionIcon>
+          )}
+        </Group>
+      </Group>
+    </Card>
+  );
+};

packages/widgets/src/wud/index.ts

@@ -0,0 +1,24 @@
+import { IconBrandDocker } from "@tabler/icons-react";
+
+import { createWidgetDefinition } from "../definition";
+import { optionsBuilder } from "../options";
+
+export const { definition, componentLoader } = createWidgetDefinition("wud", {
+  icon: IconBrandDocker,
+  refetchInterval: null,
+  supportedIntegrations: ["wud"],
+  createOptions() {
+    return optionsBuilder.from((factory) => ({
+      showTitle: factory.switch({ defaultValue: true }),
+      showRing: factory.switch({ defaultValue: true }),
+      layout: factory.select({
+        options: (["horizontal", "vertical"] as const).map((value) => ({
+          value,
+          label: (t) => t(`widget.wud.option.layout.option.${value}.label`),
+        })),
+        defaultValue: "horizontal",
+      }),
+      showUpdateList: factory.switch({ defaultValue: false, withDescription: true }),
+    }));
+  },
+}).withDynamicImport(() => import("./component"));