@kafca/agentdock 0.1.56 → 0.1.57

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

@@ -35,24 +35,20 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreLarkGateway = void 0;
 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 inbound_attachment_store_js_1 = require("../shared/inbound-attachment-store.js");
 const thread_routing_js_1 = require("../shared/thread-routing.js");
 const base_channel_gateway_js_1 = require("../shared/base-channel-gateway.js");
+const inbound_authorization_js_1 = require("../shared/inbound-authorization.js");
 const cards_js_1 = require("./cards.js");
 const channel_keys_js_1 = require("../shared/channel-keys.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 inbound_handler_js_1 = require("./inbound-handler.js");
+const outbound_transport_js_1 = require("./outbound-transport.js");
 const runtime_state_js_1 = require("./runtime-state.js");
-const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
-const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
+const gateway_utils_js_1 = require("./gateway-utils.js");
 const LARK_FINAL_PATCH_INTERVAL_MS = 900;
 const LARK_PROGRESS_PATCH_INTERVAL_MS = 3000;
 const LARK_EMPTY_RENDER_LOG_WINDOW_MS = 5 * 60 * 1000;
@@ -64,10 +60,20 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
     mirrorPermissionStateInMainCard = false;
     larkModulePromise = null;
     emptyRenderLogWindows = new Map();
-    inboundAttachmentStore = new inbound_attachment_store_js_1.FileSystemInboundAttachmentStore();
+    inboundHandler;
+    outboundTransport;
     platform = 'lark';
     constructor(options) {
         super(options);
+        this.inboundHandler = new inbound_handler_js_1.LarkInboundHandler({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+            getRuntimeState: (workspaceId, instanceId) => this.resolveRuntimeState(workspaceId, instanceId).state,
+            getBinding: (workspaceId, instanceId) => this.getBinding(workspaceId, instanceId),
+            dispatchInboundMessage: (message) => this.handleInboundMessage(message),
+            log: options.log,
+        });
+        this.outboundTransport = new outbound_transport_js_1.LarkOutboundTransport(options.log);
     }
     // ==================== Lifecycle (platform-specific) ====================
     async testConnection(workspaceId, instanceId) {
@@ -160,7 +166,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
     async sendSessionCommandResult(input, result) {
         const state = this.resolveRuntimeState(input.workspaceId, input.instanceId).state;
         if (state?.client && state.connected && result.card?.actions?.length && state.cardActionsEnabled) {
-            await this.sendSessionCommandCard(state, input.chatId, result.displayText, result.card.actions, this.options.getWorkspaceRouter().getThreadSessionKey(input.currentThreadId), input.currentThreadId);
+            await this.outboundTransport.sendSessionCommandCard(state, input.chatId, result.displayText, result.card.actions, this.options.getWorkspaceRouter().getThreadSessionKey(input.currentThreadId), input.currentThreadId);
             return;
         }
         await this.sendImmediateCard(input.workspaceId, input.chatId, result.displayText, input.instanceId);
@@ -185,7 +191,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
                 continue;
             }
             if (part.type === 'file') {
-                const sent = await this.sendFilePart(state, channelId, part);
+                const sent = await this.outboundTransport.sendFilePart(state, channelId, part);
                 messageIds.push(sent.messageId);
                 attachments.push({
                     kind: 'file',
@@ -231,46 +237,6 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
             fileSize: attachment?.fileSize || 0,
         };
     }
-    async sendFilePart(state, channelId, part) {
-        const file = await (0, file_utils_js_1.prepareChannelFile)({
-            path: part.path,
-            fileName: part.fileName,
-            workspacePath: typeof part.metadata?.workspacePath === 'string' ? part.metadata.workspacePath : undefined,
-            maxBytes: LARK_MAX_UPLOAD_FILE_SIZE,
-            platformLabel: 'Lark',
-        });
-        const upload = await state.client.im.file.create({
-            data: {
-                file_type: this.resolveLarkUploadFileType(file.fileName),
-                file_name: file.fileName,
-                file: (0, node_fs_1.createReadStream)(file.path),
-            },
-        });
-        const fileKey = String(upload?.file_key || upload?.data?.file_key || '').trim();
-        if (!fileKey) {
-            throw new Error('Lark file upload did not return a file key');
-        }
-        const response = await state.client.im.message.create({
-            params: {
-                receive_id_type: this.resolveReceiveIdType(channelId),
-            },
-            data: {
-                receive_id: channelId,
-                msg_type: 'file',
-                content: JSON.stringify({ file_key: fileKey }),
-            },
-        });
-        const messageId = String(response?.data?.message_id || '').trim();
-        if (!messageId) {
-            throw new Error('Lark file message did not return a message id');
-        }
-        this.options.log?.(`localcore-lark sent file ${file.fileName} (${file.fileSize} bytes) to ${channelId}`);
-        return {
-            messageId,
-            fileKey,
-            file,
-        };
-    }
     async onBridgeEvent(event) {
         if (!event.sessionKey) {
             this.options.log?.(`localcore-lark bridge event ignored without sessionKey: ${event.type}`);
@@ -327,7 +293,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
                 }
                 if (event.type === 'typing_start' && (turn.permissionMessageId || turn.awaitingPermission)) {
                     if (turn.permissionMessageId) {
-                        await this.patchTextCard(state, turn.permissionMessageId, '**工具确认已处理**\n\n继续生成中...', [], sessionKey, bridgeThreadId);
+                        await this.outboundTransport.patchTextCard(state, turn.permissionMessageId, '**工具确认已处理**\n\n继续生成中...', [], sessionKey, bridgeThreadId);
                     }
                     turn.permissionMessageId = undefined;
                     turn.awaitingPermission = false;
@@ -340,14 +306,14 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
                     const permissionCard = (0, cards_js_1.renderPermissionCard)(turn, event, Boolean(state.cardActionsEnabled));
                     if (permissionCard.text || permissionCard.buttonRows.length > 0) {
                         if (!turn.permissionMessageId) {
-                            const createdId = await this.sendTextAsCard(state, route.chatId, permissionCard.text, permissionCard.buttonRows, sessionKey, bridgeThreadId);
+                            const createdId = await this.outboundTransport.sendTextAsCard(state, route.chatId, permissionCard.text, permissionCard.buttonRows, sessionKey, bridgeThreadId);
                             if (createdId) {
                                 turn.permissionMessageId = createdId;
                                 this.options.log?.(`localcore-lark sent permission card ${createdId} for sessionKey=${sessionKey}`);
                             }
                         }
                         else {
-                            await this.patchTextCard(state, turn.permissionMessageId, permissionCard.text, permissionCard.buttonRows, sessionKey, bridgeThreadId);
+                            await this.outboundTransport.patchTextCard(state, turn.permissionMessageId, permissionCard.text, permissionCard.buttonRows, sessionKey, bridgeThreadId);
                             this.options.log?.(`localcore-lark patched permission card ${turn.permissionMessageId} for sessionKey=${sessionKey}`);
                         }
                     }
@@ -376,7 +342,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
                         const sentMessage = sendAsPlainMessage
                             ? await this.sendTextAsMessage(state, route.chatId, renderedMessage.text)
                             : {
-                                messageId: await this.sendTextAsCard(state, route.chatId, renderedMessage.text, renderedMessage.buttonRows, sessionKey, bridgeThreadId),
+                                messageId: await this.outboundTransport.sendTextAsCard(state, route.chatId, renderedMessage.text, renderedMessage.buttonRows, sessionKey, bridgeThreadId),
                                 renderKind: 'card',
                             };
                         const createdId = sentMessage.messageId;
@@ -392,7 +358,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
                     if (renderedMessage.delivery === 'message') {
                         continue;
                     }
-                    await this.patchTextCard(state, existingMessageId, renderedMessage.text, renderedMessage.buttonRows, sessionKey, bridgeThreadId);
+                    await this.outboundTransport.patchTextCard(state, existingMessageId, renderedMessage.text, renderedMessage.buttonRows, sessionKey, bridgeThreadId);
                     turn.lastPatchedAt = Date.now();
                     turn.lastPatchedAtByMessageId[existingMessageId] = turn.lastPatchedAt;
                     this.options.log?.(`localcore-lark patched card message ${existingMessageId} for sessionKey=${sessionKey}`);
@@ -426,7 +392,6 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
                 messageId: msg.messageId,
             },
         });
-        this.options.store.expirePendingPairings();
         const runtimeState = this.resolveRuntimeState(msg.workspaceId, instanceId).state;
         let binding;
         try {
@@ -438,47 +403,28 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
             }
             this.options.log?.(`localcore-lark using active runtime binding snapshot for ${msg.workspaceId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
         }
-        let authorized = this.options.store.getAuthorizedUser(msg.workspaceId, msg.platformUserId, platformKey);
-        if (!authorized) {
-            if (binding?.autoApprove || runtimeState?.autoApprove) {
-                const authorizedAt = new Date().toISOString();
-                this.options.store.createAuthorizedUser({
-                    id: `lark-user-${(0, node_crypto_1.randomUUID)()}`,
-                    workspace_id: msg.workspaceId,
-                    platform: platformKey,
-                    platform_user_id: msg.platformUserId,
-                    chat_id: msg.chatId,
-                    display_name: msg.displayName,
-                    thread_id: null,
-                    authorized_at: authorizedAt,
-                });
-                authorized = this.options.store.getAuthorizedUser(msg.workspaceId, msg.platformUserId, platformKey);
-                this.options.log?.(`localcore-lark auto-approved user for ${msg.workspaceId}: ${msg.platformUserId}`);
-                this.notifyRuntimeStateChanged();
-            }
-        }
-        if (!authorized) {
-            const existingPending = this.options.store.listPendingPairings(msg.workspaceId).find((item) => item.platform === platformKey && item.platform_user_id === msg.platformUserId && item.chat_id === msg.chatId && item.status === 'pending');
-            let pairingCode = existingPending?.code || '';
-            if (!existingPending) {
-                const now = new Date();
-                pairingCode = this.generatePairingCode();
-                this.options.store.createPairingRequest({
-                    code: pairingCode,
-                    workspace_id: msg.workspaceId,
-                    platform: platformKey,
-                    platform_user_id: msg.platformUserId,
-                    chat_id: msg.chatId,
-                    display_name: msg.displayName,
-                    requested_at: now.toISOString(),
-                    expires_at: new Date(now.getTime() + PAIRING_EXPIRY_MS).toISOString(),
-                    status: 'pending',
-                });
-                this.notifyRuntimeStateChanged();
-            }
-            await this.sendImmediateCard(msg.workspaceId, msg.chatId, (0, cards_js_1.renderPendingPairingCard)(pairingCode), instanceId);
+        const authorization = (0, inbound_authorization_js_1.resolveInboundChannelAuthorization)({
+            store: this.options.store,
+            identity: {
+                workspaceId: msg.workspaceId,
+                platformKey,
+                platformUserId: msg.platformUserId,
+                chatId: msg.chatId,
+                displayName: msg.displayName,
+            },
+            autoApprove: Boolean(binding?.autoApprove || runtimeState?.autoApprove),
+            authorizedUserIdPrefix: 'lark-user',
+            generatePairingCode: () => this.generatePairingCode(),
+            onStateChanged: () => this.notifyRuntimeStateChanged(),
+        });
+        if (authorization.status === 'pending') {
+            await this.sendImmediateCard(msg.workspaceId, msg.chatId, (0, cards_js_1.renderPendingPairingCard)(authorization.pairingCode), instanceId);
             return; // { paired: false };
         }
+        if (authorization.autoApproved) {
+            this.options.log?.(`localcore-lark auto-approved user for ${msg.workspaceId}: ${msg.platformUserId}`);
+        }
+        const authorized = authorization.authorized;
         const router = this.options.getWorkspaceRouter();
         let { threadId } = await (0, thread_routing_js_1.resolveChannelThreadRoute)({
             store: this.options.store,
@@ -531,10 +477,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
             return; // { paired: true, threadId };
         }
         this.options.store.clearPlatformThreadMessageId(msg.workspaceId, msg.chatId, msg.platformUserId);
-        const wrappedText = slashCommand
-            ? msg.text
-            : (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(msg.text);
-        await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(wrappedText, msg.contentParts));
+        await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(msg.text, msg.contentParts));
         return; // { paired: true, threadId };
     }
     async createSdkClientResult(binding) {
@@ -587,7 +530,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
         this.runtime.set(key, status);
         this.notifyRuntimeStateChanged();
         try {
-            this.options.log?.(`localcore-lark starting workspace=${binding.workspaceId} app=${this.maskLarkAppId(binding.appId)} cardActions=${binding.cardActionsEnabled}`);
+            this.options.log?.(`localcore-lark starting workspace=${binding.workspaceId} app=${(0, gateway_utils_js_1.maskLarkAppId)(binding.appId)} cardActions=${binding.cardActionsEnabled}`);
             const mod = await this.getLarkModule();
             status.client = new mod.Client({
                 appId: binding.appId,
@@ -610,7 +553,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
             });
             status.eventDispatcher.register({
                 'im.message.receive_v1': async (data) => {
-                    this.options.log?.(`localcore-lark received im.message.receive_v1 for ${binding.workspaceId}/${binding.instanceId}: ${this.summarizeLarkEvent(data)}`);
+                    this.options.log?.(`localcore-lark received im.message.receive_v1 for ${binding.workspaceId}/${binding.instanceId}: ${(0, inbound_js_1.summarizeLarkInboundPayload)(data)}`);
                     void this.handleMessageEvent(binding.workspaceId, binding.instanceId, binding.platformKey, data).catch((error) => {
                         this.options.log?.(`localcore-lark inbound message failed for ${binding.workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
                     });
@@ -629,7 +572,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
                 domain: mod.Domain.Feishu,
                 loggerLevel: mod.LoggerLevel.info,
             });
