mioku-plugin-admin 2.3.5 → 3.0.0

package/notify/welcome.ts

@@ -1,17 +1,16 @@
-import { type MiokiContext, wait } from "mioki";
+import { type MiokuContext, wait } from "mioku";
 import { getPluginRuntimeState, type AIService } from "mioku";
 import type { AdminConfig } from "../config";
 
 export async function resolveMemberName(
-  ctx: MiokiContext,
+  ctx: MiokuContext,
+  bot: import("mioku").Bot | undefined,
   groupId: number,
   userId: number,
-  selfId: number,
 ): Promise<string> {
   try {
-    const member = await ctx
-      .pickBot(selfId)
-      .getGroupMemberInfo(groupId, userId);
+    if (!bot) return String(userId);
+    const member = await bot.getMemberInfo(groupId, userId);
     return (
       String(member?.card || "").trim() ||
       String(member?.nickname || "").trim() ||
@@ -43,7 +42,7 @@ function getBatchMap(): Map<string, BatchState> {
   return state[RUNTIME_KEY] as Map<string, BatchState>;
 }
 
-function batchKey(selfId: number, groupId: number): string {
+function batchKey(selfId: string | number, groupId: number): string {
   return `${selfId}:${groupId}`;
 }
 
@@ -66,20 +65,21 @@ function normalizeGeneratedText(value: string): string {
 }
 
 async function flushBatch(options: {
-  ctx: MiokiContext;
+  ctx: MiokuContext;
   aiService?: AIService;
   config: AdminConfig;
-  selfId: number;
+  selfId: string | number;
   groupId: number;
   groupName: string;
   members: PendingMember[];
   promptInjections?: { content: string; title?: string }[];
+  bot?: import("mioku").Bot;
   tryCustomPrompt?: (info: {
-    selfId: number;
+    selfId: string | number;
     groupId: number;
     userId: number;
     groupName: string;
-  }) => Promise<boolean>;
+  }, bot?: import("mioku").Bot) => Promise<boolean>;
 }): Promise<string> {
   const {
     ctx,
@@ -90,6 +90,7 @@ async function flushBatch(options: {
     groupName,
     members,
     promptInjections,
+    bot,
     tryCustomPrompt,
   } = options;
   if (!members.length) return "";
@@ -97,12 +98,15 @@ async function flushBatch(options: {
   if (tryCustomPrompt) {
     let anyCustom = false;
     for (const m of members) {
-      const handled = await tryCustomPrompt({
-        selfId,
-        groupId,
-        userId: m.userId,
-        groupName,
-      });
+      const handled = await tryCustomPrompt(
+        {
+          selfId,
+          groupId,
+          userId: m.userId,
+          groupName,
+        },
+        bot,
+      );
       if (handled) anyCustom = true;
     }
     if (anyCustom) return "";
@@ -152,21 +156,22 @@ async function flushBatch(options: {
 }
 
 async function sendSingleWelcome(options: {
-  ctx: MiokiContext;
+  ctx: MiokuContext;
   aiService?: AIService;
   config: AdminConfig;
-  selfId: number;
+  selfId: string | number;
   groupId: number;
   groupName: string;
   userId: number;
   memberName: string;
   promptInjections?: { content: string; title?: string }[];
+  bot?: import("mioku").Bot;
   tryCustomPrompt?: (info: {
-    selfId: number;
+    selfId: string | number;
     groupId: number;
     userId: number;
     groupName: string;
-  }) => Promise<boolean>;
+  }, bot?: import("mioku").Bot) => Promise<boolean>;
 }): Promise<void> {
   const {
     ctx,
@@ -178,6 +183,7 @@ async function sendSingleWelcome(options: {
     userId,
     memberName,
     promptInjections,
+    bot,
     tryCustomPrompt,
   } = options;
   const welcomeMessage = await flushBatch({
@@ -189,42 +195,42 @@ async function sendSingleWelcome(options: {
     groupName,
     members: [{ userId, memberName }],
     promptInjections,
+    bot,
     tryCustomPrompt,
   });
   if (!welcomeMessage) return;
-  const bot = ctx.pickBot(selfId);
   if (!bot) return;
   try {
-    await bot.sendGroupMsg(groupId, [ctx.segment.text(welcomeMessage)]);
+    await bot.sendMessage({ type: "group", group_id: groupId}, [ctx.segment.text(welcomeMessage)]);
   } catch (error) {
     ctx.logger.warn(`发送入群欢迎失败: ${error}`);
   }
 }
 
 export async function triggerSingleWelcome(options: {
-  ctx: MiokiContext;
+  ctx: MiokuContext;
   aiService?: AIService;
   getConfig: () => AdminConfig;
-  selfId: number;
+  selfId: string | number;
   groupId: number;
   groupName: string;
   userId: number;
   memberName?: string;
   promptInjections?: { content: string; title?: string }[];
   tryCustomPrompt?: (info: {
-    selfId: number;
+    selfId: string | number;
     groupId: number;
     userId: number;
     groupName: string;
-  }) => Promise<boolean>;
-}): Promise<void> {
+  }, bot?: import("mioku").Bot) => Promise<boolean>;
+}, bot?: import("mioku").Bot): Promise<void> {
   const memberName =
     options.memberName ||
     (await resolveMemberName(
       options.ctx,
+      bot,
       options.groupId,
       options.userId,
-      options.selfId,
     ));
   await sendSingleWelcome({
     ctx: options.ctx,
@@ -236,26 +242,27 @@ export async function triggerSingleWelcome(options: {
     userId: options.userId,
     memberName,
     promptInjections: options.promptInjections,
+    bot,
     tryCustomPrompt: options.tryCustomPrompt,
   });
 }
 
 export function registerWelcomeHandler(
-  ctx: MiokiContext,
+  ctx: MiokuContext,
   aiService: AIService | undefined,
   getConfig: () => AdminConfig,
   shouldSuppress?: (info: {
-    selfId: number;
+    selfId: string | number;
     groupId: number;
     userId: number;
     groupName: string;
-  }) => Promise<boolean> | boolean,
+  }, bot?: import("mioku").Bot) => Promise<boolean> | boolean,
   tryCustomPrompt?: (info: {
-    selfId: number;
+    selfId: string | number;
     groupId: number;
     userId: number;
     groupName: string;
-  }) => Promise<boolean>,
+  }, bot?: import("mioku").Bot) => Promise<boolean>,
 ): () => void {
   const batches = getBatchMap();
 
@@ -263,18 +270,19 @@ export function registerWelcomeHandler(
     "notice.group.increase",
     async (event) => {
       const cfg = getConfig();
-      const selfId = Number(event?.self_id || ctx.self_id);
+      const bot = event.bot;
+      const selfId = event?.self_id || ctx.self_id || "";
       const groupId = Number(event?.group_id || 0);
       const userId = Number(event?.user_id || 0);
       if (!groupId || !userId) return;
-      if (userId === selfId) return;
+      if (selfId != null && String(userId) === String(selfId)) return;
 
       const groupName =
-        String(event?.group?.group_name || "").trim() || String(groupId);
+        String((event.raw as { group_name?: string } | undefined)?.group_name || "").trim() || String(groupId);
 
       if (
         shouldSuppress &&
-        (await shouldSuppress({ selfId, groupId, userId, groupName }))
+        (await shouldSuppress({ selfId, groupId, userId, groupName }, bot))
       ) {
         return;
       }
@@ -286,9 +294,9 @@ export function registerWelcomeHandler(
       if (batchWindowMs === 0) {
         const memberName = await resolveMemberName(
           ctx,
+          bot,
           groupId,
           userId,
-          selfId,
         );
         const welcomeMessage = await flushBatch({
           ctx,
@@ -298,12 +306,12 @@ export function registerWelcomeHandler(
           groupId,
           groupName,
           members: [{ userId, memberName }],
+          bot,
         });
         if (!welcomeMessage) return;
-        const bot = ctx.pickBot(selfId);
         if (!bot) return;
         try {
-          await bot.sendGroupMsg(groupId, [ctx.segment.text(welcomeMessage)]);
+          await bot.sendMessage({ type: "group", group_id: groupId}, [ctx.segment.text(welcomeMessage)]);
         } catch (error) {
           ctx.logger.warn(`发送入群欢迎失败: ${error}`);
         }
@@ -320,7 +328,7 @@ export function registerWelcomeHandler(
         state.groupName = groupName;
       }
 
-      const memberName = await resolveMemberName(ctx, groupId, userId, selfId);
+      const memberName = await resolveMemberName(ctx, bot, groupId, userId);
       if (!state.members.some((m) => m.userId === userId)) {
         state.members.push({ userId, memberName });
       }
@@ -344,14 +352,14 @@ export function registerWelcomeHandler(
             groupId,
             groupName: pending.groupName,
             members: pending.members,
+            bot,
             tryCustomPrompt,
           });
           if (!welcomeMessage) return;
 
-          const bot = ctx.pickBot(selfId);
           if (!bot) return;
           try {
-            await bot.sendGroupMsg(groupId, [ctx.segment.text(welcomeMessage)]);
+            await bot.sendMessage({ type: "group", group_id: groupId}, [ctx.segment.text(welcomeMessage)]);
           } catch (error) {
             ctx.logger.warn(`发送入群欢迎失败: ${error}`);
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-admin",
-  "version": "2.3.5",
+  "version": "3.0.0",
   "description": "管理插件，提供事件通知与群管/个人管理指令",
   "main": "index.ts",
   "type": "module",
@@ -12,12 +12,10 @@
     "url": "https://github.com/mioku-lab/mioku-plugin-admin.git"
   },
   "peerDependencies": {
-    "mioku": "^0.8.0",
-    "mioki": "^0.16.0"
+    "mioku": "^1.0.0"
   },
   "devDependencies": {
-    "mioku": "workspace:*",
-    "mioki": "^0.16.0"
+    "mioku": "workspace:*"
   },
   "mioku": {
     "services": [

package/skills/group.ts

@@ -1,25 +1,42 @@
-import type { AISkill } from "mioku";
+import type { AISkill, Bot, MessageEvent } from "mioku";
+
 import { getMemberRole } from "../config";
 import { getImageUrlByMessageId } from "./message-image";
 
-async function resolveGroupRuntime(runtimeCtx: any) {
+interface GroupRuntime {
+  ctx: { logger?: { error?: (...args: unknown[]) => void } };
+  event: MessageEvent;
+  bot: Bot;
+  groupId: number;
+  selfId: number;
+}
+
+interface SkillRuntimeContext {
+  ctx?: GroupRuntime["ctx"];
+  event?: MessageEvent;
+  rawEvent?: MessageEvent;
+}
+
+function resolveGroupRuntime(runtimeCtx: SkillRuntimeContext | undefined):
+  | GroupRuntime
+  | { error: string } {
   const ctx = runtimeCtx?.ctx;
   if (!ctx) return { error: "无法获取上下文" };
 
-  const event = runtimeCtx?.event || runtimeCtx?.rawEvent;
-  const groupId = Number(event?.group_id || 0);
+  const event = runtimeCtx?.event ?? runtimeCtx?.rawEvent;
+  const groupId = Number(event?.group_id ?? 0);
   if (!groupId) return { error: "这个工具只能在群聊中使用" };
 
-  const selfId = runtimeCtx?.event?.self_id || runtimeCtx?.rawEvent?.self_id;
+  const selfId = Number(event?.self_id ?? 0);
   if (!selfId) return { error: "无法获取Bot ID" };
 
-  const bot = ctx.pickBot(selfId);
+  const bot = event?.bot;
   if (!bot) return { error: "Bot不可用" };
 
-  return { ctx, selfId, bot, groupId, event };
+  return { ctx, event: event!, bot, groupId, selfId };
 }
 
-function logAdminSkillError(runtimeCtx: any, toolName: string, err: unknown) {
+function logAdminSkillError(runtimeCtx: SkillRuntimeContext | undefined, toolName: string, err: unknown) {
   runtimeCtx?.ctx?.logger?.error?.(
     `[admin skills] ${toolName} failed: ${String(err)}`,
   );
@@ -32,22 +49,16 @@ function formatGroupRole(role: string): string {
 }
 
 async function checkDangerousTargetPermission(
-  runtime: any,
+  runtime: GroupRuntime,
   targetUserId: number,
 ): Promise<string | null> {
-  const operatorUserId = Number(runtime.event?.user_id || 0);
+  const operatorUserId = Number(runtime.event.user_id ?? 0);
   if (!operatorUserId) return "无法获取当前操作人ID";
 
-  const operatorRole = await getMemberRole(
-    runtime.bot,
-    runtime.groupId,
-    operatorUserId,
-  );
-  const targetRole = await getMemberRole(
-    runtime.bot,
-    runtime.groupId,
-    targetUserId,
-  );
+  const [operatorRole, targetRole] = await Promise.all([
+    getMemberRole(runtime.bot, runtime.groupId, operatorUserId),
+    getMemberRole(runtime.bot, runtime.groupId, targetUserId),
+  ]);
   if (operatorRole !== targetRole) return null;
 
   return `无权操作同级成员：操作人与被操作人均为${formatGroupRole(operatorRole)}`;
@@ -94,108 +105,74 @@ const groupAdminSkill: AISkill = {
         },
         required: ["action"],
       },
-      handler: async (args: any, runtimeCtx?: any) => {
-        const runtime = await resolveGroupRuntime(runtimeCtx);
+      handler: async (args: unknown, runtimeCtx?: SkillRuntimeContext) => {
+        const runtime = resolveGroupRuntime(runtimeCtx);
         if ("error" in runtime) return { error: runtime.error };
-        const { bot, selfId, groupId, event } = runtime;
-        const action = String(args?.action || "");
+        const { bot, groupId, event } = runtime;
+        const action = String((args as { action?: unknown })?.action ?? "");
 
         try {
           switch (action) {
             case "kick": {
-              const userId = Number(args?.user_id);
+              const userId = Number((args as { user_id?: unknown })?.user_id);
               if (!userId) return { error: "kick 需要提供 user_id" };
-              const permErr = await checkDangerousTargetPermission(
-                runtime,
-                userId,
-              );
+              const permErr = await checkDangerousTargetPermission(runtime, userId);
               if (permErr) return { error: permErr };
-              await bot.api("set_group_kick", {
-                group_id: groupId,
-                user_id: userId,
-              });
+              await bot.kickMember(groupId, userId);
               return { success: true, message: `已将 ${userId} 移出当前群` };
             }
             case "mute": {
-              const userId = Number(args?.user_id);
+              const userId = Number((args as { user_id?: unknown })?.user_id);
               if (!userId) return { error: "mute 需要提供 user_id" };
-              const permErr = await checkDangerousTargetPermission(
-                runtime,
-                userId,
-              );
+              const permErr = await checkDangerousTargetPermission(runtime, userId);
               if (permErr) return { error: permErr };
               const duration =
-                Number(args?.duration) > 0 ? Number(args.duration) : 10 * 60;
-              await bot.setGroupBan(groupId, userId, duration);
-              return {
-                success: true,
-                message: `已禁言 ${userId} ${duration}秒`,
-              };
+                Number((args as { duration?: unknown })?.duration) > 0
+                  ? Number((args as { duration?: unknown }).duration)
+                  : 10 * 60;
+              await bot.banMember(groupId, userId, duration);
+              return { success: true, message: `已禁言 ${userId} ${duration}秒` };
             }
             case "unmute": {
-              const userId = Number(args?.user_id);
+              const userId = Number((args as { user_id?: unknown })?.user_id);
               if (!userId) return { error: "unmute 需要提供 user_id" };
-              await bot.setGroupBan(groupId, userId, 0);
+              await bot.banMember(groupId, userId, 0);
               return { success: true, message: `已解除 ${userId} 的禁言` };
             }
             case "set_admin": {
-              const userId = Number(args?.user_id);
+              const userId = Number((args as { user_id?: unknown })?.user_id);
               if (!userId) return { error: "set_admin 需要提供 user_id" };
-              await bot.api("set_group_admin", {
-                group_id: groupId,
-                user_id: userId,
-                enable: true,
-              });
-              return {
-                success: true,
-                message: `已将 ${userId} 设为当前群的管理员`,
-              };
+              await bot.setMemberAdmin(groupId, userId, true);
+              return { success: true, message: `已将 ${userId} 设为当前群的管理员` };
             }
             case "unset_admin": {
-              const userId = Number(args?.user_id);
+              const userId = Number((args as { user_id?: unknown })?.user_id);
               if (!userId) return { error: "unset_admin 需要提供 user_id" };
-              await bot.api("set_group_admin", {
-                group_id: groupId,
-                user_id: userId,
-                enable: false,
-              });
-              return {
-                success: true,
-                message: `已取消 ${userId} 在当前群的管理员`,
-              };
+              await bot.setMemberAdmin(groupId, userId, false);
+              return { success: true, message: `已取消 ${userId} 在当前群的管理员` };
             }
             case "set_title": {
-              const userId = Number(args?.user_id);
-              const title = String(args?.title || "").trim();
+              const userId = Number((args as { user_id?: unknown })?.user_id);
+              const title = String((args as { title?: unknown })?.title ?? "").trim();
               if (!userId || !title) {
                 return { error: "set_title 需要提供 user_id 和 title" };
               }
-              await (bot as any).setGroupSpecialTitle(groupId, userId, title);
-              return {
-                success: true,
-                message: `已将 ${userId} 的头衔设为 "${title}"`,
-              };
+              await bot.setMemberTitle(groupId, userId, title);
+              return { success: true, message: `已将 ${userId} 的头衔设为 "${title}"` };
             }
             case "set_self_title": {
-              const userId = Number(event?.user_id);
+              const userId = Number(event.user_id);
               if (!userId) return { error: "无法获取当前用户ID" };
-              const title = String(args?.title || "").trim();
+              const title = String((args as { title?: unknown })?.title ?? "").trim();
               if (!title) return { error: "set_self_title 需要提供 title" };
-              await (bot as any).setGroupSpecialTitle(groupId, userId, title);
-              return {
-                success: true,
-                message: `已将你的头衔设为 "${title}"`,
-              };
+              await bot.setMemberTitle(groupId, userId, title);
+              return { success: true, message: `已将你的头衔设为 "${title}"` };
             }
             default:
               return { error: `未知的 action: ${action}` };
           }
         } catch (err) {
-          logAdminSkillError(
-            runtimeCtx,
-            `admin_group.manage_member.${action}`,
-            err,
-          );
+          logAdminSkillError(runtimeCtx, `admin_group.manage_member.${action}`, err);
           return { error: `执行 ${action} 失败: ${err}` };
         }
       },
@@ -240,87 +217,58 @@ const groupAdminSkill: AISkill = {
         },
         required: ["action"],
       },
-      handler: async (args: any, runtimeCtx?: any) => {
-        const runtime = await resolveGroupRuntime(runtimeCtx);
+      handler: async (args: unknown, runtimeCtx?: SkillRuntimeContext) => {
+        const runtime = resolveGroupRuntime(runtimeCtx);
         if ("error" in runtime) return { error: runtime.error };
-        const { bot, selfId, groupId } = runtime;
-        const action = String(args?.action || "");
+        const { bot, groupId, selfId } = runtime;
+        const action = String((args as { action?: unknown })?.action ?? "");
 
         try {
           switch (action) {
             case "set_whole_ban":
-              await bot.api("set_group_whole_ban", {
-                group_id: groupId,
-                enable: true,
-              });
+              await bot.setGroupWholeBan(groupId, true);
               return { success: true, message: "当前群已开启全体禁言" };
             case "unset_whole_ban":
-              await bot.api("set_group_whole_ban", {
-                group_id: groupId,
-                enable: false,
-              });
+              await bot.setGroupWholeBan(groupId, false);
               return { success: true, message: "当前群已关闭全体禁言" };
             case "set_group_name": {
-              const groupName = String(args?.group_name || "").trim();
-              if (!groupName)
-                return { error: "set_group_name 需要提供 group_name" };
-              await bot.api("set_group_name", {
-                group_id: groupId,
-                group_name: groupName,
-              });
-              return {
-                success: true,
-                message: `当前群名称已修改为 ${groupName}`,
-              };
+              const groupName = String((args as { group_name?: unknown })?.group_name ?? "").trim();
+              if (!groupName) return { error: "set_group_name 需要提供 group_name" };
+              await bot.setGroupName(groupId, groupName);
+              return { success: true, message: `当前群名称已修改为 ${groupName}` };
             }
             case "set_self_card": {
-              const card = String(args?.card || "").trim();
+              const card = String((args as { card?: unknown })?.card ?? "").trim();
               if (!card) return { error: "set_self_card 需要提供 card" };
-              await bot.setGroupCard(groupId, selfId, card);
-              return {
-                success: true,
-                message: `Bot在当前群的群名片已修改为 ${card}`,
-              };
+              await bot.setMemberCard(groupId, selfId, card);
+              return { success: true, message: `Bot在当前群的群名片已修改为 ${card}` };
             }
             case "set_group_avatar": {
-              const messageId = Number(args?.message_id);
+              const messageId = Number((args as { message_id?: unknown })?.message_id);
               if (!Number.isFinite(messageId) || messageId <= 0) {
                 return { error: "set_group_avatar 需要提供有效的 message_id" };
               }
               const imageUrl = await getImageUrlByMessageId(bot, messageId);
-              if (!imageUrl) {
-                return { error: "指定 message_id 中未找到图片" };
-              }
-              await bot.api("set_group_portrait", {
-                group_id: groupId,
-                file: imageUrl,
-              });
+              if (!imageUrl) return { error: "指定 message_id 中未找到图片" };
+              await bot.setGroupPortrait(groupId, imageUrl);
               return { success: true, message: "当前群头像已修改" };
             }
             case "recall_messages": {
-              const ids = Array.isArray(args?.message_ids)
-                ? args.message_ids
-                    .map((v: any) => Number(v))
-                    .filter((n: number) => Number.isFinite(n) && n !== 0)
+              const ids = Array.isArray((args as { message_ids?: unknown })?.message_ids)
+                ? ((args as { message_ids: unknown[] }).message_ids)
+                    .map((v) => Number(v))
+                    .filter((n) => Number.isFinite(n) && n !== 0)
                 : [];
               if (ids.length === 0) {
                 return { error: "recall_messages 需要提供至少一个 message_id" };
               }
-              const results: Array<{
-                message_id: number;
-                success: boolean;
-                error?: string;
-              }> = [];
+              const results: Array<{ message_id: number; success: boolean; error?: string }> = [];
               for (const id of ids) {
                 try {
-                  await bot.api("delete_msg", { message_id: id });
+                  await bot.recallMessage(id);
                   results.push({ message_id: id, success: true });
                 } catch (err) {
-                  results.push({
-                    message_id: id,
-                    success: false,
-                    error: String(err),
-                  });
+                  results.push({ message_id: id, success: false, error: String(err) });
                 }
               }
               const ok = results.filter((r) => r.success).length;
@@ -334,11 +282,7 @@ const groupAdminSkill: AISkill = {
               return { error: `未知的 action: ${action}` };
           }
         } catch (err) {
-          logAdminSkillError(
-            runtimeCtx,
-            `admin_group.manage_group.${action}`,
-            err,
-          );
+          logAdminSkillError(runtimeCtx, `admin_group.manage_group.${action}`, err);
           return { error: `执行 ${action} 失败: ${err}` };
         }
       },
@@ -346,4 +290,4 @@ const groupAdminSkill: AISkill = {
   ],
 };
 
-export default groupAdminSkill;
+export default groupAdminSkill;

package/skills/message-image.ts

@@ -1,17 +1,16 @@
+import type { Bot } from "mioku";
+
 export async function getImageUrlByMessageId(
-  bot: any,
+  bot: Bot,
   messageId: number,
 ): Promise<string | null> {
   try {
-    const msg =
-      typeof bot?.getMsg === "function"
-        ? await bot.getMsg(messageId)
-        : await bot.api("get_msg", { message_id: messageId });
+    const msg = await bot.sendApi<{
+      message?: Array<{ type?: string; url?: string; file?: string }>;
+    }>("get_msg", { message_id: messageId });
     const segments = Array.isArray(msg?.message) ? msg.message : [];
-    const imageSeg = segments.find((seg: any) => seg?.type === "image");
-    if (!imageSeg) {
-      return null;
-    }
+    const imageSeg = segments.find((seg) => seg?.type === "image");
+    if (!imageSeg) return null;
 
     return imageSeg.url || imageSeg.file || null;
   } catch {