@exaudeus/workrail 3.24.4 → 3.25.0

package/dist/trigger/trigger-router.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerRouter = void 0;
+exports.interpolateGoalTemplate = interpolateGoalTemplate;
+const crypto = __importStar(require("node:crypto"));
+const index_js_1 = require("../v2/infra/in-memory/keyed-async-queue/index.js");
+function interpolateGoalTemplate(template, staticGoal, payload) {
+    const TOKEN_RE = /\{\{([^}]+)\}\}/g;
+    const tokens = [];
+    let match;
+    while ((match = TOKEN_RE.exec(template)) !== null) {
+        if (match[1] !== undefined)
+            tokens.push(match[1]);
+    }
+    if (tokens.length === 0)
+        return template;
+    const resolved = new Map();
+    for (const token of tokens) {
+        const value = extractDotPath(payload, token);
+        if (value === undefined || value === null) {
+            return staticGoal;
+        }
+        resolved.set(token, String(value));
+    }
+    return template.replace(TOKEN_RE, (_, token) => resolved.get(token) ?? staticGoal);
+}
+function extractDotPath(obj, rawPath) {
+    let path = rawPath.trim();
+    if (path.startsWith('$.'))
+        path = path.slice(2);
+    else if (path.startsWith('$'))
+        path = path.slice(1);
+    const segments = path.split('.');
+    let current = obj;
+    for (const segment of segments) {
+        if (segment.includes('[')) {
+            console.warn(`[TriggerRouter] contextMapping path "${rawPath}" contains array indexing ` +
+                `(segment: "${segment}"). Array indexing is not supported in MVP. ` +
+                `The extracted value will be undefined.`);
+            return undefined;
+        }
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function applyContextMapping(payload, entries) {
+    const context = {};
+    for (const entry of entries) {
+        const value = extractDotPath(payload, entry.payloadPath);
+        if (value === undefined) {
+            if (entry.required) {
+                console.warn(`[TriggerRouter] Required contextMapping key "${entry.workflowContextKey}" ` +
+                    `(path: "${entry.payloadPath}") resolved to undefined. ` +
+                    `The workflow context will be missing this variable.`);
+            }
+            continue;
+        }
+        context[entry.workflowContextKey] = value;
+    }
+    return context;
+}
+function validateHmac(rawBody, secret, headerValue) {
+    const expected = crypto
+        .createHmac('sha256', secret)
+        .update(rawBody)
+        .digest('hex');
+    const received = headerValue.startsWith('sha256=')
+        ? headerValue.slice(7)
+        : headerValue;
+    if (expected.length !== received.length) {
+        return false;
+    }
+    return crypto.timingSafeEqual(Buffer.from(expected, 'utf8'), Buffer.from(received, 'utf8'));
+}
+class TriggerRouter {
+    constructor(index, ctx, apiKey, runWorkflowFn) {
+        this.index = index;
+        this.ctx = ctx;
+        this.apiKey = apiKey;
+        this.runWorkflowFn = runWorkflowFn;
+        this.queue = new index_js_1.KeyedAsyncQueue();
+    }
+    route(event) {
+        const trigger = this.index.get(event.triggerId);
+        if (!trigger) {
+            return {
+                _tag: 'error',
+                error: { kind: 'not_found', triggerId: event.triggerId },
+            };
+        }
+        if (trigger.hmacSecret) {
+            const signature = event.signature;
+            if (!signature) {
+                return { _tag: 'error', error: { kind: 'hmac_invalid' } };
+            }
+            if (!validateHmac(event.rawBody, trigger.hmacSecret, signature)) {
+                return { _tag: 'error', error: { kind: 'hmac_invalid' } };
+            }
+        }
+        let workflowContext;
+        if (trigger.contextMapping?.mappings.length) {
+            workflowContext = applyContextMapping(event.payload, trigger.contextMapping.mappings);
+        }
+        else {
+            workflowContext = { payload: event.payload };
+        }
+        const goal = trigger.goalTemplate
+            ? interpolateGoalTemplate(trigger.goalTemplate, trigger.goal, event.payload)
+            : trigger.goal;
+        const workflowTrigger = {
+            workflowId: trigger.workflowId,
+            goal,
+            workspacePath: trigger.workspacePath,
+            context: workflowContext,
+            ...(trigger.referenceUrls !== undefined ? { referenceUrls: trigger.referenceUrls } : {}),
+            ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
+        };
+        void this.queue.enqueue(trigger.id, async () => {
+            const result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+            if (result._tag === 'success') {
+                console.log(`[TriggerRouter] Workflow completed: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} stopReason=${result.stopReason}`);
+            }
+            else {
+                console.log(`[TriggerRouter] Workflow failed: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} error=${result.message} stopReason=${result.stopReason}`);
+            }
+        });
+        return { _tag: 'enqueued', triggerId: trigger.id };
+    }
+    dispatch(workflowTrigger) {
+        void this.queue.enqueue(workflowTrigger.workflowId, async () => {
+            const result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+            if (result._tag === 'success') {
+                console.log(`[TriggerRouter] Dispatch completed: workflowId=${workflowTrigger.workflowId} ` +
+                    `stopReason=${result.stopReason}`);
+            }
+            else {
+                console.log(`[TriggerRouter] Dispatch failed: workflowId=${workflowTrigger.workflowId} ` +
+                    `error=${result.message} stopReason=${result.stopReason}`);
+            }
+        });
+        return workflowTrigger.workflowId;
+    }
+    listTriggers() {
+        return [...this.index.values()];
+    }
+}
+exports.TriggerRouter = TriggerRouter;

package/dist/trigger/trigger-store.d.ts

@@ -0,0 +1,31 @@
+import type { Result } from '../runtime/result.js';
+import { type TriggerConfig, type TriggerDefinition } from './types.js';
+export type TriggerStoreError = {
+    readonly kind: 'parse_error';
+    readonly message: string;
+    readonly lineNumber?: number;
+} | {
+    readonly kind: 'missing_secret';
+    readonly envVarName: string;
+    readonly triggerId: string;
+} | {
+    readonly kind: 'missing_field';
+    readonly field: string;
+    readonly triggerId: string;
+} | {
+    readonly kind: 'unknown_provider';
+    readonly provider: string;
+    readonly triggerId: string;
+} | {
+    readonly kind: 'file_not_found';
+    readonly filePath: string;
+} | {
+    readonly kind: 'io_error';
+    readonly message: string;
+} | {
+    readonly kind: 'duplicate_id';
+    readonly triggerId: string;
+};
+export declare function loadTriggerConfig(yamlContent: string, env?: Record<string, string | undefined>): Result<TriggerConfig, TriggerStoreError>;
+export declare function loadTriggerConfigFromFile(workspacePath: string, env?: Record<string, string | undefined>): Promise<Result<TriggerConfig, TriggerStoreError>>;
+export declare function buildTriggerIndex(config: TriggerConfig): Result<Map<string, TriggerDefinition>, TriggerStoreError>;

package/dist/trigger/trigger-store.js

@@ -0,0 +1,457 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTriggerConfig = loadTriggerConfig;
+exports.loadTriggerConfigFromFile = loadTriggerConfigFromFile;
+exports.buildTriggerIndex = buildTriggerIndex;
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs/promises"));
+const result_js_1 = require("../runtime/result.js");
+const types_js_1 = require("./types.js");
+const SUPPORTED_PROVIDERS = new Set(['generic']);
+function unquoteYamlScalar(raw) {
+    const s = raw.trim();
+    if ((s.startsWith('"') && s.endsWith('"')) ||
+        (s.startsWith("'") && s.endsWith("'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+function parseScalar(raw, lineNum) {
+    const s = raw.trim();
+    if (s.startsWith('[') || s.startsWith('{')) {
+        return (0, result_js_1.err)({
+            kind: 'parse_error',
+            message: `Inline arrays and objects are not supported. Use block style. At line ${lineNum}.`,
+            lineNumber: lineNum,
+        });
+    }
+    return (0, result_js_1.ok)(unquoteYamlScalar(s));
+}
+function parseTriggersYaml(content) {
+    const lines = content.split('\n');
+    const triggers = [];
+    let lineIndex = 0;
+    const skipBlankAndComments = () => {
+        while (lineIndex < lines.length) {
+            const l = lines[lineIndex];
+            if (l !== undefined && (l.trim() === '' || l.trim().startsWith('#'))) {
+                lineIndex++;
+            }
+            else {
+                break;
+            }
+        }
+    };
+    skipBlankAndComments();
+    if (lineIndex >= lines.length || !lines[lineIndex]?.trim().startsWith('triggers:')) {
+        return (0, result_js_1.err)({
+            kind: 'parse_error',
+            message: `Expected "triggers:" as the root key at line ${lineIndex + 1}.`,
+            lineNumber: lineIndex + 1,
+        });
+    }
+    lineIndex++;
+    while (lineIndex < lines.length) {
+        const line = lines[lineIndex];
+        if (line === undefined)
+            break;
+        const trimmed = line.trim();
+        if (trimmed === '' || trimmed.startsWith('#')) {
+            lineIndex++;
+            continue;
+        }
+        if (!line.match(/^[ ]{2,}- /)) {
+            return (0, result_js_1.err)({
+                kind: 'parse_error',
+                message: `Expected a list item starting with "  - " at line ${lineIndex + 1}. Got: "${trimmed}"`,
+                lineNumber: lineIndex + 1,
+            });
+        }
+        const trigger = {};
+        const itemIndent = line.indexOf('-');
+        const afterDash = line.slice(itemIndent + 1).trim();
+        if (afterDash) {
+            const colonIdx = afterDash.indexOf(':');
+            if (colonIdx === -1) {
+                return (0, result_js_1.err)({
+                    kind: 'parse_error',
+                    message: `Missing colon in key-value pair at line ${lineIndex + 1}: "${afterDash}"`,
+                    lineNumber: lineIndex + 1,
+                });
+            }
+            const key = afterDash.slice(0, colonIdx).trim();
+            const rawValue = afterDash.slice(colonIdx + 1).trim();
+            if (rawValue !== '') {
+                const valueResult = parseScalar(rawValue, lineIndex + 1);
+                if (valueResult.kind === 'err')
+                    return valueResult;
+                setTriggerField(trigger, key, valueResult.value);
+            }
+        }
+        lineIndex++;
+        while (lineIndex < lines.length) {
+            const kvLine = lines[lineIndex];
+            if (kvLine === undefined)
+                break;
+            const kTrimmed = kvLine.trim();
+            if (kTrimmed === '' || kTrimmed.startsWith('#')) {
+                lineIndex++;
+                continue;
+            }
+            const lineIndent = kvLine.search(/\S/);
+            if (lineIndent <= itemIndent) {
+                break;
+            }
+            const colonIdx = kTrimmed.indexOf(':');
+            if (colonIdx === -1) {
+                return (0, result_js_1.err)({
+                    kind: 'parse_error',
+                    message: `Missing colon in key-value pair at line ${lineIndex + 1}: "${kTrimmed}"`,
+                    lineNumber: lineIndex + 1,
+                });
+            }
+            const key = kTrimmed.slice(0, colonIdx).trim();
+            const rawValue = kTrimmed.slice(colonIdx + 1).trim();
+            if (key === 'contextMapping') {
+                lineIndex++;
+                const contextMapping = {};
+                while (lineIndex < lines.length) {
+                    const cmLine = lines[lineIndex];
+                    if (cmLine === undefined)
+                        break;
+                    const cmTrimmed = cmLine.trim();
+                    if (cmTrimmed === '' || cmTrimmed.startsWith('#')) {
+                        lineIndex++;
+                        continue;
+                    }
+                    const cmIndent = cmLine.search(/\S/);
+                    if (cmIndent <= lineIndent)
+                        break;
+                    const cmColonIdx = cmTrimmed.indexOf(':');
+                    if (cmColonIdx === -1) {
+                        return (0, result_js_1.err)({
+                            kind: 'parse_error',
+                            message: `Missing colon in contextMapping entry at line ${lineIndex + 1}: "${cmTrimmed}"`,
+                            lineNumber: lineIndex + 1,
+                        });
+                    }
+                    const cmKey = cmTrimmed.slice(0, cmColonIdx).trim();
+                    const cmRawValue = cmTrimmed.slice(cmColonIdx + 1).trim();
+                    const cmValueResult = parseScalar(cmRawValue, lineIndex + 1);
+                    if (cmValueResult.kind === 'err')
+                        return cmValueResult;
+                    contextMapping[cmKey] = cmValueResult.value;
+                    lineIndex++;
+                }
+                trigger.contextMapping = contextMapping;
+                continue;
+            }
+            if (key === 'agentConfig') {
+                lineIndex++;
+                const agentConfig = {};
+                while (lineIndex < lines.length) {
+                    const acLine = lines[lineIndex];
+                    if (acLine === undefined)
+                        break;
+                    const acTrimmed = acLine.trim();
+                    if (acTrimmed === '' || acTrimmed.startsWith('#')) {
+                        lineIndex++;
+                        continue;
+                    }
+                    const acIndent = acLine.search(/\S/);
+                    if (acIndent <= lineIndent)
+                        break;
+                    const acColonIdx = acTrimmed.indexOf(':');
+                    if (acColonIdx === -1) {
+                        return (0, result_js_1.err)({
+                            kind: 'parse_error',
+                            message: `Missing colon in agentConfig entry at line ${lineIndex + 1}: "${acTrimmed}"`,
+                            lineNumber: lineIndex + 1,
+                        });
+                    }
+                    const acKey = acTrimmed.slice(0, acColonIdx).trim();
+                    const acRawValue = acTrimmed.slice(acColonIdx + 1).trim();
+                    if (acRawValue !== '') {
+                        const acValueResult = parseScalar(acRawValue, lineIndex + 1);
+                        if (acValueResult.kind === 'err')
+                            return acValueResult;
+                        if (acKey === 'model')
+                            agentConfig.model = acValueResult.value;
+                    }
+                    lineIndex++;
+                }
+                trigger.agentConfig = agentConfig;
+                continue;
+            }
+            if (key === 'onComplete') {
+                lineIndex++;
+                const onComplete = {};
+                while (lineIndex < lines.length) {
+                    const ocLine = lines[lineIndex];
+                    if (ocLine === undefined)
+                        break;
+                    const ocTrimmed = ocLine.trim();
+                    if (ocTrimmed === '' || ocTrimmed.startsWith('#')) {
+                        lineIndex++;
+                        continue;
+                    }
+                    const ocIndent = ocLine.search(/\S/);
+                    if (ocIndent <= lineIndent)
+                        break;
+                    const ocColonIdx = ocTrimmed.indexOf(':');
+                    if (ocColonIdx === -1) {
+                        return (0, result_js_1.err)({
+                            kind: 'parse_error',
+                            message: `Missing colon in onComplete entry at line ${lineIndex + 1}: "${ocTrimmed}"`,
+                            lineNumber: lineIndex + 1,
+                        });
+                    }
+                    const ocKey = ocTrimmed.slice(0, ocColonIdx).trim();
+                    const ocRawValue = ocTrimmed.slice(ocColonIdx + 1).trim();
+                    if (ocRawValue !== '') {
+                        const ocValueResult = parseScalar(ocRawValue, lineIndex + 1);
+                        if (ocValueResult.kind === 'err')
+                            return ocValueResult;
+                        switch (ocKey) {
+                            case 'runOn':
+                                onComplete.runOn = ocValueResult.value;
+                                break;
+                            case 'workflowId':
+                                onComplete.workflowId = ocValueResult.value;
+                                break;
+                            case 'goal':
+                                onComplete.goal = ocValueResult.value;
+                                break;
+                            default: break;
+                        }
+                    }
+                    lineIndex++;
+                }
+                trigger.onComplete = onComplete;
+                continue;
+            }
+            if (rawValue === '') {
+                lineIndex++;
+                continue;
+            }
+            const valueResult = parseScalar(rawValue, lineIndex + 1);
+            if (valueResult.kind === 'err')
+                return valueResult;
+            setTriggerField(trigger, key, valueResult.value);
+            lineIndex++;
+        }
+        triggers.push(trigger);
+    }
+    return (0, result_js_1.ok)(triggers);
+}
+function setTriggerField(trigger, key, value) {
+    switch (key) {
+        case 'id':
+            trigger.id = value;
+            break;
+        case 'provider':
+            trigger.provider = value;
+            break;
+        case 'workflowId':
+            trigger.workflowId = value;
+            break;
+        case 'workspacePath':
+            trigger.workspacePath = value;
+            break;
+        case 'goal':
+            trigger.goal = value;
+            break;
+        case 'hmacSecret':
+            trigger.hmacSecret = value;
+            break;
+        case 'goalTemplate':
+            trigger.goalTemplate = value;
+            break;
+        case 'referenceUrls':
+            trigger.referenceUrls = value;
+            break;
+        default:
+            break;
+    }
+}
+function resolveSecret(value, triggerId, env) {
+    if (!value.startsWith('$')) {
+        return (0, result_js_1.ok)(value);
+    }
+    const envVarName = value.slice(1);
+    const resolved = env[envVarName];
+    if (resolved === undefined || resolved === '') {
+        return (0, result_js_1.err)({ kind: 'missing_secret', envVarName, triggerId });
+    }
+    return (0, result_js_1.ok)(resolved);
+}
+function assembleContextMapping(raw) {
+    if (!raw)
+        return undefined;
+    const mappings = Object.entries(raw).map(([workflowContextKey, payloadPath]) => ({
+        workflowContextKey,
+        payloadPath,
+    }));
+    return { mappings };
+}
+function validateAndResolveTrigger(raw, env) {
+    const rawId = raw.id?.trim() ?? '';
+    if (!rawId) {
+        return (0, result_js_1.err)({ kind: 'missing_field', field: 'id', triggerId: '(unknown)' });
+    }
+    const requiredStringFields = [
+        'provider',
+        'workflowId',
+        'workspacePath',
+        'goal',
+    ];
+    for (const field of requiredStringFields) {
+        const v = raw[field];
+        if (!v?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field, triggerId: rawId });
+        }
+    }
+    const provider = raw.provider.trim();
+    if (!SUPPORTED_PROVIDERS.has(provider)) {
+        return (0, result_js_1.err)({ kind: 'unknown_provider', provider, triggerId: rawId });
+    }
+    let hmacSecret;
+    if (raw.hmacSecret?.trim()) {
+        const secretResult = resolveSecret(raw.hmacSecret.trim(), rawId, env);
+        if (secretResult.kind === 'err')
+            return secretResult;
+        hmacSecret = secretResult.value;
+    }
+    const goalTemplate = raw.goalTemplate?.trim();
+    const referenceUrlsRaw = raw.referenceUrls?.trim();
+    const referenceUrls = referenceUrlsRaw
+        ? referenceUrlsRaw.split(/\s+/).filter(Boolean)
+        : undefined;
+    if (referenceUrls) {
+        for (const url of referenceUrls) {
+            try {
+                const parsed = new URL(url);
+                if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+                    return (0, result_js_1.err)({ kind: 'missing_field', field: `referenceUrls (non-HTTP URL rejected: ${url})`, triggerId: raw.id ?? '?' });
+                }
+            }
+            catch {
+                return (0, result_js_1.err)({ kind: 'missing_field', field: `referenceUrls (invalid URL: ${url})`, triggerId: raw.id ?? '?' });
+            }
+        }
+    }
+    const agentConfig = raw.agentConfig?.model?.trim()
+        ? { model: raw.agentConfig.model.trim() }
+        : undefined;
+    let onComplete;
+    if (raw.onComplete) {
+        const rawRunOn = raw.onComplete.runOn?.trim();
+        if (rawRunOn && rawRunOn !== 'success') {
+            console.warn(`[TriggerStore] UNSUPPORTED: onComplete.runOn='${rawRunOn}' is not implemented yet. ` +
+                `This trigger will NOT execute a completion hook on ${rawRunOn}. ` +
+                `Only runOn: 'success' is planned for a future release.`);
+        }
+        if (rawRunOn === 'success' || rawRunOn === 'failure' || rawRunOn === 'always') {
+            onComplete = {
+                runOn: rawRunOn,
+                ...(raw.onComplete.workflowId?.trim() ? { workflowId: raw.onComplete.workflowId.trim() } : {}),
+                ...(raw.onComplete.goal?.trim() ? { goal: raw.onComplete.goal.trim() } : {}),
+            };
+        }
+    }
+    const trigger = {
+        id: (0, types_js_1.asTriggerId)(rawId),
+        provider,
+        workflowId: raw.workflowId.trim(),
+        workspacePath: raw.workspacePath.trim(),
+        goal: raw.goal.trim(),
+        ...(hmacSecret !== undefined ? { hmacSecret } : {}),
+        ...(raw.contextMapping !== undefined
+            ? { contextMapping: assembleContextMapping(raw.contextMapping) }
+            : {}),
+        ...(goalTemplate ? { goalTemplate } : {}),
+        ...(referenceUrls !== undefined && referenceUrls.length > 0 ? { referenceUrls } : {}),
+        ...(agentConfig !== undefined ? { agentConfig } : {}),
+        ...(onComplete !== undefined ? { onComplete } : {}),
+    };
+    return (0, result_js_1.ok)(trigger);
+}
+function loadTriggerConfig(yamlContent, env = process.env) {
+    const parsedResult = parseTriggersYaml(yamlContent);
+    if (parsedResult.kind === 'err')
+        return parsedResult;
+    const validTriggers = [];
+    const validationErrors = [];
+    for (const rawTrigger of parsedResult.value) {
+        const triggerResult = validateAndResolveTrigger(rawTrigger, env);
+        if (triggerResult.kind === 'err') {
+            console.warn(`[TriggerStore] Skipping invalid trigger: ${JSON.stringify(triggerResult.error)}`);
+            validationErrors.push(triggerResult.error);
+            continue;
+        }
+        validTriggers.push(triggerResult.value);
+    }
+    if (validationErrors.length > 0) {
+        console.warn(`[TriggerStore] Loaded ${validTriggers.length} valid trigger(s), ` +
+            `skipped ${validationErrors.length} invalid trigger(s).`);
+    }
+    return (0, result_js_1.ok)({ triggers: validTriggers });
+}
+async function loadTriggerConfigFromFile(workspacePath, env = process.env) {
+    const filePath = path.join(workspacePath, 'triggers.yml');
+    let content;
+    try {
+        content = await fs.readFile(filePath, 'utf8');
+    }
+    catch (e) {
+        const error = e;
+        if (error.code === 'ENOENT') {
+            return (0, result_js_1.err)({ kind: 'file_not_found', filePath });
+        }
+        return (0, result_js_1.err)({ kind: 'io_error', message: error.message ?? String(e) });
+    }
+    return loadTriggerConfig(content, env);
+}
+function buildTriggerIndex(config) {
+    const index = new Map();
+    for (const trigger of config.triggers) {
+        if (index.has(trigger.id)) {
+            return (0, result_js_1.err)({ kind: 'duplicate_id', triggerId: trigger.id });
+        }
+        index.set(trigger.id, trigger);
+    }
+    return (0, result_js_1.ok)(index);
+}