@kafca/agentdock 0.1.41 → 0.1.43

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()],
+            };
+        },
+    };
+}

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

@@ -48,6 +48,7 @@ class WorkspaceRouter {
                     return this.schedulerBridge.deleteJob(jobId);
                 },
             },
+            getAgentTypes: () => this.options.getCapabilities().snapshot.agents.map((agent) => agent.agentType),
             log: options.log,
         });
     }
@@ -203,12 +204,14 @@ class WorkspaceRouter {
     }
     async sendThreadMessage(threadId, content, options) {
         const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
-        const route = await this.getWorkspaceRoute(workspaceId);
+        const route = isLocalSlashCommand(content)
+            ? await this.getWorkspaceRoute(workspaceId)
+            : await this.getThreadWorkspaceRoute(threadId, workspaceId);
         return this.localCoreAcp.sendThreadMessage(threadId, content, route.config, options);
     }
     async sendThreadAction(threadId, content) {
         const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
-        const route = await this.getWorkspaceRoute(workspaceId);
+        const route = await this.getThreadWorkspaceRoute(threadId, workspaceId);
         return this.localCoreAcp.sendThreadAction(threadId, content, route.config);
     }
     async interruptRun(runId) {
@@ -425,11 +428,21 @@ class WorkspaceRouter {
             await this.localCoreAcp.deleteThread(thread.id).catch(() => ({ deleted: false }));
         }
     }
