mioku-plugin-mc 3.0.1 → 4.0.1

package/index.ts

@@ -1,4 +1,4 @@
-import { definePlugin, type MiokiContext } from "mioki";
+import { definePlugin, type MiokuContext } from "mioku";
 import { getService, Services } from "mioku";
 import { createConfigHandler } from "./utils/config-handler";
 import { createPlayConfigHandler } from "./play/config";
@@ -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,10 +20,8 @@ import type { McConfig } from "./types";
 
 export default definePlugin({
   name: "mc",
-  version: "1.0.0",
-  description: "Minecraft服务器与QQ群消息互通插件",
 
-  async setup(ctx: MiokiContext) {
+  async setup(ctx: MiokuContext) {
     const configService = getService(ctx, Services.Config);
 
     const configHandler = createConfigHandler(configService);
@@ -74,7 +71,7 @@ export default definePlugin({
       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),
@@ -85,60 +82,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",
+      match: /^\/mc\s+状态\s*$/,
+      prefixes: ["/"],
+      permission: "master",
+      description: "查看所有已配置服务器的WebSocket连接状态，包括连接中、已断开等",
+      async handler({ event }) {
+        await handleStatus(serverManager, config, replyWithEvent(event));
+      },
+    });
+
+    ctx.command({
+      id: "mc-sync-on",
+      name: "mc-sync-on",
+      match: /^\/mc\s+开启同步(?:\s+(.+))?$/,
+      prefixes: ["/"],
+      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",
+      match: /^\/mc\s+关闭同步(?:\s+(.+))?$/,
+      prefixes: ["/"],
+      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",
+      match: /^\/mc\s+重连\s*$/,
+      prefixes: ["/"],
+      permission: "master",
+      description: "断开并重新建立所有服务器的WebSocket连接，用于连接异常时手动恢复",
+      async handler({ event }) {
+        await handleReconnect(serverManager, replyWithEvent(event));
+      },
     });
 
     ctx.logger.info("Minecraft插件加载成功");
@@ -153,7 +154,7 @@ export default definePlugin({
 });
 
 async function handleMcEvent(
-  ctx: MiokiContext,
+  ctx: MiokuContext,
   event: McEvent,
   config: McConfig,
   configHandler: ReturnType<typeof createConfigHandler>,
@@ -174,12 +175,12 @@ async function handleMcEvent(
   const groups = groupList ? [groupList] : [];
 
   for (const botId of bots) {
-    const bot = ctx.pickBot(Number(botId));
+    const bot = ctx.pickBot(botId);
     if (!bot) continue;
 
     for (const groupId of groups) {
       try {
-        await bot.sendGroupMsg(Number(groupId), messageText);
+        await bot.sendMessage({ type: "group", group_id: groupId}, messageText);
       } catch (err) {
         ctx.logger.error(`[MC] 发送消息到群 ${groupId} 失败: ${err}`);
       }
@@ -188,7 +189,7 @@ async function handleMcEvent(
 }
 
 async function forwardToMc(
-  ctx: MiokiContext,
+  ctx: MiokuContext,
   event: any,
   config: McConfig,
   configHandler: ReturnType<typeof createConfigHandler>,
@@ -197,10 +198,7 @@ async function forwardToMc(
   const text = ctx.text(event);
   ctx.logger.debug(`[MC] 收到群消息 group=${event.group_id} text=${text}`);
 
-  // 检查是否为群消息
-  if (!event.group_id) {
-    return;
-  }
+  if (!event.group_id) return;
 
   const servers = configHandler.getServersForGroup(event.group_id);
   if (servers.length === 0) return;
@@ -219,7 +217,7 @@ async function forwardToMc(
       const isAllowed = isCommandAllowed(
         commandText,
         server,
-        ctx.isOwner?.(event) ?? false,
+        ctx.isMaster?.(event) ?? false,
         event.user_id ?? "",
       );
 
@@ -252,4 +250,4 @@ async function forwardToMc(
       ctx.logger.error(`[MC] 发送到服务器 ${server.server_name} 失败: ${err}`);
     }
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-mc",
-  "version": "3.0.1",
+  "version": "4.0.1",
   "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",
@@ -71,11 +25,9 @@
     "zod": "^3.24.1"
   },
   "peerDependencies": {
-    "mioku": "^0.8.0",
-    "mioki": "^0.16.0"
+    "mioku": "^1.0.0"
   },
   "devDependencies": {
-    "mioku": "workspace:*",
-    "mioki": "^0.16.0"
+    "mioku": "workspace:*"
   }
 }

package/play/actions/registry.ts

@@ -67,7 +67,7 @@ export class ActionRegistry {
           .map(
             (issue) => `${issue.path.join(".") || "params"}: ${issue.message}`,
           )
-          .join("; "),
+          .join("); "),
         meta,
       );
     }

package/play/context.ts

@@ -1,4 +1,4 @@
-import type { MiokiContext } from "mioki";
+import type { MiokuContext } from "mioku";
 import type { AIService, AIInstance, ConfigService } from "mioku";
 import type { PlayConfig } from "./types";
 import type { ConfigHandler } from "../utils/config-handler";
@@ -6,7 +6,7 @@ import type { WorkSubroutine, WorkTerminator } from "./ai/work-subroutine";
 import type { PlaySession } from "./session";
 
 export interface PlayPluginContext {
-  ctx: MiokiContext;
+  ctx: MiokuContext;
   config: PlayConfig;
   aiService: AIService | undefined;
   configService: ConfigService | undefined;

package/play/debug/commands.ts

@@ -2,7 +2,7 @@ import type { PlayManager } from "../index";
 
 export interface DebugCommandContext {
   text: string;
-  isOwner: boolean;
+  isMaster: boolean;
   debugEnabled: boolean;
   playManager: PlayManager;
   groupId: number;
@@ -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

@@ -1,4 +1,4 @@
-import type { MiokiContext } from "mioki";
+import type { MiokuContext } from "mioku";
 import type { AIService, AIInstance, ConfigService } from "mioku";
 import type { ConfigHandler } from "../utils/config-handler";
 import type { PlayPluginContext } from "./context";
@@ -17,7 +17,7 @@ import { SelfDefenseBehavior } from "./behavior/catalog/defend";
 import type { GroupBinding, PlayServerConfig } from "./types";
 
 export interface PlayManagerOptions {
-  ctx: MiokiContext;
+  ctx: MiokuContext;
   aiService: AIService | undefined;
   configService: ConfigService | undefined;
   playConfigHandler: PlayConfigHandler;
@@ -36,7 +36,7 @@ export interface PlayExitResult {
 }
 
 export class PlayManager {
-  private readonly ctx: MiokiContext;
+  private readonly ctx: MiokuContext;
   private readonly aiService: AIService | undefined;
   private readonly configService: ConfigService | undefined;
   private readonly playConfigHandler: PlayConfigHandler;

package/play/missions/registry.ts

@@ -88,7 +88,7 @@ export class TaskRegistry {
         ok: false,
         error: `invalid_params: ${result.error.issues
           .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
-          .join("; ")}`,
+          .join("); ")}`,
       };
     }
     return { ok: true, params: result.data };

package/play/session.ts

@@ -242,7 +242,7 @@ export class PlaySession {
     const bot = ctx.ctx.pickBot(this.binding.botSelfId);
     if (!bot) return;
     try {
-      await bot.sendGroupMsg(this.binding.groupId, message);
+      await bot.sendMessage({ type: "group", group_id: this.binding.groupId}, message);
     } catch (err) {
       ctx.ctx.logger.error(`[MC/play] 发送 QQ 通知失败: ${err}`);
     }
@@ -264,7 +264,7 @@ export class PlaySession {
     const bot = ctx.ctx.pickBot(this.binding.botSelfId);
     if (!bot) return false;
     try {
-      await bot.sendGroupMsg(this.binding.groupId, message);
+      await bot.sendMessage({ type: "group", group_id: this.binding.groupId}, message);
       return true;
     } catch (err) {
       ctx.ctx.logger.error(`[MC/play] 发送 QQ 消息失败: ${err}`);

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} 的同步`;
-}