@exaudeus/workrail 3.31.1 → 3.33.0

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;
 }