fhirsmith 0.16.1 → 0.18.0

package/registry/uptime.js

@@ -0,0 +1,154 @@
+// registry/uptime.js
+// Uptime history for the registered servers: one record per endpoint per scan, saying
+// whether the endpoint answered. The registry's own scan is the probe - nothing else is
+// pinged - so a scan that didn't happen (the registry was down, or the master list could
+// not be read) is not held against any server.
+
+const DAY = 24 * 60 * 60 * 1000;
+
+class UptimeHistory {
+  /**
+   * @param {object} [options]
+   * @param {number} [options.retentionDays] how long records are kept (default 90)
+   * @param {number} [options.windowDays] the period uptime is reported over (default 30)
+   */
+  constructor(options = {}) {
+    this.retentionMs = (options.retentionDays || 90) * DAY;
+    this.windowMs = (options.windowDays || 30) * DAY;
+    this.records = new Map(); // address -> [[timeMs, ok(1|0)], ...] in time order
+  }
+
+  /**
+   * Record the outcome of one probe of an endpoint
+   * @param {string} address the endpoint URL
+   * @param {boolean} ok whether the scan of it succeeded
+   * @param {number} [time] when the scan ran (ms)
+   */
+  record(address, ok, time = Date.now()) {
+    if (!address) {
+      return;
+    }
+    let list = this.records.get(address);
+    if (!list) {
+      list = [];
+      this.records.set(address, list);
+    }
+    list.push([time, ok ? 1 : 0]);
+    this.prune(address, time);
+  }
+
+  prune(address, now = Date.now()) {
+    const list = this.records.get(address);
+    if (!list) {
+      return;
+    }
+    const cutoff = now - this.retentionMs;
+    let drop = 0;
+    while (drop < list.length && list[drop][0] < cutoff) {
+      drop++;
+    }
+    if (drop > 0) {
+      list.splice(0, drop);
+    }
+  }
+
+  /**
+   * Uptime over the reporting window for a set of endpoints, as the fraction of their
+   * probes that succeeded: a server with two endpoints of which one is down for a scan
+   * is half down for that scan.
+   * @param {string|string[]} addresses one endpoint, or the endpoints of one server
+   * @param {number} [now]
+   * @param {number} [from] the start of the period; the reporting window by default
+   * @returns {{percent: number, probes: number, failures: number, since: number}|null}
+   *   null when there have been no probes in the window
+   */
+  uptime(addresses, now = Date.now(), from = now - this.windowMs) {
+    const list = Array.isArray(addresses) ? addresses : [addresses];
+    let probes = 0;
+    let failures = 0;
+    let since = Infinity;
+    for (const address of list) {
+      for (const [time, ok] of this.records.get(address) || []) {
+        if (time < from || time > now) {
+          continue;
+        }
+        probes++;
+        if (!ok) {
+          failures++;
+        }
+        if (time < since) {
+          since = time;
+        }
+      }
+    }
+    if (probes === 0) {
+      return null;
+    }
+    return { percent: 100 * (probes - failures) / probes, probes, failures, since };
+  }
+
+  /**
+   * Forget what is past retention. Only age decides: an endpoint missing from one crawl (a
+   * sub-registry that failed to fetch, a crawl cut short at shutdown) keeps its history,
+   * and one that has really gone ages out with its last probes
+   * @param {Iterable<string>} [addresses] the endpoints of the last crawl (no longer used:
+   *   a crawl can miss endpoints that still exist)
+   */
+  retain(addresses, now = Date.now()) {
+    for (const address of [...this.records.keys()]) {
+      this.prune(address, now);
+      if (this.records.get(address).length === 0) {
+        this.records.delete(address);
+      }
+    }
+  }
+
+  toJSON() {
+    const endpoints = {};
+    for (const [address, list] of this.records) {
+      if (list.length > 0) {
+        endpoints[address] = list.map(([t, ok]) => [t, ok]);
+      }
+    }
+    return { version: '1', endpoints };
+  }
+
+  static fromJSON(json, options) {
+    const history = new UptimeHistory(options);
+    if (!json || json.version !== '1' || typeof json.endpoints !== 'object') {
+      return history;
+    }
+    for (const [address, list] of Object.entries(json.endpoints || {})) {
+      if (!Array.isArray(list)) {
+        continue;
+      }
+      const clean = list
+        .filter(r => Array.isArray(r) && Number.isFinite(r[0]))
+        .map(r => [r[0], r[1] ? 1 : 0])
+        .sort((a, b) => a[0] - b[0]);
+      if (clean.length > 0) {
+        history.records.set(address, clean);
+      }
+    }
+    return history;
+  }
+}
+
+/**
+ * Format an uptime for display: 100%, 99.9%, 97%, ... - the precision that is honest
+ * for the number of probes behind it
+ */
+function formatUptime(u) {
+  if (!u) {
+    return '';
+  }
+  if (u.failures === 0) {
+    return '100%';
+  }
+  if (u.percent >= 99) {
+    return `${(Math.floor(u.percent * 10) / 10).toFixed(1)}%`;
+  }
+  return `${Math.floor(u.percent)}%`;
+}
+
+module.exports = { UptimeHistory, formatUptime };

