@wumx-labs/noxaeapi-mcp 1.0.0 → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wumx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,78 +1,185 @@
 # @wumx-labs/noxaeapi-mcp
 
+[![npm version](https://img.shields.io/npm/v/@wumx-labs/noxaeapi-mcp?color=blue&style=flat-square)](https://www.npmjs.com/package/@wumx-labs/noxaeapi-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](LICENSE)
+[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-purple.svg?style=flat-square)](https://modelcontextprotocol.io)
+[![NoxAeApi Core](https://img.shields.io/badge/NoxAeApi-v1.5.1-emerald.svg?style=flat-square)](https://github.com/wumx-labs)
+
 Official **Model Context Protocol (MCP)** server for **NoxAeApi**.
 
-Allows any AI Agent (**Claude Code**, **Claude Desktop**, **Cursor**, **Windsurf**, **Cline**, **Antigravity**) to monitor and control your Minecraft servers and Velocity network hubs using natural language.
+Connect your Minecraft servers and Velocity proxy networks directly to any AI agent (**Claude Desktop**, **Claude Code**, **Cursor**, **Windsurf**, **Antigravity**, **Cline**, **Roo Code**) using natural language.
 
 ---
 
-## ⚡ Features
+## 🌟 Key Features
 
-* **Network Hub & Proxy Support (Velocity)**: Check all nodes status, TPS, broadcast to network, find players across proxy, transfer players between servers.
-* **Server Management**: Real-time TPS (1m, 5m, 15m), RAM/memory usage, execute console commands, manage whitelists, and view bans.
-* **Player Controls**: List online players with ping/health, player info & stats, kick, ban, unban, change gamemodes.
-* **LuckPerms Integration**: Inspect player groups & permissions, grant/revoke permissions with expiry, assign primary groups.
-* **Economy Management**: Check balances (Vault & multi-currency), pay, debit, and view top balance leaderboards.
-* **World Controls**: List worlds, change time (`day`, `night`, ticks), adjust weather (`clear`, `rain`, `thunder`), and inspect loaded entities.
-* **Plugin Insights**: Inspect installed plugins, enabled state, and versions.
-* **Zero Configuration**: Automatically reads your active server profile from `~/.noxaeapi-cli/config.json`.
+* **🌐 Velocity Network Hub & Standalone Servers**: Monitor network topology, broadcast announcements, find players across proxy hubs, and seamlessly route commands to backend nodes (e.g. `CSMP`, `LOBBY`).
+* **⚡ Server Health & TPS Diagnostics**: Real-time TPS metrics (1m, 5m, 15m), RAM/memory allocation, uptime, and console log inspection.
+* **👥 Player Management**: Track online players, inspect inventory/gamemode/coordinates, kick, ban, unban, and toggle whitelists.
+* **🛡️ LuckPerms Permissions**: Inspect user permissions, view inherited parent groups, grant/revoke permissions with expiry, and assign primary groups.
+* **💰 Multi-Currency & Vault Economy**: Native Vault balance queries, richest player rankings, custom currency leaderboards (Coins, Candy, Gems), deposits, and debits.
+* **🏆 Gameplay Leaderboards**: Query high-speed in-memory leaderboards (`player:kills`, `player:deaths`, `player:playtime`, `mcmmo:power`) with automatic noise filtration.
+* **🌍 Worlds & Weather**: List loaded worlds, adjust in-game time (`day`, `night`, ticks), set weather (`clear`, `rain`, `thunder`), and view entity counts.
+* **🔌 Plugin Ecosystem Integration**: Built-in support for CoreProtect, WorldGuard, EssentialsX, BetterTeams, DiscordSRV, PlayerPoints, MythicMobs, ShopGUI+, and TAB.
+* **🤖 Autonomous AI Sysadmin**: Embedded `minecraft_sysadmin` decision tree guides AI models to execute operations accurately and safely without hallucination.
 
 ---
 
-## 🚀 Setup & Usage
+## 🚀 Quick Start & Client Configuration
 
-### 1. Claude Code (CLI)
+You do **not** need to manually clone or compile this repository. Run it instantly via `npx`.
 
-Add directly using Claude CLI:
-```bash
-claude mcp add noxae -- node d:/Ainz-Project/NoxAeApi-ZZ/noxaeapi-mcp/dist/index.js
-```
-Or if installed globally:
-```bash
-claude mcp add noxae -- npx @wumx-labs/noxaeapi-mcp
-```
+### 1. Claude Desktop
 
-### 2. Claude Desktop
+Add this configuration to your `claude_desktop_config.json`:
 
-Add this to your `claude_desktop_config.json`:
+* **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+* **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
 
 ```json
 {
   "mcpServers": {
-    "noxae": {
-      "command": "node",
-      "args": ["d:/Ainz-Project/NoxAeApi-ZZ/noxaeapi-mcp/dist/index.js"]
+    "noxaeapi": {
+      "command": "npx",
+      "args": ["-y", "@wumx-labs/noxaeapi-mcp"]
     }
   }
 }
 ```
 
-### 3. Cursor / Windsurf
+> **Tip:** If you have multiple profiles saved via `noxaeapi-cli`, specify the profile using the `NOXAEAPI_PROFILE` environment variable:
+> ```json
+> {
+>   "mcpServers": {
+>     "noxaeapi": {
+>       "command": "npx",
+>       "args": ["-y", "@wumx-labs/noxaeapi-mcp"],
+>       "env": {
+>         "NOXAEAPI_PROFILE": "calm"
+>       }
+>     }
+>   }
+> }
+> ```
 
-Add a new MCP server in Settings:
-* **Name**: `noxae`
+---
+
+### 2. Cursor / Windsurf
+
+Go to **Settings** ➔ **MCP Servers** ➔ **Add New MCP Server**:
+
+* **Name**: `noxaeapi`
 * **Type**: `command`
-* **Command**: `node d:/Ainz-Project/NoxAeApi-ZZ/noxaeapi-mcp/dist/index.js`
+* **Command**: `npx -y @wumx-labs/noxaeapi-mcp`
+
+Or in `.cursor/mcp.json`:
+```json
+{
+  "mcpServers": {
+    "noxaeapi": {
+      "command": "npx",
+      "args": ["-y", "@wumx-labs/noxaeapi-mcp"]
+    }
+  }
+}
+```
 
 ---
 
-## ⚙️ Options & Flags
+### 3. Claude Code CLI
 
-By default, `noxaeapi-mcp` automatically connects to your current active profile in `noxaeapi-cli`. You can also override it:
+Add the MCP server directly using the Claude CLI:
 
 ```bash
-# Target a specific profile saved in noxaeapi-cli
-node dist/index.js --profile my-survival
+claude mcp add noxaeapi -- npx -y @wumx-labs/noxaeapi-mcp
+```
+
+---
 
-# Connect directly using URL and API Key
-node dist/index.js --url http://127.0.0.1:8080 --key my-secret-key
+### 4. Cline / Roo Code (VS Code Extension)
 
-# Connect to a Velocity Network Hub directly
-node dist/index.js --url http://127.0.0.1:19135 --key my-hub-key --hub
+Add this under the `mcpServers` object in your settings:
+
+```json
+{
+  "noxaeapi": {
+    "command": "npx",
+    "args": ["-y", "@wumx-labs/noxaeapi-mcp"],
+    "disabled": false,
+    "alwaysAllow": []
+  }
+}
+```
+
+---
+
+## ⚙️ Configuration & Environment Variables
+
+`noxaeapi-mcp` automatically detects your active profile from `~/.noxaeapi-cli/config.json`. You can also configure it directly via CLI arguments or environment variables:
+
+### Direct Connection (Standalone or Hub)
+```bash
+# Connect directly to a standalone Paper/Spigot server:
+npx @wumx-labs/noxaeapi-mcp --url http://127.0.0.1:8080 --key your-api-key
+
+# Connect directly to a Velocity Network Hub proxy:
+npx @wumx-labs/noxaeapi-mcp --url http://127.0.0.1:19135 --key your-hub-key --hub
 ```
 
-Or via environment variables:
-* `NOXAEAPI_PROFILE`
-* `NOXAEAPI_BASE_URL`
-* `NOXAEAPI_KEY`
-* `NOXAEAPI_HUB=true`
+### Supported Environment Variables
+| Variable | Description |
+| :--- | :--- |
+| `NOXAEAPI_PROFILE` | Select a specific profile name saved in `noxaeapi-cli` |
+| `NOXAEAPI_BASE_URL` | Base URL of your NoxAeApi server (e.g. `http://216.163.186.103:12005`) |
+| `NOXAEAPI_KEY` | API key configured in NoxAeApi `config.yml` |
+| `NOXAEAPI_HUB` | Set to `"true"` if connecting to a Velocity network hub |
+| `NOXAEAPI_HUB_BASE_URL` | Base URL for hub connection (auto-enables hub mode) |
+| `NOXAEAPI_HUB_KEY` | API Key for hub connection |
+
+---
+
+## 🛠️ Available MCP Tools
+
+### 🌐 Network (Velocity Hub)
+* `network_status_all` — Live status, TPS, and player count across all backend nodes.
+* `network_node_status` — Detailed metrics for a specific node ID.
+* `network_broadcast` — Broadcast announcement across all servers.
+* `network_find_player` — Locate which server node a player is currently on.
+* `network_send_player` — Transfer/teleport player between server nodes.
+
+### 🖥️ Server Diagnostics & Controls
+* `server_get_status` — TPS (1m, 5m, 15m), RAM/memory usage, uptime, version.
+* `server_dispatch_command` — Execute console commands safely (without leading `/`).
+* `server_get_logs` — Retrieve recent console logs and error traces.
+* `server_get_whitelist` / `server_whitelist_add` / `server_whitelist_remove` — Whitelist management.
+* `server_get_ops` / `server_op_player` / `server_deop_player` — Operator management.
+* `server_restart` — Restart the target server instance.
+
+### 👥 Player Subsystem
+* `players_list_online` — List active players with ping, health, and location.
+* `players_get_info` — Detailed player profile (gamemode, inventory, coordinates).
+* `players_kick` / `players_ban` / `players_unban` — Moderation controls.
+* `players_set_gamemode` — Switch player gamemodes (survival, creative, spectator, adventure).
+
+### 💰 Economy & Leaderboards
+* `economy_get_top` — Richest player leaderboard (Vault balances or custom currencies).
+* `economy_get_balance` — Query individual player balances.
+* `economy_list_currencies` — Discover custom currencies (Coins, Candy, Tokens).
+* `economy_get_currency_top` — Rankings for custom currencies.
+* `economy_pay` / `economy_debit` — Deposit or deduct currency.
+* `leaderboards_list` — Discover active gameplay leaderboards (noise-filtered).
+* `leaderboards_get_top` — Top rankings for kills, deaths, playtime, etc.
+
+### 🛡️ Permissions & Plugins
+* `luckperms_get_player_info` — View assigned permissions and group hierarchy.
+* `luckperms_add_player_permission` / `luckperms_remove_player_permission` — Modify player permissions.
+* `luckperms_set_player_primary_group` — Change player primary group.
+* `plugins_list` / `plugins_get_info` — Inspect installed plugins and versions.
+* `worlds_list` / `worlds_set_time` / `worlds_set_weather` — World environment controls.
+* `noxae_call_action` — Universal dynamic reflection caller for 16+ Minecraft plugin APIs.
+
+---
+
+## 📜 License
+
+MIT License © 2026 [wumx-labs](https://github.com/wumx-labs).

package/dist/index.js

@@ -1905,8 +1905,230 @@ function registerLeaderboardTools(server) {
   );
 }
 
-// src/tools/auto-register.ts
+// src/tools/rankforge.ts
 import { z as z10 } from "zod";
+async function resolveUuid5(client, playerOrUuid) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(playerOrUuid)) {
+    return playerOrUuid;
+  }
+  try {
+    const res = await client.players.resolve(playerOrUuid);
+    return res.uuid;
+  } catch {
+    return playerOrUuid;
+  }
+}
+function registerRankForgeTools(server) {
+  server.tool(
+    "rankforge_get_player_stats",
+    "Get full RankForge PvP stats for a player: points, current tier, next tier, kills, deaths, K/D ratio, and daily kills. Accepts UUID or player name.",
+    {
+      player: z10.string().describe("Player UUID or player name"),
+      nodeId: z10.string().optional().describe("Target server node ID when connected via Velocity hub")
+    },
+    async ({ player, nodeId }) => {
+      const session = getSession();
+      try {
+        const { client, effectiveNodeId } = await session.resolveTargetClient(nodeId);
+        const uuid = await resolveUuid5(client, player);
+        const stats = await client.rankforge.getPlayerStats(uuid);
+        const prefix = effectiveNodeId ? `[Target Node: @${effectiveNodeId}]
+` : "";
+        return {
+          content: [{ type: "text", text: prefix + JSON.stringify(stats, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Failed to get RankForge stats for '${player}': ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "rankforge_get_points",
+    "Get current RankForge points for a player. Accepts UUID or player name.",
+    {
+      player: z10.string().describe("Player UUID or player name"),
+      nodeId: z10.string().optional().describe("Target server node ID when connected via Velocity hub")
+    },
+    async ({ player, nodeId }) => {
+      const session = getSession();
+      try {
+        const { client, effectiveNodeId } = await session.resolveTargetClient(nodeId);
+        const uuid = await resolveUuid5(client, player);
+        const result = await client.rankforge.getPoints(uuid);
+        const prefix = effectiveNodeId ? `[Target Node: @${effectiveNodeId}]
+` : "";
+        return {
+          content: [{ type: "text", text: prefix + JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Failed to get points for '${player}': ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "rankforge_set_points",
+    "Set RankForge points for a player to an exact amount. This will override their current points. Accepts UUID or player name.",
+    {
+      player: z10.string().describe("Player UUID or player name"),
+      amount: z10.number().describe("Exact points value to set"),
+      nodeId: z10.string().optional().describe("Target server node ID when connected via Velocity hub")
+    },
+    async ({ player, amount, nodeId }) => {
+      const session = getSession();
+      try {
+        const { client, effectiveNodeId } = await session.resolveTargetClient(nodeId);
+        const uuid = await resolveUuid5(client, player);
+        const result = await client.rankforge.setPoints(uuid, amount);
+        const prefix = effectiveNodeId ? `[Target Node: @${effectiveNodeId}]
+` : "";
+        return {
+          content: [{ type: "text", text: prefix + JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Failed to set points for '${player}': ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "rankforge_add_points",
+    "Add RankForge points to a player. Accepts UUID or player name.",
+    {
+      player: z10.string().describe("Player UUID or player name"),
+      amount: z10.number().describe("Number of points to add"),
+      nodeId: z10.string().optional().describe("Target server node ID when connected via Velocity hub")
+    },
+    async ({ player, amount, nodeId }) => {
+      const session = getSession();
+      try {
+        const { client, effectiveNodeId } = await session.resolveTargetClient(nodeId);
+        const uuid = await resolveUuid5(client, player);
+        const result = await client.rankforge.addPoints(uuid, amount);
+        const prefix = effectiveNodeId ? `[Target Node: @${effectiveNodeId}]
+` : "";
+        return {
+          content: [{ type: "text", text: prefix + JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Failed to add points for '${player}': ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "rankforge_remove_points",
+    "Remove (deduct) RankForge points from a player. Accepts UUID or player name.",
+    {
+      player: z10.string().describe("Player UUID or player name"),
+      amount: z10.number().describe("Number of points to remove"),
+      nodeId: z10.string().optional().describe("Target server node ID when connected via Velocity hub")
+    },
+    async ({ player, amount, nodeId }) => {
+      const session = getSession();
+      try {
+        const { client, effectiveNodeId } = await session.resolveTargetClient(nodeId);
+        const uuid = await resolveUuid5(client, player);
+        const result = await client.rankforge.removePoints(uuid, amount);
+        const prefix = effectiveNodeId ? `[Target Node: @${effectiveNodeId}]
+` : "";
+        return {
+          content: [{ type: "text", text: prefix + JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Failed to remove points for '${player}': ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "rankforge_list_tiers",
+    "List all registered PvP tiers from RankForge (name, minPoints, maxPoints, etc.).",
+    {
+      nodeId: z10.string().optional().describe("Target server node ID when connected via Velocity hub")
+    },
+    async ({ nodeId }) => {
+      const session = getSession();
+      try {
+        const { client, effectiveNodeId } = await session.resolveTargetClient(nodeId);
+        const tiers = await client.rankforge.getTiers();
+        const prefix = effectiveNodeId ? `[Target Node: @${effectiveNodeId}]
+` : "";
+        return {
+          content: [{ type: "text", text: prefix + JSON.stringify(tiers, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Failed to list RankForge tiers: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "rankforge_get_top",
+    "Get the top players ranked by RankForge points (PvP leaderboard). Returns rank, UUID, name, points, and tier.",
+    {
+      limit: z10.number().optional().describe("Number of top players to return (default 10, max 100)"),
+      nodeId: z10.string().optional().describe("Target server node ID when connected via Velocity hub")
+    },
+    async ({ limit = 10, nodeId }) => {
+      const session = getSession();
+      try {
+        const { client, effectiveNodeId } = await session.resolveTargetClient(nodeId);
+        const top = await client.rankforge.getTop(limit);
+        const prefix = effectiveNodeId ? `[Target Node: @${effectiveNodeId}]
+` : "";
+        return {
+          content: [{ type: "text", text: prefix + JSON.stringify(top, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Failed to get RankForge top: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "rankforge_save",
+    "Trigger an async save of all RankForge player data to disk/database.",
+    {
+      nodeId: z10.string().optional().describe("Target server node ID when connected via Velocity hub")
+    },
+    async ({ nodeId }) => {
+      const session = getSession();
+      try {
+        const { client, effectiveNodeId } = await session.resolveTargetClient(nodeId);
+        const result = await client.rankforge.save();
+        const prefix = effectiveNodeId ? `[Target Node: @${effectiveNodeId}]
+` : "";
+        return {
+          content: [{ type: "text", text: prefix + JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Failed to trigger RankForge save: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/auto-register.ts
+import { z as z11 } from "zod";
 var SKIP_MODULES = /* @__PURE__ */ new Set(["http", "connect"]);
 function registerAllSdkModules(server, registeredNames) {
   const session = getSession();
@@ -1934,8 +2156,8 @@ function registerAllSdkModules(server, registeredNames) {
         toolName,
         `NoxAeApi ${modName}.${action}() action. Supports standalone server or Velocity node targeting via nodeId.`,
         {
-          args: z10.array(z10.unknown()).optional().describe(`Arguments array for ${modName}.${action}()`),
-          nodeId: z10.string().optional().describe("Target server node ID (e.g. 'survival', 'lobby') when connected via Velocity hub")
+          args: z11.array(z11.unknown()).optional().describe(`Arguments array for ${modName}.${action}()`),
+          nodeId: z11.string().optional().describe("Target server node ID (e.g. 'survival', 'lobby') when connected via Velocity hub")
         },
         async ({ args = [], nodeId }) => {
           const currentSession = getSession();
@@ -2001,8 +2223,8 @@ async function main() {
     );
   }
   const server = new McpServer({
-    name: "noxaeapi-mcp",
-    version: "1.0.0"
+    name: true ? "@wumx-labs/noxaeapi-mcp" : "noxaeapi-mcp",
+    version: true ? "1.0.2" : "1.0.1"
   });
   const registeredNames = /* @__PURE__ */ new Set();
   const track = (names) => names.forEach((n) => registeredNames.add(n));
@@ -2062,6 +2284,17 @@ async function main() {
     "leaderboards_list",
     "leaderboards_get_top"
   ]);
+  registerRankForgeTools(server);
+  track([
+    "rankforge_get_player_stats",
+    "rankforge_get_points",
+    "rankforge_set_points",
+    "rankforge_add_points",
+    "rankforge_remove_points",
+    "rankforge_list_tiers",
+    "rankforge_get_top",
+    "rankforge_save"
+  ]);
   registerWorldTools(server);
   track([
     "worlds_list",
@@ -2106,6 +2339,8 @@ Follow these operational guidelines to make accurate, reliable decisions:
 3. LEADERBOARD DECISION TREE:
    - For gameplay rankings (kills, deaths, playtime, mcmmo, auraskills): use 'leaderboards_get_top' with IDs like 'player:kills', 'player:deaths', 'player:playtime'.
    - Use 'leaderboards_list' to discover valid game stats (it automatically filters internal noise).
+   - For RankForge PvP tier/points rankings: use 'rankforge_get_top' or the generic 'leaderboards_get_top' with id 'rankforge:points' or 'rankforge:kills'.
+   - To inspect or modify a specific player's RankForge points: use 'rankforge_get_player_stats', 'rankforge_set_points', 'rankforge_add_points', 'rankforge_remove_points'.
 
 4. PERFORMANCE & DIAGNOSTICS:
    - For lag or TPS inquiries: call 'server_get_status'. TPS: 20.0 is perfect, <18.0 is lagging.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wumx-labs/noxaeapi-mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Official Model Context Protocol (MCP) server for NoxAeApi - control Minecraft servers & Velocity networks from any AI agent",
   "author": "wumx",
   "license": "MIT",
@@ -13,7 +13,9 @@
   },
   "main": "dist/index.js",
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup",