@exaudeus/workrail 3.24.4 → 3.26.0

package/dist/trigger/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTriggerConfigFromFile = exports.loadTriggerConfig = exports.startTriggerListener = void 0;
+var trigger_listener_js_1 = require("./trigger-listener.js");
+Object.defineProperty(exports, "startTriggerListener", { enumerable: true, get: function () { return trigger_listener_js_1.startTriggerListener; } });
+var trigger_store_js_1 = require("./trigger-store.js");
+Object.defineProperty(exports, "loadTriggerConfig", { enumerable: true, get: function () { return trigger_store_js_1.loadTriggerConfig; } });
+Object.defineProperty(exports, "loadTriggerConfigFromFile", { enumerable: true, get: function () { return trigger_store_js_1.loadTriggerConfigFromFile; } });

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

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+import express from 'express';
+import type { V2ToolContext } from '../mcp/types.js';
+import type { TriggerStoreError } from './trigger-store.js';
+import { TriggerRouter, type RunWorkflowFn } from './trigger-router.js';
+import type { WorkspaceConfig } from './types.js';
+export type TriggerListenerError = TriggerStoreError | {
+    readonly kind: 'port_conflict';
+    readonly port: number;
+} | {
+    readonly kind: 'feature_disabled';
+} | {
+    readonly kind: 'missing_api_key';
+};
+export interface TriggerListenerHandle {
+    readonly port: number;
+    readonly router: TriggerRouter;
+    stop(): Promise<void>;
+}
+export interface StartTriggerListenerOptions {
+    readonly workspacePath: string;
+    readonly apiKey?: string;
+    readonly port?: number;
+    readonly env?: Record<string, string | undefined>;
+    readonly runWorkflowFn?: RunWorkflowFn;
+    readonly workspaces?: Readonly<Record<string, WorkspaceConfig>>;
+}
+export declare function createTriggerApp(router: TriggerRouter): express.Application;
+export declare function startTriggerListener(ctx: V2ToolContext, options: StartTriggerListenerOptions): Promise<TriggerListenerHandle | null | {
+    readonly _kind: 'err';
+    readonly error: TriggerListenerError;
+}>;

package/dist/trigger/trigger-listener.js

