@kafca/agentdock 0.1.43 → 0.1.45

package/dist-electron/services/local-ai-core/src/channel/lark/inbound.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLarkInboundMessageEvent = normalizeLarkInboundMessageEvent;
+exports.isLarkBotMentioned = isLarkBotMentioned;
+exports.stripLarkMentions = stripLarkMentions;
+exports.summarizeLarkInboundPayload = summarizeLarkInboundPayload;
+const node_crypto_1 = require("node:crypto");
+function normalizeLarkInboundMessageEvent(data, options = {}) {
+    const payload = (data?.event && typeof data.event === 'object')
+        ? data.event
+        : data;
+    const message = payload?.message;
+    const sender = payload?.sender;
+    if (!message || !sender) {
+        return { ok: false, reason: 'missing-message-or-sender', detail: JSON.stringify(Object.keys(data || {})) };
+    }
+    let parsedContent = {};
+    try {
+        parsedContent = JSON.parse(String(message.content || '{}'));
+    }
+    catch {
+        parsedContent = {};
+    }
+    const messageType = String(message.message_type || '').trim().toLowerCase();
+    const chatType = String(message.chat_type || '').trim().toLowerCase();
+    const mentions = Array.isArray(message.mentions) ? message.mentions : [];
+    const botOpenId = String(options.botOpenId || '').trim();
+    if (chatType === 'group' && !options.groupReplyAll && botOpenId && !isLarkBotMentioned(mentions, botOpenId)) {
+        return {
+            ok: false,
+            reason: 'group-message-without-bot-mention',
+            detail: `chat=${String(message.chat_id || '')} message=${String(message.message_id || '')}`,
+        };
+    }
+    const text = stripLarkMentions(String(parsedContent.text || '').trim(), mentions, botOpenId);
+    const platformUserId = String(sender.sender_id?.user_id || sender.sender_id?.open_id || '').trim();
+    const chatId = String(message.chat_id || platformUserId).trim();
+    if (!platformUserId || !chatId) {
+        return {
+            ok: false,
+            reason: 'missing-sender-or-chat',
+            detail: `senderKeys=${JSON.stringify(Object.keys(sender?.sender_id || {}))} chat=${String(message.chat_id || '')}`,
+        };
+    }
+    return {
+        ok: true,
+        message: {
+            payload,
+            message,
+            sender,
+            parsedContent,
+            messageType,
+            chatType,
+            mentions,
+            text,
+            platformUserId,
+            chatId,
+            displayName: String(sender.sender_id?.user_id ||
+                sender.sender_id?.open_id ||
+                `Lark ${platformUserId.slice(-6)}`),
+            messageId: String(message.message_id || (0, node_crypto_1.randomUUID)()),
+        },
+    };
+}
+function isLarkBotMentioned(mentions, botOpenId) {
+    if (!botOpenId) {
+        return false;
+    }
+    return mentions.some((mention) => {
+        const item = mention && typeof mention === 'object' ? mention : {};
+        return getMentionOpenId(item) === botOpenId;
+    });
+}
+function stripLarkMentions(text, mentions, botOpenId) {
+    let next = String(text || '');
+    for (const mention of mentions) {
+        const item = mention && typeof mention === 'object' ? mention : {};
+        const key = String(item.key || '').trim();
+        if (!key) {
+            continue;
+        }
+        const openId = getMentionOpenId(item);
+        const name = String(item.name || item.display_name || item.displayName || '').trim();
+        if (botOpenId && openId === botOpenId) {
+            next = next.split(key).join('');
+            continue;
+        }
+        next = next.split(key).join(name ? `@${name}` : '');
+    }
+    return next.trim();
+}
+function summarizeLarkInboundPayload(payload) {
+    const eventPayload = (payload?.event && typeof payload.event === 'object')
+        ? payload.event
+        : payload;
+    const message = eventPayload?.message || {};
+    const sender = eventPayload?.sender || {};
+    const senderId = sender?.sender_id || {};
+    const content = typeof message.content === 'string' ? message.content : '';
+    return [
+        `message=${String(message.message_id || '') || 'missing'}`,
+        `type=${String(message.message_type || '') || 'missing'}`,
+        `chat=${String(message.chat_id || '') || 'missing'}`,
+        `chatType=${String(message.chat_type || '') || 'missing'}`,
+        `sender=${String(senderId.user_id || senderId.open_id || '') || 'missing'}`,
+        `mentions=${Array.isArray(message.mentions) ? message.mentions.length : 0}`,
+        `contentBytes=${Buffer.byteLength(content, 'utf8')}`,
+        `keys=${JSON.stringify(Object.keys(eventPayload || {}))}`,
+    ].join(' ');
+}
+function getMentionOpenId(item) {
+    const id = item.id || item.user_id || item.userId || {};
+    return String(id.open_id || id.openId || item.open_id || item.openId || '').trim();
+}

