koishi-plugin-kkk 1.0.0

package/lib/karin/module/utils/ErrorHandler/handler.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapWithErrorHandler = exports.handleBusinessError = void 0;
+const node_karin_1 = require("../../../../compat/node-karin.js");
+const module_1 = require("../../../module");
+const EmojiReaction_1 = require("../../../module/utils/EmojiReaction");
+const ImageSlice_1 = require("../ImageSlice");
+const render_1 = require("./render");
+const sender_1 = require("./sender");
+const strategy_1 = require("./strategy");
+const utils_1 = require("./utils");
+const handleBusinessError = async (error, options, logs, event) => {
+    try {
+        node_karin_1.logger.debug(`[ErrorHandler] 开始处理业务错误: ${options.businessName}`);
+        const buildMetadata = (0, module_1.getBuildMetadata)();
+        const adapterInfo = event.bot?.adapter ? event.bot.adapter : undefined;
+        const ctx = {
+            error,
+            options,
+            logs,
+            event,
+            buildMetadata,
+            adapterInfo
+        };
+        for (const strategy of (0, strategy_1.getStrategies)()) {
+            if (strategy.match(ctx)) {
+                node_karin_1.logger.debug(`[ErrorHandler] 匹配策略: ${strategy.name}`);
+                const result = await strategy.handle(ctx);
+                if (result === 'handled')
+                    return 'handled';
+            }
+        }
+        let img = await (0, render_1.renderErrorImage)(ctx);
+        /**
+         * 错误卡片也会超长（实测 2880×40000 / 45MB），直接发必被 QQ 拒收 ——
+         * 统一切成 markdown（分片拼接），失败就退回原图。
+         */
+        try {
+            const sliced = await (0, ImageSlice_1.sliceImageToMarkdown)(img);
+            if (sliced)
+                img = [sliced];
+        }
+        catch (sliceError) {
+            node_karin_1.logger.debug('[ErrorHandler] 错误卡片切片失败，按原图发送: ' + String(sliceError?.message ?? sliceError));
+        }
+        await (0, sender_1.sendErrorToTrigger)(ctx, img);
+        await (0, sender_1.sendErrorToMaster)(ctx, img);
+        await (0, sender_1.sendErrorToAllMasters)(ctx, img);
+        // 「管理员」= 权限等级 > 4（Koishi 的主人档）
+        await (0, sender_1.sendErrorToAdmins)(ctx, img).catch((err) => node_karin_1.logger.warn('[ErrorHandler] 发送给管理员失败: ' + String(err)));
+        if (options.customErrorHandler) {
+            try {
+                await options.customErrorHandler(error, logs);
+            }
+            catch (err) {
+                node_karin_1.logger.error(`[ErrorHandler] 自定义错误处理失败: ${err}`);
+            }
+        }
+    }
+    catch (handlerError) {
+        node_karin_1.logger.error(`[ErrorHandler] 错误处理器本身发生错误: ${handlerError}`);
+        throw handlerError;
+    }
+    return undefined;
+};
+exports.handleBusinessError = handleBusinessError;
+const wrapWithErrorHandler = (fn, options) => {
+    return async (e, next) => {
+        const rawEvent = e;
+        const normalizedEvent = await (0, utils_1.injectBotToEventForPushTask)(rawEvent, options.businessName);
+        const normalizedNext = next ?? (() => undefined);
+        const shouldHandleEmoji = Boolean(rawEvent) && !(0, utils_1.isPushTask)(rawEvent, options.businessName);
+        const emojiManager = shouldHandleEmoji ? new EmojiReaction_1.EmojiReactionManager(rawEvent) : undefined;
+        let processingTimer = null;
+        let successTimer = null;
+        if (emojiManager) {
+            await emojiManager.add('EYES');
+            processingTimer = setTimeout(() => {
+                emojiManager.add('PROCESSING').catch(() => { });
+            }, 1500);
+        }
+        const ctx = node_karin_1.logger.runContext(async () => fn(normalizedEvent, normalizedNext));
+        try {
+            const result = await ctx.run();
+            if (emojiManager) {
+                successTimer = setTimeout(() => {
+                    emojiManager.replace('PROCESSING', 'SUCCESS').catch(() => { });
+                }, 1500);
+            }
+            return result;
+        }
+        catch (error) {
+            if (processingTimer)
+                clearTimeout(processingTimer);
+            if (successTimer)
+                clearTimeout(successTimer);
+            if (emojiManager) {
+                const processingEmojiId = emojiManager['getPlatformEmojiId']('PROCESSING');
+                if (emojiManager.has(processingEmojiId)) {
+                    await emojiManager.remove('PROCESSING');
+                }
+                await emojiManager.add('ERROR');
+            }
+            node_karin_1.logger.debug('[ErrorHandler] 原始错误: ' + (error?.stack ?? String(error)));
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const structuredLogs = (0, utils_1.parseLogsToStructured)(ctx.logs());
+            const result = await (0, exports.handleBusinessError)(error, options, structuredLogs, normalizedEvent);
+            if (result === 'handled')
+                return undefined;
+            throw error;
+        }
+    };
+};
+exports.wrapWithErrorHandler = wrapWithErrorHandler;

