@logboard/cli 1.0.0

package/services/MetricsService.js

@@ -0,0 +1,116 @@
+'use strict';
+const fsP = require('fs').promises;
+const path = require('path');
+const config = require('../config');
+
+function getToday () {
+	return new Date().toISOString().slice(0, 10);
+}
+
+async function ensureDir (d) {
+	try {
+		await fsP.mkdir(d, { recursive: true });
+	} catch {}
+}
+
+class MetricsService {
+	constructor (org) {
+		this._org = org || null;
+		this._baseDir = org
+			? path.join(org.dataDir, 'metrics')
+			: path.join(config.DATA_DIR, 'metrics');
+	}
+
+	_appDir (appName) {
+		return path.join(this._baseDir, appName);
+	}
+
+	_file (appName, date) {
+		return path.join(this._appDir(appName), `${date}.ndjson`);
+	}
+
+	// Store a metrics snapshot
+	async ingest (appName, payload) {
+		if (!appName || typeof appName !== 'string') { throw new Error('appName required'); }
+		const dir = this._appDir(appName);
+		await ensureDir(dir);
+		const line
+      = `${JSON.stringify({
+      	...payload,
+      	ts: payload.ts || new Date().toISOString(),
+      	appName,
+      }) }\n`;
+		await fsP.appendFile(this._file(appName, getToday()), line, 'utf8');
+	}
+
+	// Get time-series for a service over a range
+	async getTimeSeries (appName, rangeMinutes = 1440) {
+		const now = Date.now();
+		const cutoff = now - rangeMinutes * 60 * 1000;
+		const dates = this._datesForRange(rangeMinutes);
+		const rows = [];
+		for (const date of dates) {
+			try {
+				const content = await fsP.readFile(this._file(appName, date), 'utf8');
+				for (const line of content.split('\n').filter(Boolean)) {
+					try {
+						const obj = JSON.parse(line);
+						if (new Date(obj.ts).getTime() >= cutoff) { rows.push(obj); }
+					} catch {}
+				}
+			} catch {}
+		}
+		return rows.sort((a, b) => new Date(a.ts) - new Date(b.ts));
+	}
+
+	// Get latest snapshot per service (for status cards)
+	async getLatestAll (allowedApps = []) {
+		const result = [];
+		try {
+			const dirs = await fsP.readdir(this._baseDir);
+			const apps = allowedApps.length
+				? dirs.filter((d) => allowedApps.includes(d))
+				: dirs;
+			for (const appName of apps) {
+				try {
+					const latest = await this._getLatest(appName);
+					if (latest) { result.push({ appName, ...latest }); }
+				} catch {}
+			}
+		} catch {}
+		return result;
+	}
+
+	async _getLatest (appName) {
+		const dates = this._datesForRange(2880); // last 2 days
+		for (const date of dates.reverse()) {
+			try {
+				const content = await fsP.readFile(this._file(appName, date), 'utf8');
+				const lines = content.split('\n').filter(Boolean);
+				if (lines.length) { return JSON.parse(lines[lines.length - 1]); }
+			} catch {}
+		}
+		return null;
+	}
+
+	// List services that have metrics
+	async listServices () {
+		try {
+			return await fsP.readdir(this._baseDir);
+		} catch {
+			return [];
+		}
+	}
+
+	_datesForRange (rangeMinutes) {
+		const days = Math.ceil(rangeMinutes / 1440) + 1;
+		const dates = [];
+		for (let i = days - 1; i >= 0; i--) {
+			const d = new Date(Date.now() - i * 86400000);
+			dates.push(d.toISOString().slice(0, 10));
+		}
+		return dates;
+	}
+}
+
+module.exports = MetricsService;

package/services/NotificationService.js