package/dist-electron/services/local-ai-core/src/channel/lark/local-core-lark-gateway.js

@@ -38,16 +38,19 @@ const node_events_1 = require("node:events");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const local_core_errors_js_1 = require("../../kernel/local-core-errors.js");
 const desktop_js_1 = require("../../../../../shared/desktop.js");
 const content_js_1 = require("../shared/content.js");
 const file_utils_js_1 = require("../shared/file-utils.js");
 const session_command_runtime_js_1 = require("../shared/session-command-runtime.js");
+const thread_routing_js_1 = require("../shared/thread-routing.js");
 const cards_js_1 = require("./cards.js");
 const config_js_1 = require("./config.js");
 const registration_js_1 = require("./registration.js");
 const messages_js_1 = require("./rendering/messages.js");
+const inbound_js_1 = require("./inbound.js");
 const runtime_state_js_1 = require("./runtime-state.js");
-const session_command_service_js_1 = require("../../thread/session-command-service.js");
+const thread_slash_command_dispatcher_js_1 = require("../../thread/thread-slash-command-dispatcher.js");
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 const LARK_FINAL_PATCH_INTERVAL_MS = 900;
@@ -71,15 +74,29 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     constructor(options) {
         super();
         this.options = options;
-        const sessionCommandService = new session_command_service_js_1.SessionCommandService({
-            listThreads: (workspaceId) => this.options.getWorkspaceRouter().listThreads(workspaceId),
-            getThread: (threadId) => this.options.getWorkspaceRouter().getThread(threadId),
-            createThread: (workspaceId, title) => this.options.getWorkspaceRouter().createThread(workspaceId, title),
-            renameThread: (threadId, title) => this.options.getWorkspaceRouter().renameThread(threadId, title),
-            deleteThread: (threadId) => this.options.getWorkspaceRouter().deleteThread(threadId),
+        const slashCommands = new thread_slash_command_dispatcher_js_1.ThreadSlashCommandDispatcher({
+            session: {
+                listThreads: (workspaceId) => this.options.getWorkspaceRouter().listThreads(workspaceId),
+                getThread: (threadId) => this.options.getWorkspaceRouter().getThread(threadId),
+                createThread: (workspaceId, title) => this.options.getWorkspaceRouter().createThread(workspaceId, title),
+                renameThread: (threadId, title) => this.options.getWorkspaceRouter().renameThread(threadId, title),
+                deleteThread: (threadId) => this.options.getWorkspaceRouter().deleteThread(threadId),
+            },
+            thread: {
+                getThreadRow: (threadId) => this.options.store.getThreadRow(threadId),
+                updateThreadAgentMode: (threadId, mode) => this.options.store.updateThreadAgentMode(threadId, mode),
+                updateThreadAgentType: (threadId, agentType) => this.options.store.updateThreadAgentType(threadId, agentType),
+                getLatestRunForThread: (threadId) => this.options.store.getLatestRunForThread(threadId),
+                createAuditEvent: (input) => this.options.store.createAuditEvent(input),
+                getAgentTypes: () => this.options.getWorkspaceRouter().getAgentTypes(),
+                setThreadMode: (threadId, mode) => this.options.getWorkspaceRouter().setThreadMode(threadId, mode),
+                closeThreadSession: (threadId) => this.options.getWorkspaceRouter().closeThreadSession(threadId),
+                interruptRun: (runId) => this.options.getWorkspaceRouter().interruptRun(runId),
+                log: this.options.log,
+            },
         });
         this.sessionCommandRuntime = new session_command_runtime_js_1.ChannelSessionCommandRuntime({
-            service: sessionCommandService,
+            dispatcher: slashCommands,
             store: this.options.store,
             getThreadSessionKey: (threadId) => this.options.getWorkspaceRouter().getThreadSessionKey(threadId),
             setThreadRoute: (sessionKey, route) => {
@@ -124,6 +141,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                         appId: binding.appId,
                         autoApprove: binding.autoApprove,
                         cardActionsEnabled: binding.cardActionsEnabled,
+                        groupReplyAll: binding.groupReplyAll,
+                        botOpenId: binding.botOpenId,
                     });
                 }
                 continue;
@@ -378,6 +397,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             status: binding?.status || 'disabled',
             appId: binding?.appId || '',
             lastError: binding?.lastError,
+            lastErrorInfo: binding?.lastErrorInfo,
+            lastErrorAt: binding?.lastErrorAt,
             connectedAt: binding?.connectedAt,
             pendingPairings: pairings.length,
             authorizedUsers: users.length,
@@ -659,25 +680,17 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             return { paired: false };
         }
         const router = this.options.getWorkspaceRouter();
-        const threadBinding = this.options.store.getPlatformThreadBinding(input.workspaceId, input.chatId, input.platformUserId, platformKey);
-        let threadId = threadBinding?.thread_id || authorized.thread_id || '';
-        if (!threadId) {
-            const thread = await router.createThread(input.workspaceId, input.displayName || `Lark ${input.chatId}`);
-            threadId = thread.id;
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, platformKey);
-            const now = new Date().toISOString();
-            this.options.store.upsertPlatformThreadBinding({
-                workspace_id: input.workspaceId,
-                platform: platformKey,
-                chat_id: input.chatId,
-                platform_user_id: input.platformUserId,
-                thread_id: threadId,
-                last_platform_message_id: null,
-                created_at: now,
-                updated_at: now,
-            });
-        }
-        const sessionKey = this.options.getWorkspaceRouter().getThreadSessionKey(threadId);
+        let { threadId } = await (0, thread_routing_js_1.resolveChannelThreadRoute)({
+            store: this.options.store,
+            router,
+            workspaceId: input.workspaceId,
+            platformKey,
+            chatId: input.chatId,
+            platformUserId: input.platformUserId,
+            displayName: input.displayName,
+            fallbackTitlePrefix: 'Lark',
+            authorized,
+        });
         const normalizedText = String(input.text || '').trim().toLowerCase();
         const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny')
             ? this.findAwaitingPermissionThreadId(input.workspaceId, input.chatId, input.platformUserId)
@@ -702,6 +715,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             currentThreadId: threadId,
             text: input.text,
             defaultTitle: `${input.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`,
+            defaultAgentType: slashCommand ? await this.resolveDefaultAgentType(input.workspaceId, threadId) : '',
             chatId: input.chatId,
             platformUserId: input.platformUserId,
             platformKey,
@@ -789,6 +803,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             appId: binding.appId,
             autoApprove: binding.autoApprove,
             cardActionsEnabled: binding.cardActionsEnabled,
+            groupReplyAll: binding.groupReplyAll,
+            botOpenId: binding.botOpenId,
         };
         this.runtime.set(key, status);
         this.notifyRuntimeStateChanged();
