@logboard/cli 1.0.0

package/server.js

@@ -0,0 +1,172 @@
+'use strict';
+const express = require('express');
+const helmet = require('helmet');
+const cookieParser = require('cookie-parser');
+const path = require('path');
+const config = require('./config');
+const { scheduleCleanup } = require('./lib/cleanup');
+const { closeAllStreams } = require('./lib/streams');
+const BatchWriter = require('./lib/batchWriter');
+const logger = require('./lib/logger');
+const ejsEngine = require('./lib/ejs');
+const { ipWhitelist } = require('./middleware/ipWhitelist');
+const { orgMiddleware, orgMiddlewareUI } = require('./middleware/org');
+
+const app = express();
+app.set('trust proxy', true);
+
+// ── View engine ────────────────────────────────────────────────────────────
+app.engine('ejs', ejsEngine.renderFile);
+app.set('view engine', 'ejs');
+app.set('views', path.join(__dirname, 'views'));
+
+// ── Static assets (logo, future public dir) ────────────────────────────────
+app.use('/public', express.static(path.join(__dirname, 'views')));
+
+// ── Security headers ───────────────────────────────────────────────────────
+app.use(helmet({
+	contentSecurityPolicy: {
+		directives: {
+			defaultSrc: ['\'self\''],
+			connectSrc: ['\'self\'', `http://localhost:${config.PORT}`, `ws://localhost:${config.PORT}`, 'https://cdn.jsdelivr.net'],
+			scriptSrc: ['\'self\'', '\'unsafe-inline\'', 'https://cdn.jsdelivr.net', 'https://unpkg.com'],
+			scriptSrcAttr: ['\'unsafe-inline\''],
+			styleSrc: ['\'self\'', '\'unsafe-inline\'', 'https://fonts.googleapis.com'],
+			fontSrc: ['\'self\'', 'https://fonts.gstatic.com', 'data:'],
+			imgSrc: ['\'self\'', 'data:', 'https:', 'http:'], // allow external logo URLs
+		},
+	},
+}));
+
+// ── CORS ───────────────────────────────────────────────────────────────────
+app.use((req, res, next) => {
+	const { origin } = req.headers;
+	if (!origin || config.CORS_ORIGINS.includes('*') || config.CORS_ORIGINS.includes(origin)) {
+		if (origin) { res.setHeader('Access-Control-Allow-Origin', origin); }
+		res.setHeader('Access-Control-Allow-Methods', 'GET,POST,PUT,PATCH,DELETE,OPTIONS');
+		res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Api-Key, Authorization');
+		res.setHeader('Access-Control-Allow-Credentials', 'true');
+	}
+	if (req.method === 'OPTIONS') { return res.sendStatus(204); }
+	next();
+});
+
+// ── Body / cookies ─────────────────────────────────────────────────────────
+app.use(express.json({ limit: config.MAX_BODY_SIZE }));
+app.use(cookieParser());
+app.use((req, _res, next) => { logger.debug(`${req.method} ${req.path}`); next(); });
+// req.org is attached by orgMiddleware — called inside each route after authenticate
+
+// ── Routes ─────────────────────────────────────────────────────────────────
+const healthRoute = require('./routes/health');
+const authRoute = require('./routes/auth');
+const streamRoute = require('./routes/stream');
+const analyticsRoute = require('./routes/analytics');
+const logsRoute = require('./routes/logs');
+const uiRoute = require('./routes/ui');
+const settingsRoute = require('./routes/settings');
+const apiAnalyticsRoute= require('./routes/api-analytics');
+const roleConfigRoute = require('./routes/role-config');
+const usersRoute = require('./routes/users');
+const apiKeysRoute = require('./routes/api-keys');
+const alertsRoute = require('./routes/alerts');
+const auditRoute = require('./routes/audit');
+const statusRoute = require('./routes/status');
+const archiveRoute = require('./routes/archive');
+const notificationsRoute = require('./routes/notifications');
+const savedSearchesRoute = require('./routes/saved-searches');
+const bookmarksRoute = require('./routes/bookmarks');
+const metricsRoute = require('./routes/metrics');
+const orgsRoute          = require('./routes/orgs');
+const superRoute         = require('./routes/super');
+const registrationRoute  = require('./routes/registration');
+
+const batchWriter = new BatchWriter();
+logsRoute.setWriter(batchWriter);
+uiRoute.setWriter(batchWriter);
+archiveRoute.setWriter(batchWriter);
+
+// ── Mount API routes ───────────────────────────────────────────────────────
+app.use('/api/health', healthRoute);
+app.use('/api/auth', authRoute);
+app.use('/api/logs/stream', streamRoute);
+// IP whitelist only on ingest endpoint
+app.use('/api/logs', ipWhitelist(), logsRoute.router);
+app.use('/api/analytics', analyticsRoute);
+app.use('/api/settings', settingsRoute);
+app.use('/api/api-analytics', apiAnalyticsRoute);
+app.use('/api/role-config', roleConfigRoute);
+app.use('/api/users', usersRoute);
+app.use('/api/api-keys', apiKeysRoute);
+app.use('/api/alerts', alertsRoute);
+app.use('/api/audit', auditRoute);
+app.use('/api/archive', archiveRoute.router);
+app.use('/status', statusRoute);
+app.use('/api/super',         superRoute);
+app.use('/api/orgs', orgsRoute);
+app.use('/api/notifications', notificationsRoute);
+app.use('/api/saved-searches', savedSearchesRoute);
+app.use('/api/bookmarks', bookmarksRoute);
+app.use('/api/metrics', metricsRoute);
+
+// ── Registration + OAuth routes (must be before UI catch-all) ───────────────
+app.use('/', registrationRoute);
+
+// ── UI routes ──────────────────────────────────────────────────────────────
+app.use('/', uiRoute.router);
+
+// ── 404 / error ────────────────────────────────────────────────────────────
+app.use((req, res) => {
+	if (req.path.startsWith('/api/')) { return res.status(404).json({ error: 'Not found' }); }
+	res.status(404).render('404', { title: '404', user: req.user||null });
+});
+app.use((err, _req, res, _next) => {
+	logger.error(`Unhandled: ${err.stack}`);
+	if (res.headersSent) { return; }
+	res.status(500).json({ error: 'Internal server error' });
+});
+
+scheduleCleanup();
+// Health monitor — alerts for RAM/CPU/disk
+const healthMonitor = require('./lib/healthMonitor');
+const SettingsService = require('./services/SettingsService');
+healthMonitor.start(() => new SettingsService().get());
+// Scheduled reports
+const ReportService = require('./services/ReportService');
+ReportService.startScheduler(() => new SettingsService().get());
+
+// Auto-migrate flat data to orgs structure on first start
+(async () => {
+  try {
+    const OrgSvc = require('./services/OrgService');
+    const result = await OrgSvc.migrateToDefaultOrg();
+    if (result.migrated) {
+      logger.info('[Startup] Auto-migrated existing data to default org');
+    }
+  } catch(e) { logger.warn('[Startup] Migration skipped: ' + e.message); }
+})();
+
+const server = app.listen(config.PORT, () => {
+	logger.info(`LogBoard  →  http://localhost:${config.PORT}`);
+	logger.info(`Env: ${config.NODE_ENV}  |  Log dir: ${config.LOG_BASE_DIR}`);
+	logger.info(`Data dir: ${config.DATA_DIR}`);
+});
+
+let shuttingDown = false;
+
+async function shutdown (sig) {
+	if (shuttingDown) { return; } shuttingDown=true;
+	logger.info(`${sig} received. Shutting down…`);
+	server.close(async () => {
+		try { await batchWriter.flushAll(); } catch (e) { logger.error(`Flush: ${e.message}`); }
+		closeAllStreams();
+		logger.info('Shutdown complete.');
+		process.exit(0);
+	});
+	setTimeout(() => { logger.error('Forced exit.'); process.exit(1); }, 10000).unref();
+}
+
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('uncaughtException', (e) => { logger.error(`Uncaught: ${e.stack}`); shutdown('uncaughtException'); });
+process.on('unhandledRejection', (r) => { logger.error(`UnhandledRejection: ${r}`); });

