@kafca/agentdock 0.1.42 → 0.1.44

package/dist-electron/services/local-ai-core/src/automation/automation-conversation-executor.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationConversationExecutor = void 0;
+exports.renderMonitorPrompt = renderMonitorPrompt;
+const scheduled_bridge_session_js_1 = require("../scheduler/scheduled-bridge-session.js");
+const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'interrupted']);
+const MONITOR_RUN_PERMISSION_MODE = 'bypassPermissions';
+class AutomationConversationExecutor {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(monitor, event, timeoutMs = 15 * 60 * 1000) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        const threadId = await this.resolveThread(monitor);
+        const prompt = renderMonitorPrompt(monitor.promptTemplate, event, monitor);
+        const channelRuntime = monitor.platform === 'local' ? undefined : this.options.getChannelRuntime(monitor.platform);
+        const bridge = channelRuntime
+            ? await scheduled_bridge_session_js_1.ScheduledBridgeSession.open({
+                target: {
+                    id: monitor.id,
+                    workspaceId: monitor.workspaceId,
+                    platform: monitor.platform,
+                    route: monitor.route,
+                    title: monitor.title,
+                    promptTemplate: monitor.promptTemplate,
+                },
+                threadId,
+                workspaceRouter,
+                getChannelRuntime: () => channelRuntime,
+                noticeIcon: monitor.sourceType === 'stock.quote' ? '📈' : '🔔',
+                noticeTitle: monitor.title,
+            })
+            : undefined;
+        try {
+            const sendResult = await workspaceRouter.sendThreadMessage(threadId, prompt, {
+                permissionMode: MONITOR_RUN_PERMISSION_MODE,
+                runtimeEnv: this.buildRuntimeEnv(monitor),
+            });
+            await this.waitForRun(sendResult.runId, timeoutMs);
+            const thread = await workspaceRouter.getThread(threadId);
+            const replyText = [...thread.messages]
+                .reverse()
+                .find((message) => message.role === 'assistant' && message.kind === 'final')
+                ?.content;
+            return {
+                threadId,
+                runId: sendResult.runId,
+                replyText,
+                deliveryMode: bridge ? 'bridge-stream' : 'thread-only',
+                deliveryStatus: 'succeeded',
+                lastBridgeEventAt: bridge ? new Date().toISOString() : undefined,
+            };
+        }
+        finally {
+            await bridge?.close();
+        }
+    }
+    async resolveThread(monitor) {
+        const workspaceRouter = this.options.getWorkspaceRouter();
+        if (monitor.executionMode === 'same-thread') {
+            const binding = this.options.store.getPlatformThreadBinding(monitor.workspaceId, monitor.route.channelId, monitor.route.participantId || '', monitor.platform);
+            if (binding?.thread_id && await this.threadExists(binding.thread_id)) {
+                return binding.thread_id;
+            }
+            if (monitor.route.threadId && await this.threadExists(monitor.route.threadId)) {
+                return monitor.route.threadId;
+            }
+        }
+        const title = monitor.platform === 'local'
+            ? `[Monitor] ${monitor.title}`
+            : `[Monitor:${(0, scheduled_job_route_js_1.getChannelPlatformBase)(monitor.platform) || monitor.platform}] ${monitor.title}`;
+        const existing = (await workspaceRouter.listThreads(monitor.workspaceId))
+            .find((thread) => thread.title === title);
+        if (existing) {
+            return existing.id;
+        }
+        const created = await workspaceRouter.createThread(monitor.workspaceId, title);
+        return created.id;
+    }
+    async threadExists(threadId) {
+        try {
+            await this.options.getWorkspaceRouter().getThread(threadId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    buildRuntimeEnv(monitor) {
+        const basePlatform = (0, scheduled_job_route_js_1.getChannelPlatformBase)(monitor.platform);
+        const env = {};
+        if (basePlatform && basePlatform !== 'local') {
+            env.LOCAL_AI_PLATFORM = basePlatform;
+            env.LOCAL_AI_ROUTE_TYPE = (0, scheduled_job_route_js_1.routeTypeForPlatform)(monitor.platform);
+        }
+        const instanceId = monitor.route.instanceId || (0, scheduled_job_route_js_1.getChannelPlatformInstanceId)(monitor.platform);
+        if (instanceId) {
+            env.LOCAL_AI_PLATFORM_INSTANCE_ID = instanceId;
+        }
+        if (monitor.route.channelId) {
+            env.LOCAL_AI_CHAT_ID = monitor.route.channelId;
+        }
+        if (monitor.route.participantId) {
+            env.LOCAL_AI_PLATFORM_USER_ID = monitor.route.participantId;
+        }
+        return env;
+    }
+    async waitForRun(runId, timeoutMs) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            const run = this.options.store.getRun(runId);
+            if (run && TERMINAL_RUN_STATES.has(run.status)) {
+                if (run.status !== 'completed') {
+                    throw new Error(`Monitor run finished with status ${run.status}`);
+                }
+                return run;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        throw new Error(`Timed out waiting for monitor run ${runId}`);
+    }
+}
+exports.AutomationConversationExecutor = AutomationConversationExecutor;
+function renderMonitorPrompt(template, event, monitor) {
+    const values = {
+        title: monitor.title,
+        sourceType: event.sourceType,
+        subject: event.subject,
+        summary: event.summary || '',
+        timestamp: event.occurredAt,
+        ...event.payload,
+    };
+    return String(template || '').replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_match, key) => String(values[key] ?? ''));
+}