@@ -801,6 +817,14 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 appType: mod.AppType.SelfBuild,
                 domain: mod.Domain.Feishu,
             });
+            try {
+                status.botOpenId = await this.fetchBotOpenId(status);
+                binding.botOpenId = status.botOpenId;
+                this.options.log?.(`localcore-lark bot identified for ${binding.workspaceId}/${binding.instanceId}: ${status.botOpenId}`);
+            }
+            catch (error) {
+                this.options.log?.(`localcore-lark bot identity lookup failed for ${binding.workspaceId}/${binding.instanceId}; group mention filtering may be limited: ${error instanceof Error ? error.message : String(error)}`);
+            }
             status.eventDispatcher = new mod.EventDispatcher({
                 encryptKey: binding.encryptKey || '',
                 verificationToken: binding.verificationToken || '',
@@ -835,13 +859,20 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             status.status = 'running';
             status.connected = true;
             status.connectedAt = new Date().toISOString();
-            status.lastError = undefined;
+            this.clearRuntimeError(status);
             this.options.log?.(`localcore-lark ws ready for ${binding.workspaceId}`);
         }
         catch (error) {
             status.status = 'error';
             status.connected = false;
-            status.lastError = error instanceof Error ? error.message : String(error);
+            const errorInfo = (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error instanceof local_core_errors_js_1.LocalCoreError
+                ? error
+                : new local_core_errors_js_1.LocalCoreError('channel_auth_failed', error instanceof Error ? error.message : String(error), {
+                    userMessage: 'Lark is not connected.',
+                    suggestedAction: 'Check app credentials and restart the Lark gateway.',
+                    details: { workspaceId: binding.workspaceId, instanceId: binding.instanceId },
+                }), 'channel_auth_failed');
+            this.setRuntimeError(status, errorInfo);
             this.options.log?.(`localcore-lark start failed for ${binding.workspaceId}: ${status.lastError}`);
         }
         this.notifyRuntimeStateChanged();
@@ -875,6 +906,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             appId: state.appId,
             autoApprove: state.autoApprove,
             cardActionsEnabled: state.cardActionsEnabled,
+            groupReplyAll: state.groupReplyAll,
+            botOpenId: state.botOpenId,
         });
         this.notifyRuntimeStateChanged();
     }
