Just use the targetHealthCheckId as the id

server/lib/blueprints/proxyResources.ts

@@ -141,6 +141,7 @@ export async function updateProxyResources(
                 .insert(targetHealthCheck)
                 .values({
                     name: `${targetData.hostname}:${targetData.port}`,
+                    siteId: site.siteId,
                     targetId: newTarget.targetId,
                     orgId: orgId,
                     hcEnabled: healthcheckData?.enabled || false,

server/routers/newt/buildConfiguration.ts

@@ -21,7 +21,6 @@ import {
     generateSubnetProxyTargetV2,
     SubnetProxyTargetV2
 } from "@server/lib/ip";
-import { supportsTargetHealthChecksV2 } from "./targets";
 
 export async function buildClientConfigurationForNewtClient(
     site: Site,
@@ -232,12 +231,7 @@ export async function buildTargetConfigurationForNewtClient(
             hcUnhealthyThreshold: targetHealthCheck.hcUnhealthyThreshold
         })
         .from(targetHealthCheck)
-        .where(
+        .where(eq(targetHealthCheck.siteId, siteId));
-            and(
-                eq(targetHealthCheck.siteId, siteId),
-                eq(targetHealthCheck.hcEnabled, true)
-            )
-        );
 
     const { tcpTargets, udpTargets } = allTargets.reduce(
         (acc, target) => {
@@ -285,9 +279,7 @@ export async function buildTargetConfigurationForNewtClient(
         }
 
         return {
-            id: supportsTargetHealthChecksV2(version)
+            id: target.targetHealthCheckId,
-                ? target.targetId
-                : target.targetHealthCheckId,
             hcEnabled: target.hcEnabled,
             hcPath: target.hcPath,
             hcScheme: target.hcScheme,

server/routers/newt/targets.ts

@@ -2,15 +2,6 @@ import { Target, TargetHealthCheck } from "@server/db";
 import { sendToClient } from "#dynamic/routers/ws";
 import logger from "@server/logger";
 import { canCompress } from "@server/lib/clientVersionChecks";
-import semver from "semver";
-
-const NEWT_V2_TARGET_HEALTH_CHECK_VERSION = ">=1.12.0";
-
-export function supportsTargetHealthChecksV2(version?: string | null) {
-    return version
-        ? semver.satisfies(version, NEWT_V2_TARGET_HEALTH_CHECK_VERSION)
-        : false;
-}
 
 export async function addTargets(
     newtId: string,
@@ -92,9 +83,7 @@ export async function addTargets(
         }
 
         return {
-            id: supportsTargetHealthChecksV2(version)
+            id: hc.targetHealthCheckId,
-                ? target.targetId
-                : hc.targetHealthCheckId,
             hcEnabled: hc.hcEnabled,
             hcPath: hc.hcPath,
             hcScheme: hc.hcScheme,

server/routers/target/handleHealthcheckStatusMessage.ts

@@ -14,7 +14,6 @@ import {
     fireHealthCheckHealthyAlert,
     fireHealthCheckNotHealthyAlert
 } from "#dynamic/lib/alerts";
-import { supportsTargetHealthChecksV2 } from "@server/routers/newt/targets";
 
 interface TargetHealthStatus {
     status: string;
@@ -74,8 +73,6 @@ export const handleHealthcheckStatusMessage: MessageHandler = async (
         let successCount = 0;
         let errorCount = 0;
 
-        const isV2 = supportsTargetHealthChecksV2(newt.version);
-
         // Process each target status update
         for (const [targetId, healthStatus] of Object.entries(data.targets)) {
             logger.debug(
@@ -91,78 +88,34 @@ export const handleHealthcheckStatusMessage: MessageHandler = async (
                 continue;
             }
 
-            let targetCheck: {
+            const [targetCheck] = await db
-                targetId: number;
+                .select({
-                siteId: number | null;
+                    targetId: targets.targetId,
-                orgId: string | null;
+                    siteId: targets.siteId,
-                targetHealthCheckId: number;
+                    orgId: targetHealthCheck.orgId,
-                resourceOrgId: string | null;
+                    targetHealthCheckId: targetHealthCheck.targetHealthCheckId,
-                resourceId: number | null;
+                    resourceOrgId: resources.orgId,
-                name: string | null;
+                    resourceId: resources.resourceId,
-                hcStatus: string | null;
+                    name: targetHealthCheck.name,
-            } | undefined;
+                    hcStatus: targetHealthCheck.hcHealth
-
+                })
-            if (isV2) {
+                .from(targetHealthCheck)
-                // New newt (>= 1.12.0): the key is the targetId
+                .innerJoin(
-                [targetCheck] = await db
+                    targets,
-                    .select({
+                    eq(targetHealthCheck.targetId, targets.targetId)
-                        targetId: targets.targetId,
+                )
-                        siteId: targets.siteId,
+                .innerJoin(
-                        orgId: targetHealthCheck.orgId,
+                    resources,
-                        targetHealthCheckId: targetHealthCheck.targetHealthCheckId,
+                    eq(targets.resourceId, resources.resourceId)
-                        resourceOrgId: resources.orgId,
+                )
-                        resourceId: resources.resourceId,
+                .innerJoin(sites, eq(targets.siteId, sites.siteId))
-                        name: targetHealthCheck.name,
+                .where(
-                        hcStatus: targetHealthCheck.hcHealth
+                    and(
-                    })
+                        eq(targetHealthCheck.targetHealthCheckId, targetIdNum),
-                    .from(targets)
+                        eq(sites.siteId, newt.siteId)
-                    .innerJoin(
-                        resources,
-                        eq(targets.resourceId, resources.resourceId)
                     )
-                    .innerJoin(sites, eq(targets.siteId, sites.siteId))
+                )
-                    .innerJoin(
+                .limit(1);
-                        targetHealthCheck,
-                        eq(targets.targetId, targetHealthCheck.targetId)
-                    )
-                    .where(
-                        and(
-                            eq(targets.targetId, targetIdNum),
-                            eq(sites.siteId, newt.siteId)
-                        )
-                    )
-                    .limit(1);
-            } else {
-                // Old newt (< 1.12.0): the key is the targetHealthCheckId
-                [targetCheck] = await db
-                    .select({
-                        targetId: targets.targetId,
-                        siteId: targets.siteId,
-                        orgId: targetHealthCheck.orgId,
-                        targetHealthCheckId: targetHealthCheck.targetHealthCheckId,
-                        resourceOrgId: resources.orgId,
-                        resourceId: resources.resourceId,
-                        name: targetHealthCheck.name,
-                        hcStatus: targetHealthCheck.hcHealth
-                    })
-                    .from(targetHealthCheck)
-                    .innerJoin(
-                        targets,
-                        eq(targetHealthCheck.targetId, targets.targetId)
-                    )
-                    .innerJoin(
-                        resources,
-                        eq(targets.resourceId, resources.resourceId)
-                    )
-                    .innerJoin(sites, eq(targets.siteId, sites.siteId))
-                    .where(
-                        and(
-                            eq(targetHealthCheck.targetHealthCheckId, targetIdNum),
-                            eq(sites.siteId, newt.siteId)
-                        )
-                    )
-                    .limit(1);
-            }
 
             if (!targetCheck) {
                 logger.warn(