evolcore 0.0.1 → 0.0.2

package/dist/channels/wechat.js

@@ -0,0 +1,817 @@
+import crypto from 'node:crypto';
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { logger } from '../utils/logger.js';
+import { sanitizeFileName, saveToUploads, safeFetch, bufferToInboundImage } from '../utils/media-cache.js';
+import { markdownToPlainText } from '../utils/markdown-to-plain-text.js';
+import { DEFAULT_FLUSH_DELAY_SECONDS } from '../types.js';
+import { formatItemsAsText } from '../core/message/items-formatter.js';
+import { initWelcomeManager, sendWelcomeIfNeeded } from '../utils/welcome.js';
+const CHANNEL_VERSION = '1.0.0';
+const ILINK_APP_ID = 'bot';
+// iLink-App-ClientVersion: major<<16 | minor<<8 | patch (uint32)
+const ILINK_APP_CLIENT_VERSION = String((1 << 16) | (0 << 8) | 0); // 1.0.0 = 65536
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+const DEFAULT_API_TIMEOUT_MS = 15_000;
+const DEFAULT_CONFIG_TIMEOUT_MS = 10_000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const BACKOFF_DELAY_MS = 30_000;
+const RETRY_DELAY_MS = 2_000;
+const TYPING_TICKET_TTL_MS = 5 * 60 * 1000; // 5 min cache
+const SESSION_EXPIRED_ERRCODE = -14;
+const SESSION_RETRY_DELAY_MS = 30_000; // 短暂停：30s 后重试一次
+const SESSION_PAUSE_DURATION_MS = 10 * 60 * 1000; // 长暂停：10 分钟
+const MSG_TYPE_USER = 1;
+const MSG_TYPE_BOT = 2;
+const MSG_ITEM_TEXT = 1;
+const MSG_ITEM_IMAGE = 2;
+const MSG_ITEM_VOICE = 3;
+const MSG_ITEM_FILE = 4;
+const MSG_ITEM_VIDEO = 5;
+const MSG_STATE_FINISH = 2;
+// ── CDN + AES ───────────────────────────────────────────────────────────────
+const CDN_BASE_URL = 'https://novac2c.cdn.weixin.qq.com/c2c';
+const MIME_MAP = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp',
+    '.mp4': 'video/mp4', '.mov': 'video/quicktime', '.avi': 'video/x-msvideo',
+    '.pdf': 'application/pdf', '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.zip': 'application/zip', '.rar': 'application/x-rar-compressed',
+    '.txt': 'text/plain', '.csv': 'text/csv', '.md': 'text/markdown',
+};
+// Exported for unit testing
+export function parseAesKey(aesKeyBase64) {
+    const decoded = Buffer.from(aesKeyBase64, 'base64');
+    if (decoded.length === 16)
+        return decoded;
+    if (decoded.length === 32 && /^[0-9a-fA-F]{32}$/.test(decoded.toString('ascii')))
+        return Buffer.from(decoded.toString('ascii'), 'hex');
+    throw new Error(`Invalid aes_key length: ${decoded.length}`);
+}
+// Exported for unit testing
+export function decryptAesEcb(ciphertext, key) {
+    const decipher = crypto.createDecipheriv('aes-128-ecb', key, null);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+// Exported for unit testing
+export function encryptAesEcb(plaintext, key) {
+    const cipher = crypto.createCipheriv('aes-128-ecb', key, null);
+    return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+async function downloadMedia(cdnMedia, hexKey) {
+    const aesKeyBase64 = hexKey
+        ? Buffer.from(hexKey, 'hex').toString('base64')
+        : cdnMedia.aes_key;
+    if (!cdnMedia.encrypt_query_param)
+        throw new Error('No encrypt_query_param');
+    const url = `${CDN_BASE_URL}/download?encrypted_query_param=${encodeURIComponent(cdnMedia.encrypt_query_param)}`;
+    const encrypted = await safeFetch(url);
+    if (!aesKeyBase64)
+        return encrypted; // 无 key = 明文
+    return decryptAesEcb(encrypted, parseAesKey(aesKeyBase64));
+}
+// ── Message Text Extraction ─────────────────────────────────────────────────
+function extractTextFromMessage(msg) {
+    if (!msg.item_list?.length)
+        return '';
+    for (const item of msg.item_list) {
+        if (item.type === MSG_ITEM_TEXT && item.text_item?.text) {
+            const text = item.text_item.text;
+            const ref = item.ref_msg;
+            if (!ref)
+                return text;
+            const parts = [];
+            if (ref.title)
+                parts.push(ref.title);
+            if (ref.message_item?.type === MSG_ITEM_TEXT && ref.message_item.text_item?.text) {
+                parts.push(ref.message_item.text_item.text);
+            }
+            if (!parts.length)
+                return text;
+            return `[引用: ${parts.join(' | ')}]\n${text}`;
+        }
+        if (item.type === MSG_ITEM_VOICE && item.voice_item?.text) {
+            return item.voice_item.text;
+        }
+    }
+    return '';
+}
+// ── WechatChannel ───────────────────────────────────────────────────────────
+export class WechatChannel {
+    agentAid;
+    channelName;
+    config;
+    messageHandler;
+    recallHandler;
+    abortController;
+    connected = false;
+    // 内部状态（不外泄到核心层）
+    contextTokenCache = new Map();
+    typingTicketCache = new Map();
+    getUpdatesBuf = '';
+    syncBufPath;
+    contextTokensPath;
+    // Session expired 状态
+    sessionPausedUntil = 0;
+    onSessionExpired;
+    eventBus;
+    // Project path resolver（用于保存文件到 uploads 目录）
+    projectPathResolver;
+    // Welcome message manager
+    welcomeManager;
+    constructor(config, agentAid, channelName) {
+        this.agentAid = agentAid;
+        this.channelName = channelName;
+        this.config = config;
+        const dataDir = resolvePaths().dataDir;
+        this.syncBufPath = path.join(dataDir, 'wechat-sync-buf.txt');
+        this.contextTokensPath = path.join(dataDir, 'wechat-context-tokens.json');
+        // 初始化 welcomeManager（使用共享帮助函数）
+        if (agentAid && channelName) {
+            this.welcomeManager = initWelcomeManager('wechat', agentAid, channelName);
+        }
+    }
+    // ── Public API ──────────────────────────────────────────────────────────
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onRecall(handler) {
+        this.recallHandler = handler;
+    }
+    /** 注册 session 过期通知回调（用于跨渠道通知用户） */
+    onSessionExpiredNotify(handler) {
+        this.onSessionExpired = handler;
+    }
+    /** 注册事件总线（推荐，替代 onSessionExpiredNotify） */
+    setEventBus(bus) {
+        this.eventBus = bus;
+    }
+    /** 当前是否处于 session 暂停状态 */
+    isSessionPaused() {
+        return Date.now() < this.sessionPausedUntil;
+    }
+    async connect() {
+        if (!this.config.token) {
+            throw new Error('WeChat token not configured');
+        }
+        // 恢复游标
+        try {
+            if (fs.existsSync(this.syncBufPath)) {
+                this.getUpdatesBuf = fs.readFileSync(this.syncBufPath, 'utf-8');
+                logger.info(`[WeChat] Restored sync cursor (${this.getUpdatesBuf.length} bytes)`);
+            }
+        }
+        catch {
+            // ignore
+        }
+        // 通知 ilink 后端：bot 上线
+        try {
+            await this.notifyLifecycle('notifystart');
+        }
+        catch (err) {
+            logger.warn('[WeChat] notifyStart failed during startup (ignored):', err);
+        }
+        this.abortController = new AbortController();
+        // 启动长轮询（不 await，后台运行）
+        this.pollLoop(this.abortController.signal).catch(err => {
+            if (this.abortController?.signal.aborted)
+                return;
+            logger.error('[WeChat] Poll loop fatal error:', err);
+            this.connected = false;
+        });
+        this.connected = true;
+        logger.info('[WeChat] Channel connected');
+    }
+    async disconnect() {
+        this.connected = false;
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = undefined;
+        }
+        // 通知 ilink 后端：bot 下线
+        try {
+            await this.notifyLifecycle('notifystop');
+        }
+        catch (err) {
+            logger.warn('[WeChat] notifyStop failed during shutdown (ignored):', err);
+        }
+        logger.info('[WeChat] Channel disconnected');
+    }
+    /** Get current connection status */
+    getStatus() {
+        return { connected: this.connected };
+    }
+    /** Reconnect: disconnect then connect again */
+    async reconnect() {
+        await this.disconnect();
+        try {
+            await this.connect();
+            return '重连成功';
+        }
+        catch (err) {
+            return `重连失败: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    async sendMessage(to, text) {
+        if (!text || text.trim() === '') {
+            logger.warn('[WeChat] Attempted to send empty message, skipping');
+            return;
+        }
+        // Session 暂停期间拒绝发送
+        if (this.isSessionPaused()) {
+            const remainingMin = Math.ceil((this.sessionPausedUntil - Date.now()) / 60_000);
+            logger.warn(`[WeChat] Session paused, ${remainingMin}min remaining, dropping outbound to ${to}`);
+            return;
+        }
+        const contextToken = this.contextTokenCache.get(to);
+        if (!contextToken) {
+            logger.error(`[WeChat] No context_token for ${to}, cannot send message`);
+            return;
+        }
+        // Markdown → 纯文本
+        const plainText = markdownToPlainText(text);
+        const clientId = `evolcore-wechat:${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+        const body = {
+            msg: {
+                from_user_id: '',
+                to_user_id: to,
+                client_id: clientId,
+                message_type: MSG_TYPE_BOT,
+                message_state: MSG_STATE_FINISH,
+                item_list: [{ type: MSG_ITEM_TEXT, text_item: { text: plainText } }],
+                context_token: contextToken,
+            },
+            base_info: { channel_version: CHANNEL_VERSION },
+        };
+        try {
+            await this.apiFetch('ilink/bot/sendmessage', JSON.stringify(body), DEFAULT_API_TIMEOUT_MS);
+            logger.debug(`[WeChat] Sent message to ${to}, clientId=${clientId}`);
+        }
+        catch (err) {
+            logger.error(`[WeChat] Failed to send message to ${to}:`, err);
+            throw err;
+        }
+    }
+    /** 注册 projectPath 解析器，用于保存接收的文件 */
+    onProjectPathRequest(resolver) {
+        this.projectPathResolver = resolver;
+    }
+    /** 发送文件（图片/视频/文件）给用户，通过 CDN 上传 */
+    async sendFile(to, filePath) {
+        // Session 暂停期间拒绝发送
+        if (this.isSessionPaused()) {
+            logger.warn(`[WeChat] Session paused, dropping file send to ${to}`);
+            return;
+        }
+        const contextToken = this.contextTokenCache.get(to);
+        if (!contextToken) {
+            logger.error(`[WeChat] No context_token for ${to}, cannot send file`);
+            return;
+        }
+        if (!fs.existsSync(filePath)) {
+            logger.error(`[WeChat] File not found: ${filePath}`);
+            return;
+        }
+        try {
+            const plaintext = Buffer.from(fs.readFileSync(filePath));
+            const rawsize = plaintext.length;
+            const rawfilemd5 = crypto.createHash('md5').update(plaintext).digest('hex');
+            const aeskey = crypto.randomBytes(16);
+            const filekey = crypto.randomBytes(16).toString('hex');
+            const filesize = Math.ceil((rawsize + 1) / 16) * 16;
+            // MIME → UploadMediaType
+            const ext = path.extname(filePath).toLowerCase();
+            const mime = MIME_MAP[ext] || 'application/octet-stream';
+            const uploadMediaType = mime.startsWith('image/') ? 1
+                : mime.startsWith('video/') ? 2 : 3;
+            // Step 1: getuploadurl
+            const uploadResp = await this.getUploadUrl({
+                filekey, media_type: uploadMediaType, to_user_id: to,
+                rawsize, rawfilemd5, filesize,
+                aeskey: aeskey.toString('hex'),
+                no_need_thumb: true,
+            });
+            // Step 2: encrypt + upload to CDN
+            const ciphertext = encryptAesEcb(plaintext, aeskey);
+            const downloadParam = await this.cdnUpload(uploadResp.upload_param, filekey, ciphertext);
+            // Step 3: sendmessage with CDN reference
+            const cdnMedia = {
+                encrypt_query_param: downloadParam,
+                aes_key: Buffer.from(aeskey.toString('hex')).toString('base64'),
+                encrypt_type: 1,
+            };
+            const itemType = mime.startsWith('image/') ? MSG_ITEM_IMAGE
+                : mime.startsWith('video/') ? MSG_ITEM_VIDEO : MSG_ITEM_FILE;
+            const item = this.buildMediaItem(itemType, cdnMedia, filePath, filesize, rawsize);
+            await this.sendMediaMessage(to, item, contextToken);
+        }
+        catch (err) {
+            logger.error(`[WeChat] Failed to send file ${filePath} to ${to}:`, err);
+            throw err;
+        }
+    }
+    // ── Long-Poll Loop ────────────────────────────────────────────────────
+    async pollLoop(signal) {
+        let consecutiveFailures = 0;
+        let nextTimeoutMs = DEFAULT_LONG_POLL_TIMEOUT_MS;
+        logger.info('[WeChat] Starting message polling...');
+        while (!signal.aborted) {
+            try {
+                const body = JSON.stringify({
+                    get_updates_buf: this.getUpdatesBuf,
+                    base_info: { channel_version: CHANNEL_VERSION },
+                });
+                let rawText;
+                try {
+                    rawText = await this.apiFetch('ilink/bot/getupdates', body, nextTimeoutMs, signal);
+                }
+                catch (err) {
+                    if (signal.aborted)
+                        return;
+                    // 长轮询超时是正常的
+                    if (err instanceof Error && err.name === 'AbortError') {
+                        continue;
+                    }
+                    throw err;
+                }
+                const resp = JSON.parse(rawText);
+                // 更新服务端建议的轮询超时
+                if (resp.longpolling_timeout_ms != null && resp.longpolling_timeout_ms > 0) {
+                    nextTimeoutMs = resp.longpolling_timeout_ms;
+                }
+                // API 错误处理
+                const isError = (resp.ret !== undefined && resp.ret !== 0) ||
+                    (resp.errcode !== undefined && resp.errcode !== 0);
+                if (isError) {
+                    // Session expired 专用处理
+                    const isSessionExpired = resp.errcode === SESSION_EXPIRED_ERRCODE || resp.ret === SESSION_EXPIRED_ERRCODE;
+                    if (isSessionExpired) {
+                        consecutiveFailures = 0;
+                        logger.error(`[WeChat] Session expired (errcode=${resp.errcode}), retrying in ${SESSION_RETRY_DELAY_MS / 1000}s...`);
+                        // 短暂停后重试一次
+                        await this.sleep(SESSION_RETRY_DELAY_MS, signal);
+                        if (signal.aborted)
+                            return;
+                        // 重试 getupdates
+                        try {
+                            const retryBody = JSON.stringify({
+                                get_updates_buf: this.getUpdatesBuf,
+                                base_info: { channel_version: CHANNEL_VERSION },
+                            });
+                            const retryRaw = await this.apiFetch('ilink/bot/getupdates', retryBody, nextTimeoutMs, signal);
+                            const retryResp = JSON.parse(retryRaw);
+                            const retryExpired = retryResp.errcode === SESSION_EXPIRED_ERRCODE || retryResp.ret === SESSION_EXPIRED_ERRCODE;
+                            if (!retryExpired) {
+                                // 恢复成功，静默继续
+                                logger.info('[WeChat] Session recovered after retry');
+                                // 把 retryResp 当正常响应处理（更新游标和消息）
+                                if (retryResp.get_updates_buf) {
+                                    this.getUpdatesBuf = retryResp.get_updates_buf;
+                                    try {
+                                        fs.writeFileSync(this.syncBufPath, this.getUpdatesBuf, 'utf-8');
+                                    }
+                                    catch { }
+                                }
+                                for (const msg of retryResp.msgs ?? []) {
+                                    await this.handleInboundMessage(msg);
+                                }
+                                continue;
+                            }
+                        }
+                        catch (retryErr) {
+                            if (signal.aborted)
+                                return;
+                            logger.error('[WeChat] Retry after session expired also failed:', retryErr);
+                        }
+                        // 重试仍失败，进入长暂停
+                        const pauseMin = SESSION_PAUSE_DURATION_MS / 60_000;
+                        this.sessionPausedUntil = Date.now() + SESSION_PAUSE_DURATION_MS;
+                        logger.error(`[WeChat] Session still expired, pausing for ${pauseMin}min`);
+                        // 通知用户（通过事件总线或回调）
+                        const authMsg = `⚠️ 微信 token 已过期，通道暂停 ${pauseMin} 分钟后自动重试。\n如需立即恢复，请运行: ec init wechat`;
+                        if (this.eventBus) {
+                            this.eventBus.publish({
+                                type: 'channel:error',
+                                channel: 'wechat',
+                                status: 'auth_error',
+                                message: authMsg,
+                                timestamp: Date.now(),
+                            });
+                        }
+                        else if (this.onSessionExpired) {
+                            this.onSessionExpired(authMsg);
+                        }
+                        await this.sleep(SESSION_PAUSE_DURATION_MS, signal);
+                        if (signal.aborted)
+                            return;
+                        // 长暂停结束，清除暂停状态，循环自动重试
+                        this.sessionPausedUntil = 0;
+                        logger.info('[WeChat] Session pause ended, resuming polling');
+                        continue;
+                    }
+                    consecutiveFailures++;
+                    logger.error(`[WeChat] getUpdates failed: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg ?? ''}`);
+                    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                        logger.error(`[WeChat] ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off ${BACKOFF_DELAY_MS / 1000}s`);
+                        consecutiveFailures = 0;
+                        await this.sleep(BACKOFF_DELAY_MS, signal);
+                    }
+                    else {
+                        await this.sleep(RETRY_DELAY_MS, signal);
+                    }
+                    continue;
+                }
+                consecutiveFailures = 0;
+                // 保存游标
+                if (resp.get_updates_buf) {
+                    this.getUpdatesBuf = resp.get_updates_buf;
+                    try {
+                        fs.writeFileSync(this.syncBufPath, this.getUpdatesBuf, 'utf-8');
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+                // 处理消息
+                for (const msg of resp.msgs ?? []) {
+                    await this.handleInboundMessage(msg);
+                }
+            }
+            catch (err) {
+                if (signal.aborted)
+                    return;
+                consecutiveFailures++;
+                logger.error(`[WeChat] Poll error (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}):`, err);
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                    consecutiveFailures = 0;
+                    await this.sleep(BACKOFF_DELAY_MS, signal);
+                }
+                else {
+                    await this.sleep(RETRY_DELAY_MS, signal);
+                }
+            }
+        }
+    }
+    // ── Inbound Message Handler ──────────────────────────────────────────
+    async handleInboundMessage(msg) {
+        if (msg.message_type !== MSG_TYPE_USER)
+            return;
+        const fromUserId = msg.from_user_id ?? '';
+        // 缓存 context_token
+        if (msg.context_token) {
+            this.contextTokenCache.set(fromUserId, msg.context_token);
+            this.persistContextTokens();
+        }
+        // 提取文本（原有逻辑）
+        const text = extractTextFromMessage(msg);
+        // 提取媒体 → 下载
+        const media = await this.extractMedia(msg, fromUserId);
+        // 合成最终内容
+        const finalContent = media.prompt
+            ? (text ? `${text}\n\n${media.prompt}` : media.prompt)
+            : text;
+        if (!finalContent && !media.images.length)
+            return;
+        logger.info(`[WeChat] Received: from=${fromUserId} text=${(finalContent || '').slice(0, 50)} images=${media.images.length}...`);
+        // 发送 typing 指示器（异步，不阻塞）
+        this.acknowledgeMessage(fromUserId, msg.context_token).catch(() => { });
+        // 首次交互欢迎消息（使用共享帮助函数）
+        await sendWelcomeIfNeeded(this.welcomeManager, fromUserId, fromUserId, (id, text) => this.sendMessage(id, text), 'WeChat');
+        // 回调主流程
+        if (this.messageHandler) {
+            try {
+                await this.messageHandler(fromUserId, finalContent || '', fromUserId, media.images.length ? media.images : undefined, 'private');
+            }
+            catch (err) {
+                logger.error('[WeChat] Message handler error:', err);
+            }
+        }
+    }
+    // ── Acknowledge (sendTyping) ──────────────────────────────────────────
+    async acknowledgeMessage(fromUserId, contextToken) {
+        try {
+            const ticket = await this.getTypingTicket(fromUserId, contextToken);
+            if (!ticket)
+                return;
+            const body = JSON.stringify({
+                ilink_user_id: fromUserId,
+                typing_ticket: ticket,
+                status: 1, // typing
+                base_info: { channel_version: CHANNEL_VERSION },
+            });
+            await this.apiFetch('ilink/bot/sendtyping', body, DEFAULT_CONFIG_TIMEOUT_MS);
+            logger.debug(`[WeChat] Sent typing indicator to ${fromUserId}`);
+        }
+        catch {
+            // 静默失败，不阻塞主流程（和 Feishu addAckReaction 一致）
+        }
+    }
+    async getTypingTicket(userId, contextToken) {
+        const cached = this.typingTicketCache.get(userId);
+        if (cached && Date.now() - cached.fetchedAt < TYPING_TICKET_TTL_MS) {
+            return cached.ticket;
+        }
+        try {
+            const body = JSON.stringify({
+                ilink_user_id: userId,
+                context_token: contextToken,
+                base_info: { channel_version: CHANNEL_VERSION },
+            });
+            const rawText = await this.apiFetch('ilink/bot/getconfig', body, DEFAULT_CONFIG_TIMEOUT_MS);
+            const resp = JSON.parse(rawText);
+            if (resp.ret === 0 && resp.typing_ticket) {
+                this.typingTicketCache.set(userId, { ticket: resp.typing_ticket, fetchedAt: Date.now() });
+                return resp.typing_ticket;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return undefined;
+    }
+    // ── Media Extraction (Inbound) ────────────────────────────────────────
+    async extractMedia(msg, channelId) {
+        const images = [];
+        const prompts = [];
+        for (const item of msg.item_list ?? []) {
+            try {
+                if (item.type === MSG_ITEM_IMAGE && item.image_item?.media) {
+                    const buf = await downloadMedia(item.image_item.media, item.image_item.aeskey);
+                    // 统一图片识别：magic bytes 优先正确区分 jpeg/png/gif/webp；
+                    // 检测失败时回退到 image/jpeg（微信入站图片实际均为 jpeg，保留历史行为）。
+                    const img = await bufferToInboundImage(buf, { contentType: 'image/jpeg' });
+                    if (img)
+                        images.push(img);
+                    else
+                        logger.warn('[WeChat] Image validation failed (not a supported image)');
+                }
+                else if (item.type === MSG_ITEM_FILE && item.file_item?.media) {
+                    const buf = await downloadMedia(item.file_item.media);
+                    const fileName = sanitizeFileName(item.file_item.file_name || `file_${Date.now()}`);
+                    const savePath = await this.saveToUploadsLocal(buf, fileName, channelId);
+                    prompts.push(`用户发送了文件：${fileName}\n文件已保存到：${savePath}\n请使用 Read 工具读取并分析文件内容。`);
+                }
+                else if (item.type === MSG_ITEM_VIDEO && item.video_item?.media) {
+                    const buf = await downloadMedia(item.video_item.media);
+                    const fileName = `video_${Date.now()}.mp4`;
+                    const savePath = await this.saveToUploadsLocal(buf, fileName, channelId);
+                    prompts.push(`用户发送了视频：${fileName}\n文件已保存到：${savePath}`);
+                }
+            }
+            catch (err) {
+                logger.error(`[WeChat] Failed to download media type=${item.type}:`, err);
+            }
+        }
+        return { prompt: prompts.join('\n\n'), images };
+    }
+    async saveToUploadsLocal(buf, fileName, channelId) {
+        const projectPath = this.projectPathResolver
+            ? await this.projectPathResolver(channelId)
+            : process.cwd();
+        const { filePath } = saveToUploads(buf, fileName, projectPath);
+        return filePath;
+    }
+    // ── Media Upload (Outbound) ──────────────────────────────────────────
+    async getUploadUrl(params) {
+        const body = JSON.stringify({
+            ...params,
+            base_info: { channel_version: CHANNEL_VERSION },
+        });
+        const raw = await this.apiFetch('ilink/bot/getuploadurl', body, DEFAULT_API_TIMEOUT_MS);
+        const resp = JSON.parse(raw);
+        if (!resp.upload_param)
+            throw new Error('getuploadurl: no upload_param');
+        return resp;
+    }
+    async cdnUpload(uploadParam, filekey, ciphertext) {
+        const url = `${CDN_BASE_URL}/upload?encrypted_query_param=${encodeURIComponent(uploadParam)}&filekey=${filekey}`;
+        let lastError;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                const res = await fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/octet-stream' },
+                    body: new Uint8Array(ciphertext),
+                });
+                if (res.status >= 400 && res.status < 500) {
+                    throw new Error(`CDN upload client error: ${res.status}`);
+                }
+                if (!res.ok)
+                    throw new Error(`CDN upload failed: ${res.status}`);
+                const downloadParam = res.headers.get('x-encrypted-param');
+                if (!downloadParam)
+                    throw new Error('Missing x-encrypted-param header');
+                return downloadParam;
+            }
+            catch (err) {
+                lastError = err;
+                if (err.message?.includes('client error'))
+                    throw err; // 4xx 不重试
+            }
+        }
+        throw lastError;
+    }
+    buildMediaItem(itemType, cdnMedia, filePath, ciphertextSize, plaintextSize) {
+        if (itemType === MSG_ITEM_IMAGE) {
+            return { type: MSG_ITEM_IMAGE, image_item: { media: cdnMedia, mid_size: ciphertextSize } };
+        }
+        if (itemType === MSG_ITEM_VIDEO) {
+            return { type: MSG_ITEM_VIDEO, video_item: { media: cdnMedia, video_size: ciphertextSize } };
+        }
+        return {
+            type: MSG_ITEM_FILE,
+            file_item: {
+                media: cdnMedia,
+                file_name: path.basename(filePath),
+                len: String(plaintextSize),
+            },
+        };
+    }
+    async sendMediaMessage(to, item, contextToken) {
+        const clientId = `evolcore-wechat:${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+        const body = {
+            msg: {
+                from_user_id: '',
+                to_user_id: to,
+                client_id: clientId,
+                message_type: MSG_TYPE_BOT,
+                message_state: MSG_STATE_FINISH,
+                item_list: [item],
+                context_token: contextToken,
+            },
+            base_info: { channel_version: CHANNEL_VERSION },
+        };
+        await this.apiFetch('ilink/bot/sendmessage', JSON.stringify(body), DEFAULT_API_TIMEOUT_MS);
+        logger.info(`[WeChat] Sent media to ${to}, type=${item.type}`);
+    }
+    // ── ilink API Helpers ─────────────────────────────────────────────────
+    /** Notify ilink backend of bot lifecycle events (start/stop). */
+    async notifyLifecycle(action) {
+        const body = JSON.stringify({ base_info: { channel_version: CHANNEL_VERSION } });
+        await this.apiFetch(`ilink/bot/msg/${action}`, body, DEFAULT_CONFIG_TIMEOUT_MS);
+        logger.info(`[WeChat] ${action} succeeded`);
+    }
+    async apiFetch(endpoint, body, timeoutMs, externalSignal) {
+        const base = this.config.baseUrl.endsWith('/') ? this.config.baseUrl : `${this.config.baseUrl}/`;
+        const url = new URL(endpoint, base).toString();
+        const headers = this.buildHeaders(body);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        // 外部 signal（来自 disconnect）也要能中断
+        const onExternalAbort = () => controller.abort();
+        externalSignal?.addEventListener('abort', onExternalAbort, { once: true });
+        try {
+            const res = await fetch(url, {
+                method: 'POST',
+                headers,
+                body,
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            const text = await res.text();
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}: ${text}`);
+            return text;
+        }
+        catch (err) {
+            clearTimeout(timer);
+            throw err;
+        }
+        finally {
+            externalSignal?.removeEventListener('abort', onExternalAbort);
+        }
+    }
+    buildHeaders(body) {
+        const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+        const wechatUin = Buffer.from(String(uint32), 'utf-8').toString('base64');
+        const headers = {
+            'Content-Type': 'application/json',
+            'AuthorizationType': 'ilink_bot_token',
+            'Content-Length': String(Buffer.byteLength(body, 'utf-8')),
+            'X-WECHAT-UIN': wechatUin,
+            'iLink-App-Id': ILINK_APP_ID,
+            'iLink-App-ClientVersion': ILINK_APP_CLIENT_VERSION,
+        };
+        if (this.config.token?.trim()) {
+            headers['Authorization'] = `Bearer ${this.config.token.trim()}`;
+        }
+        return headers;
+    }
+    // ── Persistence ────────────────────────────────────────────────────
+    /** 持久化 context_token 到文件，供 restart-monitor 等外部进程读取 */
+    persistContextTokens() {
+        try {
+            const obj = {};
+            for (const [k, v] of this.contextTokenCache) {
+                obj[k] = v;
+            }
+            fs.writeFileSync(this.contextTokensPath, JSON.stringify(obj), 'utf-8');
+        }
+        catch {
+            // best-effort
+        }
+    }
+    // ── Utilities ─────────────────────────────────────────────────────────
+    sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            const t = setTimeout(resolve, ms);
+            signal.addEventListener('abort', () => {
+                clearTimeout(t);
+                reject(new Error('aborted'));
+            }, { once: true });
+        });
+    }
+}
+import { middleOutputModePolicy, resolveShowActivities, showActivitiesPolicy } from '../core/channel-loader.js';
+export class WechatChannelPlugin {
+    name = 'wechat';
+    async createInstance(inst, ctx) {
+        if (inst.enabled === false || !inst.token)
+            return null;
+        const channel = new WechatChannel({
+            baseUrl: inst.baseUrl || 'https://ilinkai.weixin.qq.com',
+            token: inst.token,
+        }, ctx.agentName, inst.name);
+        const mode = resolveShowActivities(inst);
+        const adapter = {
+            channelName: inst.name,
+            channelKey: inst.name,
+            capabilities: { file: false, image: false, interaction: false, markdown: false, thought: false, status: true, thread: false, authenticatedApproval: true },
+            send: async (envelope, payload) => {
+                const channelId = envelope.channelId;
+                switch (payload.kind) {
+                    case 'result.text':
+                    case 'command.result':
+                    case 'command.error':
+                    case 'system.notice':
+                    case 'system.error':
+                    case 'result.error':
+                        await channel.sendMessage(channelId, payload.text);
+                        return;
+                    case 'result.file': {
+                        const name = payload.fileName || payload.filePath;
+                        await channel.sendMessage(channelId, `📎 文件已生成：${name}\n路径：${payload.filePath}`);
+                        return;
+                    }
+                    case 'result.image': return;
+                    case 'activity.batch': {
+                        const filtered = payload.items.filter((i) => !(i.kind === 'tool_result' && i.ok));
+                        const text = formatItemsAsText(filtered);
+                        if (text)
+                            await channel.sendMessage(channelId, text);
+                        return;
+                    }
+                    case 'status.requires_action':
+                        await channel.sendMessage(channelId, '等待 owner 审批');
+                        return;
+                    case 'status.error':
+                        if (payload.metadata?.message)
+                            await channel.sendMessage(channelId, payload.metadata.message);
+                        return;
+                    case 'interaction':
+                        if (payload.fallbackText)
+                            await channel.sendMessage(channelId, payload.fallbackText);
+                        return;
+                    default: return;
+                }
+            },
+        };
+        const policy = {
+            canSwitchProject: (_, identity) => identity === 'owner' || identity === 'admin',
+            canListProjects: (_, identity) => identity === 'owner' || identity === 'admin',
+            canCreateSession: () => true,
+            canDeleteSession: () => true,
+            canImportCliSession: (_, identity) => identity === 'owner' || identity === 'admin',
+            messagePrefix: () => '',
+            showMiddleResult: (chatType, identity) => showActivitiesPolicy(mode, chatType, identity),
+            middleOutputMode: (chatType, identity) => middleOutputModePolicy(mode, chatType, identity),
+            showIdleMonitor: (chatType, identity) => showActivitiesPolicy(mode, chatType, identity),
+            accumulateErrors: () => true,
+        };
+        return {
+            channelType: 'wechat', adapter, channel,
+            policy,
+            options: { fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g, flushDelay: inst.flushDelay ?? DEFAULT_FLUSH_DELAY_SECONDS },
+            connect: () => channel.connect(),
+            disconnect: () => channel.disconnect(),
+            onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),
+            registerBridge(bridge, channelType) {
+                bridge.register(adapter.channelName, (handler) => channel.onMessage(async (channelId, content, peerId, images, chatType) => {
+                    await handler({
+                        channel: adapter.channelName, channelType, channelId,
+                        selfAID: ctx.agentName, content, images,
+                        chatType: chatType || 'private', peerId: peerId || '',
+                    });
+                }), (channelId, text) => channel.sendMessage(channelId, text), adapter, channelType);
+            },
+            registerHooks(hookCtx) {
+                if (channel.setEventBus)
+                    channel.setEventBus(hookCtx.eventBus);
+            },
+        };
+    }
+}