Show targets and status icons in the dashboard

Author: Pallavikumarimdb

messages/en-US.json

@@ -1496,5 +1496,75 @@
         "convertButton": "Convert This Node to Managed Self-Hosted"
     },
     "internationaldomaindetected": "International Domain Detected",
-    "willbestoredas": "Will be stored as:"
+    "willbestoredas": "Will be stored as:",
+    "target": "Target",
+    "checking": "Checking",
+    "resourceDisabled": "This resource is currently disabled",
+    "checkingConnection": "Checking connection status...",
+    "connectionSuccessful": "Connection successful",
+    "connectionFailed": "Connection failed - target may be unreachable",
+    "statusUnknown": "Status unknown",
+    "targetNotConfigured": "Target not configured",
+    "tcpCheck": "TCP Check",
+    "connectionStatus": "Connection Status",
+    "responseTime": "Response Time",
+    "lastChecked": "Last Checked",
+    "refreshStatus": "Refresh Status",
+    "showColumns": "Show Columns",
+    "hideColumns": "Hide Columns",
+    "columnVisibility": "Column Visibility",
+    "toggleColumn": "Toggle {columnName} column",
+    "allColumns": "All Columns",
+    "defaultColumns": "Default Columns",
+    "customizeView": "Customize View",
+    "viewOptions": "View Options",
+    "statusIndicators": "Status Indicators",
+    "quickHealthCheck": "Quick Health Check",
+    "networkConnectivity": "Network Connectivity",
+    "targetReachable": "Target is reachable",
+    "targetUnreachable": "Target is unreachable",
+    "connectivityError": "Connectivity error: {error}",
+    "checkingAllResources": "Checking all resources...",
+    "healthCheckComplete": "Health check complete",
+    "resourcesOnline": "{count} resources online",
+    "resourcesOffline": "{count} resources offline",
+    "batchStatusCheck": "Batch Status Check",
+    "runHealthCheck": "Run Health Check",
+    "autoRefresh": "Auto Refresh",
+    "manualRefresh": "Manual Refresh",
+    "refreshInterval": "Refresh Interval",
+    "statusRefreshed": "Status refreshed successfully",
+    "statusRefreshFailed": "Failed to refresh status",
+    "tcpConnectionTest": "TCP Connection Test",
+    "portConnectivity": "Port Connectivity",
+    "networkLatency": "Network Latency",
+    "ms": "ms",
+    "seconds": "seconds",
+    "timeout": "Timeout",
+    "connectionTimeout": "Connection timeout after {timeout}ms",
+    "dnsBased": "DNS-based",
+    "ipBased": "IP-based",
+    "localhost": "Localhost",
+    "remoteHost": "Remote Host",
+    "showStatusColumn": "Show status indicators for quick health visibility",
+    "showTargetColumn": "Show target destinations to see where resources point",
+    "customizeColumns": "Customize which columns are visible in the table",
+    "statusTooltip": "Click to refresh status for this resource",
+    "targetTooltip": "The destination that this resource proxies to",
+    "bulkActions": "Bulk Actions",
+    "selectAll": "Select All",
+    "selectNone": "Select None",
+    "selectedResources": "Selected Resources",
+    "enableSelected": "Enable Selected",
+    "disableSelected": "Disable Selected",
+    "checkSelectedStatus": "Check Status of Selected",
+    "exportSelected": "Export Selected",
+    "healthDashboard": "Health Dashboard",
+    "systemHealth": "System Health",
+    "resourcesHealthSummary": "Resources Health Summary",
+    "overallHealth": "Overall Health",
+    "healthy": "Healthy",
+    "degraded": "Degraded",
+    "critical": "Critical",
+    "monitoringNote": "Status indicators provide a quick TCP connectivity check refreshed when the page loads. This is not full monitoring but helps identify unreachable targets at a glance."
 }

server/auth/actions.ts

