DC-004: Fix all 19 ESLint warnings (zero remaining)

Removed unused imports (path, validateStartupConfig, platformPaths),
renamed unused destructures (_timeout, _logEntry), replaced nested
ternaries with lookup tables, added eslint-disable comments on
require-await functions that are intentionally async for API stability,
and extracted helper functions to reduce max-depth and complexity in
app.js, dns.js, provider-dns.js, and site.js. All 879 tests pass.

dashcaddy-api/src/app.js

@@ -29,7 +29,7 @@ const healthChecker = require('../health-checker');
 const updateManager = require('../update-manager');
 const selfUpdater = require('../self-updater');
 const configureMiddleware = require('../middleware');
-const { validateStartupConfig, syncHealthCheckerServices } = require('../startup-validator');
+const { validateStartupConfig: _validateStartupConfig, syncHealthCheckerServices } = require('../startup-validator');
 const { CSRF_HEADER_NAME } = require('../csrf-protection');
 const { resolveServiceUrl } = require('../url-resolver');
 const metrics = require('../metrics');
@@ -94,6 +94,7 @@ const { APP } = require('../constants');
 /**
  * Create and configure the Express application
  */
+// eslint-disable-next-line require-await -- kept async for API consistency with other factory functions
 async function createApp() {
   const app = express();
 
@@ -182,6 +183,25 @@ async function createApp() {
     return first === 100 && second >= 64 && second <= 127;
   }
 
+  function isPrivateLan(ip) {
+    if (!ip) return false;
+    if (ip.startsWith('192.168.') || ip.startsWith('10.')) return true;
+    return /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(ip);
+  }
+
+  function collectNetworkInterfaces(osModule) {
+    const out = [];
+    const interfaces = osModule.networkInterfaces();
+    for (const [name, addrs] of Object.entries(interfaces)) {
+      for (const addr of addrs) {
+        if (addr.internal || addr.family !== 'IPv4') continue;
+        out.push({ name, ip: addr.address });
+      }
+    }
+    return out;
+  }
+
+  // eslint-disable-next-line require-await -- stub for now, will gain await when wired into context
   async function getTailscaleStatus() {
     // Stub for now - will be populated by context
     return null;
@@ -215,6 +235,7 @@ async function createApp() {
     return services.find(s => s.id === serviceId) || null;
   }
 
+  // eslint-disable-next-line require-await -- may grow awaits as config loading evolves
   async function readConfig() {
     const { readJsonFile } = require('../fs-helpers');
     return readJsonFile(config.CONFIG_FILE, {});
@@ -250,6 +271,7 @@ async function createApp() {
     // Stub - will be implemented
   }
 
+  // eslint-disable-next-line require-await -- health checker sync is sync; kept async for caller API stability
   async function resyncHealthChecker() {
     return syncHealthCheckerServices({
       log,
@@ -813,19 +835,12 @@ async function createApp() {
       };
 
       if (!envLan || !envTailscale) {
-        const interfaces = os.networkInterfaces();
+        result.all = collectNetworkInterfaces(os);
-        for (const [name, addrs] of Object.entries(interfaces)) {
+        if (!result.tailscale) {
-          for (const addr of addrs) {
+          result.tailscale = result.all.find(i => isTailscaleIP(i.ip))?.ip || null;
-            if (addr.internal || addr.family !== 'IPv4') continue;
+        }
-            const ip = addr.address;
+        if (!result.lan) {
-            result.all.push({ name, ip });
+          result.lan = result.all.find(i => isPrivateLan(i.ip))?.ip || null;
-
-            if (!result.tailscale && ip.startsWith('100.')) {
-              result.tailscale = ip;
-            } else if (!result.lan && (ip.startsWith('192.168.') || ip.startsWith('10.') || ip.match(/^172\.(1[6-9]|2[0-9]|3[0-1])\./))) {
-              result.lan = ip;
-            }
-          }
         }
       }
 

dashcaddy-api/src/config/migrations.js

@@ -17,7 +17,7 @@
  */
 const fs = require('fs');
 const path = require('path');
-const platformPaths = require('../../platform-paths');
+const _platformPaths = require('../../platform-paths');
 
 const CURRENT_VERSION = 2;
 

dashcaddy-api/src/config/site.js

@@ -24,6 +24,33 @@ const siteConfig = {
   routingMode: 'subdomain'
 };
 
+function applyConfigFields(raw) {
+  siteConfig.tld = raw.tld || '.home';
+  if (!siteConfig.tld.startsWith('.')) siteConfig.tld = '.' + siteConfig.tld;
+  siteConfig.caName = raw.caName || '';
+  siteConfig.dnsServerIp = (raw.dns && raw.dns.ip) || '';
+  siteConfig.dnsServerPort = (raw.dns && raw.dns.port) || CADDY.DEFAULT_DNS_PORT;
+  siteConfig.dashboardHost = raw.dashboardHost || `status${siteConfig.tld}`;
+  siteConfig.timezone = raw.timezone || 'UTC';
+  siteConfig.dnsServers = raw.dnsServers || {};
+  siteConfig.configurationType = raw.configurationType || 'homelab';
+  siteConfig.domain = raw.domain || '';
+  siteConfig.routingMode = raw.routingMode || 'subdomain';
+  siteConfig.pylon = raw.pylon || null;
+}
+
+function validateAndLogConfig(raw, log) {
+  const { valid, errors: configErrors, warnings: configWarnings } = validateConfig(raw);
+  if (log && log.warn) {
+    if (!valid) {
+      log.warn('config', 'Config validation errors', { errors: configErrors });
+    }
+    for (const w of configWarnings) {
+      log.warn('config', w);
+    }
+  }
+}
+
 function loadSiteConfig(CONFIG_FILE, log) {
   try {
     // Run migrations first — this handles config.json files from older
@@ -31,29 +58,8 @@ function loadSiteConfig(CONFIG_FILE, log) {
     const raw = loadAndMigrate(CONFIG_FILE, log);
 
     if (raw && Object.keys(raw).length > 0) {
-      // Validate config and log any issues
+      validateAndLogConfig(raw, log);
-      const { valid, errors: configErrors, warnings: configWarnings } = validateConfig(raw);
+      applyConfigFields(raw);
-      if (log && log.warn) {
-        if (!valid) {
-          log.warn('config', 'Config validation errors', { errors: configErrors });
-        }
-        for (const w of configWarnings) {
-          log.warn('config', w);
-        }
-      }
-
-      siteConfig.tld = raw.tld || '.home';
-      if (!siteConfig.tld.startsWith('.')) siteConfig.tld = '.' + siteConfig.tld;
-      siteConfig.caName = raw.caName || '';
-      siteConfig.dnsServerIp = (raw.dns && raw.dns.ip) || '';
-      siteConfig.dnsServerPort = (raw.dns && raw.dns.port) || CADDY.DEFAULT_DNS_PORT;
-      siteConfig.dashboardHost = raw.dashboardHost || `status${siteConfig.tld}`;
-      siteConfig.timezone = raw.timezone || 'UTC';
-      siteConfig.dnsServers = raw.dnsServers || {};
-      siteConfig.configurationType = raw.configurationType || 'homelab';
-      siteConfig.domain = raw.domain || '';
-      siteConfig.routingMode = raw.routingMode || 'subdomain';
-      siteConfig.pylon = raw.pylon || null;
     }
   } catch (e) {
     if (log && log.error) {

dashcaddy-api/src/context/caddy.js

@@ -43,6 +43,7 @@ async function modifyCaddyfile(CADDYFILE_PATH, reloadCaddy, modifyFn) {
 /**
  * Read the current Caddyfile content
  */
+// eslint-disable-next-line require-await -- fsp.readFile already returns a promise
 async function readCaddyfile(CADDYFILE_PATH) {
   return fsp.readFile(CADDYFILE_PATH, 'utf8');
 }

dashcaddy-api/src/context/dns.js

@@ -82,6 +82,20 @@ async function refreshDnsToken(username, password, server, fetchT, log) {
 /**
  * Ensure we have a valid DNS token (auto-refresh if needed)
  */
+async function tryCredentialPair(dnsId, role, primaryIp, siteConfig, credentialManager, fetchT, log) {
+  try {
+    const username = await credentialManager.retrieve(`dns.${dnsId}.${role}.username`);
+    const password = await credentialManager.retrieve(`dns.${dnsId}.${role}.password`);
+    if (username && password) {
+      return await refreshDnsToken(username, password, primaryIp, fetchT, log);
+    }
+    return null;
+  } catch (err) {
+    log.error('dns', `Per-server ${role} credential error`, { dnsId, error: err.message });
+    return null;
+  }
+}
+
 async function ensureValidDnsToken(siteConfig, credentialManager, fetchT, log) {
   // Check if token is valid and not expired
   if (dnsToken && dnsTokenExpiry && new Date() < new Date(dnsTokenExpiry)) {
@@ -93,15 +107,8 @@ async function ensureValidDnsToken(siteConfig, credentialManager, fetchT, log) {
     const dnsId = dnsIpToDnsId(primaryIp, siteConfig);
     if (dnsId) {
       for (const role of ['admin', 'readonly']) {
-        try {
+        const result = await tryCredentialPair(dnsId, role, primaryIp, siteConfig, credentialManager, fetchT, log);
-          const username = await credentialManager.retrieve(`dns.${dnsId}.${role}.username`);
+        if (result) return result;
-          const password = await credentialManager.retrieve(`dns.${dnsId}.${role}.password`);
-          if (username && password) {
-            return await refreshDnsToken(username, password, primaryIp, fetchT, log);
-          }
-        } catch (err) {
-          log.error('dns', `Per-server ${role} credential error`, { dnsId, error: err.message });
-        }
       }
     }
   }

dashcaddy-api/src/context/provider-dns.js

@@ -34,35 +34,30 @@ function createProviderDnsContext(siteConfig, buildDomain, credentialManager, fe
   /** Get provider-specific config from site config */
   function getProviderConfig(providerId) {
     const dnsConfig = siteConfig.dns || {};
-
+    const builders = {
-    switch (providerId) {
+      technitium: () => ({
-      case 'technitium':
+        serverIp: siteConfig.dnsServerIp || dnsConfig.ip || '',
-        return {
+        serverPort: siteConfig.dnsServerPort || dnsConfig.port || '5380',
-          serverIp: siteConfig.dnsServerIp || dnsConfig.ip || '',
+        dnsServers: siteConfig.dnsServers || {},
-          serverPort: siteConfig.dnsServerPort || dnsConfig.port || '5380',
+        dnsId: Object.keys(siteConfig.dnsServers || {})[0] || 'dns1'
-          dnsServers: siteConfig.dnsServers || {},
+      }),
-          dnsId: Object.keys(siteConfig.dnsServers || {})[0] || 'dns1'
+      cloudflare: () => ({
-        };
+        apiToken: dnsConfig.apiToken || '',
-      case 'cloudflare':
+        zoneId: dnsConfig.zoneId || '',
-        return {
+        domain: siteConfig.domain || ''
-          apiToken: dnsConfig.apiToken || '',
+      }),
-          zoneId: dnsConfig.zoneId || '',
+      rfc2136: () => ({
-          domain: siteConfig.domain || ''
+        server: dnsConfig.server || siteConfig.dnsServerIp || '',
-        };
+        port: dnsConfig.port || 53,
-      case 'rfc2136':
+        zone: siteConfig.tld?.replace(/^\./, '') || '',
-        return {
+        tsigAlgorithm: dnsConfig.tsigAlgorithm || 'hmac-sha256',
-          server: dnsConfig.server || siteConfig.dnsServerIp || '',
+        tsigKeyName: dnsConfig.tsigKeyName || '',
-          port: dnsConfig.port || 53,
+        tsigSecret: dnsConfig.tsigSecret || ''
-          zone: siteConfig.tld?.replace(/^\./, '') || '',
+      }),
-          tsigAlgorithm: dnsConfig.tsigAlgorithm || 'hmac-sha256',
+      manual: () => ({})
-          tsigKeyName: dnsConfig.tsigKeyName || '',
+    };
-          tsigSecret: dnsConfig.tsigSecret || ''
+    const builder = builders[providerId];
-        };
+    return builder ? builder() : dnsConfig;
-      case 'manual':
-        return {};
-      default:
-        return dnsConfig;
-    }
   }
 
   /** Get or create the active provider adapter */
@@ -120,6 +115,25 @@ function createProviderDnsContext(siteConfig, buildDomain, credentialManager, fe
     return null;
   }
 
+  async function tryServerRoleCredentials(dnsId, role, primaryIp) {
+    try {
+      const username = await credentialManager.retrieve(`dns.${dnsId}.${role}.username`);
+      const password = await credentialManager.retrieve(`dns.${dnsId}.${role}.password`);
+      if (username && password) return await refreshDnsToken(username, password, primaryIp);
+    } catch (err) { /* try next */ }
+    return null;
+  }
+
+  async function tryGlobalCredentials(primaryIp) {
+    try {
+      const username = await credentialManager.retrieve('dns.username');
+      const password = await credentialManager.retrieve('dns.password');
+      const server = await credentialManager.retrieve('dns.server');
+      if (username && password) return await refreshDnsToken(username, password, server || primaryIp);
+    } catch (err) { /* no global creds */ }
+    return null;
+  }
+
   async function ensureValidDnsToken() {
     if (dnsToken && dnsTokenExpiry && new Date() < new Date(dnsTokenExpiry)) {
       return { success: true, token: dnsToken };
@@ -129,20 +143,13 @@ function createProviderDnsContext(siteConfig, buildDomain, credentialManager, fe
       const dnsId = dnsIpToDnsId(primaryIp);
       if (dnsId) {
         for (const role of ['admin', 'readonly']) {
-          try {
+          const result = await tryServerRoleCredentials(dnsId, role, primaryIp);
-            const username = await credentialManager.retrieve(`dns.${dnsId}.${role}.username`);
+          if (result) return result;
-            const password = await credentialManager.retrieve(`dns.${dnsId}.${role}.password`);
-            if (username && password) return await refreshDnsToken(username, password, primaryIp);
-          } catch (err) { /* try next */ }
         }
       }
     }
-    try {
+    const globalResult = await tryGlobalCredentials(primaryIp);
-      const username = await credentialManager.retrieve('dns.username');
+    if (globalResult) return globalResult;
-      const password = await credentialManager.retrieve('dns.password');
-      const server = await credentialManager.retrieve('dns.server');
-      if (username && password) return await refreshDnsToken(username, password, server || primaryIp);
-    } catch (err) { /* no global creds */ }
     return { success: false, error: 'No DNS credentials configured' };
   }
 

dashcaddy-api/src/utils/logging.js

@@ -21,11 +21,8 @@ function createLogger(LOG_LEVEL) {
     
     if (Object.keys(data).length) entry.data = data;
     
-    const fn = level === 'error'
+    const logFns = { error: console.error, warn: console.warn, info: console.info, debug: console.info };
-      ? console.error
+    const fn = logFns[level] || console.info;
-      : level === 'warn'
-        ? console.warn
-        : console.info;
     fn(JSON.stringify(entry));
   }