@@ -0,0 +1,176 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTriggerApp = createTriggerApp;
+exports.startTriggerListener = startTriggerListener;
+require("reflect-metadata");
+const express_1 = __importDefault(require("express"));
+const http = __importStar(require("node:http"));
+const trigger_store_js_1 = require("./trigger-store.js");
+const trigger_router_js_1 = require("./trigger-router.js");
+const config_file_js_1 = require("../config/config-file.js");
+const workflow_runner_js_1 = require("../daemon/workflow-runner.js");
+const types_js_1 = require("./types.js");
+const DEFAULT_TRIGGER_PORT = 3200;
+function createTriggerApp(router) {
+    const app = (0, express_1.default)();
+    app.use('/webhook', express_1.default.raw({ type: 'application/json', limit: '1mb' }));
+    app.get('/health', (_req, res) => {
+        res.status(200).json({ status: 'ok' });
+    });
+    app.post('/webhook/:triggerId', (req, res) => {
+        const triggerId = (0, types_js_1.asTriggerId)(req.params['triggerId'] ?? '');
+        if (!triggerId) {
+            res.status(400).json({ error: 'Missing triggerId' });
+            return;
+        }
+        const rawBody = Buffer.isBuffer(req.body) ? req.body : Buffer.from('');
+        let payload;
+        try {
+            const bodyStr = rawBody.toString('utf8');
+            if (bodyStr) {
+                payload = JSON.parse(bodyStr);
+                if (typeof payload !== 'object' || payload === null || Array.isArray(payload)) {
+                    res.status(400).json({ error: 'Payload must be a JSON object' });
+                    return;
+                }
+            }
+            else {
+                payload = {};
+            }
+        }
+        catch {
+            res.status(400).json({ error: 'Invalid JSON body' });
+            return;
+        }
+        const signature = req.headers['x-workrail-signature'];
+        const event = {
+            triggerId,
+            rawBody,
+            payload,
+            ...(signature !== undefined ? { signature } : {}),
+        };
+        const result = router.route(event);
+        if (result._tag === 'error') {
+            switch (result.error.kind) {
+                case 'not_found':
+                    res.status(404).json({ error: `Unknown trigger: ${result.error.triggerId}` });
+                    return;
+                case 'hmac_invalid':
+                    res.status(401).json({ error: 'Invalid signature' });
+                    return;
+                case 'payload_error':
+                    res.status(400).json({ error: result.error.message });
+                    return;
+            }
+        }
+        res.status(202).json({ status: 'accepted', triggerId });
+    });
+    return app;
+}
+async function startTriggerListener(ctx, options) {
+    const env = options.env ?? process.env;
+    if (env['WORKRAIL_TRIGGERS_ENABLED'] !== 'true') {
+        return null;
+    }
+    const apiKey = options.apiKey ?? env['ANTHROPIC_API_KEY'];
+    if (!apiKey) {
+        return { _kind: 'err', error: { kind: 'missing_api_key' } };
+    }
+    const workspaceResult = (0, config_file_js_1.loadWorkspacesFromConfigFile)();
+    const loadedWorkspaces = workspaceResult.kind === 'ok' ? workspaceResult.value : {};
+    const workspaces = options.workspaces ?? loadedWorkspaces;
+    const configResult = await (0, trigger_store_js_1.loadTriggerConfigFromFile)(options.workspacePath, env, workspaces);
+    let triggerIndex;
+    if (configResult.kind === 'err') {
+        if (configResult.error.kind === 'file_not_found') {
+            console.warn(`[TriggerListener] triggers.yml not found at ${options.workspacePath}. ` +
+                `Listener will start with 0 triggers. ` +
+                `Create triggers.yml in that directory to configure triggers.`);
+            triggerIndex = new Map();
+        }
+        else {
+            return { _kind: 'err', error: configResult.error };
+        }
+    }
+    else {
+        const indexResult = (0, trigger_store_js_1.buildTriggerIndex)(configResult.value);
+        if (indexResult.kind === 'err') {
+            return { _kind: 'err', error: indexResult.error };
+        }
+        triggerIndex = indexResult.value;
+        console.log(`[TriggerListener] Loaded ${configResult.value.triggers.length} trigger(s) from triggers.yml`);
+    }
+    const workrailConfig = (0, config_file_js_1.loadWorkrailConfigFile)();
+    const maxConcurrencyRaw = workrailConfig.kind === 'ok'
+        ? workrailConfig.value['maxConcurrentSessions']
+        : undefined;
+    const parsed = parseInt(maxConcurrencyRaw ?? '', 10);
+    const maxConcurrentSessions = !isNaN(parsed) ? parsed : undefined;
+    const runWorkflowFn = options.runWorkflowFn ?? workflow_runner_js_1.runWorkflow;
+    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions);
+    const app = createTriggerApp(router);
+    await (0, workflow_runner_js_1.runStartupRecovery)().catch((err) => {
+        console.warn('[TriggerListener] Startup recovery encountered an unexpected error:', err instanceof Error ? err.message : String(err));
+    });
+    const portEnv = env['WORKRAIL_TRIGGER_PORT'];
+    const port = options.port ?? (portEnv ? parseInt(portEnv, 10) : DEFAULT_TRIGGER_PORT);
+    return new Promise((resolve) => {
+        const server = http.createServer(app);
+        server.on('error', (error) => {
+            if (error.code === 'EADDRINUSE') {
+                resolve({ _kind: 'err', error: { kind: 'port_conflict', port } });
+            }
+            else {
+                resolve({ _kind: 'err', error: { kind: 'io_error', message: error.message } });
+            }
+        });
+        server.listen(port, '127.0.0.1', () => {
+            const addr = server.address();
+            const actualPort = (addr && typeof addr === 'object') ? addr.port : port;
+            console.log(`[TriggerListener] Webhook server listening on port ${actualPort}`);
+            resolve({
+                port: actualPort,
+                router,
+                stop: () => new Promise((res, rej) => {
+                    server.close((e) => (e ? rej(e) : res()));
+                }),
+            });
+        });
+    });
+}

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

@@ -0,0 +1,38 @@
+import type { WorkflowTrigger, WorkflowRunResult } from '../daemon/workflow-runner.js';
+import type { V2ToolContext } from '../mcp/types.js';
+import type { TriggerDefinition, WebhookEvent } from './types.js';
+import type { ExecFn } from './delivery-action.js';
+export type RouteError = {
+    readonly kind: 'not_found';
+    readonly triggerId: string;
+} | {
+    readonly kind: 'hmac_invalid';
+} | {
+    readonly kind: 'payload_error';
+    readonly message: string;
+};
+export type RouteResult = {
+    readonly _tag: 'enqueued';
+    readonly triggerId: string;
+} | {
+    readonly _tag: 'error';
+    readonly error: RouteError;
+};
+export type RunWorkflowFn = (trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string) => Promise<WorkflowRunResult>;
+export declare function interpolateGoalTemplate(template: string, staticGoal: string, payload: Readonly<Record<string, unknown>>, triggerId: string): string;
+export declare class TriggerRouter {
+    private readonly index;
+    private readonly ctx;
+    private readonly apiKey;
+    private readonly runWorkflowFn;
+    private readonly queue;
+    private readonly execFn;
+    private readonly semaphore;
+    private readonly _maxConcurrentSessions;
+    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number);
+    get activeSessions(): number;
+    get maxConcurrentSessions(): number;
+    route(event: WebhookEvent): RouteResult;
+    dispatch(workflowTrigger: WorkflowTrigger): string;
+    listTriggers(): readonly TriggerDefinition[];
+}

