@kafca/agentdock 0.1.22 → 0.1.23

package/dist-electron/services/local-ai-core/src/channel/weixin/transport.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPLOAD_MEDIA_TYPE_FILE = exports.FILE_ITEM_TYPE = exports.VOICE_ITEM_TYPE = exports.IMAGE_ITEM_TYPE = exports.TEXT_ITEM_TYPE = exports.WEIXIN_ILINK_APP_CLIENT_VERSION = exports.WEIXIN_ILINK_APP_ID = exports.WEIXIN_CHANNEL_VERSION = exports.API_TIMEOUT_MS = void 0;
+exports.createWechatUin = createWechatUin;
+exports.createIlinkHeaders = createIlinkHeaders;
+exports.weixinApiPost = weixinApiPost;
+exports.weixinApiGet = weixinApiGet;
+exports.getWeixinUpdates = getWeixinUpdates;
+exports.sendWeixinTextMessageChunk = sendWeixinTextMessageChunk;
+exports.sendWeixinFileMessage = sendWeixinFileMessage;
+exports.getWeixinUploadUrl = getWeixinUploadUrl;
+exports.uploadEncryptedBufferToWeixinCdn = uploadEncryptedBufferToWeixinCdn;
+exports.isWeixinApiError = isWeixinApiError;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+exports.API_TIMEOUT_MS = 15_000;
+exports.WEIXIN_CHANNEL_VERSION = '2.1.7';
+exports.WEIXIN_ILINK_APP_ID = 'bot';
+exports.WEIXIN_ILINK_APP_CLIENT_VERSION = '131335';
+exports.TEXT_ITEM_TYPE = 1;
+exports.IMAGE_ITEM_TYPE = 2;
+exports.VOICE_ITEM_TYPE = 3;
+exports.FILE_ITEM_TYPE = 4;
+exports.UPLOAD_MEDIA_TYPE_FILE = 3;
+function createWechatUin() {
+    return Buffer.from(String(node_crypto_1.default.randomInt(0, 0xffffffff))).toString('base64');
+}
+function createIlinkHeaders() {
+    return {
+        'iLink-App-Id': exports.WEIXIN_ILINK_APP_ID,
+        'iLink-App-ClientVersion': exports.WEIXIN_ILINK_APP_CLIENT_VERSION,
+    };
+}
+async function weixinApiPost(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 function weixinApiGet(binding, endpoint, timeoutMs = exports.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);
+    }
+}
+function getWeixinUpdates(binding, buf, signal) {
+    return weixinApiPost(binding, 'ilink/bot/getupdates', { get_updates_buf: buf, base_info: { channel_version: exports.WEIXIN_CHANNEL_VERSION } }, binding.longPollTimeoutMs, signal);
+}
+function sendWeixinTextMessageChunk(binding, toUserId, text, contextToken, options = {}) {
+    return weixinApiPost(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: exports.TEXT_ITEM_TYPE, text_item: { text } }],
+            ...(contextToken ? { context_token: contextToken } : {}),
+        },
+        base_info: { channel_version: exports.WEIXIN_CHANNEL_VERSION },
+    }, exports.API_TIMEOUT_MS);
+}
+function sendWeixinFileMessage(binding, toUserId, fileName, uploaded, contextToken, options = {}) {
+    return weixinApiPost(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: 2,
+            item_list: [{
+                    type: exports.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: exports.WEIXIN_CHANNEL_VERSION },
+    }, exports.API_TIMEOUT_MS);
+}
+function getWeixinUploadUrl(binding, fileKey, toUserId, plaintextLength, rawMd5, cipherSize, aesKeyHex) {
+    return weixinApiPost(binding, 'ilink/bot/getuploadurl', {
+        filekey: fileKey,
+        media_type: exports.UPLOAD_MEDIA_TYPE_FILE,
+        to_user_id: toUserId,
+        rawsize: plaintextLength,
+        rawfilemd5: rawMd5,
+        filesize: cipherSize,
+        no_need_thumb: true,
+        aeskey: aesKeyHex,
+        base_info: { channel_version: exports.WEIXIN_CHANNEL_VERSION },
+    }, exports.API_TIMEOUT_MS);
+}
+async function uploadEncryptedBufferToWeixinCdn(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;
+}
+function isWeixinApiError(resp) {
+    return (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
+}

package/dist-electron/services/local-ai-core/src/channel/weixin/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-electron/services/local-ai-core/src/kernel/bootstrap.js

@@ -220,6 +220,10 @@ function bootstrapLocalCoreRuntime(options) {
         .map((plugin) => resolveAgentRuntime(plugin, kernel.context).runtime);
     const channelRuntime = resolveChannelRuntime(channelPlugin, kernel.context).channel;
     weixinChannelRuntime = resolveChannelRuntime(weixinChannelPlugin, kernel.context).channel;
+    const channelRuntimes = [
+        channelRuntime,
+        weixinChannelRuntime,
+    ];
     const knowledgeRuntime = kernel.plugins.isEnabled(knowledgePlugin.manifest.id)
         ? resolveKnowledgeRuntime(knowledgePlugin, kernel.context)
         : resolveKnowledgeRuntime((0, knowledge_noop_plugin_js_1.createBuiltinNoopKnowledgePlugin)(), kernel.context);
@@ -278,6 +282,7 @@ function bootstrapLocalCoreRuntime(options) {
         state,
         store,
         agentRuntimes,
+        channelRuntimes,
         channelRuntime,
         weixinChannelRuntime,
         knowledgeProvider,

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

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinLarkChannelPlugin = createBuiltinLarkChannelPlugin;
 const local_core_lark_gateway_js_1 = require("../../channel/lark/local-core-lark-gateway.js");
+const plugin_js_1 = require("../../channel/shared/plugin.js");
 function createBuiltinLarkChannelPlugin(options) {
-    let runtime = null;
-    let unsubscribeBridgeEvents = null;
-    return {
+    return (0, plugin_js_1.createBuiltinChannelPlugin)({
         manifest: {
             id: 'builtin.channel-lark',
             kind: 'channel',
@@ -20,40 +19,20 @@ function createBuiltinLarkChannelPlugin(options) {
                 ],
             },
         },
-        capabilities: {
-            channels: [
-                {
-                    id: 'channel.lark',
-                    platform: 'lark',
-                    routeType: 'channel.chat',
-                    displayName: 'LocalCore Lark',
-                },
-            ],
-        },
-        createRuntime(ctx) {
-            if (!runtime) {
-                runtime = {
-                    channel: new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
-                        store: options.store,
-                        readConfig: options.readConfig,
-                        getWorkspaceRouter: options.getWorkspaceRouter,
-                        eventBus: ctx.bus,
-                        log: options.log,
-                    }),
-                };
-                unsubscribeBridgeEvents = ctx.bus.on('platform.bridge.updated', (event) => {
-                    void runtime?.channel.onBridgeEvent?.(event);
-                });
-            }
-            return runtime;
-        },
-        async start() {
-            await runtime?.channel.refreshBindings?.();
-        },
-        async stop() {
-            unsubscribeBridgeEvents?.();
-            unsubscribeBridgeEvents = null;
-            runtime?.channel.close?.();
-        },
-    };
+        channels: [
+            {
+                id: 'channel.lark',
+                platform: 'lark',
+                routeType: 'channel.chat',
+                displayName: 'LocalCore Lark',
+            },
+        ],
+        createChannel: (ctx) => new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+            store: options.store,
+            readConfig: options.readConfig,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+            eventBus: ctx.bus,
+            log: options.log,
+        }),
+    });
 }

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

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinWeixinChannelPlugin = createBuiltinWeixinChannelPlugin;
 const local_core_weixin_gateway_js_1 = require("../../channel/weixin/local-core-weixin-gateway.js");