package/release.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+#
+# Release FHIRsmith: ./release.sh 0.17.0
+#
+# Checks that the release is ready, submits the tx test report to the /testing server, then
+# tags the release and pushes the tag (which starts .github/workflows/release.yml).
+# Stops at the first problem, before anything is tagged.
+#
+# The test report: run the tx tests first (npx jest tests/tx/test-cases.test.js). If the
+# /testing server needs a token, set FHIRSMITH_TESTING_TOKEN.
+
+set -euo pipefail
+
+fail() {
+  echo "gr.sh: $*" >&2
+  exit 1
+}
+
+[ $# -eq 1 ] || fail "usage: ./gr.sh <version>, e.g. ./gr.sh 0.17.0"
+VERSION="${1#v}"
+TAG="v$VERSION"
+[[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || fail "'$1' is not a release version (X.Y.Z)"
+
+cd "$(dirname "$0")"
+
+# --- git: on main, nothing uncommitted, and exactly what is on GitHub -------------------
+[ "$(git rev-parse --abbrev-ref HEAD)" = "main" ] || fail "not on main"
+[ -z "$(git status --porcelain --untracked-files=no)" ] || fail "there are uncommitted changes"
+git fetch --quiet origin main --tags
+[ "$(git rev-parse HEAD)" = "$(git rev-parse origin/main)" ] \
+  || fail "main is not the same as origin/main - push (or pull) first, so the tag is on a commit GitHub has"
+! git rev-parse -q --verify "refs/tags/$TAG" >/dev/null || fail "tag $TAG already exists"
+
+# --- versions: what release.yml's verify-version job checks ----------------------------
+check_version() {
+  local what="$1" found="$2"
+  [ "$found" = "$VERSION" ] || fail "$what is '$found', not $VERSION (npm version --no-git-tag-version $VERSION && npm install --package-lock-only)"
+}
+check_version "package.json version" "$(node -p "require('./package.json').version")"
+check_version "package-lock.json version" "$(node -p "require('./package-lock.json').version")"
+check_version 'package-lock.json packages[""]' "$(node -p "require('./package-lock.json').packages[''].version")"
+
+# --- CHANGELOG: a dated section for this version, with the conformance statement in -----
+HEADING=$(grep -E "^## \[v?${VERSION//./\\.}\]" CHANGELOG.md || true)
+[ -n "$HEADING" ] || fail "CHANGELOG.md has no section for $VERSION"
+[[ "$HEADING" =~ [0-9]{4}-[0-9]{2}-[0-9]{2}$ ]] || fail "the CHANGELOG.md section for $VERSION has no date: $HEADING"
+SECTION=$(sed -n "/^## \[v\{0,1\}${VERSION//./\\.}\]/,/^## \[/p" CHANGELOG.md | sed '$d')
+! grep -qx '(paste)' <<<"$SECTION" || fail "the Tx Conformance Statement for $VERSION hasn't been pasted into CHANGELOG.md"
+
+# --- the test report: this version, passed, and run on what is being released ----------
+REPORT=test-cases-report.json
+[ -f "$REPORT" ] || fail "no $REPORT - run the tx tests first (npx jest tests/tx/test-cases.test.js)"
+# the last commit that changed what the tests run - not the notes, nor the version bump
+CODE_COMMITTED=$(git log -1 --format=%cI -- . ':(exclude)*.md' ':(exclude)release.sh' ':(exclude)package.json' ':(exclude)package-lock.json')
+node - "$REPORT" "$VERSION" "$CODE_COMMITTED" <<'NODE' || exit 1
+const [file, version, committed] = process.argv.slice(2);
+const report = JSON.parse(require('fs').readFileSync(file, 'utf8'));
+const fhirsmith = (report.participant || []).find(p => p.uri === 'https://github.com/HealthIntersections/FHIRsmith');
+const problems = [];
+if (!fhirsmith || fhirsmith.version !== version) {
+  problems.push(`it is from FHIRsmith ${fhirsmith ? fhirsmith.version : '(unknown)'}, not ${version}`);
+}
+if (report.result !== 'pass') {
+  problems.push(`its result is '${report.result}', not 'pass'`);
+}
+if (!report.issued || new Date(report.issued) < new Date(committed)) {
+  problems.push(`it was run (${report.issued}) before the last change to the code (${committed})`);
+}
+if (problems.length > 0) {
+  console.error(`gr.sh: ${file} can't be submitted for ${version}: ${problems.join('; ')} - run the tx tests again`);
+  process.exit(1);
+}
+NODE
+
+# --- submit the report, then tag ---------------------------------------------------------
+node utilities/submit-test-report.js -file "$REPORT" || fail "the test report was not accepted, so $TAG has not been tagged"
+
+git tag -a "$TAG" -m "FHIRsmith $VERSION"
+git push origin "$TAG"
+echo "Tagged and pushed $TAG - the release workflow is now running"

package/server.js

@@ -18,6 +18,8 @@ const escape = require('escape-html');
 const { resolveWithin } = require('./library/path-safety');
 const { readCgroupMemoryLimit } = require('./library/cgroup-memory');
 const { NpmAudit } = require('./library/npm-audit');
+const Mailer = require('./library/mailer');
+const DailyReport = require('./library/daily-report');
 
 // Load configuration BEFORE logger
 let config;
@@ -51,7 +53,7 @@ serverLog.info(`Data directory: ${folders.dataDir()}`);
 serverLog.info(`========================================`);
 
 const activeModules = config.modules ? Object.keys(config.modules)
-    .filter(mod => config.modules[mod].enabled)
+    .filter(mod => config.modules[mod]?.enabled)
     .join(', ') : [];
 serverLog.info(`Loaded Configuration. Active modules = ${activeModules}`);
 
@@ -66,6 +68,7 @@ const TokenModule = require('./token/token.js');
 const NpmProjectorModule = require('./npmprojector/npmprojector.js');
 const TXModule = require('./tx/tx.js');
 const TestingModule = require('./testing/testing.js');
+const IpsModule = require('./ips/ips.js');
 
 const htmlServer = require('./library/html-server');
 const ServerStats = require("./stats");
@@ -90,9 +93,15 @@ app.set('trust proxy', config.server.trustProxy ?? DEFAULT_TRUST_PROXY);
 const PORT = process.env.PORT || config.server.port || 3000;
 
 // Middleware
-app.use(express.raw({ type: 'application/fhir+json', limit: '50mb' }));
-app.use(express.raw({ type: 'application/fhir+xml', limit: '50mb' }));
-app.use(express.json({ limit: '50mb' }));
+// The body parsers, for every module but those that read their own bodies with their own
+// limits and checks (the ips module: a document is read only once its submitter's token has
+// been checked, and no bigger than the module's maxSize)
+const OWN_BODIES = ['/ips'];
+const ownsBody = (req) => OWN_BODIES.some(p => req.path === p || req.path.startsWith(p + '/'));
+const unlessOwnBody = (parser) => (req, res, next) => (ownsBody(req) ? next() : parser(req, res, next));
+app.use(unlessOwnBody(express.raw({ type: 'application/fhir+json', limit: '50mb' })));
+app.use(unlessOwnBody(express.raw({ type: 'application/fhir+xml', limit: '50mb' })));
+app.use(unlessOwnBody(express.json({ limit: '50mb' })));
 app.use((req, res, next) => {
   const requestId = req.headers['x-request-id'];
   if (requestId) {
@@ -113,6 +122,8 @@ const modules = {};
 let stats = null;
 // periodic npm advisory check of the installed packages - see library/npm-audit.js
 let npmAudit = null;
+// the daily report, emailed at midnight when "email" and "dailyReport.to" are configured - see library/daily-report.js
+let dailyReport = null;
 
 // Initialize modules based on configuration
 async function initializeModules() {
@@ -247,6 +258,22 @@ async function initializeModules() {
       throw error;
     }
   }
+  if (config.modules?.ips?.enabled) {
+    try {
+      serverLog.info('Initializing module: ips...');
+      // sharing through this server's own shl module: its password, unless the ips
+      // configuration names an SHL server of its own
+      if (config.modules.ips.shl && !config.modules.ips.shl.password && config.modules.shl?.password) {
+        config.modules.ips.shl = { server: '/shl', ...config.modules.ips.shl, password: config.modules.shl.password };
+      }
+      modules.ips = new IpsModule(stats.forModule('ips'));
+      await modules.ips.initialize(config.modules.ips, app);
+      app.use('/ips', modules.ips.router);
+    } catch (error) {
+      serverLog.error('Failed to initialize ips module:', error);
+      throw error;
+    }
+  }
 
   // Initialize TX module
   // Note: TX module registers its own endpoints directly on the app
@@ -255,7 +282,7 @@ async function initializeModules() {
     try {
       serverLog.info('Initializing module: tx...');
       modules.tx = new TXModule(stats.forModule('tx'));
-      await modules.tx.initialize(config.modules.tx, app);
+      await modules.tx.initialize(config.modules.tx, app, { hostName: config.hostName });
     } catch (error) {
       serverLog.error('Failed to initialize TX module:', error);
       throw error;
@@ -317,52 +344,52 @@ async function buildRootPageContent() {
   content += '<ul class="list-group">';
 
   // Check which modules are enabled and add them to the list
-  if (config.modules.packages.enabled) {
+  if (config.modules?.packages?.enabled) {
     content += '<li class="list-group-item">';
     content += '<a href="/packages" class="text-decoration-none">Package Server</a>: Browse and download FHIR Implementation Guide packages (<a href="/packages/openapi">API</a>)';
     content += '</li>';
   }
 
-  if (config.modules.xig.enabled) {
+  if (config.modules?.xig?.enabled) {
     content += '<li class="list-group-item">';
     content += '<a href="/xig" class="text-decoration-none">FHIR IG Statistics</a>: Statistics and analysis of FHIR Implementation Guides';
     content += '</li>';
   }
 
-  if (config.modules.shl.enabled) {
+  if (config.modules?.shl?.enabled) {
     content += '<li class="list-group-item">';
     content += '<a href="/shl" class="text-decoration-none">SHL Server</a>: SMART Health Links management and validation';
     content += '</li>';
   }
 
-  if (config.modules.vcl.enabled) {
+  if (config.modules?.vcl?.enabled) {
     content += '<li class="list-group-item">';
     content += '<a href="/VCL" class="text-decoration-none">VCL Server</a>: ValueSet Compose Language expression parsing';
     content += '</li>';
   }
 
-  if (config.modules.registry && config.modules.registry.enabled) {
+  if (config.modules?.registry?.enabled) {
     content += '<li class="list-group-item">';
     content += '<a href="/tx-reg" class="text-decoration-none">Terminology Server Registry</a>: ';
     content += 'Discover and query FHIR terminology servers for code system and value set support (<a href="/tx-reg/openapi">API</a>)';
     content += '</li>';
   }
 
-  if (config.modules.publisher && config.modules.publisher.enabled) {
+  if (config.modules?.publisher?.enabled) {
     content += '<li class="list-group-item">';
     content += '<a href="/publisher" class="text-decoration-none">FHIR Publisher</a>: ';
     content += 'Manage FHIR Implementation Guide publication tasks and approvals';
     content += '</li>';
   }
 
-  if (config.modules.token && config.modules.token.enabled) {
+  if (config.modules?.token?.enabled) {
     content += '<li class="list-group-item">';
     content += '<a href="/token" class="text-decoration-none">Token Server</a>: ';
     content += 'OAuth authentication and API key management for FHIR services';
     content += '</li>';
   }
 
-  if (config.modules.npmprojector && config.modules.npmprojector.enabled) {
+  if (config.modules?.npmprojector?.enabled) {
     content += '<li class="list-group-item">';
     content += '<a href="/npmprojector" class="text-decoration-none">NpmProjector</a>: ';
     content += 'Hot-reloading FHIR server with FHIRPath-based search indexes';
@@ -383,7 +410,14 @@ async function buildRootPageContent() {
     content += '</li>';
   }
 
-  if (config.modules.folder && config.modules.folder.enabled) {
+  if (config.modules?.ips?.enabled) {
+    content += '<li class="list-group-item">';
+    content += '<a href="/ips" class="text-decoration-none">IPS</a>: ';
+    content += 'Collections of International Patient Summary documents, each with its own FHIR endpoint';
+    content += '</li>';
+  }
+
+  if (config.modules?.folder?.enabled) {
     content += '<li class="list-group-item">';
     content += '<strong>Cache Folder</strong>: ';
     content += 'Cache Folder for Kindling';
@@ -400,7 +434,7 @@ async function buildRootPageContent() {
   }
 
 
-  if (config.modules.tx && config.modules.tx.enabled) {
+  if (config.modules?.tx?.enabled) {
     content += '<li class="list-group-item">';
     content += '<strong>TX Terminology Server</strong>: ';
     content += 'FHIR terminology services (CodeSystem, ValueSet, ConceptMap)';
@@ -422,16 +456,7 @@ async function buildRootPageContent() {
 
   // Calculate uptime
   const uptimeMs = Date.now() - stats.startTime;
-  const uptimeSeconds = Math.floor(uptimeMs / 1000);
-  const uptimeDays = Math.floor(uptimeSeconds / 86400);
-  const uptimeHours = Math.floor((uptimeSeconds % 86400) / 3600);
-  const uptimeMinutes = Math.floor((uptimeSeconds % 3600) / 60);
-  const uptimeSecs = uptimeSeconds % 60;
-  let uptimeStr = '';
-  if (uptimeDays > 0) uptimeStr += `${uptimeDays}d `;
-  if (uptimeHours > 0 || uptimeDays > 0) uptimeStr += `${uptimeHours}h `;
-  if (uptimeMinutes > 0 || uptimeHours > 0 || uptimeDays > 0) uptimeStr += `${uptimeMinutes}m `;
-  uptimeStr += `${uptimeSecs}s`;
+  const uptimeStr = uptimeText(uptimeMs);
 
   // Memory usage
   const memUsage = process.memoryUsage();
@@ -550,7 +575,7 @@ app.get('/', async (req, res) => {
       // Build basic stats for root page
       const stats = {
         version: packageJson.version,
-        enabledModules: Object.keys(config.modules).filter(m => config.modules[m].enabled).length,
+        enabledModules: Object.keys(config.modules).filter(m => config.modules[m]?.enabled).length,
         processingTime: Date.now() - startTime,
         about
       };
@@ -616,16 +641,7 @@ app.get('/dashboard', async (req, res) => {
     const startTime = Date.now();
     // Calculate uptime
     const uptimeMs = Date.now() - stats.startTime;
-    const uptimeSeconds = Math.floor(uptimeMs / 1000);
-    const uptimeDays = Math.floor(uptimeSeconds / 86400);
-    const uptimeHours = Math.floor((uptimeSeconds % 86400) / 3600);
-    const uptimeMinutes = Math.floor((uptimeSeconds % 3600) / 60);
-    const uptimeSecs = uptimeSeconds % 60;
-    let uptimeStr = '';
-    if (uptimeDays > 0) uptimeStr += `${uptimeDays}d `;
-    if (uptimeHours > 0 || uptimeDays > 0) uptimeStr += `${uptimeHours}h `;
-    if (uptimeMinutes > 0 || uptimeHours > 0 || uptimeDays > 0) uptimeStr += `${uptimeMinutes}m `;
-    uptimeStr += `${uptimeSecs}s`;
+    const uptimeStr = uptimeText(uptimeMs);
 
     // Memory usage
     const memUsage = process.memoryUsage();
@@ -674,7 +690,7 @@ app.get('/dashboard', async (req, res) => {
 
     const pageStats = {
       version: packageJson.version,
-      enabledModules: Object.keys(config.modules).filter(m => config.modules[m].enabled).length,
+      enabledModules: Object.keys(config.modules).filter(m => config.modules[m]?.enabled).length,
       processingTime: Date.now() - startTime
     };
 
@@ -701,6 +717,30 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
 }
 
+/**
+ * "3d 4h 5m 6s" for this run, followed by the proportion of time the server has
+ * been up over all its recorded runs, when the statistics database is keeping that.
+ */
+function uptimeText(uptimeMs) {
+  const uptimeSeconds = Math.floor(uptimeMs / 1000);
+  const uptimeDays = Math.floor(uptimeSeconds / 86400);
+  const uptimeHours = Math.floor((uptimeSeconds % 86400) / 3600);
+  const uptimeMinutes = Math.floor((uptimeSeconds % 3600) / 60);
+  const uptimeSecs = uptimeSeconds % 60;
+  let uptimeStr = '';
+  if (uptimeDays > 0) uptimeStr += `${uptimeDays}d `;
+  if (uptimeHours > 0 || uptimeDays > 0) uptimeStr += `${uptimeHours}h `;
+  if (uptimeMinutes > 0 || uptimeHours > 0 || uptimeDays > 0) uptimeStr += `${uptimeMinutes}m `;
+  uptimeStr += `${uptimeSecs}s`;
+  const overall = stats.overallUptime();
+  if (overall) {
+    // floor rather than round, so 99.96% doesn't claim to be 100%
+    const pct = overall.percent >= 100 ? '100' : (Math.floor(overall.percent * 10) / 10).toFixed(1);
+    uptimeStr += ` (${pct}% overall)`;
+  }
+  return uptimeStr;
+}
+
 function pctColor(pct) {
   // Gradient from green (#deffe0) at 0% to red (#ffd3d1) at 100%
   const t = Math.max(0, Math.min(100, pct)) / 100;
@@ -797,11 +837,21 @@ async function startServer() {
 
     // Start server
     app.listen(PORT, () => {
-      stats.markStarted();
+      stats.markStarted(packageJson.version);
       serverLog.info(`=== Server running on http://localhost:${PORT} ===`);
     });
     npmAudit.start();
-    if (modules.packages && config.modules.packages.enabled) {
+    dailyReport = new DailyReport(config.dailyReport, {
+      log: Logger.getInstance().child({ module: 'daily-report' }),
+      stats: stats,
+      modules: modules,
+      mailer: new Mailer(config.email, Logger.getInstance().child({ module: 'email' })),
+      npmAudit: npmAudit,
+      version: packageJson.version,
+      serverId: config.hostName
+    });
+    dailyReport.start();
+    if (modules.packages && config.modules?.packages?.enabled) {
       modules.packages.startInitialCrawler();
     }
     // Run usage tracker in background after startup
@@ -825,12 +875,21 @@ async function startServer() {
   }
 }
 
-// Graceful shutdown
-process.on('SIGINT', async () => {
+// Graceful shutdown: on Ctrl-C (SIGINT), and on SIGTERM - what systemd, docker stop and
+// kill send - so the modules can save what they hold (usage counts, crawl data) either way
+let shuttingDown = false;
+async function shutdown() {
+  if (shuttingDown) {
+    return;
+  }
+  shuttingDown = true;
   serverLog.info('\nShutting down server...');
   if (npmAudit) {
     npmAudit.stop();
   }
+  if (dailyReport) {
+    dailyReport.stop();
+  }
 
   // Shutdown all modules
   for (const [moduleName, moduleInstance] of Object.entries(modules)) {
@@ -847,7 +906,9 @@ process.on('SIGINT', async () => {
   stats.finishStats();
   serverLog.info('Server shutdown complete');
   process.exit(0);
-});
+}
+process.on('SIGINT', () => void shutdown());
+process.on('SIGTERM', () => void shutdown());
 
 async function serveFhirsmithHome(req, res) {
   // Check if client wants HTML response
@@ -868,7 +929,7 @@ async function serveFhirsmithHome(req, res) {
       // Build basic stats for root page
       const stats = {
         version: packageJson.version,
-        enabledModules: Object.keys(config.modules).filter(m => config.modules[m].enabled).length,
+        enabledModules: Object.keys(config.modules).filter(m => config.modules[m]?.enabled).length,
         processingTime: Date.now() - startTime
       };
 
@@ -885,7 +946,7 @@ async function serveFhirsmithHome(req, res) {
     // Return JSON response for API clients
     const enabledModules = {};
     Object.keys(config.modules).forEach(moduleName => {
-      if (config.modules[moduleName].enabled) {
+      if (config.modules[moduleName]?.enabled) {
         if (moduleName === 'tx') {
           // TX module has multiple endpoints
           enabledModules[moduleName] = {