@kafca/agentdock 0.1.21 → 0.1.23

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

@@ -9,13 +9,12 @@ 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");
+const config_js_1 = require("./config.js");
+const transport_js_1 = require("./transport.js");
 // ==================== Constants ====================
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
-const DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
-const DEFAULT_CDN_BASE_URL = 'https://novac2c.cdn.weixin.qq.com/c2c';
-const LONG_POLL_TIMEOUT_MS = 35_000;
-const API_TIMEOUT_MS = 15_000;
 const RETRY_DELAY_MS = 2_000;
 const BACKOFF_DELAY_MS = 30_000;
 const MAX_CONSECUTIVE_FAILURES = 3;
@@ -25,14 +24,8 @@ const WEIXIN_CONTEXT_REPLY_MAX_BYTES = 3500;
 const WEIXIN_CONTEXT_SEND_LIMIT = 10;
 const WEIXIN_RESERVED_TERMINAL_SENDS = 1;
 const WEIXIN_PROGRESS_SEND_BUDGET = WEIXIN_CONTEXT_SEND_LIMIT - WEIXIN_RESERVED_TERMINAL_SENDS;
-const WEIXIN_CHANNEL_VERSION = '2.1.7';
-const WEIXIN_ILINK_APP_ID = 'bot';
-const WEIXIN_ILINK_APP_CLIENT_VERSION = '131335';
 const RESPONSE_TIMEOUT_MS = 5 * 60 * 1000;
-const TEXT_ITEM_TYPE = 1;
-const IMAGE_ITEM_TYPE = 2;
-const VOICE_ITEM_TYPE = 3;
-const FILE_ITEM_TYPE = 4;
+const WEIXIN_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 // ==================== Utilities ====================
 function stripHtml(html) {
     let result = html;
@@ -57,18 +50,6 @@ function sleep(ms, signal) {
         signal?.addEventListener('abort', onAbort, { once: true });
     });
 }
-function safeFilePart(value) {
-    return String(value || 'default').replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 80) || 'default';
-}
-function createWechatUin() {
-    return Buffer.from(String(node_crypto_1.default.randomInt(0, 0xffffffff))).toString('base64');
-}
-function createIlinkHeaders() {
-    return {
-        'iLink-App-Id': WEIXIN_ILINK_APP_ID,
-        'iLink-App-ClientVersion': WEIXIN_ILINK_APP_CLIENT_VERSION,
-    };
-}
 function utf8ByteLength(value) {
     return Buffer.byteLength(value, 'utf-8');
 }