@@ -23,6 +23,8 @@ export enum ActionsEnum {
     deleteResource = "deleteResource",
     getResource = "getResource",
     listResources = "listResources",
+    tcpCheck = "tcpCheck",
+    batchTcpCheck = "batchTcpCheck",
     updateResource = "updateResource",
     createTarget = "createTarget",
     deleteTarget = "deleteTarget",

server/routers/external.ts

@@ -290,6 +290,20 @@ authenticated.get(
     resource.listResources
 );
 
+authenticated.post(
+    "/org/:orgId/resources/tcp-check",
+    verifyOrgAccess,
+    verifyUserHasAction(ActionsEnum.tcpCheck),
+    resource.tcpCheck
+);
+
+authenticated.post(
+    "/org/:orgId/resources/tcp-check-batch",
+    verifyOrgAccess,
+    verifyUserHasAction(ActionsEnum.batchTcpCheck),
+    resource.batchTcpCheck
+);
+
 authenticated.get(
     "/org/:orgId/user-resources",
     verifyOrgAccess,

server/routers/resource/index.ts

@@ -22,3 +22,4 @@ export * from "./deleteResourceRule";
 export * from "./listResourceRules";
 export * from "./updateResourceRule";
 export * from "./getUserResources";
+export * from "./tcpCheck";

server/routers/resource/listResources.ts

@@ -6,7 +6,8 @@ import {
     userResources,
     roleResources,
     resourcePassword,
-    resourcePincode
+    resourcePincode,
+    targets,
 } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -39,6 +40,51 @@ const listResourcesSchema = z.object({
         .pipe(z.number().int().nonnegative())
 });
 
+// (resource fields + a single joined target)
+type JoinedRow = {
+    resourceId: number;
+    name: string;
+    ssl: boolean;
+    fullDomain: string | null;
+    passwordId: number | null;
+    sso: boolean;
+    pincodeId: number | null;
+    whitelist: boolean;
+    http: boolean;
+    protocol: string;
+    proxyPort: number | null;
+    enabled: boolean;
+    domainId: string | null;
+
+    targetId: number | null;
+    targetIp: string | null;
+    targetPort: number | null;
+    targetEnabled: boolean | null;
+};
+
+// grouped by resource with targets[]) 
+export type ResourceWithTargets = {
+    resourceId: number;
+    name: string;
+    ssl: boolean;
+    fullDomain: string | null;
+    passwordId: number | null;
+    sso: boolean;
+    pincodeId: number | null;
+    whitelist: boolean;
+    http: boolean;
+    protocol: string;
+    proxyPort: number | null;
+    enabled: boolean;
+    domainId: string | null;
+    targets: Array<{
+        targetId: number;
+        ip: string;
+        port: number;
+        enabled: boolean;
+    }>;
+};
+
 function queryResources(accessibleResourceIds: number[], orgId: string) {
     return db
         .select({
@@ -54,7 +100,12 @@ function queryResources(accessibleResourceIds: number[], orgId: string) {
             protocol: resources.protocol,
             proxyPort: resources.proxyPort,
             enabled: resources.enabled,
-            domainId: resources.domainId
+            domainId: resources.domainId,
+
+            targetId: targets.targetId,
+            targetIp: targets.ip,
+            targetPort: targets.port,
+            targetEnabled: targets.enabled,
         })
         .from(resources)
         .leftJoin(
@@ -65,6 +116,7 @@ function queryResources(accessibleResourceIds: number[], orgId: string) {
             resourcePincode,
             eq(resourcePincode.resourceId, resources.resourceId)
         )
+        .leftJoin(targets, eq(targets.resourceId, resources.resourceId))
         .where(
             and(
                 inArray(resources.resourceId, accessibleResourceIds),
@@ -74,7 +126,7 @@ function queryResources(accessibleResourceIds: number[], orgId: string) {
 }
 
 export type ListResourcesResponse = {
-    resources: NonNullable<Awaited<ReturnType<typeof queryResources>>>;
+    resources: ResourceWithTargets[];
     pagination: { total: number; limit: number; offset: number };
 };
 
@@ -139,7 +191,7 @@ export async function listResources(
             );
         }
 
-        let accessibleResources;
+        let accessibleResources: Array<{ resourceId: number }>;
         if (req.user) {
             accessibleResources = await db
                 .select({
@@ -176,9 +228,48 @@ export async function listResources(
 
         const baseQuery = queryResources(accessibleResourceIds, orgId);
 
-        const resourcesList = await baseQuery!.limit(limit).offset(offset);
+        const rows: JoinedRow[] = await baseQuery.limit(limit).offset(offset);
+
+        // avoids TS issues with reduce/never[]
+        const map = new Map<number, ResourceWithTargets>();
+
+        for (const row of rows) {
+            let entry = map.get(row.resourceId);
+            if (!entry) {
+                entry = {
+                    resourceId: row.resourceId,
+                    name: row.name,
+                    ssl: row.ssl,
+                    fullDomain: row.fullDomain,
+                    passwordId: row.passwordId,
+                    sso: row.sso,
+                    pincodeId: row.pincodeId,
+                    whitelist: row.whitelist,
+                    http: row.http,
+                    protocol: row.protocol,
+                    proxyPort: row.proxyPort,
+                    enabled: row.enabled,
+                    domainId: row.domainId,
+                    targets: [],
+                };
+                map.set(row.resourceId, entry);
+            }
+
+            // Push target if present (left join can be null)
+            if (row.targetId != null && row.targetIp && row.targetPort != null && row.targetEnabled != null) {
+                entry.targets.push({
+                    targetId: row.targetId,
+                    ip: row.targetIp,
+                    port: row.targetPort,
+                    enabled: row.targetEnabled,
+                });
+            }
+        }
+
+        const resourcesList: ResourceWithTargets[] = Array.from(map.values());
+
         const totalCountResult = await countQuery;
-        const totalCount = totalCountResult[0].count;
+        const totalCount = totalCountResult[0]?.count ?? 0;
 
         return response<ListResourcesResponse>(res, {
             data: {