@kafca/agentdock 0.1.46 → 0.1.47

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

@@ -34,7 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreLarkGateway = void 0;
-const node_events_1 = require("node:events");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -42,118 +41,30 @@ const local_core_errors_js_1 = require("../../kernel/local-core-errors.js");
 const desktop_js_1 = require("../../../../../shared/desktop.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 base_channel_gateway_js_1 = require("../shared/base-channel-gateway.js");
 const cards_js_1 = require("./cards.js");
 const config_js_1 = require("./config.js");
 const registration_js_1 = require("./registration.js");
 const messages_js_1 = require("./rendering/messages.js");
 const inbound_js_1 = require("./inbound.js");
 const runtime_state_js_1 = require("./runtime-state.js");
-const thread_slash_command_dispatcher_js_1 = require("../../thread/thread-slash-command-dispatcher.js");
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 const LARK_FINAL_PATCH_INTERVAL_MS = 900;
 const LARK_PROGRESS_PATCH_INTERVAL_MS = 3000;
-class LocalCoreLarkGateway extends node_events_1.EventEmitter {
-    options;
+class LocalCoreLarkGateway extends base_channel_gateway_js_1.BaseChannelGateway {
     // Lark returns 200340 when card action events are not enabled in the app's
     // event subscription. Keep card actions opt-in so text approval always works.
     defaultCardActionsEnabled = false;
     // Keep permission state in a dedicated card to avoid mixing order in the main reply card.
     mirrorPermissionStateInMainCard = false;
-    runtime = new Map();
-    threadRouting = new Map();
-    outboundEventChains = new Map();
-    outboundTurns = new Map();
-    mutedThreadBridgeCounts = new Map();
-    sessionCommandRuntime;
     larkModulePromise = null;
     platform = 'lark';
-    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),
-        });
-    }
-    async refreshBindings() {
-        const config = await this.options.readConfig();
-        const bindings = this.collectBindings(config);
-        const nextKeys = new Set(bindings.map((binding) => (0, config_js_1.runtimeKey)(binding.workspaceId, binding.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,
-                        appId: binding.appId,
-                        autoApprove: binding.autoApprove,
-                        cardActionsEnabled: binding.cardActionsEnabled,
-                        groupReplyAll: binding.groupReplyAll,
-                        botOpenId: binding.botOpenId,
-                    });
-                }
-                continue;
-            }
-            if (current?.status === 'running' && current.appId === binding.appId) {
-                continue;
-            }
-            await this.startWorkspace(binding);
-        }
-        this.notifyRuntimeStateChanged();
+        super(options);
     }
+    // ==================== Lifecycle (platform-specific) ====================
     async testConnection(workspaceId, instanceId) {
         const binding = await this.getBinding(workspaceId, instanceId);
         const result = await this.createSdkClientResult(binding);
@@ -164,15 +75,6 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             instanceId: binding.instanceId,
         };
     }
-    async enable(workspaceId, instanceId) {
-        const binding = await this.getBinding(workspaceId, instanceId);
-        await this.startWorkspace(binding);
-        return this.getStatus(workspaceId, binding.instanceId);
-    }
-    async disable(workspaceId, instanceId) {
-        await this.stopWorkspace(workspaceId, instanceId);
-        return this.getStatus(workspaceId, instanceId);
-    }
     async getQrCode(workspaceId, instanceId) {
         const binding = await this.getBinding(workspaceId, instanceId);
         const data = await (0, registration_js_1.requestAppRegistration)(binding);
@@ -250,9 +152,6 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             }
         };
     }
-    async executeSessionCommand(input) {
-        return this.sessionCommandRuntime.execute(input);
-    }
     async sendSessionCommandResult(input, result) {
         const state = this.resolveRuntimeState(input.workspaceId, input.instanceId).state;
         if (state?.client && state.connected && result.card?.actions?.length && state.cardActionsEnabled) {
@@ -367,111 +266,6 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             file,
         };
     }
