@exaudeus/workrail 3.32.0 → 3.33.0

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()));
+                    });
+                },
             });
         });
     });

package/dist/trigger/trigger-store.js

@@ -41,7 +41,7 @@ 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']);
+const SUPPORTED_PROVIDERS = new Set(['generic', 'gitlab_poll', 'github_issues_poll', 'github_prs_poll']);
 function unquoteYamlScalar(raw) {
     const s = raw.trim();
     if ((s.startsWith('"') && s.endsWith('"')) ||
@@ -304,6 +304,18 @@ function parseTriggersYaml(content) {
                             case 'projectId':
                                 source.projectId = srcValueResult.value;
                                 break;
+                            case 'repo':
+                                source.repo = srcValueResult.value;
+                                break;
+                            case 'excludeAuthors':
+                                source.excludeAuthors = srcValueResult.value;
+                                break;
+                            case 'notLabels':
+                                source.notLabels = srcValueResult.value;
+                                break;
+                            case 'labelFilter':
+                                source.labelFilter = srcValueResult.value;
+                                break;
                             case 'token':
                                 source.token = srcValueResult.value;
                                 break;
@@ -577,54 +589,123 @@ function validateAndResolveTrigger(raw, env, workspaces = {}) {
         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.`);
     }
+    function parsePollIntervalSeconds(raw2, triggerId2) {
+        const intervalRaw = raw2.pollIntervalSeconds?.trim();
+        if (!intervalRaw)
+            return (0, result_js_1.ok)(60);
+        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: triggerId2,
+            });
+        }
+        return (0, result_js_1.ok)(asNumber);
+    }
     let pollingSource;
-    if (provider === 'gitlab_poll') {
+    const isPollingProvider = provider === 'gitlab_poll' ||
+        provider === 'github_issues_poll' ||
+        provider === 'github_prs_poll';
+    if (isPollingProvider) {
         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 });
-            }
+        if (!src.token?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.token', triggerId: rawId });
         }
-        const tokenRaw = src.token.trim();
-        const tokenResult = resolveSecret(tokenRaw, rawId, env);
+        const tokenResult = resolveSecret(src.token.trim(), rawId, env);
         if (tokenResult.kind === 'err')
             return tokenResult;
-        const eventsRaw = src.events.trim();
-        const events = eventsRaw.split(/\s+/).filter(Boolean);
+        if (!src.events?.trim()) {
+            return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.events', triggerId: rawId });
+        }
+        const events = src.events.trim().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,
-                });
+        const intervalResult = parsePollIntervalSeconds(src, rawId);
+        if (intervalResult.kind === 'err')
+            return intervalResult;
+        const pollIntervalSeconds = intervalResult.value;
+        if (provider === 'gitlab_poll') {
+            if (!src.baseUrl?.trim()) {
+                return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.baseUrl', triggerId: rawId });
+            }
+            if (!src.projectId?.trim()) {
+                return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.projectId', triggerId: rawId });
+            }
+            const KNOWN_MR_EVENT_TYPES = new Set([
+                'merge_request.opened',
+                'merge_request.updated',
+                'merge_request.merged',
+                'merge_request.closed',
+            ]);
+            for (const event of events) {
+                if (!KNOWN_MR_EVENT_TYPES.has(event)) {
+                    console.warn(`[TriggerStore] Unknown polling event type '${event}' for trigger '${rawId}' -- ` +
+                        `will match all open MRs as fallback`);
+                }
+                else if (event === 'merge_request.merged' || event === 'merge_request.closed') {
+                    console.warn(`[TriggerStore] Event type '${event}' for trigger '${rawId}' cannot be observed ` +
+                        `with state=opened polling (GitLab only returns open MRs). ` +
+                        `Use a webhook trigger for merge/close events.`);
+                }
+            }
+            pollingSource = {
+                provider: 'gitlab_poll',
+                baseUrl: src.baseUrl.trim(),
+                projectId: src.projectId.trim(),
+                token: tokenResult.value,
+                events,
+                pollIntervalSeconds,
+            };
+        }
+        else {
+            if (!src.repo?.trim()) {
+                return (0, result_js_1.err)({ kind: 'missing_field', field: 'source.repo', triggerId: rawId });
+            }
+            const KNOWN_GITHUB_ISSUE_EVENTS = new Set(['issues.opened', 'issues.updated']);
+            const KNOWN_GITHUB_PR_EVENTS = new Set(['pull_request.opened', 'pull_request.updated']);
+            const knownEvents = provider === 'github_issues_poll' ? KNOWN_GITHUB_ISSUE_EVENTS : KNOWN_GITHUB_PR_EVENTS;
+            for (const event of events) {
+                if (!knownEvents.has(event)) {
+                    console.warn(`[TriggerStore] Unknown GitHub polling event type '${event}' for trigger '${rawId}' -- ` +
+                        `will match all items as fallback`);
+                }
             }
-            pollIntervalSeconds = asNumber;
+            const excludeAuthors = src.excludeAuthors?.trim()
+                ? src.excludeAuthors.trim().split(/\s+/).filter(Boolean)
+                : [];
+            const notLabels = src.notLabels?.trim()
+                ? src.notLabels.trim().split(/\s+/).filter(Boolean)
+                : [];
+            const labelFilter = src.labelFilter?.trim()
+                ? src.labelFilter.trim().split(/\s+/).filter(Boolean)
+                : [];
+            if (excludeAuthors.length === 0) {
+                console.warn(`[TriggerStore] WARNING: trigger '${rawId}' has provider='${provider}' but ` +
+                    `excludeAuthors is not set. If WorkTrain creates issues/PRs under a bot account, ` +
+                    `omitting excludeAuthors will cause infinite self-review loops. ` +
+                    `Set excludeAuthors to your WorkTrain bot account login (e.g. "worktrain-bot").`);
+            }
+            pollingSource = {
+                provider: provider,
+                repo: src.repo.trim(),
+                token: tokenResult.value,
+                events,
+                pollIntervalSeconds,
+                excludeAuthors,
+                notLabels,
+                labelFilter,
+            };
         }
-        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.`);
+            `defines a source: block. The source: block is only used for polling providers ` +
+            `(gitlab_poll, github_issues_poll, github_prs_poll). It will be ignored for this trigger.`);
     }
     const trigger = {
         id: (0, types_js_1.asTriggerId)(rawId),

package/dist/trigger/types.d.ts

@@ -25,6 +25,22 @@ export interface GitLabPollingSource {
     readonly events: readonly string[];
     readonly pollIntervalSeconds: number;
 }
+export interface GitHubPollingSource {
+    readonly repo: string;
+    readonly token: string;
+    readonly events: readonly string[];
+    readonly pollIntervalSeconds: number;
+    readonly excludeAuthors: readonly string[];
+    readonly notLabels: readonly string[];
+    readonly labelFilter: readonly string[];
+}
+export type PollingSource = (GitLabPollingSource & {
+    readonly provider: 'gitlab_poll';
+}) | (GitHubPollingSource & {
+    readonly provider: 'github_issues_poll';
+}) | (GitHubPollingSource & {
+    readonly provider: 'github_prs_poll';
+});
 export interface TriggerDefinition {
     readonly id: TriggerId;
     readonly provider: string;
@@ -49,7 +65,7 @@ export interface TriggerDefinition {
         readonly workflowId?: string;
         readonly goal?: string;
     };
-    readonly pollingSource?: GitLabPollingSource;
+    readonly pollingSource?: PollingSource;
     readonly workspaceName?: WorkspaceName;
     readonly soulFile?: string;
 }