@exaudeus/workrail 3.32.0 → 3.34.0

package/dist/trigger/adapters/gitlab-poller.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollGitLabMRs = pollGitLabMRs;
+const result_js_1 = require("../../runtime/result.js");
+async function pollGitLabMRs(source, updatedAfter, fetchFn = globalThis.fetch) {
+    const encodedProjectId = encodeURIComponent(source.projectId);
+    const baseUrl = source.baseUrl.replace(/\/$/, '');
+    const url = new URL(`${baseUrl}/api/v4/projects/${encodedProjectId}/merge_requests`);
+    url.searchParams.set('state', 'opened');
+    url.searchParams.set('updated_after', updatedAfter);
+    url.searchParams.set('per_page', '100');
+    let response;
+    try {
+        response = await fetchFn(url.toString(), {
+            headers: {
+                'PRIVATE-TOKEN': source.token,
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    catch (e) {
+        return (0, result_js_1.err)({
+            kind: 'network_error',
+            message: e instanceof Error ? e.message : String(e),
+        });
+    }
+    if (!response.ok) {
+        return (0, result_js_1.err)({
+            kind: 'http_error',
+            status: response.status,
+            message: `GitLab API returned HTTP ${response.status}: ${response.statusText}`,
+        });
+    }
+    let raw;
+    try {
+        raw = await response.json();
+    }
+    catch (e) {
+        return (0, result_js_1.err)({
+            kind: 'parse_error',
+            message: `Failed to parse GitLab API response: ${e instanceof Error ? e.message : String(e)}`,
+        });
+    }
+    if (!Array.isArray(raw)) {
+        return (0, result_js_1.err)({
+            kind: 'parse_error',
+            message: `Expected array from GitLab MR API, got: ${typeof raw}`,
+        });
+    }
+    const mrs = [];
+    for (const item of raw) {
+        if (isGitLabMRShape(item)) {
+            mrs.push(item);
+        }
+    }
+    const filtered = applyEventFilter(mrs, source.events);
+    return (0, result_js_1.ok)(filtered);
+}
+function applyEventFilter(mrs, events) {
+    if (events.length === 0)
+        return mrs;
+    const includeOpened = events.includes('merge_request.opened');
+    const includeUpdated = events.includes('merge_request.updated');
+    if (!includeOpened && !includeUpdated) {
+        return mrs;
+    }
+    if (includeUpdated)
+        return mrs;
+    return mrs.filter(mr => mr.state === 'opened');
+}
+function isGitLabMRShape(item) {
+    if (typeof item !== 'object' || item === null)
+        return false;
+    const obj = item;
+    return (typeof obj['id'] === 'number' &&
+        typeof obj['iid'] === 'number' &&
+        typeof obj['title'] === 'string' &&
+        typeof obj['web_url'] === 'string' &&
+        typeof obj['updated_at'] === 'string' &&
+        typeof obj['state'] === 'string');
+}

package/dist/trigger/index.d.ts

@@ -2,4 +2,7 @@ export { startTriggerListener } from './trigger-listener.js';
 export type { TriggerListenerHandle, TriggerListenerError, StartTriggerListenerOptions } from './trigger-listener.js';
 export { loadTriggerConfig, loadTriggerConfigFromFile } from './trigger-store.js';
 export type { TriggerStoreError } from './trigger-store.js';
-export type { TriggerId, TriggerDefinition, TriggerConfig, TriggerSource, WebhookEvent, ContextMapping, ContextMappingEntry, } from './types.js';
+export type { TriggerId, TriggerDefinition, TriggerConfig, TriggerSource, WebhookEvent, ContextMapping, ContextMappingEntry, GitLabPollingSource, GitHubPollingSource, PollingSource, } from './types.js';
+export { PolledEventStore } from './polled-event-store.js';
+export type { PolledEventState, PolledEventStoreError } from './polled-event-store.js';
+export { PollingScheduler } from './polling-scheduler.js';

package/dist/trigger/index.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadTriggerConfigFromFile = exports.loadTriggerConfig = exports.startTriggerListener = void 0;
+exports.PollingScheduler = exports.PolledEventStore = 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; } });
+var polled_event_store_js_1 = require("./polled-event-store.js");
+Object.defineProperty(exports, "PolledEventStore", { enumerable: true, get: function () { return polled_event_store_js_1.PolledEventStore; } });
+var polling_scheduler_js_1 = require("./polling-scheduler.js");
+Object.defineProperty(exports, "PollingScheduler", { enumerable: true, get: function () { return polling_scheduler_js_1.PollingScheduler; } });

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

@@ -0,0 +1,22 @@
+import type { Result } from '../runtime/result.js';
+import type { TriggerId } from './types.js';
+export interface PolledEventState {
+    readonly processedIds: readonly string[];
+    readonly lastPollAt: string;
+}
+export type PolledEventStoreError = {
+    readonly kind: 'io_error';
+    readonly message: string;
+} | {
+    readonly kind: 'write_error';
+    readonly message: string;
+};
+export declare class PolledEventStore {
+    private readonly env;
+    constructor(env?: Record<string, string | undefined>);
+    load(triggerId: TriggerId): Promise<Result<PolledEventState, PolledEventStoreError>>;
+    save(triggerId: TriggerId, state: PolledEventState): Promise<Result<void, PolledEventStoreError>>;
+    filterNew(triggerId: TriggerId, candidateIds: readonly string[]): Promise<Result<string[], PolledEventStoreError>>;
+    record(triggerId: TriggerId, newIds: readonly string[], lastPollAt: string): Promise<Result<void, PolledEventStoreError>>;
+    getLastPollAt(triggerId: TriggerId): Promise<string>;
+}

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

@@ -5,6 +5,7 @@ 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;
@@ -26,6 +27,8 @@ export interface StartTriggerListenerOptions {
     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']
@@ -145,6 +180,10 @@ async function startTriggerListener(ctx, options) {
     const runWorkflowFn = options.runWorkflowFn ?? workflow_runner_js_1.runWorkflow;
     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 } });
             }
         });
@@ -172,9 +213,12 @@ async function startTriggerListener(ctx, options) {
             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()));
+                    });
+                },
             });
         });
     });