@jasonwch/nodebb-plugin-meilisearch-r 1.1.1 → 1.2.0

package/lib/routes.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const winston = nodebb.require('winston');
+const routeHelpers = nodebb.require('./src/routes/helpers');
+const settings = nodebb.require('./src/meta/settings');
+
+// Plugin lifecycle + HTTP surface: static:app.load init, the reindex REST API,
+// the ACP nav entry, and the admin-notices health line.
+module.exports = function attachRoutes(plugin) {
+	plugin.init = async function (params) {
+		const { router } = params;
+		winston.debug('[plugin/meilisearch] Initializing MeiliSearch plugin');
+		routeHelpers.setupAdminPageRoute(router, '/admin/plugins/meilisearch', [], async (req, res) => {
+			const topicTotal = Number(plugin.indexing.topic_progress.total) || 0;
+			const topicCurrent = Number(plugin.indexing.topic_progress.current) || 0;
+			const postTotal = Number(plugin.indexing.post_progress.total) || 0;
+			const postCurrent = Number(plugin.indexing.post_progress.current) || 0;
+			const messageTotal = Number(plugin.indexing.message_progress.total) || 0;
+			const messageCurrent = Number(plugin.indexing.message_progress.current) || 0;
+			const topicPercent = topicTotal > 0 ? Math.min(100, Math.max(0, Math.round(100 * topicCurrent / topicTotal))) : 0;
+			const postPercent = postTotal > 0 ? Math.min(100, Math.max(0, Math.round(100 * postCurrent / postTotal))) : 0;
+			const messagePercent = messageTotal > 0 ? Math.min(100, Math.max(0, Math.round(100 * messageCurrent / messageTotal))) : 0;
+			const lastReindexResult = await settings.getOne(plugin.id, 'lastReindexResult') || {};
+			res.render('admin/plugins/meilisearch', {
+				title: '[[meilisearch:admin.settings]]',
+				indexing: plugin.indexing,
+				topicPercent,
+				postPercent,
+				messagePercent,
+				lastReindexResult,
+			});
+		});
+		await settings.setOnEmpty(plugin.id, plugin.defaults);
+		await plugin.prepareSearch();
+		await plugin.ensureChatMessageIndex();
+		plugin.patchTopicsSearch();
+		plugin.initialized = true;
+	};
+
+	plugin.addRoutes = async function ({ router, middleware, helpers }) {
+		const middlewares = [
+			middleware.ensureLoggedIn,
+			middleware.admin.checkPrivileges,
+		];
+		routeHelpers.setupApiRoute(router, 'get', '/meilisearch/reindex', middlewares, async (req, res) => {
+			helpers.formatApiResponse(200, res, {
+				indexing: plugin.indexing,
+				healthy: plugin.healthy,
+				lastReindexResult: await settings.getOne(plugin.id, 'lastReindexResult') || {},
+			});
+		});
+
+		routeHelpers.setupApiRoute(router, 'post', '/meilisearch/reindex', middlewares, async (req, res) => {
+			await settings.set(plugin.id, { indexed: false }, true);
+			plugin.reindex(false);
+			helpers.formatApiResponse(202, res, plugin.indexing);
+		});
+		routeHelpers.setupApiRoute(router, 'delete', '/meilisearch/reindex', middlewares, async (req, res) => {
+			await settings.set(plugin.id, { indexed: false }, true);
+			plugin.reindex(true);
+			helpers.formatApiResponse(202, res, plugin.indexing);
+		});
+
+		// Pure A: Ollama reachability probe. NodeBB container makes a 5s HTTP GET to
+		// <url>/api/version (or http://localhost:11434/api/version if URL is blank — the
+		// lib/embedder.js default). Used by static/lib/admin.js saveSettings to show a
+		// modal when Ollama is unreachable from NodeBB. Test runs from NodeBB's container,
+		// not Meilisearch's — admin is informed of this in the modal text so they can
+		// override with "Save anyway" if they're confident Meilisearch can reach Ollama
+		// on a different network path (e.g. Meilisearch runs with --network=host).
+		routeHelpers.setupApiRoute(router, 'post', '/meilisearch/test-ollama', middlewares, async (req, res) => {
+			const rawUrl = (req.body && typeof req.body.url === 'string') ? req.body.url : '';
+			// Default URL mirrors lib/embedder.js ollama fallback
+			const ollamaUrl = rawUrl || 'http://localhost:11434/api/embeddings';
+			// Strip /api/embeddings suffix if admin included it, then append /api/version probe path
+			const ollamaBase = ollamaUrl.replace(/\/api\/embeddings\/?$/, '').replace(/\/$/, '');
+			const probeUrl = `${ollamaBase}/api/version`;
+			// Declare controller/timeout above the try block so the finally clause can always
+			// clear the timer — even if the synchronous URL parsing or fetch setup throws
+			// before the await resolves (e.g. malformed URL → `new URL()` throws inside fetch).
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), 5000);
+			try {
+				const response = await fetch(probeUrl, { signal: controller.signal });
+				if (!response.ok) {
+					return helpers.formatApiResponse(200, res, {
+						reachable: false,
+						error: `Ollama responded HTTP ${response.status} ${response.statusText}`,
+						probeUrl,
+					});
+				}
+				const data = await response.json().catch(() => ({}));
+				return helpers.formatApiResponse(200, res, {
+					reachable: true,
+					version: data.version,
+					probeUrl,
+				});
+			} catch (err) {
+				return helpers.formatApiResponse(200, res, {
+					reachable: false,
+					error: err.name === 'AbortError' ? 'Timeout after 5s' : err.message,
+					probeUrl,
+				});
+			} finally {
+				clearTimeout(timeout);
+			}
+		});
+	};
+
+	plugin.addAdminNavigation = function (header) {
+		header.plugins.push({
+			route: '/plugins/meilisearch',
+			icon: 'fa-tint',
+			name: 'Meilisearch',
+		});
+
+		return header;
+	};
+
+	plugin.getNotices = async function (notices) {
+		const checkHealth = await plugin.checkHealth();
+		notices.push({
+			done: checkHealth,
+			doneText: 'MeiliSearch connection OK',
+			notDoneText: 'Could not connect to MeiliSearch',
+		});
+		return notices;
+	};
+};