package/dist/trigger/trigger-router.js

@@ -0,0 +1,343 @@
+"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 node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const index_js_1 = require("../v2/infra/in-memory/keyed-async-queue/index.js");
+const delivery_client_js_1 = require("./delivery-client.js");
+const delivery_action_js_1 = require("./delivery-action.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function interpolateGoalTemplate(template, staticGoal, payload, triggerId) {
+    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) {
+            console.warn(`[TriggerRouter] goalTemplate variable '${token}' not found in payload ` +
+                `for trigger '${triggerId}' (template: '${template}'). Falling back to static goal.`);
+            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'));
+}
+async function maybeRunDelivery(triggerId, trigger, result, execFn) {
+    if (result._tag !== 'success')
+        return;
+    if (result.lastStepNotes === undefined) {
+        if (trigger.autoCommit === true) {
+            console.warn(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} -- ` +
+                `lastStepNotes is absent (agent did not provide notes on the final step). ` +
+                `Ensure the workflow produces a JSON handoff block in its final step notes.`);
+        }
+        return;
+    }
+    if (trigger.autoCommit !== true)
+        return;
+    const parseResult = (0, delivery_action_js_1.parseHandoffArtifact)(result.lastStepNotes);
+    if (parseResult.kind === 'err') {
+        console.warn(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} -- ` +
+            `handoff artifact not parseable: ${parseResult.error}. ` +
+            `Ensure the workflow's final step produces a JSON block with commitType, filesChanged, etc.`);
+        return;
+    }
+    const deliveryResult = await (0, delivery_action_js_1.runDelivery)(parseResult.value, trigger.workspacePath, { autoCommit: trigger.autoCommit, autoOpenPR: trigger.autoOpenPR }, execFn);
+    switch (deliveryResult._tag) {
+        case 'committed':
+            console.log(`[TriggerRouter] Delivery committed: triggerId=${triggerId} sha=${deliveryResult.sha}`);
+            break;
+        case 'pr_opened':
+            console.log(`[TriggerRouter] Delivery PR opened: triggerId=${triggerId} url=${deliveryResult.url}`);
+            break;
+        case 'skipped':
+            console.log(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} reason=${deliveryResult.reason}`);
+            break;
+        case 'error':
+            console.warn(`[TriggerRouter] Delivery error: triggerId=${triggerId} phase=${deliveryResult.phase} ` +
+                `details=${deliveryResult.details}`);
+            break;
+    }
+}
+class Semaphore {
+    constructor(max) {
+        this.max = max;
+        this.active = 0;
+        this.waiters = [];
+    }
+    acquire() {
+        if (this.active < this.max) {
+            this.active++;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    release() {
+        const next = this.waiters.shift();
+        if (next !== undefined) {
+            next();
+        }
+        else {
+            this.active--;
+        }
+    }
+    get activeCount() {
+        return this.active;
+    }
+}
+const DEFAULT_MAX_CONCURRENT_SESSIONS = 3;
+class TriggerRouter {
+    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions) {
+        this.index = index;
+        this.ctx = ctx;
+        this.apiKey = apiKey;
+        this.runWorkflowFn = runWorkflowFn;
+        this.queue = new index_js_1.KeyedAsyncQueue();
+        this.execFn = execFn ?? execFileAsync;
+        const requested = maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
+        const cap = Number.isNaN(requested) ? DEFAULT_MAX_CONCURRENT_SESSIONS : requested;
+        if (cap < 1) {
+            console.warn(`[TriggerRouter] maxConcurrentSessions must be >= 1; received ${cap}, clamping to 1.`);
+            this._maxConcurrentSessions = 1;
+        }
+        else {
+            this._maxConcurrentSessions = cap;
+        }
+        this.semaphore = new Semaphore(this._maxConcurrentSessions);
+        console.log(`[TriggerRouter] maxConcurrentSessions=${this._maxConcurrentSessions}`);
+    }
+    get activeSessions() {
+        return this.semaphore.activeCount;
+    }
+    get maxConcurrentSessions() {
+        return this._maxConcurrentSessions;
+    }
+    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.id)
+            : 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 } : {}),
+            ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
+        };
+        const queueKey = trigger.concurrencyMode === 'parallel'
+            ? `${trigger.id}:${crypto.randomUUID()}`
+            : trigger.id;
+        void this.queue.enqueue(queueKey, async () => {
+            if (this.semaphore.activeCount >= this._maxConcurrentSessions) {
+                console.warn(`[TriggerRouter] Concurrency limit reached ` +
+                    `(${this.semaphore.activeCount}/${this._maxConcurrentSessions} active): ` +
+                    `queuing dispatch for triggerId=${trigger.id}`);
+            }
+            await this.semaphore.acquire();
+            let result;
+            try {
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+            }
+            finally {
+                this.semaphore.release();
+            }
+            const originalTag = result._tag;
+            const originalResult = result;
+            if (trigger.callbackUrl) {
+                const deliveryResult = await (0, delivery_client_js_1.post)(trigger.callbackUrl, result);
+                if (deliveryResult.kind === 'err') {
+                    const deliveryError = deliveryResult.error.kind === 'http_error'
+                        ? `HTTP ${deliveryResult.error.status}: ${deliveryResult.error.body}`
+                        : deliveryResult.error.message;
+                    console.error(`[TriggerRouter] Delivery failed: triggerId=${trigger.id} ` +
+                        `callbackUrl=${trigger.callbackUrl} error=${deliveryError}`);
+                    const deliveryFailed = {
+                        _tag: 'delivery_failed',
+                        workflowId: trigger.workflowId,
+                        stopReason: result.stopReason,
+                        deliveryError,
+                    };
+                    result = deliveryFailed;
+                }
+            }
+            if (result._tag === 'success') {
+                console.log(`[TriggerRouter] Workflow completed: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} stopReason=${result.stopReason}`);
+            }
+            else if (result._tag === 'delivery_failed') {
+                const outcomeLabel = originalTag === 'success'
+                    ? 'Workflow succeeded but delivery failed'
+                    : 'Workflow failed and delivery also failed';
+                console.log(`[TriggerRouter] ${outcomeLabel}: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} stopReason=${result.stopReason}`);
+            }
+            else if (result._tag === 'timeout') {
+                console.log(`[TriggerRouter] Workflow timed out: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} reason=${result.reason} message=${result.message}`);
+            }
+            else {
+                console.log(`[TriggerRouter] Workflow failed: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} error=${result.message} stopReason=${result.stopReason}`);
+            }
+            await maybeRunDelivery(trigger.id, trigger, originalResult, this.execFn);
+        });
+        return { _tag: 'enqueued', triggerId: trigger.id };
+    }
+    dispatch(workflowTrigger) {
+        void this.queue.enqueue(workflowTrigger.workflowId, async () => {
+            if (this.semaphore.activeCount >= this._maxConcurrentSessions) {
+                console.warn(`[TriggerRouter] Concurrency limit reached ` +
+                    `(${this.semaphore.activeCount}/${this._maxConcurrentSessions} active): ` +
+                    `queuing dispatch for workflowId=${workflowTrigger.workflowId}`);
+            }
+            await this.semaphore.acquire();
+            let result;
+            try {
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+            }
+            finally {
+                this.semaphore.release();
+            }
+            if (result._tag === 'success') {
+                console.log(`[TriggerRouter] Dispatch completed: workflowId=${workflowTrigger.workflowId} ` +
+                    `stopReason=${result.stopReason}`);
+            }
+            else if (result._tag === 'delivery_failed') {
+                console.log(`[TriggerRouter] Dispatch delivery failed: workflowId=${workflowTrigger.workflowId} ` +
+                    `stopReason=${result.stopReason} deliveryError=${result.deliveryError}`);
+            }
+            else if (result._tag === 'timeout') {
+                console.log(`[TriggerRouter] Dispatch timed out: workflowId=${workflowTrigger.workflowId} ` +
+                    `reason=${result.reason} message=${result.message}`);
+            }
+            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,39 @@
+import type { Result } from '../runtime/result.js';
+import { type TriggerConfig, type TriggerDefinition, type WorkspaceConfig } 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: 'invalid_field_value';
+    readonly field: string;
+    readonly triggerId: string;
+} | {
+    readonly kind: 'unknown_provider';
+    readonly provider: string;
+    readonly triggerId: string;
+} | {
+    readonly kind: 'unknown_workspace';
+    readonly workspaceName: 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>, workspaces?: Readonly<Record<string, WorkspaceConfig>>): Result<TriggerConfig, TriggerStoreError>;
+export declare function loadTriggerConfigFromFile(workspacePath: string, env?: Record<string, string | undefined>, workspaces?: Readonly<Record<string, WorkspaceConfig>>): Promise<Result<TriggerConfig, TriggerStoreError>>;
+export declare function buildTriggerIndex(config: TriggerConfig): Result<Map<string, TriggerDefinition>, TriggerStoreError>;