-    async getWorkspaceRoute(workspaceId) {
+    async getThreadWorkspaceRoute(threadId, workspaceId) {
+        const defaultRoute = await this.getWorkspaceRoute(workspaceId);
+        const row = this.store.getThreadRow(threadId);
+        const threadAgentType = String(row?.agent_type || '').trim().toLowerCase();
+        if (!threadAgentType || threadAgentType === defaultRoute.agentType) {
+            return defaultRoute;
+        }
+        return this.getWorkspaceRoute(workspaceId, threadAgentType);
+    }
+    async getWorkspaceRoute(workspaceId, agentTypeOverride = '') {
         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;
+        const project = matched && agentTypeOverride ? withAgentTypeOverride(matched, agentTypeOverride) : matched;
+        const route = project ? this.resolveProjectRoute(configState, project) : null;
         if (!matched || !route) {
             throw new Error(`Workspace "${workspaceId}" is not configured as a Local AI Core ACP workspace.`);
         }
@@ -512,6 +525,29 @@ function inferWorkspacePath(project) {
     }
     return '';
 }
+function withAgentTypeOverride(project, agentType) {
+    const options = project.agent?.options && typeof project.agent.options === 'object'
+        ? { ...project.agent.options }
+        : {};
+    delete options.command;
+    delete options.args;
+    return {
+        ...project,
+        agent: {
+            ...(project.agent || {}),
+            type: agentType,
+            options,
+        },
+    };
+}
+function isLocalSlashCommand(content) {
+    const text = typeof content === 'string' ? content : String(content.displayText || '');
+    const normalized = text.trim().toLowerCase();
+    return normalized === '/agent'
+        || normalized.startsWith('/agent ')
+        || normalized === '/mode'
+        || normalized.startsWith('/mode ');
+}
 function workspaceHealth(path) {
     if (!path) {
         return {

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

@@ -12,6 +12,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
     knowledgeProvider;
     channelRuntimes;
     scheduledJobs;
+    automationMonitors;
     kernel;
     runtime;
     runtimeDetection;
@@ -33,6 +34,15 @@ class LocalCoreController extends node_events_1.EventEmitter {
         const runtimeChannels = this.runtime.channelRuntimes || [this.runtime.channelRuntime, this.runtime.weixinChannelRuntime];
         this.channelRuntimes = new Map(runtimeChannels.filter(Boolean).map((runtime) => [runtime.platform, runtime]));
         this.scheduledJobs = this.runtime.scheduledJobs;
+        this.automationMonitors = this.runtime.automationMonitors || {
+            listMonitors: () => [],
+            getMonitor: () => undefined,
+            createMonitor: () => { throw new Error('Automation monitor service is not available.'); },
+            updateMonitor: () => { throw new Error('Automation monitor service is not available.'); },
+            deleteMonitor: () => ({ deleted: false }),
+            runMonitorNow: async () => { throw new Error('Automation monitor service is not available.'); },
+            listRuns: () => [],
+        };
         this.runtimeDetection = new runtime_detection_service_js_1.RuntimeDetectionService({
             userDataPath,
             readConfig: async () => (await this.readConfigFile()).parsed,
@@ -42,10 +52,16 @@ class LocalCoreController extends node_events_1.EventEmitter {
         this.flushPendingLogs();
         this.busUnsubscribers.push(this.kernel.context.bus.on('platform.bridge.updated', (event) => {
             this.emit('bridge', event);
+        }), this.kernel.context.bus.on('thread.session.activated', (event) => {
+            this.emit('thread-session-activated', 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('automation.monitor.updated', (monitor) => {
+            this.emit('automation-monitor', monitor);
+        }), this.kernel.context.bus.on('automation.monitor.run.updated', (run) => {
+            this.emit('automation-monitor-run', run);
         }), this.kernel.context.bus.on('runtime.state.changed', () => {
             void this.emitRuntime();
         }));
@@ -208,6 +224,31 @@ class LocalCoreController extends node_events_1.EventEmitter {
     async listScheduledJobRuns(jobId) {
         return this.scheduledJobs.listJobRuns(jobId);
     }
+    async listAutomationMonitors(workspaceId) {
+        return this.automationMonitors.listMonitors(workspaceId);
+    }
+    async getAutomationMonitor(monitorId) {
+        const monitor = this.automationMonitors.getMonitor(monitorId);
+        if (!monitor) {
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        }
+        return monitor;
+    }
+    async createAutomationMonitor(input) {
+        return this.automationMonitors.createMonitor(input);
+    }
+    async updateAutomationMonitor(monitorId, input) {
+        return this.automationMonitors.updateMonitor(monitorId, input);
+    }
+    async deleteAutomationMonitor(monitorId) {
+        return this.automationMonitors.deleteMonitor(monitorId);
+    }
+    async runAutomationMonitor(monitorId) {
+        return this.automationMonitors.runMonitorNow(monitorId);
+    }
+    async listAutomationMonitorRuns(monitorId) {
+        return this.automationMonitors.listRuns(monitorId);
+    }
     async listThreads(workspaceId) {
         return this.workspaceRouter.listThreads(workspaceId);
     }

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

@@ -48,6 +48,9 @@ function parseLocalAiCoreRoute(method, path) {
     if (segments[0] === 'scheduler' && segments[1] === 'jobs') {
         return parseSchedulerJobsRoute(normalizedMethod, segments);
     }
+    if (segments[0] === 'automation' && segments[1] === 'monitors') {
+        return parseAutomationMonitorsRoute(normalizedMethod, segments);
+    }
     if (segments[0] === 'threads') {
         return parseThreadsRoute(normalizedMethod, segments);
     }
@@ -92,6 +95,34 @@ function parseLocalAiCoreRoute(method, path) {
     }
     return null;
 }
+function parseAutomationMonitorsRoute(method, segments) {
+    if (method === 'GET' && segments.length === 2) {
+        return { name: 'automation.monitors.list' };
+    }
+    if (method === 'POST' && segments.length === 2) {
+        return { name: 'automation.monitors.create' };
+    }
+    const monitorId = segments.length >= 3 ? decodeURIComponent(segments[2] || '') : '';
+    if (!monitorId) {
+        return null;
+    }
+    if (method === 'GET' && segments.length === 3) {
+        return { name: 'automation.monitor.get', monitorId };
+    }
+    if (method === 'GET' && segments.length === 4 && segments[3] === 'runs') {
+        return { name: 'automation.monitor.runs', monitorId };
+    }
+    if (method === 'POST' && segments.length === 4 && segments[3] === 'run') {
+        return { name: 'automation.monitor.run', monitorId };
+    }
+    if (method === 'PATCH' && segments.length === 3) {
+        return { name: 'automation.monitor.update', monitorId };
+    }
+    if (method === 'DELETE' && segments.length === 3) {
+        return { name: 'automation.monitor.delete', monitorId };
+    }
+    return null;
+}
 function parseRuntimesRoute(method, segments) {
     if (method === 'GET' && segments.length === 1) {
         return { name: 'runtimes.list' };

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

@@ -62,12 +62,21 @@ class LocalAiCoreServer {
                 });
             }
         });
+        this.bindings.on('thread-session-activated', (event) => {
+            this.broadcast({ type: 'thread.session.activated', ...event });
+        });
         this.bindings.on('scheduler-job', (job) => {
             this.broadcast({ type: 'scheduler.job.updated', job });
         });
         this.bindings.on('scheduler-run', (run) => {
             this.broadcast({ type: 'scheduler.run.updated', run });
         });
+        this.bindings.on('automation-monitor', (monitor) => {
+            this.broadcast({ type: 'automation.monitor.updated', monitor });
+        });
+        this.bindings.on('automation-monitor-run', (run) => {
+            this.broadcast({ type: 'automation.monitor.run.updated', run });
+        });
         this.bindings.on('runtime-detection', (event) => {
             this.broadcast(event);
         });
@@ -226,6 +235,33 @@ class LocalAiCoreServer {
             case 'scheduler.job.delete':
                 json(res, 200, await this.bindings.deleteScheduledJob(route.jobId));
                 return;
+            case 'automation.monitors.list': {
+                const workspaceId = String(url.searchParams.get('workspace_id') || '');
+                json(res, 200, { monitors: await this.bindings.listAutomationMonitors(workspaceId || undefined) });
+                return;
+            }
+            case 'automation.monitors.create': {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.createAutomationMonitor(body));
+                return;
+            }
+            case 'automation.monitor.get':
+                json(res, 200, await this.bindings.getAutomationMonitor(route.monitorId));
+                return;
+            case 'automation.monitor.runs':
+                json(res, 200, { runs: await this.bindings.listAutomationMonitorRuns(route.monitorId) });
+                return;
+            case 'automation.monitor.run':
+                json(res, 200, await this.bindings.runAutomationMonitor(route.monitorId));
+                return;
+            case 'automation.monitor.update': {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.updateAutomationMonitor(route.monitorId, body));
+                return;
+            }
+            case 'automation.monitor.delete':
+                json(res, 200, await this.bindings.deleteAutomationMonitor(route.monitorId));
+                return;
             case 'threads.list': {
                 const workspaceId = String(url.searchParams.get('workspace_id') || '');
                 json(res, 200, { threads: workspaceId ? await this.bindings.listThreads(workspaceId) : [] });

package/dist-electron/services/local-ai-core/src/scheduler/scheduled-bridge-session.js

@@ -5,19 +5,20 @@ class ScheduledBridgeSession {
     static async open(input) {
         const sessionKey = input.workspaceRouter.getThreadSessionKey(input.threadId);
         const channelRuntime = input.getChannelRuntime();
+        const target = input.target || targetFromScheduledJob(input.job);
         const unregister = await channelRuntime.registerScheduledThreadBridge?.({
-            workspaceId: input.job.workspaceId,
-            platform: input.job.platform,
-            route: input.job.route,
+            workspaceId: target.workspaceId,
+            platform: target.platform,
+            route: target.route,
             threadId: input.threadId,
             sessionKey,
         });
-        await sendScheduledStartNotice(channelRuntime, input.job, sessionKey);
+        await sendScheduledStartNotice(channelRuntime, target, sessionKey, input.noticeIcon, input.noticeTitle);
         return {
             mode: 'bridge-stream',
-            workspaceId: input.job.workspaceId,
-            platform: input.job.platform,
-            route: input.job.route,
+            workspaceId: target.workspaceId,
+            platform: target.platform,
+            route: target.route,
             threadId: input.threadId,
             sessionKey,
             close: async () => {
@@ -27,7 +28,20 @@ class ScheduledBridgeSession {
     }
 }
 exports.ScheduledBridgeSession = ScheduledBridgeSession;
-async function sendScheduledStartNotice(channelRuntime, job, sessionKey) {
+function targetFromScheduledJob(job) {
+    if (!job) {
+        throw new Error('Scheduled bridge session requires a job or automation target.');
+    }
+    return {
+        id: job.id,
+        workspaceId: job.workspaceId,
+        platform: job.platform,
+        route: job.route,
+        title: job.description || job.promptTemplate || job.id,
+        promptTemplate: job.promptTemplate,
+    };
+}
+async function sendScheduledStartNotice(channelRuntime, target, sessionKey, noticeIcon, noticeTitle) {
     if (!channelRuntime.onBridgeEvent) {
         return;
     }
@@ -36,15 +50,15 @@ async function sendScheduledStartNotice(channelRuntime, job, sessionKey) {
             type: 'status',
             sessionKey,
             bridgeKind: 'status',
-            content: `⏰ ${scheduledNoticeTitle(job)}`,
+            content: `${noticeIcon || '⏰'} ${noticeTitle || automationNoticeTitle(target)}`,
         });
     }
     catch {
         // The scheduled run should continue even if the proactive start notice fails.
     }
 }
-function scheduledNoticeTitle(job) {
-    const title = normalizeNoticeTitle(job.description) || normalizeNoticeTitle(job.promptTemplate) || job.id;
+function automationNoticeTitle(target) {
+    const title = normalizeNoticeTitle(target.title) || normalizeNoticeTitle(target.promptTemplate) || target.id;
     return truncateNoticeTitle(title, 80);
 }
 function normalizeNoticeTitle(value) {