koishi-plugin-minecraft-search 1.3.8 → 2.0.0

package/lib/index.d.ts

@@ -2,19 +2,33 @@ import { Context, Schema } from 'koishi';
 export declare const name = "minecraft-search";
 export interface ServerConfig {
     id: number;
+    userId: string;
+    groupId: string;
     name: string;
     host: string;
+    port: number;
+    serverType: 'java' | 'bedrock';
+    timeout: number;
     minekuaiInstanceId?: string;
-    timeout?: number;
-    serverType?: 'java' | 'bedrock';
 }
-export interface Config {
-    servers: ServerConfig[];
-    minekuaiSettings: MinekuaiSettings;
-}
-export interface MinekuaiSettings {
-    apiUrl: string;
+export interface ApiKeyConfig {
+    id: number;
+    userId: string;
+    groupId: string;
     apiKey: string;
 }
+export interface Config {
+    minekuaiApiUrl: string;
+    showIpInDetail: boolean;
+}
 export declare const Config: Schema<Config>;
+export declare const inject: {
+    required: string[];
+};
+declare module 'koishi' {
+    interface Tables {
+        minecraft_server: ServerConfig;
+        minecraft_api_key: ApiKeyConfig;
+    }
+}
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -32,6 +32,7 @@ var src_exports = {};
 __export(src_exports, {
   Config: () => Config,
   apply: () => apply,
+  inject: () => inject,
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
@@ -43,23 +44,39 @@ import("mc-server-util").then((m) => {
 var name = "minecraft-search";
 var Config = import_koishi.Schema.intersect([
   import_koishi.Schema.object({
-    servers: import_koishi.Schema.array(import_koishi.Schema.object({
-      id: import_koishi.Schema.number().required().description("服务器ID"),
-      name: import_koishi.Schema.string().required().description("服务器名称"),
-      host: import_koishi.Schema.string().required().description("服务器地址"),
-      serverType: import_koishi.Schema.union(["java", "bedrock"]).default("java").description("服务器类型"),
-      timeout: import_koishi.Schema.number().default(5).description("查询超时时间(秒)"),
-      minekuaiInstanceId: import_koishi.Schema.string().description("麦块实例ID (可选)")
-    })).description("服务器列表").role("table").required()
-  }).description("服务器配置"),
+    minekuaiApiUrl: import_koishi.Schema.string().description("麦块API地址").default("https://minekuai.com/api/client")
+  }).description("麦块联机配置"),
   import_koishi.Schema.object({
-    minekuaiSettings: import_koishi.Schema.object({
-      apiUrl: import_koishi.Schema.string().description("麦块API地址").default("https://minekuai.com/api/client"),
-      apiKey: import_koishi.Schema.string().description("麦块API密钥")
-    })
-  }).description("麦块联机配置(可选)")
+    showIpInDetail: import_koishi.Schema.boolean().default(true).description("在查询详细状态时显示服务器IP地址")
+  }).description("显示配置")
 ]);
+var inject = {
+  required: ["database"]
+};
 function apply(ctx, config) {
+  ctx.model.extend("minecraft_server", {
+    id: "unsigned",
+    userId: "string",
+    groupId: "string",
+    name: "string",
+    host: "string",
+    port: "integer",
+    serverType: "string",
+    timeout: "float",
+    minekuaiInstanceId: "string"
+  }, {
+    autoInc: true,
+    primary: "id"
+  });
+  ctx.model.extend("minecraft_api_key", {
+    id: "unsigned",
+    userId: "string",
+    groupId: "string",
+    apiKey: "string"
+  }, {
+    autoInc: true,
+    primary: "id"
+  });
   function parseServerAddress(hostString, defaultPort) {
     if (hostString.includes(":")) {
       const [host, portStr] = hostString.split(":");
@@ -75,14 +92,16 @@ function apply(ctx, config) {
     };
   }
   __name(parseServerAddress, "parseServerAddress");
-  async function minekuaiApiRequest(instanceId, operation, maxRetries = 3) {
-    const { apiUrl, apiKey } = config.minekuaiSettings;
-    if (!apiKey) throw new Error("麦块API密钥未配置");
-    if (!apiUrl) throw new Error("麦块API地址未配置");
-    const baseUrl = apiUrl.replace(/\/+$/, "");
+  async function minekuaiApiRequest(instanceId, operation, groupId, maxRetries = 3) {
+    const apiKeys = await ctx.database.get("minecraft_api_key", { groupId });
+    if (!apiKeys || apiKeys.length === 0) {
+      throw new Error("本群未配置麦块API密钥，请先使用 绑定密钥 指令");
+    }
+    const apiKeyRecord = apiKeys[0];
+    const baseUrl = config.minekuaiApiUrl.replace(/\/+$/, "");
     const url = `${baseUrl}/servers/${instanceId}/power`;
     const headers = {
-      "Authorization": `Bearer ${apiKey}`,
+      "Authorization": `Bearer ${apiKeyRecord.apiKey}`,
       "Content-Type": "application/json",
       "Accept": "application/json"
     };
@@ -109,8 +128,7 @@ function apply(ctx, config) {
       if (!getMinecraftServerStatus) {
         throw new Error("mc-server-util 模块未正确加载");
       }
-      const defaultPort = server.serverType === "bedrock" ? 19132 : 25565;
-      const { host, port } = parseServerAddress(server.host, defaultPort);
+      const { host, port } = parseServerAddress(server.host, server.port || 25565);
       const timeout = (server.timeout || 5) * 1e3;
       let result;
       if (server.serverType === "bedrock") {
@@ -142,18 +160,28 @@ function apply(ctx, config) {
     }
   }
   __name(queryServerStatus, "queryServerStatus");
+  function getServerName(server) {
+    return server.name || "Minecraft 服务器";
+  }
+  __name(getServerName, "getServerName");
   function formatShortStatus(result, server) {
+    const displayName = getServerName(server);
     if (!result.online) {
-      return `🔴 ${server.name} - 离线`;
+      return `🔴 ${displayName} - 离线`;
     }
     const players = result.players ? `${result.players.online}/${result.players.max}` : "N/A";
     const version = result.version ? result.version.name : "N/A";
-    return `🟢 ${server.name} - 在线 | 玩家: ${players} | 版本: ${version}`;
+    return `🟢 ${displayName} - 在线 | 玩家: ${players} | 版本: ${version}`;
   }
   __name(formatShortStatus, "formatShortStatus");
-  function formatDetailedStatus(result, server) {
+  function formatDetailedStatus(result, server, showIp) {
+    const displayName = getServerName(server);
     if (!result.online) {
-      return `🔴 服务器 ${server.name} (${server.host}) 当前离线`;
+      if (showIp) {
+        return `🔴 ${displayName} (${server.host}) 当前离线`;
+      } else {
+        return `🔴 ${displayName} 当前离线`;
+      }
     }
     let motdText = "暂无描述";
     if (result.description) {
@@ -172,12 +200,13 @@ function apply(ctx, config) {
       descriptionStr = descriptionStr.replace(/§[0-9a-fk-or]/gi, "");
       motdText = descriptionStr.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
     }
-    const defaultPort = server.serverType === "bedrock" ? 19132 : 25565;
-    const { host, port } = parseServerAddress(server.host, defaultPort);
-    let message = `🟢 ${server.name} 状态信息
+    let message = `🟢 ${displayName} 状态信息
 `;
-    message += `📡 地址: ${host}:${port}
+    if (showIp) {
+      const { host, port } = parseServerAddress(server.host, server.port || 25565);
+      message += `📡 地址: ${host}:${port}
 `;
+    }
     message += `🎮 类型: ${server.serverType || "Java"}
 `;
     if (result.version) {
@@ -199,12 +228,13 @@ function apply(ctx, config) {
     return message;
   }
   __name(formatDetailedStatus, "formatDetailedStatus");
-  ctx.command("mc/查服 [id:number]", "查询Minecraft服务器状态").action(async ({ session }, id) => {
-    if (id === void 0) {
-      if (config.servers.length === 0) {
-        return "❌ 未配置任何服务器";
+  ctx.command("mc/查服 [target:text]", "查询Minecraft服务器状态").action(async ({ session }, target) => {
+    const servers = await ctx.database.get("minecraft_server", {});
+    if (target === void 0) {
+      if (servers.length === 0) {
+        return "❌ 本群未绑定任何服务器，请先使用 绑定 指令";
       }
-      const queries = config.servers.map((server2) => queryServerStatus(server2));
+      const queries = servers.map((server) => queryServerStatus(server));
       const results = await Promise.all(queries);
       const onlineCount = results.filter((r) => r.success && r.data && r.data.online).length;
       let message = `📊 服务器状态汇总 (当前在线${onlineCount}/${results.length}台)
@@ -217,77 +247,203 @@ function apply(ctx, config) {
           message += `[ID:${serverId}] ${originalStatus}
 `;
         } else {
-          message += `[ID:${serverId}] 🔴 ${result2.server.name} - 离线 | 原因：${result2.error}
+          message += `[ID:${serverId}] 🔴 ${getServerName(result2.server)} - 离线 | 原因：${result2.error}
 `;
         }
       });
       message += `
-💡 输入"查服+服务器ID"即可查询详细状态，例如：查服 ${config.servers[0]?.id || 1}`;
+💡 输入"查服+服务器ID"即可查询详细状态，例如：查服 ${servers[0]?.id || 1}`;
+      message += `
+💡 也可以直接输入IP地址查询`;
       return message;
     }
-    const server = config.servers.find((s) => s.id === id);
+    const id = parseInt(target);
+    if (!isNaN(id)) {
+      const server = servers.find((s) => s.id === id);
+      if (server) {
+        const result2 = await queryServerStatus(server);
+        if (!result2.success) {
+          return `🔴 ${getServerName(server)} - 离线 | 原因：${result2.error}`;
+        }
+        return formatDetailedStatus(result2.data, server, config.showIpInDetail);
+      }
+    }
+    const host = String(target);
+    const defaultPort = 25565;
+    const { host: parsedHost, port: parsedPort } = parseServerAddress(host, defaultPort);
+    const tempServer = {
+      id: 0,
+      userId: session.userId,
+      groupId: session.guildId || "",
+      name: parsedHost,
+      host: parsedHost,
+      port: parsedPort,
+      serverType: "java",
+      timeout: 5
+    };
+    const result = await queryServerStatus(tempServer);
+    if (!result.success) {
+      return `🔴 服务器 ${parsedHost}:${parsedPort} - 离线 | 原因：${result.error}`;
+    }
+    return formatDetailedStatus(result.data, tempServer, config.showIpInDetail);
+  });
+  ctx.guild().command("mc/绑定 <host:string>", "绑定Minecraft服务器").option("name", "-n <name:string>", { fallback: "" }).option("timeout", "-t <timeout:number>", { fallback: 5 }).action(async ({ session, options }, host) => {
+    if (!host) {
+      return "请提供服务器地址，例如：绑定+IP地址（不带端口时默认为25565）";
+    }
+    const groupId = session.guildId;
+    const userId = session.userId;
+    const defaultPort = 25565;
+    const { host: parsedHost, port: parsedPort } = parseServerAddress(host, defaultPort);
+    const existingServers = await ctx.database.get("minecraft_server", {
+      groupId,
+      host: parsedHost,
+      port: parsedPort
+    });
+    if (existingServers.length > 0) {
+      return `该服务器 (${parsedHost}:${parsedPort}) 已在本群绑定，服务器ID为: ${existingServers[0].id}`;
+    }
+    const createData = {
+      userId,
+      groupId,
+      host: parsedHost,
+      port: parsedPort,
+      serverType: "java",
+      timeout: options.timeout,
+      minekuaiInstanceId: ""
+    };
+    if (options.name) {
+      createData.name = options.name;
+    }
+    await ctx.database.create("minecraft_server", createData);
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    const newServer = servers[servers.length - 1];
+    return `✅ 服务器绑定成功！
+服务器ID: ${newServer.id}
+名称: ${newServer.name || "Minecraft 服务器"}
+地址: ${parsedHost}:${parsedPort}`;
+  });
+  ctx.guild().command("mc/绑定密钥 <apiKey:string>", "绑定麦块API密钥").action(async ({ session }, apiKey) => {
+    if (!apiKey) {
+      return "请提供API密钥";
+    }
+    const groupId = session.guildId;
+    const userId = session.userId;
+    const existingKeys = await ctx.database.get("minecraft_api_key", { groupId });
+    if (existingKeys.length > 0) {
+      await ctx.database.set("minecraft_api_key", { groupId }, { apiKey });
+      return "✅ API密钥更新成功！";
+    }
+    await ctx.database.create("minecraft_api_key", {
+      userId,
+      groupId,
+      apiKey
+    });
+    return "✅ API密钥绑定成功！";
+  });
+  ctx.guild().command("mc/解绑 <id:number>", "解绑Minecraft服务器").action(async ({ session }, id) => {
+    if (!id) {
+      return "请提供服务器ID，例如：解绑 1";
+    }
+    const groupId = session.guildId;
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    const server = servers.find((s) => s.id === id);
     if (!server) {
       return `❌ 未找到ID为 ${id} 的服务器`;
     }
-    const result = await queryServerStatus(server);
-    if (!result.success) {
-      return `🔴 服务器 ${server.name} - 离线 | 原因：${result.error}`;
+    await ctx.database.remove("minecraft_server", { id });
+    return `✅ 服务器 ${server.name} 已解绑`;
+  });
+  ctx.guild().command("mc/修改 <id:number>", "修改Minecraft服务器信息").option("name", "-n <name:string>", { fallback: "" }).option("timeout", "-t <timeout:number>", { fallback: 0 }).action(async ({ session, options }, id) => {
+    if (!id) {
+      return "请提供服务器ID，例如：修改 1";
+    }
+    const groupId = session.guildId;
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    const server = servers.find((s) => s.id === id);
+    if (!server) {
+      return `❌ 未找到ID为 ${id} 的服务器`;
     }
-    return formatDetailedStatus(result.data, server);
+    const updates = {};
+    if (options.name) {
+      updates.name = options.name;
+    }
+    if (options.timeout > 0) {
+      updates.timeout = options.timeout;
+    }
+    if (Object.keys(updates).length === 0) {
+      return "请提供要修改的参数，使用 -n 指定新名称，-t 指定新超时时间";
+    }
+    await ctx.database.set("minecraft_server", { id }, updates);
+    const parts = [];
+    if (updates.name) parts.push(`名称: ${updates.name}`);
+    if (updates.timeout) parts.push(`超时: ${updates.timeout}秒`);
+    return `✅ 服务器信息已更新！
+${parts.join("\n")}`;
   });
-  ctx.command("mc/开服 <id:number>", "启动麦块服务器").action(async ({ session }, id) => {
+  ctx.guild().command("mc/开服 <id:number>", "启动麦块服务器").action(async ({ session }, id) => {
     if (!id) return "请提供服务器ID，例如：开服 1";
-    const server = config.servers.find((s) => s.id === id);
-    if (!server) return `未找到ID为 ${id} 的服务器`;
+    const groupId = session.guildId;
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    const server = servers.find((s) => s.id === id);
+    if (!server) return `❌ 未找到ID为 ${id} 的服务器，请确保操作的是本群绑定的服务器`;
     if (!server.minekuaiInstanceId) return `服务器 ${server.name} 未配置麦块实例ID`;
     try {
-      await minekuaiApiRequest(server.minekuaiInstanceId, "start", 3);
+      await minekuaiApiRequest(server.minekuaiInstanceId, "start", groupId, 3);
       return `✅ 已发送启动指令到服务器 ${server.name} (ID: ${id})`;
     } catch (error) {
       return `❌ 启动服务器 ${server.name} 失败: ${error.message}`;
     }
   });
-  ctx.command("mc/重启 <id:number>", "重启麦块服务器").action(async ({ session }, id) => {
+  ctx.guild().command("mc/重启 <id:number>", "重启麦块服务器").action(async ({ session }, id) => {
     if (!id) return "请提供服务器ID，例如：重启 1";
-    const server = config.servers.find((s) => s.id === id);
-    if (!server) return `未找到ID为 ${id} 的服务器`;
+    const groupId = session.guildId;
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    const server = servers.find((s) => s.id === id);
+    if (!server) return `❌ 未找到ID为 ${id} 的服务器，请确保操作的是本群绑定的服务器`;
     if (!server.minekuaiInstanceId) return `服务器 ${server.name} 未配置麦块实例ID`;
     try {
-      await minekuaiApiRequest(server.minekuaiInstanceId, "restart", 3);
+      await minekuaiApiRequest(server.minekuaiInstanceId, "restart", groupId, 3);
       return `✅ 服务器 ${server.name} 重启指令已发送完成，请稍后检查服务器状态`;
     } catch (error) {
       return `❌ 重启服务器 ${server.name} 失败: ${error.message}`;
     }
   });
-  ctx.command("mc/强制重启 <id:number>", "强制重启麦块服务器").action(async ({ session }, id) => {
+  ctx.guild().command("mc/强制重启 <id:number>", "强制重启麦块服务器").action(async ({ session }, id) => {
     if (!id) return "请提供服务器ID，例如：强制重启 1";
-    const server = config.servers.find((s) => s.id === id);
-    if (!server) return `未找到ID为 ${id} 的服务器`;
+    const groupId = session.guildId;
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    const server = servers.find((s) => s.id === id);
+    if (!server) return `❌ 未找到ID为 ${id} 的服务器，请确保操作的是本群绑定的服务器`;
     if (!server.minekuaiInstanceId) return `服务器 ${server.name} 未配置麦块实例ID`;
     try {
-      await minekuaiApiRequest(server.minekuaiInstanceId, "stop", 3);
+      await minekuaiApiRequest(server.minekuaiInstanceId, "stop", groupId, 3);
       await new Promise((resolve) => setTimeout(resolve, 1e3));
-      await minekuaiApiRequest(server.minekuaiInstanceId, "kill", 3);
+      await minekuaiApiRequest(server.minekuaiInstanceId, "kill", groupId, 3);
       await new Promise((resolve) => setTimeout(resolve, 3e3));
-      await minekuaiApiRequest(server.minekuaiInstanceId, "start", 3);
+      await minekuaiApiRequest(server.minekuaiInstanceId, "start", groupId, 3);
       return `✅ 服务器 ${server.name} 强制重启指令已发送完成，请稍后检查服务器状态`;
     } catch (error) {
       return `❌ 强制重启服务器 ${server.name} 失败: ${error.message}`;
     }
   });
-  ctx.command("mc/资源 <id:number>", "查看麦块服务器资源使用情况").action(async ({ session }, id) => {
+  ctx.guild().command("mc/资源 <id:number>", "查看麦块服务器资源使用情况").action(async ({ session }, id) => {
     if (!id) return "请提供服务器ID，例如：资源 1";
-    const server = config.servers.find((s) => s.id === id);
-    if (!server) return `未找到ID为 ${id} 的服务器`;
+    const groupId = session.guildId;
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    const server = servers.find((s) => s.id === id);
+    if (!server) return `❌ 未找到ID为 ${id} 的服务器，请确保操作的是本群绑定的服务器`;
     if (!server.minekuaiInstanceId) return `服务器 ${server.name} 未配置麦块实例ID`;
     try {
-      const { apiUrl, apiKey } = config.minekuaiSettings;
-      if (!apiKey) throw new Error("麦块API密钥未配置");
-      if (!apiUrl) throw new Error("麦块API地址未配置");
-      const baseUrl = apiUrl.replace(/\/+$/, "");
+      const apiKeys = await ctx.database.get("minecraft_api_key", { groupId });
+      if (!apiKeys || apiKeys.length === 0) {
+        throw new Error("本群未配置麦块API密钥，请先使用 绑定密钥 指令");
+      }
+      const apiKeyRecord = apiKeys[0];
+      const baseUrl = config.minekuaiApiUrl.replace(/\/+$/, "");
       const url = `${baseUrl}/servers/${server.minekuaiInstanceId}/resources`;
       const headers = {
-        "Authorization": `Bearer ${apiKey}`,
+        "Authorization": `Bearer ${apiKeyRecord.apiKey}`,
         "Content-Type": "application/json",
         "Accept": "application/json"
       };
@@ -330,11 +486,49 @@ function apply(ctx, config) {
       return `❌ 查询服务器 ${server.name} 资源使用情况失败: ${error.message}`;
     }
   });
+  ctx.guild().command("mc/服务器列表", "查看已绑定的服务器列表").action(async ({ session }) => {
+    const groupId = session.guildId;
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    if (servers.length === 0) {
+      return "本群暂未绑定任何服务器";
+    }
+    let message = `📋 本群已绑定 ${servers.length} 台服务器：
+
+`;
+    servers.forEach((server) => {
+      message += `[ID:${server.id}] ${server.name}
+`;
+      message += `  地址: ${server.host}:${server.port}
+`;
+      message += `  类型: ${server.serverType} | 超时: ${server.timeout}秒
+`;
+      if (server.minekuaiInstanceId) {
+        message += `  麦块实例: ${server.minekuaiInstanceId}
+`;
+      }
+      message += "\n";
+    });
+    return message.trim();
+  });
+  ctx.guild().command("mc/设置实例 <id:number> <instanceId:string>", "设置服务器的麦块实例ID").action(async ({ session }, id, instanceId) => {
+    if (!id || !instanceId) {
+      return "请提供服务器ID和实例ID，例如：设置实例 1 abc123";
+    }
+    const groupId = session.guildId;
+    const servers = await ctx.database.get("minecraft_server", { groupId });
+    const server = servers.find((s) => s.id === id);
+    if (!server) {
+      return `❌ 未找到ID为 ${id} 的服务器`;
+    }
+    await ctx.database.set("minecraft_server", { id }, { minekuaiInstanceId: instanceId });
+    return `✅ 服务器 ${server.name} 的麦块实例ID已设置为: ${instanceId}`;
+  });
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,
   apply,
+  inject,
   name
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-minecraft-search",
   "description": "使用API查询基础的mc服务器信息",
-  "version": "1.3.8",
+  "version": "2.0.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -16,6 +16,7 @@
 ### ⚡ 服务器电源控制
 - 支持通过麦块联机 API 启动服务器
 - 支持通过麦块联机 API 重启服务器
+- 支持通过麦块联机 API 强制重启服务器
 - 自动重试机制，提高操作成功率
 
 ### 📊 服务器资源查询
@@ -25,6 +26,18 @@
 - 显示服务器运行时间
 - 显示服务器状态和暂停状态
 
+### 🗄️ 数据库存储
+- 使用数据库存储服务器配置，支持多群组管理
+- 支持按群组绑定服务器，每个群组只能管理自己的服务器
+- 支持 API 密钥按群组存储
+
+### 🔧 服务器管理
+- 支持绑定服务器（自动解析地址和端口）
+- 支持解绑服务器
+- 支持修改服务器信息（名称、超时时间）
+- 支持设置麦块实例ID
+- 支持查看服务器列表
+
 ## 安装
 
 1. 安装插件：
@@ -36,34 +49,30 @@ npm install koishi-plugin-minecraft-search
 
 ## 配置说明
 
-### 服务器配置
-```typescript
-servers: [
-  {
-    id: 1,                    // 服务器ID（数字）
-    name: "主服务器",          // 服务器名称
-    host: "play.example.com:25565", // 服务器地址（支持带端口）
-    serverType: "java",       // 服务器类型：java/bedrock
-    timeout: 5.0,            // 查询超时时间（秒）
-    minekuaiInstanceId: "xxx" // 麦块实例ID（可选，用于电源控制）
-  }
-]
-```
-
-### 麦块联机配置（可选）
+### 基础配置
 ```typescript
-minekuaiSettings: {
-  apiUrl: "https://minekuai.com/api/client", // 麦块API地址
-  apiKey: "your-api-key"                     // 麦块API密钥
+{
+  "minekuaiApiUrl": "https://minekuai.com/api/client", // 麦块API地址
+  "showIpInDetail": true // 是否在详细状态中显示IP地址
 }
 ```
 
 ## 使用指令
 
+### 服务器管理
+```
+mc/绑定 <host> [-n <name>] [-t <timeout>]  # 绑定服务器，支持指定名称和超时时间
+mc/解绑 <id>                               # 解绑服务器
+mc/修改 <id> [-n <name>] [-t <timeout>]    # 修改服务器信息
+mc/服务器列表                              # 查看已绑定的服务器列表
+mc/设置实例 <id> <instanceId>              # 设置服务器的麦块实例ID
+mc/绑定API密钥 <apiKey>                    # 绑定麦块API密钥
+```
+
 ### 查询服务器状态
 ```
-查服        # 查询全部服务器状态（简短信息）
-查服 1      # 查询ID为1的服务器的详细信息
+mc/查服        # 查询全部服务器状态（简短信息）
+mc/查服 1      # 查询ID为1的服务器的详细信息
 ```
 
 **输出示例：**
@@ -79,14 +88,14 @@ minekuaiSettings: {
 
 ### 服务器电源控制
 ```
-开服 1      # 启动ID为1的麦块服务器
-重启 1      # 重启ID为1的麦块服务器
-强制重启 1  # 强制重启ID为1的麦块服务器
+mc/开服 1      # 启动ID为1的麦块服务器
+mc/重启 1      # 重启ID为1的麦块服务器
+mc/强制重启 1  # 强制重启ID为1的麦块服务器
 ```
 
 ### 服务器资源查询
 ```
-资源 1      # 查看ID为1的麦块服务器资源使用情况
+mc/资源 1      # 查看ID为1的麦块服务器资源使用情况
 ```
 
 **输出示例：**
@@ -103,15 +112,35 @@ minekuaiSettings: {
 ⏰ 查询时间: 2026-03-13 12:00:00
 ```
 
-## 配置选项说明
-
-### 服务器类型 (serverType)
-- `java`：Java 版服务器（默认）
-- `bedrock`：基岩版服务器（暂不支持）
-
-### 超时时间 (timeout)
-- 默认值：5.0 秒
-- 设置查询超时时间，避免长时间等待
+## 指令说明
+
+### 绑定服务器
+- **命令**：`mc/绑定 <host> [-n <name>] [-t <timeout>]`
+- **参数**：
+  - `<host>`：服务器地址，支持带端口格式（如：`play.example.com:25565`）
+  - `-n <name>`：服务器名称（可选，默认使用地址作为名称）
+  - `-t <timeout>`：查询超时时间（可选，默认5秒）
+- **示例**：
+  - `mc/绑定 s3.ungc.com.cn` - 绑定默认端口的服务器
+  - `mc/绑定 s3.ungc.com.cn:37095 -n 测试服 -t 10` - 绑定指定端口、名称和超时的服务器
+
+### 绑定API密钥
+- **命令**：`mc/绑定API密钥 <apiKey>`
+- **参数**：
+  - `<apiKey>`：麦块联机平台的API密钥
+- **说明**：每个群组只需绑定一次，后续会自动使用该密钥
+
+### 服务器管理指令
+- **`mc/解绑 <id>`**：解绑指定ID的服务器
+- **`mc/修改 <id> [-n <name>] [-t <timeout>]`**：修改服务器名称或超时时间
+- **`mc/设置实例 <id> <instanceId>`**：为服务器设置麦块实例ID，用于电源控制
+- **`mc/服务器列表`**：查看当前群组已绑定的所有服务器
+
+### 服务器控制指令
+- **`mc/开服 <id>`**：启动指定服务器
+- **`mc/重启 <id>`**：重启指定服务器
+- **`mc/强制重启 <id>`**：强制停止并重启指定服务器
+- **`mc/资源 <id>`**：查询服务器资源使用情况
 
 ## 技术特性
 
@@ -120,19 +149,22 @@ minekuaiSettings: {
 - 📱 **友好输出格式**：使用 emoji 和清晰排版，信息易读
 - ⚡ **高性能查询**：支持并行查询多个服务器
 - 🛡️ **错误处理**：完善的错误处理和用户提示
+- 🗄️ **数据库存储**：使用数据库存储服务器配置，支持多群组管理
+- 🔒 **权限控制**：每个群组只能管理自己绑定的服务器
 
 ## 依赖说明
 
 - 使用 https://www.npmjs.com/package/mc-server-util 库进行服务器状态查询
 - 支持麦块联机平台的 API 集成
-- 基于 Koishi 框架开发
+- 基于 Koishi 框架开发，依赖数据库插件
 
 ## 注意事项
 
 1. 麦块联机功能需要配置正确的 API 地址和密钥
-2. Query 查询可能会增加查询时间，建议按需开启
-3. 服务器地址支持带端口格式（如：`play.example.com:25565`）
-4. 插件会自动处理 MOTD 中的换行符，确保输出整洁
+2. 服务器地址支持带端口格式（如：`play.example.com:25565`）
+3. 插件会自动处理 MOTD 中的换行符，确保输出整洁
+4. 所有服务器操作指令均限制为群组指令，只能操作本群绑定的服务器
+5. API 密钥按群组存储，每个群组需要单独绑定
 
 ## 故障排除
 
@@ -141,11 +173,20 @@ minekuaiSettings: {
 - 网络连接是否正常
 - 防火墙是否阻止了查询请求
 - 麦块 API 配置是否正确
+- 服务器是否为本群绑定的服务器
 
 ## 更新日志
 <details>
 <summary>点我查看更新日志详情</summary>
 
+### v2.0.0
+- 全新数据库存储架构，支持多群组管理
+- 新增服务器绑定、解绑、修改等管理指令
+- 支持按群组存储 API 密钥
+- 增加服务器列表查看功能
+- 优化错误提示，明确权限限制
+- 移除配置文件中的服务器列表，改为数据库存储
+
 ### v1.3.6
 - 新增服务器资源使用情况查询功能
 - 支持查看 CPU、内存、磁盘使用情况
@@ -176,4 +217,4 @@ minekuaiSettings: {
 
 ## 支持与反馈
 
-如有问题或建议，请通过相关渠道联系开发者。
+如有问题或建议，请通过相关渠道联系开发者。