@@ -0,0 +1,70 @@
+'use strict';
+const fsP = require('fs').promises;
+const path = require('path');
+const crypto = require('crypto');
+const config = require('../config');
+
+const FILE = path.join(config.DATA_DIR, 'notifications.json');
+
+class NotificationService {
+	async _load () {
+		try {
+			return JSON.parse(await fsP.readFile(FILE, 'utf8'));
+		} catch {
+			return [];
+		}
+	}
+
+	async _save (arr) {
+		await fsP.writeFile(FILE, JSON.stringify(arr.slice(-500), null, 2), 'utf8');
+	}
+
+	/** Create a new in-app notification */
+	async create (data) {
+		const arr = await this._load();
+		const notif = {
+			id: crypto.randomUUID(),
+			ts: new Date().toISOString(),
+			type: data.type || 'info', // alert | report | system | info
+			title: data.title || '',
+			body: data.body || '',
+			ruleId: data.ruleId || null,
+			service: data.service || null,
+			read: false,
+		};
+		arr.unshift(notif);
+		await this._save(arr);
+		return notif;
+	}
+
+	/** Get notifications (all or unread) */
+	async getAll (limit = 100, unreadOnly = false) {
+		const arr = await this._load();
+		return (unreadOnly ? arr.filter((n) => !n.read) : arr).slice(0, limit);
+	}
+
+	/** Count unread */
+	async countUnread () {
+		const arr = await this._load();
+		return arr.filter((n) => !n.read).length;
+	}
+
+	/** Mark one or all as read */
+	async markRead (id = null) {
+		const arr = await this._load();
+		arr.forEach((n) => {
+			if (!id || n.id === id) {
+				n.read = true;
+			}
+		});
+		await this._save(arr);
+	}
+
+	/** Delete a notification */
+	async delete (id) {
+		const arr = (await this._load()).filter((n) => n.id !== id);
+		await this._save(arr);
+	}
+}
+
+module.exports = new NotificationService();

package/services/OrgService.js

