evolcore 0.0.29 → 0.0.30

package/dist/trigger/manager.js

@@ -1,9 +1,10 @@
 import fs from 'fs';
 import path from 'path';
+import crypto from 'crypto';
 import { agentTriggersDir } from '../paths.js';
 import { assertExplicitAunDeliveryRoutes, definitionRevision, normalizeTriggerDefinition, resolveScriptPath, safeRelativePath, } from './validation.js';
-import { atomicWriteJson } from '../core/session/session-fs-store.js';
 import { TriggerHistoryStore } from './history.js';
+import { decodeTriggerScriptFile } from './local-files.js';
 export class TriggerDefinitionManager {
     agentAid;
     rootDir;
@@ -12,6 +13,7 @@ export class TriggerDefinitionManager {
         this.agentAid = agentAid;
         this.rootDir = rootDir;
         fs.mkdirSync(this.rootDir, { recursive: true });
+        assertRealDirectory(this.rootDir, 'Trigger root');
         this.history = new TriggerHistoryStore(rootDir, agentAid);
         for (const definition of this.list({ all: true })) {
             this.history.ensureDefinitionSnapshot(definition);
@@ -63,9 +65,16 @@ export class TriggerDefinitionManager {
         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);
+        try {
+            this.writeFiles(dir, files, definition, () => {
+                this.validateScriptFile(definition, dir);
+                this.writeDefinition(definition);
+            });
+        }
+        catch (error) {
+            fs.rmSync(dir, { recursive: true, force: true });
+            throw error;
+        }
         this.clearActive(definition.id);
         this.history.recordDefinition('trigger.created', definition);
         return definition;
@@ -91,9 +100,10 @@ export class TriggerDefinitionManager {
         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.writeFiles(dir, files, updated, () => {
+            this.validateScriptFile(updated, dir);
+            this.writeDefinition(updated);
+        });
         this.history.recordDefinition('trigger.updated', updated, {
             previousRevision: definitionRevision(existing),
         });
@@ -119,7 +129,7 @@ export class TriggerDefinitionManager {
         return definition;
     }
     triggerDir(triggerId) {
-        return path.join(this.rootDir, safeRelativePath(triggerId));
+        return path.join(this.rootDir, safeTriggerId(triggerId));
     }
     definitionPath(triggerId) {
         return path.join(this.triggerDir(triggerId), 'trigger.json');
@@ -191,7 +201,25 @@ export class TriggerDefinitionManager {
     writeDefinition(definition) {
         const dir = this.triggerDir(definition.id);
         fs.mkdirSync(dir, { recursive: true });
-        atomicWriteJson(this.definitionPath(definition.id), definition);
+        assertSafeDirectoryPath(this.rootDir, dir);
+        const target = this.definitionPath(definition.id);
+        const existing = lstatOptional(target);
+        if (existing && (!existing.isFile() || existing.isSymbolicLink() || existing.nlink !== 1)) {
+            throw new Error('Trigger definition target must be a regular, unlinked file');
+        }
+        const temporary = path.join(dir, `.ec-trigger-definition-${crypto.randomBytes(12).toString('hex')}.tmp`);
+        try {
+            writeNewFile(temporary, JSON.stringify(definition, null, 2) + '\n');
+            assertSafeDirectoryPath(this.rootDir, dir);
+            assertUnchangedTarget(target, existing);
+            fs.renameSync(temporary, target);
+        }
+        finally {
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch { }
+        }
     }
     listTriggerIds() {
         let entries;
@@ -230,28 +258,98 @@ export class TriggerDefinitionManager {
         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}`);
+    writeFiles(dir, files, definition, afterWrite) {
+        if (!Array.isArray(files) || files.length > 1)
+            throw new Error('a Trigger can upload only its configured script file');
+        if (files.length === 0) {
+            afterWrite();
+            return;
+        }
+        if (definition.execution.type !== 'script' || !definition.execution.script) {
+            throw new Error('uploaded Trigger files require execution.type=script');
+        }
+        assertRealDirectory(dir, 'Trigger directory');
+        const expectedRelative = safeScriptRelativePath(definition.execution.script.path);
+        const file = files[0];
+        if (!file || typeof file !== 'object')
+            throw new Error('invalid Trigger script upload');
+        const relative = safeScriptRelativePath(file.relativePath);
+        const normalize = (value) => process.platform === 'win32' ? value.toLowerCase() : value;
+        if (normalize(relative) !== normalize(expectedRelative)) {
+            throw new Error('uploaded file must match execution.script.path');
+        }
+        const contents = decodeTriggerScriptFile(file.contentBase64);
+        const target = path.resolve(dir, relative);
+        assertPathWithinDirectory(dir, target);
+        const parent = ensureSafeDirectoryPath(dir, path.dirname(target));
+        const existing = lstatOptional(target);
+        if (existing && (!existing.isFile() || existing.isSymbolicLink() || existing.nlink !== 1)) {
+            throw new Error('Trigger script target must be a regular, unlinked file');
+        }
+        const temporary = path.join(parent, `.ec-trigger-upload-${crypto.randomBytes(12).toString('hex')}.tmp`);
+        const backup = path.join(parent, `.ec-trigger-rollback-${crypto.randomBytes(12).toString('hex')}.tmp`);
+        let backedUp = false;
+        let installed = false;
+        let installedFile;
+        let committed = false;
+        try {
+            writeNewFile(temporary, contents);
+            assertSafeDirectoryPath(dir, parent);
+            assertUnchangedTarget(target, existing);
+            if (existing) {
+                fs.copyFileSync(target, backup, fs.constants.COPYFILE_EXCL);
+                backedUp = true;
+                assertUnchangedTarget(target, existing);
+            }
+            fs.renameSync(temporary, target);
+            installed = true;
+            installedFile = fs.lstatSync(target);
+            afterWrite();
+            committed = true;
+        }
+        catch (error) {
+            if (installed) {
+                try {
+                    assertSafeDirectoryPath(dir, parent);
+                    assertUnchangedTarget(target, installedFile);
+                    fs.unlinkSync(target);
+                    if (backedUp) {
+                        fs.renameSync(backup, target);
+                        backedUp = false;
+                    }
+                }
+                catch (rollbackError) {
+                    throw new AggregateError([error, rollbackError], 'Trigger script update failed and the previous file could not be restored');
+                }
+            }
+            throw error;
+        }
+        finally {
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch { }
+            if (backedUp && (committed || !installed)) {
+                try {
+                    fs.unlinkSync(backup);
+                }
+                catch { }
             }
-            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);
+        const relative = safeScriptRelativePath(definition.execution.script.path);
+        const scriptAbs = resolveScriptPath(dir, relative);
         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}`);
+        const stat = fs.lstatSync(scriptAbs);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) {
+            throw new Error(`script.path must be a regular unlinked file: ${definition.execution.script.path}`);
+        }
+        assertSafeDirectoryPath(dir, path.dirname(scriptAbs));
     }
     assertAgent(definition) {
         if (definition.agentAid !== this.agentAid) {
@@ -269,6 +367,121 @@ export class TriggerDefinitionManager {
         }
     }
 }
+const RESERVED_TRIGGER_FILES = new Set([
+    'trigger.json',
+    'active.json',
+    'history.jsonl',
+    'schedule.json',
+    'limits.json',
+]);
+function safeTriggerId(value) {
+    if (typeof value !== 'string' || !value || value.includes('/') || value.includes('\\')
+        || value.includes(':') || value.includes('\0') || value === '.' || value === '..') {
+        throw new Error(`invalid Trigger ID: ${value}`);
+    }
+    const normalized = safeRelativePath(value);
+    if (normalized.includes('/') || normalized.includes('\\') || normalized.includes(':')
+        || normalized.endsWith('.') || normalized.endsWith(' ')) {
+        throw new Error(`invalid Trigger ID: ${value}`);
+    }
+    if (/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(normalized)) {
+        throw new Error(`invalid Trigger ID: ${value}`);
+    }
+    return normalized;
+}
+function assertPathWithinDirectory(root, candidate) {
+    const relative = path.relative(path.resolve(root), path.resolve(candidate));
+    if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`file escapes Trigger directory: ${candidate}`);
+    }
+}
+function lstatOptional(value) {
+    try {
+        return fs.lstatSync(value);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function writeNewFile(target, contents) {
+    const descriptor = fs.openSync(target, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o600);
+    try {
+        fs.writeFileSync(descriptor, contents);
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function assertUnchangedTarget(target, expected) {
+    const current = lstatOptional(target);
+    if (!expected && current)
+        throw new Error('Trigger file target appeared during update');
+    if (expected && (!current || !current.isFile() || current.isSymbolicLink() || current.nlink !== 1
+        || current.dev !== expected.dev || current.ino !== expected.ino || current.size !== expected.size
+        || current.mtimeMs !== expected.mtimeMs || current.ctimeMs !== expected.ctimeMs)) {
+        throw new Error('Trigger file target changed during update');
+    }
+}
+function assertRealDirectory(value, label) {
+    const stat = fs.lstatSync(value);
+    const canonical = fs.realpathSync.native(value);
+    const lexical = path.resolve(value);
+    const equal = process.platform === 'win32'
+        ? canonical.toLowerCase() === lexical.toLowerCase()
+        : canonical === lexical;
+    if (!stat.isDirectory() || stat.isSymbolicLink() || !equal) {
+        throw new Error(`${label} must not be a symbolic link or junction`);
+    }
+}
+function ensureSafeDirectoryPath(root, target) {
+    const absoluteRoot = path.resolve(root);
+    const absoluteTarget = path.resolve(target);
+    if (absoluteTarget !== absoluteRoot)
+        assertPathWithinDirectory(absoluteRoot, absoluteTarget);
+    const relative = path.relative(absoluteRoot, absoluteTarget);
+    let current = absoluteRoot;
+    assertRealDirectory(current, 'Trigger directory');
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            fs.mkdirSync(current);
+        }
+        catch (error) {
+            if (error?.code !== 'EEXIST')
+                throw error;
+        }
+        assertRealDirectory(current, 'Trigger script parent');
+    }
+    return current;
+}
+function assertSafeDirectoryPath(root, target) {
+    const absoluteRoot = path.resolve(root);
+    const absoluteTarget = path.resolve(target);
+    if (absoluteTarget !== absoluteRoot)
+        assertPathWithinDirectory(absoluteRoot, absoluteTarget);
+    let current = absoluteRoot;
+    assertRealDirectory(current, 'Trigger directory');
+    for (const segment of path.relative(absoluteRoot, absoluteTarget).split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        assertRealDirectory(current, 'Trigger script parent');
+    }
+}
+function safeScriptRelativePath(value) {
+    if (typeof value !== 'string' || /[\0\r\n:<>"|?*]/.test(value)
+        || value.replace(/\\/g, '/').split('/').some(segment => segment === '..'
+            || (/[. ]$/.test(segment) && segment !== '.')
+            || /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(segment))) {
+        throw new Error('invalid Trigger script relative path');
+    }
+    const relative = safeRelativePath(value);
+    if (relative.split('/').some(segment => RESERVED_TRIGGER_FILES.has(segment.toLowerCase()))) {
+        throw new Error('script path conflicts with reserved Trigger state');
+    }
+    return relative;
+}
 function optionalString(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }

package/dist/trigger/scheduler.js

@@ -758,6 +758,27 @@ export class TriggerRuntimeScheduler {
     }
     async runRecordedExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt, previousAttempt) {
         const attemptId = `${runId}:attempt:${attempt}`;
+        const executionAuthorization = this.runtime.authorizeExecution?.(definition);
+        if (executionAuthorization && !executionAuthorization.allowed) {
+            const reply = errorReply(runId, 0, 'authorization_denied', executionAuthorization.reason || 'Trigger execution authorization denied');
+            const execution = {
+                script: null,
+                processing: { mode: definition.execution.type },
+                reply,
+            };
+            if (!dryRun) {
+                this.state.startExecutionAttempt?.(definition.id, runId, {
+                    attempt,
+                    attemptId,
+                    startedAt: Date.now(),
+                });
+                this.state.completeExecutionAttempt?.(definition.id, runId, attemptId, {
+                    status: 'failed',
+                    error: { code: 'authorization_denied', message: reply.error?.text || 'Trigger execution authorization denied' },
+                });
+            }
+            return execution;
+        }
         if (!dryRun) {
             this.state.startExecutionAttempt?.(definition.id, runId, {
                 attempt,
@@ -766,7 +787,7 @@ export class TriggerRuntimeScheduler {
             });
         }
         try {
-            const execution = await this.runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt, previousAttempt);
+            const execution = await this.runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt, previousAttempt, executionAuthorization);
             if (!dryRun) {
                 const summary = attemptSummaryFromExecution(attempt, attemptId, execution);
                 this.state.completeExecutionAttempt?.(definition.id, runId, attemptId, summary);
@@ -783,7 +804,7 @@ export class TriggerRuntimeScheduler {
             throw error;
         }
     }
-    async runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt = 1, previousAttempt) {
+    async runExecutionAttempt(definition, runId, firedAt, sourcePayload, signal, dryRun, causation, attempt = 1, previousAttempt, executionAuthorization) {
         if (signal.aborted) {
             return {
                 script: null,
@@ -792,7 +813,7 @@ export class TriggerRuntimeScheduler {
             };
         }
         if (definition.execution.type === 'script') {
-            const script = await this.runScriptOnce(definition, runId, firedAt, sourcePayload, signal);
+            const script = await this.runScriptOnce(definition, runId, firedAt, sourcePayload, signal, executionAuthorization);
             const processing = {
                 mode: 'script',
                 scriptPath: definition.execution.script?.path,
@@ -961,13 +982,15 @@ export class TriggerRuntimeScheduler {
             };
         }
     }
-    async runScriptOnce(definition, runId, firedAt, sourcePayload, signal) {
+    async runScriptOnce(definition, runId, firedAt, sourcePayload, signal, executionAuthorization) {
         return await this.scriptExecutor.execute({
             trigger: definition,
             triggerDir: this.manager.triggerDir(definition.id),
             runId,
             firedAt,
             sourcePayload,
+            projectPath: this.runtime.projectPath,
+            executionAuthorization,
             signal,
         });
     }
@@ -1906,7 +1929,9 @@ function branchFromReply(reply) {
     return 'onFailure';
 }
 function shouldRetryExecution(reply) {
-    return reply.outcome === 'error' || reply.outcome === 'timeout' || reply.outcome === 'interrupted';
+    return reply.outcome === 'error'
+        ? reply.error?.reason !== 'authorization_denied'
+        : reply.outcome === 'timeout' || reply.outcome === 'interrupted';
 }
 function triggerCancellationReason(signal) {
     const reason = signal.reason instanceof Error