@kafca/agentdock 0.1.43 → 0.1.45

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

@@ -11,10 +11,12 @@ 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 session_command_service_js_1 = require("../../thread/session-command-service.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 config_js_1 = require("./config.js");
 const transport_js_1 = require("./transport.js");
 // ==================== Constants ====================
@@ -30,6 +32,7 @@ const WEIXIN_RESERVED_TERMINAL_SENDS = 1;
 const WEIXIN_PROGRESS_SEND_BUDGET = WEIXIN_CONTEXT_SEND_LIMIT - WEIXIN_RESERVED_TERMINAL_SENDS;
 const RESPONSE_TIMEOUT_MS = 5 * 60 * 1000;
 const WEIXIN_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
+const ERROR_LOG_WINDOW_MS = 5 * 60 * 1000;
 // ==================== Utilities ====================
 function stripHtml(html) {
     let result = html;
@@ -152,21 +155,36 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
     outboundTurns = new Map();
     processedInboundMessages = new Map();
     mutedThreadBridgeCounts = new Map();
+    pollErrorLogWindows = new Map();
     sessionCommandRuntime;
     platform = 'weixin';
     routeType = 'channel.chat';
     constructor(options) {
         super();
         this.options = options;
-        const sessionCommandService = new session_command_service_js_1.SessionCommandService({
-            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),
+        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({
-            service: sessionCommandService,
+            dispatcher: slashCommands,
             store: this.options.store,
             getThreadSessionKey: (threadId) => this.options.getWorkspaceRouter().getThreadSessionKey(threadId),
             setThreadRoute: (sessionKey, route) => {
@@ -259,6 +277,10 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             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,
             pendingPairings: pairings.length,
             authorizedUsers: users.length,
@@ -657,24 +679,17 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return { paired: false };
         }
         const router = this.options.getWorkspaceRouter();
-        const threadBinding = this.options.store.getPlatformThreadBinding(input.workspaceId, input.chatId, input.platformUserId, platformKey);
-        let threadId = threadBinding?.thread_id || authorized.thread_id || '';
-        if (!threadId) {
-            const thread = await router.createThread(input.workspaceId, input.displayName || `WeChat ${input.chatId}`);
-            threadId = thread.id;
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, platformKey);
-            const now = new Date().toISOString();
-            this.options.store.upsertPlatformThreadBinding({
-                workspace_id: input.workspaceId,
-                platform: platformKey,
-                chat_id: input.chatId,
-                platform_user_id: input.platformUserId,
-                thread_id: threadId,
-                last_platform_message_id: null,
-                created_at: now,
-                updated_at: now,
-            });
-        }
+        let { threadId } = await (0, thread_routing_js_1.resolveChannelThreadRoute)({
+            store: this.options.store,
+            router,
+            workspaceId: input.workspaceId,
+            platformKey,
+            chatId: input.chatId,
+            platformUserId: input.platformUserId,
+            displayName: input.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) : '';
         if (permissionThreadId && permissionThreadId !== threadId) {
@@ -696,6 +711,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             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,
             platformKey,
@@ -729,6 +745,13 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
         await this.sendTextMessage(state, input.chatId, result.displayText, input.contextToken);
     }
+    async resolveDefaultAgentType(workspaceId, threadId) {
+        const router = this.options.getWorkspaceRouter();
+        if (typeof router.getWorkspaceDefaultAgentType === 'function') {
+            return router.getWorkspaceDefaultAgentType(workspaceId);
+        }
+        return this.options.store.getThreadRow(threadId)?.agent_type || 'codex';
+    }
     // ==================== Private: Bindings ====================
     resolveRuntimeState(workspaceId, instanceId) {
         if (instanceId) {
@@ -775,20 +798,28 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 status.status = 'stopped';
                 status.connected = false;
                 status.lastError = 'Scan the WeChat QR code to finish login before starting message polling.';
+                status.lastErrorInfo = new local_core_errors_js_1.LocalCoreError('channel_auth_failed', status.lastError, {
+                    userMessage: 'WeChat is not connected.',
+                    suggestedAction: 'Scan the WeChat QR code to finish login.',
+                }).info;
+                status.lastErrorAt = new Date().toISOString();
                 this.notifyRuntimeStateChanged();
                 return;
             }
             status.status = 'running';
             status.connected = true;
             status.connectedAt = new Date().toISOString();
-            status.lastError = undefined;
+            this.clearRuntimeError(status);
             // Start long-poll loop in background
             this.runMonitorLoop(binding, abortController.signal).catch((err) => {
                 if (!abortController.signal.aborted) {
-                    this.options.log?.(`localcore-weixin monitor terminated for ${binding.workspaceId}: ${formatError(err)}`);
                     status.status = 'error';
                     status.connected = false;
-                    status.lastError = formatError(err);
+                    this.setRuntimeError(status, err, 'internal_error', {
+                        workspaceId: binding.workspaceId,
+                        instanceId: binding.instanceId,
+                        runtimeId: 'weixin',
+                    });
                     this.notifyRuntimeStateChanged();
                 }
             });
@@ -796,8 +827,11 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         catch (error) {
             status.status = 'error';
             status.connected = false;
-            status.lastError = formatError(error);
-            this.options.log?.(`localcore-weixin start failed for ${binding.workspaceId}: ${status.lastError}`);
+            this.setRuntimeError(status, error, 'internal_error', {
+                workspaceId: binding.workspaceId,
+                instanceId: binding.instanceId,
+                runtimeId: 'weixin',
+            });
         }
         this.notifyRuntimeStateChanged();
     }
@@ -845,27 +879,47 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 const isApiError = (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
                 if (isApiError) {
                     consecutiveFailures++;
-                    const errorText = resp.errmsg ? ` errmsg=${resp.errmsg}` : '';
-                    this.options.log?.(`localcore-weixin getUpdates failed for ${binding.workspaceId}: ret=${resp.ret} errcode=${resp.errcode}${errorText} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`);
+                    const state = this.runtime.get((0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId));
+                    const retryDelayMs = this.computeRetryDelay(consecutiveFailures);
                     if (resp.errcode === -14 || resp.ret === -14) {
-                        const state = this.runtime.get((0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId));
                         if (state) {
                             state.status = 'error';
                             state.connected = false;
-                            state.lastError = 'WeChat login expired. Generate and scan a new QR code.';
+                            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.notifyRuntimeStateChanged();
                         }
                     }
-                    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-                        consecutiveFailures = 0;
-                        await sleep(BACKOFF_DELAY_MS, signal);
+                    this.logPollError(binding, `ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg || ''}`, `localcore-weixin getUpdates failed for ${binding.workspaceId}: ret=${resp.ret} errcode=${resp.errcode}${resp.errmsg ? ` errmsg=${resp.errmsg}` : ''} (${consecutiveFailures})`);
+                    if (state && resp.errcode !== -14 && resp.ret !== -14) {
+                        state.consecutiveFailures = consecutiveFailures;
+                        state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
                     }
-                    else {
-                        await sleep(RETRY_DELAY_MS, signal);
+                    await sleep(retryDelayMs, signal);
+                    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                        consecutiveFailures = MAX_CONSECUTIVE_FAILURES;
                     }
                     continue;
                 }
                 consecutiveFailures = 0;
+                const state = this.runtime.get((0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId));
+                if (state) {
+                    this.clearRuntimeError(state);
+                    state.status = 'running';
+                    state.connected = true;
+                    this.notifyRuntimeStateChanged();
+                }
                 if (resp.get_updates_buf) {
                     buf = resp.get_updates_buf;
                     (0, config_js_1.saveWeixinBuf)(binding, buf);
@@ -927,14 +981,20 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 if (signal.aborted)
                     return;
                 consecutiveFailures++;
-                this.options.log?.(`localcore-weixin getUpdates error for ${binding.workspaceId} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${formatError(err)}`);
-                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-                    consecutiveFailures = 0;
-                    await sleep(BACKOFF_DELAY_MS, signal);
-                }
-                else {
-                    await sleep(RETRY_DELAY_MS, signal);
+                const retryDelayMs = this.computeRetryDelay(consecutiveFailures);
+                const state = this.runtime.get((0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId));
+                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.notifyRuntimeStateChanged();
                 }
+                this.logPollError(binding, formatError(err), `localcore-weixin getUpdates error for ${binding.workspaceId} (${consecutiveFailures}): ${formatError(err)}`);
+                await sleep(retryDelayMs, signal);
             }
         }
     }
@@ -1273,6 +1333,50 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             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;
+        if (failures === 2)
+            return 5_000;
+        if (failures === 3)
+            return 15_000;
+        if (failures === 4)
+            return 30_000;
+        return 60_000;
+    }
+    logPollError(binding, errorKey, message) {
+        const key = (0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId);
+        const current = this.pollErrorLogWindows.get(key);
+        const now = Date.now();
+        if (!current || current.errorKey !== errorKey || now - current.at >= ERROR_LOG_WINDOW_MS) {
+            this.pollErrorLogWindows.set(key, { at: now, count: 1, errorKey });
+            this.options.log?.(message);
+            return;
+        }
+        current.count += 1;
+        this.pollErrorLogWindows.set(key, current);
+    }
 }
 exports.LocalCoreWeixinGateway = LocalCoreWeixinGateway;
 function getWeixinInstanceId(platform) {

package/dist-electron/services/local-ai-core/src/execution/agent-execution-backend.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenSandboxExecutionBackend = exports.LocalAgentExecutionBackend = void 0;
+exports.prepareAgentExecutionLaunch = prepareAgentExecutionLaunch;
+const sandbox_config_js_1 = require("../sandbox/sandbox-config.js");
+class LocalAgentExecutionBackend {
+    mode = 'local';
+    prepareLaunch(input) {
+        return {
+            ...input.launchConfig,
+            execution: {
+                mode: 'local',
+                transport: 'stdio',
+            },
+        };
+    }
+}
+exports.LocalAgentExecutionBackend = LocalAgentExecutionBackend;
+class OpenSandboxExecutionBackend {
+    mode = 'sandbox';
+    prepareLaunch(input) {
+        const sandbox = (0, sandbox_config_js_1.normalizeSandboxLaunchConfig)(input);
+        if (!sandbox) {
+            return new LocalAgentExecutionBackend().prepareLaunch(input);
+        }
+        return {
+            ...input.launchConfig,
+            command: process.execPath,
+            args: [(0, sandbox_config_js_1.sandboxProxyScriptPath)()],
+            env: {
+                ...(0, sandbox_config_js_1.sandboxProxyLaunchEnv)(sandbox),
+                AGENTDOCK_SANDBOX_AGENT_TYPE: input.launchConfig.agentType,
+            },
+            execution: {
+                mode: 'sandbox',
+                transport: `sandbox-${sandbox.transport}-stdio-proxy`,
+                provider: sandbox.provider,
+                sandbox: {
+                    image: sandbox.image,
+                    transport: sandbox.transport,
+                    acpPort: sandbox.acpPort,
+                    stateScope: sandbox.stateScope,
+                    stateMountPath: sandbox.stateMountPath,
+                },
+            },
+            sandbox,
+        };
+    }
+}
+exports.OpenSandboxExecutionBackend = OpenSandboxExecutionBackend;
+function prepareAgentExecutionLaunch(input) {
+    const backend = (0, sandbox_config_js_1.isProjectSandboxEnabled)(input.project)
+        ? new OpenSandboxExecutionBackend()
+        : new LocalAgentExecutionBackend();
+    return backend.prepareLaunch(input);
+}

package/dist-electron/services/local-ai-core/src/kernel/bootstrap.js

@@ -8,16 +8,7 @@ const diagnostics_js_1 = require("./diagnostics.js");
 const event_bus_js_1 = require("./event-bus.js");
 const lifecycle_manager_js_1 = require("./lifecycle-manager.js");
 const plugin_registry_js_1 = require("./plugin-registry.js");
-const index_js_1 = require("../agents/index.js");
-const channel_lark_plugin_js_1 = require("../plugins/builtin/channel-lark-plugin.js");
-const channel_weixin_plugin_js_1 = require("../plugins/builtin/channel-weixin-plugin.js");
-const knowledge_ai_vector_plugin_js_1 = require("../plugins/builtin/knowledge-ai-vector-plugin.js");
-const knowledge_noop_plugin_js_1 = require("../plugins/builtin/knowledge-noop-plugin.js");
-const scheduler_cron_plugin_js_1 = require("../plugins/builtin/scheduler-cron-plugin.js");
-const scheduler_lark_plugin_js_1 = require("../plugins/builtin/scheduler-lark-plugin.js");
-const scheduler_local_plugin_js_1 = require("../plugins/builtin/scheduler-local-plugin.js");
-const scheduler_weixin_plugin_js_1 = require("../plugins/builtin/scheduler-weixin-plugin.js");
-const monitor_stock_plugin_js_1 = require("../plugins/builtin/monitor-stock-plugin.js");
+const catalog_js_1 = require("../plugins/builtin/catalog.js");
 const workspace_router_js_1 = require("../router/workspace-router.js");
 const local_core_runtime_state_js_1 = require("../runtime/local-core-runtime-state.js");
 const scheduled_job_application_service_js_1 = require("../scheduler/scheduled-job-application-service.js");
@@ -37,12 +28,7 @@ function bootstrapLocalCoreKernel(options) {
     };
     const lifecycle = new lifecycle_manager_js_1.LocalCoreLifecycleManager(plugins, context);
     const diagnostics = new diagnostics_js_1.LocalCoreDiagnostics(plugins, lifecycle);
-    const builtIns = [
-        ...(0, index_js_1.getStaticAgentRuntimeDefinitions)().map((definition) => (0, index_js_1.createBuiltinStaticAgentCapabilityPlugin)(definition.agentType, definition.displayName)),
-        (0, index_js_1.createBuiltinLocalCoreAcpAgentPlugin)(),
-        (0, scheduler_cron_plugin_js_1.createBuiltinCronSchedulerPlugin)(),
-    ];
-    for (const plugin of builtIns) {
+    for (const plugin of (0, catalog_js_1.createKernelBuiltinPlugins)()) {
         plugins.register(plugin);
         options?.log?.(`[plugin:${plugin.manifest.id}] registered`);
         if (plugin.capabilities && plugins.isEnabled(plugin.manifest.id)) {
@@ -184,56 +170,31 @@ function bootstrapLocalCoreRuntime(options) {
     if (!localCoreAgentPlugin) {
         throw new Error('Missing built-in LocalCore ACP agent plugin.');
     }
-    const agentPlugins = [
-        localCoreAgentPlugin,
-        (0, index_js_1.createBuiltinPiAgentPlugin)(),
-        (0, index_js_1.createBuiltinOpencodeAgentPlugin)(),
-        (0, index_js_1.createBuiltinCodexAgentPlugin)(),
-        (0, index_js_1.createBuiltinClaudeCodeAgentPlugin)(),
-        (0, index_js_1.createBuiltinHermesAgentPlugin)(),
-    ];
+    const agentPlugins = (0, catalog_js_1.createRuntimeAgentPlugins)(localCoreAgentPlugin);
     let workspaceRouter;
     let weixinChannelRuntime;
-    const channelPlugin = (0, channel_lark_plugin_js_1.createBuiltinLarkChannelPlugin)({
+    const channelPlugins = (0, catalog_js_1.createRuntimeChannelPlugins)({
         store,
         readConfig: async () => (await state.readConfigFile()).parsed,
         getWorkspaceRouter: () => workspaceRouter,
         log: options.log,
     });
-    const weixinChannelPlugin = (0, channel_weixin_plugin_js_1.createBuiltinWeixinChannelPlugin)({
+    const channelPlugin = channelPlugins.lark;
+    const weixinChannelPlugin = channelPlugins.weixin;
+    const knowledgePlugin = (0, catalog_js_1.createRuntimeKnowledgePlugin)({
+        enableKnowledge: options.enableKnowledge,
+        userDataPath: options.userDataPath,
+        getConfig: () => state.getKnowledgeConfig(),
+        setConfig: (input) => state.updateKnowledgeConfig(input),
+    });
+    const schedulerPlugins = (0, catalog_js_1.createRuntimeSchedulerPlugins)({
         store,
-        readConfig: async () => (await state.readConfigFile()).parsed,
         getWorkspaceRouter: () => workspaceRouter,
+        getLarkChannelRuntime: () => channelRuntime,
+        getWeixinChannelRuntime: () => weixinChannelRuntime,
         log: options.log,
     });
-    const knowledgePlugin = options.enableKnowledge === false
-        ? (0, knowledge_noop_plugin_js_1.createBuiltinNoopKnowledgePlugin)()
-        : (0, knowledge_ai_vector_plugin_js_1.createBuiltinAiVectorKnowledgePlugin)({
-            userDataPath: options.userDataPath,
-            getConfig: () => state.getKnowledgeConfig(),
-            setConfig: (input) => state.updateKnowledgeConfig(input),
-        });
-    const schedulerPlugins = [
-        (0, scheduler_local_plugin_js_1.createBuiltinLocalSchedulerPlugin)({
-            store,
-            getWorkspaceRouter: () => workspaceRouter,
-        }),
-        (0, scheduler_lark_plugin_js_1.createBuiltinLarkSchedulerPlugin)({
-            store,
-            getWorkspaceRouter: () => workspaceRouter,
-            getChannelRuntime: () => channelRuntime,
-            log: options.log,
-        }),
-        (0, scheduler_weixin_plugin_js_1.createBuiltinWeixinSchedulerPlugin)({
-            store,
-            getWorkspaceRouter: () => workspaceRouter,
-            getChannelRuntime: () => weixinChannelRuntime,
-            log: options.log,
-        }),
-    ];
-    const monitorPlugins = [
-        (0, monitor_stock_plugin_js_1.createBuiltinStockMonitorPlugin)(),
-    ];
+    const monitorPlugins = (0, catalog_js_1.createRuntimeMonitorPlugins)();
     for (const plugin of agentPlugins.filter((plugin) => plugin !== localCoreAgentPlugin)) {
         registerPlugin(kernel, plugin);
     }
@@ -257,8 +218,8 @@ function bootstrapLocalCoreRuntime(options) {
     ];
     const knowledgeRuntime = kernel.plugins.isEnabled(knowledgePlugin.manifest.id)
         ? resolveKnowledgeRuntime(knowledgePlugin, kernel.context)
-        : resolveKnowledgeRuntime((0, knowledge_noop_plugin_js_1.createBuiltinNoopKnowledgePlugin)(), kernel.context);
-    const cronSchedulerPlugin = (0, scheduler_cron_plugin_js_1.createBuiltinCronSchedulerPlugin)();
+        : resolveKnowledgeRuntime((0, catalog_js_1.createBuiltinNoopKnowledgePlugin)(), kernel.context);
+    const cronSchedulerPlugin = (0, catalog_js_1.createBuiltinCronSchedulerPlugin)();
     const schedulerRuntimes = [
         ...(kernel.plugins.isEnabled(cronSchedulerPlugin.manifest.id)
             ? [resolveSchedulerRuntime(cronSchedulerPlugin, kernel.context)]