@kafca/agentdock 0.1.41 → 0.1.43

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;
+}

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

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildInteractiveCard = buildInteractiveCard;
 exports.renderPermissionCard = renderPermissionCard;
 exports.renderPendingPairingCard = renderPendingPairingCard;
+exports.buildSessionCommandCard = buildSessionCommandCard;
 exports.extractCardActionMessageId = extractCardActionMessageId;
 exports.extractCardActionValue = extractCardActionValue;
+exports.extractSessionCommandActionValue = extractSessionCommandActionValue;
 exports.formatPermissionButtonLabel = formatPermissionButtonLabel;
 exports.formatPermissionResponseLabel = formatPermissionResponseLabel;
 const desktop_js_1 = require("../../../../../shared/desktop.js");
@@ -80,6 +82,37 @@ function renderPendingPairingCard(code) {
     }
     return lines.join('\n\n');
 }
+function buildSessionCommandCard(text, actionRows = [], sessionKey, threadId) {
+    const elements = [];
+    if (text) {
+        elements.push({ tag: 'markdown', content: text });
+    }
+    for (const row of actionRows) {
+        const actions = row
+            .filter((button) => button.label && button.command)
+            .map((button) => ({
+            tag: 'button',
+            text: {
+                tag: 'plain_text',
+                content: button.label,
+            },
+            type: button.type || 'default',
+            value: {
+                action: 'session_command',
+                command: button.command,
+                session_key: sessionKey || '',
+                thread_id: threadId || '',
+            },
+        }));
+        if (actions.length) {
+            elements.push({ tag: 'action', actions });
+        }
+    }
+    return {
+        config: { wide_screen_mode: true },
+        elements,
+    };
+}
 function extractCardActionMessageId(...payloads) {
     for (const payload of payloads) {
         const messageId = extractKnownCardActionMessageId(payload);
@@ -117,6 +150,28 @@ function extractCardActionValue(payload) {
         sessionKey,
     };
 }
+function extractSessionCommandActionValue(payload) {
+    const event = (payload?.event && typeof payload.event === 'object')
+        ? payload.event
+        : payload;
+    const value = event?.action?.value;
+    if (!value || value.action !== 'session_command') {
+        return null;
+    }
+    const command = String(value.command || '').trim();
+    const threadId = String(value.thread_id || '').trim();
+    const sessionKey = String(value.session_key || '').trim();
+    if (!command || !threadId) {
+        return null;
+    }
+    return {
+        event,
+        value: value,
+        command,
+        threadId,
+        sessionKey,
+    };
+}
 function formatPermissionButtonLabel(button) {
     return formatPermissionResponseLabel(button.data || button.text);
 }