@kafca/agentdock 0.1.42 → 0.1.43

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) {

package/dist-electron/services/local-ai-core/src/thread/session-command-service.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionCommandService = void 0;
+exports.matchThread = matchThread;
+const slash_command_registry_js_1 = require("./slash-command-registry.js");
+const PAGE_SIZE = 8;
+const DEFAULT_HISTORY_LIMIT = 10;
+const MAX_HISTORY_LIMIT = 50;
+class SessionCommandService {
+    operations;
+    registry = new slash_command_registry_js_1.SlashCommandRegistry();
+    constructor(operations) {
+        this.operations = operations;
+        this.registry.register({ names: ['new'], execute: (command, context) => this.newSession(command.args, context) });
+        this.registry.register({ names: ['list', 'sessions'], execute: (command, context) => this.listSessions(command.args, context) });
+        this.registry.register({ names: ['switch', 'sw'], execute: (command, context) => this.switchSession(command.args, context) });
+        this.registry.register({ names: ['history', 'his'], execute: (command, context) => this.history(command.args, context) });
+        this.registry.register({ names: ['name'], execute: (command, context) => this.name(command.args, context) });
+        this.registry.register({ names: ['search'], execute: (command, context) => this.search(command.args, context) });
+        this.registry.register({ names: ['del', 'delete', 'rm'], execute: (command, context) => this.delete(command.args, context) });
+    }
+    async execute(text, context) {
+        return await this.registry.execute(text, context) || { handled: false, displayText: '' };
+    }
+    async newSession(args, context) {
+        const title = args.join(' ').trim() || context.defaultTitle || `New thread ${new Date().toLocaleTimeString()}`;
+        const created = await this.operations.createThread(context.workspaceId, title);
+        return {
+            handled: true,
+            displayText: `已开始新会话：${created.title}`,
+            effects: [
+                { type: 'created_thread', threadId: created.id },
+                { type: 'activate_thread', threadId: created.id, reason: 'created' },
+            ],
+        };
+    }
+    async listSessions(args, context) {
+        const all = await this.sortedThreads(context.workspaceId);
+        const page = parsePage(args[0]);
+        const pageInfo = paginate(all, page);
+        const text = this.renderList(pageInfo.items, context.currentThreadId, {
+            total: all.length,
+            page: pageInfo.page,
+            totalPages: pageInfo.totalPages,
+            empty: '当前工作区还没有会话。',
+        });
+        return {
+            handled: true,
+            displayText: text,
+            card: {
+                title: '会话列表',
+                actions: this.listActions(pageInfo.items, pageInfo.page, pageInfo.totalPages),
+            },
+        };
+    }
+    async switchSession(args, context) {
+        const query = args.join(' ').trim();
+        if (!query) {
+            return { handled: true, displayText: '用法：`/switch <编号 | id前缀 | 标题>`' };
+        }
+        const matched = await this.resolveThread(context.workspaceId, query);
+        if (!matched) {
+            return { handled: true, displayText: `没有找到匹配的会话：${query}` };
+        }
+        if (matched.id === context.currentThreadId) {
+            return { handled: true, displayText: `当前已经在会话：${this.displayName(matched)}` };
+        }
+        return {
+            handled: true,
+            displayText: `已切换到会话：${this.displayName(matched)}\n后续消息将发送到该会话。`,
+            effects: [
+                { type: 'activate_thread', threadId: matched.id, reason: 'switched' },
+            ],
+        };
+    }
+    async history(args, context) {
+        const limit = Math.max(1, Math.min(parseInt(String(args[0] || DEFAULT_HISTORY_LIMIT), 10) || DEFAULT_HISTORY_LIMIT, MAX_HISTORY_LIMIT));
+        const thread = await this.operations.getThread(context.currentThreadId);
+        const messages = thread.messages.slice(-limit);
+        if (!messages.length) {
+            return { handled: true, displayText: '当前会话还没有消息。' };
+        }
+        return {
+            handled: true,
+            displayText: [
+                `最近 ${messages.length} 条消息：`,
+                ...messages.map((message) => this.renderHistoryMessage(message)),
+            ].join('\n\n'),
+        };
+    }
+    async name(args, context) {
+        const raw = args.join(' ').trim();
+        if (!raw) {
+            return { handled: true, displayText: '用法：`/name <新名称>` 或 `/name <编号 | id前缀> <新名称>`' };
+        }
+        const [first = '', ...rest] = args;
+        let targetId = context.currentThreadId;
+        let nextName = raw;
+        if (rest.length > 0) {
+            const matched = await this.resolveThread(context.workspaceId, first);
+            if (matched) {
+                targetId = matched.id;
+                nextName = rest.join(' ').trim();
+            }
+        }
+        if (!nextName) {
+            return { handled: true, displayText: '会话名称不能为空。' };
+        }
+        const renamed = await this.operations.renameThread(targetId, nextName);
+        return {
+            handled: true,
+            displayText: `已重命名会话：${renamed.title}`,
+        };
+    }
+    async search(args, context) {
+        const query = args.join(' ').trim().toLowerCase();
+        if (!query) {
+            return { handled: true, displayText: '用法：`/search <关键词>`' };
+        }
+        const all = await this.sortedThreads(context.workspaceId);
+        const matched = all.filter((thread) => thread.title.toLowerCase().includes(query) ||
+            thread.id.toLowerCase().includes(query) ||
+            String(thread.excerpt || '').toLowerCase().includes(query));
+        const pageInfo = paginate(matched, 1);
+        const text = this.renderList(pageInfo.items, context.currentThreadId, {
+            total: matched.length,
+            page: 1,
+            totalPages: pageInfo.totalPages,
+            empty: `没有找到匹配的会话：${args.join(' ')}`,
+            title: `搜索结果：${args.join(' ')}`,
+        });
+        return {
+            handled: true,
+            displayText: text,
+            card: {
+                title: '搜索会话',
+                actions: this.listActions(pageInfo.items, 1, pageInfo.totalPages),
+            },
+        };
+    }
+    async delete(args, context) {
+        const confirm = args.some((arg) => arg === '--confirm' || arg.toLowerCase() === 'confirm');
+        const query = args.filter((arg) => arg !== '--confirm' && arg.toLowerCase() !== 'confirm').join(' ').trim();
+        if (!query) {
+            return { handled: true, displayText: '用法：`/del <编号 | id前缀 | 标题>`，确认删除：`/del <目标> --confirm`' };
+        }
+        const matched = await this.resolveThread(context.workspaceId, query);
+        if (!matched) {
+            return { handled: true, displayText: `没有找到匹配的会话：${query}` };
+        }
+        if (matched.id === context.currentThreadId) {
+            return { handled: true, displayText: '不能删除当前正在使用的会话。请先 `/switch` 到其他会话后再删除。' };
+        }
+        if (!confirm) {
+            return {
+                handled: true,
+                displayText: [
+                    `确认删除会话：${this.displayName(matched)}？`,
+                    '删除后会清空该会话历史。',
+                    `确认命令：\`/del ${shortThreadId(matched.id)} --confirm\``,
+                ].join('\n'),
+                card: {
+                    title: '确认删除会话',
+                    actions: [[
+                            { label: '确认删除', command: `/del ${shortThreadId(matched.id)} --confirm`, type: 'danger' },
+                            { label: '取消', command: '/list', type: 'default' },
+                        ]],
+                },
+            };
+        }
+        await this.operations.deleteThread(matched.id);
+        return {
+            handled: true,
+            displayText: `已删除会话：${this.displayName(matched)}`,
+            effects: [
+                { type: 'deleted_thread', threadId: matched.id },
+            ],
+        };
+    }
+    async sortedThreads(workspaceId) {
+        const threads = await this.operations.listThreads(workspaceId);
+        return [...threads].sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+    }
+    async resolveThread(workspaceId, query) {
+        const threads = await this.sortedThreads(workspaceId);
+        return matchThread(threads, query);
+    }
+    renderList(threads, currentThreadId, input) {
+        if (input.total === 0) {
+            return input.empty;
+        }
+        const lines = [
+            input.title || `会话列表（${input.total} 个）`,
+            ...threads.map((thread, index) => {
+                const globalIndex = (input.page - 1) * PAGE_SIZE + index + 1;
+                const marker = thread.id === currentThreadId ? '▶' : '◻';
+                return `${marker} **${globalIndex}.** ${this.displayName(thread)} · ${thread.historyCount} msgs · ${formatDate(thread.updatedAt)}`;
+            }),
+        ];
+        if (input.totalPages > 1) {
+            lines.push(`第 ${input.page}/${input.totalPages} 页，使用 \`/list ${input.page + 1 > input.totalPages ? input.totalPages : input.page + 1}\` 查看更多。`);
+        }
+        lines.push('使用 `/switch <编号>` 切换，`/history` 查看历史，`/new 名称` 新建会话。');
+        return lines.join('\n');
+    }
+    listActions(threads, page, totalPages) {
+        const rows = threads.map((thread, index) => {
+            const globalIndex = (page - 1) * PAGE_SIZE + index + 1;
+            return [
+                { label: `${globalIndex}. ${truncate(this.displayName(thread), 18)}`, command: `/switch ${globalIndex}`, type: 'primary' },
+                { label: '删除', command: `/del ${globalIndex}`, type: 'danger' },
+            ];
+        });
+        const nav = [];
+        if (page > 1)
+            nav.push({ label: '上一页', command: `/list ${page - 1}` });
+        if (page < totalPages)
+            nav.push({ label: '下一页', command: `/list ${page + 1}` });
+        if (nav.length)
+            rows.push(nav);
+        return rows;
+    }
+    renderHistoryMessage(message) {
+        const role = message.role === 'assistant' ? '助手' : message.role === 'user' ? '用户' : '系统';
+        return `**${role}** · ${formatDate(message.timestamp)}\n${truncate(String(message.content || '').trim(), 600) || '(empty)'}`;
+    }
+    displayName(thread) {
+        const title = String(thread.title || '').trim();
+        if (title)
+            return title;
+        const excerpt = String(thread.excerpt || '').replace(/\s+/g, ' ').trim();
+        return excerpt ? truncate(excerpt, 40) : shortThreadId(thread.id);
+    }
+}
+exports.SessionCommandService = SessionCommandService;
+function matchThread(threads, query) {
+    const normalized = String(query || '').trim();
+    if (!normalized)
+        return undefined;
+    if (/^\d+$/.test(normalized)) {
+        const index = Number(normalized);
+        if (index >= 1 && index <= threads.length) {
+            return threads[index - 1];
+        }
+    }
+    const lower = normalized.toLowerCase();
+    return threads.find((thread) => thread.id.startsWith(normalized))
+        || threads.find((thread) => thread.title.toLowerCase() === lower)
+        || threads.find((thread) => thread.title.toLowerCase().startsWith(lower))
+        || threads.find((thread) => String(thread.excerpt || '').toLowerCase().includes(lower));
+}
+function paginate(items, requestedPage) {
+    const totalPages = Math.max(1, Math.ceil(items.length / PAGE_SIZE));
+    const page = Math.max(1, Math.min(requestedPage, totalPages));
+    const start = (page - 1) * PAGE_SIZE;
+    return { items: items.slice(start, start + PAGE_SIZE), page, totalPages };
+}
+function parsePage(value) {
+    const parsed = Number(value || 1);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 1;
+}
+function shortThreadId(threadId) {
+    const normalized = threadId.includes(':') ? threadId.split(':').at(-1) || threadId : threadId;
+    return normalized.length > 12 ? normalized.slice(0, 12) : normalized;
+}
+function formatDate(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return value;
+    return `${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+}
+function truncate(value, maxLength) {
+    const chars = Array.from(value);
+    return chars.length > maxLength ? `${chars.slice(0, maxLength).join('')}...` : value;
+}

package/dist-electron/services/local-ai-core/src/thread/slash-command-registry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlashCommandRegistry = void 0;
+const local_core_slash_commands_js_1 = require("../acp/local-core-slash-commands.js");
+class SlashCommandRegistry {
+    handlers = new Map();
+    register(handler) {
+        for (const name of handler.names) {
+            const normalized = String(name || '').trim().toLowerCase();
+            if (normalized) {
+                this.handlers.set(normalized, handler);
+            }
+        }
+    }
+    async execute(text, context) {
+        const command = (0, local_core_slash_commands_js_1.parseSlashCommand)(text);
+        if (!command) {
+            return null;
+        }
+        const handler = this.handlers.get(command.name);
+        if (!handler) {
+            return null;
+        }
+        return handler.execute(command, context);
+    }
+}
+exports.SlashCommandRegistry = SlashCommandRegistry;

package/dist-electron/services/local-ai-core/src/thread/thread-command-service.js

@@ -3,29 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadCommandService = void 0;
 const local_core_slash_commands_js_1 = require("../acp/local-core-slash-commands.js");
 const index_js_1 = require("../agents/index.js");
+const slash_command_registry_js_1 = require("./slash-command-registry.js");
 class ThreadCommandService {
     options;
+    registry = new slash_command_registry_js_1.SlashCommandRegistry();
     constructor(options) {
         this.options = options;
-    }
-    async execute(input) {
-        const command = (0, local_core_slash_commands_js_1.parseSlashCommand)(input.content);
-        if (!command) {
-            return { handled: false, displayText: '' };
-        }
-        if (command.name === 'mode') {
-            return {
+        this.registry.register({
+            names: ['mode'],
+            execute: async (command, input) => ({
                 handled: true,
                 displayText: await this.executeModeCommand(input.threadId, input.workspaceId, command.args),
-            };
-        }
-        if (command.name === 'agent') {
-            return {
+            }),
+        });
+        this.registry.register({
+            names: ['agent'],
+            execute: (command, input) => ({
                 handled: true,
                 displayText: this.executeAgentCommand(input.threadId, input.workspaceId, command.args, input.defaultAgentType),
-            };
-        }
-        return { handled: false, displayText: '' };
+            }),
+        });
+    }
+    async execute(input) {
+        return await this.registry.execute(input.content, input) || { handled: false, displayText: '' };
     }
     async executeModeCommand(threadId, workspaceId, args) {
         const row = this.options.getThreadRow(threadId);

package/dist-electron/shared/desktop.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CHANNEL_PROTOCOL_INSTRUCTION = exports.SCHEDULER_PROTOCOL_INSTRUCTION = exports.LOCALCORE_ACP_AGENT_TYPE = exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = exports.DESKTOP_PROVIDER_THINKING_OPTIONS = exports.DESKTOP_PROVIDER_PRESET_OPTIONS = exports.DESKTOP_PLATFORM_TYPE_OPTIONS = exports.DESKTOP_AGENT_TYPE_OPTIONS = exports.DESKTOP_LARK_SDK_PACKAGE = exports.DESKTOP_CLAUDECODE_ACP_PACKAGE = exports.DESKTOP_CODEX_ACP_PACKAGE = exports.DESKTOP_PI_CODING_AGENT_PACKAGE = exports.DESKTOP_PI_ACP_PACKAGE = exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = exports.DEFAULT_DESKTOP_OPENCODE_MODEL = exports.DEFAULT_DESKTOP_AGENT_TYPE = void 0;
+exports.CHANNEL_PROTOCOL_INSTRUCTION = exports.MONITOR_PROTOCOL_INSTRUCTION = exports.SCHEDULER_PROTOCOL_INSTRUCTION = exports.LOCALCORE_ACP_AGENT_TYPE = exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = exports.DESKTOP_PROVIDER_THINKING_OPTIONS = exports.DESKTOP_PROVIDER_PRESET_OPTIONS = exports.DESKTOP_PLATFORM_TYPE_OPTIONS = exports.DESKTOP_AGENT_TYPE_OPTIONS = exports.DESKTOP_LARK_SDK_PACKAGE = exports.DESKTOP_CLAUDECODE_ACP_PACKAGE = exports.DESKTOP_CODEX_ACP_PACKAGE = exports.DESKTOP_PI_CODING_AGENT_PACKAGE = exports.DESKTOP_PI_ACP_PACKAGE = exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = exports.DEFAULT_DESKTOP_OPENCODE_MODEL = exports.DEFAULT_DESKTOP_AGENT_TYPE = void 0;
 exports.deriveDesktopRuntimePhase = deriveDesktopRuntimePhase;
 exports.deriveDesktopRuntimeRoles = deriveDesktopRuntimeRoles;
 exports.normalizeDesktopPlatformType = normalizeDesktopPlatformType;
@@ -78,6 +78,24 @@ exports.SCHEDULER_PROTOCOL_INSTRUCTION = [
     'Only use the scheduler CLI when the user explicitly asks for scheduled automation.',
     '[/Scheduler Tools]',
 ].join('\n');
+exports.MONITOR_PROTOCOL_INSTRUCTION = [
+    '[Monitor Tools]',
+    'If the user asks to create, view, edit, delete, or manually run an event monitor for this conversation, use the Bash tool to run the local monitor CLI.',
+    'Use these commands:',
+    'lac monitor add --title "<short title>" --source stock.quote --symbol "<ticker>" --condition "<metric operator value>" --message "<exact analysis prompt>" [--cooldown 15m] [--execution-mode same-thread|side-thread]',
+    'lac monitor list',
+    'lac monitor list --thread',
+    'lac monitor info <short-monitor-id>',
+    'lac monitor edit <short-monitor-id> [--title "<title>"] [--condition "<expr>"] [--message "<exact prompt>"] [--enabled true|false] [--cooldown 15m] [--execution-mode same-thread|side-thread]',
+    'lac monitor del <short-monitor-id>',
+    'lac monitor run <short-monitor-id>',
+    'Supported stock metrics include latestPrice, change_percent, changePercent, and abs_change_percent. Example condition: "abs_change_percent >= 3".',
+    'Environment variables LOCAL_AI_WORKSPACE_ID, LOCAL_AI_THREAD_ID, LOCAL_AI_PLATFORM, LOCAL_AI_CHAT_ID, and LOCAL_AI_PLATFORM_USER_ID are already set when available.',
+    'Prefer relying on those variables instead of inventing your own route.',
+    'Use --execution-mode side-thread by default so monitor analysis does not interrupt the current conversation.',
+    'Only use the monitor CLI when the user explicitly asks for event monitoring automation.',
+    '[/Monitor Tools]',
+].join('\n');
 exports.CHANNEL_PROTOCOL_INSTRUCTION = [
     '[Channel Tools]',
     'If the user asks you to send a local file back through the current channel conversation, use the Bash tool to run the local channel CLI.',
@@ -138,6 +156,8 @@ function wrapUserMessageWithSchedulerProtocol(content, extraBlocks = []) {
     return [
         exports.SCHEDULER_PROTOCOL_INSTRUCTION,
         '',
+        exports.MONITOR_PROTOCOL_INSTRUCTION,
+        '',
         exports.CHANNEL_PROTOCOL_INSTRUCTION,
         ...extraBlocks.flatMap((block) => (block ? ['', block] : [])),
         '',

package/dist-electron/tests/contracts/local-core-contracts.test.js

@@ -53,6 +53,15 @@ const index_js_1 = require("../../packages/contracts/src/index.js");
     strict_1.default.equal((0, index_js_1.normalizeScheduledJobRunStatus)('complete'), 'succeeded');
     strict_1.default.equal((0, index_js_1.normalizeScheduledJobRunStatus)('cancelled'), 'skipped');
 });
+(0, node_test_1.default)('automation monitor status normalization accepts canonical aliases', () => {
+    strict_1.default.equal((0, index_js_1.normalizeAutomationMonitorStatus)(undefined), 'queued');
+    strict_1.default.equal((0, index_js_1.normalizeAutomationMonitorStatus)('completed'), 'succeeded');
+    strict_1.default.equal((0, index_js_1.normalizeAutomationMonitorStatus)('SKIPPED'), 'skipped');
+});
+(0, node_test_1.default)('automation monitor condition operator normalization rejects unsupported values', () => {
+    strict_1.default.equal((0, index_js_1.normalizeAutomationMonitorConditionOperator)('>='), '>=');
+    strict_1.default.throws(() => (0, index_js_1.normalizeAutomationMonitorConditionOperator)('contains'), /condition operator must be/);
+});
 (0, node_test_1.default)('channel content part type normalization accepts canonical aliases', () => {
     strict_1.default.equal((0, index_js_1.normalizeChannelContentPartType)(' TEXT '), 'text');
     strict_1.default.equal((0, index_js_1.normalizeChannelContentPartType)('permission-card'), 'permission_card');

package/dist-electron/tests/electron/automation-monitor.test.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const condition_evaluator_js_1 = require("../../services/local-ai-core/src/automation/condition-evaluator.js");
+const event = {
+    id: 'event-1',
+    sourceType: 'stock.quote',
+    occurredAt: '2026-05-11T00:00:00.000Z',
+    subject: 'AAPL',
+    payload: {
+        latestPrice: 188,
+        change_percent: 4.2,
+        volumeRatio: 2.1,
+    },
+};
+(0, node_test_1.default)('monitor condition evaluator supports simple comparisons and safe boolean expressions', () => {
+    strict_1.default.equal((0, condition_evaluator_js_1.evaluateMonitorCondition)({
+        metric: 'abs_change_percent',
+        operator: '>=',
+        value: 3,
+    }, event), true);
+    strict_1.default.equal((0, condition_evaluator_js_1.evaluateMonitorCondition)({
+        metric: 'expression',
+        operator: '==',
+        value: true,
+        expression: 'abs_change_percent >= 3 && latestPrice > 100',
+    }, event), true);
+    strict_1.default.equal((0, condition_evaluator_js_1.evaluateMonitorCondition)({
+        metric: 'expression',
+        operator: '==',
+        value: true,
+        expression: 'latestPrice < 100 || volumeRatio >= 2',
+    }, event), true);
+});