@exaudeus/workrail 3.24.4 → 3.26.0

package/dist/trigger/trigger-store.js

@@ -0,0 +1,698 @@
+"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 os = __importStar(require("node:os"));
+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', 'gitlab_poll']);
+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;
+                        else if (acKey === 'maxSessionMinutes')
+                            agentConfig.maxSessionMinutes = acValueResult.value;
+                        else if (acKey === 'maxTurns')
+                            agentConfig.maxTurns = 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 (key === 'source') {
+                lineIndex++;
+                const source = {};
+                while (lineIndex < lines.length) {
+                    const srcLine = lines[lineIndex];
+                    if (srcLine === undefined)
+                        break;
+                    const srcTrimmed = srcLine.trim();
+                    if (srcTrimmed === '' || srcTrimmed.startsWith('#')) {
+                        lineIndex++;
+                        continue;
+                    }
+                    const srcIndent = srcLine.search(/\S/);
+                    if (srcIndent <= lineIndent)
+                        break;
+                    const srcColonIdx = srcTrimmed.indexOf(':');
+                    if (srcColonIdx === -1) {
+                        return (0, result_js_1.err)({
+                            kind: 'parse_error',
+                            message: `Missing colon in source entry at line ${lineIndex + 1}: "${srcTrimmed}"`,
+                            lineNumber: lineIndex + 1,
+                        });
+                    }
+                    const srcKey = srcTrimmed.slice(0, srcColonIdx).trim();
+                    const srcRawValue = srcTrimmed.slice(srcColonIdx + 1).trim();
+                    if (srcRawValue !== '') {
+                        const srcValueResult = parseScalar(srcRawValue, lineIndex + 1);
+                        if (srcValueResult.kind === 'err')
+                            return srcValueResult;
+                        switch (srcKey) {
+                            case 'baseUrl':
+                                source.baseUrl = srcValueResult.value;
+                                break;
+                            case 'projectId':
+                                source.projectId = srcValueResult.value;
+                                break;
+                            case 'token':
+                                source.token = srcValueResult.value;
+                                break;
+                            case 'events':
+                                source.events = srcValueResult.value;
+                                break;
+                            case 'pollIntervalSeconds':
+                                source.pollIntervalSeconds = srcValueResult.value;
+                                break;
+                            default: break;
+                        }
+                    }
+                    lineIndex++;
+                }
+                trigger.source = source;
+                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;
+        case 'concurrencyMode':
+            trigger.concurrencyMode = value;
+            break;
+        case 'callbackUrl':
+            trigger.callbackUrl = value;
+            break;
+        case 'autoCommit':
+            trigger.autoCommit = value;
+            break;
+        case 'autoOpenPR':
+            trigger.autoOpenPR = value;
+            break;
+        case 'workspaceName':
+            trigger.workspaceName = value;
+            break;
+        case 'soulFile':
+            trigger.soulFile = value;
+            break;
+        default:
+            break;
+    }
+}
+function expandTildePath(p) {
+    return p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : p;
+}
+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, workspaces = {}) {
+    const rawId = raw.id?.trim() ?? '';
+    if (!rawId) {
+        return (0, result_js_1.err)({ kind: 'missing_field', field: 'id', triggerId: '(unknown)' });
+    }
+    const requiredStringFields = [
+        'provider',
+        'workflowId',
+        '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 resolvedWorkspacePath;
+    let resolvedWorkspaceName;
+    let resolvedSoulFile;
+    const rawWorkspaceName = raw.workspaceName?.trim();
+    const rawWorkspacePath = raw.workspacePath?.trim();
+    const rawSoulFile = raw.soulFile?.trim();
+    if (rawWorkspaceName) {
+        if (!/^[a-zA-Z0-9_-]+$/.test(rawWorkspaceName)) {
+            return (0, result_js_1.err)({
+                kind: 'invalid_field_value',
+                field: `workspaceName (must match ^[a-zA-Z0-9_-]+$, got: "${rawWorkspaceName}")`,
+                triggerId: rawId,
+            });
+        }
+        const workspaceConfig = workspaces[rawWorkspaceName];
+        if (!workspaceConfig) {
+            return (0, result_js_1.err)({ kind: 'unknown_workspace', workspaceName: rawWorkspaceName, triggerId: rawId });
+        }
+        if (!path.isAbsolute(workspaceConfig.path)) {
+            return (0, result_js_1.err)({
+                kind: 'invalid_field_value',
+                field: `workspace "${rawWorkspaceName}".path (must be absolute, got: "${workspaceConfig.path}")`,
+                triggerId: rawId,
+            });
+        }
+        if (rawWorkspacePath) {
+            console.warn(`[TriggerStore] WARNING: trigger "${rawId}" has both workspaceName and workspacePath. ` +
+                `workspaceName takes precedence; workspacePath "${rawWorkspacePath}" is ignored.`);
+        }
+        resolvedWorkspacePath = workspaceConfig.path;
+        resolvedWorkspaceName = (0, types_js_1.asWorkspaceName)(rawWorkspaceName);
+        resolvedSoulFile = rawSoulFile ?? workspaceConfig.soulFile;
+    }
+    else {
+        if (!rawWorkspacePath) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'workspacePath', triggerId: rawId });
+        }
+        resolvedWorkspacePath = rawWorkspacePath;
+        resolvedSoulFile = rawSoulFile;
+    }
+    if (resolvedSoulFile) {
+        resolvedSoulFile = expandTildePath(resolvedSoulFile);
+    }
+    if (resolvedSoulFile && !path.isAbsolute(resolvedSoulFile)) {
+        return (0, result_js_1.err)({ kind: 'invalid_field_value', field: 'soulFile', 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: 'invalid_field_value', field: `referenceUrls (non-HTTP URL rejected: ${url})`, triggerId: raw.id ?? '?' });
+                }
+            }
+            catch {
+                return (0, result_js_1.err)({ kind: 'invalid_field_value', field: `referenceUrls (invalid URL: ${url})`, triggerId: raw.id ?? '?' });
+            }
+        }
+    }
+    let callbackUrl;
+    if (raw.callbackUrl?.trim()) {
+        const rawCb = raw.callbackUrl.trim();
+        try {
+            const parsedCb = new URL(rawCb);
+            if (parsedCb.protocol !== 'https:' && parsedCb.protocol !== 'http:') {
+                return (0, result_js_1.err)({ kind: 'invalid_field_value', field: `callbackUrl (non-HTTP URL rejected: ${rawCb})`, triggerId: rawId });
+            }
+        }
+        catch {
+            return (0, result_js_1.err)({ kind: 'invalid_field_value', field: `callbackUrl (invalid URL: ${rawCb})`, triggerId: rawId });
+        }
+        callbackUrl = rawCb;
+    }
+    let agentConfig;
+    if (raw.agentConfig) {
+        const model = raw.agentConfig.model?.trim() || undefined;
+        let maxSessionMinutes;
+        if (raw.agentConfig.maxSessionMinutes !== undefined) {
+            const asNumber = Number(raw.agentConfig.maxSessionMinutes);
+            if (!Number.isInteger(asNumber) || asNumber <= 0) {
+                return (0, result_js_1.err)({
+                    kind: 'invalid_field_value',
+                    field: 'agentConfig.maxSessionMinutes (must be a positive integer)',
+                    triggerId: rawId,
+                });
+            }
+            maxSessionMinutes = asNumber;
+        }
+        let maxTurns;
+        if (raw.agentConfig.maxTurns !== undefined) {
+            const asNumber = Number(raw.agentConfig.maxTurns);
+            if (!Number.isInteger(asNumber) || asNumber <= 0) {
+                return (0, result_js_1.err)({
+                    kind: 'invalid_field_value',
+                    field: 'agentConfig.maxTurns (must be a positive integer)',
+                    triggerId: rawId,
+                });
+            }
+            maxTurns = asNumber;
+        }
+        if (model !== undefined || maxSessionMinutes !== undefined || maxTurns !== undefined) {
+            agentConfig = {
+                ...(model !== undefined ? { model } : {}),
+                ...(maxSessionMinutes !== undefined ? { maxSessionMinutes } : {}),
+                ...(maxTurns !== undefined ? { maxTurns } : {}),
+            };
+        }
+    }
+    const rawConcurrencyMode = raw.concurrencyMode?.trim();
+    if (rawConcurrencyMode !== undefined && rawConcurrencyMode !== 'serial' && rawConcurrencyMode !== 'parallel') {
+        return (0, result_js_1.err)({
+            kind: 'invalid_field_value',
+            field: `concurrencyMode (invalid value: "${rawConcurrencyMode}"; must be "serial" or "parallel")`,
+            triggerId: rawId,
+        });
+    }
+    const concurrencyMode = rawConcurrencyMode === 'parallel' ? 'parallel' : 'serial';
+    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 autoCommit = raw.autoCommit?.trim().toLowerCase() === 'true';
+    const autoOpenPR = raw.autoOpenPR?.trim().toLowerCase() === 'true';
+    if (autoOpenPR && !autoCommit) {
+        console.warn(`[TriggerStore] Warning: trigger "${rawId}" has autoOpenPR: true but autoCommit is not true. ` +
+            `A PR requires a commit -- delivery will be skipped unless autoCommit is also set to true.`);
+    }
+    let pollingSource;
+    if (provider === 'gitlab_poll') {
+        if (!raw.source) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source', triggerId: rawId });
+        }
+        const src = raw.source;
+        const requiredSourceFields = [
+            'baseUrl', 'projectId', 'token', 'events',
+        ];
+        for (const field of requiredSourceFields) {
+            if (!src[field]?.trim()) {
+                return (0, result_js_1.err)({ kind: 'missing_field', field: `source.${field}`, triggerId: rawId });
+            }
+        }
+        const tokenRaw = src.token.trim();
+        const tokenResult = resolveSecret(tokenRaw, rawId, env);
+        if (tokenResult.kind === 'err')
+            return tokenResult;
+        const eventsRaw = src.events.trim();
+        const events = eventsRaw.split(/\s+/).filter(Boolean);
+        if (events.length === 0) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.events (empty)', triggerId: rawId });
+        }
+        const intervalRaw = src.pollIntervalSeconds?.trim();
+        let pollIntervalSeconds = 60;
+        if (intervalRaw) {
+            const asNumber = Number(intervalRaw);
+            if (!Number.isInteger(asNumber) || asNumber <= 0) {
+                return (0, result_js_1.err)({
+                    kind: 'invalid_field_value',
+                    field: `source.pollIntervalSeconds (must be a positive integer, got: ${intervalRaw})`,
+                    triggerId: rawId,
+                });
+            }
+            pollIntervalSeconds = asNumber;
+        }
+        pollingSource = {
+            baseUrl: src.baseUrl.trim(),
+            projectId: src.projectId.trim(),
+            token: tokenResult.value,
+            events,
+            pollIntervalSeconds,
+        };
+    }
+    else if (raw.source) {
+        console.warn(`[TriggerStore] WARNING: trigger '${rawId}' has provider='${provider}' but also ` +
+            `defines a source: block. The source: block is only used for provider='gitlab_poll'. ` +
+            `It will be ignored for this trigger.`);
+    }
+    const trigger = {
+        id: (0, types_js_1.asTriggerId)(rawId),
+        provider,
+        workflowId: raw.workflowId.trim(),
+        workspacePath: resolvedWorkspacePath,
+        goal: raw.goal.trim(),
+        concurrencyMode,
+        ...(hmacSecret !== undefined ? { hmacSecret } : {}),
+        ...(raw.contextMapping !== undefined
+            ? { contextMapping: assembleContextMapping(raw.contextMapping) }
+            : {}),
+        ...(goalTemplate ? { goalTemplate } : {}),
+        ...(referenceUrls !== undefined && referenceUrls.length > 0 ? { referenceUrls } : {}),
+        ...(agentConfig !== undefined ? { agentConfig } : {}),
+        ...(callbackUrl !== undefined ? { callbackUrl } : {}),
+        ...(onComplete !== undefined ? { onComplete } : {}),
+        ...(autoCommit ? { autoCommit } : {}),
+        ...(autoOpenPR ? { autoOpenPR } : {}),
+        ...(pollingSource !== undefined ? { pollingSource } : {}),
+        ...(resolvedWorkspaceName !== undefined ? { workspaceName: resolvedWorkspaceName } : {}),
+        ...(resolvedSoulFile ? { soulFile: resolvedSoulFile } : {}),
+    };
+    return (0, result_js_1.ok)(trigger);
+}
+function loadTriggerConfig(yamlContent, env = process.env, workspaces = {}) {
+    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, workspaces);
+        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, workspaces = {}) {
+    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, workspaces);
+}
+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);
+}