nodebb-plugin-integration 0.4.1 → 0.4.4

package/src/config/index.js

@@ -1,133 +1,176 @@
-"use strict";
-
-/**
- * NodeBB Integration Layer
- *
- * Configuration provider
- *
- * Settings are stored in the NodeBB database
- * using meta.settings.
- */
-
-let meta = null;
-
-try {
-
-    meta = require.main.require("./src/meta");
-
-} catch (err) {
-
-    // Standalone mode (tests, npm, CLI)
-
-}
-
-const DEFAULTS = {
-
-    aiProvider: "fake",
-
-    openaiApiKey: "",
-
-    openaiModel: "text-embedding-3-small",
-
-    qdrantUrl: "http://localhost:6333",
-
-    collection: "nodebb_knowledge",
-
-    mcpEnabled: false,
-
-    mcpPort: 3001
-
-};
-
-async function get() {
-
-    if (!meta) {
-        return { ...DEFAULTS };
-    }
-
-    try {
-
-        return await meta.settings.get(
-            "nodebb-plugin-integration",
-            DEFAULTS
-        );
-
-    } catch (err) {
-
-        console.error(
-            "[Config] unable to load settings:",
-            err.message
-        );
-
-        return { ...DEFAULTS };
-
-    }
-
-}
-
-async function set(values) {
-
-    if (!meta) {
-        return false;
-    }
-
-    try {
-
-        await meta.settings.set(
-            "nodebb-plugin-integration",
-            values
-        );
-
-        return true;
-
-    } catch (err) {
-
-        console.error(
-            "[Config] unable to save settings:",
-            err.message
-        );
-
-        return false;
-
-    }
-
-}
-
-async function info() {
-
-    const cfg = await get();
-
-    return {
-
-        aiProvider: cfg.aiProvider,
-
-        openaiModel: cfg.openaiModel,
-
-        qdrantUrl: cfg.qdrantUrl,
-
-        collection: cfg.collection,
-
-        mcpEnabled: cfg.mcpEnabled,
-
-        mcpPort: cfg.mcpPort,
-
-        openaiApiKey:
-            cfg.openaiApiKey
-                ? "***configured***"
-                : ""
-
-    };
-
-}
-
-module.exports = {
-
-    get,
-
-    set,
-
-    info,
-
-    defaults: DEFAULTS
-
-};
+"use strict";
+
+const crypto = require("crypto");
+const Validation = require("./validation");
+
+const DEFAULTS = Object.freeze({
+    aiProvider: "openai",
+    openaiApiKey: "",
+    openaiModel: "text-embedding-3-small",
+    embeddingSize: 1536,
+    qdrantUrl: "http://qdrant:6333",
+    collection: "nodebb_knowledge",
+    excludedCategories: [],
+
+    mcpEnabled: false,
+    mcpHost: "127.0.0.1",
+    mcpPort: 3100,
+    mcpNodebbUrl: "http://127.0.0.1:4567",
+    mcpBearerToken: "",
+    mcpServiceUid: 0,
+
+    internalApiToken: ""
+});
+
+const SETTINGS_KEY = "nodebb-plugin-integration";
+
+let nativeMeta = null;
+
+function getMeta() {
+    if (nativeMeta) {
+        return nativeMeta;
+    }
+
+    try {
+        if (typeof nodebb !== "undefined" && nodebb &&
+            typeof nodebb.require === "function") {
+            nativeMeta = nodebb.require("./src/meta");
+        }
+    } catch (error) {
+        throw new Error(`Cannot load NodeBB meta module: ${error.message}`);
+    }
+
+    if (!nativeMeta || !nativeMeta.settings) {
+        throw new Error("NodeBB settings API is unavailable");
+    }
+
+    return nativeMeta;
+}
+
+async function get() {
+    const meta = getMeta();
+    const saved = await meta.settings.get(SETTINGS_KEY);
+    const settings = Validation.normalize(saved || {}, DEFAULTS);
+
+    if (!settings.internalApiToken) {
+        settings.internalApiToken = crypto.randomBytes(48).toString("hex");
+        await meta.settings.set(SETTINGS_KEY, settings);
+    }
+
+    return settings;
+}
+
+async function set(values = {}) {
+    if (!values || typeof values !== "object" || Array.isArray(values)) {
+        throw new TypeError("Settings must be an object");
+    }
+
+    const current = await get();
+    const next = { ...current };
+
+    const allowed = [
+        "aiProvider",
+        "openaiApiKey",
+        "openaiModel",
+        "embeddingSize",
+        "qdrantUrl",
+        "collection",
+        "excludedCategories",
+        "mcpEnabled",
+        "mcpHost",
+        "mcpPort",
+        "mcpNodebbUrl",
+        "mcpBearerToken",
+        "mcpServiceUid"
+    ];
+
+    for (const key of allowed) {
+        if (Object.prototype.hasOwnProperty.call(values, key)) {
+            next[key] = values[key];
+        }
+    }
+
+    for (const key of ["openaiApiKey", "mcpBearerToken"]) {
+        if (
+            Object.prototype.hasOwnProperty.call(values, key) &&
+            (typeof values[key] !== "string" || !values[key].trim())
+        ) {
+            next[key] = current[key];
+        }
+    }
+
+    if (Object.prototype.hasOwnProperty.call(values, "aiProvider")) {
+        next.aiProvider = Validation.validateAiProvider(values.aiProvider);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(values, "qdrantUrl")) {
+        next.qdrantUrl = Validation.validateQdrantUrl(values.qdrantUrl);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(values, "mcpHost")) {
+        next.mcpHost = Validation.validateMcpHost(values.mcpHost);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(values, "mcpPort")) {
+        next.mcpPort = Validation.validatePort(values.mcpPort);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(values, "mcpNodebbUrl")) {
+        next.mcpNodebbUrl = Validation.validateNodebbUrl(values.mcpNodebbUrl);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(values, "mcpServiceUid")) {
+        next.mcpServiceUid = Validation.validateServiceUid(values.mcpServiceUid);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(values, "mcpBearerToken")) {
+        next.mcpBearerToken = Validation.validateBearerToken(next.mcpBearerToken);
+    }
+
+    const normalized = Validation.normalize(next, DEFAULTS);
+
+    if (normalized.mcpEnabled) {
+        if (!normalized.mcpBearerToken) {
+            throw new Error("Set MCP Bearer Token before enabling MCP");
+        }
+
+        if (!normalized.mcpServiceUid) {
+            throw new Error("Set MCP service UID before enabling MCP");
+        }
+    }
+
+    await getMeta().settings.set(SETTINGS_KEY, normalized);
+
+    return normalized;
+}
+
+async function info() {
+    const settings = await get();
+
+    return {
+        aiProvider: settings.aiProvider,
+        aiProviderOpenai: settings.aiProvider === "openai",
+        aiProviderFake: settings.aiProvider === "fake",
+        openaiConfigured: Boolean(settings.openaiApiKey),
+        openaiModel: settings.openaiModel,
+        embeddingSize: settings.embeddingSize,
+        qdrantUrl: settings.qdrantUrl,
+        collection: settings.collection,
+        excludedCategories: settings.excludedCategories,
+
+        mcpEnabled: settings.mcpEnabled,
+        mcpHost: settings.mcpHost,
+        mcpPort: settings.mcpPort,
+        mcpNodebbUrl: settings.mcpNodebbUrl,
+        mcpBearerTokenConfigured: Boolean(settings.mcpBearerToken),
+        mcpServiceUid: settings.mcpServiceUid,
+        internalApiConfigured: Boolean(settings.internalApiToken)
+    };
+}
+
+module.exports = {
+    DEFAULTS,
+    get,
+    set,
+    info
+};