@@ -160,21 +141,25 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
     async refreshBindings() {
         const config = await this.options.readConfig();
         const bindings = this.collectBindings(config);
-        const nextWorkspaceIds = new Set(bindings.map((b) => b.workspaceId));
-        for (const workspaceId of [...this.runtime.keys()]) {
-            if (!nextWorkspaceIds.has(workspaceId)) {
-                await this.stopWorkspace(workspaceId);
+        const nextKeys = new Set(bindings.map((b) => (0, config_js_1.runtimeKey)(b.workspaceId, b.instanceId)));
+        for (const key of [...this.runtime.keys()]) {
+            if (!nextKeys.has(key)) {
+                await this.stopWorkspaceKey(key);
             }
         }
         for (const binding of bindings) {
-            const current = this.runtime.get(binding.workspaceId);
+            const key = (0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId);
+            const current = this.runtime.get(key);
             if (!binding.enabled) {
                 if (current) {
-                    await this.stopWorkspace(binding.workspaceId);
+                    await this.stopWorkspaceKey(key);
                 }
                 else {
-                    this.runtime.set(binding.workspaceId, {
+                    this.runtime.set(key, {
                         workspaceId: binding.workspaceId,
+                        instanceId: binding.instanceId,
+                        displayName: binding.displayName,
+                        platformKey: binding.platformKey,
                         enabled: false,
                         status: 'disabled',
                         connected: false,
@@ -190,35 +175,39 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
         this.notifyRuntimeStateChanged();
     }
-    async testConnection(workspaceId) {
-        const binding = await this.getBinding(workspaceId);
+    async testConnection(workspaceId, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
         try {
-            const bufPath = this.getBufPath(binding);
+            const bufPath = (0, config_js_1.getWeixinBufPath)(binding);
             node_fs_1.default.accessSync(bufPath);
-            return { success: true, platform: 'weixin', workspaceId, appId: binding.accountId };
+            return { success: true, platform: 'weixin', workspaceId, instanceId: binding.instanceId, appId: binding.accountId };
         }
         catch {
-            return { success: false, platform: 'weixin', workspaceId, error: 'No sync buf found for account. Ensure the plugin has been connected at least once.' };
+            return { success: false, platform: 'weixin', workspaceId, instanceId: binding.instanceId, error: 'No sync buf found for account. Ensure the plugin has been connected at least once.' };
         }
     }
-    async enable(workspaceId) {
-        const binding = await this.getBinding(workspaceId);
+    async enable(workspaceId, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
         await this.startWorkspace(binding);
-        return this.getStatus(workspaceId);
+        return this.getStatus(workspaceId, binding.instanceId);
     }
-    async disable(workspaceId) {
-        await this.stopWorkspace(workspaceId);
-        return this.getStatus(workspaceId);
+    async disable(workspaceId, instanceId) {
+        await this.stopWorkspace(workspaceId, instanceId);
+        return this.getStatus(workspaceId, instanceId);
     }
-    getStatus(workspaceId) {
+    getStatus(workspaceId, instanceId) {
         this.options.store.expirePendingPairings();
-        const binding = this.runtime.get(workspaceId);
+        const resolved = this.resolveRuntimeState(workspaceId, instanceId);
+        const binding = resolved.state;
+        const platformKey = binding?.platformKey || (0, config_js_1.channelPlatformKey)('weixin', resolved.instanceId);
         const pairings = this.options.store.listPendingPairings(workspaceId)
-            .filter((row) => row.platform === 'weixin' && row.expires_at >= new Date().toISOString());
-        const users = this.options.store.listAuthorizedUsers(workspaceId, 'weixin');
+            .filter((row) => row.platform === platformKey && row.expires_at >= new Date().toISOString());
+        const users = this.options.store.listAuthorizedUsers(workspaceId, platformKey);
         return {
             workspaceId,
             platform: 'weixin',
+            instanceId: resolved.instanceId,
+            displayName: binding?.displayName,
             enabled: Boolean(binding?.enabled),
             connected: Boolean(binding?.connected),
             status: binding?.status || 'disabled',
@@ -230,16 +219,20 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         };
     }
     listStatuses() {
-        return [...this.runtime.keys()].sort().map((workspaceId) => this.getStatus(workspaceId));
+        return [...this.runtime.values()]
+            .sort((a, b) => `${a.workspaceId}:${a.instanceId}`.localeCompare(`${b.workspaceId}:${b.instanceId}`))
+            .map((state) => this.getStatus(state.workspaceId, state.instanceId));
     }
     listPendingPairings(workspaceId) {
         this.options.store.expirePendingPairings();
         return this.options.store
-            .listPairingRequests(workspaceId, 'weixin')
+            .listPairingRequests(workspaceId)
+            .filter((item) => item.platform === 'weixin' || item.platform.startsWith('weixin:'))
             .filter((item) => item.status === 'pending' && item.expiresAt >= new Date().toISOString());
     }
     listAuthorizedUsers(workspaceId) {
-        return this.options.store.listAuthorizedUsers(workspaceId, 'weixin');
+        return this.options.store.listAuthorizedUsers(workspaceId)
+            .filter((item) => item.platform === 'weixin' || item.platform.startsWith('weixin:'));
     }
     async start() {
         await this.refreshBindings();
@@ -248,12 +241,12 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         this.close();
     }
     close() {
-        return Promise.all([...this.runtime.keys()].map((id) => this.stopWorkspace(id))).then(() => undefined);
+        return Promise.all([...this.runtime.keys()].map((id) => this.stopWorkspaceKey(id))).then(() => undefined);
     }
     // ==================== QR Code Login ====================
-    async getQrCode(workspaceId) {
-        const binding = await this.getBinding(workspaceId);
-        const data = await this.apiGet(binding, `ilink/bot/get_bot_qrcode?bot_type=3`);
+    async getQrCode(workspaceId, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
+        const data = await (0, transport_js_1.weixinApiGet)(binding, `ilink/bot/get_bot_qrcode?bot_type=3`);
         if (data.errcode && data.errcode !== 0) {
             throw new Error(`Failed to get QR code: ${data.errmsg || data.errcode}`);
         }
@@ -261,11 +254,11 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             throw new Error('No QR code returned from iLink');
         }
         const qrCodeUrl = data.qrcode_img_content || `${binding.baseUrl.replace(/\/$/, '')}/ilink/bot/qr_code/${data.qrcode}`;
-        return { ticket: data.qrcode, expiresIn: data.expired || 180, qrCodeUrl };
+        return { ticket: data.qrcode, expiresIn: data.expired || 180, qrCodeUrl, instanceId: binding.instanceId, displayName: binding.displayName };
     }
-    async checkQrCodeStatus(workspaceId, ticket) {
-        const binding = await this.getBinding(workspaceId);
-        const data = await this.apiGet(binding, `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(ticket)}`);
+    async checkQrCodeStatus(workspaceId, ticket, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
+        const data = await (0, transport_js_1.weixinApiGet)(binding, `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(ticket)}`);
         if (data.errcode && data.errcode !== 0) {
             throw new Error(`Failed to check QR code status: ${data.errmsg || data.errcode}`);
         }
@@ -274,14 +267,14 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             if (!data.bot_token) {
                 throw new Error('WeChat QR code confirmed but no bot token was returned.');
             }
-            this.saveCredentials(binding, {
+            (0, config_js_1.saveWeixinCredentials)(binding, {
                 token: data.bot_token,
                 baseUrl: data.baseurl || binding.baseUrl,
                 botId: data.ilink_bot_id,
                 userId: data.ilink_user_id || data.user_id,
                 savedAt: new Date().toISOString(),
             });
-            await this.startWorkspace(await this.getBinding(workspaceId));
+            await this.startWorkspace(await this.getBinding(workspaceId, binding.instanceId));
         }
         if (!['wait', 'signed', 'confirmed', 'expired'].includes(status)) {
             return { status: 'wait' };
@@ -298,7 +291,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         const pairing = this.options.store.getPairingRequest(code);
         if (!pairing)
             throw new Error(`Pairing code not found: ${code}`);
-        if (pairing.platform !== 'weixin')
+        if (pairing.platform !== 'weixin' && !pairing.platform.startsWith('weixin:'))
             throw new Error(`Pairing code ${code} is not a WeChat pairing`);
         if (pairing.status !== 'pending')
             throw new Error(`Pairing code ${code} is already ${pairing.status}`);
@@ -306,13 +299,13 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             this.options.store.updatePairingStatus(code, 'expired');
             throw new Error(`Pairing code ${code} has expired`);
         }
-        const existing = this.options.store.getAuthorizedUser(pairing.workspace_id, pairing.platform_user_id, 'weixin');
+        const existing = this.options.store.getAuthorizedUser(pairing.workspace_id, pairing.platform_user_id, pairing.platform);
         const userId = existing?.id || `wx-user-${(0, node_crypto_2.randomUUID)()}`;
         const authorizedAt = new Date().toISOString();
         this.options.store.createAuthorizedUser({
             id: userId,
             workspace_id: pairing.workspace_id,
-            platform: 'weixin',
+            platform: pairing.platform,
             platform_user_id: pairing.platform_user_id,
             chat_id: pairing.chat_id,
             display_name: pairing.display_name,
@@ -321,7 +314,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         });
         this.options.store.updatePairingStatus(code, 'approved');
         this.notifyRuntimeStateChanged();
-        const user = this.options.store.listAuthorizedUsers(pairing.workspace_id, 'weixin').find((e) => e.id === userId);
+        const user = this.options.store.listAuthorizedUsers(pairing.workspace_id, pairing.platform).find((e) => e.id === userId);
         if (!user)
             throw new Error('Authorized user lookup failed after approval');
         return user;
@@ -330,7 +323,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         const pairing = this.options.store.getPairingRequest(code);
         if (!pairing)
             throw new Error(`Pairing code not found: ${code}`);
-        if (pairing.platform !== 'weixin')
+        if (pairing.platform !== 'weixin' && !pairing.platform.startsWith('weixin:'))
             throw new Error(`Pairing code ${code} is not a WeChat pairing`);
         this.options.store.updatePairingStatus(code, 'rejected');
         this.notifyRuntimeStateChanged();
@@ -360,12 +353,14 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             this.options.log?.(`localcore-weixin bridge route miss for sessionKey=${sessionKey} type=${event.type}`);
             return;
         }
-        const state = this.runtime.get(route.workspaceId);
+        const routeInstanceId = route.instanceId || 'default';
+        const routePlatformKey = route.platformKey || (0, config_js_1.channelPlatformKey)('weixin', routeInstanceId);
+        const state = this.runtime.get((0, config_js_1.runtimeKey)(route.workspaceId, routeInstanceId)) || this.runtime.get(route.workspaceId);
         if (!state?.connected) {
             this.options.log?.(`localcore-weixin bridge event ignored because workspace is not connected: ${route.workspaceId}`);
             return;
         }
-        const initialBinding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId, 'weixin');
+        const initialBinding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId, routePlatformKey);
         if (!initialBinding) {
             this.options.log?.(`localcore-weixin bridge binding miss for workspace=${route.workspaceId}`);
             return;
@@ -383,7 +378,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         const current = previous
             .catch(() => undefined)
             .then(async () => {
-            const binding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId, 'weixin');
+            const binding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId, routePlatformKey);
             if (!binding)
                 return;
             if (this.mutedThreadBridgeCounts.has(binding.thread_id))
@@ -438,7 +433,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         return this.sendScheduledMessage(workspaceId, { type: 'channel.chat', channelId: chatId }, text);
     }
     async sendScheduledMessage(workspaceId, route, text) {
-        const state = this.runtime.get(workspaceId);
+        const state = this.resolveRuntimeState(workspaceId, route.instanceId).state;
         if (!state?.connected) {
             this.options.log?.(`localcore-weixin scheduled message skipped: workspace not connected: ${workspaceId}`);
             return '';
@@ -453,8 +448,81 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return '';
         }
     }
+    async sendOutboundMessage(workspaceId, input) {
+        const state = this.resolveRuntimeState(workspaceId, input.route?.instanceId).state;
+        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, input.route?.instanceId);
+        const platformKey = state.platformKey;
+        const contextToken = this.resolveContextTokenForFileSend(workspaceId, channelId, input.route.participantId, platformKey);
+        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) {
+        const instanceId = input.instanceId || 'default';
+        const platformKey = input.platformKey || (0, config_js_1.channelPlatformKey)('weixin', instanceId);
         if (this.isDuplicateInboundMessage(input)) {
             this.options.log?.(`localcore-weixin skipped duplicate inbound message workspace=${input.workspaceId} chat=${input.chatId} id=${input.contextToken || input.messageId}`);
             return { paired: true, duplicate: true };
@@ -472,28 +540,28 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             },
         });
         this.options.store.expirePendingPairings();
-        const binding = await this.getBinding(input.workspaceId);
-        let authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, 'weixin');
+        const binding = await this.getBinding(input.workspaceId, instanceId);
+        let authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, platformKey);
         if (!authorized) {
             if (binding.allowFrom === '*') {
                 const authorizedAt = new Date().toISOString();
                 this.options.store.createAuthorizedUser({
                     id: `wx-user-${(0, node_crypto_2.randomUUID)()}`,
                     workspace_id: input.workspaceId,
-                    platform: 'weixin',
+                    platform: platformKey,
                     platform_user_id: input.platformUserId,
                     chat_id: input.chatId,
                     display_name: input.displayName,
                     thread_id: null,
                     authorized_at: authorizedAt,
                 });
-                authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, 'weixin');
+                authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, platformKey);
                 this.options.log?.(`localcore-weixin auto-approved user for ${input.workspaceId}: ${input.platformUserId}`);
                 this.notifyRuntimeStateChanged();
             }
         }
         if (!authorized) {
-            const existingPending = this.options.store.listPendingPairings(input.workspaceId).find((item) => item.platform === 'weixin' && item.platform_user_id === input.platformUserId && item.chat_id === input.chatId && item.status === 'pending');
+            const existingPending = this.options.store.listPendingPairings(input.workspaceId).find((item) => item.platform === platformKey && item.platform_user_id === input.platformUserId && item.chat_id === input.chatId && item.status === 'pending');
             let pairingCode = existingPending?.code || '';
             if (!existingPending) {
                 const now = new Date();
@@ -501,7 +569,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 this.options.store.createPairingRequest({
                     code: pairingCode,
                     workspace_id: input.workspaceId,
-                    platform: 'weixin',
+                    platform: platformKey,
                     platform_user_id: input.platformUserId,
                     chat_id: input.chatId,
                     display_name: input.displayName,
@@ -511,23 +579,23 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 });
                 this.notifyRuntimeStateChanged();
             }
-            const state = this.runtime.get(input.workspaceId);
+            const state = this.runtime.get((0, config_js_1.runtimeKey)(input.workspaceId, instanceId));
             if (state?.connected) {
                 await this.sendTextMessage(state, input.chatId, `**已收到消息**\n\n当前账号还未授权接入这个工作区。\n请在桌面端完成审批后再次发送消息。\n\n配对码：\`${pairingCode}\``, input.contextToken);
             }
             return { paired: false };
         }
         const router = this.options.getWorkspaceRouter();
-        const threadBinding = this.options.store.getPlatformThreadBinding(input.workspaceId, input.chatId, input.platformUserId, 'weixin');
+        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 || `WeChat ${input.chatId}`);
             threadId = thread.id;
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, 'weixin');
+            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, platformKey);
             const now = new Date().toISOString();
             this.options.store.upsertPlatformThreadBinding({
                 workspace_id: input.workspaceId,
-                platform: 'weixin',
+                platform: platformKey,
                 chat_id: input.chatId,
                 platform_user_id: input.platformUserId,
                 thread_id: threadId,
@@ -538,13 +606,15 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
         const sessionKey = router.getThreadSessionKey(threadId);
         const normalizedText = String(input.text || '').trim().toLowerCase();
-        const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny') ? this.findAwaitingPermissionThreadId(input.workspaceId, input.chatId, input.platformUserId) : '';
+        const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny') ? this.findAwaitingPermissionThreadId(input.workspaceId, input.chatId, input.platformUserId, input.platformKey) : '';
         if (permissionThreadId && permissionThreadId !== threadId) {
             threadId = permissionThreadId;
         }
         const effectiveSessionKey = router.getThreadSessionKey(threadId);
         this.threadRouting.set(effectiveSessionKey, {
             workspaceId: input.workspaceId,
+            instanceId,
+            platformKey,
             platformUserId: input.platformUserId,
             chatId: input.chatId,
             threadId,
@@ -555,10 +625,10 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'WeChat'} ${new Date().toLocaleTimeString()}`;
             const nextThread = await router.createThread(input.workspaceId, title);
             const now = new Date().toISOString();
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, 'weixin');
+            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, platformKey);
             this.options.store.upsertPlatformThreadBinding({
                 workspace_id: input.workspaceId,
-                platform: 'weixin',
+                platform: platformKey,
                 chat_id: input.chatId,
                 platform_user_id: input.platformUserId,
                 thread_id: nextThread.id,
@@ -568,11 +638,13 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             });
             this.threadRouting.set(router.getThreadSessionKey(nextThread.id), {
                 workspaceId: input.workspaceId,
+                instanceId,
+                platformKey,
                 platformUserId: input.platformUserId,
                 chatId: input.chatId,
                 threadId: nextThread.id,
             });
-            const st = this.runtime.get(input.workspaceId);
+            const st = this.runtime.get((0, config_js_1.runtimeKey)(input.workspaceId, instanceId));
             if (st?.connected) {
                 await this.sendTextMessage(st, input.chatId, '**已开始新会话**', input.contextToken);
             }
@@ -584,70 +656,49 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             await router.sendThreadAction(threadId, input.text);
             return { paired: true, threadId };
         }
-        this.options.store.updatePlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId, input.contextToken || input.messageId, 'weixin');
+        this.options.store.updatePlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId, input.contextToken || input.messageId, platformKey);
         const wrappedText = (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
         await router.sendThreadMessage(threadId, this.createThreadMessageInput(wrappedText, input.contentParts));
         return { paired: true, threadId };
     }
     // ==================== Private: Bindings ====================
-    async getBinding(workspaceId) {
+    resolveRuntimeState(workspaceId, instanceId) {
+        if (instanceId) {
+            const state = this.runtime.get((0, config_js_1.runtimeKey)(workspaceId, instanceId)) || (instanceId === 'default' ? this.runtime.get(workspaceId) : undefined);
+            return { instanceId, state };
+        }
+        const states = [...this.runtime.values()].filter((entry) => entry.workspaceId === workspaceId);
+        const state = states.find((entry) => entry.instanceId === 'default') || states[0];
+        return { instanceId: state?.instanceId || 'default', state: state || this.runtime.get(workspaceId) };
+    }
+    async getBinding(workspaceId, instanceId) {
         const config = await this.options.readConfig();
-        const binding = this.collectBindings(config).find((e) => e.workspaceId === workspaceId);
+        const bindings = this.collectBindings(config).filter((e) => e.workspaceId === workspaceId);
+        const binding = instanceId
+            ? bindings.find((entry) => entry.instanceId === instanceId)
+            : bindings.find((entry) => entry.instanceId === 'default') || bindings[0];
         if (!binding)
-            throw new Error(`No WeChat binding configured for workspace "${workspaceId}"`);
+            throw new Error(`No WeChat binding configured for workspace "${workspaceId}"${instanceId ? ` instance "${instanceId}"` : ''}`);
         return binding;
     }
     collectBindings(config) {
-        const projects = Array.isArray(config?.projects) ? config.projects : [];
-        return projects.flatMap((project) => {
-            const platforms = Array.isArray(project.platforms) ? project.platforms : [];
-            return platforms
-                .map((platform) => ({
-                platformType: (0, desktop_js_1.normalizeDesktopPlatformType)(platform?.type),
-                options: platform?.options && typeof platform.options === 'object'
-                    ? platform.options
-                    : {},
-            }))
-                .filter((p) => p.platformType === 'weixin')
-                .map((p) => {
-                const stateDir = String(p.options.state_dir || this.getDefaultStateDir()).trim();
-                const credentials = this.loadCredentials(project.name, stateDir);
-                const configuredToken = String(p.options.token || '').trim();
-                const configuredBaseUrl = String(p.options.base_url || '').trim();
-                const accountId = String(p.options.account_id || credentials?.botId || 'qr-login').trim();
-                return {
-                    workspaceId: project.name,
-                    token: configuredToken || credentials?.token || '',
-                    accountId,
-                    baseUrl: configuredBaseUrl || credentials?.baseUrl || DEFAULT_BASE_URL,
-                    cdnBaseUrl: String(p.options.cdn_base_url || DEFAULT_CDN_BASE_URL).trim(),
-                    allowFrom: String(p.options.allow_from || '*').trim(),
-                    routeTag: String(p.options.route_tag || '').trim(),
-                    longPollTimeoutMs: Number(p.options.long_poll_timeout_ms || LONG_POLL_TIMEOUT_MS) || LONG_POLL_TIMEOUT_MS,
-                    stateDir,
-                    proxy: String(p.options.proxy || '').trim(),
-                    proxyUsername: String(p.options.proxy_username || '').trim(),
-                    proxyPassword: String(p.options.proxy_password || '').trim(),
-                    enabled: true,
-                    project,
-                };
-            });
-        });
-    }
-    getDefaultStateDir() {
-        return node_path_1.default.join(process.cwd(), 'weixin-monitor');
+        return (0, config_js_1.collectWeixinWorkspaceBindings)(config);
     }
     // ==================== Private: Workspace Lifecycle ====================
     async startWorkspace(binding) {
-        await this.stopWorkspace(binding.workspaceId);
+        const key = (0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId);
+        await this.stopWorkspaceKey(key);
         const status = {
             workspaceId: binding.workspaceId,
+            instanceId: binding.instanceId,
+            displayName: binding.displayName,
+            platformKey: binding.platformKey,
             enabled: true,
             status: 'starting',
             connected: false,
             accountId: binding.accountId,
         };
-        this.runtime.set(binding.workspaceId, status);
+        this.runtime.set(key, status);
         this.notifyRuntimeStateChanged();
         try {
             const abortController = new AbortController();
@@ -682,16 +733,23 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
         this.notifyRuntimeStateChanged();
     }
-    async stopWorkspace(workspaceId) {
-        const state = this.runtime.get(workspaceId);
+    async stopWorkspace(workspaceId, instanceId) {
+        const resolved = this.resolveRuntimeState(workspaceId, instanceId);
+        await this.stopWorkspaceKey((0, config_js_1.runtimeKey)(workspaceId, resolved.instanceId));
+    }
+    async stopWorkspaceKey(key) {
+        const state = this.runtime.get(key);
         if (!state)
             return;
         try {
             state.abortController?.abort();
         }
         catch { }
-        this.runtime.set(workspaceId, {
-            workspaceId,
+        this.runtime.set(key, {
+            workspaceId: state.workspaceId,
+            instanceId: state.instanceId,
+            displayName: state.displayName,
+            platformKey: state.platformKey,
             enabled: false,
             status: 'stopped',
             connected: false,
@@ -700,35 +758,6 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         this.notifyRuntimeStateChanged();
     }
     // ==================== Private: Long-poll Monitor ====================
-    getBufPath(binding) {
-        return node_path_1.default.join(binding.stateDir, `${binding.accountId}.buf`);
-    }
-    getCredentialsPath(workspaceId, stateDir) {
-        return node_path_1.default.join(stateDir, `${safeFilePart(workspaceId)}.credentials.json`);
-    }
-    loadCredentials(workspaceId, stateDir) {
-        try {
-            const raw = node_fs_1.default.readFileSync(this.getCredentialsPath(workspaceId, stateDir), 'utf-8');
-            const parsed = JSON.parse(raw);
-            const token = String(parsed.token || '').trim();
-            if (!token)
-                return null;
-            return {
-                token,
-                baseUrl: parsed.baseUrl ? String(parsed.baseUrl) : undefined,
-                botId: parsed.botId ? String(parsed.botId) : undefined,
-                userId: parsed.userId ? String(parsed.userId) : undefined,
-                savedAt: parsed.savedAt ? String(parsed.savedAt) : new Date().toISOString(),
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    saveCredentials(binding, credentials) {
-        node_fs_1.default.mkdirSync(binding.stateDir, { recursive: true });
-        node_fs_1.default.writeFileSync(this.getCredentialsPath(binding.workspaceId, binding.stateDir), JSON.stringify(credentials, null, 2), 'utf-8');
-    }
     normalizeQrStatus(status) {
         const normalized = String(status || 'wait').trim().toLowerCase();
         if (normalized === 'scaned' || normalized === 'scanned' || normalized === 'signed')
@@ -739,32 +768,19 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return 'expired';
         return 'wait';
     }
-    loadBuf(binding) {
-        try {
-            return node_fs_1.default.readFileSync(this.getBufPath(binding), 'utf-8');
-        }
-        catch {
-            return '';
-        }
-    }
-    saveBuf(binding, buf) {
-        const dir = binding.stateDir;
-        node_fs_1.default.mkdirSync(dir, { recursive: true });
-        node_fs_1.default.writeFileSync(this.getBufPath(binding), buf, 'utf-8');
-    }
     async runMonitorLoop(binding, signal) {
-        let buf = this.loadBuf(binding);
+        let buf = (0, config_js_1.loadWeixinBuf)(binding);
         let consecutiveFailures = 0;
         while (!signal.aborted) {
             try {
-                const resp = await this.getUpdates(binding, buf, signal);
+                const resp = await (0, transport_js_1.getWeixinUpdates)(binding, buf, signal);
                 const isApiError = (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
                 if (isApiError) {
                     consecutiveFailures++;
                     const errorText = resp.errmsg ? ` errmsg=${resp.errmsg}` : '';
                     this.options.log?.(`localcore-weixin getUpdates failed for ${binding.workspaceId}: ret=${resp.ret} errcode=${resp.errcode}${errorText} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`);
                     if (resp.errcode === -14 || resp.ret === -14) {
-                        const state = this.runtime.get(binding.workspaceId);
+                        const state = this.runtime.get((0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId));
                         if (state) {
                             state.status = 'error';
                             state.connected = false;
@@ -784,13 +800,13 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 consecutiveFailures = 0;
                 if (resp.get_updates_buf) {
                     buf = resp.get_updates_buf;
-                    this.saveBuf(binding, buf);
+                    (0, config_js_1.saveWeixinBuf)(binding, buf);
                 }
                 for (const msg of resp.msgs ?? []) {
                     const items = msg.item_list ?? [];
-                    const textItem = items.find((i) => i.type === TEXT_ITEM_TYPE);
-                    const voiceTextItems = items.filter((i) => i.type === VOICE_ITEM_TYPE && i.voice_item?.text);
-                    const mediaItems = items.filter((i) => i.type === IMAGE_ITEM_TYPE || i.type === FILE_ITEM_TYPE);
+                    const textItem = items.find((i) => i.type === transport_js_1.TEXT_ITEM_TYPE);
+                    const voiceTextItems = items.filter((i) => i.type === transport_js_1.VOICE_ITEM_TYPE && i.voice_item?.text);
+                    const mediaItems = items.filter((i) => i.type === transport_js_1.IMAGE_ITEM_TYPE || i.type === transport_js_1.FILE_ITEM_TYPE);
                     if (!textItem && voiceTextItems.length === 0 && mediaItems.length === 0)
                         continue;
                     const conversationId = msg.from_user_id ?? '';
@@ -829,6 +845,8 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                         continue;
                     await this.handleInboundMessage({
                         workspaceId: binding.workspaceId,
+                        instanceId: binding.instanceId,
+                        platformKey: binding.platformKey,
                         platformUserId: conversationId,
                         chatId: conversationId,
                         displayName: conversationId.slice(-6),
@@ -858,65 +876,6 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
     }
     // ==================== Private: HTTP API ====================
-    async apiPost(binding, endpoint, bodyObj, timeoutMs, signal) {
-        const url = `${binding.baseUrl.replace(/\/$/, '')}/${endpoint}`;
-        const body = JSON.stringify(bodyObj);
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        const onAbort = () => controller.abort();
-        signal?.addEventListener('abort', onAbort, { once: true });
-        try {
-            const headers = {
-                'Content-Type': 'application/json',
-                'Content-Length': String(Buffer.byteLength(body, 'utf-8')),
-                'X-WECHAT-UIN': createWechatUin(),
-                ...createIlinkHeaders(),
-            };
-            if (binding.token) {
-                headers.AuthorizationType = 'ilink_bot_token';
-                headers.Authorization = `Bearer ${binding.token}`;
-            }
-            const res = await fetch(url, {
-                method: 'POST',
-                headers,
-                body,
-                signal: controller.signal,
-            });
-            if (!res.ok)
-                throw new Error(`HTTP ${res.status}`);
-            return (await res.json());
-        }
-        finally {
-            clearTimeout(timer);
-            signal?.removeEventListener('abort', onAbort);
-        }
-    }
-    async apiGet(binding, endpoint, timeoutMs = API_TIMEOUT_MS) {
-        const url = `${binding.baseUrl.replace(/\/$/, '')}/${endpoint}`;
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const headers = createIlinkHeaders();
-            if (binding.token) {
-                headers.AuthorizationType = 'ilink_bot_token';
-                headers.Authorization = `Bearer ${binding.token}`;
-            }
-            const res = await fetch(url, {
-                method: 'GET',
-                headers,
-                signal: controller.signal,
-            });
-            if (!res.ok)
-                throw new Error(`HTTP ${res.status}`);
-            return (await res.json());
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    async getUpdates(binding, buf, signal) {
-        return this.apiPost(binding, 'ilink/bot/getupdates', { get_updates_buf: buf, base_info: { channel_version: WEIXIN_CHANNEL_VERSION } }, binding.longPollTimeoutMs, signal);
-    }
     async sendTextMessage(state, toUserId, text, contextToken, options = {}) {
         const binding = await this.getBinding(state.workspaceId);
         const stripped = stripHtml(text);
@@ -925,32 +884,77 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             : splitTextByUtf8Bytes(stripped, WEIXIN_TEXT_MESSAGE_MAX_BYTES);
         for (const [index, chunk] of chunks.entries()) {
             const finalChunk = options.final && index === chunks.length - 1;
-            const resp = await this.sendTextMessageChunk(binding, toUserId, chunk, contextToken, {
+            const resp = await (0, transport_js_1.sendWeixinTextMessageChunk)(binding, toUserId, chunk, contextToken, {
                 clientId: options.clientId,
                 final: finalChunk,
             });
-            if (this.isSendMessageError(resp)) {
+            if ((0, transport_js_1.isWeixinApiError)(resp)) {
                 throw new Error(`WeChat sendmessage failed: ret=${resp.ret} errcode=${resp.errcode}${resp.errmsg ? ` errmsg=${resp.errmsg}` : ''} chunk=${index + 1}/${chunks.length} bytes=${utf8ByteLength(chunk)} context=${contextToken ? 'yes' : 'no'} message_state=${finalChunk ? 2 : 1}`);
             }
         }
         this.options.log?.(`localcore-weixin sent message to ${toUserId} for workspace ${state.workspaceId}${chunks.length > 1 ? ` chunks=${chunks.length}` : ''}`);
     }
-    async sendTextMessageChunk(binding, toUserId, text, contextToken, options = {}) {
-        return this.apiPost(binding, 'ilink/bot/sendmessage', {
-            msg: {
-                from_user_id: '',
-                to_user_id: toUserId,
-                client_id: options.clientId || `openclaw-weixin-${node_crypto_1.default.randomUUID()}`,
-                message_type: 2,
-                message_state: options.final === false ? 1 : 2,
-                item_list: [{ type: TEXT_ITEM_TYPE, text_item: { text } }],
-                ...(contextToken ? { context_token: contextToken } : {}),
-            },
-            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 (0, transport_js_1.sendWeixinFileMessage)(binding, toUserId, fileName, uploaded, contextToken, { clientId });
+        if ((0, transport_js_1.isWeixinApiError)(resp)) {
+            throw new Error(`WeChat send file failed: ret=${resp.ret} errcode=${resp.errcode}${resp.errmsg ? ` errmsg=${resp.errmsg}` : ''}`);
+        }
+        return clientId;
     }
-    isSendMessageError(resp) {
-        return (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
+    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,
+        };
+    }
+    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 (0, transport_js_1.getWeixinUploadUrl)(binding, fileKey, toUserId, plaintext.length, rawMd5, cipherSize, aesKeyHex);
+        if ((0, transport_js_1.isWeixinApiError)(uploadUrlResp) || !uploadUrlResp.upload_param) {
+            throw new Error(`WeChat getuploadurl failed: ret=${uploadUrlResp.ret} errcode=${uploadUrlResp.errcode}${uploadUrlResp.errmsg ? ` errmsg=${uploadUrlResp.errmsg}` : ''}`);
+        }
+        const encryptedQueryParam = await (0, transport_js_1.uploadEncryptedBufferToWeixinCdn)(binding, plaintext, uploadUrlResp.upload_param, fileKey, aesKey);
+        return {
+            fileKey,
+            encryptedQueryParam,
+            aesKeyHex,
+            fileSize: plaintext.length,
+            cipherSize,
+        };
+    }
+    getAesEcbPaddedSize(size) {
+        return Math.ceil((size + 1) / 16) * 16;
+    }
+    resolveContextTokenForFileSend(workspaceId, channelId, participantId, platformKey = 'weixin') {
+        const preferredParticipantId = String(participantId || '').trim();
+        const direct = preferredParticipantId
+            ? this.options.store.getPlatformThreadBinding(workspaceId, channelId, preferredParticipantId, platformKey)
+            : undefined;
+        if (direct?.last_platform_message_id) {
+            return direct.last_platform_message_id;
+        }
+        const users = this.options.store.listAuthorizedUsers(workspaceId, platformKey);
+        const user = users.find((entry) => entry.chatId === channelId || entry.platformUserId === channelId);
+        if (!user) {
+            return '';
+        }
+        return this.options.store.getPlatformThreadBinding(workspaceId, user.chatId, user.platformUserId, platformKey)?.last_platform_message_id || '';
     }
     // ==================== Private: Attachment Download ====================
     sniffExtAndKind(buf) {
@@ -998,7 +1002,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             resultBuf = rawBuf;
         }
         const { ext, kind } = this.sniffExtAndKind(resultBuf);
-        const declaredName = String(itemData?.file_name ?? (item.type === IMAGE_ITEM_TYPE ? 'image' : 'file'));
+        const declaredName = String(itemData?.file_name ?? (item.type === transport_js_1.IMAGE_ITEM_TYPE ? 'image' : 'file'));
         const safeName = declaredName.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 64);
         const safeMsgId = msgId.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 48);
         const fileName = `${safeMsgId}-${idx}-${safeName}${ext}`;
@@ -1174,9 +1178,9 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         this.processedInboundMessages.set(key, now + PROCESSED_MESSAGE_TTL_MS);
         return false;
     }
-    findAwaitingPermissionThreadId(workspaceId, chatId, platformUserId) {
+    findAwaitingPermissionThreadId(workspaceId, chatId, platformUserId, platformKey = 'weixin') {
         for (const [sessionKey, route] of this.threadRouting.entries()) {
-            if (route.workspaceId !== workspaceId || route.chatId !== chatId || route.platformUserId !== platformUserId)
+            if (route.workspaceId !== workspaceId || route.platformKey !== platformKey || route.chatId !== chatId || route.platformUserId !== platformUserId)
                 continue;
             const turn = this.outboundTurns.get(sessionKey);
             if (turn?.awaitingPermission && route.threadId)