evolclaw 2.4.0 → 2.5.1

package/dist/index.js

@@ -1,7 +1,7 @@
 import { ClaudeSessionFileAdapter } from './core/session/adapters/claude-session-file-adapter.js';
 import { CodexSessionFileAdapter } from './core/session/adapters/codex-session-file-adapter.js';
 import { GeminiSessionFileAdapter } from './core/session/adapters/gemini-session-file-adapter.js';
-import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig, isOwner, validateConfigIntegrity, validateChannelInstanceNames, getOwner } from './config.js';
+import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig, isOwner, isAdmin, validateConfigIntegrity, validateChannelInstanceNames, getOwner } from './config.js';
 import { SessionManager } from './core/session/session-manager.js';
 import { ClaudeAgentPlugin } from './agents/claude-runner.js';
 import { CodexAgentPlugin } from './agents/codex-runner.js';
@@ -9,6 +9,9 @@ import { GeminiAgentPlugin } from './agents/gemini-runner.js';
 import { FeishuChannelPlugin } from './channels/feishu.js';
 import { WechatChannelPlugin } from './channels/wechat.js';
 import { AUNChannelPlugin } from './channels/aun.js';
+import { DingtalkChannelPlugin } from './channels/dingtalk.js';
+import { QQBotChannelPlugin } from './channels/qqbot.js';
+import { WecomChannelPlugin } from './channels/wecom.js';
 import { MessageProcessor } from './core/message/message-processor.js';
 import { MessageQueue } from './core/message/message-queue.js';
 import { MessageBridge } from './core/message/message-bridge.js';
@@ -47,6 +50,7 @@ async function main() {
     ensureDataDirs();
     // 加载配置
     const config = loadConfig();
+    const paths = resolvePaths();
     // 配置完整性校验
     const integrity = validateConfigIntegrity(config);
     if (!integrity.valid) {
@@ -68,9 +72,7 @@ async function main() {
     // 统计收集器（近 1 小时滚动统计）
     const statsCollector = new StatsCollector(eventBus);
     // 初始化数据库（带 ownerResolver）
-    const sessionManager = new SessionManager(undefined, eventBus, (channel, userId) => {
-        return isOwner(config, channel, userId);
-    });
+    const sessionManager = new SessionManager(undefined, eventBus, (channel, userId) => isOwner(config, channel, userId), (channel, userId) => isAdmin(config, channel, userId));
     logger.info('✓ Database initialized');
     // 注册会话文件适配器（Claude / Codex 各自的会话文件操作）
     sessionManager.registerFileAdapter(new ClaudeSessionFileAdapter());
@@ -118,6 +120,9 @@ async function main() {
     channelLoader.register(new FeishuChannelPlugin());
     channelLoader.register(new WechatChannelPlugin());
     channelLoader.register(new AUNChannelPlugin());
+    channelLoader.register(new DingtalkChannelPlugin());
+    channelLoader.register(new QQBotChannelPlugin());
+    channelLoader.register(new WecomChannelPlugin());
     const channelInstances = await channelLoader.createAll(config);
     logger.info(`✓ Created ${channelInstances.length} channel instance(s)`);
     // 启动迁移：将 sessions.channel 从 channelType 回填为实例名
@@ -163,13 +168,14 @@ async function main() {
     messageQueue.setEventBus(eventBus);
     // 回填 messageQueue 引用
     cmdHandler.setMessageQueue(messageQueue);
+    processor.setMessageQueue(messageQueue);
     // 默认策略
     const defaultPolicy = {
-        canSwitchProject: (chatType, role) => chatType === 'private' || role === 'owner',
-        canListProjects: (chatType, role) => chatType === 'private' || role === 'owner',
+        canSwitchProject: (chatType, role) => chatType === 'private' ? (role === 'owner' || role === 'admin') : role === 'owner',
+        canListProjects: (chatType, role) => chatType === 'private' ? (role === 'owner' || role === 'admin') : role === 'owner',
         canCreateSession: () => true,
-        canDeleteSession: (chatType, role) => chatType === 'private' || role === 'owner',
-        canImportCliSession: (chatType, role) => chatType === 'private' || role === 'owner',
+        canDeleteSession: (chatType, role) => chatType === 'private' ? (role === 'owner' || role === 'admin') : role === 'owner',
+        canImportCliSession: (chatType, role) => chatType === 'private' ? (role === 'owner' || role === 'admin') : role === 'owner',
         messagePrefix: () => '',
         showMiddleResult: () => true,
         showIdleMonitor: () => true,
@@ -220,9 +226,6 @@ async function main() {
                 replyToMessageId: replyContext?.replyToMessageId,
                 replyInThread: replyContext?.replyInThread,
             }), inst.adapter, channelType);
-            inst.channel.onRecall?.((messageId) => {
-                msgBridge.cancel(messageId);
-            });
         }
         if (channelType === 'wechat') {
             // 注入 EventBus（用于 channel:health 事件）
@@ -256,6 +259,38 @@ async function main() {
                 });
             }), (channelId, text, replyContext) => inst.channel.sendMessage(channelId, text, replyContext), inst.adapter, channelType);
         }
