@kafca/agentdock 0.1.45 → 0.1.47

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

@@ -8,15 +8,13 @@ exports.createWeixinAttachmentContentPart = createWeixinAttachmentContentPart;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 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 local_core_errors_js_1 = require("../../kernel/local-core-errors.js");
 const content_js_1 = require("../shared/content.js");
 const file_utils_js_1 = require("../shared/file-utils.js");
-const session_command_runtime_js_1 = require("../shared/session-command-runtime.js");
 const thread_routing_js_1 = require("../shared/thread-routing.js");
-const thread_slash_command_dispatcher_js_1 = require("../../thread/thread-slash-command-dispatcher.js");
+const base_channel_gateway_js_1 = require("../shared/base-channel-gateway.js");
 const config_js_1 = require("./config.js");
 const transport_js_1 = require("./transport.js");
 // ==================== Constants ====================
@@ -147,169 +145,99 @@ function renderBridgeContentForWeixin(event) {
     return [name, status].filter(Boolean).join(' - ');
 }
 // ==================== Gateway Class ====================
-class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
-    options;
-    runtime = new Map();
-    threadRouting = new Map();
-    outboundEventChains = new Map();
-    outboundTurns = new Map();
+class LocalCoreWeixinGateway extends base_channel_gateway_js_1.BaseChannelGateway {
     processedInboundMessages = new Map();
-    mutedThreadBridgeCounts = new Map();
     pollErrorLogWindows = new Map();
-    sessionCommandRuntime;
     platform = 'weixin';
-    routeType = 'channel.chat';
     constructor(options) {
-        super();
-        this.options = options;
-        const slashCommands = new thread_slash_command_dispatcher_js_1.ThreadSlashCommandDispatcher({
-            session: {
-                listThreads: (workspaceId) => this.options.getWorkspaceRouter().listThreads(workspaceId),
-                getThread: (threadId) => this.options.getWorkspaceRouter().getThread(threadId),
-                createThread: (workspaceId, title) => this.options.getWorkspaceRouter().createThread(workspaceId, title),
-                renameThread: (threadId, title) => this.options.getWorkspaceRouter().renameThread(threadId, title),
-                deleteThread: (threadId) => this.options.getWorkspaceRouter().deleteThread(threadId),
-            },
-            thread: {
-                getThreadRow: (threadId) => this.options.store.getThreadRow(threadId),
-                updateThreadAgentMode: (threadId, mode) => this.options.store.updateThreadAgentMode(threadId, mode),
-                updateThreadAgentType: (threadId, agentType) => this.options.store.updateThreadAgentType(threadId, agentType),
-                getLatestRunForThread: (threadId) => this.options.store.getLatestRunForThread(threadId),
-                createAuditEvent: (input) => this.options.store.createAuditEvent(input),
-                getAgentTypes: () => this.options.getWorkspaceRouter().getAgentTypes(),
-                setThreadMode: (threadId, mode) => this.options.getWorkspaceRouter().setThreadMode(threadId, mode),
-                closeThreadSession: (threadId) => this.options.getWorkspaceRouter().closeThreadSession(threadId),
-                interruptRun: (runId) => this.options.getWorkspaceRouter().interruptRun(runId),
-                log: this.options.log,
-            },
-        });
-        this.sessionCommandRuntime = new session_command_runtime_js_1.ChannelSessionCommandRuntime({
-            dispatcher: slashCommands,
-            store: this.options.store,
-            getThreadSessionKey: (threadId) => this.options.getWorkspaceRouter().getThreadSessionKey(threadId),
-            setThreadRoute: (sessionKey, route) => {
-                this.threadRouting.set(sessionKey, route);
-            },
-            createRoute: (input, threadId) => ({
-                workspaceId: input.workspaceId,
-                instanceId: input.instanceId,
-                platformKey: input.platformKey,
-                platformUserId: input.platformUserId,
-                chatId: input.chatId,
-                threadId,
-            }),
-            sendResult: (input, result) => this.sendSessionCommandResult(input, result),
-        });
-    }
-    // ==================== Lifecycle ====================
-    async refreshBindings() {
-        const config = await this.options.readConfig();
-        const bindings = this.collectBindings(config);
-        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 key = (0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId);
-            const current = this.runtime.get(key);
-            if (!binding.enabled) {
-                if (current) {
-                    await this.stopWorkspaceKey(key);
-                }
-                else {
-                    this.runtime.set(key, {
-                        workspaceId: binding.workspaceId,
-                        instanceId: binding.instanceId,
-                        displayName: binding.displayName,
-                        platformKey: binding.platformKey,
-                        enabled: false,
-                        status: 'disabled',
-                        connected: false,
-                        accountId: binding.accountId,
-                    });
-                }
-                continue;
-            }
-            if (current?.status === 'running' && current.accountId === binding.accountId) {
-                continue;
-            }
-            await this.startWorkspace(binding);
-        }
-        this.notifyRuntimeStateChanged();
-    }
-    async testConnection(workspaceId, instanceId) {
-        const binding = await this.getBinding(workspaceId, instanceId);
-        try {
-            const bufPath = (0, config_js_1.getWeixinBufPath)(binding);
-            node_fs_1.default.accessSync(bufPath);
-            return { success: true, platform: 'weixin', workspaceId, instanceId: binding.instanceId, appId: binding.accountId };
-        }
-        catch {
-            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.' };
-        }
+        super(options);
     }