package/dist-electron/services/local-ai-core/src/automation/automation-monitor-repository.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationMonitorRepository = void 0;
+class AutomationMonitorRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    list(workspaceId) {
+        return this.store.listAutomationMonitors(workspaceId);
+    }
+    get(monitorId) {
+        return this.store.getAutomationMonitor(monitorId);
+    }
+    create(input) {
+        return this.store.createAutomationMonitor(input);
+    }
+    update(monitorId, input) {
+        return this.store.updateAutomationMonitor(monitorId, input);
+    }
+    updateState(monitorId, input) {
+        return this.store.updateAutomationMonitorState(monitorId, input);
+    }
+    delete(monitorId) {
+        return this.store.deleteAutomationMonitor(monitorId);
+    }
+    listRuns(monitorId) {
+        return this.store.listAutomationMonitorRuns(monitorId);
+    }
+    createRun(monitorId, status, input = {}) {
+        return this.store.createAutomationMonitorRun(monitorId, status, input);
+    }
+    updateRun(runId, input) {
+        return this.store.updateAutomationMonitorRun(runId, input);
+    }
+    getPlatformThreadBindingByThreadId(threadId) {
+        return this.store.getPlatformThreadBindingByThreadId(threadId);
+    }
+    toScheduledLike(monitor) {
+        return {
+            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,
+        };
+    }
+}
+exports.AutomationMonitorRepository = AutomationMonitorRepository;