-            this.attachWsDiagnostics(binding.workspaceId, status.wsClient);
+            (0, gateway_utils_js_1.attachLarkWsDiagnostics)(binding.workspaceId, status.wsClient, this.options.log);
             this.options.log?.(`localcore-lark ws starting for ${binding.workspaceId}`);
             await status.wsClient.start({
                 eventDispatcher: status.eventDispatcher,
@@ -656,279 +599,13 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
         this.notifyRuntimeStateChanged();
     }
     async handleMessageEvent(workspaceId, instanceIdOrData, platformKeyOrData, maybeData) {
-        const legacyCall = typeof instanceIdOrData === 'object';
-        const instanceId = legacyCall ? 'default' : instanceIdOrData;
-        const platformKey = legacyCall ? 'lark' : String(platformKeyOrData || (0, channel_keys_js_1.channelPlatformKey)('lark', instanceId));
-        const data = (legacyCall ? instanceIdOrData : maybeData) || {};
-        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;
-        }
-        const { message, parsedContent, messageType, chatType, mentions, text, platformUserId, chatId, displayName, messageId, } = normalized.message;
-        const mayMaterializeAttachments = Boolean(runtimeState?.autoApprove
-            || this.options.store.getAuthorizedUser(workspaceId, platformUserId, platformKey));
-        const contentParts = [];
-        if (text) {
-            contentParts.push({ type: 'text', text });
-        }
-        if (messageType === 'image') {
-            const imageKey = String(parsedContent.image_key || parsedContent.file_key || '').trim();
-            if (imageKey) {
-                if (!mayMaterializeAttachments) {
-                    contentParts.push({ type: 'text', text: '[Image]' });
-                }
-                else {
-                    try {
-                        contentParts.push(await this.downloadMessageImage(workspaceId, String(message.message_id || ''), imageKey, instanceId));
-                    }
-                    catch (error) {
-                        const errorText = `[Image download failed: ${error instanceof Error ? error.message : String(error)}]`;
-                        contentParts.push({ type: 'text', text: errorText });
-                        this.options.log?.(`localcore-lark image download failed for ${workspaceId}: message=${String(message.message_id || '')} imageKey=${imageKey} error=${error instanceof Error ? error.message : String(error)}`);
-                    }
-                }
-            }
-        }
-        if (messageType === 'file') {
-            const fileKey = String(parsedContent.file_key || '').trim();
-            if (fileKey) {
-                if (!mayMaterializeAttachments) {
-                    const inboundFileName = String(parsedContent.file_name || parsedContent.name || '').trim();
-                    contentParts.push({ type: 'text', text: inboundFileName ? `[File: ${inboundFileName}]` : '[File]' });
-                }
-                else {
-                    try {
-                        contentParts.push(await this.downloadMessageFile(workspaceId, String(message.message_id || ''), fileKey, String(parsedContent.file_name || parsedContent.name || '').trim(), instanceId));
-                    }
-                    catch (error) {
-                        const errorText = `[File download failed: ${error instanceof Error ? error.message : String(error)}]`;
-                        contentParts.push({ type: 'text', text: errorText });
-                        this.options.log?.(`localcore-lark file download failed for ${workspaceId}: message=${String(message.message_id || '')} fileKey=${fileKey} error=${error instanceof Error ? error.message : String(error)}`);
-                    }
-                }
-            }
-        }
-        if (contentParts.length === 0) {
-            this.options.log?.(`localcore-lark ignored unsupported message for ${workspaceId}: type=${String(message.message_type || 'unknown')} contentKeys=${JSON.stringify(Object.keys(parsedContent))}`);
-            return;
-        }
-        const displayText = text || this.summarizeInboundContentParts(contentParts);
-        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,
-            text: displayText,
-            messageId,
-            contentParts,
-        });
+        await this.inboundHandler.handleMessageEvent(workspaceId, instanceIdOrData, platformKeyOrData, maybeData);
     }
     async downloadMessageImage(workspaceId, messageId, imageKey, instanceId) {
-        const state = this.resolveRuntimeState(workspaceId, instanceId).state;
-        if (!state?.client) {
-            throw new Error('Lark client is not connected');
-        }
-        if (!messageId) {
-            throw new Error('Lark image message is missing message_id');
-        }
-        const downloadsDir = await this.resolveInboundDownloadsDir(workspaceId, instanceId, state.downloadsDir);
-        const stored = await this.inboundAttachmentStore.save({
-            directory: downloadsDir,
-            storedFileName: `${messageId}-${imageKey}`,
-            displayFileName: imageKey,
-            maxBytes: LARK_MAX_UPLOAD_FILE_SIZE,
-            includeBase64: true,
-            finalizeStoredFileName: ({ storedFileName, prefix }) => `${storedFileName}.${this.sniffImageExtension(prefix)}`,
-            source: {
-                open: async () => {
-                    const resource = await state.client.im.messageResource.get({
-                        path: {
-                            message_id: messageId,
-                            file_key: imageKey,
-                        },
-                        params: {
-                            type: 'image',
-                        },
-                    });
-                    const stream = resource?.getReadableStream?.();
-                    if (!stream || typeof stream.pipe !== 'function') {
-                        throw new Error('Lark image resource did not provide a readable stream');
-                    }
-                    return {
-                        stream,
-                        mimeType: this.extractHeaderMimeType(resource?.headers),
-                    };
-                },
-            },
-        });
-        const extension = (0, node_path_1.extname)(stored.path).slice(1) || 'bin';
-        const uri = await this.resolveInboundAttachmentUri(workspaceId, stored.path, instanceId);
-        return {
-            type: 'image',
-            data: stored.data || '',
-            ...(uri ? { uri } : {}),
-            mimeType: stored.mimeType || this.sniffImageMimeType(stored.prefix),
-            fileName: `${imageKey}.${extension}`,
-        };
+        return this.inboundHandler.downloadMessageImage(workspaceId, messageId, imageKey, instanceId);
     }
     async downloadMessageFile(workspaceId, messageId, fileKey, fileName, instanceId) {
-        const state = this.resolveRuntimeState(workspaceId, instanceId).state;
-        if (!state?.client) {
-            throw new Error('Lark client is not connected');
-        }
-        if (!messageId) {
-            throw new Error('Lark file message is missing message_id');
-        }
-        const downloadsDir = await this.resolveInboundDownloadsDir(workspaceId, instanceId, state.downloadsDir);
-        const displayFileName = fileName || fileKey;
-        const stored = await this.inboundAttachmentStore.save({
-            directory: downloadsDir,
-            storedFileName: `${messageId}-${displayFileName}`,
-            displayFileName,
-            maxBytes: LARK_MAX_UPLOAD_FILE_SIZE,
-            source: {
-                open: async () => {
-                    const resource = await state.client.im.messageResource.get({
-                        path: {
-                            message_id: messageId,
-                            file_key: fileKey,
-                        },
-                        params: {
-                            type: 'file',
-                        },
-                    });
-                    const stream = resource?.getReadableStream?.();
-                    if (!stream || typeof stream.pipe !== 'function') {
-                        throw new Error('Lark file resource did not provide a readable stream');
-                    }
-                    return {
-                        stream,
-                        mimeType: this.extractHeaderMimeType(resource?.headers) || 'application/octet-stream',
-                    };
-                },
-            },
-        });
-        return {
-            type: 'file',
-            path: stored.path,
-            fileName: stored.fileName,
-            mimeType: stored.mimeType,
-            size: stored.size,
-        };
-    }
-    async resolveInboundDownloadsDir(workspaceId, instanceId = 'default', runtimeDownloadsDir) {
-        const binding = runtimeDownloadsDir === undefined
-            ? await this.getBinding(workspaceId, instanceId)
-            : undefined;
-        const configuredDir = String(runtimeDownloadsDir ?? binding?.downloadsDir ?? '').trim();
-        if (configuredDir && (0, node_path_1.isAbsolute)(configuredDir)) {
-            return configuredDir;
-        }
-        const workspace = await this.options.getWorkspaceRouter().getWorkspaceRegistryEntry(workspaceId);
-        return configuredDir
-            ? (0, node_path_1.resolve)(workspace.path, configuredDir)
-            : (0, node_path_1.join)(workspace.path, '.agentdock', 'channel-uploads', 'lark', instanceId);
-    }
-    async resolveInboundAttachmentUri(workspaceId, filePath, instanceId = 'default') {
-        const binding = await this.getBinding(workspaceId, instanceId).catch(() => undefined);
-        if (!binding) {
-            return undefined;
-        }
-        const sandbox = binding.project.agent?.options?.sandbox;
-        if (!sandbox?.enabled) {
-            return (0, inbound_attachment_store_js_1.resolveInboundAttachmentUri)({ filePath });
-        }
-        const workspace = await this.options.getWorkspaceRouter().getWorkspaceRegistryEntry(workspaceId).catch(() => undefined);
-        if (!workspace) {
-            return undefined;
-        }
-        return (0, inbound_attachment_store_js_1.resolveInboundAttachmentUri)({
-            filePath,
-            workspacePath: workspace.path,
-            sandboxEnabled: true,
-            sandboxWorkspacePath: sandbox.workspace_mount_path,
-        });
-    }
-    summarizeInboundContentParts(parts) {
-        const text = parts
-            .filter((part) => part.type === 'text')
-            .map((part) => part.text)
-            .filter(Boolean)
-            .join('\n\n')
-            .trim();
-        if (text)
-            return text;
-        const attachmentSummary = parts
-            .map((part) => {
-            if (part.type === 'image') {
-                return '[Image]';
-            }
-            if (part.type === 'file') {
-                return part.fileName ? `[File: ${part.fileName}]` : '[File]';
-            }
-            return '';
-        })
-            .filter(Boolean)
-            .join('\n');
-        return attachmentSummary;
-    }
-    extractHeaderMimeType(headers) {
-        const value = headers && typeof headers === 'object'
-            ? headers['content-type'] || headers['Content-Type']
-            : '';
-        return String(value || '').split(';')[0]?.trim() || '';
-    }
-    sniffImageMimeType(buffer) {
-        if (buffer[0] === 0xff && buffer[1] === 0xd8)
-            return 'image/jpeg';
-        if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47)
-            return 'image/png';
-        if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46)
-            return 'image/gif';
-        if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46)
-            return 'image/webp';
-        return 'application/octet-stream';
-    }
-    sniffImageExtension(buffer) {
-        const mimeType = this.sniffImageMimeType(buffer);
-        if (mimeType === 'image/jpeg')
-            return 'jpg';
-        if (mimeType === 'image/png')
-            return 'png';
-        if (mimeType === 'image/gif')
-            return 'gif';
-        if (mimeType === 'image/webp')
-            return 'webp';
-        return 'bin';
-    }
-    attachWsDiagnostics(workspaceId, wsClient) {
-        const on = typeof wsClient?.on === 'function' ? wsClient.on.bind(wsClient) : null;
-        if (!on) {
-            this.options.log?.(`localcore-lark ws diagnostics unavailable for ${workspaceId}: client has no on()`);
-            return;
-        }
-        for (const eventName of ['open', 'connect', 'connected', 'ready', 'close', 'closed', 'disconnect', 'error', 'reconnect']) {
-            try {
-                on(eventName, (...args) => {
-                    this.options.log?.(`localcore-lark ws event ${eventName} for ${workspaceId}: ${this.summarizeWsArgs(args)}`);
-                });
-            }
-            catch (error) {
-                this.options.log?.(`localcore-lark ws diagnostic hook failed for ${workspaceId} event=${eventName}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-    summarizeLarkEvent(data) {
-        return (0, inbound_js_1.summarizeLarkInboundPayload)(data);
+        return this.inboundHandler.downloadMessageFile(workspaceId, messageId, fileKey, fileName, instanceId);
     }
     async fetchBotOpenId(state) {
         const response = await state.client.request({
@@ -942,30 +619,6 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
         }
         return openId;
     }
-    summarizeWsArgs(args) {
-        if (args.length === 0) {
-            return 'no-args';
-        }
-        return args.map((arg) => {
-            if (arg instanceof Error) {
-                return `${arg.name}: ${arg.message}`;
-            }
-            if (typeof arg === 'string') {
-                return arg.slice(0, 200);
-            }
-            if (arg && typeof arg === 'object') {
-                return JSON.stringify(Object.keys(arg));
-            }
-            return String(arg);
-        }).join(' ');
-    }
-    maskLarkAppId(appId) {
-        const value = String(appId || '').trim();
-        if (value.length <= 8) {
-            return value ? '***' : '';
-        }
-        return `${value.slice(0, 6)}...${value.slice(-4)}`;
-    }
     makeThreadRoute(input, threadId) {
         return {
             workspaceId: input.workspaceId,
@@ -982,7 +635,6 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
         });
     }
     buildStatusObject(state, _resolved) {
-        this.options.store.expirePendingPairings();
         const resolved = this.resolveRuntimeState(state.workspaceId, state.instanceId);
         const binding = resolved.state;
         const platformKey = binding?.platformKey || (0, channel_keys_js_1.channelPlatformKey)('lark', resolved.instanceId);
@@ -1054,94 +706,8 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
         }
         return this.larkModulePromise;
     }
-    async sendTextAsCard(state, chatId, text, buttonRows = [], sessionKey, threadId) {
-        const startedAt = Date.now();
-        const response = await state.client.im.message.create({
-            params: {
-                receive_id_type: this.resolveReceiveIdType(chatId),
-            },
-            data: {
-                receive_id: chatId,
-                msg_type: 'interactive',
-                content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)),
-            },
-        });
-        this.options.log?.(`localcore-lark card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
-        return String(response?.data?.message_id || '').trim();
-    }
-    async sendSessionCommandCard(state, chatId, text, actionRows, sessionKey, threadId) {
-        const startedAt = Date.now();
-        const response = await state.client.im.message.create({
-            params: {
-                receive_id_type: this.resolveReceiveIdType(chatId),
-            },
-            data: {
-                receive_id: chatId,
-                msg_type: 'interactive',
-                content: JSON.stringify((0, cards_js_1.buildSessionCommandCard)(text, actionRows, sessionKey, threadId)),
-            },
-        });
-        this.options.log?.(`localcore-lark session card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
-        return String(response?.data?.message_id || '').trim();
-    }
     async sendTextAsMessage(state, chatId, text) {
-        const startedAt = Date.now();
-        const rendered = (0, messages_js_1.renderLarkTextMessage)(text);
-        const response = await state.client.im.message.create({
-            params: {
-                receive_id_type: this.resolveReceiveIdType(chatId),
-            },
-            data: {
-                receive_id: chatId,
-                msg_type: rendered.msgType,
-                content: JSON.stringify(rendered.content),
-            },
-        });
-        this.options.log?.(`localcore-lark ${rendered.renderKind} create took ${Date.now() - startedAt}ms msgType=${rendered.msgType} reason=${rendered.reason} tableCount=${rendered.tableCount} textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
-        return {
-            messageId: String(response?.data?.message_id || '').trim(),
-            renderKind: rendered.renderKind,
-            msgType: rendered.msgType,
-        };
-    }
-    resolveReceiveIdType(receiveId) {
-        return receiveId.startsWith('oc_') ? 'chat_id' : receiveId.startsWith('ou_') ? 'open_id' : 'user_id';
-    }
-    resolveLarkUploadFileType(fileName) {
-        switch ((0, node_path_1.extname)(fileName).toLowerCase()) {
-            case '.opus':
-                return 'opus';
-            case '.mp4':
-            case '.mov':
-            case '.m4v':
-                return 'mp4';
-            case '.pdf':
-                return 'pdf';
-            case '.doc':
-            case '.docx':
-                return 'doc';
-            case '.xls':
-            case '.xlsx':
-            case '.csv':
-                return 'xls';
-            case '.ppt':
-            case '.pptx':
-                return 'ppt';
-            default:
-                return 'stream';
-        }
-    }
-    async patchTextCard(state, messageId, text, buttonRows = [], sessionKey, threadId) {
-        const startedAt = Date.now();
-        await state.client.im.message.patch({
-            path: {
-                message_id: messageId,
-            },
-            data: {
-                content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)),
-            },
-        });
-        this.options.log?.(`localcore-lark card patch took ${Date.now() - startedAt}ms message=${messageId} textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
+        return this.outboundTransport.sendTextAsMessage(state, chatId, text);
     }
     generatePairingCode() {
         return String((0, node_crypto_1.randomInt)(100000, 1000000));
@@ -1269,7 +835,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
             return;
         }
         try {
-            await this.patchTextCard(state, messageId, [
+            await this.outboundTransport.patchTextCard(state, messageId, [
                 '**工具确认已处理**',
                 `已选择：${(0, cards_js_1.formatPermissionResponseLabel)(response)}`,
                 '等待代理继续执行...',
@@ -1290,7 +856,7 @@ class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway
             return '';
         }
         try {
-            return await this.sendTextAsCard(state, chatId, text);
+            return await this.outboundTransport.sendTextAsCard(state, chatId, text);
         }
         catch (error) {
             this.options.log?.(`localcore-lark immediate card failed for ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`);