@kafca/agentdock 0.1.21 → 0.1.22

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

@@ -36,8 +36,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreLarkGateway = void 0;
 const node_events_1 = require("node:events");
 const node_crypto_1 = require("node:crypto");
-const desktop_js_1 = require("../../../../shared/desktop.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const file_utils_js_1 = require("../shared/file-utils.js");
+function foldToolResultForLark(content) {
+    const normalized = String(content || '').trim();
+    if (!normalized.startsWith('🔧 '))
+        return normalized;
+    const parts = normalized.split(' - ');
+    if (parts.length <= 2)
+        return normalized;
+    return parts.slice(0, 2).join(' - ');
+}
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
+const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     options;
     // Lark returns 200340 when card action events are not enabled in the app's
@@ -115,6 +128,111 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     async sendScheduledMessage(workspaceId, route, text) {
         return this.sendScheduledCard(workspaceId, route.channelId, text);
     }
+    async sendOutboundMessage(workspaceId, input) {
+        const state = this.runtime.get(workspaceId);
+        if (!state?.client || !state.connected) {
+            throw new Error(`Lark workspace is not connected: ${workspaceId}`);
+        }
+        const channelId = String(input.route?.channelId || '').trim();
+        if (!channelId) {
+            throw new Error('Missing Lark target channel id');
+        }
+        const messageIds = [];
+        const attachments = [];
+        for (const part of input.parts || []) {
+            if (part.type === 'text') {
+                const text = String(part.text || '').trim();
+                if (text) {
+                    messageIds.push(await this.sendTextAsCard(state, channelId, text));
+                }
+                continue;
+            }
+            if (part.type === 'file') {
+                const sent = await this.sendFilePart(state, channelId, part);
+                messageIds.push(sent.messageId);
+                attachments.push({
+                    kind: 'file',
+                    attachmentId: sent.fileKey,
+                    fileName: sent.file.fileName,
+                    fileSize: sent.file.fileSize,
+                    metadata: {
+                        fileKey: sent.fileKey,
+                    },
+                });
+            }
+        }
+        return {
+            platform: 'lark',
+            workspaceId,
+            channelId,
+            participantId: input.route.participantId,
+            messageIds: messageIds.filter(Boolean),
+            attachments,
+        };
+    }
+    async sendFile(workspaceId, input) {
+        const result = await this.sendOutboundMessage(workspaceId, {
+            route: {
+                type: 'channel.chat',
+                channelId: input.channelId,
+                participantId: input.participantId,
+            },
+            parts: [{
+                    type: 'file',
+                    path: input.path,
+                    fileName: input.fileName,
+                }],
+        });
+        const attachment = result.attachments?.[0];
+        return {
+            platform: 'lark',
+            workspaceId,
+            channelId: result.channelId,
+            messageId: result.messageIds[0] || '',
+            fileKey: String(attachment?.metadata?.fileKey || attachment?.attachmentId || ''),
+            fileName: attachment?.fileName || input.fileName || '',
+            fileSize: attachment?.fileSize || 0,
+        };
+    }
+    async sendFilePart(state, channelId, part) {
+        const file = await (0, file_utils_js_1.prepareChannelFile)({
+            path: part.path,
+            fileName: part.fileName,
+            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,
+        };
+    }
     muteThreadBridge(threadId) {
         const current = this.mutedThreadBridgeCounts.get(threadId) || 0;
         this.mutedThreadBridgeCounts.set(threadId, current + 1);
@@ -881,10 +999,9 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         };
     }
     async sendTextAsCard(state, chatId, text, buttonRows = [], sessionKey, threadId) {
-        const receiveIdType = chatId.startsWith('oc_') ? 'chat_id' : chatId.startsWith('ou_') ? 'open_id' : 'user_id';
         const response = await state.client.im.message.create({
             params: {
-                receive_id_type: receiveIdType,
+                receive_id_type: this.resolveReceiveIdType(chatId),
             },
             data: {
                 receive_id: chatId,
@@ -894,6 +1011,33 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         });
         return String(response?.data?.message_id || '').trim();
     }
+    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) {
         await state.client.im.message.patch({
             path: {
@@ -971,7 +1115,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         return turn;
     }
     consumeBridgeEvent(turn, event) {
-        const content = String(event.content || '').trim();
+        const content = foldToolResultForLark(String(event.content || '').trim());
         if (event.type === 'typing_start') {
             // Always start a fresh card for each generation phase.
             // This keeps Feishu message order aligned with user-visible timeline.
@@ -1030,7 +1174,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         turn.previewText = content;
     }
     renderBridgeEventMessage(turn, event) {
-        const content = String(event.content || '').trim();
+        const content = foldToolResultForLark(String(event.content || '').trim());
         if (event.type === 'preview_start' || event.type === 'update_message') {
             if (content.startsWith('💭 ')) {
                 return this.renderProgressMessage(event.previewHandle || 'thinking-preview', content);
@@ -1159,12 +1303,107 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             }
             const router = this.options.getWorkspaceRouter();
             await router.sendThreadAction(threadId, response);
+            await this.markPermissionCardActionHandled(workspaceId, data, payload, value, response, threadId);
             this.options.log?.(`localcore-lark processed card action for ${workspaceId}: ${response}`);
         }
         catch (error) {
             this.options.log?.(`localcore-lark card action failed for ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    async markPermissionCardActionHandled(workspaceId, rootPayload, payload, value, response, threadId) {
+        const state = this.runtime.get(workspaceId);
+        if (!state?.client) {
+            return;
+        }
+        const sessionKey = String(value.session_key || '').trim();
+        const turn = sessionKey ? this.outboundTurns.get(sessionKey) : undefined;
+        const messageId = this.extractCardActionMessageId(rootPayload, payload, value) || turn?.permissionMessageId;
+        if (!messageId) {
+            this.options.log?.(`localcore-lark could not find permission card message id for workspace=${workspaceId} sessionKey=${sessionKey || 'missing'}`);
+            return;
+        }
+        try {
+            await this.patchTextCard(state, messageId, [
+                '**工具确认已处理**',
+                `已选择：${this.formatPermissionResponseLabel(response)}`,
+                '等待代理继续执行...',
+            ].join('\n\n'), [], sessionKey || undefined, threadId);
+            if (turn) {
+                turn.awaitingPermission = false;
+                turn.buttonRows = [];
+            }
+        }
+        catch (error) {
+            this.options.log?.(`localcore-lark failed to patch handled permission card ${messageId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    extractCardActionMessageId(...payloads) {
+        for (const payload of payloads) {
+            const messageId = this.extractKnownCardActionMessageId(payload);
+            if (messageId) {
+                return messageId;
+            }
+        }
+        for (const payload of payloads) {
+            const messageId = this.findNestedCardActionMessageId(payload);
+            if (messageId) {
+                return messageId;
+            }
+        }
+        return '';
+    }
+    extractKnownCardActionMessageId(payload) {
+        const source = payload;
+        if (!source || typeof source !== 'object') {
+            return '';
+        }
+        const candidates = [
+            source?.permission_message_id,
+            source?.action_message_id,
+            source?.context?.open_message_id,
+            source?.context?.message_id,
+            source?.event?.context?.open_message_id,
+            source?.event?.context?.message_id,
+            source?.event_context?.open_message_id,
+            source?.event_context?.message_id,
+            source?.message?.message_id,
+            source?.message?.open_message_id,
+            source?.event?.message?.message_id,
+            source?.event?.message?.open_message_id,
+            source?.message_id,
+            source?.open_message_id,
+        ];
+        return candidates
+            .map((candidate) => String(candidate || '').trim())
+            .find(Boolean) || '';
+    }
+    findNestedCardActionMessageId(payload, seen = new Set()) {
+        if (!payload || typeof payload !== 'object' || seen.has(payload)) {
+            return '';
+        }
+        seen.add(payload);
+        if (Array.isArray(payload)) {
+            for (const item of payload) {
+                const nested = this.findNestedCardActionMessageId(item, seen);
+                if (nested)
+                    return nested;
+            }
+            return '';
+        }
+        const source = payload;
+        for (const key of ['open_message_id', 'message_id', 'permission_message_id', 'action_message_id']) {
+            const value = source[key];
+            if (typeof value === 'string' && value.trim()) {
+                return value.trim();
+            }
+        }
+        for (const value of Object.values(source)) {
+            const nested = this.findNestedCardActionMessageId(value, seen);
+            if (nested)
+                return nested;
+        }
+        return '';
+    }
     pushUnique(target, value) {
         const normalized = value.trim();
         if (!normalized) {
@@ -1179,8 +1418,10 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
     }
     formatPermissionButtonLabel(button) {
-        const response = (0, desktop_js_1.normalizePermissionResponse)(button.data) || (0, desktop_js_1.normalizePermissionResponse)(button.text);
-        switch (response) {
+        return this.formatPermissionResponseLabel(button.data || button.text);
+    }
+    formatPermissionResponseLabel(response) {
+        switch ((0, desktop_js_1.normalizePermissionResponse)(response) || response) {
             case 'allow':
                 return '允许一次';
             case 'allow all':
@@ -1188,7 +1429,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             case 'deny':
                 return '拒绝';
             default:
-                return button.text;
+                return response;
         }
     }
     resolveLarkButtonType(button, index) {

package/dist-electron/services/local-ai-core/src/channel/shared/file-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareChannelFile = prepareChannelFile;
+exports.sanitizeChannelFileName = sanitizeChannelFileName;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+async function prepareChannelFile(input) {
+    const filePath = String(input.path || '').trim();
+    if (!filePath) {
+        throw new Error('Missing file path');
+    }
+    const fileStat = await (0, promises_1.stat)(filePath).catch((error) => {
+        throw new Error(`Cannot read file "${filePath}": ${error instanceof Error ? error.message : String(error)}`);
+    });
+    if (!fileStat.isFile()) {
+        throw new Error(`Path is not a file: ${filePath}`);
+    }
+    if (fileStat.size <= 0) {
+        throw new Error(`File is empty: ${filePath}`);
+    }
+    if (input.maxBytes && fileStat.size > input.maxBytes) {
+        throw new Error(`File is too large for ${input.platformLabel} upload: ${fileStat.size} bytes`);
+    }
+    return {
+        path: filePath,
+        fileName: sanitizeChannelFileName(input.fileName || (0, node_path_1.basename)(filePath)),
+        fileSize: fileStat.size,
+    };
+}
+function sanitizeChannelFileName(fileName) {
+    const normalized = String(fileName || '').trim().replace(/[\/\\]+/g, '_');
+    return normalized || 'file';
+}

package/dist-electron/services/local-ai-core/src/{gateway → channel/weixin}/local-core-weixin-gateway.js

@@ -9,7 +9,8 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_events_1 = require("node:events");
 const node_crypto_2 = require("node:crypto");
-const desktop_js_1 = require("../../../../shared/desktop.js");
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const file_utils_js_1 = require("../shared/file-utils.js");
 // ==================== Constants ====================
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 const DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
@@ -33,6 +34,8 @@ const TEXT_ITEM_TYPE = 1;
 const IMAGE_ITEM_TYPE = 2;
 const VOICE_ITEM_TYPE = 3;
 const FILE_ITEM_TYPE = 4;
+const UPLOAD_MEDIA_TYPE_FILE = 3;
+const WEIXIN_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 // ==================== Utilities ====================
 function stripHtml(html) {
     let result = html;
@@ -453,6 +456,76 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return '';
         }
     }
+    async sendOutboundMessage(workspaceId, input) {
+        const state = this.runtime.get(workspaceId);
+        if (!state?.connected) {
+            throw new Error(`WeChat workspace is not connected: ${workspaceId}`);
+        }
+        const channelId = String(input.route?.channelId || '').trim();
+        if (!channelId) {
+            throw new Error('Missing WeChat target channel id');
+        }
+        const binding = await this.getBinding(workspaceId);
+        const contextToken = this.resolveContextTokenForFileSend(workspaceId, channelId, input.route.participantId);
+        const messageIds = [];
+        const attachments = [];
+        for (const part of input.parts || []) {
+            if (part.type === 'text') {
+                const text = String(part.text || '').trim();
+                if (text) {
+                    await this.sendTextMessage(state, channelId, text, contextToken);
+                    messageIds.push(`wx_text_${(0, node_crypto_2.randomUUID)()}`);
+                }
+                continue;
+            }
+            if (part.type === 'file') {
+                const sent = await this.sendFilePart(binding, channelId, part, contextToken);
+                messageIds.push(sent.messageId);
+                attachments.push({
+                    kind: 'file',
+                    attachmentId: sent.uploaded.fileKey,
+                    fileName: sent.file.fileName,
+                    fileSize: sent.file.fileSize,
+                    metadata: {
+                        fileKey: sent.uploaded.fileKey,
+                        encryptedQueryParam: sent.uploaded.encryptedQueryParam,
+                    },
+                });
+            }
+        }
+        return {
+            platform: 'weixin',
+            workspaceId,
+            channelId,
+            participantId: input.route.participantId,
+            messageIds,
+            attachments,
+        };
+    }
+    async sendFile(workspaceId, input) {
+        const result = await this.sendOutboundMessage(workspaceId, {
+            route: {
+                type: 'channel.chat',
+                channelId: input.channelId,
+                participantId: input.participantId,
+            },
+            parts: [{
+                    type: 'file',
+                    path: input.path,
+                    fileName: input.fileName,
+                }],
+        });
+        const attachment = result.attachments?.[0];
+        return {
+            platform: 'weixin',
+            workspaceId,
+            channelId: result.channelId,
+            messageId: result.messageIds[0] || '',
+            fileKey: String(attachment?.metadata?.fileKey || attachment?.attachmentId || ''),
+            fileName: attachment?.fileName || input.fileName || '',
+            fileSize: attachment?.fileSize || 0,
+        };
+    }
     // ==================== Inbound Message Handling ====================
     async handleInboundMessage(input) {
         if (this.isDuplicateInboundMessage(input)) {
@@ -949,9 +1022,123 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             base_info: { channel_version: WEIXIN_CHANNEL_VERSION },
         }, API_TIMEOUT_MS);
     }
+    async sendFileMessage(binding, toUserId, fileName, uploaded, contextToken) {
+        const clientId = `openclaw-weixin-${node_crypto_1.default.randomUUID()}`;
+        const resp = await this.apiPost(binding, 'ilink/bot/sendmessage', {
+            msg: {
+                from_user_id: '',
+                to_user_id: toUserId,
+                client_id: clientId,
+                message_type: 2,
+                message_state: 2,
+                item_list: [{
+                        type: FILE_ITEM_TYPE,
+                        file_item: {
+                            media: {
+                                encrypt_query_param: uploaded.encryptedQueryParam,
+                                aes_key: Buffer.from(uploaded.aesKeyHex).toString('base64'),
+                                encrypt_type: 1,
+                            },
+                            file_name: fileName,
+                            len: String(uploaded.fileSize),
+                        },
+                    }],
+                ...(contextToken ? { context_token: contextToken } : {}),
+            },
+            base_info: { channel_version: WEIXIN_CHANNEL_VERSION },
+        }, API_TIMEOUT_MS);
+        if (this.isSendMessageError(resp)) {
+            throw new Error(`WeChat send file failed: ret=${resp.ret} errcode=${resp.errcode}${resp.errmsg ? ` errmsg=${resp.errmsg}` : ''}`);
+        }
+        return clientId;
+    }
+    async sendFilePart(binding, channelId, part, contextToken) {
+        const file = await (0, file_utils_js_1.prepareChannelFile)({
+            path: part.path,
+            fileName: part.fileName,
+            maxBytes: WEIXIN_MAX_UPLOAD_FILE_SIZE,
+            platformLabel: 'WeChat',
+        });
+        const uploaded = await this.uploadFileToCdn(binding, channelId, file.path);
+        const messageId = await this.sendFileMessage(binding, channelId, file.fileName, uploaded, contextToken);
+        this.options.log?.(`localcore-weixin sent file ${file.fileName} (${file.fileSize} bytes) to ${channelId}`);
+        return {
+            messageId,
+            uploaded,
+            file,
+        };
+    }
     isSendMessageError(resp) {
         return (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
     }
+    async uploadFileToCdn(binding, toUserId, filePath) {
+        const plaintext = await node_fs_1.default.promises.readFile(filePath);
+        const fileKey = node_crypto_1.default.randomBytes(16).toString('hex');
+        const aesKey = node_crypto_1.default.randomBytes(16);
+        const aesKeyHex = aesKey.toString('hex');
+        const rawMd5 = node_crypto_1.default.createHash('md5').update(plaintext).digest('hex');
+        const cipherSize = this.getAesEcbPaddedSize(plaintext.length);
+        const uploadUrlResp = await this.apiPost(binding, 'ilink/bot/getuploadurl', {
+            filekey: fileKey,
+            media_type: UPLOAD_MEDIA_TYPE_FILE,
+            to_user_id: toUserId,
+            rawsize: plaintext.length,
+            rawfilemd5: rawMd5,
+            filesize: cipherSize,
+            no_need_thumb: true,
+            aeskey: aesKeyHex,
+            base_info: { channel_version: WEIXIN_CHANNEL_VERSION },
+        }, API_TIMEOUT_MS);
+        if (this.isSendMessageError(uploadUrlResp) || !uploadUrlResp.upload_param) {
+            throw new Error(`WeChat getuploadurl failed: ret=${uploadUrlResp.ret} errcode=${uploadUrlResp.errcode}${uploadUrlResp.errmsg ? ` errmsg=${uploadUrlResp.errmsg}` : ''}`);
+        }
+        const encryptedQueryParam = await this.uploadEncryptedBufferToCdn(binding, plaintext, uploadUrlResp.upload_param, fileKey, aesKey);
+        return {
+            fileKey,
+            encryptedQueryParam,
+            aesKeyHex,
+            fileSize: plaintext.length,
+            cipherSize,
+        };
+    }
+    async uploadEncryptedBufferToCdn(binding, plaintext, uploadParam, fileKey, aesKey) {
+        const cipher = node_crypto_1.default.createCipheriv('aes-128-ecb', aesKey, null);
+        const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        const url = `${binding.cdnBaseUrl.replace(/\/$/, '')}/upload?encrypted_query_param=${encodeURIComponent(uploadParam)}&filekey=${encodeURIComponent(fileKey)}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/octet-stream',
+            },
+            body: new Uint8Array(ciphertext),
+        });
+        if (!res.ok) {
+            throw new Error(`WeChat CDN upload failed: HTTP ${res.status}`);
+        }
+        const encryptedQueryParam = res.headers.get('x-encrypted-param') || '';
+        if (!encryptedQueryParam) {
+            throw new Error('WeChat CDN upload response missing x-encrypted-param');
+        }
+        return encryptedQueryParam;
+    }
+    getAesEcbPaddedSize(size) {
+        return Math.ceil((size + 1) / 16) * 16;
+    }
+    resolveContextTokenForFileSend(workspaceId, channelId, participantId) {
+        const preferredParticipantId = String(participantId || '').trim();
+        const direct = preferredParticipantId
+            ? this.options.store.getPlatformThreadBinding(workspaceId, channelId, preferredParticipantId, 'weixin')
+            : undefined;
+        if (direct?.last_platform_message_id) {
+            return direct.last_platform_message_id;
+        }
+        const users = this.options.store.listAuthorizedUsers(workspaceId, 'weixin');
+        const user = users.find((entry) => entry.chatId === channelId || entry.platformUserId === channelId);
+        if (!user) {
+            return '';
+        }
+        return this.options.store.getPlatformThreadBinding(workspaceId, user.chatId, user.platformUserId, 'weixin')?.last_platform_message_id || '';
+    }
     // ==================== Private: Attachment Download ====================
     sniffExtAndKind(buf) {
         if (buf[0] === 0xff && buf[1] === 0xd8)

package/dist-electron/services/local-ai-core/src/cli/lac.js

@@ -10,11 +10,20 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
     try {
         const { positionals, flags } = parseArgs(argv);
         const [domain = '', action = '', maybeId = ''] = positionals;
+        const json = getBooleanFlag(flags, 'json', false);
+        if (domain === 'channel') {
+            switch (action) {
+                case 'send-file':
+                    return await handleChannelSendFile(flags, env, io, json);
+                default:
+                    printUsage(io.stderr);
+                    return 2;
+            }
+        }
         if (domain !== 'scheduler') {
             printUsage(io.stderr);
             return 2;
         }
-        const json = getBooleanFlag(flags, 'json', false);
         switch (action) {
             case 'add':
                 return await handleAdd(flags, env, io, json);
@@ -39,6 +48,36 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
         return 1;
     }
 }
+async function handleChannelSendFile(flags, env, io, json) {
+    const context = resolveContext(flags, env);
+    const filePath = getRequiredFlag(flags, 'path');
+    const platform = getFlag(flags, 'platform') || context.platform;
+    if (!platform) {
+        throw new Error('channel send-file requires a platform. Set LOCAL_AI_PLATFORM or pass --platform.');
+    }
+    if (!context.workspaceId) {
+        throw new Error('channel send-file requires a workspace context. Set LOCAL_AI_WORKSPACE_ID or pass --workspace.');
+    }
+    const target = getFlag(flags, 'target') || getFlag(flags, 'chat-id') || context.chatId;
+    if (!target) {
+        throw new Error('channel send-file requires a target. Set LOCAL_AI_CHAT_ID or pass --target.');
+    }
+    const result = await request(context.baseUrl, 'POST', `/platforms/${encodeURIComponent(platform)}/${encodeURIComponent(context.workspaceId)}/messages`, {
+        route: {
+            type: 'channel.chat',
+            channelId: target,
+            participantId: getFlag(flags, 'participant-id') || context.platformUserId || undefined,
+        },
+        parts: [{
+                type: 'file',
+                path: filePath,
+                fileName: getFlag(flags, 'name') || undefined,
+            }],
+    });
+    const file = result.attachments?.[0];
+    print(json, io.stdout, result, `Sent file ${file?.fileName || filePath} to ${result.channelId}: ${result.messageIds[0] || ''}`);
+    return 0;
+}
 async function handleAdd(flags, env, io, json) {
     const cronExpr = getRequiredFlag(flags, 'cron');
     const promptTemplate = getRequiredFlag(flags, 'message');
@@ -265,6 +304,7 @@ function printUsage(output) {
         '  lac scheduler edit <job-id> [--cron "<expr>"] [--message "<text>"] [--desc "<label>"] [--enabled true|false] [--execution-mode same-thread|side-thread] [--json]',
         '  lac scheduler del <job-id> [--json]',
         '  lac scheduler run <job-id> [--json]',
+        '  lac channel send-file --path "<file>" [--target <chat-or-user-id>] [--workspace <id>] [--platform lark] [--name <filename>] [--json]',
     ].join('\n') + '\n');
 }
 function formatJobLine(job) {

package/dist-electron/services/local-ai-core/src/plugins/builtin/channel-lark-plugin.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinLarkChannelPlugin = createBuiltinLarkChannelPlugin;
-const local_core_lark_gateway_js_1 = require("../../gateway/local-core-lark-gateway.js");
+const local_core_lark_gateway_js_1 = require("../../channel/lark/local-core-lark-gateway.js");
 function createBuiltinLarkChannelPlugin(options) {
     let runtime = null;
     let unsubscribeBridgeEvents = null;

package/dist-electron/services/local-ai-core/src/plugins/builtin/channel-weixin-plugin.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinWeixinChannelPlugin = createBuiltinWeixinChannelPlugin;
-const local_core_weixin_gateway_js_1 = require("../../gateway/local-core-weixin-gateway.js");
+const local_core_weixin_gateway_js_1 = require("../../channel/weixin/local-core-weixin-gateway.js");
 function createBuiltinWeixinChannelPlugin(options) {
     let runtime = null;
     let unsubscribeBridgeEvents = null;