evolcore 0.0.1 → 0.0.3

package/dist/trigger/audit.js

@@ -0,0 +1,152 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { LogWriter } from '../utils/log-writer.js';
+export class TriggerAuditLogger {
+    history;
+    writer;
+    logDir;
+    constructor(logDir = resolvePaths().logs, history, writer) {
+        this.history = history;
+        this.logDir = logDir;
+        this.history?.importAuditLogs(logDir);
+        this.writer = writer ?? new LogWriter({
+            baseName: 'trigger-runs',
+            logDir,
+            rotation: 'daily',
+            retention: { days: 7 },
+        });
+    }
+    withHistory(history) {
+        return new TriggerAuditLogger(this.logDir, history, this.writer);
+    }
+    write(record) {
+        this.writer.write(JSON.stringify(record));
+        this.history?.recordRun(record);
+    }
+    recent(triggerId, limit = 20) {
+        if (this.history)
+            return this.history.recentRuns(triggerId, limit);
+        const file = path.join(this.logDir, 'trigger-runs.log');
+        let lines;
+        try {
+            lines = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (let i = lines.length - 1; i >= 0 && out.length < limit; i--) {
+            try {
+                const record = JSON.parse(lines[i]);
+                if (record.triggerId === triggerId)
+                    out.push(record);
+            }
+            catch {
+                // skip malformed audit lines
+            }
+        }
+        return out;
+    }
+    latest(triggerIds) {
+        const ids = [...new Set(triggerIds)];
+        if (this.history)
+            return this.history.latestRuns(ids);
+        const latest = new Map();
+        for (const triggerId of ids) {
+            const record = this.recent(triggerId, 1)[0];
+            if (record)
+                latest.set(triggerId, record);
+        }
+        return latest;
+    }
+    /**
+     * 汇总某 trigger 的运行统计。绑定 history 时读取长期历史；未绑定时保留旧的
+     * 日志扫描行为，供兼容调用使用。skipped 和 dry-run 不计入 fireCount。
+     */
+    stats(triggerId) {
+        if (this.history)
+            return this.history.stats(triggerId);
+        const out = { fireCount: 0, failCount: 0 };
+        let latestFinishedAt = -1;
+        for (const file of this.listLogFiles()) {
+            let lines;
+            try {
+                lines = fs.readFileSync(file, 'utf-8').split('\n');
+            }
+            catch {
+                continue;
+            }
+            for (const line of lines) {
+                if (!line)
+                    continue;
+                let record;
+                try {
+                    record = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (record.triggerId !== triggerId)
+                    continue;
+                if (record.status !== 'completed'
+                    && record.status !== 'degraded'
+                    && record.status !== 'noop'
+                    && record.status !== 'failed')
+                    continue;
+                out.fireCount += 1;
+                if (record.status === 'failed')
+                    out.failCount += 1;
+                if (record.finishedAt > latestFinishedAt) {
+                    latestFinishedAt = record.finishedAt;
+                    out.lastFiredAt = record.finishedAt;
+                    out.lastResult = record.status === 'failed' ? 'failed' : 'completed';
+                }
+            }
+        }
+        return out;
+    }
+    hasSkippedSchedule(triggerId, scheduledAt) {
+        if (this.history)
+            return this.history.hasSkippedSchedule(triggerId, scheduledAt);
+        for (const file of this.listLogFiles()) {
+            let lines;
+            try {
+                lines = fs.readFileSync(file, 'utf-8').split('\n');
+            }
+            catch {
+                continue;
+            }
+            for (const line of lines) {
+                if (!line)
+                    continue;
+                let record;
+                try {
+                    record = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (record.triggerId === triggerId
+                    && record.status === 'skipped'
+                    && record.source.scheduledAt === scheduledAt) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /** 列出所有 trigger-runs 日志文件（活跃 + 归档切片），用于跨切片统计。 */
+    listLogFiles() {
+        let entries;
+        try {
+            entries = fs.readdirSync(this.logDir);
+        }
+        catch {
+            return [];
+        }
+        return entries
+            .filter(f => f === 'trigger-runs.log' || /^trigger-runs-\d{8}\.log$/.test(f))
+            .map(f => path.join(this.logDir, f));
+    }
+}

package/dist/trigger/event-source.js

@@ -0,0 +1,119 @@
+import { logger } from '../utils/logger.js';
+/** Match a real or simulated event without publishing it to the event bus. */
+export function matchTriggerEvent(source, event) {
+    if (typeof event.type !== 'string' || !event.type.trim()) {
+        return { matched: false, reason: 'missing_event_type' };
+    }
+    if (!matchPattern(event.type, source.eventPattern)) {
+        return { matched: false, reason: 'event_pattern_mismatch' };
+    }
+    if (source.filter && !matchFilter(event, source.filter)) {
+        return { matched: false, reason: 'event_filter_mismatch' };
+    }
+    return { matched: true };
+}
+export class TriggerEventSource {
+    eventBus;
+    fire;
+    subscriptions = new Map();
+    constructor(eventBus, fire) {
+        this.eventBus = eventBus;
+        this.fire = fire;
+    }
+    register(trigger) {
+        if (trigger.source.type !== 'event')
+            return () => { };
+        this.unregister(trigger.id);
+        const { eventPattern, filter } = trigger.source;
+        const handler = (event) => {
+            try {
+                // target/daemon execution attempts use trigger:* internally to settle
+                // their scheduler waiter. Downstream Trigger sources consume only the
+                // final run outcome published after audit/feedback completes.
+                if (event.type.startsWith('trigger:') && event.attemptId)
+                    return;
+                if (event.type.startsWith('trigger:') && event.originTriggerId === trigger.id)
+                    return;
+                if (!matchTriggerEvent({ type: 'event', eventPattern, ...(filter ? { filter } : {}) }, event).matched)
+                    return;
+                this.fire(trigger.id, {
+                    sourceType: 'event',
+                    eventName: event.type,
+                    firedAt: Date.now(),
+                    payload: event,
+                    causation: event.causation,
+                });
+            }
+            catch (err) {
+                logger.warn(`[TriggerEventSource] handler failed for ${trigger.id}: ${err}`);
+            }
+        };
+        this.eventBus.subscribeAll(handler);
+        const unsubscribe = () => this.eventBus.unsubscribe('*', handler);
+        this.subscriptions.set(trigger.id, unsubscribe);
+        return unsubscribe;
+    }
+    unregister(triggerId) {
+        const unsubscribe = this.subscriptions.get(triggerId);
+        if (!unsubscribe)
+            return;
+        unsubscribe();
+        this.subscriptions.delete(triggerId);
+    }
+    has(triggerId) {
+        return this.subscriptions.has(triggerId);
+    }
+    stop() {
+        for (const triggerId of [...this.subscriptions.keys()]) {
+            this.unregister(triggerId);
+        }
+    }
+}
+function matchPattern(eventType, pattern) {
+    if (pattern === '*' || pattern === eventType)
+        return true;
+    if (pattern.endsWith(':*'))
+        return eventType.startsWith(pattern.slice(0, -1));
+    return false;
+}
+function matchFilter(event, filter) {
+    if (!filter.match)
+        return true;
+    for (const [path, expected] of Object.entries(filter.match)) {
+        if (!matchValue(getByPath(event, path), expected))
+            return false;
+    }
+    return true;
+}
+function matchValue(actual, expected) {
+    if (typeof expected === 'string' || typeof expected === 'number' || typeof expected === 'boolean') {
+        return actual === expected;
+    }
+    if ('$exists' in expected) {
+        const exists = actual !== undefined;
+        if (exists !== expected.$exists)
+            return false;
+    }
+    if ('$in' in expected && !expected.$in.includes(actual))
+        return false;
+    if ('$regex' in expected && !new RegExp(expected.$regex).test(String(actual ?? '')))
+        return false;
+    if ('$gt' in expected && !(typeof actual === 'number' && actual > expected.$gt))
+        return false;
+    if ('$gte' in expected && !(typeof actual === 'number' && actual >= expected.$gte))
+        return false;
+    if ('$lt' in expected && !(typeof actual === 'number' && actual < expected.$lt))
+        return false;
+    if ('$lte' in expected && !(typeof actual === 'number' && actual <= expected.$lte))
+        return false;
+    return true;
+}
+function getByPath(obj, path) {
+    let cur = obj;
+    for (const part of path.split('.')) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[part];
+    }
+    return cur;
+}