@jasonwch/nodebb-plugin-meilisearch-r 1.1.2 → 1.2.1

package/lib/settings-helpers.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const settings = nodebb.require('./src/meta/settings');
+
+async function resolveMinTermLength(plugin) {
+	const v = parseInt(await settings.getOne(plugin.id, 'searchMinTermLength'), 10);
+	return Number.isFinite(v) && v >= 2 ? v : 2;
+}
+
+function clampMinTermLength(value) {
+	const v = parseInt(value, 10);
+	return Number.isFinite(v) && v >= 2 ? v : 2;
+}
+
+module.exports = { resolveMinTermLength, clampMinTermLength };

package/lib/settings.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const winston = nodebb.require('winston');
+const settings = nodebb.require('./src/meta/settings');
+const { clampMinTermLength } = require('./settings-helpers');
+const { SEMANTIC_SETTING_KEYS, resetAppliedConfigs } = require('./embedder');
+const { redactSettingForLog, redactSecrets } = require('./redact');
+
+function deepCompare(a, b) {
+	if (a === null || b === null) return a === b;
+	if (typeof a !== typeof b) return false;
+	switch (typeof a) {
+		case 'object':
+			return Object.keys(a).length === Object.keys(b).length &&
+				Object.keys(a).every(key => deepCompare(a[key], b[key]));
+		case 'string':
+		case 'number':
+		case 'boolean':
+		default:
+			return a === b;
+	}
+}
+
+// filter:settings.set — reacts to ACP settings saves: reconnects on connection-setting
+// changes and pushes breaking settings (ranking rules, typo tolerance, etc.) to MeiliSearch.
+module.exports = function attachSettings(plugin) {
+	async function connectionSettingsChanged(newSettings) {
+		if (!newSettings) return false;
+		const keys = ['host', 'apiKey', 'healthCheckInterval'];
+		for (const k of keys) {
+			if (!Object.prototype.hasOwnProperty.call(newSettings, k)) continue;
+			const stored = await settings.getOne(plugin.id, k);
+			if (String(stored || '') !== String(newSettings[k] || '')) return true;
+		}
+		return false;
+	}
+
+	async function hostSettingChanged(newSettings) {
+		if (!newSettings || !Object.prototype.hasOwnProperty.call(newSettings, 'host')) return false;
+		const stored = await settings.getOne(plugin.id, 'host');
+		return String(stored || '') !== String(newSettings.host || '');
+	}
+
+	async function isBreaking([setting, value]) {
+		if (!plugin.breakingSettings.includes(setting)) {
+			return false;
+		}
+		const stored = await settings.getOne(plugin.id, setting);
+		const changed = !deepCompare(stored, value);
+		if (changed) {
+			// M5 fix: redact credential-bearing fields (apiKey, REST templates) from winston diff log
+			// so admin key rotation doesn't leak old+new paid OpenAI keys to output.log/aggregators
+			// via the ACP Logs page and any streaming log aggregator (Loki/ELK/Datadog).
+			winston.info(`[plugin/meilisearch] ${setting} changed: ${redactSettingForLog(setting, stored)} -> ${redactSettingForLog(setting, value)}`);
+		}
+		return changed;
+	}
+
+	// Deliberately separate from isBreaking()/updateIndexSettings: embedder config
+	// changes are the only thing that can make Meilisearch re-embed every document
+	// through a (often paid) embedding API, so this must only fire when a semantic
+	// search field was itself part of the diff - never as a side effect of saving
+	// unrelated settings like ranking rules or stop words.
+	async function semanticSettingsChanged(newSettings) {
+		if (!newSettings) return false;
+		const results = await Promise.all(SEMANTIC_SETTING_KEYS.map(async (key) => {
+			if (!Object.prototype.hasOwnProperty.call(newSettings, key)) return false;
+			const stored = await settings.getOne(plugin.id, key);
+			return !deepCompare(stored, newSettings[key]);
+		}));
+		return results.some(Boolean);
+	}
+
+	plugin.saveSettings = async (data) => {
+		if (data.plugin === plugin.id && !data.quiet && plugin.initialized) {
+			try {
+				if (data.settings && Object.prototype.hasOwnProperty.call(data.settings, 'searchMinTermLength')) {
+					data.settings.searchMinTermLength = clampMinTermLength(data.settings.searchMinTermLength);
+				}
+				// #8: Only re-connect when connection settings changed.
+				const connChanged = await connectionSettingsChanged(data.settings);
+				if (connChanged) {
+					// Fix 10: If host changed, clear indexed so prepareSearch auto-reindexes the new (empty) host.
+					const hostChanged = await hostSettingChanged(data.settings);
+					if (hostChanged) {
+						await settings.set(plugin.id, { indexed: false }, true);
+						// The new host has no memory of what embedder config this plugin last
+						// applied to the OLD host - without this, an unchanged semantic search
+						// setting would look "already applied" and never get pushed to the new host.
+						await resetAppliedConfigs(plugin);
+					}
+					await plugin.prepareSearch(data.settings, true);
+				}
+				const changed = (await Promise.all(
+					Object.entries(data.settings).map(([k, v]) => isBreaking([k, v])),
+				)).some(Boolean);
+				if (changed) {
+					winston.info('settings changed, updating index');
+					await plugin.updateIndexSettings(data.settings);
+				}
+				if (await semanticSettingsChanged(data.settings)) {
+					winston.info('[plugin/meilisearch] semantic search settings changed, updating embedders');
+					await plugin.updateEmbedders(data.settings);
+				}
+			} catch (err) {
+				// #7: Don't throw — let settings persist to DB even when Meili is unreachable.
+				// C1 fix: redact any apiKey that Meilisearch may echo in its error message before
+				// logging. Falls back to pattern-only redaction if settings DB is unreachable.
+				// A3-style inner try/catch: fall back to raw err.message if redaction itself fails,
+				// so the error still surfaces (just unredacted) rather than silently swallowing it.
+				const rawReason = err.message;
+				let safeReason;
+				try {
+					safeReason = await redactSecrets(rawReason, plugin);
+				} catch {
+					safeReason = rawReason;
+				}
+				winston.error(`[plugin/meilisearch] Error while saving settings: ${safeReason}`);
+				plugin.healthy = false;
+				// Surface the failure to admins in the ACP — without this, the client sees the
+				// "Settings Saved" success toast even when Meilisearch silently rejected the
+				// settings/embedder update. Client-side validation (admin.js) is the primary
+				// UX path for invalid configs; this catches connection-level failures (e.g.
+				// Meilisearch host unreachable after Fix B's 30s HTTP timeout fires).
+				// C1 fix: surface the failure to admins without leaking credentials. The error
+				// message may contain the apiKey if Meilisearch echoes it in 401 responses.
+				plugin.notifyAdmins('settings:save', {
+					type: 'danger',
+					titleKey: '[[meilisearch:admin.meilisearchError]]',
+					message: safeReason,
+				});
+			}
+		}
+		return data;
+	};
+};