package/lib/search.js

@@ -0,0 +1,230 @@
+'use strict';
+
+const winston = nodebb.require('winston');
+const settings = nodebb.require('./src/meta/settings');
+const plugins = nodebb.require('./src/plugins');
+const { resolveMinTermLength } = require('./settings-helpers');
+const { EMBEDDER_NAME, isSemanticSearchEnabled, getSemanticRatio, getSemanticScoreThreshold } = require('./embedder');
+
+// rankingScoreThreshold is a top-level search parameter (a sibling of "hybrid", not nested
+// inside it) - Meilisearch defaults it to 0 (no filtering) when omitted, which is why
+// unfiltered vector search returns its full `limit` regardless of how unrelated the tail is.
+async function buildSemanticSearchExtras(plugin) {
+	if (!(await isSemanticSearchEnabled(plugin))) return {};
+	return {
+		hybrid: { embedder: EMBEDDER_NAME, semanticRatio: await getSemanticRatio(plugin) },
+		rankingScoreThreshold: await getSemanticScoreThreshold(plugin),
+	};
+}
+
+// Runs a Meilisearch query and never lets it throw past this point: a broken/misconfigured
+// embedder (e.g. "Cannot find embedder with name `default`") must not take down normal
+// keyword search or callers like Topics.getSuggestedTopics, which propagate rejections
+// straight up through NodeBB's hook chain. If hybrid search fails, retries once as a plain
+// keyword search so users still get results instead of nothing; if that also fails (e.g.
+// Meilisearch itself is down), logs + alerts once (throttled) and returns null so the
+// caller can fall back to its original, unmodified data.
+async function safeSearch(plugin, indexName, term, opts) {
+	try {
+		return await plugin.client.index(indexName).search(term, opts);
+	} catch (err) {
+		const reason = err?.message || String(err);
+		if (opts.hybrid) {
+			winston.error(`[plugin/meilisearch] Hybrid search on "${indexName}" failed (${reason}); falling back to keyword-only search`);
+			plugin.notifyAdmins(`search:${indexName}`, {
+				type: 'danger',
+				titleKey: '[[meilisearch:admin.semanticSearchDegraded]]',
+				message: `${indexName}: ${reason}`,
+			});
+			// rankingScoreThreshold is tuned for hybrid/vector scores - drop it too, or a
+			// keyword-only fallback could wrongly filter out valid BM25-style matches.
+			const { hybrid, rankingScoreThreshold, ...keywordOnly } = opts;
+			try {
+				return await plugin.client.index(indexName).search(term, keywordOnly);
+			} catch (fallbackErr) {
+				winston.error(`[plugin/meilisearch] Keyword-only fallback search on "${indexName}" also failed: ${fallbackErr.message}`);
+				return null;
+			}
+		}
+		winston.error(`[plugin/meilisearch] Search on "${indexName}" failed: ${reason}`);
+		plugin.notifyAdmins(`search:${indexName}`, {
+			type: 'danger',
+			titleKey: '[[meilisearch:admin.semanticSearchDegraded]]',
+			message: `${indexName}: ${reason}`,
+		});
+		return null;
+	}
+}
+
+// Core search integration: filter:search.query / filter:topic.search / filter:messaging.searchMessages.
+module.exports = function attachSearch(plugin) {
+	plugin.checkConflict = function () {
+		const hooksToCheck = [
+			'filter:search.query',
+			'filter:topic.search',
+			'filter:messaging.searchMessages',
+		];
+		// blacklist, in case someone makes a plugin using these hooks that doesn't conflict.
+		// also, outside of dbsearch the user is expected to realize they installed two search plugins.
+		const conflictingPlugins = [
+			'nodebb-plugin-dbsearch',
+			'nodebb-plugin-solr',
+			'nodebb-plugin-elasticsearch',
+			'nodebb-plugin-search-elasticsearch',
+		];
+		for (const hook of hooksToCheck) {
+			if ((plugins.loadedHooks[hook] || []).filter(hookData => conflictingPlugins.includes(hookData.id)).length >= 1) {
+				return true;
+			}
+		}
+		return false;
+	};
+
+	plugin.searchMessages = async function (data) {
+		if (!data || !data.content) {
+			return data;
+		}
+		if (plugin.checkConflict()) {
+			winston.warn('[plugin/meilisearch] Another search plugin (most likely dbsearch) is enabled, so chat search via Meilisearch was aborted.');
+			return data;
+		}
+		if (!plugin.healthy && !(await plugin.checkHealth())) {
+			winston.warn('[plugin/meilisearch] Meilisearch instance did not return a healthy response, so chat search via Meilisearch was aborted.');
+			return data;
+		}
+		const rawQuery = String(data.content).trim();
+		const minTermLength = await resolveMinTermLength(plugin);
+		if (!rawQuery || !rawQuery.split(' ').some(word => word.length >= minTermLength)) {
+			winston.debug(`[plugin/meilisearch] Skipping chat search: no query word >= ${minTermLength} char(s)`);
+			return data;
+		}
+		const num = (v) => {
+			const n = parseInt(v, 10);
+			return Number.isFinite(n) ? n : null;
+		};
+		const filter = [];
+		// Core passes roomId/uid as arrays (filter:messaging.searchMessages payload in src/api/search.js).
+		const roomIds = Array.isArray(data.roomId) ? data.roomId : [data.roomId];
+		const roomNums = roomIds.map(num).filter(r => r !== null);
+		// Fail closed: if no valid roomId, return no results rather than searching globally across all rooms.
+		if (!roomNums.length) {
+			winston.warn('[plugin/meilisearch] searchMessages called with no valid roomId; returning no results');
+			return data;
+		}
+		filter.push(roomNums.map(rid => `roomId = ${rid}`));
+		// uid is an optional sender filter (message author, not the searcher); never populated by core callers.
+		const uids = Array.isArray(data.uid) ? data.uid : [data.uid];
+		const uidNums = uids.map(num).filter(u => u !== null);
+		if (uidNums.length) {
+			filter.push(uidNums.map(u => `uid = ${u}`));
+		}
+		const limit = parseInt(await settings.getOne(plugin.id, 'maxDocuments') || 100, 10);
+		winston.debug(`[plugin/meilisearch] Searching chat messages for "${rawQuery}" in room ${roomNums.join(',')}`);
+		const result = await safeSearch(plugin, 'chat_message', rawQuery, {
+			attributesToRetrieve: ['mid'],
+			limit: Math.min(limit, 100),
+			filter: filter.length ? filter : undefined,
+			matchingStrategy: data.matchWords === 'all' ? 'all' : 'last',
+			...(await buildSemanticSearchExtras(plugin)),
+		});
+		if (!result) return data;
+		data.ids = data.ids.concat(result.hits.map(hit => hit.mid));
+		return data;
+	};
+
+	plugin.search = async function (data) {
+		if (plugin.checkConflict()) {
+			// The dbsearch plugin was detected, abort search!
+			winston.warn(
+				'[plugin/meilisearch] Another search plugin (most likely dbsearch) is enabled, so search via Meilisearch was aborted.',
+			);
+			return data;
+		}
+		if (!plugin.healthy && !(await plugin.checkHealth())) {
+			winston.warn(
+				'[plugin/meilisearch] Meilisearch instance did not return a healthy response, so search via Meilisearch was aborted.',
+			);
+			return data;
+		}
+		const rawQuery = (data.term || data.content || '').trim();
+		const minTermLength = await resolveMinTermLength(plugin);
+		if (!rawQuery || !rawQuery.split(' ').some(word => word.length >= minTermLength)) {
+			winston.debug(`[plugin/meilisearch] Skipping search: no query word >= ${minTermLength} char(s)`);
+			return data;
+		}
+		// #6: Use local variables instead of mutating the shared payload.
+		const content = data.term || data.content;
+		const searchData = data.term ? { tid: data.tid } : data?.searchData;
+		const rawIndex = Array.isArray(data?.index) ? data.index[0] : data.index;
+		const ALLOWED_INDEXES = { post: 'pid', topic: 'tid' };
+		const index = ALLOWED_INDEXES[rawIndex] ? rawIndex : 'post';
+		const id = ALLOWED_INDEXES[index];
+		winston.debug(`[plugin/meilisearch] Searching for ${content} in ${index}`);
+		const result = await safeSearch(plugin, index, content, {
+			attributesToRetrieve: [id],
+			limit: parseInt(await settings.getOne(plugin.id, 'maxDocuments') || 500, 10),
+			filter: plugin.buildFilter(
+				data.cid,
+				data.uid,
+				searchData?.timeFilter,
+				searchData?.timeRange,
+				searchData?.tid,
+			),
+			sort: plugin.buildSort(searchData?.sortBy, searchData?.sortDirection),
+			matchingStrategy: data.matchWords === 'all' ? 'all' : 'last',
+			...(await buildSemanticSearchExtras(plugin)),
+		});
+		if (!result) return data;
+		data.ids = result.hits.map(hit => hit[id]);
+		return data;
+	};
+
+	plugin.buildFilter = function (categories, postedBy, timeFilter, timeRange, tid) {
+		const num = (v) => {
+			const n = parseInt(v, 10);
+			return Number.isFinite(n) ? n : null;
+		};
+		const filter = [];
+		if (categories?.length) {
+			const cids = categories.map(num).filter(c => c !== null);
+			if (cids.length) filter.push(cids.map(cid => `cid = ${cid}`));
+		}
+		if (postedBy?.length) {
+			const uids = postedBy.map(num).filter(u => u !== null);
+			if (uids.length) filter.push(uids.map(uid => `uid = ${uid}`));
+		}
+		if (timeFilter && timeRange) {
+			const range = num(timeRange);
+			if (range !== null) {
+				filter.push(`timestamp ${timeFilter === 'newer' ? '>' : '<'} ${Date.now() - (range * 1000)}`);
+			}
+		}
+		const numericTid = num(tid);
+		if (numericTid !== null) {
+			filter.push(`tid = ${numericTid}`);
+		}
+		return filter.length ? filter : undefined;
+	};
+
+	plugin.buildSort = function (sortBy, sortDirection) {
+		let field = '';
+		switch (sortBy) {
+			case 'timestamp':
+				field = 'timestamp';
+				break;
+			case 'topic.title':
+				field = 'title';
+				break;
+			case 'category':
+				field = 'cid';
+				break;
+			default:
+				return undefined;
+		}
+		return [`${field}:${sortDirection === 'ascending' ? 'asc' : 'desc'}`];
+	};
+};
+
+// Exposed so other direct-search call sites (lib/chat-search-global.js) get the same
+// crash-proofing/degrade-and-alert behavior instead of duplicating or, worse, skipping it.
+module.exports.safeSearch = safeSearch;

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,119 @@
+'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');
+
+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) {
+			winston.info(`[plugin/meilisearch] ${setting} changed: ${JSON.stringify(stored)} -> ${JSON.stringify(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.
+				winston.error(`[plugin/meilisearch] Error while saving settings: ${err.message}`);
+				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).
+				plugin.notifyAdmins('settings:save', {
+					type: 'danger',
+					titleKey: '[[meilisearch:admin.meilisearchError]]',
+					message: err.message,
+				});
+			}
+		}
+		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}`));
+	});
+};