+const plugin_js_1 = require("../../channel/shared/plugin.js");
 function createBuiltinWeixinChannelPlugin(options) {
-    let runtime = null;
-    let unsubscribeBridgeEvents = null;
-    return {
+    return (0, plugin_js_1.createBuiltinChannelPlugin)({
         manifest: {
             id: 'builtin.channel-weixin',
             kind: 'channel',
@@ -17,40 +16,20 @@ function createBuiltinWeixinChannelPlugin(options) {
                 fields: [],
             },
         },
-        capabilities: {
-            channels: [
-                {
-                    id: 'channel.weixin',
-                    platform: 'weixin',
-                    routeType: 'channel.chat',
-                    displayName: 'LocalCore WeChat',
-                },
-            ],
-        },
-        createRuntime(ctx) {
-            if (!runtime) {
-                runtime = {
-                    channel: new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
-                        store: options.store,
-                        readConfig: options.readConfig,
-                        getWorkspaceRouter: options.getWorkspaceRouter,
-                        eventBus: ctx.bus,
-                        log: options.log,
-                    }),
-                };
-                unsubscribeBridgeEvents = ctx.bus.on('platform.bridge.updated', (event) => {
-                    void runtime?.channel.onBridgeEvent?.(event);
-                });
-            }
-            return runtime;
-        },
-        async start() {
-            await runtime?.channel.refreshBindings?.();
-        },
-        async stop() {
-            unsubscribeBridgeEvents?.();
-            unsubscribeBridgeEvents = null;
-            runtime?.channel.close?.();
-        },
-    };
+        channels: [
+            {
+                id: 'channel.weixin',
+                platform: 'weixin',
+                routeType: 'channel.chat',
+                displayName: 'LocalCore WeChat',
+            },
+        ],
+        createChannel: (ctx) => new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+            store: options.store,
+            readConfig: options.readConfig,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+            eventBus: ctx.bus,
+            log: options.log,
+        }),
+    });
 }

