@kafca/agentdock 0.1.22 → 0.1.24

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

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCli = runCli;
 const node_process_1 = __importDefault(require("node:process"));
+const index_js_1 = require("../../../../packages/contracts/src/index.js");
+const job_id_js_1 = require("../scheduler/job-id.js");
 const DEFAULT_BASE_URL = 'http://127.0.0.1:9831/api/local/v1';
 async function runCli(argv, env = node_process_1.default.env, io = node_process_1.default) {
     try {
@@ -51,7 +53,8 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
 async function handleChannelSendFile(flags, env, io, json) {
     const context = resolveContext(flags, env);
     const filePath = getRequiredFlag(flags, 'path');
-    const platform = getFlag(flags, 'platform') || context.platform;
+    const rawPlatform = getFlag(flags, 'platform') || context.platform;
+    const platform = rawPlatform ? (0, index_js_1.normalizeChannelPlatform)(rawPlatform) : '';
     if (!platform) {
         throw new Error('channel send-file requires a platform. Set LOCAL_AI_PLATFORM or pass --platform.');
     }
@@ -113,8 +116,8 @@ async function handleAdd(flags, env, io, json) {
         description,
         enabled: true,
     });
-    print(json, io.stdout, job, [
-        `Created scheduler job ${job.id}`,
+    print(json, io.stdout, presentJob(job), [
+        `Created scheduler job ${(0, job_id_js_1.toPublicScheduledJobId)(job.id)}`,
         `Schedule: ${job.cronExpr || ''}`,
         `Execution mode: ${job.executionMode}`,
         `Description: ${job.description}`,
@@ -132,7 +135,7 @@ async function handleList(flags, env, io, json) {
     const jobs = threadId
         ? response.jobs.filter((job) => job.route.threadId === threadId)
         : response.jobs;
-    print(json, io.stdout, { jobs }, jobs.length === 0 ? 'No scheduler jobs.' : jobs.map(formatJobLine).join('\n'));
+    print(json, io.stdout, { jobs: jobs.map(presentJob) }, jobs.length === 0 ? 'No scheduler jobs.' : jobs.map(formatJobLine).join('\n'));
     return 0;
 }
 async function handleInfo(jobId, flags, env, io, json) {
@@ -142,7 +145,7 @@ async function handleInfo(jobId, flags, env, io, json) {
     const context = resolveContext(flags, env);
     const job = await request(context.baseUrl, 'GET', `/scheduler/jobs/${encodeURIComponent(jobId)}`);
     const runs = await request(context.baseUrl, 'GET', `/scheduler/jobs/${encodeURIComponent(jobId)}/runs`);
-    print(json, io.stdout, { job, runs: runs.runs }, formatJobDetails(job, runs.runs[0]));
+    print(json, io.stdout, { job: presentJob(job), runs: runs.runs }, formatJobDetails(job, runs.runs[0]));
     return 0;
 }
 async function handleEdit(jobId, flags, env, io, json) {
@@ -168,14 +171,14 @@ async function handleEdit(jobId, flags, env, io, json) {
         input.enabled = enabled;
     }
     if (executionMode) {
-        input.executionMode = parseExecutionMode(executionMode);
+        input.executionMode = (0, index_js_1.normalizeScheduledJobExecutionMode)(executionMode);
     }
     if (Object.keys(input).length === 0) {
         throw new Error('scheduler edit requires at least one editable field.');
     }
     const context = resolveContext(flags, env);
     const job = await request(context.baseUrl, 'PATCH', `/scheduler/jobs/${encodeURIComponent(jobId)}`, input);
-    print(json, io.stdout, job, `Updated scheduler job ${job.id}`);
+    print(json, io.stdout, presentJob(job), `Updated scheduler job ${(0, job_id_js_1.toPublicScheduledJobId)(job.id)}`);
     return 0;
 }
 async function handleDelete(jobId, flags, env, io, json) {
@@ -284,13 +287,7 @@ function normalizeMaybeBooleanFlag(value) {
     return value === 'true' ? '' : value;
 }
 function getExecutionMode(flags) {
-    return parseExecutionMode(getFlag(flags, 'execution-mode') || 'same-thread');
-}
-function parseExecutionMode(value) {
-    if (value === 'same-thread' || value === 'side-thread') {
-        return value;
-    }
-    throw new Error('Flag --execution-mode must be same-thread or side-thread');
+    return (0, index_js_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode'));
 }
 function print(asJson, output, payload, text) {
     output.write(asJson ? `${JSON.stringify(payload, null, 2)}\n` : `${text}\n`);
@@ -309,11 +306,11 @@ function printUsage(output) {
 }
 function formatJobLine(job) {
     const schedule = job.triggerType === 'cron' ? job.cronExpr || '' : job.runAt || '';
-    return `${job.id} | ${job.enabled ? 'enabled' : 'disabled'} | ${job.executionMode} | ${schedule} | ${job.description}`;
+    return `${(0, job_id_js_1.toPublicScheduledJobId)(job.id)} | ${job.enabled ? 'enabled' : 'disabled'} | ${job.executionMode} | ${schedule} | ${job.description}`;
 }
 function formatJobDetails(job, latestRun) {
     return [
-        `Job: ${job.id}`,
+        `Job: ${(0, job_id_js_1.toPublicScheduledJobId)(job.id)}`,
         `Workspace: ${job.workspaceId}`,
         `Platform: ${job.platform}`,
         `Thread: ${job.route.threadId || ''}`,
@@ -325,6 +322,12 @@ function formatJobDetails(job, latestRun) {
         latestRun ? `Latest run: ${latestRun.status} @ ${latestRun.triggeredAt}` : 'Latest run: none',
     ].join('\n');
 }
+function presentJob(job) {
+    return {
+        ...job,
+        id: (0, job_id_js_1.toPublicScheduledJobId)(job.id),
+    };
+}
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }

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}`);
     }