@logboard/cli 1.0.0

package/controllers/UserController.js

@@ -0,0 +1,79 @@
+const audit = require('../services/AuditService');
+('use strict');
+const UserService = require('../services/UserService');
+const svc = new UserService();
+
+class UserController {
+	async list (req, res) {
+		try {
+			res.json(await svc.getAll());
+		} catch (e) {
+			res.status(500).json({ error: e.message });
+		}
+	}
+
+	async create (req, res) {
+		try {
+			const { username, password, role } = req.body;
+			res
+				.status(201)
+				.json(await svc.add(username, password, role, req.user.username));
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+
+	async updateRole (req, res) {
+		try {
+			await svc.updateRole(
+				req.params.username,
+				req.body.role,
+				req.user.username,
+			);
+			new audit()
+				.log(
+					req.user?.username,
+					'user_delete',
+					req.params.username,
+					{},
+					req.ip || '',
+				)
+				.catch(() => {});
+			res.json({ success: true });
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+
+	async resetPassword (req, res) {
+		try {
+			await svc.resetPassword(
+				req.params.username,
+				req.body.newPassword,
+				req.user.username,
+			);
+			res.json({ success: true });
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+
+	async remove (req, res) {
+		try {
+			await svc.remove(req.params.username, req.user.username);
+			res.json({ success: true });
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+
+	async revoke2fa (req, res) {
+		try {
+			await svc.revoke2fa(req.params.username, req.user.username);
+			res.json({ success: true });
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+}
+module.exports = UserController;

package/lib/batchWriter.js

@@ -0,0 +1,57 @@
+"use strict";
+const { getLogStream } = require("./streams");
+const logger = require("./logger");
+const config = require("../config");
+
+class BatchWriter {
+  constructor() {
+    this.buffer = new Map(); // key → { appName, date, logsDir, logs[] }
+    this.timers = new Map();
+  }
+
+  // logsDir is optional — defaults to config.LOG_BASE_DIR for backward compat
+  write(appName, date, log, logsDir, type) {
+    const base = logsDir || config.LOG_BASE_DIR;
+
+    const key = `${base}\x00${appName}\x00${date}`;
+
+    if (!this.buffer.has(key)) {
+      this.buffer.set(key, { appName, date, logsDir: base, logs: [] });
+    }
+    const entry = this.buffer.get(key);
+    entry.logs.push(log);
+    if (entry.logs.length >= config.BATCH_SIZE) {
+      this._flushKey(key);
+    } else if (!this.timers.has(key)) {
+      this.timers.set(
+        key,
+        setTimeout(() => this._flushKey(key), config.BATCH_TIMEOUT),
+      );
+    }
+  }
+
+  _flushKey(key) {
+    const timer = this.timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+    const entry = this.buffer.get(key);
+    if (!entry || !entry.logs.length) return;
+    this.buffer.delete(key);
+    const { appName, date, logsDir, logs } = entry;
+    const stream = getLogStream(appName, date, logsDir);
+    for (const log of logs) {
+      stream.write(`${log}\n`, (err) => {
+        if (err)
+          logger.error(`[BatchWriter] ${appName}/${date}: ${err.message}`);
+      });
+    }
+  }
+
+  async flushAll() {
+    for (const key of this.buffer.keys()) this._flushKey(key);
+  }
+}
+
+module.exports = BatchWriter;

package/lib/cleanup.js

@@ -0,0 +1,67 @@
+'use strict';
+const fs = require('fs').promises;
+const path = require('path');
+const config = require('../config');
+const logger = require('./logger');
+
+async function cleanupOldLogs () {
+	logger.info('[Cleanup] Running log retention cleanup…');
+	const cutoff = new Date();
+	cutoff.setDate(cutoff.getDate() - config.RETENTION_DAYS);
+	const cutoffStr = cutoff.toISOString().slice(0, 10);
+
+	let appDirs;
+	try {
+		appDirs = await fs.readdir(config.LOG_BASE_DIR);
+	} catch (err) {
+		if (err.code === 'ENOENT') {
+			return;
+		}
+		throw err;
+	}
+
+	let deleted = 0;
+	for (const app of appDirs) {
+		const appPath = path.join(config.LOG_BASE_DIR, app);
+		try {
+			const stat = await fs.stat(appPath);
+			if (!stat.isDirectory()) {
+				continue;
+			}
+			const files = await fs.readdir(appPath);
+			for (const file of files) {
+				const m = file.match(/^(\d{4}-\d{2}-\d{2})\.log$/);
+				if (!m || m[1] >= cutoffStr) {
+					continue;
+				}
+				try {
+					await fs.unlink(path.join(appPath, file));
+					deleted++;
+					logger.info(`[Cleanup] Deleted ${app}/${file}`);
+				} catch (e) {
+					logger.error(
+						`[Cleanup] Failed to delete ${app}/${file}: ${e.message}`,
+					);
+				}
+			}
+		} catch (err) {
+			logger.warn(`[Cleanup] Skipping ${app}: ${err.message}`);
+		}
+	}
+	logger.info(`[Cleanup] Done. Deleted ${deleted} file(s).`);
+}
+
+function scheduleCleanup () {
+	cleanupOldLogs().catch((err) =>
+		logger.error(`[Cleanup] Error: ${err.message}`),
+	);
+	setInterval(
+		() =>
+			cleanupOldLogs().catch((err) =>
+				logger.error(`[Cleanup] Error: ${err.message}`),
+			),
+		config.CLEANUP_INTERVAL,
+	).unref();
+}
+
+module.exports = { scheduleCleanup, cleanupOldLogs };

package/lib/ejs.js

@@ -0,0 +1,103 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const cache = new Map();
+
+function escapeHtml (str) {
+	if (str == null) {
+		return '';
+	}
+	return String(str)
+		.replace(/&/g, '&')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&#39;');
+}
+
+function compile (template) {
+	let src = `'use strict';\nlet __buf=[];\nconst __e=${escapeHtml.toString()};\n`;
+	const re = /<%([-=#]?)([\s\S]*?)%>/g;
+	let cursor = 0,
+		match;
+	while ((match = re.exec(template)) !== null) {
+		if (match.index > cursor) {
+			src += `__buf.push(${JSON.stringify(template.slice(cursor, match.index))});\n`;
+		}
+		const type = match[1],
+			content = match[2].trim();
+		if (!type) {
+			src += `${content}\n`;
+		} else if (type === '=') {
+			src += `__buf.push(__e(${content}));\n`;
+		} else if (type === '-') {
+			src += `__buf.push(${content});\n`;
+		}
+		cursor = match.index + match[0].length;
+	}
+	if (cursor < template.length) {
+		src += `__buf.push(${JSON.stringify(template.slice(cursor))});\n`;
+	}
+	src += 'return __buf.join("");';
+	return src;
+}
+
+function render (template, locals, viewsDir) {
+	const src = compile(template);
+	const merged = {
+		allowedCards: [],
+		allowedPages: null,
+		user: null,
+		title: '',
+		...(locals || {}),
+	};
+	// canSee: returns true if allowedPages is null (not loaded) OR pageId is in list
+	merged.canSee = function (pageId) {
+		if (!merged.allowedPages || !merged.allowedPages.length) {
+			return true;
+		}
+		return merged.allowedPages.includes(pageId);
+	};
+	// hasCard: returns true if allowedCards is empty (not loaded) OR cardId is in list
+	merged.hasCard = function (cardId) {
+		if (!merged.allowedCards || !merged.allowedCards.length) {
+			return true;
+		}
+		return merged.allowedCards.includes(cardId);
+	};
+	const include = function (relPath, extra) {
+		const fp = path.resolve(
+			viewsDir,
+			relPath.endsWith('.ejs') ? relPath : `${relPath}.ejs`,
+		);
+		return render(
+			fs.readFileSync(fp, 'utf8'),
+			Object.assign({}, merged, extra || {}),
+			path.dirname(fp),
+		);
+	};
+	const fn = new Function('include', 'locals', `with(locals){\n${src}\n}`);
+	return fn(include, merged);
+}
+
+function renderFile (filePath, options, callback) {
+	try {
+		const viewsDir
+      = (options && options.settings && options.settings.views)
+      || path.dirname(filePath);
+		let tpl;
+		if (process.env.NODE_ENV === 'production' && cache.has(filePath)) {
+			tpl = cache.get(filePath);
+		} else {
+			tpl = fs.readFileSync(filePath, 'utf8');
+			if (process.env.NODE_ENV === 'production') {
+				cache.set(filePath, tpl);
+			}
+		}
+		callback(null, render(tpl, options, viewsDir));
+	} catch (err) {
+		callback(err);
+	}
+}
+
+module.exports = { renderFile, render, compile, escapeHtml };

package/lib/emitter.js

@@ -0,0 +1,5 @@
+'use strict';
+const EventEmitter = require('events');
+const emitter = new EventEmitter();
+emitter.setMaxListeners(500);
+module.exports = emitter;

package/lib/healthMonitor.js

@@ -0,0 +1,245 @@
+'use strict';
+const os = require('os');
+const path = require('path');
+const config = require('../config');
+const logger = require('../lib/logger');
+
+const COOLDOWN_MS = 15 * 60_000;
+const lastFired = { ram: 0, cpu: 0, disk: 0 };
+
+function getCpuPercent () {
+	return new Promise((resolve) => {
+		const start = os
+			.cpus()
+			.map((c) => ({
+				idle: c.times.idle,
+				total: Object.values(c.times).reduce((a, b) => a + b, 0),
+			}));
+		setTimeout(() => {
+			const end = os
+				.cpus()
+				.map((c) => ({
+					idle: c.times.idle,
+					total: Object.values(c.times).reduce((a, b) => a + b, 0),
+				}));
+			let idleDiff = 0,
+				totalDiff = 0;
+			for (let i = 0; i < start.length; i++) {
+				idleDiff += end[i].idle - start[i].idle;
+				totalDiff += end[i].total - start[i].total;
+			}
+			resolve(
+				totalDiff === 0 ? 0 : Math.round((1 - idleDiff / totalDiff) * 100),
+			);
+		}, 1000);
+	});
+}
+
+function getRamPercent () {
+	const total = os.totalmem(),
+		free = os.freemem();
+	return Math.round(((total - free) / total) * 100);
+}
+
+function getDiskPercent () {
+	try {
+		const { execSync } = require('child_process');
+		const logDir = config.LOG_BASE_DIR || '/';
+		if (process.platform === 'win32') {
+			const out = execSync('wmic logicaldisk get size,freespace,caption', {
+				timeout: 3000,
+			}).toString();
+			const drive = path.parse(logDir).root.replace('\\', '');
+			const lines = out.split('\n').filter((l) => l.includes(drive));
+			if (lines.length) {
+				const [, free, size] = lines[0].trim().split(/\s+/);
+				return size ? Math.round((1 - Number(free) / Number(size)) * 100) : 0;
+			}
+			return 0;
+		}
+		const out = execSync(`df -k "${logDir}" 2>/dev/null | tail -1`, {
+			timeout: 3000,
+		}).toString();
+		const parts = out.trim().split(/\s+/);
+		const pct = parts[4] ? parseInt(parts[4], 10) : 0;
+		return isNaN(pct) ? 0 : pct;
+	} catch {
+		return 0;
+	}
+}
+
+/**
+ * Render the Slack message template.
+ * Template variables: {appName} {metric} {value} {threshold} {host} {time}
+ */
+function renderTemplate (tpl, vars) {
+	if (!tpl) {
+		return `⚠️ LogBoard Alert: ${vars.metric} at ${vars.value}% on ${vars.host}`;
+	}
+	return tpl
+		.replace(/\{appName\}/g, vars.appName || 'LogBoard')
+		.replace(/\{metric\}/g, vars.metric || '')
+		.replace(/\{value\}/g, vars.value || '')
+		.replace(/\{threshold\}/g, vars.threshold || '')
+		.replace(/\{host\}/g, vars.host || os.hostname())
+		.replace(/\{time\}/g, vars.time || new Date().toLocaleString());
+}
+
+async function sendSlack (url, text, fields) {
+	if (!url) {
+		return;
+	}
+	try {
+		const axios = require('axios');
+		await axios.post(
+			url,
+			{ text, attachments: [{ color: 'warning', fields }] },
+			{ timeout: 5000 },
+		);
+	} catch (e) {
+		logger.warn(`[HealthMonitor] Slack failed: ${e.message}`);
+	}
+}
+
+async function check (settings = {}) {
+	const webhookUrl = settings.webhookUrl || config.WEBHOOK_URL || '';
+	const ramThresh = settings.alertRamPct ?? config.ALERT_RAM_PCT ?? 85;
+	const cpuThresh = settings.alertCpuPct ?? config.ALERT_CPU_PCT ?? 90;
+	const diskThresh = settings.alertDiskPct ?? config.ALERT_DISK_PCT ?? 90;
+	const alertEnabled = settings.alertsEnabled !== false;
+	const template = settings.alertSlackTemplate || '';
+	const appName = settings.appName || 'LogBoard';
+	const now = Date.now();
+
+	if (!alertEnabled) {
+		return;
+	}
+
+	const ramPct = getRamPercent();
+	const diskPct = getDiskPercent();
+	const cpuPct = await getCpuPercent();
+
+	const metrics = [
+		{
+			key: 'ram',
+			pct: ramPct,
+			thresh: ramThresh,
+			label: 'RAM',
+			emoji: ':fire:',
+		},
+		{
+			key: 'cpu',
+			pct: cpuPct,
+			thresh: cpuThresh,
+			label: 'CPU',
+			emoji: ':zap:',
+		},
+		{
+			key: 'disk',
+			pct: diskPct,
+			thresh: diskThresh,
+			label: 'Disk',
+			emoji: ':floppy_disk:',
+		},
+	];
+
+	for (const m of metrics) {
+		if (m.pct < m.thresh) {
+			continue;
+		}
+		if (now - lastFired[m.key] < COOLDOWN_MS) {
+			continue;
+		}
+		lastFired[m.key] = now;
+
+		const vars = {
+			appName,
+			metric: m.label,
+			value: m.pct,
+			threshold: m.thresh,
+			host: os.hostname(),
+			time: new Date().toLocaleString(),
+		};
+
+		const text = template
+			? renderTemplate(template, vars)
+			: `${m.emoji} *${appName}* — High ${m.label} Usage: *${m.pct}%* (threshold: ${m.thresh}%) on \`${os.hostname()}\``;
+
+		if (webhookUrl) {
+			await sendSlack(webhookUrl, text, [
+				{
+					title: `${m.label} Used`,
+					value: `${m.pct}%  (threshold: ${m.thresh}%)`,
+					short: true,
+				},
+				{ title: 'App', value: appName, short: true },
+				{ title: 'Host', value: os.hostname(), short: true },
+				{ title: 'Time', value: vars.time, short: true },
+			]);
+			logger.warn(`[HealthMonitor] ${m.label} alert fired: ${m.pct}%`);
+		}
+
+		// Also notify via Discord if configured
+		if (settings.discordUrl) {
+			try {
+				await require('axios').post(
+					settings.discordUrl,
+					{
+						username: appName,
+						embeds: [
+							{
+								title: `⚠️ ${m.label} Alert`,
+								description: `${m.pct}% used (threshold: ${m.thresh}%)`,
+								color: 0xf59e0b,
+								fields: [{ name: 'Host', value: os.hostname(), inline: true }],
+								timestamp: new Date().toISOString(),
+							},
+						],
+					},
+					{ timeout: 5000 },
+				);
+			} catch {}
+		}
+	}
+
+	return { ramPct, cpuPct, diskPct };
+}
+
+let _interval = null;
+
+function start (getSettings) {
+	if (_interval) {
+		return;
+	}
+	_interval = setInterval(async () => {
+		try {
+			const s
+        = typeof getSettings === 'function'
+        	? await getSettings()
+        	: getSettings || {};
+			await check(s);
+		} catch (e) {
+			logger.warn(`[HealthMonitor] check error: ${e.message}`);
+		}
+	}, 60_000);
+	if (_interval.unref) {
+		_interval.unref();
+	}
+	logger.info('[HealthMonitor] Started — checking every 60s');
+}
+
+function stop () {
+	if (_interval) {
+		clearInterval(_interval);
+		_interval = null;
+	}
+}
+
+module.exports = {
+	start,
+	stop,
+	check,
+	getRamPercent,
+	getCpuPercent,
+	getDiskPercent,
+};

package/lib/logger.js

@@ -0,0 +1,21 @@
+'use strict';
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+const cur = LEVELS[process.env.LOG_LEVEL] ?? LEVELS.info;
+
+function log (level, message) {
+	if (LEVELS[level] > cur) {
+		return;
+	}
+	const line = JSON.stringify({ ts: new Date().toISOString(), level, message });
+	(level === 'error' || level === 'warn'
+		? process.stderr
+		: process.stdout
+	).write(`${line}\n`);
+}
+
+module.exports = {
+	error: (m) => log('error', m),
+	warn: (m) => log('warn', m),
+	info: (m) => log('info', m),
+	debug: (m) => log('debug', m),
+};

package/lib/streams.js

@@ -0,0 +1,32 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const config = require('../config');
+const logger = require('./logger');
+const { ensureDir } = require('./utils');
+
+const activeStreams = new Map();
+
+function getLogStream (appName, date, logsDir) {
+	const baseDir = logsDir || config.LOG_BASE_DIR;
+	const key = `${baseDir}\x00${appName}\x00${date}`;
+	if (activeStreams.has(key)) { return activeStreams.get(key); }
+
+	const dir = path.join(baseDir, appName);
+	ensureDir(dir);
+	const filePath = path.join(dir, `${date}.log`);
+	const stream = fs.createWriteStream(filePath, { flags: 'a' });
+	stream.on('error', (err) => {
+		logger.error(`[Stream] ${filePath}: ${err.message}`);
+		activeStreams.delete(key);
+	});
+	activeStreams.set(key, stream);
+	return stream;
+}
+
+function closeAllStreams () {
+	for (const s of activeStreams.values()) { s.end(); }
+	activeStreams.clear();
+}
+
+module.exports = { getLogStream, closeAllStreams };

package/lib/theme.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const PRESETS = {
+	'dark-indigo': { mode: 'dark', r: 99, g: 102, b: 241, label: 'Dark Indigo' },
+	'dark-violet': { mode: 'dark', r: 139, g: 92, b: 246, label: 'Dark Violet' },
+	'dark-rose': { mode: 'dark', r: 244, g: 63, b: 94, label: 'Dark Rose' },
+	'dark-emerald': {
+		mode: 'dark',
+		r: 16,
+		g: 185,
+		b: 129,
+		label: 'Dark Emerald',
+	},
+	'dark-sky': { mode: 'dark', r: 14, g: 165, b: 233, label: 'Dark Sky' },
+	'dark-amber': { mode: 'dark', r: 245, g: 158, b: 11, label: 'Dark Amber' },
+	'light-indigo': {
+		mode: 'light',
+		r: 99,
+		g: 102,
+		b: 241,
+		label: 'Light Indigo',
+	},
+	'light-violet': {
+		mode: 'light',
+		r: 139,
+		g: 92,
+		b: 246,
+		label: 'Light Violet',
+	},
+	'light-sky': { mode: 'light', r: 14, g: 165, b: 233, label: 'Light Sky' },
+};
+
+/**
+ * Build CSS variable overrides + data-theme setter for the given settings.
+ * Called inside head.ejs on every page render.
+ */
+function buildThemeSnippet (s) {
+	if (!s || typeof s !== 'object') {
+		return '';
+	}
+
+	// Read accent from settings; fall back to default indigo
+	const r = Math.max(0, Math.min(255, Number(s.accentR ?? s.accentR ?? 99)));
+	const g = Math.max(0, Math.min(255, Number(s.accentG ?? 102)));
+	const b = Math.max(0, Math.min(255, Number(s.accentB ?? 241)));
+	const mode = s.themeMode === 'light' ? 'light' : 'dark';
+
+	// Lighter variant for text on accent backgrounds
+	const lr = Math.min(255, r + 55);
+	const lg = Math.min(255, g + 55);
+	const lb = Math.min(255, b + 55);
+
+	return [
+		'<style id="lb-theme">',
+		':root {',
+		`  --accent:     rgb(${r},${g},${b});`,
+		`  --accent-l:   rgb(${lr},${lg},${lb});`,
+		`  --accent-dim: rgba(${r},${g},${b},.15);`,
+		`  --accent-btn: rgb(${r},${g},${b});`,
+		'}',
+		'</style>',
+		'<script>',
+		'(function(){',
+		'  var stored = localStorage.getItem(\'theme\');',
+		`  var mode   = stored || '${mode}';`,
+		'  document.documentElement.setAttribute(\'data-theme\', mode);',
+		'  // Apply accent vars immediately (prevents flash)',
+		'  var s = document.documentElement.style;',
+		`  s.setProperty('--accent',     'rgb(${r},${g},${b})');`,
+		`  s.setProperty('--accent-l',   'rgb(${lr},${lg},${lb})');`,
+		`  s.setProperty('--accent-dim', 'rgba(${r},${g},${b},.15)');`,
+		'})();',
+		'</script>',
+	].join('\n');
+}
+
+module.exports = { PRESETS, buildThemeSnippet };

package/lib/userStore.js

@@ -0,0 +1,13 @@
+'use strict';
+const fs = require('fs').promises;
+const config = require('../config');
+
+async function getUsers () {
+	try { return JSON.parse(await fs.readFile(config.USERS_FILE, 'utf8')); } catch (err) { if (err.code === 'ENOENT') { return {}; } throw err; }
+}
+
+async function saveUsers (users) {
+	await fs.writeFile(config.USERS_FILE, JSON.stringify(users, null, 2), 'utf8');
+}
+
+module.exports = { getUsers, saveUsers };