@kafca/agentdock 0.1.7

package/dist-electron/services/local-ai-core/src/router/workspace-router.js

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceRouter = exports.encodeThreadId = exports.decodeThreadId = void 0;
+exports.createWorkspaceRouter = createWorkspaceRouter;
+const local_core_acp_backend_js_1 = require("../acp/local-core-acp-backend.js");
+const workspace_thread_id_js_1 = require("../thread/workspace-thread-id.js");
+const workspace_route_config_js_1 = require("./workspace-route-config.js");
+var workspace_thread_id_js_2 = require("../thread/workspace-thread-id.js");
+Object.defineProperty(exports, "decodeThreadId", { enumerable: true, get: function () { return workspace_thread_id_js_2.decodeThreadId; } });
+Object.defineProperty(exports, "encodeThreadId", { enumerable: true, get: function () { return workspace_thread_id_js_2.encodeThreadId; } });
+class WorkspaceRouter {
+    options;
+    store;
+    localCoreAcp;
+    runThreadMap = new Map();
+    bridgeSubscribers = new Set();
+    schedulerBridge = null;
+    constructor(options) {
+        this.options = options;
+        this.store = options.store;
+        this.localCoreAcp = new local_core_acp_backend_js_1.LocalCoreAcpBackend({
+            store: this.store,
+            runThreadMap: this.runThreadMap,
+            cliBinDir: options.cliBinDir,
+            localCoreBase: options.localCoreBase,
+            emitBridge: (event) => this.emitBridgeEvent(event),
+            eventBus: options.eventBus,
+            scheduler: {
+                createJob: async (input) => {
+                    if (!this.schedulerBridge) {
+                        throw new Error('Scheduler bridge is unavailable.');
+                    }
+                    return this.schedulerBridge.createJob(input);
+                },
+                listJobsForThread: async (threadId) => {
+                    if (!this.schedulerBridge) {
+                        throw new Error('Scheduler bridge is unavailable.');
+                    }
+                    return this.schedulerBridge.listJobsForThread(threadId);
+                },
+                deleteJob: async (jobId) => {
+                    if (!this.schedulerBridge) {
+                        throw new Error('Scheduler bridge is unavailable.');
+                    }
+                    return this.schedulerBridge.deleteJob(jobId);
+                },
+            },
+            log: options.log,
+        });
+    }
+    close() {
+        this.localCoreAcp.close();
+        this.bridgeSubscribers.clear();
+        this.store.close();
+    }
+    getThreadSessionKey(threadId) {
+        const row = this.store.getThreadRow(threadId);
+        return row?.bridge_session_key || '';
+    }
+    setSchedulerBridge(bridge) {
+        this.schedulerBridge = bridge;
+    }
+    async listWorkspaces() {
+        const localProjects = await this.listLocalCoreProjects();
+        const workspaceMap = new Map();
+        for (const project of localProjects) {
+            const route = this.resolveProjectRoute(await this.options.readConfigState(), project);
+            if (!route) {
+                continue;
+            }
+            workspaceMap.set(project.name, {
+                id: project.name,
+                name: project.name,
+                agentType: route.agentType,
+                platforms: (0, workspace_route_config_js_1.normalizePlatformTypes)(project),
+                sessionsCount: this.store.countThreads(project.name),
+                heartbeatEnabled: false,
+            });
+        }
+        return [...workspaceMap.values()].sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async listThreads(workspaceId) {
+        await this.getWorkspaceRoute(workspaceId);
+        return this.localCoreAcp.listThreads(workspaceId);
+    }
+    async createThread(workspaceId, title) {
+        const route = await this.getWorkspaceRoute(workspaceId);
+        return this.withKnowledge(await this.localCoreAcp.createThread(workspaceId, title || `New thread ${new Date().toLocaleTimeString()}`, route.agentType));
+    }
+    async getThread(threadId) {
+        const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
+        await this.getWorkspaceRoute(workspaceId);
+        return this.withKnowledge(await this.localCoreAcp.getThread(threadId));
+    }
+    async renameThread(threadId, title) {
+        const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
+        await this.getWorkspaceRoute(workspaceId);
+        return this.withKnowledge(await this.localCoreAcp.renameThread(threadId, title));
+    }
+    async updateThreadKnowledgeBases(threadId, knowledgeBaseIds) {
+        return {
+            knowledgeBaseIds: await this.options.knowledgeAttachments.updateThreadKnowledgeBaseIds(threadId, knowledgeBaseIds),
+        };
+    }
+    async deleteThread(threadId) {
+        const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
+        await this.getWorkspaceRoute(workspaceId);
+        await this.localCoreAcp.deleteThread(threadId);
+        await this.options.knowledgeAttachments.deleteThreadKnowledgeBaseLinks(threadId);
+        return { deleted: true };
+    }
+    async sendThreadMessage(threadId, content) {
+        const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
+        const route = await this.getWorkspaceRoute(workspaceId);
+        return this.localCoreAcp.sendThreadMessage(threadId, content, route.config);
+    }
+    async sendThreadAction(threadId, content) {
+        const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
+        const route = await this.getWorkspaceRoute(workspaceId);
+        return this.localCoreAcp.sendThreadAction(threadId, content, route.config);
+    }
+    async interruptRun(runId) {
+        const threadId = this.runThreadMap.get(runId);
+        if (!threadId) {
+            return { interrupted: false };
+        }
+        const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
+        await this.getWorkspaceRoute(workspaceId);
+        return this.localCoreAcp.interruptRun(runId);
+    }
+    getCapabilities() {
+        return this.options.getCapabilities();
+    }
+    async probeWorkspaceStreaming(workspaceId) {
+        const route = await this.getWorkspaceRoute(workspaceId);
+        if (!route.supportsStreamingProbe) {
+            throw new Error(`Workspace "${workspaceId}" does not expose a streaming probe.`);
+        }
+        return this.probeLocalCoreAcpWorkspace(workspaceId, route);
+    }
+    async withKnowledge(detail) {
+        return {
+            ...detail,
+            selectedKnowledgeBaseIds: await this.options.knowledgeAttachments.listThreadKnowledgeBaseIds(detail.id),
+        };
+    }
+    emitBridgeEvent(event) {
+        this.options.eventBus.emit({
+            type: 'platform.bridge.updated',
+            payload: event,
+        });
+        this.notifyBridgeSubscribers(event);
+    }
+    notifyBridgeSubscribers(event) {
+        for (const listener of this.bridgeSubscribers) {
+            listener(event);
+        }
+    }
+    subscribeBridge(listener) {
+        this.bridgeSubscribers.add(listener);
+        return () => {
+            this.bridgeSubscribers.delete(listener);
+        };
+    }
+    subscribeBridgeEvents(listener) {
+        return this.subscribeBridge(listener);
+    }
+    createProbeCollector() {
+        return {
+            startedAt: new Date().toISOString(),
+            events: [],
+            sawTypingStart: false,
+            sawTypingStop: false,
+            sawReply: false,
+            sawPreviewLike: false,
+            firstPreviewAt: null,
+            firstReplyAt: null,
+            updateMessageCount: 0,
+            cumulativeUpdates: true,
+            lastPreviewContent: '',
+        };
+    }
+    recordProbeEvent(collector, event) {
+        const at = Date.now();
+        const content = String(event.content || '');
+        collector.events.push({
+            type: event.type,
+            at: new Date(at).toISOString(),
+            contentLength: content.length,
+            previewHandle: event.previewHandle,
+        });
+        switch (event.type) {
+            case 'typing_start':
+                collector.sawTypingStart = true;
+                break;
+            case 'typing_stop':
+                collector.sawTypingStop = true;
+                break;
+            case 'preview_start':
+                collector.sawPreviewLike = true;
+                collector.firstPreviewAt ??= at;
+                collector.lastPreviewContent = content;
+                break;
+            case 'update_message':
+                collector.sawPreviewLike = true;
+                collector.firstPreviewAt ??= at;
+                collector.updateMessageCount += 1;
+                if (collector.lastPreviewContent &&
+                    content &&
+                    !content.startsWith(collector.lastPreviewContent)) {
+                    collector.cumulativeUpdates = false;
+                }
+                collector.lastPreviewContent = content;
+                break;
+            case 'reply':
+                collector.sawReply = true;
+                collector.firstReplyAt ??= at;
+                break;
+            default:
+                break;
+        }
+    }
+    finalizeProbeResult(workspaceId, agentType, transport, prompt, collector, options = {}) {
+        const completedAt = new Date().toISOString();
+        const durationMs = Math.max(0, Date.parse(completedAt) - Date.parse(collector.startedAt));
+        const previewBeforeFinal = collector.sawPreviewLike && (collector.firstReplyAt == null ||
+            (collector.firstPreviewAt != null && collector.firstPreviewAt <= collector.firstReplyAt));
+        const finalEvent = options.error
+            ? 'error'
+            : options.timedOut
+                ? 'timeout'
+                : collector.sawReply
+                    ? 'reply'
+                    : collector.sawTypingStop
+                        ? 'typing_stop'
+                        : 'none';
+        const hungPreview = collector.sawPreviewLike && !collector.sawTypingStop;
+        const passed = Boolean(collector.sawTypingStart &&
+            collector.sawTypingStop &&
+            previewBeforeFinal &&
+            collector.updateMessageCount >= 2 &&
+            collector.cumulativeUpdates &&
+            !hungPreview &&
+            !options.error &&
+            !options.timedOut);
+        return {
+            workspaceId,
+            agentType,
+            transport,
+            prompt,
+            passed,
+            startedAt: collector.startedAt,
+            completedAt,
+            durationMs,
+            threadId: options.threadId,
+            sessionKey: options.sessionKey,
+            error: options.error,
+            criteria: {
+                sawTypingStart: collector.sawTypingStart,
+                sawTypingStop: collector.sawTypingStop,
+                previewBeforeFinal,
+                updateMessageCount: collector.updateMessageCount,
+                cumulativeUpdates: collector.cumulativeUpdates,
+                finalEvent,
+                hungPreview,
+            },
+            events: collector.events,
+        };
+    }
+    waitForProbeSequence(sessionKey, timeoutMs, collector) {
+        let active = true;
+        let unsubscribe = () => { };
+        const promise = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                active = false;
+                unsubscribe();
+                reject(new Error(`Timed out waiting for ACP streaming events after ${timeoutMs}ms`));
+            }, timeoutMs);
+            unsubscribe = this.subscribeBridge((event) => {
+                if (!active) {
+                    return;
+                }
+                if (event.sessionKey !== sessionKey) {
+                    return;
+                }
+                this.recordProbeEvent(collector, event);
+                if (event.type === 'typing_stop') {
+                    active = false;
+                    clearTimeout(timeout);
+                    unsubscribe();
+                    resolve();
+                }
+            });
+        });
+        return {
+            promise,
+            cancel: () => {
+                if (!active) {
+                    return;
+                }
+                active = false;
+                unsubscribe();
+            },
+        };
+    }
+    buildProbePrompt() {
+        return 'Reply with exactly three short plain-text lines: alpha, beta, gamma. Do not call tools or ask questions.';
+    }
+    async probeLocalCoreAcpWorkspace(workspaceId, route) {
+        const prompt = this.buildProbePrompt();
+        const thread = await this.localCoreAcp.createThread(workspaceId, `[probe] ${new Date().toISOString()}`, route.agentType);
+        const collector = this.createProbeCollector();
+        const sequence = this.waitForProbeSequence(thread.bridgeSessionKey || '', 20000, collector);
+        try {
+            const sent = await this.localCoreAcp.sendThreadMessage(thread.id, prompt, route.config);
+            await sequence.promise;
+            await this.localCoreAcp.interruptRun(sent.runId).catch(() => ({ interrupted: false }));
+            return this.finalizeProbeResult(workspaceId, route.agentType, 'localcore-acp', prompt, collector, {
+                threadId: thread.id,
+                sessionKey: thread.bridgeSessionKey,
+            });
+        }
+        catch (error) {
+            sequence.cancel();
+            return this.finalizeProbeResult(workspaceId, route.agentType, 'localcore-acp', prompt, collector, {
+                threadId: thread.id,
+                sessionKey: thread.bridgeSessionKey,
+                error: error instanceof Error ? error.message : String(error),
+                timedOut: error instanceof Error && error.message.includes('Timed out'),
+            });
+        }
+        finally {
+            await this.localCoreAcp.deleteThread(thread.id).catch(() => ({ deleted: false }));
+        }
+    }
+    async getWorkspaceRoute(workspaceId) {
+        const configState = await this.options.readConfigState();
+        const projects = Array.isArray(configState.parsed?.projects) ? configState.parsed.projects : [];
+        const matched = projects.find((project) => String(project?.name || '').trim() === workspaceId);
+        const route = matched ? this.resolveProjectRoute(configState, matched) : null;
+        if (!matched || !route) {
+            throw new Error(`Workspace "${workspaceId}" is not configured as a Local AI Core ACP workspace.`);
+        }
+        return route;
+    }
+    async listLocalCoreProjects() {
+        const configState = await this.options.readConfigState();
+        const projects = Array.isArray(configState.parsed?.projects) ? configState.parsed.projects : [];
+        return projects.filter((project) => this.resolveProjectRoute(configState, project));
+    }
+    resolveProjectRoute(configState, project) {
+        for (const runtime of this.options.getAgentRuntimes?.() || []) {
+            if (!runtime.matchesProject(project)) {
+                continue;
+            }
+            const route = runtime.createRoute(configState, project);
+            if (route) {
+                return {
+                    ...route,
+                    runtime,
+                };
+            }
+        }
+        if ((0, workspace_route_config_js_1.isLocalCoreNativeAcpProject)(project)) {
+            const agentType = String(project.agent?.type || '').trim().toLowerCase() || 'localcore-acp';
+            return {
+                kind: 'localcore-acp',
+                agentType,
+                transport: 'localcore-acp',
+                config: {
+                    ...(0, workspace_route_config_js_1.toLocalCoreProjectConfig)(configState, project),
+                    agentType,
+                },
+                supportsStreamingProbe: true,
+                runtime: {
+                    agentType,
+                    transport: 'localcore-acp',
+                    matchesProject: () => true,
+                    createRoute: () => null,
+                },
+            };
+        }
+        return null;
+    }
+}
+exports.WorkspaceRouter = WorkspaceRouter;
+function createWorkspaceRouter(options) {
+    return new WorkspaceRouter(options);
+}

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

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCoreController = void 0;
+const node_events_1 = require("node:events");
+const desktop_js_1 = require("../../../../shared/desktop.js");
+const bootstrap_js_1 = require("../kernel/bootstrap.js");
+class LocalCoreController extends node_events_1.EventEmitter {
+    userDataPath;
+    state;
+    workspaceRouter;
+    knowledgeProvider;
+    channelRuntime;
+    weixinChannelRuntime;
+    scheduler;
+    kernel;
+    runtime;
+    busUnsubscribers = [];
+    constructor(userDataPath, runtime) {
+        super();
+        this.userDataPath = userDataPath;
+        this.runtime = runtime || (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            localCoreBase: 'http://127.0.0.1:9831/api/local/v1',
+            log: (message) => this.handleLog(message),
+        });
+        this.state = this.runtime.state;
+        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;
+        this.scheduler = this.runtime.scheduler;
+        this.busUnsubscribers.push(this.kernel.context.bus.on('platform.bridge.updated', (event) => {
+            this.emit('bridge', event);
+        }), this.kernel.context.bus.on('scheduler.job.updated', (job) => {
+            this.emit('scheduler-job', job);
+        }), this.kernel.context.bus.on('scheduler.run.updated', (run) => {
+            this.emit('scheduler-run', run);
+        }), this.kernel.context.bus.on('runtime.state.changed', () => {
+            void this.emitRuntime();
+        }));
+    }
+    async init() {
+        await this.runtime.start();
+        await this.emitRuntime();
+    }
+    async close() {
+        for (const unsubscribe of this.busUnsubscribers) {
+            unsubscribe();
+        }
+        await this.runtime.stop();
+    }
+    async getRuntimeStatus() {
+        const service = {
+            status: 'running',
+            startedAt: new Date().toISOString(),
+        };
+        return {
+            mode: 'desktop',
+            phase: 'api_ready',
+            pendingRestart: false,
+            service,
+            roles: (0, desktop_js_1.deriveDesktopRuntimeRoles)(service),
+            settings: this.state.getSettings(),
+            configFile: await this.readConfigFile(),
+            logs: this.getLogs(200),
+            pluginDiagnostics: await this.getPluginDiagnostics(),
+        };
+    }
+    async startService() {
+        return { status: 'running' };
+    }
+    async stopService() {
+        return { status: 'running' };
+    }
+    async restartService() {
+        await this.channelRuntime.refreshBindings?.();
+        await this.weixinChannelRuntime.refreshBindings?.();
+        await this.emitRuntime();
+        return { status: 'running' };
+    }
+    getLogs(limit = 200) {
+        return this.state.getLogs(limit);
+    }
+    async readConfigFile() {
+        return this.state.readConfigFile();
+    }
+    async saveRawConfigFile(raw) {
+        const next = await this.state.saveRawConfigFile(raw);
+        await this.channelRuntime.refreshBindings?.();
+        await this.weixinChannelRuntime.refreshBindings?.();
+        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.emitRuntime();
+        return next;
+    }
+    async saveSettings(input) {
+        const settings = await this.state.saveSettings(input);
+        await this.channelRuntime.refreshBindings?.();
+        await this.weixinChannelRuntime.refreshBindings?.();
+        await this.emitRuntime();
+        return settings;
+    }
+    async listWorkspaces() {
+        return this.workspaceRouter.listWorkspaces();
+    }
+    async listScheduledJobs(workspaceId) {
+        return this.scheduler.listJobs(workspaceId);
+    }
+    async getScheduledJob(jobId) {
+        const job = this.scheduler.getJob(jobId);
+        if (!job) {
+            throw new Error(`Scheduled job not found: ${jobId}`);
+        }
+        return job;
+    }
+    async createScheduledJob(input) {
+        return this.scheduler.createJob(input);
+    }
+    async updateScheduledJob(jobId, input) {
+        return this.scheduler.updateJob(jobId, input);
+    }
+    async deleteScheduledJob(jobId) {
+        return this.scheduler.deleteJob(jobId);
+    }
+    async runScheduledJob(jobId) {
+        return this.scheduler.runJobNow(jobId);
+    }
+    async listScheduledJobRuns(jobId) {
+        return this.scheduler.listJobRuns(jobId);
+    }
+    async listThreads(workspaceId) {
+        return this.workspaceRouter.listThreads(workspaceId);
+    }
+    async createThread(workspaceId, title) {
+        return this.workspaceRouter.createThread(workspaceId, title);
+    }
+    async getThread(threadId) {
+        return this.workspaceRouter.getThread(threadId);
+    }
+    async renameThread(threadId, title) {
+        return this.workspaceRouter.renameThread(threadId, title);
+    }
+    async updateThreadKnowledgeBases(threadId, knowledgeBaseIds) {
+        return this.workspaceRouter.updateThreadKnowledgeBases(threadId, knowledgeBaseIds);
+    }
+    async deleteThread(threadId) {
+        return this.workspaceRouter.deleteThread(threadId);
+    }
+    async sendThreadMessage(threadId, content) {
+        return this.workspaceRouter.sendThreadMessage(threadId, content);
+    }
+    async sendThreadAction(threadId, content) {
+        return this.workspaceRouter.sendThreadAction(threadId, content);
+    }
+    async interruptRun(runId) {
+        return this.workspaceRouter.interruptRun(runId);
+    }
+    async listKnowledgeSources() {
+        return this.knowledgeProvider.listSources();
+    }
+    async getKnowledgeConfig() {
+        return this.knowledgeProvider.getConfig();
+    }
+    async updateKnowledgeConfig(input) {
+        return this.knowledgeProvider.updateConfig(input);
+    }
+    async listKnowledgeFolders() {
+        return this.knowledgeProvider.listFolders();
+    }
+    async createKnowledgeFolder(input) {
+        return this.knowledgeProvider.createFolder(input);
+    }
+    async updateKnowledgeFolder(id, input) {
+        return this.knowledgeProvider.updateFolder(id, input);
+    }
+    async deleteKnowledgeFolder(id) {
+        return this.knowledgeProvider.deleteFolder(id);
+    }
+    async listKnowledgeBases() {
+        return this.knowledgeProvider.listKnowledgeBases();
+    }
+    async getKnowledgeBase(id) {
+        return this.knowledgeProvider.getKnowledgeBase(id);
+    }
+    async createKnowledgeBase(input) {
+        return this.knowledgeProvider.createKnowledgeBase(input);
+    }
+    async updateKnowledgeBase(id, input) {
+        return this.knowledgeProvider.updateKnowledgeBase(id, input);
+    }
+    async deleteKnowledgeBase(id) {
+        return this.knowledgeProvider.deleteKnowledgeBase(id);
+    }
+    async listKnowledgeBaseFiles(knowledgeBaseId) {
+        return this.knowledgeProvider.listKnowledgeBaseFiles(knowledgeBaseId);
+    }
+    async uploadKnowledgeBaseFiles(knowledgeBaseId, request) {
+        return this.knowledgeProvider.uploadKnowledgeBaseFiles(knowledgeBaseId, request);
+    }
+    async deleteKnowledgeBaseFile(knowledgeBaseId, fileId) {
+        return this.knowledgeProvider.deleteKnowledgeBaseFile(knowledgeBaseId, fileId);
+    }
+    async searchKnowledgeBase(knowledgeBaseId, input) {
+        return this.knowledgeProvider.searchKnowledgeBase(knowledgeBaseId, input);
+    }
+    async getCapabilities() {
+        return this.kernel.getCapabilitySnapshot();
+    }
+    async getCapabilitySnapshot() {
+        return this.kernel.getCapabilitySnapshot().snapshot;
+    }
+    async getPluginDiagnostics() {
+        return this.kernel.diagnostics.snapshot();
+    }
+    async probeWorkspaceStreaming(workspaceId) {
+        return this.workspaceRouter.probeWorkspaceStreaming(workspaceId);
+    }
+    async listChannelGatewayStatuses(platform) {
+        if (!platform) {
+            const [larkStatuses, weixinStatuses] = await Promise.all([
+                this.channelRuntime.listStatuses(),
+                this.weixinChannelRuntime.listStatuses(),
+            ]);
+            return [...larkStatuses, ...weixinStatuses];
+        }
+        return this.resolveChannelRuntime(platform).listStatuses();
+    }
+    async getChannelGatewayStatus(platform, workspaceId) {
+        return this.resolveChannelRuntime(platform).getStatus(workspaceId);
+    }
+    async testChannelConnection(platform, workspaceId) {
+        return this.resolveChannelRuntime(platform).testConnection(workspaceId);
+    }
+    async enableChannelGateway(platform, workspaceId) {
+        return this.resolveChannelRuntime(platform).enable(workspaceId);
+    }
+    async disableChannelGateway(platform, workspaceId) {
+        return this.resolveChannelRuntime(platform).disable(workspaceId);
+    }
+    async listChannelPendingPairings(platform, workspaceId) {
+        return this.resolveChannelRuntime(platform).listPendingPairings(workspaceId);
+    }
+    async approveChannelPairing(platform, code) {
+        return this.resolveChannelRuntime(platform).approvePairing(code);
+    }
+    async rejectChannelPairing(platform, code) {
+        return this.resolveChannelRuntime(platform).rejectPairing(code);
+    }
+    async listChannelAuthorizedUsers(platform, workspaceId) {
+        return this.resolveChannelRuntime(platform).listAuthorizedUsers(workspaceId);
+    }
+    async getWeixinQrCode(workspaceId) {
+        const runtime = this.weixinChannelRuntime;
+        return runtime.getQrCode(workspaceId);
+    }
+    async checkWeixinQrCodeStatus(workspaceId, ticket) {
+        const runtime = this.weixinChannelRuntime;
+        return runtime.checkQrCodeStatus(workspaceId, ticket);
+    }
+    async listLarkGatewayStatuses() {
+        return this.listChannelGatewayStatuses('lark');
+    }
+    async getLarkGatewayStatus(workspaceId) {
+        return this.getChannelGatewayStatus('lark', workspaceId);
+    }
+    async testLarkConnection(workspaceId) {
+        return this.testChannelConnection('lark', workspaceId);
+    }
+    async enableLarkGateway(workspaceId) {
+        return this.enableChannelGateway('lark', workspaceId);
+    }
+    async disableLarkGateway(workspaceId) {
+        return this.disableChannelGateway('lark', workspaceId);
+    }
+    async listLarkPendingPairings(workspaceId) {
+        return this.listChannelPendingPairings('lark', workspaceId);
+    }
+    async approveLarkPairing(code) {
+        return this.approveChannelPairing('lark', code);
+    }
+    async rejectLarkPairing(code) {
+        return this.rejectChannelPairing('lark', code);
+    }
+    async listLarkAuthorizedUsers(workspaceId) {
+        return this.listChannelAuthorizedUsers('lark', workspaceId);
+    }
+    emitBridge(event) {
+        this.emit('bridge', event);
+    }
+    async emitRuntime() {
+        this.emit('runtime', await this.getRuntimeStatus());
+    }
+    handleLog(message) {
+        this.emit('logs', message);
+    }
+    resolveChannelRuntime(platform) {
+        if (platform === this.channelRuntime.platform) {
+            return this.channelRuntime;
+        }
+        if (platform === this.weixinChannelRuntime.platform) {
+            return this.weixinChannelRuntime;
+        }
+        throw new Error(`Unsupported channel platform: ${platform}`);
+    }
+    assertPlatform(platform) {
+        this.resolveChannelRuntime(platform);
+    }
+}
+exports.LocalCoreController = LocalCoreController;