+        if (channelType === 'dingtalk') {
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async (event) => {
+                handler({
+                    channel: channelType,
+                    channelId: event.channelId,
+                    content: event.content,
+                    images: event.images,
+                    chatType: event.chatType || 'private',
+                    peerId: event.peerId || '',
+                    peerName: event.peerName,
+                    messageId: event.messageId,
+                });
+            }), (channelId, text) => inst.channel.sendMessage(channelId, text), inst.adapter, channelType);
+        }
+        if (channelType === 'qqbot') {
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async (event) => {
+                handler({
+                    channel: channelType,
+                    channelId: event.channelId,
+                    content: event.content,
+                    images: event.images,
+                    chatType: event.chatType || 'private',
+                    peerId: event.peerId || '',
+                    peerName: event.peerName,
+                    messageId: event.messageId,
+                });
+            }), (channelId, text) => inst.channel.sendMessage(channelId, text), inst.adapter, channelType);
+        }
+        // 通用：撤回消息 → 中断执行中任务（所有支持 onRecall 的渠道）
+        inst.channel.onRecall?.((messageId) => {
+            msgBridge.cancel(messageId);
+        });
     }
     // ── 连接所有渠道 ──
     const connected = await channelLoader.connectAll(channelInstances);
@@ -394,7 +429,7 @@ async function main() {
     const readySignalPath = resolvePaths().readySignal;
     fs.writeFileSync(readySignalPath, String(Date.now()));
     logger.info(`✓ Ready signal written: ${readySignalPath}`);
-    // IPC server — 供 CLI 查询实时状态
+    // IPC server — 供 CLI 查询实时状态 + Agent ctl 指令执行
     const ipcServer = new IpcServer(resolvePaths().socket, () => {
         const channels = {};
         const channelsByType = {};
@@ -424,7 +459,7 @@ async function main() {
                 avgResponseMs: snap.lastHour.avgResponseMs,
             },
         };
-    });
+    }, async (cmd, sessionId) => cmdHandler.handleCtl(cmd, sessionId));
     ipcServer.start();
     // 运行时配置文件监控
     const configPath = resolvePaths().config;

package/dist/ipc.js

