nodebb-plugin-admin-ai-connect 1.0.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "nodebb-plugin-admin-ai-connect",
+  "version": "1.0.0",
+  "description": "Pro tool-set for Goldnat AI Connect — create topics, reply, edit, message, follow. Requires nodebb-plugin-ai-connect (core) to run.",
+  "main": "src/index.js",
+  "peerDependencies": {
+    "nodebb-plugin-ai-connect": "*"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "author": "Goldnat",
+  "nbbpm": {
+    "compatibility": "^3.0.0 || ^4.0.0"
+  },
+  "keywords": [
+    "nodebb",
+    "plugin",
+    "ai",
+    "mcp",
+    "gacp",
+    "webmcp",
+    "goldnat",
+    "ai-connect",
+    "admin",
+    "pro"
+  ],
+  "homepage": "https://goldnat.ai/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chgold/nodebb-plugin-admin-ai-connect"
+  },
+  "bugs": {
+    "url": "https://github.com/chgold/nodebb-plugin-admin-ai-connect/issues"
+  },
+  "license": "PROPRIETARY"
+}

package/src/ProModule.js

@@ -0,0 +1,377 @@
+'use strict';
+
+/**
+ * ProModule — the Pro tool-set for NodeBB AI Connect.
+ *
+ * Lives in a SEPARATE package (nodebb-admin-ai-connect) and is loaded into the
+ * core registry only when the Pro package is installed AND the site edition
+ * grants Pro. Mirrors the Ghost model: a standalone Pro plugin that registers
+ * its tools into the core's shared registry via a factory that receives the
+ * core's ModuleBase.
+ *
+ * NodeBB core APIs (topics/posts/messaging) are resolved from the running
+ * NodeBB instance via require.main.require, or injected in tests through
+ * ProModule._setApis().
+ */
+module.exports = function createProModule({ ModuleBase }) {
+    class ProModule extends ModuleBase {
+        getModuleName() { return 'nodebb'; }
+
+        registerTools() {
+            this.registerTool('createTopic', {
+                description: 'Create a new topic in a category',
+                inputSchema: {
+                    type: 'object',
+                    required: ['cid', 'title', 'content'],
+                    properties: {
+                        cid:     { type: 'integer' },
+                        title:   { type: 'string' },
+                        content: { type: 'string' },
+                    },
+                },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('replyToTopic', {
+                description: 'Post a reply to an existing topic',
+                inputSchema: {
+                    type: 'object',
+                    required: ['tid', 'content'],
+                    properties: {
+                        tid:     { type: 'integer' },
+                        content: { type: 'string' },
+                    },
+                },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('editPost', {
+                description: 'Edit an existing post',
+                inputSchema: {
+                    type: 'object',
+                    required: ['pid', 'content'],
+                    properties: {
+                        pid:     { type: 'integer' },
+                        content: { type: 'string' },
+                    },
+                },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('sendMessage', {
+                description: 'Send a private chat message to a user',
+                inputSchema: {
+                    type: 'object',
+                    required: ['touid', 'content'],
+                    properties: {
+                        touid:   { type: 'integer' },
+                        content: { type: 'string' },
+                    },
+                },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('followTopic', {
+                description: 'Follow or unfollow a topic for notifications',
+                inputSchema: {
+                    type: 'object',
+                    required: ['tid'],
+                    properties: {
+                        tid:    { type: 'integer' },
+                        follow: { type: 'boolean' },
+                    },
+                },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('deleteTopic', {
+                description: 'Soft-delete a topic (hides from lists; can be restored). Use purgeTopic to hard-delete.',
+                inputSchema: { type: 'object', required: ['tid'], properties: { tid: { type: 'integer' } } },
+                requiredScope: 'delete',
+                proOnly: true,
+            });
+
+            this.registerTool('purgeTopic', {
+                description: 'HARD-DELETE a topic and all its posts. Destructive and irreversible.',
+                inputSchema: { type: 'object', required: ['tid'], properties: { tid: { type: 'integer' } } },
+                requiredScope: 'delete',
+                proOnly: true,
+            });
+
+            this.registerTool('lockTopic', {
+                description: 'Lock a topic (prevents new replies).',
+                inputSchema: { type: 'object', required: ['tid'], properties: { tid: { type: 'integer' } } },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('unlockTopic', {
+                description: 'Unlock a previously locked topic.',
+                inputSchema: { type: 'object', required: ['tid'], properties: { tid: { type: 'integer' } } },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('pinTopic', {
+                description: 'Pin a topic to the top of its category.',
+                inputSchema: { type: 'object', required: ['tid'], properties: { tid: { type: 'integer' } } },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('unpinTopic', {
+                description: 'Unpin a previously pinned topic.',
+                inputSchema: { type: 'object', required: ['tid'], properties: { tid: { type: 'integer' } } },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('moveTopic', {
+                description: 'Move a topic to a different category.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['tid', 'cid'],
+                    properties: { tid: { type: 'integer' }, cid: { type: 'integer', description: 'Target category id' } },
+                },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('deletePost', {
+                description: 'Soft-delete a post (hidden but recoverable). Use purgePost to hard-delete.',
+                inputSchema: { type: 'object', required: ['pid'], properties: { pid: { type: 'integer' } } },
+                requiredScope: 'delete',
+                proOnly: true,
+            });
+
+            this.registerTool('purgePost', {
+                description: 'HARD-DELETE a post. Destructive and irreversible.',
+                inputSchema: { type: 'object', required: ['pid'], properties: { pid: { type: 'integer' } } },
+                requiredScope: 'delete',
+                proOnly: true,
+            });
+
+            this.registerTool('upvotePost', {
+                description: 'Upvote a post as the acting user.',
+                inputSchema: { type: 'object', required: ['pid'], properties: { pid: { type: 'integer' } } },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('downvotePost', {
+                description: 'Downvote a post as the acting user.',
+                inputSchema: { type: 'object', required: ['pid'], properties: { pid: { type: 'integer' } } },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('bookmarkPost', {
+                description: 'Bookmark a post for the acting user. Provide bookmark:false to remove.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['pid'],
+                    properties: { pid: { type: 'integer' }, bookmark: { type: 'boolean' } },
+                },
+                requiredScope: 'write',
+                proOnly: true,
+            });
+
+            this.registerTool('banUser', {
+                description: 'Ban a user. Provide optional reason and until (Unix timestamp; omit for permanent).',
+                inputSchema: {
+                    type: 'object',
+                    required: ['uid'],
+                    properties: {
+                        uid:    { type: 'integer' },
+                        reason: { type: 'string' },
+                        until:  { type: 'integer', description: 'Unix timestamp — ban expires at this time; omit for permanent' },
+                    },
+                },
+                requiredScope: 'admin',
+                proOnly: true,
+            });
+
+            this.registerTool('unbanUser', {
+                description: 'Lift a ban on a user.',
+                inputSchema: { type: 'object', required: ['uid'], properties: { uid: { type: 'integer' } } },
+                requiredScope: 'admin',
+                proOnly: true,
+            });
+
+            this.registerTool('deleteUserAccount', {
+                description: 'DELETE a user account. Destructive. Provide keepPosts=true to preserve their posts.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['uid'],
+                    properties: {
+                        uid:       { type: 'integer' },
+                        keepPosts: { type: 'boolean', description: 'Retain the user posts (default false)' },
+                    },
+                },
+                requiredScope: 'admin',
+                proOnly: true,
+            });
+        }
+
+        async execute_createTopic({ cid, title, content }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            const req = { ip: '127.0.0.1', headers: {}, uid };
+            const result = await topics.post({ uid, cid, title, content, req });
+            return { tid: result.topicData.tid, title: result.topicData.title, pid: result.postData.pid };
+        }
+
+        async execute_replyToTopic({ tid, content }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            const req = { ip: '127.0.0.1', headers: {}, uid };
+            const result = await topics.reply({ uid, tid, content, req });
+            return { pid: result.pid, tid };
+        }
+
+        async execute_editPost({ pid, content }, { uid } = {}) {
+            const { posts } = ProModule._getApis();
+            const req = { ip: '127.0.0.1', headers: {}, uid };
+            const result = await posts.edit({ uid, pid, content, req });
+            return { pid: result.pid, edited: true };
+        }
+
+        async execute_sendMessage({ touid, content }, { uid } = {}) {
+            const { messaging } = ProModule._getApis();
+            const roomId = await messaging.newRoom(uid, { uids: [touid] });
+            await messaging.sendMessage({ uid, roomId, content });
+            return { sent: true, touid };
+        }
+
+        async execute_followTopic({ tid, follow = true }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            if (follow) await topics.follow(tid, uid);
+            else await topics.unfollow(tid, uid);
+            return { followed: follow, tid };
+        }
+
+        async execute_deleteTopic({ tid }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            await topics.delete(tid, uid);
+            return { tid, deleted: true, hard: false };
+        }
+
+        async execute_purgeTopic({ tid }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            await topics.purge(tid, uid);
+            return { tid, purged: true, hard: true };
+        }
+
+        async execute_lockTopic({ tid }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            await topics.tools.lock(tid, uid);
+            return { tid, locked: true };
+        }
+
+        async execute_unlockTopic({ tid }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            await topics.tools.unlock(tid, uid);
+            return { tid, locked: false };
+        }
+
+        async execute_pinTopic({ tid }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            await topics.tools.pin(tid, uid);
+            return { tid, pinned: true };
+        }
+
+        async execute_unpinTopic({ tid }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            await topics.tools.unpin(tid, uid);
+            return { tid, pinned: false };
+        }
+
+        async execute_moveTopic({ tid, cid }, { uid } = {}) {
+            const { topics } = ProModule._getApis();
+            await topics.tools.move(tid, { cid, uid });
+            return { tid, moved_to_cid: cid };
+        }
+
+        async execute_deletePost({ pid }, { uid } = {}) {
+            const { posts } = ProModule._getApis();
+            await posts.delete(pid, uid);
+            return { pid, deleted: true, hard: false };
+        }
+
+        async execute_purgePost({ pid }, { uid } = {}) {
+            const { posts } = ProModule._getApis();
+            await posts.purge(pid, uid);
+            return { pid, purged: true, hard: true };
+        }
+
+        async execute_upvotePost({ pid }, { uid } = {}) {
+            const { posts } = ProModule._getApis();
+            await posts.upvote(pid, uid);
+            return { pid, vote: 'up' };
+        }
+
+        async execute_downvotePost({ pid }, { uid } = {}) {
+            const { posts } = ProModule._getApis();
+            await posts.downvote(pid, uid);
+            return { pid, vote: 'down' };
+        }
+
+        async execute_bookmarkPost({ pid, bookmark = true }, { uid } = {}) {
+            const { posts } = ProModule._getApis();
+            if (bookmark) await posts.bookmark(pid, uid);
+            else await posts.unbookmark(pid, uid);
+            return { pid, bookmarked: bookmark };
+        }
+
+        async execute_banUser({ uid: targetUid, reason, until }, { uid } = {}) {
+            const { user } = ProModule._getApis();
+            if (!(await user.exists(targetUid))) {
+                return { error: 'user_not_found' };
+            }
+            const payload = { uid: targetUid, reason: reason || '' };
+            if (until) payload.until = until;
+            await user.bans.ban(payload);
+            return { uid: targetUid, banned: true, reason: reason || null, until: until || null };
+        }
+
+        async execute_unbanUser({ uid: targetUid }, { uid } = {}) {
+            const { user } = ProModule._getApis();
+            if (!(await user.exists(targetUid))) {
+                return { error: 'user_not_found' };
+            }
+            await user.bans.unban(targetUid);
+            return { uid: targetUid, banned: false };
+        }
+
+        async execute_deleteUserAccount({ uid: targetUid, keepPosts = false }, { uid } = {}) {
+            const { user } = ProModule._getApis();
+            if (!(await user.exists(targetUid))) {
+                return { error: 'user_not_found' };
+            }
+            if (keepPosts) {
+                await user.deleteAccount(targetUid);
+            } else {
+                await user.delete(uid, targetUid);
+            }
+            return { uid: targetUid, deleted: true, kept_posts: keepPosts };
+        }
+    }
+
+    ProModule._getApis = function () {
+        if (ProModule._nodebb) return ProModule._nodebb;
+        /* istanbul ignore next */
+        return {
+            topics: require.main.require('./src/topics'),
+            posts: require.main.require('./src/posts'),
+            messaging: require.main.require('./src/messaging'),
+            user: require.main.require('./src/user'),
+        };
+    };
+
+    ProModule._setApis = function (apis) { ProModule._nodebb = apis; };
+
+    return ProModule;
+};

package/src/index.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * nodebb-admin-ai-connect — Pro package entry point.
+ *
+ * Mirrors the Ghost model: a standalone Pro plugin that registers its tool-set
+ * into the core registry, gated by edition. The core calls loadPro() during
+ * registry construction with a context describing the core internals + the
+ * site edition. If the edition does not grant Pro, this returns without
+ * registering anything — so Pro tools never appear in the manifest and cannot
+ * be executed.
+ */
+const createProModule = require('./ProModule');
+
+/**
+ * Bundle contract (BUNDLES-LICENSE-SPEC v1.0) — ctx.bundles wins over
+ * legacy ctx.edition. See ghost-members-ai-connect/src/index.js for the
+ * full contract description.
+ *
+ * @param {object} ctx
+ * @param {Function} ctx.ModuleRegistry Core ModuleRegistry class (for onInit).
+ * @param {Function} ctx.ModuleBase     Core ModuleBase class.
+ * @param {string}   [ctx.edition]      Legacy: 'free' | 'pro'.
+ * @param {string[]} [ctx.bundles]      New: array of granted bundle keys. Precedes edition.
+ * @returns {boolean} true if Pro tools were registered, false if gated out.
+ */
+function loadPro(ctx) {
+    const { ModuleRegistry, ModuleBase, edition, bundles } = ctx;
+
+    const resolvedBundles = Array.isArray(bundles)
+        ? bundles
+        : (edition === 'pro' ? ['*'] : []);
+
+    if (resolvedBundles.length === 0) {
+        return false;
+    }
+
+    if (!ModuleRegistry || !ModuleBase) {
+        throw new Error('nodebb-admin-ai-connect: incompatible core — missing ModuleRegistry/ModuleBase');
+    }
+
+    const ProModule = createProModule({ ModuleBase });
+
+    ModuleRegistry.onInit((registry) => {
+        registry.register(new ProModule());
+    });
+
+    return true;
+}
+
+module.exports = { loadPro };