package/dist-electron/services/local-ai-core/src/automation/automation-monitor-service.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationMonitorService = void 0;
+const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
+const condition_evaluator_js_1 = require("./condition-evaluator.js");
+const automation_conversation_executor_js_1 = require("./automation-conversation-executor.js");
+const automation_monitor_repository_js_1 = require("./automation-monitor-repository.js");
+class AutomationMonitorService {
+    options;
+    timer = null;
+    pollInFlight = false;
+    runningMonitors = new Set();
+    subscriptionHandles = new Map();
+    providers = new Map();
+    executor;
+    repository;
+    constructor(options) {
+        this.options = options;
+        for (const provider of options.providers) {
+            this.providers.set(provider.sourceType, provider);
+        }
+        this.repository = new automation_monitor_repository_js_1.AutomationMonitorRepository(options.store);
+        this.executor = new automation_conversation_executor_js_1.AutomationConversationExecutor({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+            getChannelRuntime: options.getChannelRuntime,
+        });
+    }
+    async start() {
+        await this.refreshSubscriptions();
+        await this.tick();
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, 30_000);
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        for (const handle of this.subscriptionHandles.values()) {
+            await handle.stop();
+        }
+        this.subscriptionHandles.clear();
+    }
+    listMonitors(workspaceId) {
+        return this.repository.list(workspaceId);
+    }
+    getMonitor(monitorId) {
+        const resolvedMonitorId = this.resolveMonitorId(monitorId);
+        return resolvedMonitorId ? this.repository.get(resolvedMonitorId) : undefined;
+    }
+    createMonitor(input) {
+        const resolved = this.resolveCreateInput(input);
+        const provider = this.providers.get(resolved.sourceType);
+        provider?.validateConfig?.(resolved.sourceConfig || {});
+        const monitor = this.repository.create(resolved);
+        this.emitMonitor(monitor);
+        void this.ensureSubscription(monitor);
+        return monitor;
+    }
+    updateMonitor(monitorId, input) {
+        const resolvedMonitorId = this.resolveRequiredMonitorId(monitorId);
+        const existing = this.repository.get(resolvedMonitorId);
+        if (existing && input.sourceConfig) {
+            this.providers.get(existing.sourceType)?.validateConfig?.(input.sourceConfig);
+        }
+        const monitor = this.repository.update(resolvedMonitorId, {
+            ...input,
+            ...(input.route ? { route: (0, scheduled_job_route_js_1.withoutThreadRoute)(input.route) } : {}),
+        });
+        this.emitMonitor(monitor);
+        void this.ensureSubscription(monitor);
+        return monitor;
+    }
+    deleteMonitor(monitorId) {
+        const resolvedMonitorId = this.resolveRequiredMonitorId(monitorId);
+        void this.stopSubscription(resolvedMonitorId);
+        return this.repository.delete(resolvedMonitorId);
+    }
+    listRuns(monitorId) {
+        return this.repository.listRuns(this.resolveRequiredMonitorId(monitorId));
+    }
+    async runMonitorNow(monitorId, event) {
+        const monitor = this.getRequiredMonitor(monitorId);
+        const snapshot = event || await this.pollMonitor(monitor, true);
+        if (!snapshot) {
+            const skipped = this.markSkipped(monitor, new Date().toISOString(), 'No event snapshot is available for this monitor.');
+            this.emitRun(skipped);
+            return skipped;
+        }
+        return this.executeMonitor(monitor, snapshot, true);
+    }
+    listMonitorsForThread(threadId) {
+        const binding = this.repository.getPlatformThreadBindingByThreadId(threadId);
+        return this.repository
+            .list()
+            .filter((monitor) => monitor.route.threadId === threadId ||
+            (binding ? (0, scheduled_job_route_js_1.scheduledJobMatchesPlatformBinding)(this.repository.toScheduledLike(monitor), binding) : false));
+    }
+    async tick() {
+        if (this.pollInFlight) {
+            return;
+        }
+        this.pollInFlight = true;
+        try {
+            for (const monitor of this.repository.list().filter((candidate) => candidate.enabled)) {
+                const provider = this.providers.get(monitor.sourceType);
+                if (provider?.startMonitor) {
+                    continue;
+                }
+                const event = await this.pollMonitor(monitor, false);
+                if (!event) {
+                    continue;
+                }
+                if (!(0, condition_evaluator_js_1.evaluateMonitorCondition)(monitor.condition, event)) {
+                    this.repository.updateState(monitor.id, {
+                        lastState: this.stateFromEvent(event, monitor.lastState),
+                    });
+                    continue;
+                }
+                if (this.isCoolingDown(monitor, event.occurredAt)) {
+                    continue;
+                }
+                void this.executeMonitor(monitor, event, false);
+            }
+        }
+        finally {
+            this.pollInFlight = false;
+        }
+    }
+    async pollMonitor(monitor, manual) {
+        const provider = this.providers.get(monitor.sourceType);
+        if (!provider?.poll) {
+            if (manual) {
+                throw new Error(`No polling provider is available for monitor source "${monitor.sourceType}"`);
+            }
+            return null;
+        }
+        return provider.poll({
+            monitorId: monitor.id,
+            workspaceId: monitor.workspaceId,
+            sourceConfig: monitor.sourceConfig,
+            lastState: monitor.lastState,
+        });
+    }
+    async executeMonitor(monitor, event, manual) {
+        if (this.runningMonitors.has(monitor.id)) {
+            const skipped = this.markSkipped(monitor, event.occurredAt, 'Skipped because the previous monitor run is still active.', event);
+            this.emitRun(skipped);
+            return skipped;
+        }
+        this.runningMonitors.add(monitor.id);
+        const run = this.repository.createRun(monitor.id, 'queued', {
+            triggeredAt: event.occurredAt,
+            eventSnapshot: event,
+            deliveryStatus: 'pending',
+        });
+        this.emitRun(run);
+        try {
+            const running = this.repository.updateRun(run.id, {
+                status: 'running',
+                startedAt: new Date().toISOString(),
+            });
+            this.emitRun(running);
+            const result = await this.executor.execute(monitor, event);
+            const succeeded = this.repository.updateRun(run.id, {
+                status: 'succeeded',
+                finishedAt: new Date().toISOString(),
+                threadId: result.threadId,
+                runId: result.runId,
+                deliveryMode: result.deliveryMode,
+                deliveryStatus: result.deliveryStatus || 'succeeded',
+                deliveryError: result.deliveryError || '',
+                lastBridgeEventAt: result.lastBridgeEventAt,
+                error: '',
+            });
+            this.repository.updateState(monitor.id, {
+                lastState: this.stateFromEvent(event, monitor.lastState),
+                lastTriggeredAt: event.occurredAt,
+                lastStatus: 'succeeded',
+                lastError: '',
+            });
+            this.emitRun(succeeded);
+            const nextMonitor = this.repository.get(monitor.id);
+            if (nextMonitor)
+                this.emitMonitor(nextMonitor);
+            return succeeded;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const failed = this.repository.updateRun(run.id, {
+                status: 'failed',
+                finishedAt: new Date().toISOString(),
+                error: message,
+                deliveryStatus: 'failed',
+                deliveryError: message,
+            });
+            this.repository.updateState(monitor.id, {
+                lastState: this.stateFromEvent(event, monitor.lastState),
+                lastTriggeredAt: event.occurredAt,
+                lastStatus: 'failed',
+                lastError: message,
+            });
+            this.emitRun(failed);
+            const nextMonitor = this.repository.get(monitor.id);
+            if (nextMonitor)
+                this.emitMonitor(nextMonitor);
+            this.options.log?.(`automation monitor failed ${monitor.id}: ${message}`);
+            return failed;
+        }
+        finally {
+            this.runningMonitors.delete(monitor.id);
+        }
+    }
+    markSkipped(monitor, triggeredAt, error, eventSnapshot) {
+        return this.repository.createRun(monitor.id, 'skipped', {
+            triggeredAt,
+            error,
+            eventSnapshot,
+            deliveryStatus: 'skipped',
+            deliveryError: error,
+        });
+    }
+    stateFromEvent(event, previous) {
+        return {
+            ...(previous || {}),
+            lastEventId: event.id,
+            lastEventAt: event.occurredAt,
+            latestPrice: event.payload.latestPrice ?? previous?.latestPrice,
+            previousPrice: event.payload.previousPrice ?? previous?.previousPrice,
+            payload: event.payload,
+        };
+    }
+    isCoolingDown(monitor, occurredAt) {
+        if (!monitor.lastTriggeredAt || monitor.cooldownMs <= 0) {
+            return false;
+        }
+        return Date.parse(occurredAt) - Date.parse(monitor.lastTriggeredAt) < monitor.cooldownMs;
+    }
+    resolveCreateInput(input) {
+        if (input.platform && input.route) {
+            return {
+                ...input,
+                route: (0, scheduled_job_route_js_1.routeWithPlatformInstance)((0, scheduled_job_route_js_1.withoutThreadRoute)(input.route), input.platform),
+            };
+        }
+        const threadId = String(input.threadId || input.route?.threadId || '').trim();
+        if (threadId) {
+            const binding = this.repository.getPlatformThreadBindingByThreadId(threadId);
+            if (binding && binding.workspace_id === input.workspaceId) {
+                return {
+                    ...input,
+                    platform: binding.platform,
+                    route: (0, scheduled_job_route_js_1.routeFromPlatformThreadBinding)(binding),
+                };
+            }
+        }
+        return {
+            ...input,
+            platform: 'local',
+            route: {
+                type: 'local.thread',
+                channelId: input.workspaceId,
+            },
+        };
+    }
+    getRequiredMonitor(monitorId) {
+        const monitor = this.getMonitor(monitorId);
+        if (!monitor) {
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        }
+        return monitor;
+    }
+    resolveMonitorId(monitorId) {
+        if (this.repository.get(monitorId)) {
+            return monitorId;
+        }
+        const matches = this.repository
+            .list()
+            .filter((monitor) => publicMonitorId(monitor.id) === monitorId);
+        if (matches.length === 0) {
+            return '';
+        }
+        if (matches.length > 1) {
+            throw new Error(`Automation monitor id is ambiguous: ${monitorId}`);
+        }
+        return matches[0].id;
+    }
+    resolveRequiredMonitorId(monitorId) {
+        const resolved = this.resolveMonitorId(monitorId);
+        if (!resolved) {
+            throw new Error(`Automation monitor not found: ${monitorId}`);
+        }
+        return resolved;
+    }
+    emitMonitor(monitor) {
+        this.options.eventBus.emit({ type: 'automation.monitor.updated', payload: monitor });
+    }
+    emitRun(run) {
+        this.options.eventBus.emit({ type: 'automation.monitor.run.updated', payload: run });
+    }
+    async refreshSubscriptions() {
+        const activeIds = new Set();
+        for (const monitor of this.repository.list().filter((candidate) => candidate.enabled)) {
+            const provider = this.providers.get(monitor.sourceType);
+            if (!provider?.startMonitor)
+                continue;
+            activeIds.add(monitor.id);
+            await this.ensureSubscription(monitor);
+        }
+        for (const monitorId of [...this.subscriptionHandles.keys()]) {
+            if (!activeIds.has(monitorId)) {
+                await this.stopSubscription(monitorId);
+            }
+        }
+    }
+    async ensureSubscription(monitor) {
+        const provider = this.providers.get(monitor.sourceType);
+        if (!monitor.enabled || !provider?.startMonitor) {
+            await this.stopSubscription(monitor.id);
+            return;
+        }
+        if (this.subscriptionHandles.has(monitor.id)) {
+            return;
+        }
+        const handle = await provider.startMonitor({
+            monitorId: monitor.id,
+            workspaceId: monitor.workspaceId,
+            sourceConfig: monitor.sourceConfig,
+            lastState: monitor.lastState,
+            emit: async (event) => {
+                const latest = this.repository.get(monitor.id);
+                if (!latest || !latest.enabled)
+                    return;
+                if (!(0, condition_evaluator_js_1.evaluateMonitorCondition)(latest.condition, event)) {
+                    this.repository.updateState(latest.id, { lastState: this.stateFromEvent(event, latest.lastState) });
+                    return;
+                }
+                if (this.isCoolingDown(latest, event.occurredAt))
+                    return;
+                await this.executeMonitor(latest, event, false);
+            },
+        });
+        this.subscriptionHandles.set(monitor.id, handle);
+    }
+    async stopSubscription(monitorId) {
+        const handle = this.subscriptionHandles.get(monitorId);
+        if (!handle)
+            return;
+        this.subscriptionHandles.delete(monitorId);
+        await handle.stop();
+    }
+}
+exports.AutomationMonitorService = AutomationMonitorService;
+function publicMonitorId(monitorId) {
+    const normalized = monitorId.startsWith('monitor:') ? monitorId.slice('monitor:'.length) : monitorId;
+    return normalized.includes('-') ? normalized.split('-')[0] || normalized : normalized;
+}