-    async enable(workspaceId, instanceId) {
-        const binding = await this.getBinding(workspaceId, instanceId);
-        await this.startWorkspace(binding);
-        return this.getStatus(workspaceId, binding.instanceId);
+    // ==================== Abstract implementations ====================
+    makeThreadRoute(input, threadId) {
+        return {
+            workspaceId: input.workspaceId,
+            instanceId: input.instanceId,
+            platformKey: input.platformKey,
+            platformUserId: input.platformUserId,
+            chatId: input.chatId,
+            threadId,
+        };
     }
-    async disable(workspaceId, instanceId) {
-        await this.stopWorkspace(workspaceId, instanceId);
-        return this.getStatus(workspaceId, instanceId);
+    collectBindings(config) {
+        return (0, config_js_1.collectWeixinWorkspaceBindings)(config);
     }
-    getStatus(workspaceId, instanceId) {
+    buildStatusObject(state, resolved) {
         this.options.store.expirePendingPairings();
-        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)
+        const platformKey = state.platformKey || (0, config_js_1.channelPlatformKey)('weixin', resolved.instanceId);
+        const pairings = this.options.store.listPendingPairings(state.workspaceId)
             .filter((row) => row.platform === platformKey && row.expires_at >= new Date().toISOString());
-        const users = this.options.store.listAuthorizedUsers(workspaceId, platformKey);
+        const users = this.options.store.listAuthorizedUsers(state.workspaceId, platformKey);
         return {
-            workspaceId,
+            workspaceId: state.workspaceId,
             platform: 'weixin',
             instanceId: resolved.instanceId,
-            displayName: binding?.displayName,
-            enabled: Boolean(binding?.enabled),
-            connected: Boolean(binding?.connected),
-            status: binding?.status || 'disabled',
-            appId: binding?.accountId || '',
-            lastError: binding?.lastError,
-            lastErrorInfo: binding?.lastErrorInfo,
-            lastErrorAt: binding?.lastErrorAt,
-            consecutiveFailures: binding?.consecutiveFailures,
-            nextRetryAt: binding?.nextRetryAt,
-            connectedAt: binding?.connectedAt,
+            displayName: state.displayName,
+            enabled: Boolean(state.enabled),
+            connected: Boolean(state.connected),
+            status: state.status || 'disabled',
+            appId: state.accountId || '',
+            lastError: state.lastError,
+            lastErrorInfo: state.lastErrorInfo,
+            lastErrorAt: state.lastErrorAt,
+            consecutiveFailures: state.consecutiveFailures,
+            nextRetryAt: state.nextRetryAt,
+            connectedAt: state.connectedAt,
             pendingPairings: pairings.length,
             authorizedUsers: users.length,
         };
     }
-    listStatuses() {
-        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)
-            .filter((item) => item.platform === 'weixin' || item.platform.startsWith('weixin:'))
-            .filter((item) => item.status === 'pending' && item.expiresAt >= new Date().toISOString());
+    createDisabledState(binding) {
+        return {
+            workspaceId: binding.workspaceId,
+            instanceId: binding.instanceId,
+            displayName: binding.displayName,
+            platformKey: binding.platformKey,
+            enabled: false,
+            status: 'disabled',
+            connected: false,
+            accountId: binding.accountId,
+        };
     }
-    listAuthorizedUsers(workspaceId) {
-        return this.options.store.listAuthorizedUsers(workspaceId)
-            .filter((item) => item.platform === 'weixin' || item.platform.startsWith('weixin:'));
+    async stopWorkspaceTransport(state) {
+        try {
+            state.abortController?.abort();
+        }
+        catch { }
     }
-    async start() {
-        await this.refreshBindings();
+    resetStateToStopped(state, _key) {
+        Object.assign(state, {
+            enabled: false,
+            status: 'stopped',
+            connected: false,
+        });
     }
-    async stop() {
-        this.close();
+    async sendSessionCommandResult(input, result) {
+        const state = this.resolveRuntimeState(input.workspaceId, input.instanceId).state;
+        if (!state?.connected)
+            return;
+        try {
+            await this.sendTextMessage(state, input.chatId, result.displayText);
+        }
+        catch (error) {
+            this.options.log?.(`localcore-weixin session command result failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
-    close() {
-        return Promise.all([...this.runtime.keys()].map((id) => this.stopWorkspaceKey(id))).then(() => undefined);
+    // ==================== Lifecycle (platform-specific) ====================
+    async testConnection(workspaceId, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
+        try {
+            const bufPath = (0, config_js_1.getWeixinBufPath)(binding);
+            node_fs_1.default.accessSync(bufPath);
+            return { success: true, platform: 'weixin', workspaceId, instanceId: binding.instanceId, appId: binding.accountId };
+        }
+        catch {
+            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.' };
+        }
     }
     // ==================== QR Code Login ====================
     async getQrCode(workspaceId, instanceId) {
@@ -354,62 +282,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         };
     }
     // ==================== Pairing ====================
-    approvePairing(code) {
-        this.options.store.expirePendingPairings();
-        const pairing = this.options.store.getPairingRequest(code);
-        if (!pairing)
-            throw new Error(`Pairing code not found: ${code}`);
-        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}`);
-        if (pairing.expires_at < new Date().toISOString()) {
-            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, 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: pairing.platform,
-            platform_user_id: pairing.platform_user_id,
-            chat_id: pairing.chat_id,
-            display_name: pairing.display_name,
-            thread_id: existing?.thread_id || null,
-            authorized_at: authorizedAt,
-        });
-        this.options.store.updatePairingStatus(code, 'approved');
-        this.notifyRuntimeStateChanged();
-        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;
-    }
-    rejectPairing(code) {
-        const pairing = this.options.store.getPairingRequest(code);
-        if (!pairing)
-            throw new Error(`Pairing code not found: ${code}`);
-        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();
-        return { rejected: true };
-    }
     // ==================== Bridge Event Handling ====================
-    muteThreadBridge(threadId) {
-        const current = this.mutedThreadBridgeCounts.get(threadId) || 0;
-        this.mutedThreadBridgeCounts.set(threadId, current + 1);
-    }
-    unmuteThreadBridge(threadId) {
-        const current = this.mutedThreadBridgeCounts.get(threadId) || 0;
-        if (current <= 1) {
-            this.mutedThreadBridgeCounts.delete(threadId);
-            return;
-        }
-        this.mutedThreadBridgeCounts.set(threadId, current - 1);
-    }
     async onBridgeEvent(event) {
         if (!event.sessionKey) {
             this.options.log?.(`localcore-weixin bridge event ignored without sessionKey: ${event.type}`);
@@ -497,25 +370,6 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         this.outboundEventChains.set(sessionKey, current);
         await current;
     }
-    async sendScheduledCard(workspaceId, chatId, text) {
-        return this.sendScheduledMessage(workspaceId, { type: 'channel.chat', channelId: chatId }, text);
-    }
-    async sendScheduledMessage(workspaceId, route, text) {
-        const state = this.resolveRuntimeState(workspaceId, route.instanceId).state;
-        if (!state?.connected) {
-            this.options.log?.(`localcore-weixin scheduled message skipped: workspace not connected: ${workspaceId}`);
-            return '';
-        }
-        try {
-            const stripped = stripHtml(text);
-            await this.sendTextMessage(state, route.channelId, stripped);
-            return `wx_sched_${(0, node_crypto_2.randomUUID)()}`;
-        }
-        catch (error) {
-            this.options.log?.(`localcore-weixin scheduled message failed for ${workspaceId}: ${formatError(error)}`);
-            return '';
-        }
-    }
     registerScheduledThreadBridge(input) {
         const instanceId = input.route.instanceId || getWeixinInstanceId(input.platform) || 'default';
         const platformKey = (0, config_js_1.channelPlatformKey)('weixin', instanceId);
@@ -614,136 +468,126 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
     }
     // ==================== 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 };
+        const msg = input;
+        const instanceId = msg.instanceId || 'default';
+        const platformKey = msg.platformKey || (0, config_js_1.channelPlatformKey)('weixin', instanceId);
+        if (this.isDuplicateInboundMessage(msg)) {
+            this.options.log?.(`localcore-weixin skipped duplicate inbound message workspace=${msg.workspaceId} chat=${msg.chatId} id=${msg.contextToken || msg.messageId}`);
+            return;
         }
         this.options.eventBus.emit({
             type: 'platform.message.received',
             payload: {
                 platform: this.platform,
-                workspaceId: input.workspaceId,
-                participantId: input.platformUserId,
-                channelId: input.chatId,
-                displayName: input.displayName,
-                text: input.text,
-                messageId: input.messageId,
+                workspaceId: msg.workspaceId,
+                participantId: msg.platformUserId,
+                channelId: msg.chatId,
+                displayName: msg.displayName,
+                text: msg.text,
+                messageId: msg.messageId,
             },
         });
         this.options.store.expirePendingPairings();
-        const binding = await this.getBinding(input.workspaceId, instanceId);
-        let authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, platformKey);
+        const binding = await this.getBinding(msg.workspaceId, instanceId);
+        let authorized = this.options.store.getAuthorizedUser(msg.workspaceId, msg.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,
+                    workspace_id: msg.workspaceId,
                     platform: platformKey,
-                    platform_user_id: input.platformUserId,
-                    chat_id: input.chatId,
-                    display_name: input.displayName,
+                    platform_user_id: msg.platformUserId,
+                    chat_id: msg.chatId,
+                    display_name: msg.displayName,
                     thread_id: null,
                     authorized_at: authorizedAt,
                 });
-                authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, platformKey);
-                this.options.log?.(`localcore-weixin auto-approved user for ${input.workspaceId}: ${input.platformUserId}`);
+                authorized = this.options.store.getAuthorizedUser(msg.workspaceId, msg.platformUserId, platformKey);
+                this.options.log?.(`localcore-weixin auto-approved user for ${msg.workspaceId}: ${msg.platformUserId}`);
                 this.notifyRuntimeStateChanged();
             }
         }
         if (!authorized) {
-            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');
+            const existingPending = this.options.store.listPendingPairings(msg.workspaceId).find((item) => item.platform === platformKey && item.platform_user_id === msg.platformUserId && item.chat_id === msg.chatId && item.status === 'pending');
             let pairingCode = existingPending?.code || '';
             if (!existingPending) {
                 const now = new Date();
                 pairingCode = String((0, node_crypto_2.randomInt)(100000, 1000000));
                 this.options.store.createPairingRequest({
                     code: pairingCode,
-                    workspace_id: input.workspaceId,
+                    workspace_id: msg.workspaceId,
                     platform: platformKey,
-                    platform_user_id: input.platformUserId,
-                    chat_id: input.chatId,
-                    display_name: input.displayName,
+                    platform_user_id: msg.platformUserId,
+                    chat_id: msg.chatId,
+                    display_name: msg.displayName,
                     requested_at: now.toISOString(),
                     expires_at: new Date(now.getTime() + PAIRING_EXPIRY_MS).toISOString(),
                     status: 'pending',
                 });
                 this.notifyRuntimeStateChanged();
             }
-            const state = this.runtime.get((0, config_js_1.runtimeKey)(input.workspaceId, instanceId));
+            const state = this.runtime.get((0, config_js_1.runtimeKey)(msg.workspaceId, instanceId));
             if (state?.connected) {
-                await this.sendTextMessage(state, input.chatId, `**已收到消息**\n\n当前账号还未授权接入这个工作区。\n请在桌面端完成审批后再次发送消息。\n\n配对码：\`${pairingCode}\``, input.contextToken);
+                await this.sendTextMessage(state, msg.chatId, `**已收到消息**\n\n当前账号还未授权接入这个工作区。\n请在桌面端完成审批后再次发送消息。\n\n配对码：\`${pairingCode}\``, msg.contextToken);
             }
-            return { paired: false };
+            return;
         }
         const router = this.options.getWorkspaceRouter();
         let { threadId } = await (0, thread_routing_js_1.resolveChannelThreadRoute)({
             store: this.options.store,
             router,
-            workspaceId: input.workspaceId,
+            workspaceId: msg.workspaceId,
             platformKey,
-            chatId: input.chatId,
-            platformUserId: input.platformUserId,
-            displayName: input.displayName,
+            chatId: msg.chatId,
+            platformUserId: msg.platformUserId,
+            displayName: msg.displayName,
             fallbackTitlePrefix: 'WeChat',
             authorized,
         });
-        const normalizedText = String(input.text || '').trim().toLowerCase();
-        const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny') ? this.findAwaitingPermissionThreadId(input.workspaceId, input.chatId, input.platformUserId, input.platformKey) : '';
+        const normalizedText = String(msg.text || '').trim().toLowerCase();
+        const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny') ? this.findAwaitingPermissionThreadId(msg.workspaceId, msg.chatId, msg.platformUserId, msg.platformKey) : '';
         if (permissionThreadId && permissionThreadId !== threadId) {
             threadId = permissionThreadId;
         }
         const effectiveSessionKey = router.getThreadSessionKey(threadId);
         this.threadRouting.set(effectiveSessionKey, {
-            workspaceId: input.workspaceId,
+            workspaceId: msg.workspaceId,
             instanceId,
             platformKey,
-            platformUserId: input.platformUserId,
-            chatId: input.chatId,
+            platformUserId: msg.platformUserId,
+            chatId: msg.chatId,
             threadId,
         });
         // Handle slash commands
-        const slashCommand = this.parseSlashCommand(input.text);
+        const slashCommand = this.parseSlashCommand(msg.text);
         const sessionCommand = await this.executeSessionCommand({
-            workspaceId: input.workspaceId,
+            workspaceId: msg.workspaceId,
             currentThreadId: threadId,
-            text: input.text,
-            defaultTitle: `${input.displayName || 'WeChat'} ${new Date().toLocaleTimeString()}`,
-            defaultAgentType: slashCommand ? await this.resolveDefaultAgentType(input.workspaceId, threadId) : '',
-            chatId: input.chatId,
-            platformUserId: input.platformUserId,
+            text: msg.text,
+            defaultTitle: `${msg.displayName || 'WeChat'} ${new Date().toLocaleTimeString()}`,
+            defaultAgentType: slashCommand ? await this.resolveDefaultAgentType(msg.workspaceId, threadId) : '',
+            chatId: msg.chatId,
+            platformUserId: msg.platformUserId,
             platformKey,
             instanceId,
-            contextToken: input.contextToken,
+            contextToken: msg.contextToken,
         });
         if (sessionCommand.handled) {
-            return { paired: true, threadId: sessionCommand.threadId || threadId };
+            return;
         }
         const latestRun = this.options.store.getLatestRunForThread(threadId);
         if ((normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny')
             && latestRun?.status === 'awaiting_input') {
-            await router.sendThreadAction(threadId, input.text);
-            return { paired: true, threadId };
-        }
-        this.options.store.updatePlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId, input.contextToken || input.messageId, platformKey);
-        const wrappedText = slashCommand
-            ? input.text
-            : (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
-        await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(wrappedText, input.contentParts));
-        return { paired: true, threadId };
-    }
-    async executeSessionCommand(input) {
-        return this.sessionCommandRuntime.execute(input);
-    }
-    async sendSessionCommandResult(input, result) {
-        const state = this.resolveRuntimeState(input.workspaceId, input.instanceId).state;
-        if (!state?.connected) {
-            this.options.log?.(`localcore-weixin session command response skipped: workspace not connected: ${input.workspaceId}`);
+            await router.sendThreadAction(threadId, msg.text);
             return;
         }
-        await this.sendTextMessage(state, input.chatId, result.displayText, input.contextToken);
+        this.options.store.updatePlatformThreadMessageId(msg.workspaceId, msg.chatId, msg.platformUserId, msg.contextToken || msg.messageId, platformKey);
+        const wrappedText = slashCommand
+            ? msg.text
+            : (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(msg.text);
+        await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(wrappedText, msg.contentParts));
+        return;
     }
     async resolveDefaultAgentType(workspaceId, threadId) {
         const router = this.options.getWorkspaceRouter();
@@ -753,28 +597,6 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         return this.options.store.getThreadRow(threadId)?.agent_type || 'codex';
     }
     // ==================== Private: Bindings ====================
