fix(admin): address review feedback

Broadcast newly persisted NIP-66 events, prefer relay_url in bootstrap
relay list, clamp frequency tags to the worker minimum, add bootstrap TTL,
and complete Network Health dashboard coverage for issue #698.

Author: Ferryx349

.changeset/admin-network-health-panel.md

@@ -4,4 +4,4 @@
 
 feat(admin): add Network Health panel to observability dashboard
 
-Adds GET `/admin/network-health` and a dashboard section that displays the latest NIP-66 external probe snapshot alongside live KPI metrics.
+Adds a dashboard section that renders the latest NIP-66 probe snapshot with per-target DNS, TLS, WebSocket RTT, and NIP-11 status.

resources/admin/assets/dashboard.css

@@ -765,14 +765,35 @@
   padding: 0.85rem 1rem;
 }
 
+.network-health-target-header {
+  align-items: flex-start;
+  display: flex;
+  gap: 0.65rem;
+  justify-content: space-between;
+  margin-bottom: 0.65rem;
+}
+
 .network-health-target-url {
   color: var(--text);
+  flex: 1;
   font-size: 0.85rem;
   font-weight: 600;
-  margin-bottom: 0.65rem;
+  margin-bottom: 0;
   word-break: break-all;
 }
 
+.network-health-network-type {
+  background: var(--panel-border);
+  border: 1px solid var(--panel-border);
+  color: var(--label);
+  font-size: 0.62rem;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  padding: 0.15rem 0.4rem;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+
 .network-health-checks {
   display: grid;
   gap: 0.45rem;

resources/admin/assets/dashboard.js

@@ -385,8 +385,12 @@
     networkHealthSync.innerHTML = `<span class="prompt-char">&gt;</span> probes: ${message}`
   }
 
-  const probeCheckStatusClass = (status) => {
+  const probeCheckStatusClass = (status, options = {}) => {
     if (status === 'ok') {
+      if (typeof options.tlsDaysUntilExpiry === 'number' && options.tlsDaysUntilExpiry < 14) {
+        return 'status-degraded'
+      }
+
       return 'status-ok'
     }
     if (status === 'error') {
@@ -396,13 +400,14 @@
     return 'status-no-data'
   }
 
-  const formatProbeCheckDetail = (check, formatter) => {
+  const formatProbeCheckDetail = (check, formatter, options = {}) => {
     const label = statusLabels.probeCheck[check?.status] ?? statusLabels.probeCheck.skipped
     const detail = typeof formatter === 'function' && check?.status === 'ok' ? formatter(check.data) : check?.error
+    const className = probeCheckStatusClass(check?.status, options)
 
     return {
       label,
-      className: probeCheckStatusClass(check?.status),
+      className,
       detail: detail ? String(detail) : '',
     }
   }
@@ -458,31 +463,78 @@
       const card = document.createElement('article')
       card.className = 'network-health-target'
 
+      const header = document.createElement('div')
+      header.className = 'network-health-target-header'
+
       const title = document.createElement('p')
       title.className = 'network-health-target-url mb-0'
       title.textContent = result?.target?.relayUrl ?? result?.target?.wsUrl ?? 'Unknown target'
-      card.appendChild(title)
+      header.appendChild(title)
+
+      const networkType = result?.target?.networkType
+      if (networkType) {
+        const badge = document.createElement('span')
+        badge.className = 'network-health-network-type'
+        badge.textContent = networkType
+        header.appendChild(badge)
+      }
+
+      card.appendChild(header)
 
       const checks = document.createElement('div')
       checks.className = 'network-health-checks'
 
       const dns = formatProbeCheckDetail(result.dns, (data) => {
-        const count = Array.isArray(data?.records) ? data.records.length : 0
-        return `${count} record${count === 1 ? '' : 's'}`
-      })
-      const tls = formatProbeCheckDetail(result.tls, (data) => {
-        if (typeof data?.daysUntilExpiry === 'number') {
-          return `${data.daysUntilExpiry}d remaining`
+        const records = Array.isArray(data?.records) ? data.records : []
+
+        if (records.length === 0) {
+          return 'no records'
         }
 
-        return data?.issuer ?? 'valid'
+        const preview = records.slice(0, 3).map((record) => {
+          const ttl = typeof record?.ttl === 'number' ? ` TTL ${record.ttl}` : ''
+          return `${record.type} ${record.value}${ttl}`
+        })
+
+        if (records.length > 3) {
+          preview.push(`+${records.length - 3} more`)
+        }
+
+        return preview.join('; ')
       })
+      const tlsDaysUntilExpiry =
+        result.tls?.status === 'ok' && typeof result.tls?.data?.daysUntilExpiry === 'number'
+          ? result.tls.data.daysUntilExpiry
+          : undefined
+      const tls = formatProbeCheckDetail(
+        result.tls,
+        (data) => {
+          if (typeof data?.daysUntilExpiry === 'number') {
+            return `${data.daysUntilExpiry}d remaining`
+          }
+
+          return data?.issuer ?? 'valid'
+        },
+        { tlsDaysUntilExpiry },
+      )
       const wsRtt = formatProbeCheckDetail(result.wsRtt, (data) => `${data.rttOpenMs} ms`)
       const nip11 = formatProbeCheckDetail(result.nip11, (data) => {
         const name = data?.name ? ` ${data.name}` : ''
-        return `HTTP ${data.statusCode}${name}`
+        const supportedNips = Array.isArray(data?.supportedNips) ? data.supportedNips : null
+        const nip66Warning =
+          supportedNips && !supportedNips.includes(66) ? ' · NIP-66 not in supported_nips' : ''
+
+        return `HTTP ${data.statusCode}${name}${nip66Warning}`
       })
 
+      if (
+        result.nip11?.status === 'ok' &&
+        Array.isArray(result.nip11?.data?.supportedNips) &&
+        !result.nip11.data.supportedNips.includes(66)
+      ) {
+        nip11.className = 'status-degraded'
+      }
+
       ;[
         ['DNS', dns],
         ['TLS', tls],

src/app/relay-monitor-worker.ts

@@ -6,14 +6,12 @@ import { INip66EventPublisher } from '../services/nip66-event-publisher'
 import { shutdownMetricsTelemetry } from '../telemetry/metrics'
 import { filterValidProbeTargets, resolveProbeTargets } from '../utils/relay-probe-targets'
 import { deriveRelayProbeRunStatus, serializeProbeResults } from '../utils/relay-probe-snapshot'
+import { getEffectiveProbeIntervalSeconds, getProbeIntervalMs } from '../utils/nip66-schedule'
 import { runProbe } from '../utils/relay-probe'
 import { ProbeOptions, ProbeResult } from '../utils/relay-probe/types'
 
 const logger = createLogger('relay-monitor-worker')
 
-const DEFAULT_PROBE_INTERVAL_SECONDS = 3600
-const MIN_PROBE_INTERVAL_SECONDS = 60
-
 export type RunProbeFn = (relayUrl: string, options?: ProbeOptions) => Promise<ProbeResult>
 
 export const buildProbeOptions = (settings: Settings): ProbeOptions => {
@@ -25,12 +23,7 @@ export const buildProbeOptions = (settings: Settings): ProbeOptions => {
   }
 }
 
-export const getProbeIntervalMs = (settings: Settings): number => {
-  const configured = settings.nip66?.probeIntervalSeconds ?? DEFAULT_PROBE_INTERVAL_SECONDS
-  const intervalSeconds = Math.max(configured, MIN_PROBE_INTERVAL_SECONDS)
-
-  return intervalSeconds * 1000
-}
+export { getProbeIntervalMs } from '../utils/nip66-schedule'
 
 export class RelayMonitorWorker implements IRunnable {
   private interval: NodeJS.Timeout | undefined
@@ -130,10 +123,7 @@ export class RelayMonitorWorker implements IRunnable {
       status: deriveRelayProbeRunStatus(results),
     }
 
-    const expirySeconds = Math.max(
-      (currentSettings.nip66?.probeIntervalSeconds ?? DEFAULT_PROBE_INTERVAL_SECONDS) * 2,
-      MIN_PROBE_INTERVAL_SECONDS * 2,
-    )
+    const expirySeconds = getEffectiveProbeIntervalSeconds(currentSettings) * 2
 
     await this.snapshotStore.saveLatest(snapshot, expirySeconds)
     logger('saved probe snapshot for %d target(s) with status %s', valid.length, snapshot.status)

src/services/nip66-event-publisher.ts

@@ -1,11 +1,11 @@
 import { ICacheAdapter } from '../@types/adapters'
-import { ParameterizedReplaceableEvent, UnidentifiedEvent } from '../@types/event'
+import { Event, ParameterizedReplaceableEvent, UnidentifiedEvent } from '../@types/event'
 import { RelayProbeRunSnapshot } from '../@types/relay-probe-snapshot'
 import { IEventRepository } from '../@types/repositories'
 import { Settings } from '../@types/settings'
 import { EventDeduplicationMetadataKey, EventTags } from '../constants/base'
 import { createLogger } from '../factories/logger-factory'
-import { getPublicKey, identifyEvent, isParameterizedReplaceableEvent, signEvent } from '../utils/event'
+import { broadcastEvent, getPublicKey, identifyEvent, isParameterizedReplaceableEvent, signEvent } from '../utils/event'
 import { getMonitorPrivateKey } from '../utils/monitor-identity'
 import {
   buildMonitorAnnouncementEvent,
@@ -18,6 +18,7 @@ import { resolveProbeTargets } from '../utils/relay-probe-targets'
 const logger = createLogger('nip66-event-publisher')
 
 export const NIP66_MONITOR_BOOTSTRAPPED_KEY = 'nip66:monitor:bootstrapped'
+export const NIP66_MONITOR_BOOTSTRAP_TTL_SECONDS = 30 * 24 * 60 * 60
 
 export interface INip66EventPublisher {
   publishAfterProbe(snapshot: RelayProbeRunSnapshot, settings: Settings): Promise<void>
@@ -63,32 +64,40 @@ export class Nip66EventPublisher implements INip66EventPublisher {
       return
     }
 
-    const relayUrl = resolveProbeTargets(settings)[0] ?? settings.info.relay_url
+    const relayUrl = settings.info?.relay_url?.trim() || resolveProbeTargets(settings)[0]
+
+    if (!relayUrl) {
+      logger.warn('no relay URL available for NIP-66 bootstrap relay list; skipping kind 10002 publish')
+      return
+    }
 
     await this.persistSignedEvent(buildMonitorProfileEvent(monitorPubkey, createdAt), privkey)
     await this.persistSignedEvent(buildMonitorRelayListEvent(relayUrl, monitorPubkey, createdAt), privkey)
 
-    await this.cache.setKey(NIP66_MONITOR_BOOTSTRAPPED_KEY, monitorPubkey)
+    await this.cache.setKey(NIP66_MONITOR_BOOTSTRAPPED_KEY, monitorPubkey, NIP66_MONITOR_BOOTSTRAP_TTL_SECONDS)
     logger('bootstrapped NIP-66 monitor identity for pubkey %s', monitorPubkey)
   }
 
   private async persistSignedEvent(unsigned: UnidentifiedEvent, privkey: string): Promise<void> {
     const signed = await signEvent(privkey)(await identifyEvent(unsigned))
+    let count: number
 
     if (isParameterizedReplaceableEvent(signed)) {
       const [, deduplication] = signed.tags.find((tag) => tag.length >= 2 && tag[0] === EventTags.Deduplication) ?? [
         null,
         '',
       ]
 
-      await this.eventRepository.upsert({
+      count = await this.eventRepository.upsert({
         ...signed,
         [EventDeduplicationMetadataKey]: deduplication ? [deduplication] : [''],
       } as ParameterizedReplaceableEvent)
-
-      return
+    } else {
+      count = await this.eventRepository.upsert(signed as Event)
     }
 
-    await this.eventRepository.upsert(signed)
+    if (count) {
+      await broadcastEvent(signed)
+    }
   }
 }

src/utils/nip66-events.ts

@@ -3,6 +3,7 @@ import { Tag } from '../@types/base'
 import { StoredProbeResult } from '../@types/relay-probe-snapshot'
 import { Settings } from '../@types/settings'
 import { EventKinds, EventTags } from '../constants/base'
+import { getEffectiveProbeIntervalSeconds } from './nip66-schedule'
 
 export const normalizeRelayUrlForDTag = (relayUrl: string): string => {
   const parsed = new URL(relayUrl)
@@ -57,7 +58,7 @@ export const buildMonitorAnnouncementEvent = (
   const timeouts = nip66?.timeouts
 
   const tags: Tag[] = [
-    ['frequency', String(nip66?.probeIntervalSeconds ?? 3600)],
+    ['frequency', String(getEffectiveProbeIntervalSeconds(settings))],
     ['c', 'ws'],
     ['c', 'nip11'],
     ['c', 'ssl'],

src/utils/nip66-schedule.ts

@@ -0,0 +1,14 @@
+import { Settings } from '../@types/settings'
+
+export const DEFAULT_PROBE_INTERVAL_SECONDS = 3600
+export const MIN_PROBE_INTERVAL_SECONDS = 60
+
+export const getEffectiveProbeIntervalSeconds = (settings: Settings): number => {
+  const configured = settings.nip66?.probeIntervalSeconds ?? DEFAULT_PROBE_INTERVAL_SECONDS
+
+  return Math.max(configured, MIN_PROBE_INTERVAL_SECONDS)
+}
+
+export const getProbeIntervalMs = (settings: Settings): number => {
+  return getEffectiveProbeIntervalSeconds(settings) * 1000
+}

src/utils/relay-probe/nip11-probe.ts

@@ -11,6 +11,7 @@ const nip11DocumentSchema = z
   .object({
     name: z.string().optional(),
     pubkey: pubkeySchema.optional(),
+    supported_nips: z.array(z.number().int().positive()).optional(),
   })
   .passthrough()
 
@@ -96,6 +97,7 @@ export const createNodeNip11Fetcher = (): Nip11Fetcher => ({
         statusCode: response.status,
         name: parsed.data.name,
         pubkey: parsed.data.pubkey,
+        supportedNips: parsed.data.supported_nips,
       }
     } catch (error: unknown) {
       const axiosError = error as AxiosError

src/utils/relay-probe/types.ts

@@ -51,6 +51,7 @@ export interface Nip11Result {
   statusCode: number
   name?: string
   pubkey?: string
+  supportedNips?: number[]
 }
 
 export interface ProbeResult {