package/dist-electron/services/local-ai-core/src/automation/condition-evaluator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateMonitorCondition = evaluateMonitorCondition;
+exports.evaluateExpression = evaluateExpression;
+exports.readMetric = readMetric;
+function evaluateMonitorCondition(condition, event) {
+    if (condition.expression) {
+        return evaluateExpression(condition.expression, event);
+    }
+    const actual = readMetric(event, condition.metric);
+    const expected = condition.value;
+    switch (condition.operator) {
+        case '>':
+            return Number(actual) > Number(expected);
+        case '>=':
+            return Number(actual) >= Number(expected);
+        case '<':
+            return Number(actual) < Number(expected);
+        case '<=':
+            return Number(actual) <= Number(expected);
+        case '==':
+            return String(actual) === String(expected);
+        case '!=':
+            return String(actual) !== String(expected);
+        default:
+            return false;
+    }
+}
+function evaluateExpression(expression, event) {
+    const orParts = splitExpression(expression, '||');
+    return orParts.some((orPart) => splitExpression(orPart, '&&').every((andPart) => evaluateComparison(andPart.trim(), event)));
+}
+function evaluateComparison(expression, event) {
+    const match = expression.match(/^([a-zA-Z0-9_.-]+)\s*(>=|<=|==|!=|>|<)\s*(.+)$/);
+    if (!match) {
+        throw new Error(`Unsupported monitor condition expression: ${expression}`);
+    }
+    const rawValue = String(match[3] || '').trim().replace(/^["']|["']$/g, '');
+    const numeric = Number(rawValue);
+    return evaluateMonitorCondition({
+        metric: String(match[1] || '').trim(),
+        operator: match[2],
+        value: Number.isFinite(numeric) && rawValue !== '' ? numeric : rawValue,
+    }, event);
+}
+function splitExpression(expression, operator) {
+    return expression
+        .split(operator)
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+function readMetric(event, metric) {
+    const key = String(metric || '').trim();
+    if (!key) {
+        return undefined;
+    }
+    if (key === 'subject')
+        return event.subject;
+    if (key === 'sourceType')
+        return event.sourceType;
+    const payload = event.payload || {};
+    if (key === 'abs_change_percent') {
+        return Math.abs(Number(payload.change_percent ?? payload.changePercent ?? 0));
+    }
+    const normalizedKey = key.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+    if (Object.prototype.hasOwnProperty.call(payload, key)) {
+        return payload[key];
+    }
+    if (Object.prototype.hasOwnProperty.call(payload, normalizedKey)) {
+        return payload[normalizedKey];
+    }
+    return key.split('.').reduce((current, part) => {
+        if (!current || typeof current !== 'object')
+            return undefined;
+        return current[part];
+    }, payload);
+}

package/dist-electron/services/local-ai-core/src/automation/mock-stock-provider.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockStockQuoteProvider = void 0;
+class MockStockQuoteProvider {
+    sourceType = 'stock.quote';
+    modes = ['poll'];
+    validateConfig(config) {
+        const symbol = String(config.symbol || '').trim();
+        if (!symbol) {
+            throw new Error('stock.quote monitor requires sourceConfig.symbol.');
+        }
+    }
+    poll(input) {
+        this.validateConfig(input.sourceConfig);
+        const symbol = String(input.sourceConfig.symbol || '').trim().toUpperCase();
+        const latestPrice = Number(input.sourceConfig.price ?? input.sourceConfig.latestPrice ?? input.lastState?.latestPrice ?? 0);
+        if (!Number.isFinite(latestPrice) || latestPrice <= 0) {
+            return null;
+        }
+        const previousPrice = Number(input.lastState?.latestPrice ?? input.sourceConfig.previousPrice ?? latestPrice);
+        const changePercent = previousPrice > 0 ? ((latestPrice - previousPrice) / previousPrice) * 100 : 0;
+        const now = new Date().toISOString();
+        return {
+            id: `${input.monitorId}:${symbol}:${now}`,
+            sourceType: this.sourceType,
+            occurredAt: now,
+            subject: symbol,
+            summary: `${symbol} ${latestPrice} (${changePercent.toFixed(2)}%)`,
+            payload: {
+                symbol,
+                latestPrice,
+                previousPrice,
+                change_percent: changePercent,
+                changePercent,
+                timestamp: now,
+            },
+        };
+    }
+}
+exports.MockStockQuoteProvider = MockStockQuoteProvider;

package/dist-electron/services/local-ai-core/src/automation/monitor-id.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPublicAutomationMonitorId = toPublicAutomationMonitorId;
+function toPublicAutomationMonitorId(monitorId) {
+    const normalized = monitorId.startsWith('monitor:') ? monitorId.slice('monitor:'.length) : monitorId;
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(normalized)) {
+        return normalized.split('-')[0] || normalized;
+    }
+    return normalized;
+}