@exaudeus/workrail 3.32.0 → 3.33.0

package/dist/mcp/v2/tools.d.ts

@@ -164,18 +164,18 @@ export declare const V2ResumeSessionInput: z.ZodObject<{
     sameWorkspaceOnly: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     workspacePath: string;
-    query?: string | undefined;
-    runId?: string | undefined;
     sessionId?: string | undefined;
+    runId?: string | undefined;
     gitBranch?: string | undefined;
+    query?: string | undefined;
     gitHeadSha?: string | undefined;
     sameWorkspaceOnly?: boolean | undefined;
 }, {
     workspacePath: string;
-    query?: string | undefined;
-    runId?: string | undefined;
     sessionId?: string | undefined;
+    runId?: string | undefined;
     gitBranch?: string | undefined;
+    query?: string | undefined;
     gitHeadSha?: string | undefined;
     sameWorkspaceOnly?: boolean | undefined;
 }>;

package/dist/trigger/adapters/github-poller.d.ts

@@ -0,0 +1,44 @@
+import type { GitHubPollingSource } from '../types.js';
+import type { Result } from '../../runtime/result.js';
+export interface GitHubLabel {
+    readonly name: string;
+}
+export interface GitHubIssue {
+    readonly id: number;
+    readonly number: number;
+    readonly title: string;
+    readonly html_url: string;
+    readonly updated_at: string;
+    readonly state: string;
+    readonly user?: {
+        readonly login?: string;
+    };
+    readonly labels?: readonly GitHubLabel[];
+}
+export interface GitHubPR {
+    readonly id: number;
+    readonly number: number;
+    readonly title: string;
+    readonly html_url: string;
+    readonly updated_at: string;
+    readonly state: string;
+    readonly user?: {
+        readonly login?: string;
+    };
+    readonly draft?: boolean;
+    readonly labels?: readonly GitHubLabel[];
+}
+export type GitHubPollError = {
+    readonly kind: 'http_error';
+    readonly status: number;
+    readonly message: string;
+} | {
+    readonly kind: 'network_error';
+    readonly message: string;
+} | {
+    readonly kind: 'parse_error';
+    readonly message: string;
+};
+export type FetchFn = (url: string, init: RequestInit) => Promise<Response>;
+export declare function pollGitHubIssues(source: GitHubPollingSource, since: string, fetchFn?: FetchFn): Promise<Result<GitHubIssue[], GitHubPollError>>;
+export declare function pollGitHubPRs(source: GitHubPollingSource, since: string, fetchFn?: FetchFn): Promise<Result<GitHubPR[], GitHubPollError>>;

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

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollGitHubIssues = pollGitHubIssues;
+exports.pollGitHubPRs = pollGitHubPRs;
+const result_js_1 = require("../../runtime/result.js");
+function checkRateLimit(response) {
+    const remainingHeader = response.headers.get('X-RateLimit-Remaining');
+    const resetHeader = response.headers.get('X-RateLimit-Reset');
+    if (remainingHeader === null)
+        return true;
+    const remaining = parseInt(remainingHeader, 10);
+    if (isNaN(remaining) || remaining >= 100)
+        return true;
+    const resetTs = parseInt(resetHeader ?? '0', 10);
+    const resetAt = resetTs > 0 ? new Date(resetTs * 1000).toISOString() : 'unknown';
+    console.warn(`[GitHubPoller] Rate limit low: remaining=${remaining}, resets at ${resetAt}. ` +
+        `Skipping poll cycle to avoid exhaustion.`);
+    return false;
+}
+async function pollGitHubIssues(source, since, fetchFn = globalThis.fetch) {
+    const [owner, repo] = source.repo.split('/');
+    const url = new URL(`https://api.github.com/repos/${owner}/${repo}/issues`);
+    url.searchParams.set('state', 'open');
+    url.searchParams.set('since', since);
+    url.searchParams.set('sort', 'updated');
+    url.searchParams.set('direction', 'desc');
+    url.searchParams.set('per_page', '100');
+    if (source.labelFilter.length > 0) {
+        url.searchParams.set('labels', source.labelFilter.join(','));
+    }
+    let response;
+    try {
+        response = await fetchFn(url.toString(), {
+            headers: {
+                'Authorization': `Bearer ${source.token}`,
+                'Accept': 'application/vnd.github+json',
+                'X-GitHub-Api-Version': '2022-11-28',
+            },
+        });
+    }
+    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: `GitHub API returned HTTP ${response.status}: ${response.statusText}`,
+        });
+    }
+    if (!checkRateLimit(response)) {
+        return (0, result_js_1.ok)([]);
+    }
+    let raw;
+    try {
+        raw = await response.json();
+    }
+    catch (e) {
+        return (0, result_js_1.err)({
+            kind: 'parse_error',
+            message: `Failed to parse GitHub Issues 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 GitHub Issues API, got: ${typeof raw}`,
+        });
+    }
+    const issues = [];
+    for (const item of raw) {
+        if (isGitHubIssueShape(item)) {
+            issues.push(item);
+        }
+    }
+    return (0, result_js_1.ok)(applyIssueFilters(issues, source));
+}
+async function pollGitHubPRs(source, since, fetchFn = globalThis.fetch) {
+    const [owner, repo] = source.repo.split('/');
+    const url = new URL(`https://api.github.com/repos/${owner}/${repo}/pulls`);
+    url.searchParams.set('state', 'open');
+    url.searchParams.set('sort', 'updated');
+    url.searchParams.set('direction', 'desc');
+    url.searchParams.set('per_page', '100');
+    let response;
+    try {
+        response = await fetchFn(url.toString(), {
+            headers: {
+                'Authorization': `Bearer ${source.token}`,
+                'Accept': 'application/vnd.github+json',
+                'X-GitHub-Api-Version': '2022-11-28',
+            },
+        });
+    }
+    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: `GitHub API returned HTTP ${response.status}: ${response.statusText}`,
+        });
+    }
+    if (!checkRateLimit(response)) {
+        return (0, result_js_1.ok)([]);
+    }
+    let raw;
+    try {
+        raw = await response.json();
+    }
+    catch (e) {
+        return (0, result_js_1.err)({
+            kind: 'parse_error',
+            message: `Failed to parse GitHub PRs 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 GitHub PRs API, got: ${typeof raw}`,
+        });
+    }
+    const prs = [];
+    for (const item of raw) {
+        if (isGitHubPRShape(item)) {
+            prs.push(item);
+        }
+    }
+    const filtered = prs.filter(pr => pr.updated_at > since);
+    return (0, result_js_1.ok)(applyPRFilters(filtered, source));
+}
+function applyIssueFilters(issues, source) {
+    return issues.filter(issue => {
+        if (source.excludeAuthors.length > 0) {
+            const login = issue.user?.login;
+            if (!login || source.excludeAuthors.includes(login))
+                return false;
+        }
+        if (source.notLabels.length > 0 && issue.labels) {
+            const labelNames = issue.labels.map(l => l.name);
+            if (source.notLabels.some(nl => labelNames.includes(nl)))
+                return false;
+        }
+        return true;
+    });
+}
+function applyPRFilters(prs, source) {
+    return prs.filter(pr => {
+        if (source.excludeAuthors.length > 0) {
+            const login = pr.user?.login;
+            if (!login || source.excludeAuthors.includes(login))
+                return false;
+        }
+        if (source.notLabels.length > 0 && pr.labels) {
+            const labelNames = pr.labels.map(l => l.name);
+            if (source.notLabels.some(nl => labelNames.includes(nl)))
+                return false;
+        }
+        return true;
+    });
+}
+function isGitHubIssueShape(item) {
+    if (typeof item !== 'object' || item === null)
+        return false;
+    const obj = item;
+    return (typeof obj['id'] === 'number' &&
+        typeof obj['number'] === 'number' &&
+        typeof obj['title'] === 'string' &&
+        typeof obj['html_url'] === 'string' &&
+        typeof obj['updated_at'] === 'string' &&
+        typeof obj['state'] === 'string');
+}
+function isGitHubPRShape(item) {
+    if (typeof item !== 'object' || item === null)
+        return false;
+    const obj = item;
+    return (typeof obj['id'] === 'number' &&
+        typeof obj['number'] === 'number' &&
+        typeof obj['title'] === 'string' &&
+        typeof obj['html_url'] === 'string' &&
+        typeof obj['updated_at'] === 'string' &&
+        typeof obj['state'] === 'string');
+}

package/dist/trigger/adapters/gitlab-poller.d.ts

@@ -0,0 +1,27 @@
+import type { GitLabPollingSource } from '../types.js';
+import type { Result } from '../../runtime/result.js';
+export interface GitLabMR {
+    readonly id: number;
+    readonly iid: number;
+    readonly title: string;
+    readonly web_url: string;
+    readonly updated_at: string;
+    readonly state: string;
+    readonly author?: {
+        readonly username?: string;
+        readonly name?: string;
+    };
+}
+export type GitLabPollError = {
+    readonly kind: 'http_error';
+    readonly status: number;
+    readonly message: string;
+} | {
+    readonly kind: 'network_error';
+    readonly message: string;
+} | {
+    readonly kind: 'parse_error';
+    readonly message: string;
+};
+export type FetchFn = (url: string, init: RequestInit) => Promise<Response>;
+export declare function pollGitLabMRs(source: GitLabPollingSource, updatedAfter: string, fetchFn?: FetchFn): Promise<Result<GitLabMR[], GitLabPollError>>;

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