evolcore 0.0.2 → 0.0.4

package/dist/channels/feishu.js

@@ -4,8 +4,28 @@ import imageType from 'image-type';
 import { sanitizeFileName, saveToUploads, bufferToInboundImage } from '../utils/media-cache.js';
 import { logger } from '../utils/logger.js';
 import { formatItemsAsText } from '../core/message/items-formatter.js';
+import { createSendFileMarkerPattern } from '../core/message/file-markers.js';
 import { initWelcomeManager, sendWelcomeIfNeeded } from '../utils/welcome.js';
 import { chatDirPath, decodeDirSegment } from '../core/session/session-fs-store.js';
+import { sentReceipt, suppressedReceipt } from '../core/message/send-receipt.js';
+import { ContactBindCodeRegistry, handleExplicitContactBindCommand, } from '../config/contact-bind-code.js';
+const feishuContactBinds = new ContactBindCodeRegistry({
+    channelType: 'feishu',
+    displayName: '飞书',
+    initCommand: 'ec init feishu',
+});
+export function registerPendingFeishuContactBind(req) {
+    return feishuContactBinds.register(req);
+}
+export function handlePendingFeishuContactBindMessage(ctx) {
+    return handleExplicitContactBindCommand(feishuContactBinds, ctx);
+}
+export function getPendingFeishuContactBind(selfAid, channelName, primaryId) {
+    return feishuContactBinds.get(selfAid, channelName, primaryId);
+}
+export function clearPendingFeishuContactBinds() {
+    feishuContactBinds.clear();
+}
 export class FeishuChannel {
     config;
     agentAid;
@@ -125,7 +145,7 @@ export class FeishuChannel {
                     try {
                         // 首次交互欢迎消息（使用共享帮助函数）
                         if (peerId) {
-                            await sendWelcomeIfNeeded(this.welcomeManager, peerId, msg.chat_id, (id, text) => this.sendMessage(id, text), 'Feishu');
+                            await sendWelcomeIfNeeded(this.welcomeManager, peerId, msg.chat_id, async (id, text) => { await this.sendMessage(id, text); }, 'Feishu');
                         }
                         // 提取话题信息
                         const threadId = msg.thread_id || undefined;
@@ -471,11 +491,11 @@ export class FeishuChannel {
     }
     async sendMessage(chatId, content, options) {
         if (!this.client)
-            return;
+            throw new Error('Feishu client is not connected');
         content = exposeLocalMarkdownLinkTargetsForFeishu(content);
         if (!content || content.trim() === '') {
             logger.warn('[Feishu] Attempted to send empty message, skipping');
-            return;
+            return [];
         }
         // 飞书消息内容限制约 30KB（text）/ 150KB（post），安全阈值 28000 字符
         // 超长消息自动拆分，按段落边界分割
@@ -483,12 +503,13 @@ export class FeishuChannel {
         if (content.length > MAX_CONTENT_LENGTH) {
             logger.info(`[Feishu] Message too long (${content.length} chars), splitting into parts`);
             const parts = splitLongMessage(content, MAX_CONTENT_LENGTH);
+            const messageIds = [];
             for (let i = 0; i < parts.length; i++) {
                 // 首条消息保留 reply 选项，后续消息不再 reply
                 const partOptions = i === 0 ? options : { ...options, replyToMessageId: undefined };
-                await this.sendMessage(chatId, parts[i], partOptions);
+                messageIds.push(...await this.sendMessage(chatId, parts[i], partOptions));
             }
-            return;
+            return messageIds;
         }
         logger.debug(`[Feishu] sendMessage called, chatId: ${chatId}, content length: ${content.length}`);
         try {
@@ -511,6 +532,7 @@ export class FeishuChannel {
             else {
                 msgContent = JSON.stringify({ text: content });
             }
+            let messageId;
             if (options?.replyToMessageId) {
                 const replyData = { msg_type: msgType, content: msgContent };
                 if (options.replyInThread) {
@@ -520,6 +542,7 @@ export class FeishuChannel {
                     path: { message_id: options.replyToMessageId },
                     data: replyData
                 });
+                messageId = replyRes?.data?.message_id;
                 if (options.replyInThread && options.onThreadCreated) {
                     const newThreadId = replyRes?.data?.thread_id;
                     if (newThreadId)
@@ -527,12 +550,16 @@ export class FeishuChannel {
                 }
             }
             else {
-                await this.client.im.message.create({
+                const createRes = await this.client.im.message.create({
                     params: { receive_id_type: chatId.startsWith('ou_') ? 'open_id' : chatId.startsWith('on_') ? 'union_id' : 'chat_id' },
                     data: { receive_id: chatId, msg_type: msgType, content: msgContent }
                 });
+                messageId = createRes?.data?.message_id;
             }
+            if (!messageId)
+                throw new Error('Feishu send succeeded without message_id');
             logger.debug(`[Feishu] Sent message as ${useMarkdown ? 'post (Markdown)' : 'text'}`);
+            return [messageId];
         }
         catch (error) {
             // 230011: 消息已被撤回，降级为普通消息重试
@@ -560,7 +587,7 @@ export class FeishuChannel {
     }
     async sendFile(chatId, filePath, options) {
         if (!this.client)
-            return;
+            throw new Error('Feishu client is not connected');
         try {
             // 检测是否为图片，是则走 sendImage（内联预览）而非文件卡片
             // 读取足够字节供 file-type 解析（ZIP-based 格式如 PPTX 需要更多字节）
@@ -585,24 +612,25 @@ export class FeishuChannel {
                 }
             });
             if (!uploadResponse || !uploadResponse.file_key) {
-                logger.error('[Feishu] File upload failed: no file_key returned');
-                return;
+                throw new Error('Feishu file upload failed: no file_key returned');
             }
             const fileKey = uploadResponse.file_key;
             const msgContent = JSON.stringify({ file_key: fileKey });
             logger.info('[Feishu] File uploaded, file_key:', fileKey);
+            let messageId;
             if (options?.replyToMessageId) {
                 const replyData = { msg_type: 'file', content: msgContent };
                 if (options.replyInThread) {
                     replyData.reply_in_thread = true;
                 }
-                await this.client.im.message.reply({
+                const replyRes = await this.client.im.message.reply({
                     path: { message_id: options.replyToMessageId },
                     data: replyData
                 });
+                messageId = replyRes?.data?.message_id;
             }
             else {
-                await this.client.im.message.create({
+                const createRes = await this.client.im.message.create({
                     params: { receive_id_type: chatId.startsWith('ou_') ? 'open_id' : chatId.startsWith('on_') ? 'union_id' : 'chat_id' },
                     data: {
                         receive_id: chatId,
@@ -610,8 +638,12 @@ export class FeishuChannel {
                         content: msgContent
                     }
                 });
+                messageId = createRes?.data?.message_id;
             }
+            if (!messageId)
+                throw new Error('Feishu file send succeeded without message_id');
             logger.info('[Feishu] File message sent successfully');
+            return [messageId];
         }
         catch (error) {
             // 230011/99992354: reply target invalid, retry without reply
@@ -626,7 +658,7 @@ export class FeishuChannel {
     }
     async sendImage(chatId, png, options) {
         if (!this.client)
-            return;
+            throw new Error('Feishu client is not connected');
         try {
             const uploadResponse = await this.client.im.image.create({
                 data: {
@@ -636,27 +668,32 @@ export class FeishuChannel {
             });
             const imageKey = uploadResponse?.image_key;
             if (!imageKey) {
-                logger.error('[Feishu] Image upload failed: no image_key returned');
-                return;
+                throw new Error('Feishu image upload failed: no image_key returned');
             }
             logger.debug('[Feishu] Image uploaded, image_key:', imageKey);
             const msgContent = JSON.stringify({ image_key: imageKey });
+            let messageId;
             if (options?.replyToMessageId) {
                 const replyData = { msg_type: 'image', content: msgContent };
                 if (options.replyInThread)
                     replyData.reply_in_thread = true;
-                await this.client.im.message.reply({
+                const replyRes = await this.client.im.message.reply({
                     path: { message_id: options.replyToMessageId },
                     data: replyData
                 });
+                messageId = replyRes?.data?.message_id;
             }
             else {
-                await this.client.im.message.create({
+                const createRes = await this.client.im.message.create({
                     params: { receive_id_type: chatId.startsWith('ou_') ? 'open_id' : chatId.startsWith('on_') ? 'union_id' : 'chat_id' },
                     data: { receive_id: chatId, msg_type: 'image', content: msgContent }
                 });
+                messageId = createRes?.data?.message_id;
             }
+            if (!messageId)
+                throw new Error('Feishu image send succeeded without message_id');
             logger.debug('[Feishu] Image message sent successfully');
+            return [messageId];
         }
         catch (error) {
             // 99992354: reply target invalid — image cannot easily retry, just log
@@ -1273,6 +1310,10 @@ export class FeishuChannel {
     }
     // messageId → Pin reaction create promise（等待 reaction_id 落地，供 promoteAck 删除）
     pinReactions = new Map();
+    // messageId → StatusInFlight reaction create promise（终态时替换）
+    inFlightReactions = new Map();
+    // taskId → 触发该任务的全部原始入站 messageId（批量合并时可有多条）
+    taskAckMessages = new Map();
     /** 收到消息时添加 Pin 表情（表示"已收到，排队中"） */
     addPinReaction(messageId) {
         if (!this.client)
@@ -1284,22 +1325,94 @@ export class FeishuChannel {
             .catch(() => undefined);
         this.pinReactions.set(messageId, p);
     }
-    /** Runner 开始执行时：添加 CheckMark，然后异步移除 Pin（视觉无闪烁） */
-    async promoteAckReaction(messageId) {
+    /** Runner 开始执行时：添加 StatusInFlight，然后移除 Pin（视觉无闪烁） */
+    async promoteAckReaction(messageId, taskId, sourceMessageIds, restartResume = false) {
+        const messageIds = [...new Set([...(sourceMessageIds ?? []), messageId].filter(Boolean))];
+        if (taskId)
+            this.taskAckMessages.set(taskId, messageIds);
         if (!this.client)
             return;
-        // 先加 CheckMark，再删 Pin——用户看到的是 Pin→Pin+CheckMark→CheckMark，无空窗
-        this.client.im.messageReaction.create({
-            path: { message_id: messageId },
-            data: { reaction_type: { emoji_type: 'CheckMark' } },
-        }).catch(() => { });
-        const pending = this.pinReactions.get(messageId);
-        this.pinReactions.delete(messageId);
-        const reactionId = await pending;
-        if (reactionId) {
-            this.client.im.messageReaction.delete({
-                path: { message_id: messageId, reaction_id: reactionId },
-            }).catch(() => { });
+        const promotions = messageIds.map(id => {
+            // 先加 StatusInFlight，再删 Pin——用户看到的是 Pin→Pin+InFlight→InFlight。
+            const inFlightPending = this.client.im.messageReaction.create({
+                path: { message_id: id },
+                data: { reaction_type: { emoji_type: 'StatusInFlight' } },
+            }).then((res) => res?.data?.reaction_id)
+                .catch(() => undefined);
+            this.inFlightReactions.set(id, inFlightPending);
+            const pending = this.pinReactions.get(id);
+            this.pinReactions.delete(id);
+            return { id, pending };
+        });
+        // Every in-flight reaction is registered before this first await, so a
+        // fast terminal event cannot race ahead and strand a merged-batch status.
+        for (const { id, pending } of promotions) {
+            if (restartResume)
+                await this.clearRestartCrossMark(id);
+            const reactionId = await pending;
+            if (reactionId) {
+                await this.client.im.messageReaction.delete({
+                    path: { message_id: id, reaction_id: reactionId },
+                }).catch(() => { });
+            }
+        }
+    }
+    /**
+     * A daemon restart terminates the old task with CrossMark. The reaction IDs
+     * are process-local, so a resumed process must discover and remove its own
+     * stale terminal reaction before it can show the new task state.
+     */
+    async clearRestartCrossMark(messageId) {
+        const reactions = this.client?.im?.messageReaction;
+        if (!reactions?.list || !reactions?.delete)
+            return;
+        try {
+            const response = await reactions.list({
+                path: { message_id: messageId },
+                params: { reaction_type: 'CrossMark', page_size: 50 },
+            });
+            const staleReactionIds = (response?.data?.items ?? [])
+                .filter((reaction) => (reaction?.reaction_type?.emoji_type === 'CrossMark'
+                && reaction?.operator?.operator_type === 'app'
+                && typeof reaction?.reaction_id === 'string'))
+                .map((reaction) => reaction.reaction_id);
+            await Promise.all(staleReactionIds.map(reactionId => (reactions.delete({ path: { message_id: messageId, reaction_id: reactionId } }).catch(() => { }))));
+        }
+        catch {
+            // A missing reaction-list permission must not block the resumed task.
+        }
+    }
+    /** 任务终态：用 CheckMark/CrossMark 替换 StatusInFlight。 */
+    async finalizeAckReaction(taskId, terminalEmoji) {
+        const messageIds = this.taskAckMessages.get(taskId);
+        if (!messageIds)
+            return;
+        if (!this.client) {
+            this.taskAckMessages.delete(taskId);
+            return;
+        }
+        this.taskAckMessages.delete(taskId);
+        for (const messageId of messageIds) {
+            const inFlightPending = this.inFlightReactions.get(messageId);
+            // 先加终态表情，再删处理中表情，避免视觉空窗。
+            const addTerminal = () => this.client.im.messageReaction.create({
+                path: { message_id: messageId },
+                data: { reaction_type: { emoji_type: terminalEmoji } },
+            }).then((res) => !!res?.data?.reaction_id).catch(() => false);
+            let terminalAdded = await addTerminal();
+            if (!terminalAdded)
+                terminalAdded = await addTerminal();
+            if (!terminalAdded) {
+                logger.warn(`[Feishu] Failed to add terminal reaction for ${messageId}; preserving processing reaction`);
+                continue;
+            }
+            this.inFlightReactions.delete(messageId);
+            const inFlightReactionId = await inFlightPending;
+            if (inFlightReactionId) {
+                await this.client.im.messageReaction.delete({
+                    path: { message_id: messageId, reaction_id: inFlightReactionId },
+                }).catch(() => { });
+            }
         }
     }
 }
@@ -1707,46 +1820,53 @@ export class FeishuChannelPlugin {
                             sendCtx.title = '✅ 最终回复:';
                         if (replyCtx?.metadata?.onThreadCreated)
                             sendCtx.onThreadCreated = replyCtx.metadata.onThreadCreated;
-                        await channel.sendMessage(channelId, payload.text, sendCtx);
-                        return;
+                        const ids = await channel.sendMessage(channelId, payload.text, sendCtx);
+                        return ids.length > 0
+                            ? sentReceipt(envelope, ids, replyCtx?.threadId)
+                            : suppressedReceipt(envelope, 'empty_message');
                     }
-                    case 'result.file':
-                        await channel.sendFile(channelId, payload.filePath, replyCtx);
-                        return;
-                    case 'result.image':
-                        await channel.sendImage(channelId, payload.data, replyCtx);
-                        return;
+                    case 'result.file': return sentReceipt(envelope, await channel.sendFile(channelId, payload.filePath, replyCtx), replyCtx?.threadId);
+                    case 'result.image': return sentReceipt(envelope, await channel.sendImage(channelId, payload.data, replyCtx), replyCtx?.threadId);
                     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, replyCtx);
-                        return;
+                            return sentReceipt(envelope, await channel.sendMessage(channelId, text, replyCtx), replyCtx?.threadId);
+                        return suppressedReceipt(envelope, 'empty_activity');
                     }
                     case 'status.started':
+                    case 'status.queued':
+                    case 'status.progress':
+                        return suppressedReceipt(envelope, 'reaction_lifecycle');
                     case 'status.completed':
+                        await channel.finalizeAckReaction(envelope.taskId, 'CheckMark');
+                        return suppressedReceipt(envelope, 'reaction_lifecycle');
                     case 'status.interrupted':
                     case 'status.timeout':
-                    case 'status.progress': return;
+                        await channel.finalizeAckReaction(envelope.taskId, 'CrossMark');
+                        return suppressedReceipt(envelope, 'reaction_lifecycle');
                     case 'status.requires_action':
-                        await channel.sendMessage(channelId, '等待 owner 审批', replyCtx);
-                        return;
+                        return sentReceipt(envelope, await channel.sendMessage(channelId, '等待 owner 审批', replyCtx), replyCtx?.threadId);
                     case 'status.error':
-                        if (payload.metadata?.message)
-                            await channel.sendMessage(channelId, payload.metadata.message, replyCtx);
-                        return;
+                        await channel.finalizeAckReaction(envelope.taskId, 'CrossMark');
+                        if (payload.metadata?.message) {
+                            return sentReceipt(envelope, await channel.sendMessage(channelId, payload.metadata.message, replyCtx), replyCtx?.threadId);
+                        }
+                        return suppressedReceipt(envelope, 'reaction_lifecycle');
                     case 'interaction': {
                         const sent = await channel.sendInteraction(channelId, payload.interaction, replyCtx);
                         if (!sent)
                             throw new Error('sendInteraction returned false');
-                        return;
+                        return sentReceipt(envelope, [sent], replyCtx?.threadId);
                     }
-                    case 'custom': return;
-                    default: logger.warn(`[Feishu] Unhandled payload kind: ${payload.kind}`);
+                    case 'custom': return suppressedReceipt(envelope, 'unsupported_custom_payload');
+                    default:
+                        logger.warn(`[Feishu] Unhandled payload kind: ${payload.kind}`);
+                        return suppressedReceipt(envelope, 'unhandled_payload');
                 }
             },
             acknowledge: (messageId) => { channel.addPinReaction(messageId); return Promise.resolve(); },
-            promoteAck: (messageId) => channel.promoteAckReaction(messageId),
+            promoteAck: (messageId, context) => (channel.promoteAckReaction(messageId, context?.taskId, context?.messageIds, context?.restartResume)),
             onInteraction: (callback) => channel.onInteraction(callback),
             onInteractionInvalidated: (callback) => channel.onInteractionInvalidated(callback),
             invalidateInteraction: (interactionId, reason) => channel.invalidateInteraction(interactionId, reason),
@@ -1766,23 +1886,31 @@ export class FeishuChannelPlugin {
         return {
             channelType: 'feishu', adapter, channel,
             policy,
-            options: { fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g, supportsImages: true, flushDelay: inst.flushDelay },
+            options: { fileMarkerPattern: createSendFileMarkerPattern(), supportsImages: true, flushDelay: inst.flushDelay },
             connect: () => channel.connect(),
             disconnect: () => channel.disconnect(),
             onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),
             registerBridge(bridge, channelType) {
                 bridge.register(adapter.channelName, (handler) => channel.onMessage(async ({ channelId: chatId, content, images, peerId, peerName, messageId, mentions, mentionAids, threadId, rootId, chatType, source }) => {
+                    const replyContext = peerId || threadId
+                        ? {
+                            ...(peerId ? { peerId } : {}),
+                            ...(threadId ? { threadId, replyToMessageId: rootId ?? threadId, replyInThread: true } : {}),
+                        }
+                        : undefined;
                     await handler({
                         channel: adapter.channelName, channelType, channelId: chatId, content, images,
                         selfAID: ctx.agentName, chatType: chatType || 'private',
                         peerId: peerId || '', peerName, messageId, mentions, mentionAids, threadId,
-                        replyContext: threadId ? { threadId, replyToMessageId: rootId ?? threadId, replyInThread: true } : undefined,
+                        replyContext,
                         source,
                     });
-                }), (channelId, text, replyContext) => channel.sendMessage(channelId, text, {
-                    replyToMessageId: replyContext?.replyToMessageId,
-                    replyInThread: replyContext?.replyInThread,
-                }), adapter, channelType);
+                }), async (channelId, text, replyContext) => {
+                    await channel.sendMessage(channelId, text, {
+                        replyToMessageId: replyContext?.replyToMessageId,
+                        replyInThread: replyContext?.replyInThread,
+                    });
+                }, adapter, channelType);
             },
         };
     }

package/dist/channels/qqbot.js

@@ -3,7 +3,26 @@ import { markdownToPlainText } from '../utils/markdown-to-plain-text.js';
 import { requireOptional } from '../utils/npm-ops.js';
 import { middleOutputModePolicy, resolveShowActivities, showActivitiesPolicy } from '../core/channel-loader.js';
 import { formatItemsAsText } from '../core/message/items-formatter.js';
+import { createSendFileMarkerPattern } from '../core/message/file-markers.js';
 import { initWelcomeManager, sendWelcomeIfNeeded } from '../utils/welcome.js';
+import { ContactBindCodeRegistry, handleExplicitContactBindCommand, } from '../config/contact-bind-code.js';
+const qqbotContactBinds = new ContactBindCodeRegistry({
+    channelType: 'qqbot',
+    displayName: 'QQ',
+    initCommand: 'ec init qqbot',
+});
+export function registerPendingQQBotContactBind(req) {
+    return qqbotContactBinds.register(req);
+}
+export function handlePendingQQBotContactBindMessage(ctx) {
+    return handleExplicitContactBindCommand(qqbotContactBinds, ctx);
+}
+export function getPendingQQBotContactBind(selfAid, channelName, primaryId) {
+    return qqbotContactBinds.get(selfAid, channelName, primaryId);
+}
+export function clearPendingQQBotContactBinds() {
+    qqbotContactBinds.clear();
+}
 // ── QQBotChannel ────────────────────────────────────────────────────────────
 export class QQBotChannel {
     agentAid;
@@ -93,6 +112,9 @@ export class QQBotChannel {
         }
         logger.info('[QQBot] Disconnected');
     }
+    getStatus() {
+        return { connected: this.connected };
+    }
     onMessage(handler) {
         this.messageHandler = handler;
     }
@@ -390,7 +412,7 @@ export class QQBotChannelPlugin {
         return {
             channelType: 'qqbot', adapter, channel,
             policy,
-            options: { fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g, supportsImages: true, flushDelay: inst.flushDelay },
+            options: { fileMarkerPattern: createSendFileMarkerPattern(), supportsImages: true, flushDelay: inst.flushDelay },
             connect: () => channel.connect(),
             disconnect: () => channel.disconnect(),
             onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),