@@ -0,0 +1,217 @@
+'use strict';
+const fsP    = require('fs').promises;
+const path   = require('path');
+const crypto = require('crypto');
+const config = require('../config');
+
+const ORGS_FILE = () => path.join(config.DATA_DIR, 'orgs.json');
+async function ensureDir(d) { try { await fsP.mkdir(d, { recursive: true }); } catch {} }
+
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 32);
+}
+
+class OrgService {
+
+  orgDataDir(slug) { return path.join(config.DATA_DIR, 'orgs', slug); }
+  orgLogsDir(slug) { return path.join(config.LOG_BASE_DIR, slug); }
+
+  // Returns all file paths for an org — passed to every service as `req.org`
+  orgPaths(slug) {
+    const d = this.orgDataDir(slug);
+    return {
+      slug,
+      name:               null, // filled by getOrg()
+      dataDir:            d,
+      logsDir:            this.orgLogsDir(slug),
+      usersFile:          path.join(d, 'users.json'),
+      settingsFile:       path.join(d, 'settings.json'),
+      rolesFile:          path.join(d, 'role-config.json'),
+      apiKeysFile:        path.join(d, 'api-keys.json'),
+      auditFile:          path.join(d, 'audit.ndjson'),
+      alertsFile:         path.join(d, 'alerts.json'),
+      bookmarksFile:      path.join(d, 'bookmarks.json'),
+      savedSearchesFile:  path.join(d, 'saved-searches.json'),
+      notificationsFile:  path.join(d, 'notifications.json'),
+      invitesFile:        path.join(d, 'invites.json'),
+    };
+  }
+
+  // ── Registry ──────────────────────────────────────────────────────────────
+  async getOrgs() {
+    try { return JSON.parse(await fsP.readFile(ORGS_FILE(), 'utf8')); }
+    catch (e) { if (e.code === 'ENOENT') return {}; throw e; }
+  }
+
+  async saveOrgs(orgs) {
+    await ensureDir(path.dirname(ORGS_FILE()));
+    await fsP.writeFile(ORGS_FILE(), JSON.stringify(orgs, null, 2), 'utf8');
+  }
+
+  async getOrg(slug) {
+    if (!slug || typeof slug !== 'string') return null;
+    const orgs = await this.getOrgs();
+    if (!orgs[slug]) return null;
+    const p = this.orgPaths(slug);
+    p.name = orgs[slug].name;
+    return { ...orgs[slug], ...p };
+  }
+
+  // ── Create ────────────────────────────────────────────────────────────────
+  async create({ name, ownerUsername, ownerPassword, plan = 'free' }) {
+    if (!name || typeof name !== 'string') throw Object.assign(new Error('Org name required'), { status: 400 });
+    const slug = slugify(name);
+    if (!slug) throw Object.assign(new Error('Invalid org name'), { status: 400 });
+    const orgs = await this.getOrgs();
+    if (orgs[slug]) throw Object.assign(new Error(`Org "${slug}" already exists`), { status: 409 });
+
+    const p = this.orgPaths(slug);
+    await ensureDir(p.dataDir);
+    await ensureDir(p.logsDir);
+
+    await fsP.writeFile(p.settingsFile, JSON.stringify({
+      appName: name, appLogoUrl: '/public/logo.png', faviconUrl: '',
+      themeId: 'dark-indigo', themeMode: 'dark', accentR: 99, accentG: 102, accentB: 241,
+      retentionDays: 7, enableStream: true, alertsEnabled: true,
+      alertRamPct: 85, alertCpuPct: 90, alertDiskPct: 90,
+    }, null, 2), 'utf8');
+
+    await fsP.writeFile(p.rolesFile, JSON.stringify({
+      admin:  { label: 'Administrator', color: '#6366f1', isBuiltIn: true, pages: [], cards: [] },
+      viewer: { label: 'Viewer', color: '#22c55e', isBuiltIn: true, pages: ['logs','live'], cards: [] },
+    }, null, 2), 'utf8');
+
+    if (ownerUsername && ownerPassword) {
+      const bcrypt = require('bcryptjs');
+      const hash   = await bcrypt.hash(ownerPassword, 10);
+      await fsP.writeFile(p.usersFile, JSON.stringify({
+        [ownerUsername]: { username: ownerUsername, password: hash, role: 'admin', createdAt: new Date().toISOString() }
+      }, null, 2), 'utf8');
+    } else {
+      await fsP.writeFile(p.usersFile, '{}', 'utf8');
+    }
+
+    const org = { slug, name, plan, createdAt: new Date().toISOString(), ownerUsername: ownerUsername || null };
+    orgs[slug] = org;
+    await this.saveOrgs(orgs);
+    return { ...org, ...p };
+  }
+
+  // ── Delete ────────────────────────────────────────────────────────────────
+  async delete(slug) {
+    const orgs = await this.getOrgs();
+    if (!orgs[slug]) throw Object.assign(new Error('Org not found'), { status: 404 });
+    delete orgs[slug];
+    await this.saveOrgs(orgs);
+    // Data dirs kept on disk — super-admin must manually remove
+  }
+
+  // ── Invites ───────────────────────────────────────────────────────────────
+  async createInvite(orgSlug, email, role = 'viewer', invitedBy = 'admin') {
+    const org = await this.getOrg(orgSlug);
+    if (!org) throw Object.assign(new Error('Org not found'), { status: 404 });
+    const token   = crypto.randomBytes(24).toString('hex');
+    const invites = await this._readInvites(org.invitesFile);
+    invites[token] = {
+      email, role, invitedBy, orgSlug,
+      createdAt: new Date().toISOString(),
+      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+    };
+    await fsP.writeFile(org.invitesFile, JSON.stringify(invites, null, 2), 'utf8');
+    return { token, email, role, orgSlug };
+  }
+
+  async getInvite(token) {
+    // Search all orgs for this token
+    const orgs = await this.getOrgs();
+    for (const slug of Object.keys(orgs)) {
+      const p       = this.orgPaths(slug);
+      const invites = await this._readInvites(p.invitesFile);
+      const inv     = invites[token];
+      if (inv && new Date(inv.expiresAt) > new Date()) return { ...inv, token };
+    }
+    return null;
+  }
+
+  async acceptInvite(token, username, password) {
+    const inv = await this.getInvite(token);
+    if (!inv) throw Object.assign(new Error('Invite not found or expired'), { status: 404 });
+
+    const org = await this.getOrg(inv.orgSlug);
+    const bcrypt = require('bcryptjs');
+    let users = {};
+    try { users = JSON.parse(await fsP.readFile(org.usersFile, 'utf8')); } catch {}
+    if (users[username]) throw Object.assign(new Error('Username taken in this org'), { status: 409 });
+
+    users[username] = {
+      username, role: inv.role, email: inv.email,
+      password: await bcrypt.hash(password, 10),
+      createdAt: new Date().toISOString(),
+    };
+    await fsP.writeFile(org.usersFile, JSON.stringify(users, null, 2), 'utf8');
+
+    // Consume invite
+    const invites = await this._readInvites(org.invitesFile);
+    delete invites[token];
+    await fsP.writeFile(org.invitesFile, JSON.stringify(invites, null, 2), 'utf8');
+
+    return { username, role: inv.role, orgSlug: inv.orgSlug };
+  }
+
+  async _readInvites(file) {
+    try { return JSON.parse(await fsP.readFile(file, 'utf8')); } catch { return {}; }
+  }
+
+  // ── Migration: flat data → data/orgs/default/ ────────────────────────────
+  async migrateToDefaultOrg() {
+    const orgs = await this.getOrgs();
+    if (orgs['default']) return { skipped: true, message: 'Already migrated' };
+
+    const p = this.orgPaths('default');
+    await ensureDir(p.dataDir);
+    await ensureDir(p.logsDir);
+
+    const fileMoves = [
+      ['users.json',          p.usersFile],
+      ['settings.json',       p.settingsFile],
+      ['role-config.json',    p.rolesFile],
+      ['api-keys.json',       p.apiKeysFile],
+      ['audit.ndjson',        p.auditFile],
+      ['alerts.json',         p.alertsFile],
+      ['bookmarks.json',      p.bookmarksFile],
+      ['saved-searches.json', p.savedSearchesFile],
+      ['notifications.json',  p.notificationsFile],
+    ];
+
+    const moved = [], skipped = [];
+    for (const [filename, dst] of fileMoves) {
+      const src = path.join(config.DATA_DIR, filename);
+      try {
+        const content = await fsP.readFile(src, 'utf8');
+        await fsP.writeFile(dst, content, 'utf8');
+        await fsP.rename(src, src + '.bak');
+        moved.push(filename);
+      } catch (e) { if (e.code !== 'ENOENT') skipped.push(filename + ':' + e.message); }
+    }
+
+    // Move existing service log dirs into logs/default/
+    try {
+      const logDirs = await fsP.readdir(config.LOG_BASE_DIR);
+      for (const d of logDirs) {
+        if (['default', '_archive'].includes(d)) continue;
+        const src = path.join(config.LOG_BASE_DIR, d);
+        const dst = path.join(p.logsDir, d);
+        try {
+          const st = await fsP.stat(src);
+          if (st.isDirectory()) { await ensureDir(p.logsDir); await fsP.rename(src, dst); }
+        } catch {}
+      }
+    } catch {}
+
+    orgs['default'] = { slug: 'default', name: 'Default', plan: 'free', createdAt: new Date().toISOString(), ownerUsername: 'admin', migratedAt: new Date().toISOString() };
+    await this.saveOrgs(orgs);
+    return { migrated: true, moved, skipped };
+  }
+}
+
+module.exports = new OrgService();

