@kafca/agentdock 0.1.41 → 0.1.43

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

@@ -41,11 +41,13 @@ const node_path_1 = require("node:path");
 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 cards_js_1 = require("./cards.js");
 const config_js_1 = require("./config.js");
 const registration_js_1 = require("./registration.js");
 const messages_js_1 = require("./rendering/messages.js");
 const runtime_state_js_1 = require("./runtime-state.js");
+const session_command_service_js_1 = require("../../thread/session-command-service.js");
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 const LARK_FINAL_PATCH_INTERVAL_MS = 900;
@@ -62,12 +64,37 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     outboundEventChains = new Map();
     outboundTurns = new Map();
     mutedThreadBridgeCounts = new Map();
+    sessionCommandRuntime;
     larkModulePromise = null;
     platform = 'lark';
     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),
+        });
     }
     async refreshBindings() {
         const config = await this.options.readConfig();
@@ -204,6 +231,17 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             }
         };
     }
+    async executeSessionCommand(input) {
+        return this.sessionCommandRuntime.execute(input);
+    }
+    async sendSessionCommandResult(input, result) {
+        const state = this.resolveRuntimeState(input.workspaceId, input.instanceId).state;
+        if (state?.client && state.connected && result.card?.actions?.length && state.cardActionsEnabled) {
+            await this.sendSessionCommandCard(state, input.chatId, result.displayText, result.card.actions, this.options.getWorkspaceRouter().getThreadSessionKey(input.currentThreadId), input.currentThreadId);
+            return;
+        }
+        await this.sendImmediateCard(input.workspaceId, input.chatId, result.displayText, input.instanceId);
+    }
     async sendOutboundMessage(workspaceId, input) {
         const state = this.resolveRuntimeState(workspaceId, input.route?.instanceId).state;
         if (!state?.client || !state.connected) {
@@ -659,35 +697,18 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const acknowledgement = this.createTurnState(effectiveSessionKey, input.messageId);
         await this.addAcknowledgementReaction(input.workspaceId, input.messageId, acknowledgement, instanceId);
         const slashCommand = this.parseSlashCommand(input.text);
-        if (slashCommand?.name === 'new') {
-            const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'Lark'} ${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(this.options.getWorkspaceRouter().getThreadSessionKey(nextThread.id), {
-                workspaceId: input.workspaceId,
-                instanceId,
-                platformKey,
-                platformUserId: input.platformUserId,
-                chatId: input.chatId,
-                threadId: nextThread.id,
-            });
-            await this.sendImmediateCard(input.workspaceId, input.chatId, '**已开始新会话**', instanceId);
-            return { paired: true, threadId: nextThread.id };
+        const sessionCommand = await this.executeSessionCommand({
+            workspaceId: input.workspaceId,
+            currentThreadId: threadId,
+            text: input.text,
+            defaultTitle: `${input.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`,
+            chatId: input.chatId,
+            platformUserId: input.platformUserId,
+            platformKey,
+            instanceId,
+        });
+        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')
@@ -1157,6 +1178,21 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         this.options.log?.(`localcore-lark card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
         return String(response?.data?.message_id || '').trim();
     }
+    async sendSessionCommandCard(state, chatId, text, actionRows, sessionKey, threadId) {
+        const startedAt = Date.now();
+        const response = await state.client.im.message.create({
+            params: {
+                receive_id_type: this.resolveReceiveIdType(chatId),
+            },
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: JSON.stringify((0, cards_js_1.buildSessionCommandCard)(text, actionRows, sessionKey, threadId)),
+            },
+        });
+        this.options.log?.(`localcore-lark session card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
+        return String(response?.data?.message_id || '').trim();
+    }
     async sendTextAsMessage(state, chatId, text) {
         const startedAt = Date.now();
         const rendered = (0, messages_js_1.renderLarkTextMessage)(text);
@@ -1272,6 +1308,27 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const instanceId = legacyCall ? 'default' : instanceIdOrData;
         const data = (legacyCall ? instanceIdOrData : maybeData) || {};
         try {
+            const sessionAction = (0, cards_js_1.extractSessionCommandActionValue)(data);
+            if (sessionAction) {
+                const route = this.threadRouting.get(sessionAction.sessionKey)
+                    || this.routeFromThreadBinding(sessionAction.threadId, instanceId);
+                if (!route) {
+                    this.options.log?.(`localcore-lark session card action ignored without route for thread=${sessionAction.threadId}`);
+                    return;
+                }
+                await this.executeSessionCommand({
+                    workspaceId,
+                    currentThreadId: sessionAction.threadId,
+                    text: sessionAction.command,
+                    defaultTitle: `Lark ${new Date().toLocaleTimeString()}`,
+                    chatId: route.chatId,
+                    platformUserId: route.platformUserId,
+                    platformKey: route.platformKey,
+                    instanceId: route.instanceId,
+                });
+                this.options.log?.(`localcore-lark processed session card action for ${workspaceId}/${instanceId}: ${sessionAction.command}`);
+                return;
+            }
             const action = (0, cards_js_1.extractCardActionValue)(data);
             if (!action) {
                 return;
@@ -1285,6 +1342,21 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             this.options.log?.(`localcore-lark card action failed for ${workspaceId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    routeFromThreadBinding(threadId, instanceId) {
+        const binding = this.options.store.getPlatformThreadBindingByThreadId(threadId);
+        if (!binding || (binding.platform !== 'lark' && !binding.platform.startsWith('lark:'))) {
+            return undefined;
+        }
+        const bindingInstanceId = getLarkInstanceId(binding.platform) || instanceId || 'default';
+        return {
+            workspaceId: binding.workspace_id,
+            instanceId: bindingInstanceId,
+            platformKey: binding.platform,
+            platformUserId: binding.platform_user_id,
+            chatId: binding.chat_id,
+            threadId: binding.thread_id,
+        };
+    }
     async markPermissionCardActionHandled(workspaceId, instanceId, rootPayload, payload, value, response, threadId) {
         const state = this.resolveRuntimeState(workspaceId, instanceId).state;
         if (!state?.client) {

package/dist-electron/services/local-ai-core/src/channel/shared/session-command-runtime.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSessionCommandRuntime = void 0;
+class ChannelSessionCommandRuntime {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(input) {
+        const result = await this.options.service.execute(input.text, {
+            workspaceId: input.workspaceId,
+            currentThreadId: input.currentThreadId,
+            defaultTitle: input.defaultTitle,
+        });
+        if (!result.handled) {
+            return { handled: false, threadId: input.currentThreadId };
+        }
+        let activeThreadId = input.currentThreadId;
+        for (const effect of result.effects || []) {
+            if (effect.type === 'created_thread') {
+                this.inheritAgentMode(input.currentThreadId, effect.threadId);
+            }
+            if (effect.type === 'activate_thread') {
+                activeThreadId = effect.threadId;
+                this.activateThread(input, effect.threadId);
+            }
+        }
+        await this.options.sendResult(input, result);
+        return { handled: true, threadId: activeThreadId, result };
+    }
+    inheritAgentMode(sourceThreadId, targetThreadId) {
+        const inheritedMode = this.options.store.getThreadRow?.(sourceThreadId)?.agent_mode || '';
+        if (inheritedMode && inheritedMode !== 'default') {
+            this.options.store.updateThreadAgentMode?.(targetThreadId, inheritedMode);
+        }
+    }
+    activateThread(input, threadId) {
+        const now = new Date().toISOString();
+        this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, input.platformKey);
+        this.options.store.upsertPlatformThreadBinding({
+            workspace_id: input.workspaceId,
+            platform: input.platformKey,
+            chat_id: input.chatId,
+            platform_user_id: input.platformUserId,
+            thread_id: threadId,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        this.options.setThreadRoute(this.options.getThreadSessionKey(threadId), this.options.createRoute(input, threadId));
+    }
+}
+exports.ChannelSessionCommandRuntime = ChannelSessionCommandRuntime;

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

@@ -13,6 +13,8 @@ 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 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 +152,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() {
@@ -648,7 +675,6 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 updated_at: now,
             });
         }
-        const sessionKey = router.getThreadSessionKey(threadId);
         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 +691,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 +718,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);
+}