evolcore 0.0.1 → 0.0.3

package/dist/trigger/history.js

@@ -0,0 +1,290 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { definitionRevision } from './validation.js';
+export class TriggerHistoryStore {
+    rootDir;
+    agentAid;
+    file;
+    constructor(rootDir, agentAid) {
+        this.rootDir = rootDir;
+        this.agentAid = agentAid;
+        fs.mkdirSync(rootDir, { recursive: true });
+        this.file = path.join(rootDir, 'history.jsonl');
+    }
+    recordDefinition(type, definition, opts = {}) {
+        const event = {
+            schemaVersion: 1,
+            eventId: `evt_${Date.now()}_${crypto.randomBytes(6).toString('hex')}`,
+            type,
+            timestamp: Date.now(),
+            triggerId: definition.id,
+            agentAid: definition.agentAid,
+            definition,
+            revision: definitionRevision(definition),
+            previousRevision: opts.previousRevision,
+            reason: opts.reason,
+        };
+        this.append(event);
+        return event;
+    }
+    recordRun(audit, importedFrom) {
+        const event = {
+            schemaVersion: 1,
+            eventId: `run:${audit.runId}`,
+            type: `run.${audit.status}`,
+            timestamp: audit.finishedAt,
+            triggerId: audit.triggerId,
+            agentAid: audit.agentAid,
+            audit,
+            importedFrom,
+        };
+        this.append(event);
+        return event;
+    }
+    events(triggerId, limit = 100) {
+        if (limit <= 0)
+            return [];
+        const lines = this.readLines();
+        const out = [];
+        for (let i = lines.length - 1; i >= 0 && out.length < limit; i--) {
+            const event = parseHistoryEvent(lines[i], this.agentAid);
+            if (!event || event.agentAid !== this.agentAid)
+                continue;
+            if (triggerId && event.triggerId !== triggerId)
+                continue;
+            out.push(event);
+        }
+        return out;
+    }
+    recentRuns(triggerId, limit = 20) {
+        if (limit <= 0)
+            return [];
+        const lines = this.readLines();
+        const out = [];
+        for (let i = lines.length - 1; i >= 0 && out.length < limit; i--) {
+            const event = parseHistoryEvent(lines[i], this.agentAid);
+            if (!event || !isRunEvent(event))
+                continue;
+            if (event.agentAid === this.agentAid && event.triggerId === triggerId) {
+                out.push(event.audit);
+            }
+        }
+        return out;
+    }
+    latestRuns(triggerIds) {
+        const pending = new Set(triggerIds);
+        const latest = new Map();
+        if (pending.size === 0)
+            return latest;
+        const lines = this.readLines();
+        for (let i = lines.length - 1; i >= 0 && pending.size > 0; i--) {
+            const event = parseHistoryEvent(lines[i], this.agentAid);
+            if (!event || !isRunEvent(event) || !pending.has(event.triggerId))
+                continue;
+            latest.set(event.triggerId, event.audit);
+            pending.delete(event.triggerId);
+        }
+        return latest;
+    }
+    stats(triggerId) {
+        const legacy = { fireCount: 0, failCount: 0 };
+        const current = { fireCount: 0, failCount: 0 };
+        let legacyMatched = false;
+        let latestFinishedAt = -1;
+        for (const line of this.readLines()) {
+            const event = parseHistoryEvent(line, this.agentAid);
+            if (!event || event.triggerId !== triggerId || event.agentAid !== this.agentAid)
+                continue;
+            if (isLegacyEvent(event)) {
+                legacyMatched = true;
+                const fireCount = nonNegativeInteger(event.legacyRecord.fireCount);
+                const failCount = nonNegativeInteger(event.legacyRecord.failCount);
+                legacy.fireCount = Math.max(legacy.fireCount, fireCount ?? 0);
+                legacy.failCount = Math.max(legacy.failCount, failCount ?? 0);
+                const lastFiredAt = finiteNumber(event.legacyRecord.lastFiredAt);
+                if (lastFiredAt !== undefined && lastFiredAt > latestFinishedAt) {
+                    latestFinishedAt = lastFiredAt;
+                    legacy.lastFiredAt = lastFiredAt;
+                    legacy.lastResult = event.legacyRecord.lastResult === 'failed' ? 'failed' : 'completed';
+                }
+                continue;
+            }
+            if (!isRunEvent(event))
+                continue;
+            const record = event.audit;
+            if (record.status !== 'completed'
+                && record.status !== 'degraded'
+                && record.status !== 'noop'
+                && record.status !== 'failed')
+                continue;
+            current.fireCount += 1;
+            if (record.status === 'failed')
+                current.failCount += 1;
+            if (record.finishedAt > latestFinishedAt) {
+                latestFinishedAt = record.finishedAt;
+                current.lastFiredAt = record.finishedAt;
+                current.lastResult = record.status === 'failed' ? 'failed' : 'completed';
+            }
+        }
+        return this.mergeRunStats(legacyMatched ? legacy : undefined, current);
+    }
+    hasSkippedSchedule(triggerId, scheduledAt) {
+        for (const line of this.readLines()) {
+            const event = parseHistoryEvent(line, this.agentAid);
+            if (!event || !isRunEvent(event) || event.triggerId !== triggerId || event.agentAid !== this.agentAid)
+                continue;
+            if (event.audit.status === 'skipped' && event.audit.source.scheduledAt === scheduledAt)
+                return true;
+        }
+        return false;
+    }
+    hasLegacyArchive(triggerId) {
+        return this.readLines().some(line => {
+            const event = parseHistoryEvent(line, this.agentAid);
+            return !!event
+                && event.agentAid === this.agentAid
+                && event.triggerId === triggerId
+                && isLegacyEvent(event);
+        });
+    }
+    ensureDefinitionSnapshot(definition) {
+        const revision = definitionRevision(definition);
+        for (const event of this.events(definition.id, Number.MAX_SAFE_INTEGER)) {
+            if (isDefinitionEvent(event) && event.revision === revision)
+                return;
+        }
+        this.recordDefinition('trigger.created', definition, { reason: 'migration_snapshot' });
+    }
+    importAuditLogs(logDir) {
+        const knownRuns = new Set(this.events(undefined, Number.MAX_SAFE_INTEGER)
+            .filter(isRunEvent)
+            .map(event => event.audit.runId));
+        let imported = 0;
+        for (const file of listAuditLogFiles(logDir)) {
+            let lines;
+            try {
+                lines = fs.readFileSync(file, 'utf8').split('\n');
+            }
+            catch {
+                continue;
+            }
+            for (const line of lines) {
+                if (!line)
+                    continue;
+                let audit;
+                try {
+                    audit = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (audit.agentAid !== this.agentAid || !audit.runId || knownRuns.has(audit.runId))
+                    continue;
+                if (audit.status === 'dry-run')
+                    continue;
+                this.recordRun(audit, path.basename(file));
+                knownRuns.add(audit.runId);
+                imported += 1;
+            }
+        }
+        return imported;
+    }
+    append(event) {
+        fs.appendFileSync(this.file, `${JSON.stringify(event)}\n`, { encoding: 'utf8', mode: 0o600 });
+    }
+    readLines() {
+        try {
+            return fs.readFileSync(this.file, 'utf8').split('\n').filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+    mergeRunStats(legacy, current) {
+        if (!legacy)
+            return current;
+        const out = {
+            fireCount: legacy.fireCount + current.fireCount,
+            failCount: legacy.failCount + current.failCount,
+        };
+        const legacyAt = legacy.lastFiredAt ?? -1;
+        const currentAt = current.lastFiredAt ?? -1;
+        if (legacyAt >= currentAt && legacy.lastFiredAt !== undefined) {
+            out.lastFiredAt = legacy.lastFiredAt;
+            out.lastResult = legacy.lastResult;
+        }
+        else if (current.lastFiredAt !== undefined) {
+            out.lastFiredAt = current.lastFiredAt;
+            out.lastResult = current.lastResult;
+        }
+        return out;
+    }
+}
+function parseHistoryEvent(line, fallbackAgentAid) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.schemaVersion !== 1) {
+        const triggerId = stringValue(record.id);
+        if (!triggerId)
+            return undefined;
+        const timestamp = finiteNumber(record.doneAt)
+            ?? finiteNumber(record.updatedAt)
+            ?? finiteNumber(record.createdAt)
+            ?? 0;
+        return {
+            schemaVersion: 1,
+            eventId: `legacy:${triggerId}:${timestamp}`,
+            type: 'trigger.legacy_archived',
+            timestamp,
+            triggerId,
+            agentAid: stringValue(record.schedulerAid) ?? fallbackAgentAid,
+            legacyRecord: record,
+        };
+    }
+    const event = record;
+    if (typeof event.type !== 'string' || typeof event.triggerId !== 'string')
+        return undefined;
+    if (!event.type.startsWith('trigger.') && !event.type.startsWith('run.'))
+        return undefined;
+    return event;
+}
+function isRunEvent(event) {
+    return event.type.startsWith('run.');
+}
+function isDefinitionEvent(event) {
+    return event.type.startsWith('trigger.') && event.type !== 'trigger.legacy_archived';
+}
+function isLegacyEvent(event) {
+    return event.type === 'trigger.legacy_archived';
+}
+function stringValue(value) {
+    return typeof value === 'string' && value ? value : undefined;
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+function listAuditLogFiles(logDir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(logDir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter(file => file === 'trigger-runs.log' || /^trigger-runs-\d{8}\.log$/.test(file))
+        .sort()
+        .map(file => path.join(logDir, file));
+}

package/dist/trigger/manager.js

@@ -0,0 +1,294 @@
+import fs from 'fs';
+import path from 'path';
+import { agentTriggersDir } from '../paths.js';
+import { definitionRevision, normalizeTriggerDefinition, resolveScriptPath, safeRelativePath, } from './validation.js';
+import { atomicWriteJson } from '../core/session/session-fs-store.js';
+import { TriggerHistoryStore } from './history.js';
+export class TriggerDefinitionManager {
+    agentAid;
+    rootDir;
+    history;
+    constructor(agentAid, rootDir = agentTriggersDir(agentAid)) {
+        this.agentAid = agentAid;
+        this.rootDir = rootDir;
+        fs.mkdirSync(this.rootDir, { recursive: true });
+        this.history = new TriggerHistoryStore(rootDir, agentAid);
+        for (const definition of this.list({ all: true })) {
+            this.history.ensureDefinitionSnapshot(definition);
+        }
+    }
+    list(opts = {}) {
+        const definitions = [];
+        for (const triggerId of this.listTriggerIds()) {
+            const definition = this.get(triggerId);
+            if (!definition)
+                continue;
+            if (!opts.all && !definition.enabled)
+                continue;
+            definitions.push(definition);
+        }
+        return definitions.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    get(triggerId) {
+        const file = this.definitionPath(triggerId);
+        if (!fs.existsSync(file))
+            return undefined;
+        const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        return normalizeTriggerDefinition(raw);
+    }
+    require(triggerId) {
+        const def = this.get(triggerId);
+        if (!def)
+            throw new Error(`trigger not found: ${triggerId}`);
+        return def;
+    }
+    create(input, files = [], opts = {}) {
+        const now = Date.now();
+        const definition = normalizeTriggerDefinition(input, { now });
+        this.assertAgent(definition);
+        if (opts.enable !== undefined)
+            definition.enabled = opts.enable;
+        definition.createdAt = definition.createdAt || now;
+        definition.updatedAt = now;
+        this.assertUnique(definition);
+        const dir = this.triggerDir(definition.id);
+        if (fs.existsSync(dir))
+            throw new Error(`trigger directory already exists: ${definition.id}`);
+        fs.mkdirSync(dir, { recursive: true });
+        this.writeFiles(dir, files);
+        this.validateScriptFile(definition, dir);
+        this.writeDefinition(definition);
+        this.clearActive(definition.id);
+        this.history.recordDefinition('trigger.created', definition);
+        return definition;
+    }
+    update(triggerId, input, files = []) {
+        const existing = this.require(triggerId);
+        const rawInput = isRecord(input) ? input : {};
+        const origin = mergeOrigin(existing.origin, rawInput.origin);
+        const updated = normalizeTriggerDefinition({
+            ...rawInput,
+            id: triggerId,
+            ...(origin ? { origin } : {}),
+        }, { now: Date.now() });
+        this.assertAgent(updated);
+        if (existing.execution.baseagent !== updated.execution.baseagent) {
+            throw new Error('execution.baseagent is immutable; create a new Trigger to use another baseagent');
+        }
+        updated.createdAt = existing.createdAt;
+        updated.updatedAt = Date.now();
+        this.assertUnique(updated, triggerId);
+        const dir = this.triggerDir(triggerId);
+        fs.mkdirSync(dir, { recursive: true });
+        this.writeFiles(dir, files);
+        this.validateScriptFile(updated, dir);
+        this.writeDefinition(updated);
+        this.history.recordDefinition('trigger.updated', updated, {
+            previousRevision: definitionRevision(existing),
+        });
+        return updated;
+    }
+    setEnabled(triggerId, enabled) {
+        const definition = this.require(triggerId);
+        definition.enabled = enabled;
+        definition.updatedAt = Date.now();
+        this.writeDefinition(definition);
+        this.history.recordDefinition(enabled ? 'trigger.enabled' : 'trigger.disabled', definition);
+        return definition;
+    }
+    cancel(triggerId) {
+        return this.setEnabled(triggerId, false);
+    }
+    delete(triggerId) {
+        const definition = this.require(triggerId);
+        this.history.recordDefinition('trigger.deleted', definition);
+        fs.rmSync(this.triggerDir(triggerId), { recursive: true, force: true });
+        return definition;
+    }
+    triggerDir(triggerId) {
+        return path.join(this.rootDir, safeRelativePath(triggerId));
+    }
+    definitionPath(triggerId) {
+        return path.join(this.triggerDir(triggerId), 'trigger.json');
+    }
+    activePath(triggerId) {
+        return path.join(this.triggerDir(triggerId), 'active.json');
+    }
+    clearActive(triggerId) {
+        const file = this.activePath(triggerId);
+        try {
+            fs.unlinkSync(file);
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT')
+                throw e;
+        }
+    }
+    readRawDefinition(triggerId) {
+        return JSON.parse(fs.readFileSync(this.definitionPath(triggerId), 'utf-8'));
+    }
+    legacyStats(triggerId) {
+        const snapshots = this.listLegacyMigrationFiles();
+        const stats = { fireCount: 0, failCount: 0 };
+        let matched = false;
+        let latestAt = -1;
+        for (const file of snapshots) {
+            const record = this.readLegacyTriggerRecord(file, triggerId);
+            if (!record)
+                continue;
+            matched = true;
+            const fireCount = nonNegativeInteger(record.fireCount);
+            const failCount = nonNegativeInteger(record.failCount);
+            if (fireCount !== undefined)
+                stats.fireCount = Math.max(stats.fireCount, fireCount);
+            if (failCount !== undefined)
+                stats.failCount = Math.max(stats.failCount, failCount);
+            const lastFiredAt = finiteNumber(record.lastFiredAt);
+            const lastResult = record.lastResult === 'failed'
+                ? 'failed'
+                : record.lastResult === 'completed'
+                    ? 'completed'
+                    : undefined;
+            if (lastFiredAt !== undefined && lastFiredAt > latestAt) {
+                latestAt = lastFiredAt;
+                stats.lastFiredAt = lastFiredAt;
+                if (lastResult)
+                    stats.lastResult = lastResult;
+            }
+        }
+        return matched ? stats : undefined;
+    }
+    importFromPath(inputPath, opts = {}) {
+        const stat = fs.statSync(inputPath);
+        const sourceDir = stat.isDirectory() ? inputPath : path.dirname(inputPath);
+        const triggerJson = stat.isDirectory() ? path.join(inputPath, 'trigger.json') : inputPath;
+        const definitionRaw = JSON.parse(fs.readFileSync(triggerJson, 'utf-8'));
+        const definition = normalizeTriggerDefinition(definitionRaw);
+        const files = [];
+        if (definition.execution.type === 'script') {
+            const scriptAbs = resolveScriptPath(sourceDir, definition.execution.script.path);
+            const rel = path.relative(sourceDir, scriptAbs).replace(/\\/g, '/');
+            files.push({
+                relativePath: rel,
+                contentBase64: fs.readFileSync(scriptAbs).toString('base64'),
+            });
+        }
+        return this.create(definition, files, opts);
+    }
+    writeDefinition(definition) {
+        const dir = this.triggerDir(definition.id);
+        fs.mkdirSync(dir, { recursive: true });
+        atomicWriteJson(this.definitionPath(definition.id), definition);
+    }
+    listTriggerIds() {
+        let entries;
+        try {
+            entries = fs.readdirSync(this.rootDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        return entries.filter(e => e.isDirectory()).map(e => e.name);
+    }
+    listLegacyMigrationFiles() {
+        let entries;
+        try {
+            entries = fs.readdirSync(this.rootDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        return entries
+            .filter(e => e.isFile() && /^triggers\.legacy\.migrated\.\d+\.json$/.test(e.name))
+            .map(e => path.join(this.rootDir, e.name))
+            .sort();
+    }
+    readLegacyTriggerRecord(file, triggerId) {
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        }
+        catch {
+            return undefined;
+        }
+        if (!isRecord(parsed))
+            return undefined;
+        const triggers = isRecord(parsed.triggers) ? parsed.triggers : parsed;
+        const record = triggers[triggerId];
+        return isRecord(record) ? record : undefined;
+    }
+    writeFiles(dir, files) {
+        for (const file of files) {
+            const rel = safeRelativePath(file.relativePath);
+            const target = path.resolve(dir, rel);
+            const relFromRoot = path.relative(path.resolve(dir), target);
+            if (relFromRoot.startsWith('..') || path.isAbsolute(relFromRoot)) {
+                throw new Error(`file escapes trigger directory: ${file.relativePath}`);
+            }
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, Buffer.from(file.contentBase64, 'base64'));
+        }
+    }
+    validateScriptFile(definition, dir) {
+        if (definition.execution.type !== 'script')
+            return;
+        const scriptAbs = resolveScriptPath(dir, definition.execution.script.path);
+        if (!fs.existsSync(scriptAbs)) {
+            throw new Error(`script file not found: ${definition.execution.script.path}`);
+        }
+        const stat = fs.statSync(scriptAbs);
+        if (!stat.isFile())
+            throw new Error(`script.path is not a file: ${definition.execution.script.path}`);
+    }
+    assertAgent(definition) {
+        if (definition.agentAid !== this.agentAid) {
+            throw new Error(`definition.agentAid (${definition.agentAid}) does not match request agent (${this.agentAid})`);
+        }
+    }
+    assertUnique(definition, existingId) {
+        for (const other of this.list({ all: true })) {
+            if (existingId && other.id === existingId)
+                continue;
+            if (other.id === definition.id)
+                throw new Error(`trigger ID already exists: ${definition.id}`);
+            if (other.name === definition.name)
+                throw new Error(`trigger name already exists: ${definition.name}`);
+        }
+    }
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function mergeOrigin(existing, incoming) {
+    if (existing?.channelKey && existing.channelId)
+        return existing;
+    if (!isRecord(incoming))
+        return existing;
+    const channelKey = optionalString(incoming.channelKey) ?? existing?.channelKey;
+    const channelId = optionalString(incoming.channelId) ?? existing?.channelId;
+    const session = incoming.session === 'thread' || existing?.session === 'thread' ? 'thread' : 'main';
+    const threadId = optionalString(incoming.threadId) ?? existing?.threadId;
+    const peerId = optionalString(incoming.peerId) ?? existing?.peerId;
+    const sessionKey = optionalString(incoming.sessionKey) ?? existing?.sessionKey;
+    if (!channelKey && !channelId && !peerId && !sessionKey)
+        return undefined;
+    if (!channelKey || !channelId)
+        return existing;
+    return {
+        channelKey,
+        channelId,
+        session,
+        ...(session === 'thread' && threadId ? { threadId } : {}),
+        peerId,
+        sessionKey,
+    };
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+}