@@ -4,10 +4,12 @@ import { logger } from './utils/logger.js';
 export class IpcServer {
     socketPath;
     getStatus;
+    commandExecutor;
     server = null;
-    constructor(socketPath, getStatus) {
+    constructor(socketPath, getStatus, commandExecutor) {
         this.socketPath = socketPath;
         this.getStatus = getStatus;
+        this.commandExecutor = commandExecutor;
     }
     start() {
         // Remove stale socket file
@@ -17,7 +19,7 @@ export class IpcServer {
         catch { }
         this.server = net.createServer((conn) => {
             let buf = '';
-            conn.on('data', (data) => {
+            conn.on('data', async (data) => {
                 buf += data.toString();
                 // Simple newline-delimited JSON protocol
                 const idx = buf.indexOf('\n');
@@ -27,7 +29,7 @@ export class IpcServer {
                 buf = buf.slice(idx + 1);
                 try {
                     const cmd = JSON.parse(line);
-                    const response = this.handleCommand(cmd);
+                    const response = await this.handleCommand(cmd);
                     conn.end(JSON.stringify(response) + '\n');
                 }
                 catch {
@@ -58,12 +60,20 @@ export class IpcServer {
         }
         catch { }
     }
-    handleCommand(cmd) {
+    async handleCommand(cmd) {
         switch (cmd.type) {
             case 'status':
                 return this.getStatus();
             case 'ping':
                 return { pong: true, pid: process.pid };
+            case 'ctl': {
+                if (!this.commandExecutor)
+                    return { ok: false, error: 'ctl not configured' };
+                const { cmd: slashCmd, sessionId } = cmd;
+                if (!slashCmd || !sessionId)
+                    return { ok: false, error: 'missing cmd or sessionId' };
+                return await this.commandExecutor(slashCmd, sessionId);
+            }
             default:
                 return { error: `unknown command: ${cmd.type}` };
         }

package/dist/templates/skills.md

@@ -0,0 +1,64 @@
+---
+name: evolclaw-ctl
+version: 1.0.0
+description: EvolClaw 运行时自管理指令，仅在 evolclaw 托管环境中可用
+trigger: 用户询问或需要切换模型、调整推理强度、查看运行状态、压缩上下文、检查通道健康、管理权限模式、发送文件、重启服务、重连渠道时
+---
+
+# EvolClaw Ctl
+
+通过 `evolclaw ctl <command> [args]` 管理运行时配置。仅在 evolclaw 托管环境中可用（`EVOLCLAW_SESSION_ID` 已设置）。
+
+## 可用指令
+
+### 查询类（所有用户）
+- `evolclaw ctl help` — 显示帮助
+- `evolclaw ctl status` — 显示会话状态
+- `evolclaw ctl check` — 检查渠道健康状态
+
+### 配置类（管理员）
+- `evolclaw ctl model` — 查看当前模型和可选列表
+- `evolclaw ctl model <model-id>` — 切换模型（如 `opus`, `sonnet`, `haiku`）
+- `evolclaw ctl effort` — 查看当前推理强度
+- `evolclaw ctl effort <low|medium|high|max>` — 切换推理强度
+- `evolclaw ctl compact` — 压缩当前会话上下文
+
+### 权限类
+- `evolclaw ctl perm` — 查看当前权限模式（管理员）
+- `evolclaw ctl perm <mode>` — 切换权限模式（仅 owner）
+
+### 运维类（仅 owner）
+- `evolclaw ctl activity <all|dm|owner|none>` — 查看/控制中间输出显示模式
+- `evolclaw ctl send [channel] <path>` — 发送项目内文件（仅限项目目录内）
+- `evolclaw ctl restart` — 重启服务（慎用：中断所有会话）
+- `evolclaw ctl restart <channel>` — 重连指定渠道（管理员可用）
+- `evolclaw ctl agentmd` — 查看当前 agent.md
+- `evolclaw ctl agentmd put` — 发布本地 agent.md
+- `evolclaw ctl agentmd set <内容>` — 直接设置 agent.md 内容
+
+## 使用示例
+
+```bash
+# 查看当前模型
+evolclaw ctl model
+
+# 切换到 opus
+evolclaw ctl model opus
+
+# 降低推理强度以加快响应
+evolclaw ctl effort low
+
+# 压缩上下文
+evolclaw ctl compact
+
+# 查看服务状态
+evolclaw ctl status
+```
+
+## 注意事项
+
+- 仅在 evolclaw 托管环境中可用（EVOLCLAW_SESSION_ID 环境变量已设置时）
+- 权限继承当前会话用户的角色（owner / admin / guest）
+- `compact` 不能在当前会话处理消息期间执行
+- `send` 只能发送项目目录下的文件
+- `restart` 会中断当前所有会话，谨慎使用

package/dist/utils/error-dict.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import { logger } from './logger.js';
+let rules = [];
+/**
+ * 加载错误字典文件
+ * 文件不存在或格式错误 → 警告日志，rules = []（不影响启动）
+ */
+export function loadErrorDict(dictPath) {
+    try {
+        if (!fs.existsSync(dictPath)) {
+            logger.debug('[error-dict] 字典文件不存在，使用内置规则: %s', dictPath);
+            rules = [];
+            return;
+        }
+        const raw = JSON.parse(fs.readFileSync(dictPath, 'utf-8'));
+        if (!Array.isArray(raw?.rules)) {
+            logger.warn('[error-dict] 字典格式错误（缺少 rules 数组），忽略: %s', dictPath);
+            rules = [];
+            return;
+        }
+        // 校验每条规则的必填字段
+        rules = raw.rules.filter((r) => {
+            if (!r.id || !r.match || !r.action) {
+                logger.warn('[error-dict] 跳过无效规则（缺少 id/match/action）: %o', r);
+                return false;
+            }
+            if (!['retry', 'stop', 'ignore'].includes(r.action)) {
+                logger.warn('[error-dict] 跳过无效 action "%s": %s', r.action, r.id);
+                return false;
+            }
+            return true;
+        });
+        logger.info('[error-dict] 已加载 %d 条规则: %s', rules.length, dictPath);
+    }
+    catch (err) {
+        logger.warn('[error-dict] 加载失败: %s — %s', dictPath, err.message);
+        rules = [];
+    }
+}
+/** 运行时重新加载（供 /reload 命令使用） */
+export function reloadErrorDict(dictPath) {
+    loadErrorDict(dictPath);
+}
+/**
+ * 匹配错误消息，返回首条命中的规则
+ * @param errorMessage 已 toLowerCase 的错误消息
+ */
+export function matchErrorRule(errorMessage) {
+    for (const rule of rules) {
+        if (errorMessage.includes(rule.match.toLowerCase())) {
+            return rule;
+        }
+    }
+    return null;
+}
+/** 获取当前已加载的规则数量（供测试和状态查询使用） */
+export function getLoadedRuleCount() {
+    return rules.length;
+}
+/** 重置规则（仅供测试使用） */
+export function _resetRules() {
+    rules = [];
+}

package/dist/utils/error-utils.js

@@ -1,3 +1,7 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { logger } from './logger.js';
 export var ErrorType;
 (function (ErrorType) {
     ErrorType["SDK_TIMEOUT"] = "sdk_timeout";
@@ -62,32 +66,152 @@ export function isInfraError(subtype, terminalReason) {
 export function prefixErrorType(prefix, errorType) {
     return `${prefix}:${errorType}`;
 }
+// ── 错误字典 ──────────────────────────────────────────────────────────
+const VALID_ACTIONS = new Set(['retry', 'stop', 'ignore']);
+let _dictPath = null;
+let _rules = [];
+let _lastMtime = 0;
+function getDictPath() {
+    if (!_dictPath) {
+        _dictPath = path.join(resolvePaths().dataDir, 'error-dict.json');
+    }
+    return _dictPath;
+}
+/** 校验单条规则，返回错误原因（null = 合法） */
+function validateRule(r, index) {
+    if (!r || typeof r !== 'object')
+        return `rules[${index}]: 不是对象`;
+    if (!r.id || typeof r.id !== 'string')
+        return `rules[${index}]: 缺少 id 或类型不是 string`;
+    if (!r.match || typeof r.match !== 'string')
+        return `rules[${index}] (${r.id}): 缺少 match 或类型不是 string`;
+    if (!VALID_ACTIONS.has(r.action))
+        return `rules[${index}] (${r.id}): action 无效 "${r.action}"，允许值: retry/stop/ignore`;
+    if (r.type !== undefined && typeof r.type !== 'string')
+        return `rules[${index}] (${r.id}): type 类型不是 string`;
+    if (r.message !== undefined && typeof r.message !== 'string')
+        return `rules[${index}] (${r.id}): message 类型不是 string`;
+    return null;
+}
+/**
+ * 刷新字典：检查文件 mtime，有变化则重新读取并校验。
+ * 校验不通过 → 不更新内存数据，记录告警日志。
+ */
+function refreshDict() {
+    const dictPath = getDictPath();
+    let stat;
+    try {
+        stat = fs.statSync(dictPath);
+    }
+    catch {
+        // 文件不存在 → 清空规则（首次）或保持不变（之前有数据且文件被删）
+        if (_rules.length > 0) {
+            logger.warn('[error-dict] 字典文件已删除，清空规则: %s', dictPath);
+            _rules = [];
+            _lastMtime = 0;
+        }
+        return;
+    }
+    const mtime = stat.mtimeMs;
+    if (mtime === _lastMtime)
+        return; // 文件未变化，跳过
+    // 文件有变化，尝试加载
+    try {
+        const content = fs.readFileSync(dictPath, 'utf-8');
+        let raw;
+        try {
+            raw = JSON.parse(content);
+        }
+        catch (parseErr) {
+            logger.warn('[error-dict] JSON 解析失败，保留原有规则: %s — %s', dictPath, parseErr.message);
+            _lastMtime = mtime; // 标记已检查，避免重复读取
+            return;
+        }
+        if (!raw || typeof raw !== 'object' || !Array.isArray(raw.rules)) {
+            logger.warn('[error-dict] 字典格式错误（缺少 rules 数组），保留原有规则: %s', dictPath);
+            _lastMtime = mtime;
+            return;
+        }
+        // 逐条校验
+        const errors = [];
+        for (let i = 0; i < raw.rules.length; i++) {
+            const err = validateRule(raw.rules[i], i);
+            if (err)
+                errors.push(err);
+        }
+        if (errors.length > 0) {
+            logger.warn('[error-dict] 字典校验失败（%d 条错误），保留原有规则:\n  %s', errors.length, errors.join('\n  '));
+            _lastMtime = mtime;
+            return;
+        }
+        // 全部通过，更新
+        _rules = raw.rules;
+        _lastMtime = mtime;
+        logger.info('[error-dict] 已加载 %d 条规则: %s', _rules.length, dictPath);
+    }
+    catch (err) {
+        logger.warn('[error-dict] 读取失败，保留原有规则: %s — %s', dictPath, err.message);
+    }
+}
+/**
+ * 匹配错误消息，返回首条命中的规则。
+ * 每次调用自动检查文件变化（基于 mtime，无变化零开销）。
+ * @param errorMessage 已 toLowerCase 的错误消息
+ */
+export function matchErrorRule(errorMessage) {
+    refreshDict();
+    for (const rule of _rules) {
+        if (errorMessage.includes(rule.match.toLowerCase())) {
+            return rule;
+        }
+    }
+    return null;
+}
+/** 获取当前已加载的规则数量（供测试和状态查询使用） */
+export function getLoadedRuleCount() {
+    refreshDict();
+    return _rules.length;
+}
+/** 重置字典状态（仅供测试使用） */
+export function _resetDict() {
+    _rules = [];
+    _lastMtime = 0;
+    _dictPath = null;
+}
+/** 设置字典文件路径（仅供测试使用） */
+export function _setDictPath(p) {
+    _dictPath = p;
+    _lastMtime = 0; // 强制下次刷新
+}
+// ── 错误分类 / 重试 / 消息 ──────────────────────────────────────────
 export function classifyError(error) {
     const msg = (error?.message || '').toLowerCase();
-    if (msg.includes('上下文过长') || msg.includes('context too long')
-        || msg.includes('context_length_exceeded') || msg.includes('context_compact_failed')
-        || msg.includes('prompt is too long') || msg.includes('context limit')) {
+    // 字典优先 — 命中则直接返回
+    const rule = matchErrorRule(msg);
+    if (rule) {
+        if (rule.type)
+            return rule.type;
+        if (rule.action === 'retry')
+            return ErrorType.API_ERROR;
+        if (rule.action === 'stop')
+            return ErrorType.AUTH_ERROR;
+        return ErrorType.UNKNOWN;
+    }
+    // 内置兜底规则（结构性、稳定的错误模式）
+    if (msg.includes('context_length_exceeded') || msg.includes('context_compact_failed')
+        || msg.includes('context limit')) {
         return ErrorType.CONTEXT_TOO_LONG;
     }
-    // 认证错误（401 / Invalid API Key / key_not_found）— 不可恢复，不应触发安全模式
-    if (msg.includes('401') || msg.includes('invalid api key') || msg.includes('key_not_found')
-        || msg.includes('authentication_error') || msg.includes('failed to authenticate')) {
+    if (msg.includes('401') || msg.includes('authentication_error')) {
         return ErrorType.AUTH_ERROR;
     }
     if (msg.includes('timeout') || msg.includes('etimedout')) {
         return ErrorType.SDK_TIMEOUT;
     }
-    if (msg.includes('5') && (msg.includes('00') || msg.includes('02') || msg.includes('03') || msg.includes('04'))) {
-        return ErrorType.API_ERROR;
-    }
-    // "X is not valid JSON" — API 返回了非 JSON 响应（如算力池切换提示），属于 API 错误
-    if (msg.includes('is not valid json')) {
-        return ErrorType.API_ERROR;
-    }
-    if (msg.includes('enoent') || msg.includes('corrupt') || msg.includes('invalid json')) {
+    if (msg.includes('enoent') || msg.includes('corrupt')) {
         return ErrorType.FILE_CORRUPT;
     }
-    if (msg.includes('stream') || msg.includes('aborted') || msg.includes('interrupted')) {
+    if (msg.includes('aborted') || msg.includes('interrupted')) {
         return ErrorType.STREAM_ERROR;
     }
     return ErrorType.UNKNOWN;
@@ -100,26 +224,16 @@ export function classifyError(error) {
 export function isRetryableError(error) {
     const msg = error?.message || String(error);
     const lower = msg.toLowerCase();
-    // 认证错误不可重试：重试不会恢复无效/缺失凭据
-    if (lower.includes('401')
-        || lower.includes('invalid api key')
-        || lower.includes('key_not_found')
-        || lower.includes('authentication_error')
-        || lower.includes('failed to authenticate')
-        || (lower.includes('api error: 403') && (lower.includes('auth') || lower.includes('key') || lower.includes('token')))) {
-        return false;
+    // 字典优先 — 命中则直接返回
+    const rule = matchErrorRule(lower);
+    if (rule)
+        return rule.action === 'retry';
+    // 内置兜底规则（结构性错误码）
+    if (lower.includes('401') || lower.includes('authentication_error')) {
+        return false; // 认证错误不可重试
     }
-    if (msg.includes('API Error: 403'))
-        return true;
-    if (msg.includes('API Error: 429'))
-        return true;
-    if (msg.includes('API Error: 500'))
-        return true;
-    if (msg.includes('API Error: 502'))
-        return true;
-    if (msg.includes('API Error: 503'))
-        return true;
-    if (msg.includes('API Error: 504'))
+    // HTTP 5xx / 429 — 标准可重试状态码
+    if (/api error: (429|5\d{2})\b/.test(lower))
         return true;
     return false;
 }
@@ -148,34 +262,20 @@ export function getErrorMessage(error, terminalReason) {
     }
     // 回退到原有的错误消息匹配逻辑
     const msg = error?.message || String(error);
-    if (msg.includes('CONTEXT_COMPACT_FAILED')) {
+    // 字典优先 — 命中且有自定义消息则直接返回
+    const rule = matchErrorRule(msg.toLowerCase());
+    if (rule?.message)
+        return rule.message;
+    // 内置兜底规则（结构性错误）
+    if (msg.includes('CONTEXT_COMPACT_FAILED') || msg.includes('context_length_exceeded')
+        || msg.includes('Context limit')) {
         return '⚠️ 上下文过长，自动压缩失败，请手动输入 /compact 重试';
     }
-    if (msg.includes('上下文过长') || msg.includes('context too long') || msg.includes('context_length_exceeded')
-        || msg.includes('Prompt is too long') || msg.includes('Context limit')) {
-        return '⚠️ 上下文过长，自动压缩重试失败，请手动输入 /compact 重试';
-    }
-    if (msg.includes('API Error: 400')) {
-        return '❌ 请求格式错误，请检查输入内容';
-    }
-    if (msg.includes('401') || msg.includes('Invalid API key') || msg.includes('key_not_found')
-        || msg.includes('authentication_error')) {
+    if (msg.includes('401') || msg.includes('authentication_error')) {
         return '❌ API Key 无效，请检查密钥配置。使用 /status 查看当前配置';
     }
-    if (msg.includes('API Error: 500')) {
-        return '❌ API 服务暂时不可用，请稍后重试';
-    }
-    if (msg.includes('API Error: 403')) {
-        return '❌ API 认证失败，请检查密钥配置或稍后重试';
-    }
-    if (msg.includes('API Error: 429')) {
-        return '⚠️ 请求过于频繁，请稍后再试';
-    }
     if (msg.includes('timeout')) {
         return '⚠️ 请求超时，请重试';
     }
-    if (msg.includes('permission') || msg.includes('im:resource')) {
-        return '❌ 权限不足，请联系管理员配置应用权限';
-    }
     return '❌ 处理消息时出错，请稍后重试';
 }

package/dist/utils/format.js

@@ -0,0 +1,32 @@
+// ── Markdown → Plain Text ───────────────────────────────────────────────────
+export function markdownToPlainText(text) {
+    let result = text;
+    // Code blocks: strip fences, keep content
+    result = result.replace(/```[^\n]*\n?([\s\S]*?)```/g, (_, code) => code.trim());
+    // Images: remove entirely
+    result = result.replace(/!\[[^\]]*\]\([^)]*\)/g, '');
+    // Links: keep display text only
+    result = result.replace(/\[([^\]]+)\]\([^)]*\)/g, '$1');
+    // Tables: remove separator rows
+    result = result.replace(/^\|[\s:|-]+\|$/gm, '');
+    result = result.replace(/^\|(.+)\|$/gm, (_, inner) => inner.split('|').map(cell => cell.trim()).join('  '));
+    // Bold/italic
+    result = result.replace(/\*\*(.+?)\*\*/g, '$1');
+    result = result.replace(/\*(.+?)\*/g, '$1');
+    result = result.replace(/__(.+?)__/g, '$1');
+    result = result.replace(/_(.+?)_/g, '$1');
+    // Strikethrough
+    result = result.replace(/~~(.+?)~~/g, '$1');
+    // Inline code
+    result = result.replace(/`([^`]+)`/g, '$1');
+    // Headers
+    result = result.replace(/^#{1,6}\s+/gm, '');
+    // Blockquotes
+    result = result.replace(/^>\s?/gm, '');
+    // Horizontal rules
+    result = result.replace(/^[-*_]{3,}$/gm, '');
+    // List markers
+    result = result.replace(/^(\s*)[-*+]\s/gm, '$1');
+    result = result.replace(/^(\s*)\d+\.\s/gm, '$1');
+    return result.trim();
+}