package/src/config/validation.js

@@ -0,0 +1,250 @@
+"use strict";
+
+const net = require("net");
+
+function normalizeBoolean(value) {
+    return value === true ||
+        value === "true" ||
+        value === "on" ||
+        value === 1;
+}
+
+function normalizeCategories(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+
+    return [...new Set(
+        value
+            .map(Number)
+            .filter(item => Number.isSafeInteger(item) && item > 0)
+    )];
+}
+
+function validateHttpUrl(value, label) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${label} is required`);
+    }
+
+    let parsed;
+
+    try {
+        parsed = new URL(value.trim());
+    } catch {
+        throw new Error(`Invalid ${label}`);
+    }
+
+    if (
+        !["http:", "https:"].includes(parsed.protocol) ||
+        !parsed.hostname ||
+        parsed.username ||
+        parsed.password ||
+        parsed.search ||
+        parsed.hash
+    ) {
+        throw new Error(`${label} must be a valid HTTP or HTTPS URL`);
+    }
+
+    return parsed.toString().replace(/\/+$/, "");
+}
+
+function validateQdrantUrl(value) {
+    return validateHttpUrl(value, "Qdrant URL");
+}
+
+function validateNodebbUrl(value) {
+    return validateHttpUrl(value, "NodeBB API URL");
+}
+
+function validateAiProvider(value) {
+    if (value !== "openai" && value !== "fake") {
+        throw new Error("AI provider must be openai or fake");
+    }
+
+    return value;
+}
+
+function validateMcpHost(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error("MCP bind address is required");
+    }
+
+    const host = value.trim();
+
+    if (host.length > 253 || /[\s/\\?#@]/.test(host)) {
+        throw new Error("Invalid MCP bind address");
+    }
+
+    if (net.isIP(host)) {
+        return host;
+    }
+
+    const labels = host.split(".");
+
+    const validHostname = labels.every((label) => {
+        if (
+            label.length < 1 ||
+            label.length > 63 ||
+            !/[a-zA-Z0-9]/.test(label[0]) ||
+            !/[a-zA-Z0-9]/.test(label[label.length - 1])
+        ) {
+            return false;
+        }
+
+        return [...label].every((char) => (
+            (char >= "a" && char <= "z") ||
+            (char >= "A" && char <= "Z") ||
+            (char >= "0" && char <= "9") ||
+            char === "-"
+        ));
+    });
+
+    if (!validHostname) {
+        throw new Error("Invalid MCP bind address");
+    }
+
+    return host;
+}
+
+function validatePort(value) {
+    const port = Number(value);
+
+    if (!Number.isSafeInteger(port) || port < 1 || port > 65535) {
+        throw new Error("MCP port must be between 1 and 65535");
+    }
+
+    return port;
+}
+
+function validateServiceUid(value) {
+    const uid = Number(value);
+
+    if (!Number.isSafeInteger(uid) || uid < 1) {
+        throw new Error("MCP service UID must be a positive NodeBB user ID");
+    }
+
+    return uid;
+}
+
+function validateBearerToken(value) {
+    if (typeof value !== "string" || /[\r\n]/.test(value)) {
+        throw new Error("Invalid MCP Bearer Token");
+    }
+
+    const token = value.trim();
+
+    if (/\s/.test(token)) {
+        throw new Error("MCP Bearer Token must not contain whitespace");
+    }
+
+    if (token && token.length < 32) {
+        throw new Error("MCP Bearer Token must contain at least 32 characters");
+    }
+
+    if (token.length > 512) {
+        throw new Error("Invalid MCP Bearer Token");
+    }
+
+    return token;
+}
+
+function normalize(values = {}, defaults) {
+    const result = {
+        ...defaults,
+        ...values
+    };
+
+    try {
+        result.aiProvider = validateAiProvider(result.aiProvider);
+    } catch {
+        result.aiProvider = defaults.aiProvider;
+    }
+
+    result.openaiApiKey =
+        typeof result.openaiApiKey === "string"
+            ? result.openaiApiKey.trim()
+            : "";
+
+    result.openaiModel =
+        typeof result.openaiModel === "string" &&
+        result.openaiModel.trim()
+            ? result.openaiModel.trim()
+            : defaults.openaiModel;
+
+    result.embeddingSize = Number(result.embeddingSize);
+
+    if (
+        !Number.isSafeInteger(result.embeddingSize) ||
+        result.embeddingSize < 1
+    ) {
+        result.embeddingSize = defaults.embeddingSize;
+    }
+
+    try {
+        result.qdrantUrl = validateQdrantUrl(result.qdrantUrl);
+    } catch {
+        result.qdrantUrl = defaults.qdrantUrl;
+    }
+
+    result.collection =
+        typeof result.collection === "string" &&
+        /^[a-zA-Z0-9_-]+$/.test(result.collection.trim())
+            ? result.collection.trim()
+            : defaults.collection;
+
+    result.excludedCategories =
+        normalizeCategories(result.excludedCategories);
+
+    result.mcpEnabled = normalizeBoolean(result.mcpEnabled);
+
+    try {
+        result.mcpHost = validateMcpHost(result.mcpHost);
+    } catch {
+        result.mcpHost = defaults.mcpHost;
+    }
+
+    try {
+        result.mcpPort = validatePort(result.mcpPort);
+    } catch {
+        result.mcpPort = defaults.mcpPort;
+    }
+
+    try {
+        result.mcpNodebbUrl = validateNodebbUrl(result.mcpNodebbUrl);
+    } catch {
+        result.mcpNodebbUrl = defaults.mcpNodebbUrl;
+    }
+
+    try {
+        result.mcpServiceUid = validateServiceUid(result.mcpServiceUid);
+    } catch {
+        result.mcpServiceUid = 0;
+    }
+
+    try {
+        result.mcpBearerToken = validateBearerToken(result.mcpBearerToken);
+    } catch {
+        result.mcpBearerToken = "";
+    }
+
+    result.internalApiToken =
+        typeof result.internalApiToken === "string"
+            ? result.internalApiToken
+            : "";
+
+    return result;
+}
+
+module.exports = {
+    normalizeBoolean,
+    normalizeCategories,
+    validateHttpUrl,
+    validateQdrantUrl,
+    validateNodebbUrl,
+    validateAiProvider,
+    validateMcpHost,
+    validatePort,
+    validateServiceUid,
+    validateBearerToken,
+    normalize
+};