package/services/ReportService.js

@@ -0,0 +1,247 @@
+'use strict';
+const os = require('os');
+const logger = require('../lib/logger');
+
+class ReportService {
+	/**
+   * Build the report payload (used for both email and in-app)
+   */
+	async buildReport (settings) {
+		const AnalyticsService = require('./AnalyticsService');
+		const svc = new AnalyticsService();
+		const today = new Date().toISOString().slice(0, 10);
+		// Yesterday
+		const yd = new Date();
+		yd.setDate(yd.getDate() - 1);
+		const yesterday = yd.toISOString().slice(0, 10);
+
+		let overview = null,
+			trend = null,
+			topSvcs = [],
+			recentErrors = [];
+		try {
+			overview = await svc.getOverview();
+		} catch {}
+		try {
+			trend = await svc.getDailyTrend(null, 7);
+		} catch {}
+		try {
+			topSvcs = await svc.getTopServices(yesterday, 10);
+		} catch {}
+		try {
+			recentErrors = await svc.getRecentErrors(5);
+		} catch {}
+
+		return {
+			today,
+			yesterday,
+			overview,
+			trend,
+			topSvcs,
+			recentErrors,
+			host: os.hostname(),
+			generatedAt: new Date().toISOString(),
+		};
+	}
+
+	/** Format report as plain text */
+	_formatText (report) {
+		const lines = [
+			`LogBoard Daily Report — ${report.yesterday}`,
+			'='.repeat(50),
+			'',
+		];
+		if (report.overview) {
+			lines.push(
+				`Logs Today:   ${(report.overview.logsToday || 0).toLocaleString()}`,
+			);
+			lines.push(
+				`Errors Today: ${(report.overview.errorsToday || 0).toLocaleString()}`,
+			);
+			lines.push(`Error Rate:   ${report.overview.errorRate || 0}%`);
+			lines.push(`Services:     ${report.overview.services || 0}`);
+			lines.push('');
+		}
+		if (report.topSvcs?.length) {
+			lines.push('Top Services:');
+			report.topSvcs
+				.slice(0, 5)
+				.forEach((s) => lines.push(`  ${s.appName}: ${s.count} logs`));
+			lines.push('');
+		}
+		if (report.recentErrors?.length) {
+			lines.push('Recent Errors:');
+			report.recentErrors
+				.slice(0, 5)
+				.forEach((e) =>
+					lines.push(`  [${e.appName}] ${(e.message || '').slice(0, 80)}`),
+				);
+			lines.push('');
+		}
+		lines.push(`Generated: ${report.generatedAt}`);
+		lines.push(`Host: ${report.host}`);
+		return lines.join('\n');
+	}
+
+	/** Format report as HTML */
+	_formatHTML (report) {
+		const errRate = report.overview?.errorRate || 0;
+		const rateColor
+      = errRate > 10 ? '#ef4444' : errRate > 3 ? '#f59e0b' : '#22c55e';
+		return `<!DOCTYPE html><html><head><meta charset="UTF-8"/><style>
+      body{font-family:'Inter',sans-serif;background:#0d0d14;color:#e2e2f2;padding:30px;margin:0;}
+      .card{background:#13131e;border:1px solid #2a2a45;border-radius:12px;padding:20px;margin-bottom:16px;}
+      .title{font-size:22px;font-weight:700;margin-bottom:4px;}
+      .sub{font-size:13px;color:#5a5a78;margin-bottom:20px;}
+      .stat{display:inline-block;margin-right:32px;margin-bottom:12px;}
+      .stat-val{font-size:28px;font-weight:700;}
+      .stat-lbl{font-size:11px;color:#5a5a78;text-transform:uppercase;letter-spacing:.5px;}
+      table{width:100%;border-collapse:collapse;font-size:13px;}
+      td,th{padding:8px 10px;text-align:left;border-bottom:1px solid #2a2a45;}
+      th{font-size:10px;text-transform:uppercase;letter-spacing:.5px;color:#5a5a78;font-weight:600;}
+      .badge{display:inline-block;padding:2px 8px;border-radius:4px;font-size:10px;font-weight:600;}
+    </style></head><body>
+    <div class="title">📊 LogBoard Daily Report</div>
+    <div class="sub">${report.yesterday} • Generated ${new Date(report.generatedAt).toLocaleString()} • ${report.host}</div>
+    ${
+	report.overview
+		? `<div class="card">
+      <div class="stat">
+	  	<div class="stat-val">${(report.overview.logsToday || 0).toLocaleString()}</div>
+		<div class="stat-lbl">Logs Today</div>
+		</div>
+      <div class="stat">
+	  	<div class="stat-val" style="color:#ef4444">${(report.overview.errorsToday || 0).toLocaleString()}</div>
+		<div class="stat-lbl">Errors Today</div>
+		</div>
+      <div class="stat">
+	  	<div class="stat-val" style="color:${rateColor}">${errRate}%</div><div class="stat-lbl">Error Rate</div>
+		</div>
+      <div class="stat">
+	  	<div class="stat-val">${report.overview.services || 0}</div><div class="stat-lbl">Services</div>
+		</div>
+    </div>`
+		: ''
+}
+    ${
+	report.topSvcs?.length
+		? `<div class="card"><table>
+      <thead><tr><th>Service</th><th>Logs</th></tr></thead>
+      <tbody>${report.topSvcs
+		.slice(0, 8)
+		.map((s) => `<tr><td>${s.appName}</td><td>${s.count}</td></tr>`)
+		.join('')}</tbody>
+    </table></div>`
+		: ''
+}
+    ${
+	report.recentErrors?.length
+		? `<div class="card"><table>
+      <thead><tr><th>Service</th><th>Recent Error</th></tr></thead>
+      <tbody>${report.recentErrors
+		.slice(0, 5)
+		.map(
+			(e) =>
+				`<tr>
+					<td style="color:#818cf8">${e.appName || ''}</td>
+					<td style="font-family:monospace;font-size:11px">${(e.message || '').slice(0, 120)}</td>
+				</tr>`,
+		)
+		.join('')}</tbody>
+    </table></div>`
+		: ''
+}
+    </body></html>`;
+	}
+
+	/** Send report email */
+	async sendEmail (settings) {
+		if (
+			!settings?.reportEmail
+      || !settings?.smtpHost
+      || !settings?.emailEnabled
+		) {
+			return false;
+		}
+		try {
+			const nodemailer = require('nodemailer');
+			const report = await this.buildReport(settings);
+			const transport = nodemailer.createTransport({
+				host: settings.smtpHost,
+				port: Number(settings.smtpPort || 587),
+				secure: Number(settings.smtpPort) === 465,
+				auth: { user: settings.smtpUser, pass: settings.smtpPass },
+			});
+			await transport.sendMail({
+				from: settings.smtpFrom || 'logboard@example.com',
+				to: settings.reportEmail,
+				subject: `[LogBoard] Daily Report — ${report.yesterday}`,
+				text: this._formatText(report),
+				html: this._formatHTML(report),
+			});
+			logger.info(`[Report] Daily report sent to ${settings.reportEmail}`);
+			// Record last sent time
+			try {
+				const SettingsService = require('./SettingsService');
+				await new SettingsService().save({
+					lastReportAt: new Date().toISOString(),
+				});
+			} catch {}
+
+			// Also create in-app notification
+			const N = require('./NotificationService');
+			await N.create({
+				type: 'report',
+				title: `Daily Report — ${report.yesterday}`,
+				body: `${report.overview?.logsToday || 0} logs, ${report.overview?.errorsToday || 0} errors`,
+			});
+			return true;
+		} catch (e) {
+			logger.warn(`[Report] Email failed: ${e.message}`);
+			return false;
+		}
+	}
+
+	/** Start the cron scheduler */
+	startScheduler (getSettings) {
+		try {
+			const cron = require('node-cron');
+			// Daily at 08:00 server time
+			cron.schedule('0 8 * * *', async () => {
+				try {
+					const settings
+            = typeof getSettings === 'function'
+            	? await getSettings()
+            	: getSettings;
+					if (settings?.reportEnabled) {
+						await this.sendEmail(settings);
+					}
+				} catch (e) {
+					logger.warn(`[Report] Scheduler error: ${e.message}`);
+				}
+			});
+			// Weekly on Monday 08:00
+			cron.schedule('0 8 * * 1', async () => {
+				try {
+					const settings
+            = typeof getSettings === 'function'
+            	? await getSettings()
+            	: getSettings;
+					if (
+						settings?.reportEnabled
+            && settings?.reportSchedule === 'weekly'
+					) {
+						await this.sendEmail(settings);
+					}
+				} catch (e) {
+					logger.warn(`[Report] Weekly scheduler error: ${e.message}`);
+				}
+			});
+			logger.info('[Report] Scheduler started (daily @ 08:00)');
+		} catch (e) {
+			logger.warn(`[Report] node-cron not available: ${e.message}`);
+		}
+	}
+}
+
+module.exports = new ReportService();