@kafca/agentdock 0.1.42 → 0.1.44

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

@@ -13,6 +13,9 @@ const node_crypto_2 = require("node:crypto");
 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 session_command_service_js_1 = require("../../thread/session-command-service.js");
 const config_js_1 = require("./config.js");
 const transport_js_1 = require("./transport.js");
 // ==================== Constants ====================
@@ -150,11 +153,36 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
     outboundTurns = new Map();
     processedInboundMessages = new Map();
     mutedThreadBridgeCounts = 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),
+        });
+        this.sessionCommandRuntime = new session_command_runtime_js_1.ChannelSessionCommandRuntime({
+            service: sessionCommandService,
+            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() {
@@ -630,25 +658,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,
-            });
-        }
-        const sessionKey = router.getThreadSessionKey(threadId);
+        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) {
@@ -665,38 +685,19 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         });
         // Handle slash commands
         const slashCommand = this.parseSlashCommand(input.text);
-        if (slashCommand?.name === 'new') {
-            const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'WeChat'} ${new Date().toLocaleTimeString()}`;
-            const nextThread = await router.createThread(input.workspaceId, title);
-            const inheritedMode = this.options.store.getThreadRow?.(threadId)?.agent_mode || '';
-            if (inheritedMode && inheritedMode !== 'default') {
-                this.options.store.updateThreadAgentMode?.(nextThread.id, inheritedMode);
-            }
-            const now = new Date().toISOString();
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, platformKey);
-            this.options.store.upsertPlatformThreadBinding({
-                workspace_id: input.workspaceId,
-                platform: platformKey,
-                chat_id: input.chatId,
-                platform_user_id: input.platformUserId,
-                thread_id: nextThread.id,
-                last_platform_message_id: null,
-                created_at: now,
-                updated_at: now,
-            });
-            this.threadRouting.set(router.getThreadSessionKey(nextThread.id), {
-                workspaceId: input.workspaceId,
-                instanceId,
-                platformKey,
-                platformUserId: input.platformUserId,
-                chatId: input.chatId,
-                threadId: nextThread.id,
-            });
-            const st = this.runtime.get((0, config_js_1.runtimeKey)(input.workspaceId, instanceId));
-            if (st?.connected) {
-                await this.sendTextMessage(st, input.chatId, '**已开始新会话**', input.contextToken);
-            }
-            return { paired: true, threadId: nextThread.id };
+        const sessionCommand = await this.executeSessionCommand({
+            workspaceId: input.workspaceId,
+            currentThreadId: threadId,
+            text: input.text,
+            defaultTitle: `${input.displayName || 'WeChat'} ${new Date().toLocaleTimeString()}`,
+            chatId: input.chatId,
+            platformUserId: input.platformUserId,
+            platformKey,
+            instanceId,
+            contextToken: input.contextToken,
+        });
+        if (sessionCommand.handled) {
+            return { paired: true, threadId: sessionCommand.threadId || threadId };
         }
         const latestRun = this.options.store.getLatestRunForThread(threadId);
         if ((normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny')
@@ -711,6 +712,17 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         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}`);
+            return;
+        }
+        await this.sendTextMessage(state, input.chatId, result.displayText, input.contextToken);
+    }
     // ==================== Private: Bindings ====================
     resolveRuntimeState(workspaceId, instanceId) {
         if (instanceId) {

package/dist-electron/services/local-ai-core/src/cli/lac.js

@@ -8,6 +8,8 @@ const node_process_1 = __importDefault(require("node:process"));
 const index_js_1 = require("../../../../packages/contracts/src/index.js");
 const job_id_js_1 = require("../scheduler/job-id.js");
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
+const monitor_id_js_1 = require("../automation/monitor-id.js");
+const monitor_cli_parsers_js_1 = require("./monitor-cli-parsers.js");
 const DEFAULT_BASE_URL = 'http://127.0.0.1:9831/api/local/v1';
 async function runCli(argv, env = node_process_1.default.env, io = node_process_1.default) {
     try {
@@ -23,6 +25,26 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
                     return 2;
             }
         }
+        if (domain === 'monitor') {
+            switch (action) {
+                case 'add':
+                    return await handleMonitorAdd(flags, env, io, json);
+                case 'list':
+                    return await handleMonitorList(flags, env, io, json);
+                case 'info':
+                    return await handleMonitorInfo(maybeId, flags, env, io, json);
+                case 'edit':
+                    return await handleMonitorEdit(maybeId, flags, env, io, json);
+                case 'del':
+                case 'delete':
+                    return await handleMonitorDelete(maybeId, flags, env, io, json);
+                case 'run':
+                    return await handleMonitorRun(maybeId, flags, env, io, json);
+                default:
+                    printUsage(io.stderr);
+                    return 2;
+            }
+        }
         if (domain !== 'scheduler') {
             printUsage(io.stderr);
             return 2;
@@ -51,6 +73,110 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
         return 1;
     }
 }
+async function handleMonitorAdd(flags, env, io, json) {
+    const context = resolveContext(flags, env);
+    if (!context.workspaceId) {
+        throw new Error('monitor add requires a workspace context. Set LOCAL_AI_WORKSPACE_ID or pass --workspace.');
+    }
+    const title = getRequiredFlag(flags, 'title');
+    const sourceType = getRequiredFlag(flags, 'source');
+    const promptTemplate = getRequiredFlag(flags, 'message');
+    const condition = (0, monitor_cli_parsers_js_1.parseMonitorCondition)(getRequiredFlag(flags, 'condition'));
+    const sourceConfig = buildSourceConfig(sourceType, flags);
+    const monitor = await request(context.baseUrl, 'POST', '/automation/monitors', {
+        workspaceId: context.workspaceId,
+        ...(context.threadId ? { threadId: context.threadId } : {}),
+        title,
+        sourceType,
+        sourceConfig,
+        condition,
+        promptTemplate,
+        executionMode: getMonitorExecutionMode(flags),
+        cooldownMs: (0, monitor_cli_parsers_js_1.parseDurationMs)(getFlag(flags, 'cooldown') || '15m'),
+        enabled: true,
+    });
+    print(json, io.stdout, presentMonitor(monitor), [
+        `Created monitor ${(0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id)}`,
+        `Title: ${monitor.title}`,
+        `Source: ${monitor.sourceType}`,
+        `Condition: ${formatCondition(monitor.condition)}`,
+        `Execution mode: ${monitor.executionMode}`,
+    ].join('\n'));
+    return 0;
+}
+async function handleMonitorList(flags, env, io, json) {
+    const context = resolveContext(flags, env);
+    const workspaceId = getFlag(flags, 'workspace') || context.workspaceId;
+    const threadId = flags.has('thread')
+        ? normalizeMaybeBooleanFlag(getFlag(flags, 'thread')) || context.threadId
+        : '';
+    const suffix = workspaceId ? `?workspace_id=${encodeURIComponent(workspaceId)}` : '';
+    const response = await request(context.baseUrl, 'GET', `/automation/monitors${suffix}`);
+    const monitors = threadId
+        ? response.monitors.filter((monitor) => monitor.route.threadId === threadId || monitorMatchesCliContext(monitor, context))
+        : response.monitors;
+    print(json, io.stdout, { monitors: monitors.map(presentMonitor) }, monitors.length === 0 ? 'No monitors.' : monitors.map(formatMonitorLine).join('\n'));
+    return 0;
+}
+async function handleMonitorInfo(monitorId, flags, env, io, json) {
+    if (!monitorId) {
+        throw new Error('monitor info requires a monitor id.');
+    }
+    const context = resolveContext(flags, env);
+    const monitor = await request(context.baseUrl, 'GET', `/automation/monitors/${encodeURIComponent(monitorId)}`);
+    const runs = await request(context.baseUrl, 'GET', `/automation/monitors/${encodeURIComponent(monitorId)}/runs`);
+    print(json, io.stdout, { monitor: presentMonitor(monitor), runs: runs.runs }, formatMonitorDetails(monitor, runs.runs[0]));
+    return 0;
+}
+async function handleMonitorEdit(monitorId, flags, env, io, json) {
+    if (!monitorId) {
+        throw new Error('monitor edit requires a monitor id.');
+    }
+    const input = {};
+    const title = getFlag(flags, 'title');
+    const promptTemplate = getFlag(flags, 'message');
+    const condition = getFlag(flags, 'condition');
+    const enabled = getOptionalBooleanFlag(flags, 'enabled');
+    const executionMode = getFlag(flags, 'execution-mode');
+    const cooldown = getFlag(flags, 'cooldown');
+    if (title)
+        input.title = title;
+    if (typeof promptTemplate === 'string' && promptTemplate)
+        input.promptTemplate = promptTemplate;
+    if (condition)
+        input.condition = (0, monitor_cli_parsers_js_1.parseMonitorCondition)(condition);
+    if (typeof enabled === 'boolean')
+        input.enabled = enabled;
+    if (executionMode)
+        input.executionMode = (0, index_js_1.normalizeScheduledJobExecutionMode)(executionMode);
+    if (cooldown)
+        input.cooldownMs = (0, monitor_cli_parsers_js_1.parseDurationMs)(cooldown);
+    if (Object.keys(input).length === 0) {
+        throw new Error('monitor edit requires at least one editable field.');
+    }
+    const context = resolveContext(flags, env);
+    const monitor = await request(context.baseUrl, 'PATCH', `/automation/monitors/${encodeURIComponent(monitorId)}`, input);
+    print(json, io.stdout, presentMonitor(monitor), `Updated monitor ${(0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id)}`);
+    return 0;
+}
+async function handleMonitorDelete(monitorId, flags, env, io, json) {
+    if (!monitorId) {
+        throw new Error('monitor del requires a monitor id.');
+    }
+    const context = resolveContext(flags, env);
+    const result = await request(context.baseUrl, 'DELETE', `/automation/monitors/${encodeURIComponent(monitorId)}`);
+    print(json, io.stdout, result, `Deleted monitor ${monitorId}`);
+    return 0;
+}
+async function handleMonitorRun(monitorId, flags, env, io, json) {
+    if (!monitorId) {
+        throw new Error('monitor run requires a monitor id.');
+    }
+    const context = resolveContext(flags, env);
+    const run = await request(context.baseUrl, 'POST', `/automation/monitors/${encodeURIComponent(monitorId)}/run`);
+    print(json, io.stdout, run, `Triggered monitor ${monitorId}: ${run.status}`);
+    return 0;
+}
 async function handleChannelSendFile(flags, env, io, json) {
     const context = resolveContext(flags, env);
     const filePath = getRequiredFlag(flags, 'path');
@@ -282,6 +408,23 @@ function normalizeMaybeBooleanFlag(value) {
 function getExecutionMode(flags) {
     return (0, index_js_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode'));
 }
+function getMonitorExecutionMode(flags) {
+    return (0, index_js_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode') || 'side-thread');
+}
+function buildSourceConfig(sourceType, flags) {
+    const config = {};
+    if (sourceType === 'stock.quote') {
+        config.symbol = getRequiredFlag(flags, 'symbol').toUpperCase();
+        const price = getFlag(flags, 'price');
+        if (price)
+            config.price = Number(price);
+    }
+    const rawConfig = getFlag(flags, 'source-config');
+    if (rawConfig) {
+        return { ...config, ...JSON.parse(rawConfig) };
+    }
+    return config;
+}
 function print(asJson, output, payload, text) {
     output.write(asJson ? `${JSON.stringify(payload, null, 2)}\n` : `${text}\n`);
 }
@@ -294,6 +437,12 @@ function printUsage(output) {
         '  lac scheduler edit <job-id> [--cron "<expr>"] [--message "<text>"] [--desc "<label>"] [--enabled true|false] [--execution-mode same-thread|side-thread] [--json]',
         '  lac scheduler del <job-id> [--json]',
         '  lac scheduler run <job-id> [--json]',
+        '  lac monitor add --title "<title>" --source stock.quote --symbol <symbol> --condition "change_percent >= 3" --message "<text>" [--cooldown 15m] [--execution-mode same-thread|side-thread] [--json]',
+        '  lac monitor list [--workspace <id>] [--thread [<id>]] [--json]',
+        '  lac monitor info <monitor-id> [--json]',
+        '  lac monitor edit <monitor-id> [--title "<title>"] [--condition "<expr>"] [--message "<text>"] [--enabled true|false] [--cooldown 15m] [--execution-mode same-thread|side-thread] [--json]',
+        '  lac monitor del <monitor-id> [--json]',
+        '  lac monitor run <monitor-id> [--json]',
         '  lac channel send-file --path "<file>" [--target <chat-or-user-id>] [--workspace <id>] [--workspace-path <path>] [--platform lark] [--name <filename>] [--json]',
     ].join('\n') + '\n');
 }
@@ -321,6 +470,53 @@ function presentJob(job) {
         id: (0, job_id_js_1.toPublicScheduledJobId)(job.id),
     };
 }
+function formatMonitorLine(monitor) {
+    return `${(0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id)} | ${monitor.enabled ? 'enabled' : 'disabled'} | ${monitor.executionMode} | ${monitor.sourceType} | ${formatCondition(monitor.condition)} | ${monitor.title}`;
+}
+function formatMonitorDetails(monitor, latestRun) {
+    return [
+        `Monitor: ${(0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id)}`,
+        `Title: ${monitor.title}`,
+        `Workspace: ${monitor.workspaceId}`,
+        `Platform: ${monitor.platform}`,
+        `Thread: ${monitor.route.threadId || ''}`,
+        `Execution mode: ${monitor.executionMode}`,
+        `Source: ${monitor.sourceType}`,
+        `Condition: ${formatCondition(monitor.condition)}`,
+        `Cooldown: ${monitor.cooldownMs}ms`,
+        `Enabled: ${monitor.enabled ? 'true' : 'false'}`,
+        `Message: ${monitor.promptTemplate}`,
+        latestRun ? `Latest run: ${latestRun.status} @ ${latestRun.triggeredAt}` : 'Latest run: none',
+    ].join('\n');
+}
+function formatCondition(condition) {
+    if (condition.expression) {
+        return condition.expression;
+    }
+    return `${condition.metric} ${condition.operator} ${condition.value}`;
+}
+function presentMonitor(monitor) {
+    return {
+        ...monitor,
+        id: (0, monitor_id_js_1.toPublicAutomationMonitorId)(monitor.id),
+    };
+}
+function monitorMatchesCliContext(monitor, context) {
+    return (0, scheduled_job_route_js_1.scheduledJobMatchesCliContext)({
+        id: monitor.id,
+        workspaceId: monitor.workspaceId,
+        platform: monitor.platform,
+        route: monitor.route,
+        executionMode: monitor.executionMode,
+        triggerType: 'once',
+        promptTemplate: monitor.promptTemplate,
+        description: monitor.title,
+        enabled: monitor.enabled,
+        concurrencyPolicy: monitor.concurrencyPolicy,
+        createdAt: monitor.createdAt,
+        updatedAt: monitor.updatedAt,
+    }, context);
+}
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist-electron/services/local-ai-core/src/cli/monitor-cli-parsers.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMonitorCondition = parseMonitorCondition;
+exports.parseDurationMs = parseDurationMs;
+const index_js_1 = require("../../../../packages/contracts/src/index.js");
+function parseMonitorCondition(value) {
+    const expression = String(value || '').trim();
+    if (expression.includes('&&') || expression.includes('||')) {
+        return {
+            metric: 'expression',
+            operator: '==',
+            value: true,
+            expression,
+        };
+    }
+    const match = expression.match(/^([a-zA-Z0-9_.-]+)\s*(>=|<=|==|!=|>|<)\s*(.+)$/);
+    if (!match) {
+        throw new Error('Monitor condition must look like "change_percent >= 3".');
+    }
+    const rawValue = String(match[3] || '').trim();
+    const numeric = Number(rawValue);
+    return {
+        metric: String(match[1] || '').trim(),
+        operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(match[2]),
+        value: Number.isFinite(numeric) && rawValue !== '' ? numeric : rawValue,
+    };
+}
+function parseDurationMs(value) {
+    const match = String(value || '').trim().match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/i);
+    if (!match) {
+        throw new Error('Duration must be a number with optional ms, s, m, or h suffix.');
+    }
+    const amount = Number(match[1]);
+    const unit = String(match[2] || 'ms').toLowerCase();
+    const multiplier = unit === 'h' ? 60 * 60 * 1000 : unit === 'm' ? 60 * 1000 : unit === 's' ? 1000 : 1;
+    return Math.round(amount * multiplier);
+}

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

@@ -17,10 +17,12 @@ const scheduler_cron_plugin_js_1 = require("../plugins/builtin/scheduler-cron-pl
 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 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");
 const scheduler_service_js_1 = require("../scheduler/scheduler-service.js");
+const automation_monitor_service_js_1 = require("../automation/automation-monitor-service.js");
 function bootstrapLocalCoreKernel(options) {
     const capabilities = new capability_registry_js_1.LocalCoreCapabilityRegistry();
     const plugins = new plugin_registry_js_1.LocalCorePluginRegistry(options?.disabledPluginIds);
@@ -59,6 +61,7 @@ function bootstrapLocalCoreKernel(options) {
         diagnostics,
         getCapabilitySnapshot() {
             const snapshot = capabilities.snapshot();
+            const monitorCapabilities = snapshot.monitors || [];
             return {
                 adapters: {
                     channels: snapshot.channels.map((capability) => capability.platform),
@@ -74,6 +77,14 @@ function bootstrapLocalCoreKernel(options) {
                     deliveryTargets: [...new Set(snapshot.schedulers.flatMap((capability) => capability.deliveryTargets || capability.deliveryPlatforms || []))],
                     platforms: [...new Set(snapshot.schedulers.flatMap((capability) => capability.deliveryTargets || capability.deliveryPlatforms || []))],
                 },
+                ...(monitorCapabilities.length > 0
+                    ? {
+                        monitors: {
+                            enabled: monitorCapabilities.some((capability) => capability.enabled !== false),
+                            sourceTypes: [...new Set(monitorCapabilities.flatMap((capability) => capability.sourceTypes))],
+                        },
+                    }
+                    : {}),
                 snapshot,
             };
         },
@@ -99,6 +110,7 @@ function logCapabilityContributions(plugin, log) {
         ...(plugin.capabilities.channels || []).map((capability) => capability.id),
         ...(plugin.capabilities.knowledge || []).map((capability) => capability.id),
         ...(plugin.capabilities.schedulers || []).map((capability) => capability.id),
+        ...(plugin.capabilities.monitors || []).map((capability) => capability.id),
         ...(plugin.capabilities.ui || []).map((capability) => capability.id),
     ];
     for (const capabilityId of capabilityIds) {
@@ -145,6 +157,16 @@ function resolveSchedulerRuntime(plugin, context) {
     }
     return runtime;
 }
+function resolveMonitorRuntime(plugin, context) {
+    if (!plugin.createRuntime) {
+        throw new Error(`Monitor plugin ${plugin.manifest.id} does not provide a runtime factory.`);
+    }
+    const runtime = plugin.createRuntime(context);
+    if (runtime instanceof Promise) {
+        throw new Error(`Monitor plugin ${plugin.manifest.id} returned an async runtime factory during synchronous bootstrap.`);
+    }
+    return runtime;
+}
 function bootstrapLocalCoreRuntime(options) {
     const state = (0, local_core_runtime_state_js_1.createLocalCoreRuntimeState)({
         userDataPath: options.userDataPath,
@@ -209,6 +231,9 @@ function bootstrapLocalCoreRuntime(options) {
             log: options.log,
         }),
     ];
+    const monitorPlugins = [
+        (0, monitor_stock_plugin_js_1.createBuiltinStockMonitorPlugin)(),
+    ];
     for (const plugin of agentPlugins.filter((plugin) => plugin !== localCoreAgentPlugin)) {
         registerPlugin(kernel, plugin);
     }
@@ -218,6 +243,9 @@ function bootstrapLocalCoreRuntime(options) {
     for (const plugin of schedulerPlugins) {
         registerPlugin(kernel, plugin);
     }
+    for (const plugin of monitorPlugins) {
+        registerPlugin(kernel, plugin);
+    }
     const agentRuntimes = agentPlugins
         .filter((plugin) => kernel.plugins.isEnabled(plugin.manifest.id))
         .map((plugin) => resolveAgentRuntime(plugin, kernel.context).runtime);
@@ -241,6 +269,10 @@ function bootstrapLocalCoreRuntime(options) {
     ];
     const schedulerTriggers = schedulerRuntimes.flatMap((runtime) => runtime.triggers || []);
     const schedulerExecutors = schedulerRuntimes.flatMap((runtime) => runtime.executors || []);
+    const monitorRuntimes = monitorPlugins
+        .filter((plugin) => kernel.plugins.isEnabled(plugin.manifest.id))
+        .map((plugin) => resolveMonitorRuntime(plugin, kernel.context));
+    const monitorProviders = monitorRuntimes.flatMap((runtime) => runtime.providers || []);
     const knowledgeProvider = knowledgeRuntime.provider;
     const knowledgeAttachments = knowledgeRuntime.attachments;
     workspaceRouter = (0, workspace_router_js_1.createWorkspaceRouter)({
@@ -266,6 +298,14 @@ function bootstrapLocalCoreRuntime(options) {
         store,
         scheduler,
     });
+    const automationMonitors = new automation_monitor_service_js_1.AutomationMonitorService({
+        store,
+        providers: monitorProviders,
+        getWorkspaceRouter: () => workspaceRouter,
+        getChannelRuntime: (platform) => channelRuntimes.find((runtime) => runtime.platform === platform || platform.startsWith(`${runtime.platform}:`)),
+        eventBus: kernel.context.bus,
+        log: options.log,
+    });
     workspaceRouter.setSchedulerBridge({
         createJob: async ({ workspaceId, platform, route, name, schedule, scheduleDescription, message }) => scheduledJobs.createCronJob({ workspaceId, platform, route, name, schedule, scheduleDescription, message }),
         listJobsForThread: async (threadId) => scheduledJobs.listJobsForThread(threadId),
@@ -286,11 +326,14 @@ function bootstrapLocalCoreRuntime(options) {
         workspaceRouter,
         scheduler,
         scheduledJobs,
+        automationMonitors,
         async start() {
             await kernel.lifecycle.startAll();
             await scheduler.start();
+            await automationMonitors.start();
         },
         async stop() {
+            await automationMonitors.stop();
             await scheduler.stop();
             await kernel.lifecycle.stopAll();
             workspaceRouter.close();

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

@@ -6,6 +6,7 @@ class LocalCoreCapabilityRegistry {
     channels = new Map();
     knowledge = new Map();
     schedulers = new Map();
+    monitors = new Map();
     ui = new Map();
     registerAgent(capability) {
         this.agents.set(capability.id, capability);
@@ -19,6 +20,9 @@ class LocalCoreCapabilityRegistry {
     registerScheduler(capability) {
         this.schedulers.set(capability.id, capability);
     }
+    registerMonitor(capability) {
+        this.monitors.set(capability.id, capability);
+    }
     registerUi(capability) {
         this.ui.set(capability.id, capability);
     }
@@ -35,6 +39,9 @@ class LocalCoreCapabilityRegistry {
         for (const capability of contributions.schedulers || []) {
             this.registerScheduler(capability);
         }
+        for (const capability of contributions.monitors || []) {
+            this.registerMonitor(capability);
+        }
         for (const capability of contributions.ui || []) {
             this.registerUi(capability);
         }
@@ -51,15 +58,20 @@ class LocalCoreCapabilityRegistry {
     listSchedulers() {
         return [...this.schedulers.values()];
     }
+    listMonitors() {
+        return [...this.monitors.values()];
+    }
     listUi() {
         return [...this.ui.values()];
     }
     snapshot() {
+        const monitors = this.listMonitors();
         return {
             agents: this.listAgents(),
             channels: this.listChannels(),
             knowledge: this.listKnowledge(),
             schedulers: this.listSchedulers(),
+            ...(monitors.length > 0 ? { monitors } : {}),
             ui: this.listUi(),
         };
     }

package/dist-electron/services/local-ai-core/src/plugins/builtin/monitor-stock-plugin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinStockMonitorPlugin = createBuiltinStockMonitorPlugin;
+const mock_stock_provider_js_1 = require("../../automation/mock-stock-provider.js");
+function createBuiltinStockMonitorPlugin() {
+    return {
+        manifest: {
+            id: 'builtin.monitor-stock',
+            kind: 'monitor',
+            version: '0.1.0',
+            provides: ['monitor.source.stock.quote'],
+        },
+        capabilities: {
+            monitors: [
+                {
+                    id: 'monitor.source.stock.quote',
+                    sourceTypes: ['stock.quote'],
+                    modes: ['poll'],
+                    enabled: true,
+                    displayName: 'Stock Quote Monitor',
+                },
+            ],
+        },
+        createRuntime() {
+            return {
+                providers: [new mock_stock_provider_js_1.MockStockQuoteProvider()],
+            };
+        },
+    };
+}