domma-cms 0.79.1 → 0.81.0

package/server/services/email.js

@@ -28,6 +28,8 @@ function recordSendResult(ok, info) {
         at: new Date().toISOString(),
         info: info || null
     };
+    // A failed send is the Super Admin's business (at most once a day - see notification-sources.js).
+    if (!ok) import('./notification-sources.js').then(m => m.emailFailed(info)).catch(() => {});
 }
 
 /**
@@ -89,6 +91,7 @@ export async function createTransport(smtp) {
     // same warning on the Email tab, and checkSmtpConfig() surfaces it in
     // Health. A site scaffolded by the CLI or the fleet manager ships with a
     // host precisely so it never lands here.
+    import('./notification-sources.js').then(m => m.emailNotConfigured()).catch(() => {});
     const testAccount = await nodemailer.createTestAccount();
     console.warn('[email] NO SMTP HOST CONFIGURED - mail is going to an Ethereal test inbox '
         + 'and will NOT reach its recipients. Set one in Settings > Email. '

package/server/services/notification-sources.js

@@ -0,0 +1,361 @@
+/**
+ * What core itself tells the Super Admin about - the system's notification
+ * sources. Registered once at start-up (server.js); each shows in
+ * Notifications' settings, where a Super Admin can switch it off or send it to
+ * more people.
+ *
+ * Two kinds:
+ *   - scheduled checks (`every` + `check`), run by services/notify.js's ticker
+ *   - event sources (no `check`): named here so they can be listed and switched
+ *     off; raised with notify({source: 'core:…'}) where the thing happens -
+ *     the helpers at the bottom are those call sites' one line each.
+ *
+ * Pure decisions (what a licence state or a login count means) are exported
+ * for tests/services/notification-sources.test.js.
+ *
+ * @module services/notification-sources
+ */
+import fs from 'fs';
+import path from 'path';
+import {config, getConfig} from '../config.js';
+import {notify, registerNotificationSource} from './notify.js';
+
+const day = (d = new Date()) => d.toISOString().slice(0, 10);
+
+// ---------------------------------------------------------------------------
+// Pure decisions
+// ---------------------------------------------------------------------------
+
+/**
+ * What a licensed plugin's entitlement means for the Super Admin, or null.
+ *
+ * @param {string} name        - plugin name
+ * @param {string} label       - its display name
+ * @param {{state: string, entitlement: object|null}} verdict - classifyEntitlement()
+ * @param {Date} now
+ * @returns {{severity: string, title: string, body: string}|null}
+ */
+export function licenceNotice(name, label, verdict, now = new Date()) {
+    const e = verdict?.entitlement || {};
+    const ends = (iso) => String(iso || '').slice(0, 10);
+    switch (verdict?.state) {
+        case 'unlicensed':
+            return {severity: 'critical', title: `${label} is not running: no valid licence`,
+                body: `${label} is switched on but has no valid licence for this site, so it did not start. Its screens and pages are missing until a licence is installed.`};
+        case 'expired':
+            return {severity: 'critical', title: `${label} has stopped: licence expired`,
+                body: `The ${label} licence ended on ${ends(e.expiresAt)} and its grace period has passed, so it no longer starts. Renew it to bring it back - its data is kept.`};
+        case 'grace': {
+            const graceEnd = new Date(Date.parse(e.expiresAt) + (Number(e.gracePeriodDays) || 0) * 86_400_000);
+            return {severity: 'warning', title: `${label} licence has expired`,
+                body: `The ${label} licence ended on ${ends(e.expiresAt)}. It keeps working until ${day(graceEnd)}, then stops. Renew it before then.`};
+        }
+        case 'support-ended':
+            return {severity: 'info', title: `${label}: support and updates have ended`,
+                body: `Your ${label} licence is permanent and keeps working, but updates stopped on ${ends(e.supportExpiresAt)}.`};
+        case 'valid': {
+            if (e.model !== 'rental') return null;
+            const left = Math.ceil((Date.parse(e.expiresAt) - now.getTime()) / 86_400_000);
+            if (!(left >= 0 && left <= 14)) return null;
+            return {severity: 'warning', title: `${label} licence ends in ${left} day${left === 1 ? '' : 's'}`,
+                body: `The ${label} licence ends on ${ends(e.expiresAt)}. Renew it to keep ${label} running.`};
+        }
+        default:
+            return null;
+    }
+}
+
+/**
+ * An API token worth a word: expiring within 7 days, or expired in the last 7.
+ *
+ * @param {object} data - the token entry's data
+ * @param {Date} now
+ */
+export function tokenNotice(data, now = new Date()) {
+    if (!data?.expiresAt || data.enabled === false) return null;
+    const left = Math.ceil((Date.parse(data.expiresAt) - now.getTime()) / 86_400_000);
+    if (!Number.isFinite(left) || left > 7 || left < -7) return null;
+    const name = data.name || 'An API token';
+    return left < 0
+        ? {severity: 'warning', title: `API token "${name}" has expired`,
+            body: `It expired on ${String(data.expiresAt).slice(0, 10)}. Anything still using it is being refused - issue a new one in API Tokens.`}
+        : {severity: 'warning', title: `API token "${name}" expires in ${left} day${left === 1 ? '' : 's'}`,
+            body: `It expires on ${String(data.expiresAt).slice(0, 10)}. Anything using it will be refused after that - extend it or issue a new one in API Tokens.`};
+}
+
+/** Sign-in failures: this many for one account inside the window is worth telling. */
+export const LOGIN_FAILURES = {count: 5, windowMs: 15 * 60_000};
+
+/**
+ * Count one failed sign-in; true when it tips over the threshold (once per window).
+ *
+ * @param {Map} counts - email -> timestamps (state kept by the caller)
+ * @param {string} email
+ * @param {number} now
+ */
+export function countLoginFailure(counts, email, now = Date.now()) {
+    const key = String(email || '').trim().toLowerCase();
+    const recent = (counts.get(key) || []).filter(t => now - t < LOGIN_FAILURES.windowMs);
+    recent.push(now);
+    counts.set(key, recent);
+    return recent.length === LOGIN_FAILURES.count;
+}
+
+/** Free space worth a warning: under 10% or under 1 GB. */
+export function diskNotice(freeBytes, totalBytes) {
+    if (!(totalBytes > 0)) return null;
+    const pct = freeBytes / totalBytes;
+    if (pct >= 0.1 && freeBytes >= 1024 ** 3) return null;
+    const gb = (freeBytes / 1024 ** 3).toFixed(1);
+    return {severity: pct < 0.03 ? 'critical' : 'warning', title: `Disk space is low: ${gb} GB free`,
+        body: `Only ${Math.round(pct * 100)}% of the disk holding this site's content is free (${gb} GB). Uploads, backups and saves fail when it runs out.`};
+}
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+function crashMarker() {
+    return path.join(path.dirname(path.resolve(config.content.collectionsDir)), '.crash.json');
+}
+
+/**
+ * Note a crash on the way down (sync - the process is exiting), so the next
+ * start can say so. Never throws.
+ *
+ * @param {unknown} err
+ */
+export function recordCrash(err) {
+    try {
+        fs.writeFileSync(crashMarker(), JSON.stringify({at: new Date().toISOString(),
+            message: String(err?.message || err || 'unknown').slice(0, 500)}));
+    } catch { /* nothing more to be done */ }
+}
+
+/** Register every core source. Called once, before plugins load. */
+export async function registerCoreSources() {
+    const plugins = await import('./plugins.js');
+    const {classifyEntitlement} = await import('./pluginEntitlement.js');
+
+    registerNotificationSource({
+        id: 'core:plugin-load', label: 'Plugin failed to start', severity: 'critical', every: 'boot',
+        description: 'A plugin that is switched on stopped with an error while the site started.',
+        async check({notify: raise, resolve}) {
+            const failures = plugins.getPluginLoadFailures();
+            for (const f of failures) {
+                await raise({severity: 'critical', dedupeKey: `plugin-load:${f.name}`, link: '#/plugins',
+                    title: `Plugin failed to start: ${f.name}`,
+                    body: `${f.name} stopped with an error while the site started, so its screens and pages are missing.\n\n${f.reason}`});
+            }
+            const failed = new Set(failures.map(f => f.name));
+            for (const [name, p] of Object.entries(plugins.getLoadedPlugins())) {
+                if (p.enabled && !failed.has(name)) await resolve(`plugin-load:${name}`);
+            }
+        }
+    });
+
+    registerNotificationSource({
+        id: 'core:licence', label: 'Plugin licences', severity: 'warning', every: 'daily', atBoot: true,
+        description: 'A licensed plugin that has stopped, is in its grace period, or ends within 14 days.',
+        async check({notify: raise, resolve, now}) {
+            const states = plugins.getPluginStates();
+            for (const m of await plugins.discoverPlugins()) {
+                if (m.closedSource !== true) continue;
+                const key = `licence:${m.name}`;
+                if (!states[m.name]?.enabled) { await resolve(key); continue; }
+                const notice = licenceNotice(m.name, m.displayName || m.name, classifyEntitlement(m.name), now);
+                if (notice) await raise({...notice, dedupeKey: key, link: '#/plugins'});
+                else await resolve(key);
+            }
+        }
+    });
+
+    registerNotificationSource({
+        id: 'core:crash', label: 'Site restarted after a crash', severity: 'critical', every: 'boot',
+        description: 'The site stopped on an unexpected error and was started again.',
+        async check({notify: raise}) {
+            let marker;
+            try { marker = JSON.parse(fs.readFileSync(crashMarker(), 'utf8')); } catch { return; }
+            try { fs.rmSync(crashMarker(), {force: true}); } catch { /* raised once anyway: dedupe */ }
+            await raise({severity: 'critical', dedupeKey: `crash:${marker.at}`,
+                title: 'The site restarted after a crash',
+                body: `It stopped on an unexpected error at ${String(marker.at).replace('T', ' ').slice(0, 16)} UTC and was started again.\n\n${marker.message}`});
+        }
+    });
+
+    registerNotificationSource({
+        id: 'core:api-tokens', label: 'API tokens expiring', severity: 'warning', every: 'daily', atBoot: true,
+        description: 'An API token that expires within 7 days, or expired in the last 7.',
+        async check({notify: raise}) {
+            const {listEntries} = await import('./collections.js');
+            const {entries} = await listEntries('api-tokens', {limit: 0}).catch(() => ({entries: []}));
+            for (const e of entries || []) {
+                const notice = tokenNotice(e.data);
+                if (notice) await raise({...notice, dedupeKey: `api-token:${e.id}`, link: '#/api-tokens'});
+            }
+        }
+    });
+
+    registerNotificationSource({
+        id: 'core:disk', label: 'Disk space low', severity: 'warning', every: 'hourly', atBoot: true,
+        description: 'Under 10% (or 1 GB) free on the disk that holds the site\'s content.',
+        async check({notify: raise, resolve}) {
+            if (typeof fs.promises.statfs !== 'function') return;
+            const st = await fs.promises.statfs(path.resolve(config.content.contentDir || 'content'));
+            const notice = diskNotice(st.bavail * st.bsize, st.blocks * st.bsize);
+            if (notice) await raise({...notice, dedupeKey: 'disk'});
+            else await resolve('disk');
+        }
+    });
+
+    // Event sources - raised where the thing happens (see the helpers below).
+    const events = [
+        {id: 'core:storage', label: 'Database unavailable', severity: 'critical',
+            description: 'A MongoDB connection failed, so collections on it fell back to file storage.'},
+        {id: 'core:startup', label: 'Start-up problems', severity: 'warning',
+            description: 'A start-up repair that did not finish and will be retried.'},
+        {id: 'core:email', label: 'Email not delivered', severity: 'warning',
+            description: 'The site could not send an email, or has no mail server set up (mail goes nowhere). At most once a day.'},
+        {id: 'core:logins', label: 'Repeated failed sign-ins', severity: 'warning',
+            description: `${LOGIN_FAILURES.count} failed sign-ins to one account within 15 minutes, or the sign-in limit being hit.`},
+        {id: 'core:roles', label: 'Admin rights given', severity: 'warning',
+            description: 'Someone was given the Admin or Super Admin role.'},
+        {id: 'core:forms', label: 'Form actions failing', severity: 'warning',
+            description: 'A form\'s email, webhook or action failed after a submission. At most once a day per form.'},
+        {id: 'core:form-submitted', label: 'Form submitted', severity: 'info', defaultOn: false,
+            description: 'Every form submission. Off by default - busy forms would fill the inbox.'},
+        // On, and to every admin: the author asked for it answer by answer, so
+        // it is not noise, and fleet sites have no Super Admin to receive it.
+        {id: 'core:form-triggers', label: 'Form triggers', severity: 'info', audience: 'admins',
+            description: 'A form trigger set to "Notify the admins" fired when a form was submitted.'},
+        {id: 'core:actions', label: 'Actions', severity: 'info', audience: 'admins',
+            description: 'An Action with a "Notify the admins" step ran.'},
+        {id: 'core:users', label: 'Users added or removed', severity: 'info', defaultOn: false,
+            description: 'A user account was created or deleted.'}
+    ];
+    for (const e of events) registerNotificationSource(e);
+
+    // Hook-bus events core already emits.
+    const {hooks} = await import('./hooks.js');
+    hooks.on('form:submitted', ({slug, formTitle}) => {
+        notify({source: 'core:form-submitted', severity: 'info', link: `#/forms/${slug}/submissions`,
+            title: `New submission: ${formTitle || slug}`, body: `Someone submitted the "${formTitle || slug}" form.`});
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Call-site helpers (one line where the thing happens)
+// ---------------------------------------------------------------------------
+
+/** email.js: a send failed. */
+export function emailFailed(message) {
+    return notify({source: 'core:email', severity: 'warning', dedupeKey: `email-failed:${day()}`, link: '#/settings',
+        title: 'An email could not be sent',
+        body: `The mail server refused or could not be reached: ${String(message || '').slice(0, 300)}\n\nPassword resets and form emails may not be arriving. Check Settings > Email.`});
+}
+
+/** email.js: no SMTP host, so mail goes to a test inbox. */
+export function emailNotConfigured() {
+    return notify({source: 'core:email', severity: 'warning', dedupeKey: 'smtp-missing', link: '#/settings',
+        title: 'Email is not set up',
+        body: 'No mail server is configured, so the site\'s emails (password resets, form notifications) go to a test inbox and reach nobody. Set one in Settings > Email.'});
+}
+
+const loginCounts = new Map();
+
+/** auth.js: a sign-in failed. */
+export function loginFailed(email, ip) {
+    if (!countLoginFailure(loginCounts, email)) return null;
+    return notify({source: 'core:logins', severity: 'warning', dedupeKey: `login-failures:${String(email).toLowerCase()}`, link: '#/users',
+        title: `Repeated failed sign-ins for ${email}`,
+        body: `${LOGIN_FAILURES.count} wrong passwords for ${email} in 15 minutes${ip ? `, the last from ${ip}` : ''}. If that was not the account holder, someone may be guessing the password.`});
+}
+
+/** auth.js: the sign-in rate limit refused someone. */
+export function loginRateLimited(ip) {
+    const hour = new Date().toISOString().slice(0, 13);
+    return notify({source: 'core:logins', severity: 'warning', dedupeKey: `login-limit:${ip}:${hour}`,
+        title: 'Sign-in limit reached',
+        body: `${ip || 'One address'} made more than 5 sign-in attempts in a minute and is being refused for now. Repeated, that is someone guessing passwords.`});
+}
+
+/** users route: someone was given admin rights. */
+export function adminRightsGiven(user, roles, by) {
+    const which = roles.includes('super-admin') ? 'Super Admin' : 'Admin';
+    return notify({source: 'core:roles', severity: 'warning', link: '#/users',
+        title: `${user.name || user.email} is now ${which === 'Admin' ? 'an' : 'a'} ${which}`,
+        body: `${user.name || ''} <${user.email}> was given the ${which} role${by ? ` by ${by}` : ''}.`.trim()});
+}
+
+/** users route: an account was created. */
+export function userCreated(user, by) {
+    return notify({source: 'core:users', severity: 'info', link: '#/users',
+        title: `New user: ${user.name || user.email}`,
+        body: `${user.name || ''} <${user.email}> was added as ${user.role}${by ? ` by ${by}` : ''}.`.trim()});
+}
+
+/** users route: an account was deleted. */
+export function userDeleted(user, by) {
+    return notify({source: 'core:users', severity: 'info', link: '#/users',
+        title: `User removed: ${user.name || user.email}`,
+        body: `${user.name || ''} <${user.email}> was deleted${by ? ` by ${by}` : ''}.`.trim()});
+}
+
+/** forms route: a side effect of a submission failed. */
+export function formActionFailed(slug, title, what, message) {
+    return notify({source: 'core:forms', severity: 'warning', dedupeKey: `form-failed:${slug}:${what}:${day()}`, link: `#/forms/edit/${slug}`,
+        title: `Form "${title || slug}": ${what} failed`,
+        body: `After a submission to "${title || slug}", its ${what} failed: ${String(message || '').slice(0, 300)}\n\nThe submission itself was saved.`});
+}
+
+/** What a trigger's level means to a notification: `error` is the one word they do not share. */
+const TRIGGER_SEVERITY = {info: 'info', success: 'success', warning: 'warning', error: 'critical'};
+
+/**
+ * The notice a form trigger's "Notify the admins" raises. Pure, for the tests.
+ *
+ * @param {object} o
+ * @param {string} o.slug
+ * @param {string} [o.formTitle]
+ * @param {object} o.action       - the trigger action: {message, level}
+ * @param {string} [o.field]      - label of the field the trigger hangs off
+ * @param {*} [o.answer]          - that field's answer
+ * @param {boolean} [o.ended]     - an end-form cut the form short
+ * @param {boolean} [o.recorded]  - the submission was stored
+ */
+export function formTriggerPayload({slug, formTitle, action = {}, field, answer, ended, recorded}) {
+    const form = formTitle || slug;
+    const said = Array.isArray(answer) ? answer.join(', ') : String(answer ?? '');
+    const lines = [`On the "${form}" form, ${field ? `"${field}" was answered "${said.slice(0, 200)}"` : 'a trigger fired'}.`];
+    if (ended) lines.push(recorded ? 'The form ended there; the answers given so far were saved.' : 'The form ended there; nothing was saved.');
+    return {
+        source: 'core:form-triggers',
+        severity: TRIGGER_SEVERITY[action.level] || 'info',
+        title: String(action.message || '').trim() || `Form "${form}": a trigger fired`,
+        body: lines.join('\n\n'),
+        link: recorded ? `#/forms/${slug}/submissions` : `#/forms/edit/${slug}`
+    };
+}
+
+/** forms route: a trigger's "Notify the admins" fired on a submission. */
+export function formTriggerNotice(o) {
+    return notify(formTriggerPayload(o));
+}
+
+/** adapterRegistry / connectionManager: a database connection failed. */
+export function storageDown(name, message) {
+    return notify({source: 'core:storage', severity: 'critical', dedupeKey: `storage:${name}`,
+        title: `Database connection "${name}" failed`,
+        body: `The site could not connect to MongoDB ("${name}"): ${String(message || '').slice(0, 300)}\n\nCollections stored there are being read from and written to local files instead, so they may look empty or out of date.`});
+}
+
+/** server.js: a start-up repair left something to retry. */
+export function startupPending(what) {
+    return notify({source: 'core:startup', severity: 'warning', dedupeKey: `startup:${what}:${day()}`,
+        title: 'A start-up repair did not finish', body: `${what} It will be tried again at the next start.`});
+}
+
+/** Used by the smtp check - is mail set up at all (config/site.json). */
+export function smtpConfigured() {
+    try { return Boolean(String(getConfig('site')?.smtp?.host || '').trim()); } catch { return true; }
+}