-    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);
-    }
-    getStatus(workspaceId, instanceId) {
-        this.options.store.expirePendingPairings();
-        const resolved = this.resolveRuntimeState(workspaceId, instanceId);
-        const binding = resolved.state;
-        const platformKey = binding?.platformKey || (0, config_js_1.channelPlatformKey)('lark', resolved.instanceId);
-        const pairings = this.options.store.listPendingPairings(workspaceId)
-            .filter((row) => row.platform === platformKey && row.expires_at >= new Date().toISOString());
-        const users = this.options.store.listAuthorizedUsers(workspaceId, platformKey);
-        return {
-            workspaceId,
-            platform: 'lark',
-            instanceId: resolved.instanceId,
-            displayName: binding?.displayName,
-            enabled: Boolean(binding?.enabled),
-            connected: Boolean(binding?.connected),
-            status: binding?.status || 'disabled',
-            appId: binding?.appId || '',
-            lastError: binding?.lastError,
-            lastErrorInfo: binding?.lastErrorInfo,
-            lastErrorAt: binding?.lastErrorAt,
-            connectedAt: binding?.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 === 'lark' || item.platform.startsWith('lark:'))
-            .filter((item) => item.status === 'pending' && item.expiresAt >= new Date().toISOString());
-    }
-    listAuthorizedUsers(workspaceId) {
-        return this.options.store.listAuthorizedUsers(workspaceId)
-            .filter((item) => item.platform === 'lark' || item.platform.startsWith('lark:'));
-    }
-    async start() {
-        await this.refreshBindings();
-    }
-    async stop() {
-        this.close();
-    }
-    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 !== 'lark' && !pairing.platform.startsWith('lark:')) {
-            throw new Error(`Pairing code ${code} is not a Lark 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 || `lark-user-${(0, node_crypto_1.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((entry) => entry.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}`);
-        }
-        this.options.store.updatePairingStatus(code, 'rejected');
-        this.notifyRuntimeStateChanged();
-        return { rejected: true };
-    }
     async onBridgeEvent(event) {
         if (!event.sessionKey) {
             this.options.log?.(`localcore-lark bridge event ignored without sessionKey: ${event.type}`);
@@ -612,153 +406,131 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         await current;
     }
     async handleInboundMessage(input) {
-        const instanceId = input.instanceId || 'default';
-        const platformKey = input.platformKey || (0, config_js_1.channelPlatformKey)('lark', instanceId);
+        const msg = input;
+        const instanceId = msg.instanceId || 'default';
+        const platformKey = msg.platformKey || (0, config_js_1.channelPlatformKey)('lark', instanceId);
         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 runtimeState = this.resolveRuntimeState(input.workspaceId, instanceId).state;
+        const runtimeState = this.resolveRuntimeState(msg.workspaceId, instanceId).state;
         let binding;
         try {
-            binding = await this.getBinding(input.workspaceId, instanceId);
+            binding = await this.getBinding(msg.workspaceId, instanceId);
         }
         catch (error) {
             if (!runtimeState) {
                 throw error;
             }
-            this.options.log?.(`localcore-lark using active runtime binding snapshot for ${input.workspaceId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
+            this.options.log?.(`localcore-lark using active runtime binding snapshot for ${msg.workspaceId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
         }
-        let authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, platformKey);
+        let authorized = this.options.store.getAuthorizedUser(msg.workspaceId, msg.platformUserId, platformKey);
         if (!authorized) {
             if (binding?.autoApprove || runtimeState?.autoApprove) {
                 const authorizedAt = new Date().toISOString();
                 this.options.store.createAuthorizedUser({
                     id: `lark-user-${(0, node_crypto_1.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-lark auto-approved user for ${input.workspaceId}: ${input.platformUserId}`);
+                authorized = this.options.store.getAuthorizedUser(msg.workspaceId, msg.platformUserId, platformKey);
+                this.options.log?.(`localcore-lark 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 = this.generatePairingCode();
                 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();
             }
-            await this.sendImmediateCard(input.workspaceId, input.chatId, (0, cards_js_1.renderPendingPairingCard)(pairingCode), instanceId);
-            return { paired: false };
+            await this.sendImmediateCard(msg.workspaceId, msg.chatId, (0, cards_js_1.renderPendingPairingCard)(pairingCode), instanceId);
+            return; // { paired: false };
         }
         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: 'Lark',
             authorized,
         });
-        const normalizedText = String(input.text || '').trim().toLowerCase();
+        const normalizedText = String(msg.text || '').trim().toLowerCase();
         const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny')
-            ? this.findAwaitingPermissionThreadId(input.workspaceId, input.chatId, input.platformUserId)
+            ? this.findAwaitingPermissionThreadId(msg.workspaceId, msg.chatId, msg.platformUserId)
             : '';
         if (permissionThreadId && permissionThreadId !== threadId) {
             threadId = permissionThreadId;
         }
         const effectiveSessionKey = this.options.getWorkspaceRouter().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,
         });
-        const acknowledgement = this.createTurnState(effectiveSessionKey, input.messageId);
-        await this.addAcknowledgementReaction(input.workspaceId, input.messageId, acknowledgement, instanceId);
-        const slashCommand = this.parseSlashCommand(input.text);
+        const acknowledgement = this.createTurnState(effectiveSessionKey, msg.messageId);
+        await this.addAcknowledgementReaction(msg.workspaceId, msg.messageId, acknowledgement, instanceId);
+        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 || 'Lark'} ${new Date().toLocaleTimeString()}`,
-            defaultAgentType: slashCommand ? await this.resolveDefaultAgentType(input.workspaceId, threadId) : '',
-            chatId: input.chatId,
-            platformUserId: input.platformUserId,
+            text: msg.text,
+            defaultTitle: `${msg.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`,
+            defaultAgentType: slashCommand ? await this.resolveDefaultAgentType(msg.workspaceId, threadId) : '',
+            chatId: msg.chatId,
+            platformUserId: msg.platformUserId,
             platformKey,
             instanceId,
         });
         if (sessionCommand.handled) {
-            return { paired: true, threadId: sessionCommand.threadId || threadId };
+            return; // { paired: true, threadId: sessionCommand.threadId || threadId };
         }
         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 };
+            await router.sendThreadAction(threadId, msg.text);
+            return; // { paired: true, threadId };
         }
-        this.options.store.clearPlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId);
+        this.options.store.clearPlatformThreadMessageId(msg.workspaceId, msg.chatId, msg.platformUserId);
         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 };
-    }
-    close() {
-        return Promise.all([...this.runtime.keys()].map((key) => this.stopWorkspaceKey(key))).then(() => undefined);
-    }
-    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((entry) => entry.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 Lark binding configured for workspace "${workspaceId}"${instanceId ? ` instance "${instanceId}"` : ''}`);
-        }
-        return binding;
+            ? msg.text
+            : (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(msg.text);
+        await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(wrappedText, msg.contentParts));
+        return; // { paired: true, threadId };
     }
     async createSdkClientResult(binding) {
         try {
@@ -877,70 +649,6 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
         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;
-        }
-        this.options.log?.(`localcore-lark stopping workspace=${state.workspaceId}/${state.instanceId} status=${state.status}`);
-        try {
-            await state.wsClient?.stop?.();
-            this.options.log?.(`localcore-lark stopped workspace=${state.workspaceId}/${state.instanceId}`);
-        }
-        catch (error) {
-            this.options.log?.(`localcore-lark stop failed for ${state.workspaceId}/${state.instanceId}: ${error instanceof Error ? error.message : String(error)}`);
-            // Best effort: current SDK versions may not implement stop().
-        }
-        this.runtime.set(key, {
-            workspaceId: state.workspaceId,
-            instanceId: state.instanceId,
-            displayName: state.displayName,
-            platformKey: state.platformKey,
-            enabled: false,
-            status: 'stopped',
-            connected: false,
-            appId: state.appId,
-            autoApprove: state.autoApprove,
-            cardActionsEnabled: state.cardActionsEnabled,
-            groupReplyAll: state.groupReplyAll,
-            botOpenId: state.botOpenId,
-        });
-        this.notifyRuntimeStateChanged();
-    }
-    notifyRuntimeStateChanged() {
-        this.options.eventBus.emit({
-            type: 'runtime.state.changed',
-            payload: {
-                reason: 'channel-bindings',
-            },
-        });
-    }
-    clearRuntimeError(state) {
-        state.lastError = undefined;
-        state.lastErrorInfo = undefined;
-        state.lastErrorAt = undefined;
-    }
-    setRuntimeError(state, errorInfo) {
-        state.lastError = errorInfo.message;
-        state.lastErrorInfo = errorInfo;
-        state.lastErrorAt = new Date().toISOString();
-        this.options.eventBus.emit({
-            type: 'localcore.error',
-            payload: {
-                scope: 'channel.lark',
-                errorInfo,
-                context: {
-                    workspaceId: state.workspaceId,
-                    instanceId: state.instanceId,
-                    platform: 'lark',
-                },
-            },
-        });
-    }
     async handleMessageEvent(workspaceId, instanceIdOrData, platformKeyOrData, maybeData) {
         const legacyCall = typeof instanceIdOrData === 'object';
         const instanceId = legacyCall ? 'default' : instanceIdOrData;
@@ -1186,11 +894,87 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
         return `${value.slice(0, 6)}...${value.slice(-4)}`;
     }