package/dist-electron/services/local-ai-core/src/runtime/local-core-controller.js

@@ -10,8 +10,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
     state;
     workspaceRouter;
     knowledgeProvider;
-    channelRuntime;
-    weixinChannelRuntime;
+    channelRuntimes;
     scheduler;
     kernel;
     runtime;
@@ -31,8 +30,8 @@ class LocalCoreController extends node_events_1.EventEmitter {
         this.kernel = this.runtime.kernel;
         this.knowledgeProvider = this.runtime.knowledgeProvider;
         this.workspaceRouter = this.runtime.workspaceRouter;
-        this.channelRuntime = this.runtime.channelRuntime;
-        this.weixinChannelRuntime = this.runtime.weixinChannelRuntime;
+        const runtimeChannels = this.runtime.channelRuntimes || [this.runtime.channelRuntime, this.runtime.weixinChannelRuntime];
+        this.channelRuntimes = new Map(runtimeChannels.filter(Boolean).map((runtime) => [runtime.platform, runtime]));
         this.scheduler = this.runtime.scheduler;
         this.runtimeDetection = new runtime_detection_service_js_1.RuntimeDetectionService({
             userDataPath,
@@ -99,8 +98,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
         return { status: 'running' };
     }
     async restartService() {
-        await this.channelRuntime.refreshBindings?.();
-        await this.weixinChannelRuntime.refreshBindings?.();
+        await this.refreshChannelBindings();
         await this.emitRuntime();
         return { status: 'running' };
     }
@@ -112,22 +110,19 @@ class LocalCoreController extends node_events_1.EventEmitter {
     }
     async saveRawConfigFile(raw) {
         const next = await this.state.saveRawConfigFile(raw);
-        await this.channelRuntime.refreshBindings?.();
-        await this.weixinChannelRuntime.refreshBindings?.();
+        await this.refreshChannelBindings();
         await this.emitRuntime();
         return next;
     }
     async saveStructuredConfigFile(config) {
         const next = await this.state.saveStructuredConfigFile(config);
-        await this.channelRuntime.refreshBindings?.();
-        await this.weixinChannelRuntime.refreshBindings?.();
+        await this.refreshChannelBindings();
         await this.emitRuntime();
         return next;
     }
     async saveSettings(input) {
         const settings = await this.state.saveSettings(input);
-        await this.channelRuntime.refreshBindings?.();
-        await this.weixinChannelRuntime.refreshBindings?.();
+        await this.refreshChannelBindings();
         await this.emitRuntime();
         return settings;
     }
@@ -311,25 +306,22 @@ class LocalCoreController extends node_events_1.EventEmitter {
     }
     async listChannelGatewayStatuses(platform) {
         if (!platform) {
-            const [larkStatuses, weixinStatuses] = await Promise.all([
-                this.channelRuntime.listStatuses(),
-                this.weixinChannelRuntime.listStatuses(),
-            ]);
-            return [...larkStatuses, ...weixinStatuses];
+            const statuses = await Promise.all([...this.channelRuntimes.values()].map((runtime) => runtime.listStatuses()));
+            return statuses.flat();
         }
         return this.resolveChannelRuntime(platform).listStatuses();
     }
-    async getChannelGatewayStatus(platform, workspaceId) {
-        return this.resolveChannelRuntime(platform).getStatus(workspaceId);
+    async getChannelGatewayStatus(platform, workspaceId, instanceId) {
+        return this.resolveChannelRuntime(platform).getStatus(workspaceId, instanceId);
     }
-    async testChannelConnection(platform, workspaceId) {
-        return this.resolveChannelRuntime(platform).testConnection(workspaceId);
+    async testChannelConnection(platform, workspaceId, instanceId) {
+        return this.resolveChannelRuntime(platform).testConnection(workspaceId, instanceId);
     }
-    async enableChannelGateway(platform, workspaceId) {
-        return this.resolveChannelRuntime(platform).enable(workspaceId);
+    async enableChannelGateway(platform, workspaceId, instanceId) {
+        return this.resolveChannelRuntime(platform).enable(workspaceId, instanceId);
     }
-    async disableChannelGateway(platform, workspaceId) {
-        return this.resolveChannelRuntime(platform).disable(workspaceId);
+    async disableChannelGateway(platform, workspaceId, instanceId) {
+        return this.resolveChannelRuntime(platform).disable(workspaceId, instanceId);
     }
     async listChannelPendingPairings(platform, workspaceId) {
         return this.resolveChannelRuntime(platform).listPendingPairings(workspaceId);
@@ -384,28 +376,46 @@ class LocalCoreController extends node_events_1.EventEmitter {
         }
         return runtime.sendOutboundMessage(workspaceId, input);
     }
-    async getWeixinQrCode(workspaceId) {
-        const runtime = this.weixinChannelRuntime;
-        return runtime.getQrCode(workspaceId);
+    async getWeixinQrCode(workspaceId, instanceId) {
+        return this.getChannelQrCode('weixin', workspaceId, instanceId);
     }
-    async checkWeixinQrCodeStatus(workspaceId, ticket) {
-        const runtime = this.weixinChannelRuntime;
-        return runtime.checkQrCodeStatus(workspaceId, ticket);
+    async checkWeixinQrCodeStatus(workspaceId, ticket, instanceId) {
+        return this.checkChannelQrCodeStatus('weixin', workspaceId, ticket, instanceId);
+    }
+    async getLarkQrCode(workspaceId, instanceId) {
+        return this.getChannelQrCode('lark', workspaceId, instanceId);
+    }
+    async checkLarkQrCodeStatus(workspaceId, ticket, instanceId) {
+        return this.checkChannelQrCodeStatus('lark', workspaceId, ticket, instanceId);
+    }
+    async getChannelQrCode(platform, workspaceId, instanceId) {
+        const runtime = this.resolveChannelRuntime(platform);
+        if (!runtime.getQrCode) {
+            throw new Error(`Channel platform does not support QR setup: ${platform}`);
+        }
+        return runtime.getQrCode(workspaceId, instanceId);
+    }
+    async checkChannelQrCodeStatus(platform, workspaceId, ticket, instanceId) {
+        const runtime = this.resolveChannelRuntime(platform);
+        if (!runtime.checkQrCodeStatus) {
+            throw new Error(`Channel platform does not support QR setup: ${platform}`);
+        }
+        return runtime.checkQrCodeStatus(workspaceId, ticket, instanceId);
     }
     async listLarkGatewayStatuses() {
         return this.listChannelGatewayStatuses('lark');
     }
-    async getLarkGatewayStatus(workspaceId) {
-        return this.getChannelGatewayStatus('lark', workspaceId);
+    async getLarkGatewayStatus(workspaceId, instanceId) {
+        return this.getChannelGatewayStatus('lark', workspaceId, instanceId);
     }
-    async testLarkConnection(workspaceId) {
-        return this.testChannelConnection('lark', workspaceId);
+    async testLarkConnection(workspaceId, instanceId) {
+        return this.testChannelConnection('lark', workspaceId, instanceId);
     }
-    async enableLarkGateway(workspaceId) {
-        return this.enableChannelGateway('lark', workspaceId);
+    async enableLarkGateway(workspaceId, instanceId) {
+        return this.enableChannelGateway('lark', workspaceId, instanceId);
     }
-    async disableLarkGateway(workspaceId) {
-        return this.disableChannelGateway('lark', workspaceId);
+    async disableLarkGateway(workspaceId, instanceId) {
+        return this.disableChannelGateway('lark', workspaceId, instanceId);
     }
     async listLarkPendingPairings(workspaceId) {
         return this.listChannelPendingPairings('lark', workspaceId);
@@ -459,12 +469,13 @@ class LocalCoreController extends node_events_1.EventEmitter {
             this.handlingLog = false;
         }
     }
+    async refreshChannelBindings() {
+        await Promise.all([...this.channelRuntimes.values()].map((runtime) => runtime.refreshBindings?.()));
+    }
     resolveChannelRuntime(platform) {
-        if (platform === this.channelRuntime.platform) {
-            return this.channelRuntime;
-        }
-        if (platform === this.weixinChannelRuntime.platform) {
-            return this.weixinChannelRuntime;
+        const runtime = this.channelRuntimes.get(platform);
+        if (runtime) {
+            return runtime;
         }
         throw new Error(`Unsupported channel platform: ${platform}`);
     }

package/dist-electron/services/local-ai-core/src/runtime/server.js

@@ -187,6 +187,7 @@ class LocalAiCoreServer {
                 const suffix = path.slice('/api/local/v1/platforms/'.length);
                 const segments = suffix.split('/').filter(Boolean).map((segment) => decodeURIComponent(segment));
                 const [platform = '', workspaceOrCollection = '', action = ''] = segments;
+                const instanceId = String(url.searchParams.get('instance_id') || url.searchParams.get('instanceId') || '').trim() || undefined;
                 if (!platform) {
                     json(res, 404, null, false, 'Platform not found');
                     return;
@@ -206,16 +207,16 @@ class LocalAiCoreServer {
                     return;
                 }
                 if (segments.length === 2) {
-                    json(res, 200, await this.bindings.getChannelGatewayStatus(platform, workspaceOrCollection));
+                    json(res, 200, await this.bindings.getChannelGatewayStatus(platform, workspaceOrCollection, instanceId));
                     return;
                 }
-                if (platform === 'weixin' && segments.length === 4 && action === 'qrcode' && segments[3] === 'status') {
+                if (segments.length === 4 && action === 'qrcode' && segments[3] === 'status') {
                     const ticket = String(url.searchParams.get('ticket') || '');
                     if (!ticket) {
                         json(res, 400, null, false, 'Missing ticket parameter');
                         return;
                     }
-                    json(res, 200, await this.bindings.checkWeixinQrCodeStatus(workspaceOrCollection, ticket));
+                    json(res, 200, await this.bindings.checkChannelQrCodeStatus(platform, workspaceOrCollection, ticket, instanceId));
                     return;
                 }
             }
@@ -223,6 +224,7 @@ class LocalAiCoreServer {
                 const suffix = path.slice('/api/local/v1/platforms/'.length);
                 const segments = suffix.split('/').filter(Boolean).map((segment) => decodeURIComponent(segment));
                 const [platform = '', workspaceOrCollection = '', action = ''] = segments;
+                const instanceId = String(url.searchParams.get('instance_id') || url.searchParams.get('instanceId') || '').trim() || undefined;
                 if (!platform) {
                     json(res, 404, null, false, 'Platform not found');
                     return;
@@ -238,15 +240,15 @@ class LocalAiCoreServer {
                     return;
                 }
                 if (action === 'test') {
-                    json(res, 200, await this.bindings.testChannelConnection(platform, workspaceOrCollection));
+                    json(res, 200, await this.bindings.testChannelConnection(platform, workspaceOrCollection, instanceId));
                     return;
                 }
                 if (action === 'enable') {
-                    json(res, 200, await this.bindings.enableChannelGateway(platform, workspaceOrCollection));
+                    json(res, 200, await this.bindings.enableChannelGateway(platform, workspaceOrCollection, instanceId));
                     return;
                 }
                 if (action === 'disable') {
-                    json(res, 200, await this.bindings.disableChannelGateway(platform, workspaceOrCollection));
+                    json(res, 200, await this.bindings.disableChannelGateway(platform, workspaceOrCollection, instanceId));
                     return;
                 }
                 if (action === 'files') {
@@ -259,8 +261,8 @@ class LocalAiCoreServer {
                     json(res, 200, await this.bindings.sendChannelMessage(platform, workspaceOrCollection, body));
                     return;
                 }
-                if (platform === 'weixin' && segments.length === 3 && workspaceOrCollection !== 'pairings' && action === 'qrcode') {
-                    json(res, 200, await this.bindings.getWeixinQrCode(workspaceOrCollection));
+                if (segments.length === 3 && workspaceOrCollection !== 'pairings' && action === 'qrcode') {
+                    json(res, 200, await this.bindings.getChannelQrCode(platform, workspaceOrCollection, instanceId));
                     return;
                 }
             }

package/dist-electron/shared/desktop.js

@@ -89,9 +89,19 @@ const PERMISSION_RESPONSE_MAP = {
     deny: 'deny',
     'allow all': 'allow all',
     allowall: 'allow all',
+    allow_all: 'allow all',
+    allow_always: 'allow all',
+    always: 'allow all',
+    always_allow: 'allow all',
+    'always allow': 'allow all',
+    'allow always': 'allow all',
+    '始终允许': 'allow all',
+    '永久允许': 'allow all',
     'perm:allow': 'allow',
     'perm:deny': 'deny',
     'perm:allow_all': 'allow all',
+    'perm:allow_always': 'allow all',
+    'perm:always': 'allow all',
 };
 function deriveDesktopRuntimePhase(service) {
     if (service.status === 'starting') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kafca/agentdock",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "type": "module",
   "main": "dist-electron/electron/main.js",
   "bin": {