mioku-plugin-mc 4.0.0 → 4.0.2

package/core/rcon.ts

@@ -24,7 +24,7 @@ export function isCommandAllowed(
   text: string,
   serverItem: ServerConfig,
   isMaster: boolean,
-  userId: number | string,
+  userId: string,
 ): boolean {
   if (isMaster) return true;
 

package/index.ts

@@ -6,7 +6,6 @@ import { createPlayManager } from "./play";
 import { createMcSkill } from "./skills/mc";
 import { handleDebugCommand } from "./play/debug/commands";
 import { createServerManager } from "./utils/server-manager";
-import { parseMcCommand } from "./utils/command-router";
 import { handleStatus } from "./handlers/status";
 import { handleSync } from "./handlers/sync";
 import { handleReconnect } from "./handlers/reconnect";
@@ -21,8 +20,6 @@ import type { McConfig } from "./types";
 
 export default definePlugin({
   name: "mc",
-  version: "1.0.0",
-  description: "Minecraft服务器与QQ群消息互通插件",
 
   async setup(ctx: MiokuContext) {
     const configService = getService(ctx, Services.Config);
@@ -66,18 +63,15 @@ export default definePlugin({
 
     ctx.handle("message", async (event) => {
       const text = ctx.text(event).trim();
-      const groupId =
-        "group_id" in event && typeof event.group_id === "number"
-          ? event.group_id
-          : undefined;
+      const groupId = String(event.group_id ?? "").trim() || undefined;
 
       if (groupId) {
         const reply = await handleDebugCommand({
           text,
-          isOwner: ctx.isOwner?.(event) ?? false,
+          isMaster: ctx.isMaster?.(event) ?? false,
           debugEnabled: playConfigHandler.getConfig().debug.enabled,
           playManager,
-          groupId: Number(groupId),
+          groupId,
         });
         if (reply !== null) {
           await event.reply(reply);
@@ -85,60 +79,64 @@ export default definePlugin({
         }
       }
 
-      const parsed = parseMcCommand(text);
-
-      if (!parsed || parsed.action === "") {
-        if (groupId) {
-          playManager.onQqMessage(event);
-          await forwardToMc(ctx, event, config, configHandler, serverManager);
-        }
-        return;
+      if (groupId) {
+        await forwardToMc(ctx, event, config, configHandler, serverManager);
       }
+    });
 
-      switch (parsed.action) {
-        case "状态": {
-          await handleStatus(serverManager, config, async (msg) => {
-            await event.reply(msg);
-          });
-          break;
-        }
-        case "开启同步": {
-          const serverName = parsed.args[0];
-          await handleSync(
-            serverName,
-            true,
-            serverManager,
-            configHandler,
-            config,
-            async (msg) => {
-              await event.reply(msg);
-            },
-          );
-          break;
-        }
-        case "关闭同步": {
-          const serverName = parsed.args[0];
-          await handleSync(
-            serverName,
-            false,
-            serverManager,
-            configHandler,
-            config,
-            async (msg) => {
-              await event.reply(msg);
-            },
-          );
-          break;
-        }
-        case "重连": {
-          if (ctx.isOwner?.(event)) {
-            await handleReconnect(serverManager, async (msg) => {
-              await event.reply(msg);
-            });
-          }
-          break;
-        }
-      }
+    const replyWithEvent = (event: import("mioku").MessageEvent) =>
+      async (msg: string) => {
+        await event.reply(msg);
+      };
+
+    ctx.command({
+      id: "mc-status",
+      name: "mc-status",
+      prefixes: ["/", "."],
+      match: /^mc\s+状态\s*$/,
+      permission: "master",
+      description: "查看所有已配置服务器的WebSocket连接状态，包括连接中、已断开等",
+      async handler({ event }) {
+        await handleStatus(serverManager, config, replyWithEvent(event));
+      },
+    });
+
+    ctx.command({
+      id: "mc-sync-on",
+      name: "mc-sync-on",
+      prefixes: ["/", "."],
+      match: /^mc\s+开启同步(?:\s+(.+))?$/,
+      description: "开启指定服务器的群聊消息同步功能，开启后该服务器可接收和发送群聊消息",
+      usage: ".mc 开启同步 <服务器名称>",
+      permission: "master",
+      async handler({ event, args }) {
+        await handleSync(args[0], true, serverManager, configHandler, config, replyWithEvent(event));
+      },
+    });
+
+    ctx.command({
+      id: "mc-sync-off",
+      name: "mc-sync-off",
+      prefixes: ["/", "."],
+      match: /^mc\s+关闭同步(?:\s+(.+))?$/,
+      description: "关闭指定服务器的群聊消息同步功能，关闭后该服务器不再接收和发送群聊消息",
+      usage: ".mc 关闭同步 <服务器名称>",
+      permission: "master",
+      async handler({ event, args }) {
+        await handleSync(args[0], false, serverManager, configHandler, config, replyWithEvent(event));
+      },
+    });
+
+    ctx.command({
+      id: "mc-reconnect",
+      name: "mc-reconnect",
+      prefixes: ["/", "."],
+      match: /^mc\s+重连\s*$/,
+      permission: "master",
+      description: "断开并重新建立所有服务器的WebSocket连接，用于连接异常时手动恢复",
+      async handler({ event }) {
+        await handleReconnect(serverManager, replyWithEvent(event));
+      },
     });
 
     ctx.logger.info("Minecraft插件加载成功");
@@ -197,12 +195,10 @@ async function forwardToMc(
   const text = ctx.text(event);
   ctx.logger.debug(`[MC] 收到群消息 group=${event.group_id} text=${text}`);
 
-  // 检查是否为群消息
-  if (!event.group_id) {
-    return;
-  }
+  const groupId = String(event.group_id ?? "").trim();
+  if (!groupId) return;
 
-  const servers = configHandler.getServersForGroup(event.group_id);
+  const servers = configHandler.getServersForGroup(groupId);
   if (servers.length === 0) return;
 
   const msgList = Array.isArray(event.message)
@@ -219,7 +215,7 @@ async function forwardToMc(
       const isAllowed = isCommandAllowed(
         commandText,
         server,
-        ctx.isOwner?.(event) ?? false,
+        ctx.isMaster?.(event) ?? false,
         event.user_id ?? "",
       );
 
@@ -252,4 +248,4 @@ async function forwardToMc(
       ctx.logger.error(`[MC] 发送到服务器 ${server.server_name} 失败: ${err}`);
     }
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-mc",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "Minecraft与QQ群消息互通插件，支持服务器状态监控与RCON命令",
   "main": "index.ts",
   "type": "module",
@@ -15,53 +15,7 @@
     "services": [
       "config",
       "ai"
-    ],
-    "accessHooks": [
-      {
-        "id": "/mc 状态",
-        "match": "/^\\/mc\\s*状态/"
-      },
-      {
-        "id": "/mc 开启同步",
-        "match": "/^\\/mc\\s*开启同步/"
-      },
-      {
-        "id": "/mc 关闭同步",
-        "match": "/^\\/mc\\s*关闭同步/"
-      },
-      {
-        "id": "/mc 重连",
-        "match": "/^\\/mc\\s*重连/"
-      }
-    ],
-    "help": {
-      "title": "Minecraft",
-      "description": "Minecraft服务器与QQ群消息互通插件，支持服务器状态监控与RCON命令",
-      "commands": [
-        {
-          "cmd": "/mc 状态",
-          "desc": "查看所有已配置服务器的WebSocket连接状态，包括连接中、已断开等",
-          "role": "master"
-        },
-        {
-          "cmd": "/mc 开启同步",
-          "desc": "开启指定服务器的群聊消息同步功能，开启后该服务器可接收和发送群聊消息",
-          "usage": "/mc 开启同步 <服务器名称>",
-          "role": "master"
-        },
-        {
-          "cmd": "/mc 关闭同步",
-          "desc": "关闭指定服务器的群聊消息同步功能，关闭后该服务器不再接收和发送群聊消息",
-          "usage": "/mc 关闭同步 <服务器名称>",
-          "role": "master"
-        },
-        {
-          "cmd": "/mc 重连",
-          "desc": "断开并重新建立所有服务器的WebSocket连接，用于连接异常时手动恢复",
-          "role": "master"
-        }
-      ]
-    }
+    ]
   },
   "dependencies": {
     "@cikeyqi/queqiao-node-sdk": "^0.1.3",

package/play/ai/prompt.ts

@@ -126,7 +126,7 @@ function describeTerminator(t: WorkTerminator): string {
 export function buildSessionFacts(input: {
   serverName: string;
   username: string;
-  groupId: number;
+  groupId: string;
   maxPlayMs: number;
   allowedCommands: string[];
 }): string {

package/play/config.ts

@@ -27,10 +27,12 @@ export function createPlayConfigHandler(configService: ConfigService | undefined
     return currentConfig.servers.find((s) => s.id === id) ?? null;
   };
 
-  const findBinding = (groupId: number | string): GroupBinding | null => {
-    const gid = Number(groupId);
-    if (!Number.isFinite(gid) || gid <= 0) return null;
-    return currentConfig.groups.find((g) => g.groupId === gid) ?? null;
+  const findBinding = (groupId: string | number): GroupBinding | null => {
+    const gid = String(groupId ?? "").trim();
+    if (!gid) return null;
+    return (
+      currentConfig.groups.find((g) => String(g.groupId) === gid) ?? null
+    );
   };
 
   return { register, getConfig, findServer, findBinding };

package/play/debug/commands.ts

@@ -2,10 +2,10 @@ import type { PlayManager } from "../index";
 
 export interface DebugCommandContext {
   text: string;
-  isOwner: boolean;
+  isMaster: boolean;
   debugEnabled: boolean;
   playManager: PlayManager;
-  groupId: number;
+  groupId: string;
 }
 
 const OVERLAY_NAMES = ["defend", "auto_eat"];
@@ -78,7 +78,7 @@ function parseBundleArgs(arg: string): ParsedBundleArgs | null {
 export async function handleDebugCommand(
   ctx: DebugCommandContext,
 ): Promise<string | null> {
-  if (!ctx.debugEnabled || !ctx.isOwner) return null;
+  if (!ctx.debugEnabled || !ctx.isMaster) return null;
   const text = ctx.text.trim();
   if (!text.startsWith("/")) return null;
   const head = text.split(/\s+/)[0]?.toLowerCase();

package/play/index.ts

@@ -41,7 +41,7 @@ export class PlayManager {
   private readonly configService: ConfigService | undefined;
   private readonly playConfigHandler: PlayConfigHandler;
   private readonly syncConfigHandler: ConfigHandler;
-  private readonly sessions = new Map<number, PlaySession>();
+  private readonly sessions = new Map<string, PlaySession>();
   private mainInstance?: AIInstance;
   private workInstance?: AIInstance;
 
@@ -100,7 +100,7 @@ export class PlayManager {
   }
 
   async enter(
-    groupId: number,
+    groupId: string,
     serverId: string,
     opts: { debug?: boolean } = {},
   ): Promise<PlayEnterResult> {
@@ -180,7 +180,7 @@ export class PlayManager {
     return { success: true, serverId: server.id, message: `已进入 ${server.name}${mode}` };
   }
 
-  async exit(groupId: number): Promise<PlayExitResult> {
+  async exit(groupId: string): Promise<PlayExitResult> {
     const session = this.sessions.get(groupId);
     if (!session || session.isStopped) {
       return { success: false, message: "当前没有进行中的 mc 会话" };
@@ -191,8 +191,8 @@ export class PlayManager {
   }
 
   onQqMessage(event: any): void {
-    const groupId = Number(event?.group_id);
-    if (!Number.isFinite(groupId) || groupId <= 0) return;
+    const groupId = String(event?.group_id ?? "").trim();
+    if (!groupId) return;
     const session = this.sessions.get(groupId);
     if (!session || session.isStopped) return;
     const text = String(event?.raw_message ?? event?.message ?? "").trim();
@@ -206,7 +206,7 @@ export class PlayManager {
     return [...this.sessions.values()].map((s) => s.getStatus());
   }
 
-  getActiveSession(groupId: number): PlaySession | undefined {
+  getActiveSession(groupId: string): PlaySession | undefined {
     const s = this.sessions.get(groupId);
     return s && !s.isStopped ? s : undefined;
   }
@@ -231,7 +231,7 @@ export function createPlayManager(opts: PlayManagerOptions): PlayManager {
 function detectQqAtBot(
   event: any,
   botName: string,
-  botSelfId: number | undefined,
+  botSelfId: string | undefined,
 ): boolean {
   const lower = String(event?.raw_message ?? event?.message ?? "").toLowerCase();
   if (botName && lower.includes(botName.toLowerCase())) return true;
@@ -239,8 +239,8 @@ function detectQqAtBot(
     for (const segment of event.message) {
       if (!segment || typeof segment !== "object") continue;
       if (segment.type !== "at") continue;
-      const qq = Number(segment.data?.qq ?? 0);
-      if (qq > 0 && qq === botSelfId) return true;
+      const target = String(segment.data?.qq ?? segment.data?.target ?? "").trim();
+      if (target && target === botSelfId) return true;
     }
   }
   return false;

package/play/types.ts

@@ -12,8 +12,8 @@ export interface PlayServerConfig {
 }
 
 export interface GroupBinding {
-  groupId: number;
-  botSelfId: number;
+  groupId: string;
+  botSelfId: string;
   allowedServerIds: string[];
 }
 
@@ -73,8 +73,8 @@ export type MainLoopTrigger =
 export interface PlaySessionStatus {
   serverId: string;
   serverName: string;
-  groupId: number;
-  botSelfId: number;
+  groupId: string;
+  botSelfId: string;
   startedAt: number;
   connected: boolean;
   currentBehavior: string | null;
@@ -182,6 +182,11 @@ function asStringList(value: unknown): string[] {
   return [];
 }
 
+function asId(value: unknown, fallback = ""): string {
+  const text = String(value ?? "").trim();
+  return text.length > 0 ? text : fallback;
+}
+
 function asNumber(value: unknown, fallback: number): number {
   const n = Number(value);
   return Number.isFinite(n) ? n : fallback;
@@ -212,8 +217,8 @@ function normalizeServer(raw: any): PlayServerConfig {
 
 function normalizeBinding(raw: any): GroupBinding {
   return {
-    groupId: asNumber(raw?.groupId ?? raw?.group_id, 0),
-    botSelfId: asNumber(raw?.botSelfId ?? raw?.bot_self_id, 0),
+    groupId: asId(raw?.groupId ?? raw?.group_id),
+    botSelfId: asId(raw?.botSelfId ?? raw?.bot_self_id),
     allowedServerIds: asStringList(raw?.allowedServerIds ?? raw?.allowed_server_ids),
   };
 }
@@ -225,7 +230,7 @@ export function normalizePlayConfig(raw: any): PlayConfig {
   const groups = Array.isArray(raw?.groups)
     ? raw?.groups
         .map(normalizeBinding)
-        .filter((g: GroupBinding) => g.groupId > 0 && g.botSelfId > 0)
+        .filter((g: GroupBinding) => g.groupId.length > 0 && g.botSelfId.length > 0)
     : [];
   const perm: PlayToolPermission =
     raw?.toolPermission === "owner" ||

package/skills/mc.ts

@@ -29,8 +29,8 @@ export function createMcSkill(playManager: PlayManager): AISkill {
         },
         handler: async (args: any, runtimeCtx?: any) => {
           const event = runtimeCtx?.event || runtimeCtx?.rawEvent;
-          const groupId = Number(event?.group_id);
-          if (!Number.isFinite(groupId) || groupId <= 0) {
+          const groupId = String(event?.group_id ?? "").trim();
+          if (!groupId) {
             return { error: "无法识别当前群，请在群聊中调用" };
           }
 

package/utils/command-router.ts

@@ -1,51 +0,0 @@
-export interface ParsedCommand {
-  action: string;
-  args: string[];
-  raw: string;
-}
-
-export function parseMcCommand(text: string): ParsedCommand | null {
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("/mc")) return null;
-
-  const remainder = trimmed.slice(3).trim();
-  if (!remainder) {
-    return { action: "", args: [], raw: "" };
-  }
-
-  // split into action and args
-  const parts = remainder.split(/\s+/);
-  const action = parts[0] || "";
-  const args = parts.slice(1);
-
-  return { action, args, raw: remainder };
-}
-
-export function matchMcCommand(
-  text: string,
-  pattern: RegExp
-): RegExpMatchArray | null {
-  const parsed = parseMcCommand(text);
-  if (!parsed) return null;
-  return parsed.raw.match(pattern);
-}
-
-export function buildStatusReply(
-  serverName: string,
-  status: string,
-  displayName?: string
-): string {
-  const name = displayName || serverName;
-  const icon = status === "connected" ? "在线" : status === "connecting" ? "连接中" : "离线";
-  return `[${name}] ${icon}`;
-}
-
-export function buildSyncReply(
-  serverName: string,
-  enabled: boolean,
-  displayName?: string
-): string {
-  const name = displayName || serverName;
-  const action = enabled ? "开启" : "关闭";
-  return `${action}了服务器 ${name} 的同步`;
-}