+    makeThreadRoute(input, threadId) {
+        return {
+            workspaceId: input.workspaceId,
+            instanceId: input.instanceId,
+            platformKey: input.platformKey,
+            platformUserId: input.platformUserId,
+            chatId: input.chatId,
+            threadId,
+        };
+    }
     collectBindings(config) {
         return (0, config_js_1.collectLarkWorkspaceBindings)(config, {
             defaultCardActionsEnabled: this.defaultCardActionsEnabled,
         });
     }
+    buildStatusObject(state, _resolved) {
+        this.options.store.expirePendingPairings();
+        const resolved = this.resolveRuntimeState(state.workspaceId, state.instanceId);
+        const binding = resolved.state;
+        const platformKey = binding?.platformKey || (0, config_js_1.channelPlatformKey)('lark', 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(state.workspaceId, platformKey);
+        return {
+            workspaceId: state.workspaceId,
+            platform: 'lark',
+            instanceId: resolved.instanceId,
+            displayName: binding?.displayName,
+            enabled: Boolean(binding?.enabled),
+            connected: Boolean(binding?.connected),
+            status: binding?.status || 'disabled',
+            appId: binding?.appId || '',
+            lastError: binding?.lastError,
+            lastErrorInfo: binding?.lastErrorInfo,
+            lastErrorAt: binding?.lastErrorAt,
+            connectedAt: binding?.connectedAt,
+            pendingPairings: pairings.length,
+            authorizedUsers: users.length,
+        };
+    }
+    createDisabledState(binding) {
+        return {
+            workspaceId: binding.workspaceId,
+            instanceId: binding.instanceId,
+            displayName: binding.displayName,
+            platformKey: binding.platformKey,
+            enabled: false,
+            status: 'disabled',
+            connected: false,
+            appId: binding.appId,
+            autoApprove: binding.autoApprove,
+            cardActionsEnabled: binding.cardActionsEnabled,
+            groupReplyAll: binding.groupReplyAll,
+            botOpenId: binding.botOpenId,
+        };
+    }
+    async stopWorkspaceTransport(state) {
+        this.options.log?.(`localcore-lark stopping workspace=${state.workspaceId}/${state.instanceId} status=${state.status}`);
+        try {
+            await state.wsClient?.stop?.();
+            this.options.log?.(`localcore-lark stopped workspace=${state.workspaceId}/${state.instanceId}`);
+        }
+        catch (error) {
+            this.options.log?.(`localcore-lark stop failed for ${state.workspaceId}/${state.instanceId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    resetStateToStopped(state, _key) {
+        Object.assign(state, {
+            enabled: false,
+            status: 'stopped',
+            connected: false,
+            appId: state.appId,
+            autoApprove: state.autoApprove,
+            cardActionsEnabled: state.cardActionsEnabled,
+            groupReplyAll: state.groupReplyAll,
+            botOpenId: state.botOpenId,
+        });
+    }
+    isSameIdentity(state, binding) {
+        return state.appId === binding.appId;
+    }
     async getLarkModule() {
         if (!this.larkModulePromise) {
             this.larkModulePromise = Promise.resolve().then(() => __importStar(require('@larksuiteoapi/node-sdk')));