Initial commit: DashCaddy v1.0

Full codebase including API server (32 modules + routes), dashboard frontend,
DashCA certificate distribution, installer script, and deployment skills.

dashcaddy-api/routes/notifications.js

@@ -0,0 +1,185 @@
+const express = require('express');
+const { validateURL, validateToken } = require('../input-validator');
+const { paginate, parsePaginationParams } = require('../pagination');
+
+module.exports = function(ctx) {
+  const router = express.Router();
+
+  // GET /config — Get notification configuration (sensitive data redacted)
+  router.get('/config', ctx.asyncHandler(async (req, res) => {
+      const notificationConfig = ctx.notification.getConfig();
+      // Return config without sensitive data
+      const safeConfig = {
+        enabled: notificationConfig.enabled,
+        providers: {
+          discord: {
+            enabled: notificationConfig.providers.discord?.enabled || false,
+            configured: !!notificationConfig.providers.discord?.webhookUrl
+          },
+          telegram: {
+            enabled: notificationConfig.providers.telegram?.enabled || false,
+            configured: !!(notificationConfig.providers.telegram?.botToken && notificationConfig.providers.telegram?.chatId)
+          },
+          ntfy: {
+            enabled: notificationConfig.providers.ntfy?.enabled || false,
+            configured: !!notificationConfig.providers.ntfy?.topic,
+            serverUrl: notificationConfig.providers.ntfy?.serverUrl || 'https://ntfy.sh'
+          }
+        },
+        events: notificationConfig.events,
+        healthCheck: notificationConfig.healthCheck
+      };
+      res.json({ success: true, config: safeConfig });
+  }, 'notifications-config-get'));
+
+  // POST /config — Update notification configuration
+  router.post('/config', ctx.asyncHandler(async (req, res) => {
+      const { enabled, providers, events, healthCheck } = req.body;
+      const notificationConfig = ctx.notification.getConfig();
+
+      // Validate provider webhook URLs and tokens
+      if (providers) {
+        if (providers.discord?.webhookUrl) {
+          try {
+            validateURL(providers.discord.webhookUrl);
+          } catch (validationErr) {
+            return ctx.errorResponse(res, 400, 'Invalid Discord webhook URL');
+          }
+        }
+        if (providers.telegram?.botToken) {
+          try {
+            validateToken(providers.telegram.botToken);
+          } catch (validationErr) {
+            return ctx.errorResponse(res, 400, 'Invalid Telegram bot token format');
+          }
+        }
+        if (providers.ntfy?.serverUrl) {
+          try {
+            validateURL(providers.ntfy.serverUrl);
+          } catch (validationErr) {
+            return ctx.errorResponse(res, 400, 'Invalid ntfy server URL');
+          }
+        }
+        if (providers.ntfy?.topic) {
+          const topicRegex = /^[a-zA-Z0-9_-]{1,64}$/;
+          if (!topicRegex.test(providers.ntfy.topic)) {
+            return ctx.errorResponse(res, 400, 'Invalid ntfy topic (alphanumeric, hyphens, underscores only, max 64 chars)');
+          }
+        }
+      }
+
+      // Update enabled state
+      if (typeof enabled === 'boolean') {
+        notificationConfig.enabled = enabled;
+      }
+
+      // Update providers (only update provided fields)
+      if (providers) {
+        if (providers.discord) {
+          notificationConfig.providers.discord = {
+            ...notificationConfig.providers.discord,
+            ...providers.discord
+          };
+        }
+        if (providers.telegram) {
+          notificationConfig.providers.telegram = {
+            ...notificationConfig.providers.telegram,
+            ...providers.telegram
+          };
+        }
+        if (providers.ntfy) {
+          notificationConfig.providers.ntfy = {
+            ...notificationConfig.providers.ntfy,
+            ...providers.ntfy
+          };
+        }
+      }
+
+      // Update events
+      if (events) {
+        notificationConfig.events = { ...notificationConfig.events, ...events };
+      }
+
+      // Update health check settings
+      if (healthCheck) {
+        const wasEnabled = notificationConfig.healthCheck?.enabled;
+        notificationConfig.healthCheck = { ...notificationConfig.healthCheck, ...healthCheck };
+
+        // Restart daemon if settings changed
+        if (healthCheck.enabled !== wasEnabled || healthCheck.intervalMinutes) {
+          if (notificationConfig.healthCheck.enabled) {
+            ctx.notification.startHealthDaemon();
+          } else {
+            ctx.notification.stopHealthDaemon();
+          }
+        }
+      }
+
+      await ctx.notification.saveConfig();
+      res.json({ success: true, message: 'Notification config updated' });
+  }, 'notifications-config-update'));
+
+  // POST /test — Test notification delivery
+  router.post('/test', ctx.asyncHandler(async (req, res) => {
+    const { provider } = req.body;
+
+    if (provider) {
+      // Test specific provider
+      let result;
+      switch (provider) {
+        case 'discord':
+          result = await ctx.notification.sendDiscord('Test Notification', 'This is a test notification from DashCaddy.', 'info');
+          break;
+        case 'telegram':
+          result = await ctx.notification.sendTelegram('Test Notification', 'This is a test notification from DashCaddy.', 'info');
+          break;
+        case 'ntfy':
+          result = await ctx.notification.sendNtfy('Test Notification', 'This is a test notification from DashCaddy.', 'info');
+          break;
+        default:
+          return ctx.errorResponse(res, 400, 'Unknown provider');
+      }
+      res.json({ success: result.success, provider, error: result.error });
+    } else {
+      // Test all enabled providers
+      const result = await ctx.notification.send('test', 'Test Notification', 'This is a test notification from DashCaddy.', 'info');
+      res.json({ success: true, ...result });
+    }
+  }, 'notifications-test'));
+
+  // GET /history — Get notification history
+  router.get('/history', ctx.asyncHandler(async (req, res) => {
+    const notificationHistory = ctx.notification.getHistory();
+    const paginationParams = parsePaginationParams(req.query);
+    if (paginationParams) {
+      const result = paginate(notificationHistory, paginationParams);
+      res.json({ success: true, history: result.data, total: notificationHistory.length, pagination: result.pagination });
+    } else {
+      const limit = parseInt(req.query.limit) || 50;
+      res.json({
+        success: true,
+        history: notificationHistory.slice(0, limit),
+        total: notificationHistory.length
+      });
+    }
+  }, 'notifications-history'));
+
+  // DELETE /history — Clear notification history
+  router.delete('/history', ctx.asyncHandler(async (req, res) => {
+    ctx.notification.clearHistory();
+    res.json({ success: true, message: 'Notification history cleared' });
+  }, 'notifications-history-clear'));
+
+  // POST /health-check — Manually trigger health check
+  router.post('/health-check', ctx.asyncHandler(async (req, res) => {
+    await ctx.notification.checkHealth();
+    const notificationConfig = ctx.notification.getConfig();
+    res.json({
+      success: true,
+      lastCheck: notificationConfig.healthCheck.lastCheck,
+      containersMonitored: Object.keys(ctx.notification.getHealthState()).length
+    });
+  }, 'notifications-health-check'));
+
+  return router;
+};