@kafca/agentdock 0.1.21 → 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/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/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

@@ -1,11 +1,10 @@
 "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");
+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

@@ -1,11 +1,10 @@
 "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");
+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);
@@ -343,28 +335,87 @@ class LocalCoreController extends node_events_1.EventEmitter {
     async listChannelAuthorizedUsers(platform, workspaceId) {
         return this.resolveChannelRuntime(platform).listAuthorizedUsers(workspaceId);
     }
-    async getWeixinQrCode(workspaceId) {
-        const runtime = this.weixinChannelRuntime;
-        return runtime.getQrCode(workspaceId);
+    async sendChannelFile(platform, workspaceId, input) {
+        const runtime = this.resolveChannelRuntime(platform);
+        if (runtime.sendOutboundMessage) {
+            const result = await runtime.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: result.platform,
+                workspaceId: result.workspaceId,
+                channelId: result.channelId,
+                messageId: result.messageIds[0] || '',
+                messageIds: result.messageIds,
+                fileKey: String(attachment?.metadata?.fileKey || attachment?.attachmentId || ''),
+                attachmentId: attachment?.attachmentId,
+                fileName: attachment?.fileName || input.fileName || '',
+                fileSize: attachment?.fileSize || 0,
+                metadata: result.metadata,
+            };
+        }
+        if (!runtime.sendFile) {
+            throw new Error(`Channel platform does not support sending files: ${platform}`);
+        }
+        return runtime.sendFile(workspaceId, input);
+    }
+    async sendChannelMessage(platform, workspaceId, input) {
+        const runtime = this.resolveChannelRuntime(platform);
+        if (!runtime.sendOutboundMessage) {
+            throw new Error(`Channel platform does not support outbound messages: ${platform}`);
+        }
+        return runtime.sendOutboundMessage(workspaceId, input);
+    }
+    async getWeixinQrCode(workspaceId, instanceId) {
+        return this.getChannelQrCode('weixin', workspaceId, instanceId);
+    }
+    async checkWeixinQrCodeStatus(workspaceId, ticket, instanceId) {
+        return this.checkChannelQrCodeStatus('weixin', workspaceId, ticket, instanceId);
+    }
+    async getLarkQrCode(workspaceId, instanceId) {
+        return this.getChannelQrCode('lark', workspaceId, instanceId);
     }
-    async checkWeixinQrCodeStatus(workspaceId, ticket) {
-        const runtime = this.weixinChannelRuntime;
-        return runtime.checkQrCodeStatus(workspaceId, ticket);
+    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);
@@ -418,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}`);
     }