package/lib/state.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const winston = nodebb.require('winston');
+const Sockets = nodebb.require('./src/socket.io');
+const pubsub = nodebb.require('./src/pubsub');
+const user = nodebb.require('./src/user');
+const { defaults, breakingSettings } = require('./defaults');
+
+// Sockets currently joined to 'admin/plugins/meilisearch' (set by app.enterRoom in ACP).
+// NodeBB 4.15.0 SocketMeta.rooms.enter only guards uid_/chat_/topic_/category_ prefixes
+// (verified in NodeBB v4.15.0 src/socket.io/meta.js) — arbitrary room names like
+// 'admin/plugins/meilisearch' are freely joinable by any authenticated user. Filter by
+// isAdministrator before emitting, so alert payloads (which may contain embedder endpoint
+// URLs / model names from Meilisearch task error messages) don't reach authenticated
+// non-admins who manually joined the room. isAdministrator is Redis-cached for 60s by
+// NodeBB core (src/user.js), so for low-frequency alert emissions the overhead is sub-ms.
+async function emitToAdmins(eventName, payload) {
+	const sockets = await Sockets.server.in('admin/plugins/meilisearch').fetchSockets();
+	if (!sockets.length) return;
+	const adminChecks = await Promise.all(
+		// Use s.data.uid (cluster-safe — socket.data is shared across nodes via fetchSockets,
+		// verified in NodeBB v4.15.0 src/socket.io/index.js:87-88). s.uid only exists on the
+		// local node, so in a multi-node cluster, s.uid would be undefined for remote sockets,
+		// silently defeating the admin-only filter.
+		sockets.map(s => (s.data && s.data.uid ? user.isAdministrator(s.data.uid) : Promise.resolve(false))),
+	);
+	sockets.forEach((s, i) => {
+		if (adminChecks[i]) s.emit(eventName, payload);
+	});
+}
+
+// Sets up the plugin object's mutable state and cross-instance sync via pubsub.
+// Must run before any other lib/* attach step since everything else reads/writes these fields.
+module.exports = function initState(plugin) {
+	plugin.id = 'meilisearch';
+	plugin.healthy = false;
+
+	plugin.indexing = {
+		running: false,
+		topic_progress: { total: null, current: null },
+		post_progress: { total: null, current: null },
+		message_progress: { total: null, current: null },
+	};
+
+	plugin.reindexingForced = false;
+	plugin.pendingDuringReindex = [];
+	plugin.reindexLockRefresh = null;
+
+	/** @type {import('meilisearch').Meilisearch} */
+	plugin.client = undefined;
+	plugin.defaults = defaults;
+	plugin.breakingSettings = breakingSettings;
+	plugin.initialized = false;
+	plugin.initializingOnAnotherInstance = false;
+	plugin.healthCheckTask = null;
+
+	pubsub.on('meilisearch:reindex', (indexing) => {
+		plugin.indexing = indexing;
+		emitToAdmins('plugins.meilisearch.reindex', plugin.indexing)
+			.catch(err => winston.error(`[plugin/meilisearch] emitToAdmins reindex failed: ${err.message}`));
+	});
+	pubsub.on('meilisearch:init', (initializing) => {
+		plugin.initializingOnAnotherInstance = initializing;
+	});
+	pubsub.on('meilisearch:alert', (alert) => {
+		emitToAdmins('plugins.meilisearch.alert', alert)
+			.catch(err => winston.error(`[plugin/meilisearch] emitToAdmins alert failed: ${err.message}`));
+	});
+};