@@ -886,30 +919,44 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             },
         });
     }
+    clearRuntimeError(state) {
+        state.lastError = undefined;
+        state.lastErrorInfo = undefined;
+        state.lastErrorAt = undefined;
+    }
+    setRuntimeError(state, errorInfo) {
+        state.lastError = errorInfo.message;
+        state.lastErrorInfo = errorInfo;
+        state.lastErrorAt = new Date().toISOString();
+        this.options.eventBus.emit({
+            type: 'localcore.error',
+            payload: {
+                scope: 'channel.lark',
+                errorInfo,
+                context: {
+                    workspaceId: state.workspaceId,
+                    instanceId: state.instanceId,
+                    platform: 'lark',
+                },
+            },
+        });
+    }
     async handleMessageEvent(workspaceId, instanceIdOrData, platformKeyOrData, maybeData) {
         const legacyCall = typeof instanceIdOrData === 'object';
         const instanceId = legacyCall ? 'default' : instanceIdOrData;
         const platformKey = legacyCall ? 'lark' : String(platformKeyOrData || (0, config_js_1.channelPlatformKey)('lark', instanceId));
         const data = (legacyCall ? instanceIdOrData : maybeData) || {};
-        const payload = (data?.event && typeof data.event === 'object')
-            ? data.event
-            : data;
-        const message = payload?.message;
-        const sender = payload?.sender;
-        this.options.log?.(`localcore-lark handling message event for ${workspaceId}: ${this.summarizeLarkPayload(payload)}`);
-        if (!message || !sender) {
-            this.options.log?.(`localcore-lark ignored event without message/sender for ${workspaceId}: ${JSON.stringify(Object.keys(data || {}))}`);
+        const runtimeState = this.resolveRuntimeState(workspaceId, instanceId).state;
+        const normalized = (0, inbound_js_1.normalizeLarkInboundMessageEvent)(data, {
+            botOpenId: runtimeState?.botOpenId,
+            groupReplyAll: runtimeState?.groupReplyAll,
+        });
+        this.options.log?.(`localcore-lark handling message event for ${workspaceId}: ${(0, inbound_js_1.summarizeLarkInboundPayload)(data)}`);
+        if (!normalized.ok) {
+            this.options.log?.(`localcore-lark ignored message event for ${workspaceId}: reason=${normalized.reason}${normalized.detail ? ` ${normalized.detail}` : ''}`);
             return;
         }
-        let parsedContent = {};
-        try {
-            parsedContent = JSON.parse(String(message.content || '{}'));
-        }
-        catch {
-            parsedContent = {};
-        }
-        const messageType = String(message.message_type || '').trim().toLowerCase();
-        const text = String(parsedContent.text || '').trim();
+        const { message, parsedContent, messageType, chatType, mentions, text, platformUserId, chatId, displayName, messageId, } = normalized.message;
         const contentParts = [];
         if (text) {
             contentParts.push({ type: 'text', text });
@@ -945,24 +992,16 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             return;
         }
         const displayText = text || this.summarizeInboundContentParts(contentParts);
-        const platformUserId = String(sender.sender_id?.user_id || sender.sender_id?.open_id || '').trim();
-        const chatId = String(message.chat_id || platformUserId).trim();
-        if (!platformUserId || !chatId) {
-            this.options.log?.(`localcore-lark ignored message without sender/chat for ${workspaceId}: senderKeys=${JSON.stringify(Object.keys(sender?.sender_id || {}))} chat=${String(message.chat_id || '')}`);
-            return;
-        }
-        this.options.log?.(`localcore-lark inbound message for ${workspaceId}: chat=${chatId} user=${platformUserId} type=${messageType || 'unknown'} text=${JSON.stringify(displayText.slice(0, 120))}`);
+        this.options.log?.(`localcore-lark inbound message for ${workspaceId}: chat=${chatId} user=${platformUserId} chatType=${chatType || 'unknown'} mentions=${mentions.length} type=${messageType || 'unknown'} text=${JSON.stringify(displayText.slice(0, 120))}`);
         await this.handleInboundMessage({
             workspaceId,
             instanceId,
             platformKey,
             platformUserId,
             chatId,
-            displayName: String(payload?.sender?.sender_id?.user_id ||
-                payload?.sender?.sender_id?.open_id ||
-                `Lark ${platformUserId.slice(-6)}`),
+            displayName,
             text: displayText,
-            messageId: String(message.message_id || (0, node_crypto_1.randomUUID)()),
+            messageId,
             contentParts,
         });
     }
@@ -1109,24 +1148,19 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
     }
     summarizeLarkEvent(data) {
-        const payload = (data?.event && typeof data.event === 'object')
-            ? data.event
-            : data;
-        return this.summarizeLarkPayload(payload);
-    }
-    summarizeLarkPayload(payload) {
-        const message = payload?.message || {};
-        const sender = payload?.sender || {};
-        const senderId = sender?.sender_id || {};
-        const content = typeof message.content === 'string' ? message.content : '';
-        return [
-            `message=${String(message.message_id || '') || 'missing'}`,
-            `type=${String(message.message_type || '') || 'missing'}`,
-            `chat=${String(message.chat_id || '') || 'missing'}`,
-            `sender=${String(senderId.user_id || senderId.open_id || '') || 'missing'}`,
-            `contentBytes=${Buffer.byteLength(content, 'utf8')}`,
-            `keys=${JSON.stringify(Object.keys(payload || {}))}`,
-        ].join(' ');
+        return (0, inbound_js_1.summarizeLarkInboundPayload)(data);
+    }
+    async fetchBotOpenId(state) {
+        const response = await state.client.request({
+            url: '/open-apis/bot/v3/info',
+            method: 'GET',
+        });
+        const bot = response?.bot || response?.data?.bot;
+        const openId = String(bot?.open_id || bot?.openId || '').trim();
+        if (!openId) {
+            throw new Error('Lark bot info response did not include bot.open_id');
+        }
+        return openId;
     }
     summarizeWsArgs(args) {
         if (args.length === 0) {
@@ -1321,6 +1355,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                     currentThreadId: sessionAction.threadId,
                     text: sessionAction.command,
                     defaultTitle: `Lark ${new Date().toLocaleTimeString()}`,
+                    defaultAgentType: await this.resolveDefaultAgentType(workspaceId, sessionAction.threadId),
                     chatId: route.chatId,
                     platformUserId: route.platformUserId,
                     platformKey: route.platformKey,
@@ -1357,6 +1392,13 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             threadId: binding.thread_id,
         };
     }