package/services/AlertRulesService.js

@@ -0,0 +1,323 @@
+'use strict';
+const fsP = require('fs').promises;
+const crypto = require('crypto');
+const os = require('os');
+const config = require('../config');
+const logger = require('../lib/logger');
+
+const RULE_TYPES = ['error_rate', 'error_count', 'keyword_match', 'log_volume'];
+
+class AlertRulesService {
+	constructor (org) {
+		this._org = org || null;
+	}
+
+	_file (cfgRef, orgAttr) {
+		return this._org && this._org[orgAttr] ? this._org[orgAttr] : cfgRef;
+	}
+
+	async _load () {
+		try {
+			return JSON.parse(
+				await fsP.readFile(
+					this._file(config.ALERTS_FILE, 'alertsFile'),
+					'utf8',
+				),
+			);
+		} catch (e) {
+			if (e.code === 'ENOENT') {
+				return { rules: [], history: [] };
+			}
+			throw e;
+		}
+	}
+
+	async _save (d) {
+		await fsP.writeFile(
+			this._file(config.ALERTS_FILE, 'alertsFile'),
+			JSON.stringify(d, null, 2),
+			'utf8',
+		);
+	}
+
+	async listRules () {
+		return (await this._load()).rules || [];
+	}
+
+	async getHistory (n = 50) {
+		return ((await this._load()).history || []).slice(-n).reverse();
+	}
+
+	async upsertRule (rule) {
+		if (!rule.name) {
+			throw Object.assign(new Error('name required'), { status: 400 });
+		}
+		if (!RULE_TYPES.includes(rule.type)) {
+			throw Object.assign(
+				new Error(
+					`invalid type: ${rule.type}. Valid: ${RULE_TYPES.join(', ')}`,
+				),
+				{ status: 400 },
+			);
+		}
+		const d = await this._load();
+		const id = rule.id || crypto.randomUUID();
+		const idx = (d.rules || []).findIndex((r) => r.id === id);
+		const entry = {
+			id,
+			name: rule.name,
+			type: rule.type,
+			service: rule.service || '',
+			threshold: Number(rule.threshold) || 5,
+			windowMinutes: Number(rule.windowMinutes) || 10,
+			cooldownMinutes: Number(rule.cooldownMinutes) || 30,
+			keyword: rule.keyword || '',
+			enabled: rule.enabled !== false,
+			// Per-rule delivery overrides (fall back to global settings if empty)
+			slackUrl: rule.slackUrl || '',
+			discordUrl: rule.discordUrl || '',
+			emailTo: rule.emailTo || '',
+			pagerdutyKey: rule.pagerdutyKey || '',
+			lastFiredAt: rule.lastFiredAt || null,
+			createdAt: rule.createdAt || new Date().toISOString(),
+		};
+		if (idx >= 0) {
+			d.rules[idx] = entry;
+		} else {
+			d.rules = [...(d.rules || []), entry];
+		}
+		await this._save(d);
+		return entry;
+	}
+
+	async deleteRule (id) {
+		const d = await this._load();
+		d.rules = (d.rules || []).filter((r) => r.id !== id);
+		await this._save(d);
+	}
+
+	// ── Evaluate incoming log batch ────────────────────────────────────────────
+	async evaluate (parsedLogs, settings) {
+		const rules = (await this.listRules()).filter((r) => r.enabled);
+		if (!rules.length) {
+			return;
+		}
+		const now = Date.now();
+		for (const rule of rules) {
+			if (
+				rule.lastFiredAt
+        && now - new Date(rule.lastFiredAt).getTime()
+          < rule.cooldownMinutes * 60_000
+			) {
+				continue;
+			}
+			const subset = rule.service
+				? parsedLogs.filter((l) => (l.appName || '').startsWith(rule.service))
+				: parsedLogs;
+			let triggered = false,
+				triggerMsg = '';
+			if (rule.type === 'error_count') {
+				const n = subset.filter(
+					(l) => (l.level || '').toLowerCase() === 'error',
+				).length;
+				if (n >= rule.threshold) {
+					triggered = true;
+					triggerMsg = `${n} errors in batch (threshold: ${rule.threshold})`;
+				}
+			} else if (rule.type === 'error_rate') {
+				const n = subset.filter(
+					(l) => (l.level || '').toLowerCase() === 'error',
+				).length;
+				const pct = subset.length ? (n / subset.length) * 100 : 0;
+				if (pct >= rule.threshold) {
+					triggered = true;
+					triggerMsg = `${pct.toFixed(1)}% error rate (threshold: ${rule.threshold}%)`;
+				}
+			} else if (rule.type === 'keyword_match' && rule.keyword) {
+				const kw = rule.keyword.toLowerCase();
+				const n = subset.filter((l) =>
+					JSON.stringify(l).toLowerCase().includes(kw),
+				).length;
+				if (n >= rule.threshold) {
+					triggered = true;
+					triggerMsg = `${n} occurrences of "${rule.keyword}"`;
+				}
+			} else if (rule.type === 'log_volume') {
+				if (subset.length >= rule.threshold) {
+					triggered = true;
+					triggerMsg = `${subset.length} logs in batch (threshold: ${rule.threshold})`;
+				}
+			}
+			if (triggered) {
+				await this._fire(rule, triggerMsg, settings);
+			}
+		}
+	}
+
+	// ── Fire: save history + notify all channels ───────────────────────────────
+	async _fire (rule, message, settings) {
+		const ts = new Date().toISOString();
+		const d = await this._load();
+		d.history = [
+			...(d.history || []),
+			{
+				ts,
+				ruleId: rule.id,
+				ruleName: rule.name,
+				service: rule.service || 'all',
+				message,
+			},
+		].slice(-500);
+		const idx = (d.rules || []).findIndex((r) => r.id === rule.id);
+		if (idx >= 0) {
+			d.rules[idx].lastFiredAt = ts;
+		}
+		await this._save(d);
+		logger.info(`[Alert] "${rule.name}" fired: ${message}`);
+
+		// In-app notification bell
+		try {
+			const N = require('./NotificationService');
+			await N.create({
+				type: 'alert',
+				title: `Alert: ${rule.name}`,
+				body: message,
+				ruleId: rule.id,
+				service: rule.service || 'all',
+			});
+		} catch {}
+
+		const p = {
+			rule: rule.name,
+			trigger: message,
+			service: rule.service || 'all',
+			ts,
+			host: os.hostname(),
+		};
+
+		// All channels in parallel — one failure never blocks others
+		await Promise.allSettled([
+			this._slack(rule.slackUrl || settings?.webhookUrl || '', p),
+			this._discord(rule.discordUrl || settings?.discordUrl || '', p),
+			this._email(rule.emailTo || settings?.reportEmail || '', settings, p),
+			this._pagerduty(
+				rule.pagerdutyKey || settings?.pagerdutyKey || '',
+				settings,
+				p,
+			),
+		]);
+	}
+
+	async _slack (url, p) {
+		if (!url) {
+			return;
+		}
+		await fetch(url, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({
+				text: `:rotating_light: *LogBoard Alert* — ${p.rule}`,
+				attachments: [
+					{
+						color: 'danger',
+						fields: [
+							{ title: 'Rule', value: p.rule, short: true },
+							{ title: 'Trigger', value: p.trigger, short: true },
+							{ title: 'Service', value: p.service, short: true },
+							{ title: 'Host', value: p.host, short: true },
+							{ title: 'Time', value: p.ts, short: true },
+						],
+					},
+				],
+			}),
+			signal: AbortSignal.timeout(5000),
+		}).catch((e) => logger.warn(`[Alert] Slack: ${e.message}`));
+	}
+
+	async _discord (url, p) {
+		if (!url) {
+			return;
+		}
+		await fetch(url, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({
+				username: 'LogBoard',
+				embeds: [
+					{
+						title: `🚨 Alert: ${p.rule}`,
+						description: p.trigger,
+						color: 0xef4444,
+						fields: [
+							{ name: 'Service', value: p.service, inline: true },
+							{ name: 'Host', value: p.host, inline: true },
+						],
+						timestamp: p.ts,
+						footer: { text: 'LogBoard Alert System' },
+					},
+				],
+			}),
+			signal: AbortSignal.timeout(5000),
+		}).catch((e) => logger.warn(`[Alert] Discord: ${e.message}`));
+	}
+
+	async _email (to, settings, p) {
+		if (!to || !settings?.smtpHost || !settings?.emailEnabled) {
+			return;
+		}
+		try {
+			const nm = require('nodemailer');
+			const tr = nm.createTransport({
+				host: settings.smtpHost,
+				port: Number(settings.smtpPort || 587),
+				secure: Number(settings.smtpPort) === 465,
+				auth: { user: settings.smtpUser, pass: settings.smtpPass },
+			});
+			await tr.sendMail({
+				from: settings.smtpFrom || 'logboard@example.com',
+				to,
+				subject: `[LogBoard Alert] ${p.rule} — ${p.service}`,
+				text: `Rule: ${p.rule}\nTrigger: ${p.trigger}\nService: ${p.service}\nHost: ${p.host}\nTime: ${p.ts}`,
+				html: `<h2 style="color:#ef4444">🚨 LogBoard Alert</h2>
+          <table cellpadding="8" style="font-family:sans-serif;font-size:14px;border-collapse:collapse;">
+            <tr><td><b>Rule</b></td><td>${p.rule}</td></tr>
+            <tr><td><b>Trigger</b></td><td>${p.trigger}</td></tr>
+            <tr><td><b>Service</b></td><td>${p.service}</td></tr>
+            <tr><td><b>Host</b></td><td>${p.host}</td></tr>
+            <tr><td><b>Time</b></td><td>${p.ts}</td></tr>
+          </table>`,
+			});
+		} catch (e) {
+			logger.warn(`[Alert] Email: ${e.message}`);
+		}
+	}
+
+	async _pagerduty (key, settings, p) {
+		if (!key || !settings?.pagerdutyEnabled) {
+			return;
+		}
+		await fetch('https://events.pagerduty.com/v2/enqueue', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({
+				routing_key: key,
+				event_action: 'trigger',
+				dedup_key: `logboard-${p.rule}-${new Date().toISOString().slice(0, 10)}`,
+				payload: {
+					summary: `${p.rule}: ${p.trigger}`.slice(0, 1024),
+					source: p.host,
+					severity: 'error',
+					timestamp: p.ts,
+					custom_details: {
+						rule: p.rule,
+						service: p.service,
+						trigger: p.trigger,
+					},
+				},
+			}),
+			signal: AbortSignal.timeout(8000),
+		}).catch((e) => logger.warn(`[Alert] PagerDuty: ${e.message}`));
+	}
+}
+
+module.exports = new AlertRulesService();