-    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 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}"${instanceId ? ` instance "${instanceId}"` : ''}`);
-        return binding;
-    }
-    collectBindings(config) {
-        return (0, config_js_1.collectWeixinWorkspaceBindings)(config);
-    }
     // ==================== Private: Workspace Lifecycle ====================
     async startWorkspace(binding) {
         const key = (0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId);
@@ -815,11 +637,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 if (!abortController.signal.aborted) {
                     status.status = 'error';
                     status.connected = false;
-                    this.setRuntimeError(status, err, 'internal_error', {
-                        workspaceId: binding.workspaceId,
-                        instanceId: binding.instanceId,
-                        runtimeId: 'weixin',
-                    });
+                    this.setRuntimeError(status, (0, local_core_errors_js_1.toLocalCoreErrorInfo)(err));
                     this.notifyRuntimeStateChanged();
                 }
             });
@@ -827,38 +645,10 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         catch (error) {
             status.status = 'error';
             status.connected = false;
-            this.setRuntimeError(status, error, 'internal_error', {
-                workspaceId: binding.workspaceId,
-                instanceId: binding.instanceId,
-                runtimeId: 'weixin',
-            });
+            this.setRuntimeError(status, (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error));
         }
         this.notifyRuntimeStateChanged();
     }
-    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(key, {
-            workspaceId: state.workspaceId,
-            instanceId: state.instanceId,
-            displayName: state.displayName,
-            platformKey: state.platformKey,
-            enabled: false,
-            status: 'stopped',
-            connected: false,
-            accountId: state.accountId,
-        });
-        this.notifyRuntimeStateChanged();
-    }
     // ==================== Private: Long-poll Monitor ====================
     normalizeQrStatus(status) {
         const normalized = String(status || 'wait').trim().toLowerCase();
@@ -887,17 +677,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                             state.connected = false;
                             state.consecutiveFailures = consecutiveFailures;
                             state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
-                            this.setRuntimeError(state, new local_core_errors_js_1.LocalCoreError('channel_session_expired', 'WeChat login expired. Generate and scan a new QR code.', {
-                                suggestedAction: 'Generate and scan a new WeChat QR code.',
-                                details: {
-                                    errcode: resp.errcode ?? resp.ret ?? -14,
-                                },
-                            }), 'channel_session_expired', {
-                                workspaceId: binding.workspaceId,
-                                instanceId: binding.instanceId,
-                                runtimeId: 'weixin',
-                                errcode: resp.errcode ?? resp.ret ?? -14,
-                            });
+                            this.setRuntimeError(state, (0, local_core_errors_js_1.toLocalCoreErrorInfo)(new local_core_errors_js_1.LocalCoreError('channel_session_expired', 'WeChat login expired.')));
                             this.notifyRuntimeStateChanged();
                         }
                     }