+    async resolveDefaultAgentType(workspaceId, threadId) {
+        const router = this.options.getWorkspaceRouter();
+        if (typeof router.getWorkspaceDefaultAgentType === 'function') {
+            return router.getWorkspaceDefaultAgentType(workspaceId);
+        }
+        return this.options.store.getThreadRow(threadId)?.agent_type || 'codex';
+    }
     async markPermissionCardActionHandled(workspaceId, instanceId, rootPayload, payload, value, response, threadId) {
         const state = this.resolveRuntimeState(workspaceId, instanceId).state;
         if (!state?.client) {

package/dist-electron/services/local-ai-core/src/channel/shared/session-command-runtime.js

@@ -7,10 +7,12 @@ class ChannelSessionCommandRuntime {
         this.options = options;
     }
     async execute(input) {
-        const result = await this.options.service.execute(input.text, {
+        const result = await this.options.dispatcher.execute({
             workspaceId: input.workspaceId,
-            currentThreadId: input.currentThreadId,
+            threadId: input.currentThreadId,
+            content: input.text,
             defaultTitle: input.defaultTitle,
+            defaultAgentType: input.defaultAgentType,
         });
         if (!result.handled) {
             return { handled: false, threadId: input.currentThreadId };

package/dist-electron/services/local-ai-core/src/channel/shared/thread-routing.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveChannelThreadRoute = resolveChannelThreadRoute;
+async function resolveChannelThreadRoute(input) {
+    const threadBinding = input.store.getPlatformThreadBinding(input.workspaceId, input.chatId, input.platformUserId, input.platformKey);
+    let threadId = threadBinding?.thread_id || (input.authorized.chat_id === input.chatId ? input.authorized.thread_id : '') || '';
+    let createdThread = false;
+    if (!threadId) {
+        const thread = await input.router.createThread(input.workspaceId, input.displayName || `${input.fallbackTitlePrefix} ${input.chatId}`);
+        threadId = thread.id;
+        createdThread = true;
+        input.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, input.platformKey);
+    }
+    let createdBinding = false;
+    if (!threadBinding) {
+        const now = new Date().toISOString();
+        input.store.upsertPlatformThreadBinding({
+            workspace_id: input.workspaceId,
+            platform: input.platformKey,
+            chat_id: input.chatId,
+            platform_user_id: input.platformUserId,
+            thread_id: threadId,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        createdBinding = true;
+    }
+    return {
+        threadId,
+        createdThread,
+        createdBinding,
+    };
+}