@exaudeus/workrail 3.31.1 → 3.33.0

package/dist/trigger/polled-event-store.js

@@ -0,0 +1,173 @@
+"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.PolledEventStore = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_crypto_1 = require("node:crypto");
+const result_js_1 = require("../runtime/result.js");
+const MAX_PROCESSED_IDS = 500;
+function polledEventsDir(env = process.env) {
+    const workrailHome = env['WORKRAIL_HOME'] ?? path.join(os.homedir(), '.workrail');
+    return path.join(workrailHome, 'polled-events');
+}
+function stateFilePath(triggerId, env = process.env) {
+    const safeId = String(triggerId).replace(/[^a-zA-Z0-9_-]/g, '_');
+    return path.join(polledEventsDir(env), `${safeId}.json`);
+}
+class PolledEventStore {
+    constructor(env = process.env) {
+        this.env = env;
+    }
+    async load(triggerId) {
+        const filePath = stateFilePath(triggerId, this.env);
+        let raw;
+        try {
+            raw = await fs.readFile(filePath, 'utf8');
+        }
+        catch (e) {
+            const error = e;
+            if (error.code === 'ENOENT') {
+                return (0, result_js_1.ok)(freshState());
+            }
+            return (0, result_js_1.err)({ kind: 'io_error', message: error.message ?? String(e) });
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (isValidState(parsed)) {
+                return (0, result_js_1.ok)({
+                    processedIds: parsed.processedIds,
+                    lastPollAt: parsed.lastPollAt,
+                });
+            }
+            console.warn(`[PolledEventStore] State file for trigger '${triggerId}' has unexpected schema. ` +
+                `Starting fresh with lastPollAt=now to prevent burst firing.`);
+            return (0, result_js_1.ok)(freshState());
+        }
+        catch {
+            console.warn(`[PolledEventStore] Could not parse state file for trigger '${triggerId}'. ` +
+                `Starting fresh with lastPollAt=now to prevent burst firing.`);
+            return (0, result_js_1.ok)(freshState());
+        }
+    }
+    async save(triggerId, state) {
+        const filePath = stateFilePath(triggerId, this.env);
+        const dir = path.dirname(filePath);
+        try {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        catch (e) {
+            return (0, result_js_1.err)({ kind: 'write_error', message: `Failed to create directory ${dir}: ${String(e)}` });
+        }
+        const pruned = state.processedIds.length > MAX_PROCESSED_IDS
+            ? state.processedIds.slice(state.processedIds.length - MAX_PROCESSED_IDS)
+            : state.processedIds;
+        const serialized = JSON.stringify({ processedIds: pruned, lastPollAt: state.lastPollAt }, null, 2);
+        const tmpPath = `${filePath}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+        try {
+            await fs.writeFile(tmpPath, serialized, 'utf8');
+            const fh = await fs.open(tmpPath, 'r+');
+            try {
+                await fh.sync();
+            }
+            finally {
+                await fh.close();
+            }
+            await fs.rename(tmpPath, filePath);
+            const dirFh = await fs.open(dir, 'r');
+            try {
+                await dirFh.sync();
+            }
+            finally {
+                await dirFh.close();
+            }
+            return (0, result_js_1.ok)(undefined);
+        }
+        catch (e) {
+            await fs.unlink(tmpPath).catch(() => undefined);
+            return (0, result_js_1.err)({ kind: 'write_error', message: `Failed to save state for trigger '${triggerId}': ${String(e)}` });
+        }
+    }
+    async filterNew(triggerId, candidateIds) {
+        if (candidateIds.length === 0)
+            return (0, result_js_1.ok)([]);
+        const stateResult = await this.load(triggerId);
+        if (stateResult.kind === 'err')
+            return stateResult;
+        const processed = new Set(stateResult.value.processedIds);
+        const newIds = candidateIds.filter(id => !processed.has(id));
+        return (0, result_js_1.ok)(newIds);
+    }
+    async record(triggerId, newIds, lastPollAt) {
+        if (newIds.length === 0) {
+            const stateResult = await this.load(triggerId);
+            if (stateResult.kind === 'err')
+                return stateResult;
+            return this.save(triggerId, { ...stateResult.value, lastPollAt });
+        }
+        const stateResult = await this.load(triggerId);
+        if (stateResult.kind === 'err')
+            return stateResult;
+        const existing = stateResult.value.processedIds;
+        const combined = [...existing, ...newIds];
+        return this.save(triggerId, { processedIds: combined, lastPollAt });
+    }
+    async getLastPollAt(triggerId) {
+        const stateResult = await this.load(triggerId);
+        if (stateResult.kind === 'err')
+            return new Date().toISOString();
+        return stateResult.value.lastPollAt;
+    }
+}
+exports.PolledEventStore = PolledEventStore;
+function freshState() {
+    return {
+        processedIds: [],
+        lastPollAt: new Date().toISOString(),
+    };
+}
+function isValidState(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const obj = value;
+    if (!Array.isArray(obj['processedIds']))
+        return false;
+    if (typeof obj['lastPollAt'] !== 'string')
+        return false;
+    if (!obj['processedIds'].every(id => typeof id === 'string'))
+        return false;
+    return true;
+}

package/dist/trigger/polling-scheduler.d.ts

@@ -0,0 +1,20 @@
+import type { TriggerDefinition } from './types.js';
+import type { TriggerRouter } from './trigger-router.js';
+import type { PolledEventStore } from './polled-event-store.js';
+import { type FetchFn } from './adapters/gitlab-poller.js';
+export declare class PollingScheduler {
+    private readonly triggers;
+    private readonly router;
+    private readonly store;
+    private readonly fetchFn?;
+    private readonly intervals;
+    private readonly polling;
+    constructor(triggers: readonly TriggerDefinition[], router: TriggerRouter, store: PolledEventStore, fetchFn?: FetchFn | undefined);
+    start(): void;
+    stop(): void;
+    private runPollCycle;
+    private doPoll;
+    private doPollGitLab;
+    private doPollGitHub;
+    private dispatchAndRecord;
+}

package/dist/trigger/polling-scheduler.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingScheduler = void 0;
+const gitlab_poller_js_1 = require("./adapters/gitlab-poller.js");
+const github_poller_js_1 = require("./adapters/github-poller.js");
+function isPollingTrigger(trigger) {
+    return trigger.pollingSource !== undefined;
+}
+class PollingScheduler {
+    constructor(triggers, router, store, fetchFn) {
+        this.triggers = triggers;
+        this.router = router;
+        this.store = store;
+        this.fetchFn = fetchFn;
+        this.intervals = new Map();
+        this.polling = new Map();
+    }
+    start() {
+        const pollingTriggers = this.triggers.filter(isPollingTrigger);
+        if (pollingTriggers.length === 0) {
+            return;
+        }
+        console.log(`[PollingScheduler] Starting polling for ${pollingTriggers.length} trigger(s)`);
+        for (const trigger of pollingTriggers) {
+            if (this.intervals.has(trigger.id)) {
+                continue;
+            }
+            const intervalMs = trigger.pollingSource.pollIntervalSeconds * 1000;
+            this.polling.set(trigger.id, false);
+            const firstPollTimeout = setTimeout(() => {
+                void this.runPollCycle(trigger);
+            }, 5000);
+            const handle = setInterval(() => {
+                void this.runPollCycle(trigger);
+            }, intervalMs);
+            this.intervals.set(trigger.id, handle);
+            this.intervals.set(`${trigger.id}__first`, firstPollTimeout);
+            console.log(`[PollingScheduler] Started polling trigger '${trigger.id}' ` +
+                `(provider: ${trigger.provider}, interval: ${trigger.pollingSource.pollIntervalSeconds}s)`);
+        }
+    }
+    stop() {
+        for (const [id, handle] of this.intervals) {
+            clearInterval(handle);
+            this.intervals.delete(id);
+        }
+        console.log('[PollingScheduler] All polling loops stopped.');
+    }
+    async runPollCycle(trigger) {
+        const triggerId = trigger.id;
+        if (this.polling.get(triggerId)) {
+            console.warn(`[PollingScheduler] Skipping poll cycle for trigger '${triggerId}' -- ` +
+                `previous cycle is still running. Consider increasing pollIntervalSeconds.`);
+            return;
+        }
+        this.polling.set(triggerId, true);
+        try {
+            await this.doPoll(trigger);
+        }
+        catch (e) {
+            console.warn(`[PollingScheduler] Unexpected error in poll cycle for trigger '${triggerId}':`, e instanceof Error ? e.message : String(e));
+        }
+        finally {
+            this.polling.set(triggerId, false);
+        }
+    }
+    async doPoll(trigger) {
+        const triggerId = trigger.id;
+        const pollStartAt = new Date().toISOString();
+        const lastPollAt = await this.store.getLastPollAt(triggerId);
+        switch (trigger.pollingSource.provider) {
+            case 'gitlab_poll':
+                await this.doPollGitLab(trigger, triggerId, pollStartAt, lastPollAt, trigger.pollingSource);
+                break;
+            case 'github_issues_poll':
+                await this.doPollGitHub(trigger, triggerId, pollStartAt, lastPollAt, trigger.pollingSource, 'issues');
+                break;
+            case 'github_prs_poll':
+                await this.doPollGitHub(trigger, triggerId, pollStartAt, lastPollAt, trigger.pollingSource, 'prs');
+                break;
+            default: {
+                const _exhaustive = trigger.pollingSource;
+                console.warn(`[PollingScheduler] Unknown provider '${String(_exhaustive.provider)}' ` +
+                    `for trigger '${triggerId}'. Skipping cycle.`);
+            }
+        }
+    }
+    async doPollGitLab(trigger, triggerId, pollStartAt, lastPollAt, source) {
+        const pollResult = await (0, gitlab_poller_js_1.pollGitLabMRs)(source, lastPollAt, this.fetchFn);
+        if (pollResult.kind === 'err') {
+            console.warn(`[PollingScheduler] GitLab poll failed for trigger '${triggerId}': ` +
+                `${pollResult.error.kind}: ${pollResult.error.message}. ` +
+                `Skipping this cycle, will retry at next interval.`);
+            return;
+        }
+        const mrs = pollResult.value;
+        await this.dispatchAndRecord(trigger, triggerId, pollStartAt, mrs.map(mr => String(mr.id)), (id) => {
+            const mr = mrs.find(m => String(m.id) === id);
+            return mr ? buildGitLabWorkflowTrigger(trigger, mr) : null;
+        });
+    }
+    async doPollGitHub(trigger, triggerId, pollStartAt, lastPollAt, source, kind) {
+        let pollResult;
+        if (kind === 'issues') {
+            pollResult = await (0, github_poller_js_1.pollGitHubIssues)(source, lastPollAt, this.fetchFn);
+        }
+        else {
+            pollResult = await (0, github_poller_js_1.pollGitHubPRs)(source, lastPollAt, this.fetchFn);
+        }
+        if (pollResult.kind === 'err') {
+            console.warn(`[PollingScheduler] GitHub ${kind} poll failed for trigger '${triggerId}': ` +
+                `${pollResult.error.kind}: ${pollResult.error.message}. ` +
+                `Skipping this cycle, will retry at next interval.`);
+            return;
+        }
+        const items = pollResult.value;
+        await this.dispatchAndRecord(trigger, triggerId, pollStartAt, items.map(item => String(item.id)), (id) => {
+            const item = items.find(i => String(i.id) === id);
+            return item ? buildGitHubWorkflowTrigger(trigger, item) : null;
+        });
+    }
+    async dispatchAndRecord(trigger, triggerId, pollStartAt, candidateIds, buildTrigger) {
+        if (candidateIds.length === 0) {
+            await this.store.record(triggerId, [], pollStartAt);
+            return;
+        }
+        const filterResult = await this.store.filterNew(triggerId, candidateIds);
+        if (filterResult.kind === 'err') {
+            console.warn(`[PollingScheduler] Failed to read event store for trigger '${triggerId}': ` +
+                `${filterResult.error.message}. Skipping dispatch to avoid duplicates.`);
+            return;
+        }
+        const newIds = filterResult.value;
+        if (newIds.length === 0) {
+            await this.store.record(triggerId, [], pollStartAt);
+            return;
+        }
+        for (const newId of newIds) {
+            const workflowTrigger = buildTrigger(newId);
+            if (!workflowTrigger)
+                continue;
+            this.router.dispatch(workflowTrigger);
+        }
+        const recordResult = await this.store.record(triggerId, newIds, pollStartAt);
+        if (recordResult.kind === 'err') {
+            console.warn(`[PollingScheduler] Failed to record processed events for trigger '${triggerId}': ` +
+                `${recordResult.error.message}. Events may be re-dispatched on the next cycle.`);
+        }
+        else {
+            console.log(`[PollingScheduler] Dispatched ${newIds.length} new event(s) for trigger '${triggerId}'`);
+        }
+    }
+}
+exports.PollingScheduler = PollingScheduler;
+function buildGitLabWorkflowTrigger(trigger, mr) {
+    const context = {
+        mrId: mr.id,
+        mrIid: mr.iid,
+        mrTitle: mr.title,
+        mrUrl: mr.web_url,
+        mrUpdatedAt: mr.updated_at,
+        ...(mr.author?.username ? { mrAuthorUsername: mr.author.username } : {}),
+    };
+    const goal = interpolateGoalFromPayload(trigger, {
+        id: mr.id,
+        iid: mr.iid,
+        title: mr.title,
+        web_url: mr.web_url,
+        updated_at: mr.updated_at,
+        state: mr.state,
+        author: mr.author ?? {},
+    });
+    return {
+        workflowId: trigger.workflowId,
+        goal,
+        workspacePath: trigger.workspacePath,
+        context,
+        ...(trigger.referenceUrls !== undefined ? { referenceUrls: trigger.referenceUrls } : {}),
+        ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
+        ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
+    };
+}
+function buildGitHubWorkflowTrigger(trigger, item) {
+    const context = {
+        itemId: item.id,
+        itemNumber: item.number,
+        itemTitle: item.title,
+        itemUrl: item.html_url,
+        itemUpdatedAt: item.updated_at,
+        ...(item.user?.login ? { itemAuthorLogin: item.user.login } : {}),
+    };
+    const goal = interpolateGoalFromPayload(trigger, {
+        id: item.id,
+        number: item.number,
+        title: item.title,
+        html_url: item.html_url,
+        updated_at: item.updated_at,
+        state: item.state,
+        user: item.user ?? {},
+    });
+    return {
+        workflowId: trigger.workflowId,
+        goal,
+        workspacePath: trigger.workspacePath,
+        context,
+        ...(trigger.referenceUrls !== undefined ? { referenceUrls: trigger.referenceUrls } : {}),
+        ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
+        ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
+    };
+}
+function interpolateGoalFromPayload(trigger, payload) {
+    const template = trigger.goalTemplate;
+    if (!template)
+        return trigger.goal;
+    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 trigger.goal;
+        }
+        resolved.set(token, String(value));
+    }
+    return template.replace(/\{\{([^}]+)\}\}/g, (_, token) => resolved.get(token) ?? trigger.goal);
+}
+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('[') || current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}

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

@@ -4,6 +4,8 @@ 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';
+import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
+import type { FetchFn } from './adapters/gitlab-poller.js';
 export type TriggerListenerError = TriggerStoreError | {
     readonly kind: 'port_conflict';
     readonly port: number;
@@ -24,6 +26,9 @@ export interface StartTriggerListenerOptions {
     readonly env?: Record<string, string | undefined>;
     readonly runWorkflowFn?: RunWorkflowFn;
     readonly workspaces?: Readonly<Record<string, WorkspaceConfig>>;
+    readonly emitter?: DaemonEventEmitter;
+    readonly fetchFn?: FetchFn;
+    readonly getWorkflowByIdFn?: (id: string) => Promise<boolean>;
 }
 export declare function createTriggerApp(router: TriggerRouter): express.Application;
 export declare function startTriggerListener(ctx: V2ToolContext, options: StartTriggerListenerOptions): Promise<TriggerListenerHandle | null | {

package/dist/trigger/trigger-listener.js

@@ -46,6 +46,8 @@ 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 polling_scheduler_js_1 = require("./polling-scheduler.js");
+const polled_event_store_js_1 = require("./polled-event-store.js");
 const DEFAULT_TRIGGER_PORT = 3200;
 function createTriggerApp(router) {
     const app = (0, express_1.default)();
@@ -136,6 +138,39 @@ async function startTriggerListener(ctx, options) {
         triggerIndex = indexResult.value;
         console.log(`[TriggerListener] Loaded ${configResult.value.triggers.length} trigger(s) from triggers.yml`);
     }
+    const getWorkflowByIdFn = options.getWorkflowByIdFn
+        ?? (ctx.workflowService
+            ? async (id) => (await ctx.workflowService.getWorkflowById(id)) !== null
+            : undefined);
+    if (getWorkflowByIdFn) {
+        const unknownTriggerIds = [];
+        for (const [triggerId, trigger] of triggerIndex) {
+            let found;
+            try {
+                found = await getWorkflowByIdFn(trigger.workflowId);
+            }
+            catch (e) {
+                found = false;
+                console.warn(`[TriggerListener] Error validating workflowId '${trigger.workflowId}' for trigger '${triggerId}': ` +
+                    (e instanceof Error ? e.message : String(e)));
+            }
+            if (!found) {
+                unknownTriggerIds.push(triggerId);
+                console.warn(`[TriggerListener] Skipping trigger '${triggerId}': workflowId '${trigger.workflowId}' was not found. ` +
+                    `Fix the workflowId in triggers.yml and restart the daemon.`);
+            }
+        }
+        for (const id of unknownTriggerIds) {
+            triggerIndex.delete(id);
+        }
+        if (unknownTriggerIds.length > 0) {
+            console.warn(`[TriggerListener] Skipped ${unknownTriggerIds.length} trigger(s) with unknown workflowId(s). ` +
+                `${triggerIndex.size} trigger(s) will be active.`);
+        }
+    }
+    else {
+        console.log(`[TriggerListener] workflowId validation skipped (no resolver provided).`);
+    }
     const workrailConfig = (0, config_file_js_1.loadWorkrailConfigFile)();
     const maxConcurrencyRaw = workrailConfig.kind === 'ok'
         ? workrailConfig.value['maxConcurrentSessions']
@@ -143,8 +178,12 @@ async function startTriggerListener(ctx, options) {
     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 router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions, options.emitter);
     const app = createTriggerApp(router);
+    const allTriggers = [...triggerIndex.values()];
+    const polledEventStore = new polled_event_store_js_1.PolledEventStore(env);
+    const pollingScheduler = new polling_scheduler_js_1.PollingScheduler(allTriggers, router, polledEventStore, options.fetchFn);
+    pollingScheduler.start();
     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));
     });
@@ -154,9 +193,11 @@ async function startTriggerListener(ctx, options) {
         const server = http.createServer(app);
         server.on('error', (error) => {
             if (error.code === 'EADDRINUSE') {
+                pollingScheduler.stop();
                 resolve({ _kind: 'err', error: { kind: 'port_conflict', port } });
             }
             else {
+                pollingScheduler.stop();
                 resolve({ _kind: 'err', error: { kind: 'io_error', message: error.message } });
             }
         });
@@ -164,12 +205,20 @@ async function startTriggerListener(ctx, options) {
             const addr = server.address();
             const actualPort = (addr && typeof addr === 'object') ? addr.port : port;
             console.log(`[TriggerListener] Webhook server listening on port ${actualPort}`);
+            options.emitter?.emit({
+                kind: 'daemon_started',
+                port: actualPort,
+                workspacePath: options.workspacePath,
+            });
             resolve({
                 port: actualPort,
                 router,
-                stop: () => new Promise((res, rej) => {
-                    server.close((e) => (e ? rej(e) : res()));
-                }),
+                stop: async () => {
+                    pollingScheduler.stop();
+                    return new Promise((res, rej) => {
+                        server.close((e) => (e ? rej(e) : res()));
+                    });
+                },
             });
         });
     });

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

@@ -2,6 +2,7 @@ import type { WorkflowTrigger, WorkflowRunResult } from '../daemon/workflow-runn
 import type { V2ToolContext } from '../mcp/types.js';
 import type { TriggerDefinition, WebhookEvent } from './types.js';
 import type { ExecFn } from './delivery-action.js';
+import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
 export type RouteError = {
     readonly kind: 'not_found';
     readonly triggerId: string;
@@ -18,7 +19,7 @@ export type RouteResult = {
     readonly _tag: 'error';
     readonly error: RouteError;
 };
-export type RunWorkflowFn = (trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string) => Promise<WorkflowRunResult>;
+export type RunWorkflowFn = (trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: import('../v2/infra/in-memory/daemon-registry/index.js').DaemonRegistry, emitter?: DaemonEventEmitter) => 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;
@@ -29,7 +30,8 @@ export declare class TriggerRouter {
     private readonly execFn;
     private readonly semaphore;
     private readonly _maxConcurrentSessions;
-    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number);
+    private readonly emitter;
+    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number, emitter?: DaemonEventEmitter);
     get activeSessions(): number;
     get maxConcurrentSessions(): number;
     route(event: WebhookEvent): RouteResult;

package/dist/trigger/trigger-router.js

@@ -182,13 +182,14 @@ class Semaphore {
 }
 const DEFAULT_MAX_CONCURRENT_SESSIONS = 3;
 class TriggerRouter {
-    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions) {
+    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions, emitter) {
         this.index = index;
         this.ctx = ctx;
         this.apiKey = apiKey;
         this.runWorkflowFn = runWorkflowFn;
         this.queue = new index_js_1.KeyedAsyncQueue();
         this.execFn = execFn ?? execFileAsync;
+        this.emitter = emitter;
         const requested = maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
         const cap = Number.isNaN(requested) ? DEFAULT_MAX_CONCURRENT_SESSIONS : requested;
         if (cap < 1) {
@@ -243,10 +244,12 @@ class TriggerRouter {
             ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
             ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
         };
+        this.emitter?.emit({ kind: 'trigger_fired', triggerId: trigger.id, workflowId: trigger.workflowId });
         const queueKey = trigger.concurrencyMode === 'parallel'
             ? `${trigger.id}:${crypto.randomUUID()}`
             : trigger.id;
         void this.queue.enqueue(queueKey, async () => {
+            this.emitter?.emit({ kind: 'session_queued', triggerId: trigger.id, workflowId: trigger.workflowId });
             if (this.semaphore.activeCount >= this._maxConcurrentSessions) {
                 console.warn(`[TriggerRouter] Concurrency limit reached ` +
                     `(${this.semaphore.activeCount}/${this._maxConcurrentSessions} active): ` +
@@ -255,7 +258,7 @@ class TriggerRouter {
             await this.semaphore.acquire();
             let result;
             try {
-                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey, undefined, this.emitter);
             }
             finally {
                 this.semaphore.release();
@@ -263,7 +266,7 @@ class TriggerRouter {
             const originalTag = result._tag;
             const originalResult = result;
             if (trigger.callbackUrl) {
-                const deliveryResult = await (0, delivery_client_js_1.post)(trigger.callbackUrl, result);
+                const deliveryResult = await (0, delivery_client_js_1.post)(trigger.callbackUrl, result, this.emitter);
                 if (deliveryResult.kind === 'err') {
                     const deliveryError = deliveryResult.error.kind === 'http_error'
                         ? `HTTP ${deliveryResult.error.status}: ${deliveryResult.error.body}`
@@ -312,7 +315,7 @@ class TriggerRouter {
             await this.semaphore.acquire();
             let result;
             try {
-                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey, undefined, this.emitter);
             }
             finally {
                 this.semaphore.release();