@@ -986,11 +766,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 if (state) {
                     state.consecutiveFailures = consecutiveFailures;
                     state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
-                    this.setRuntimeError(state, err, 'internal_error', {
-                        workspaceId: binding.workspaceId,
-                        instanceId: binding.instanceId,
-                        runtimeId: 'weixin',
-                    });
+                    this.setRuntimeError(state, (0, local_core_errors_js_1.toLocalCoreErrorInfo)(err));
                     this.notifyRuntimeStateChanged();
                 }
                 this.logPollError(binding, formatError(err), `localcore-weixin getUpdates error for ${binding.workspaceId} (${consecutiveFailures}): ${formatError(err)}`);
@@ -1327,33 +1103,6 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return null;
         return { name: name.trim().toLowerCase(), args };
     }
-    notifyRuntimeStateChanged() {
-        this.options.eventBus.emit({
-            type: 'runtime.state.changed',
-            payload: { reason: 'channel-bindings' },
-        });
-    }
-    clearRuntimeError(state) {
-        state.lastError = undefined;
-        state.lastErrorInfo = undefined;
-        state.lastErrorAt = undefined;
-        state.consecutiveFailures = 0;
-        state.nextRetryAt = undefined;
-    }
-    setRuntimeError(state, error, fallbackCode, context) {
-        const errorInfo = (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error, fallbackCode, context);
-        state.lastError = errorInfo.message;
-        state.lastErrorInfo = errorInfo;
-        state.lastErrorAt = new Date().toISOString();
-        this.options.eventBus.emit({
-            type: 'localcore.error',
-            payload: {
-                scope: 'channel.weixin',
-                errorInfo,
-                context,
-            },
-        });
-    }
     computeRetryDelay(failures) {
         if (failures <= 1)
             return RETRY_DELAY_MS;