package/lib/karin/module/utils/ErrorHandler/index.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * 错误处理模块
+ *
+ * @remarks
+ * 提供统一的错误处理机制，支持：
+ * - 策略模式：注册自定义错误处理策略
+ * - 错误图片渲染：生成包含详细信息的错误报告图片
+ * - 多目标发送：支持发送给触发者、单个主人或所有主人
+ * - 函数包装器：自动捕获并处理业务函数中的错误
+ *
+ * @example
+ * ```ts
+ * import { wrapWithErrorHandler, registerErrorStrategy } from '@/module/utils/ErrorHandler'
+ *
+ * // 使用包装器
+ * const handler = wrapWithErrorHandler(
+ *   async (e) => await doSomething(e),
+ *   { businessName: '我的业务' }
+ * )
+ *
+ * // 注册自定义策略
+ * registerErrorStrategy({
+ *   name: 'MyStrategy',
+ *   match: (ctx) => ctx.error instanceof MyError,
+ *   handle: async (ctx) => 'handled'
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statBotId = exports.parseLogsToStructured = exports.isPushTask = exports.getPushTaskBotId = exports.wrapWithErrorHandler = exports.handleBusinessError = exports.sendErrorToTrigger = exports.sendErrorToMaster = exports.sendErrorToAllMasters = exports.renderErrorImage = exports.registerErrorStrategy = exports.getStrategies = void 0;
+// 策略注册
+var strategy_1 = require("./strategy");
+Object.defineProperty(exports, "getStrategies", { enumerable: true, get: function () { return strategy_1.getStrategies; } });
+Object.defineProperty(exports, "registerErrorStrategy", { enumerable: true, get: function () { return strategy_1.registerErrorStrategy; } });
+// 渲染
+var render_1 = require("./render");
+Object.defineProperty(exports, "renderErrorImage", { enumerable: true, get: function () { return render_1.renderErrorImage; } });
+// 发送
+var sender_1 = require("./sender");
+Object.defineProperty(exports, "sendErrorToAllMasters", { enumerable: true, get: function () { return sender_1.sendErrorToAllMasters; } });
+Object.defineProperty(exports, "sendErrorToMaster", { enumerable: true, get: function () { return sender_1.sendErrorToMaster; } });
+Object.defineProperty(exports, "sendErrorToTrigger", { enumerable: true, get: function () { return sender_1.sendErrorToTrigger; } });
+// 核心处理
+var handler_1 = require("./handler");
+Object.defineProperty(exports, "handleBusinessError", { enumerable: true, get: function () { return handler_1.handleBusinessError; } });
+Object.defineProperty(exports, "wrapWithErrorHandler", { enumerable: true, get: function () { return handler_1.wrapWithErrorHandler; } });
+// 工具函数
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "getPushTaskBotId", { enumerable: true, get: function () { return utils_1.getPushTaskBotId; } });
+Object.defineProperty(exports, "isPushTask", { enumerable: true, get: function () { return utils_1.isPushTask; } });
+Object.defineProperty(exports, "parseLogsToStructured", { enumerable: true, get: function () { return utils_1.parseLogsToStructured; } });
+Object.defineProperty(exports, "statBotId", { enumerable: true, get: function () { return utils_1.statBotId; } });

package/lib/karin/module/utils/ErrorHandler/render.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderErrorImage = void 0;
+const node_util_1 = __importDefault(require("node:util"));
+const Render_1 = require("../../../module/utils/Render");
+const module_1 = require("../../../module");
+const amagiClient_1 = require("../../../module/utils/amagiClient");
+/**
+ * 把 amagi 的 v7 错误摊成模板能直接印的一块。
+ *
+ * 非 amagi 异常返回 `undefined` —— 模板据此整块不渲染，而不是印一排空值。
+ * @param error - 捕获的异常
+ * @returns v7 分层错误信息，或 `undefined`
+ */
+const amagiDetailOf = (error) => {
+    if (!(error instanceof amagiClient_1.AmagiError))
+        return undefined;
+    const { meta } = error.envelope;
+    return {
+        kind: error.kind,
+        code: error.amagiCode,
+        reason: error.reason,
+        retryable: error.retryable,
+        platformCode: error.rawError.platform?.code,
+        httpStatus: error.httpStatus,
+        requestId: meta?.requestId,
+        attempts: meta?.attempts,
+        durationMs: meta?.durationMs,
+        issues: error.issues,
+        // 逐个请求的明细。amagi 只在 debug: true 时填，封装层常开着
+        trace: meta?.trace
+    };
+};
+/**
+ * 取 amagi 失败信封里记的平台名。
+ * @param error - 捕获的异常
+ * @returns 平台名，非 amagi 异常时为 `undefined`
+ */
+const amagiPlatformOf = (error) => {
+    if (!(error instanceof amagiClient_1.AmagiError))
+        return undefined;
+    return error.envelope.meta?.platform;
+};
+/**
+ * 自有属性的转储（`util.inspect`，带 ANSI）。
+ *
+ * 三样东西不进转储：`stack`（调用帧在上面的「错误堆栈」一节已经有结构高亮的那份）、
+ * `message` 与 `name`（栈首行就是 `名字: message`）。剩下的是调用点或上游挂上的
+ * 数据：Node 的 `errno` / `syscall`、三方库的响应体、OneBot 的 `cause`（`retcode`
+ * / `wording`）—— 这些堆栈里一个字都没有，是转储存在的全部理由。
+ *
+ * 一个都不剩就返回 `undefined`：引擎抛的 `TypeError: Cannot read properties of
+ * null` 只有 message，再来一块空转储没有意义。
+ *
+ * `cause` 链原样保留 —— 它的帧在上层栈里恰好被 `... N lines matching cause stack
+ * trace ...` 省略掉了，属于补充而非重复。
+ * @param error - 捕获的异常
+ * @returns 供模板渲染的转储文本，没有额外信息时为 `undefined`
+ */
+const dumpOf = (error) => {
+    const source = error;
+    const skip = new Set(['stack', 'message', 'name']);
+    const own = {};
+    for (const key of Object.getOwnPropertyNames(error)) {
+        if (skip.has(key))
+            continue;
+        try {
+            own[key] = source[key];
+        }
+        catch {
+            // 取值就抛的 getter（罕见）跳过，别让转储把渲染带崩
+        }
+    }
+    if (Object.keys(own).length === 0)
+        return undefined;
+    return (node_util_1.default
+        .inspect(own, { depth: 10, colors: true, breakLength: 120, showHidden: true })
+        // oxlint-disable-next-line no-control-regex
+        .replace(/\x1b\[90m/g, '\x1b[90;2m')
+        // oxlint-disable-next-line no-control-regex
+        .replace(/\x1b\[32m/g, '\x1b[31m'));
+};
+/**
+ * 错误堆栈与对象转储：调用帧一律走纯文本，交给模板按结构上色。
+ *
+ * 对 `AmagiError` 做 `util.inspect(error, { depth: 10, showHidden: true })` 会把
+ * 同一份数据打印四遍 —— message 一遍、`showHidden` 把 message 当自有属性再打一遍
+ * （连 ANSI 转义都成了字面量）、`rawError` 一遍、`envelope` 又一遍，实测 118 行里
+ * 只有 7 行是调用帧，`trace` 里那条上百字符的签名 URL 出现两次。这些字段现在由
+ * 「解析库错误诊断」那一节单独渲染，堆栈只需要回答「从哪儿抛的」。
+ *
+ * 非 amagi 异常同样只把帧交给堆栈一节：`error.stack` 本身就是纯文本，模板据此按
+ * 结构上色（整对象转储一并塞进去的话，那些帧会掉进 ANSI 解析器里渲染成一片单色），
+ * 自有属性另走 {@link dumpOf} —— 上游协议实现那一层（OneBot 的 retcode/wording、
+ * Node 的 errno/syscall）没有调用栈，只能靠它呈现。
+ * @param error - 捕获的异常
+ * @param override - 调用方显式指定的堆栈文本
+ * @returns 纯文本堆栈；非 amagi 异常且确有 message / name 之外的自有属性时，附带转储
+ */
+/**
+ * 堆栈和转储都**截断**。
+ *
+ * 实测：不截断时错误卡片能渲染成 2880×40000（45MB）—— 光渲染要 20 秒，
+ * 而这么大的图 QQ 必然拒收，等于「报错本身也发不出来」，用户什么都看不到。
+ * 卡片只需要让人一眼看出错在哪，前几千字符足够，完整内容仍在日志里。
+ */
+const MAX_STACK_CHARS = 4000;
+const MAX_DUMP_CHARS = 4000;
+const truncateText = (text, limit) => {
+    const value = String(text ?? '');
+    if (value.length <= limit)
+        return value;
+    return value.slice(0, limit) + '\n…（已截断，完整内容见日志；原文共 ' + value.length + ' 字符）';
+};
+const stackPartsOf = (error, override) => {
+    if (override)
+        return { stack: truncateText(override, MAX_STACK_CHARS) };
+    if (error instanceof amagiClient_1.AmagiError)
+        return { stack: truncateText(error.stack ?? error.message, MAX_STACK_CHARS) };
+    return { stack: truncateText(error.stack ?? error.message, MAX_STACK_CHARS), dump: truncateText(dumpOf(error), MAX_DUMP_CHARS) };
+};
+/**
+ * 渲染错误图片
+ *
+ * @param ctx - 错误处理上下文
+ * @param opts - 渲染选项，可覆盖默认值
+ * @returns 渲染后的图片元素数组
+ *
+ * @remarks
+ * 使用 `other/handlerError` 模板渲染错误信息图片，
+ * 包含错误详情、日志、触发命令、版本信息等
+ *
+ * @example
+ * ```ts
+ * const img = await renderErrorImage(ctx, {
+ *   platform: 'bilibili',
+ *   errorName: 'RiskControl',
+ *   errorMessage: '风控验证'
+ * })
+ * await event.reply(img)
+ * ```
+ */
+const renderErrorImage = async (ctx, opts = {}) => {
+    const { error, options, logs, event, buildMetadata, adapterInfo } = ctx;
+    const amagi = amagiDetailOf(error);
+    const { stack, dump } = stackPartsOf(error, opts.stack);
+    return (0, module_1.Render)(event, 'other/handlerError', {
+        type: 'business_error',
+        // amagi 的失败信封自带 meta.platform，比调用点顺手传的更准；
+        // 小红书的报错原先一律落到 system，就是因为这里没人传
+        platform: opts.platform ?? amagiPlatformOf(error) ?? 'system',
+        error: {
+            // 这几个字段模板里会直接做字符串处理（例如 version.startsWith），
+            // 取不到值时给空串，避免错误卡片自己再崩一次
+            message: String(opts.errorMessage || error?.message || '未知错误'),
+            name: String(opts.errorName || error?.name || 'Error'),
+            stack: stack ?? '',
+            dump: dump ?? '',
+            businessName: options?.businessName ?? ''
+        },
+        amagi,
+        method: options.businessName,
+        timestamp: new Date().toISOString(),
+        logs: logs?.slice().reverse(),
+        triggerCommand: event?.msg || '未知命令或处于非消息环境',
+        frameworkVersion: module_1.Root.karinVersion,
+        // 和主布局用同一份 logo（跨模块导入以免又出现「旧头像」）
+        frameworkLogo: (0, Render_1.resolveFrameLogo)(),
+        pluginVersion: module_1.Root.pluginVersion,
+        buildTime: buildMetadata?.buildTime ? (0, module_1.formatBuildTime)(buildMetadata.buildTime) : undefined,
+        commitHash: buildMetadata?.commitHash,
+        // 之前这里可能传 undefined，模板读 adapterInfo.version.startsWith 直接 SSR 崩掉
+        adapterInfo: adapterInfo ?? { name: '未知适配器', version: '' },
+        isVerification: opts.isVerification,
+        verificationUrl: opts.verificationUrl,
+        share_url: opts.share_url
+    });
+};
+exports.renderErrorImage = renderErrorImage;

package/lib/karin/module/utils/ErrorHandler/sender.js

@@ -0,0 +1,206 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendErrorToAdmins = exports.sendErrorToAllMasters = exports.sendErrorToMaster = exports.sendErrorToTrigger = void 0;
+const node_karin_1 = __importStar(require("../../../../compat/node-karin.js"));
+const bot_1 = require("../bot");
+const Config_1 = require("../Config");
+const utils_1 = require("./utils");
+/**
+ * 发送错误图片给触发者
+ *
+ * @param ctx - 错误处理上下文
+ * @param img - 渲染后的错误图片
+ *
+ * @remarks
+ * 仅当配置 `errorLogSendTo` 包含 `'trigger'` 且存在 event 时发送
+ */
+const sendErrorToTrigger = async (ctx, img) => {
+    const { event, options } = ctx;
+    if (!event)
+        return;
+    if ((0, utils_1.isPushTask)(event, options.businessName))
+        return;
+    if (!Config_1.Config.app.errorLogSendTo.some((item) => item === 'trigger'))
+        return;
+    try {
+        await event.reply(img);
+    }
+    catch (err) {
+        node_karin_1.logger.error(`[ErrorHandler] 发送错误消息给触发者失败: ${err}`);
+    }
+};
+exports.sendErrorToTrigger = sendErrorToTrigger;
+/**
+ * 发送错误图片给单个主人
+ *
+ * @param ctx - 错误处理上下文
+ * @param img - 渲染后的错误图片
+ * @param customPrefix - 自定义消息前缀（可选）
+ *
+ * @remarks
+ * 发送给除 `'console'` 外的第一个主人，
+ * 仅当配置 `errorLogSendTo` 包含 `'master'` 时发送
+ *
+ * @example
+ * ```ts
+ * const img = await renderErrorImage(ctx)
+ * await sendErrorToMaster(ctx, img, '自定义前缀消息')
+ * ```
+ */
+const sendErrorToMaster = async (ctx, img, customPrefix) => {
+    const { options, event } = ctx;
+    if (!Config_1.Config.app.errorLogSendTo.some((item) => item === 'master'))
+        return;
+    const isPush = (0, utils_1.isPushTask)(event, options.businessName);
+    const target = await resolveSingleMasterTarget(event, isPush);
+    if (!target)
+        return;
+    try {
+        const prefix = customPrefix || (await buildErrorPrefix(ctx, isPush, target.botId));
+        await node_karin_1.default.sendMaster(target.botId, target.master, [node_karin_1.segment.text(prefix), ...img]);
+    }
+    catch (err) {
+        node_karin_1.logger.error(`[ErrorHandler] 发送错误消息给主人失败: ${err}`);
+    }
+};
+exports.sendErrorToMaster = sendErrorToMaster;
+/**
+ * 发送错误图片给所有主人
+ *
+ * @param ctx - 错误处理上下文
+ * @param img - 渲染后的错误图片
+ * @param customPrefix - 自定义消息前缀（可选）
+ *
+ * @remarks
+ * 发送给所有主人（排除 `'console'`），
+ * 仅当配置 `errorLogSendTo` 包含 `'allMasters'` 时发送，
+ * 内部会去重避免重复发送
+ *
+ * @example
+ * ```ts
+ * const img = await renderErrorImage(ctx)
+ * await sendErrorToAllMasters(ctx, img)
+ * ```
+ */
+const sendErrorToAllMasters = async (ctx, img, customPrefix) => {
+    const { options, event } = ctx;
+    if (!Config_1.Config.app.errorLogSendTo.some((item) => item === 'allMasters'))
+        return;
+    const isPush = (0, utils_1.isPushTask)(event, options.businessName);
+    const targets = await resolveAllMasterTargets(event, isPush);
+    if (targets.length === 0)
+        return;
+    const prefix = customPrefix || (await buildErrorPrefix(ctx, isPush, targets[0].botId));
+    const notifiedSet = new Set();
+    for (const target of targets) {
+        const key = `${target.botId}:${target.master}`;
+        if (notifiedSet.has(key))
+            continue;
+        try {
+            await node_karin_1.default.sendMaster(target.botId, target.master, [node_karin_1.segment.text(prefix), ...img]);
+            notifiedSet.add(key);
+            node_karin_1.logger.debug(`[ErrorHandler] 已发送错误消息给主人: ${target.master} (via ${target.botId})`);
+        }
+        catch (err) {
+            node_karin_1.logger.error(`[ErrorHandler] 发送错误消息给主人 (${target.master}) 失败: ${err}`);
+        }
+    }
+};
+exports.sendErrorToAllMasters = sendErrorToAllMasters;
+/**
+ * 发送错误图片给**管理员**（权限等级 > 4）。
+ *
+ * Koishi 这边「权限 > 4」就是主人（master）这一档，所以实现上直接复用「发给所有主人」，
+ * 只是配置取值叫 `'admin'`、面板上显示「管理员（权限等级 > 4）」；旧的 `'allMasters'` 仍然兼容。
+ */
+const sendErrorToAdmins = async (ctx, img, customPrefix) => {
+    const list = Config_1.Config.app.errorLogSendTo;
+    if (!list.some((item) => item === 'admin' || item === 'allMasters'))
+        return;
+    return await (0, exports.sendErrorToAllMasters)(ctx, img, customPrefix);
+};
+exports.sendErrorToAdmins = sendErrorToAdmins;
+/**
+ * 解析单个主人目标
+ *
+ * @param event - 错误事件上下文
+ * @param isPush - 是否为推送任务
+ *
+ * @returns
+ */
+const resolveSingleMasterTarget = async (event, isPush) => {
+    if (isPush) {
+        const bindings = await (0, bot_1.getReachableMasterBots)();
+        const matched = bindings[0];
+        if (!matched)
+            return undefined;
+        return {
+            master: matched.master,
+            botId: matched.bot.account.selfId
+        };
+    }
+    const master = node_karin_1.config.master().find((item) => item !== 'console');
+    const botId = event?.bot?.account.selfId ?? event?.selfId;
+    if (!master || !botId)
+        return undefined;
+    return { master, botId };
+};
+const resolveAllMasterTargets = async (event, isPush) => {
+    const masters = node_karin_1.config.master().filter((item) => item !== 'console');
+    if (masters.length === 0)
+        return [];
+    if (isPush) {
+        const bindings = await (0, bot_1.getReachableMasterBots)(masters);
+        return bindings.map((item) => ({
+            master: item.master,
+            botId: item.bot.account.selfId
+        }));
+    }
+    const botId = event?.bot?.account.selfId ?? event?.selfId;
+    if (!botId)
+        return [];
+    return masters.map((master) => ({ master, botId }));
+};
+const buildErrorPrefix = async (ctx, isPush, botId) => {
+    const { options, event } = ctx;
+    if (isPush) {
+        return `${options.businessName} 任务执行出错\n请尽快解决以消除警告`;
+    }
+    const groupId = event && 'groupId' in event ? event.groupId : '';
+    const groupInfo = await node_karin_1.default.getBot(botId)?.getGroupInfo(groupId);
+    const groupName = groupInfo?.groupName || '未知';
+    return `群：${groupName}(${groupId})\n${options.businessName} 任务执行出错\n请尽快解决以消除警告`;
+};

package/lib/karin/module/utils/ErrorHandler/strategy.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStrategies = exports.registerErrorStrategy = void 0;
+const node_karin_1 = require("../../../../compat/node-karin.js");
+/**
+ * 策略注册表
+ * @internal
+ */
+const strategies = [];
+/**
+ * 注册错误处理策略
+ *
+ * @param strategy - 要注册的错误处理策略
+ *
+ * @remarks
+ * 策略按注册顺序依次匹配，匹配成功后执行对应的处理函数
+ *
+ * @example
+ * ```ts
+ * registerErrorStrategy({
+ *   name: 'MyStrategy',
+ *   match: (ctx) => ctx.error instanceof MyError,
+ *   handle: async (ctx) => {
+ *     // 处理逻辑
+ *     return 'handled'
+ *   }
+ * })
+ * ```
+ */
+const registerErrorStrategy = (strategy) => {
+    strategies.push(strategy);
+    node_karin_1.logger.debug(`[ErrorHandler] 注册策略: ${strategy.name}`);
+};
+exports.registerErrorStrategy = registerErrorStrategy;
+/**
+ * 获取所有已注册的策略
+ *
+ * @returns 只读的策略数组
+ */
+const getStrategies = () => strategies;
+exports.getStrategies = getStrategies;

package/lib/karin/module/utils/ErrorHandler/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });