@exaudeus/workrail 3.32.0 → 3.34.0

package/dist/mcp/output-schemas.d.ts

@@ -63,12 +63,12 @@ export declare const WorkflowNextOutputSchema: z.ZodObject<{
     next: z.ZodNullable<z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>;
     isComplete: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
-    state: import("../domain/execution/state.js").ExecutionState;
     isComplete: boolean;
+    state: import("../domain/execution/state.js").ExecutionState;
     next: JsonValue;
 }, {
-    state: import("../domain/execution/state.js").ExecutionState;
     isComplete: boolean;
+    state: import("../domain/execution/state.js").ExecutionState;
     next: JsonValue;
 }>;
 export declare const WorkflowValidateJsonOutputSchema: z.ZodObject<{
@@ -1123,22 +1123,22 @@ export declare const V2ResumeNextCallSchema: z.ZodObject<{
         continueToken: z.ZodString;
         intent: z.ZodLiteral<"rehydrate">;
     }, "strip", z.ZodTypeAny, {
-        continueToken: string;
         intent: "rehydrate";
-    }, {
         continueToken: string;
+    }, {
         intent: "rehydrate";
+        continueToken: string;
     }>;
 }, "strip", z.ZodTypeAny, {
     params: {
-        continueToken: string;
         intent: "rehydrate";
+        continueToken: string;
     };
     tool: "continue_workflow";
 }, {
     params: {
-        continueToken: string;
         intent: "rehydrate";
+        continueToken: string;
     };
     tool: "continue_workflow";
 }>;
@@ -2237,66 +2237,66 @@ export declare const V2ResumeSessionOutputSchema: z.ZodObject<{
                 continueToken: z.ZodString;
                 intent: z.ZodLiteral<"rehydrate">;
             }, "strip", z.ZodTypeAny, {
-                continueToken: string;
                 intent: "rehydrate";
-            }, {
                 continueToken: string;
+            }, {
                 intent: "rehydrate";
+                continueToken: string;
             }>;
         }, "strip", z.ZodTypeAny, {
             params: {
-                continueToken: string;
                 intent: "rehydrate";
+                continueToken: string;
             };
             tool: "continue_workflow";
         }, {
             params: {
-                continueToken: string;
                 intent: "rehydrate";
+                continueToken: string;
             };
             tool: "continue_workflow";
         }>;
     }, "strip", z.ZodTypeAny, {
         confidence: "strong" | "weak" | "medium";
         workflowId: string;
-        runId: string;
         sessionId: string;
-        gitBranch: string | null;
+        runId: string;
         isComplete: boolean;
+        sessionTitle: string | null;
+        gitBranch: string | null;
+        lastModifiedMs: number | null;
         nextCall: {
             params: {
-                continueToken: string;
                 intent: "rehydrate";
+                continueToken: string;
             };
             tool: "continue_workflow";
         };
-        sessionTitle: string | null;
         resumeToken: string;
         snippet: string;
         matchExplanation: string;
         pendingStepId: string | null;
-        lastModifiedMs: number | null;
         whyMatched: ("matched_exact_id" | "matched_notes" | "matched_notes_partial" | "matched_workflow_id" | "matched_head_sha" | "matched_branch" | "matched_repo_root" | "recency_fallback")[];
     }, {
         confidence: "strong" | "weak" | "medium";
         workflowId: string;
-        runId: string;
         sessionId: string;
-        gitBranch: string | null;
+        runId: string;
         isComplete: boolean;
+        sessionTitle: string | null;
+        gitBranch: string | null;
+        lastModifiedMs: number | null;
         nextCall: {
             params: {
-                continueToken: string;
                 intent: "rehydrate";
+                continueToken: string;
             };
             tool: "continue_workflow";
         };
-        sessionTitle: string | null;
         resumeToken: string;
         snippet: string;
         matchExplanation: string;
         pendingStepId: string | null;
-        lastModifiedMs: number | null;
         whyMatched: ("matched_exact_id" | "matched_notes" | "matched_notes_partial" | "matched_workflow_id" | "matched_head_sha" | "matched_branch" | "matched_repo_root" | "recency_fallback")[];
     }>, "many">;
     totalEligible: z.ZodNumber;
@@ -2304,23 +2304,23 @@ export declare const V2ResumeSessionOutputSchema: z.ZodObject<{
     candidates: {
         confidence: "strong" | "weak" | "medium";
         workflowId: string;
-        runId: string;
         sessionId: string;
-        gitBranch: string | null;
+        runId: string;
         isComplete: boolean;
+        sessionTitle: string | null;
+        gitBranch: string | null;
+        lastModifiedMs: number | null;
         nextCall: {
             params: {
-                continueToken: string;
                 intent: "rehydrate";
+                continueToken: string;
             };
             tool: "continue_workflow";
         };
-        sessionTitle: string | null;
         resumeToken: string;
         snippet: string;
         matchExplanation: string;
         pendingStepId: string | null;
-        lastModifiedMs: number | null;
         whyMatched: ("matched_exact_id" | "matched_notes" | "matched_notes_partial" | "matched_workflow_id" | "matched_head_sha" | "matched_branch" | "matched_repo_root" | "recency_fallback")[];
     }[];
     totalEligible: number;
@@ -2328,23 +2328,23 @@ export declare const V2ResumeSessionOutputSchema: z.ZodObject<{
     candidates: {
         confidence: "strong" | "weak" | "medium";
         workflowId: string;
-        runId: string;
         sessionId: string;
-        gitBranch: string | null;
+        runId: string;
         isComplete: boolean;
+        sessionTitle: string | null;
+        gitBranch: string | null;
+        lastModifiedMs: number | null;
         nextCall: {
             params: {
-                continueToken: string;
                 intent: "rehydrate";
+                continueToken: string;
             };
             tool: "continue_workflow";
         };
-        sessionTitle: string | null;
         resumeToken: string;
         snippet: string;
         matchExplanation: string;
         pendingStepId: string | null;
-        lastModifiedMs: number | null;
         whyMatched: ("matched_exact_id" | "matched_notes" | "matched_notes_partial" | "matched_workflow_id" | "matched_head_sha" | "matched_branch" | "matched_repo_root" | "recency_fallback")[];
     }[];
     totalEligible: number;

package/dist/mcp/transports/fatal-exit.js

@@ -86,6 +86,10 @@ function fatalExit(label, reason) {
 }
 function registerFatalHandlers(transport) {
     registeredTransport = transport;
+    process.stderr.on('error', () => { });
+    if (process.stdout.listenerCount('error') === 0) {
+        process.stdout.on('error', () => { });
+    }
     process.on('uncaughtException', (err) => fatalExit('Uncaught exception', err));
     process.on('unhandledRejection', (reason) => fatalExit('Unhandled promise rejection', reason));
 }

package/dist/mcp/transports/http-entry.js

@@ -41,14 +41,12 @@ const server_js_1 = require("../server.js");
 const http_listener_js_1 = require("./http-listener.js");
 const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
 const fatal_exit_js_1 = require("./fatal-exit.js");
-const primary_tombstone_js_1 = require("./primary-tombstone.js");
 const crypto = __importStar(require("crypto"));
 const express_1 = __importDefault(require("express"));
 const HTTP_PORT_SCAN_END = 3199;
 async function startHttpServer(port) {
     (0, fatal_exit_js_1.registerFatalHandlers)('http');
     (0, fatal_exit_js_1.logStartup)('http', { port });
-    (0, primary_tombstone_js_1.clearTombstone)();
     const { server, ctx } = await (0, server_js_1.composeServer)();
     const scanEnd = Math.max(port, HTTP_PORT_SCAN_END);
     const listener = await (0, http_listener_js_1.bindWithPortFallback)(port, scanEnd);
@@ -74,9 +72,6 @@ async function startHttpServer(port) {
     console.error(`[Transport] MCP endpoint: http://localhost:${boundPort}/mcp`);
     (0, shutdown_hooks_js_1.wireShutdownHooks)({
         onBeforeTerminate: async () => {
-            if (boundPort != null) {
-                (0, primary_tombstone_js_1.writeTombstone)(boundPort, process.pid);
-            }
             await listener.stop();
             await ctx.httpServer?.stop();
         },

package/dist/mcp/transports/stdio-entry.js

@@ -37,7 +37,6 @@ exports.startStdioServer = startStdioServer;
 const server_js_1 = require("../server.js");
 const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
 const fatal_exit_js_1 = require("./fatal-exit.js");
-const primary_tombstone_js_1 = require("./primary-tombstone.js");
 const INITIAL_ROOTS_TIMEOUT_MS = 1000;
 async function fetchInitialRootsWithTimeout(server) {
     return Promise.race([
@@ -50,7 +49,6 @@ async function fetchInitialRootsWithTimeout(server) {
 async function startStdioServer() {
     (0, fatal_exit_js_1.registerFatalHandlers)('stdio');
     (0, fatal_exit_js_1.logStartup)('stdio');
-    (0, primary_tombstone_js_1.clearTombstone)();
     const { server, ctx, rootsManager } = await (0, server_js_1.composeServer)();
     (0, fatal_exit_js_1.registerGracefulShutdown)(async () => { await ctx.httpServer?.stop(); });
     const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
@@ -59,35 +57,49 @@ async function startStdioServer() {
         try {
             const result = await server.listRoots();
             rootsManager.updateRootUris(result.roots.map((r) => r.uri));
-            console.error(`[Roots] Updated workspace roots: ${result.roots.map((r) => r.uri).join(', ') || '(none)'}`);
+            try {
+                process.stderr.write(`[Roots] Updated workspace roots: ${result.roots.map((r) => r.uri).join(', ') || '(none)'}\n`);
+            }
+            catch { }
         }
         catch {
-            console.error('[Roots] Failed to fetch updated roots after change notification');
+            try {
+                process.stderr.write('[Roots] Failed to fetch updated roots after change notification\n');
+            }
+            catch { }
         }
     });
     (0, shutdown_hooks_js_1.wireStdoutShutdown)();
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('[Transport] WorkRail MCP Server running on stdio');
+    try {
+        process.stderr.write('[Transport] WorkRail MCP Server running on stdio\n');
+    }
+    catch { }
     void fetchInitialRootsWithTimeout(server)
         .then((result) => {
         if (result == null) {
-            console.error('[Roots] Initial roots probe timed out; workspace context will use server CWD fallback');
+            try {
+                process.stderr.write('[Roots] Initial roots probe timed out; workspace context will use server CWD fallback\n');
+            }
+            catch { }
             return;
         }
         rootsManager.updateRootUris(result.roots.map((r) => r.uri));
-        console.error(`[Roots] Initial workspace roots: ${result.roots.map((r) => r.uri).join(', ') || '(none)'}`);
+        try {
+            process.stderr.write(`[Roots] Initial workspace roots: ${result.roots.map((r) => r.uri).join(', ') || '(none)'}\n`);
+        }
+        catch { }
     })
         .catch(() => {
-        console.error('[Roots] Client does not support roots/list; workspace context will use server CWD fallback');
+        try {
+            process.stderr.write('[Roots] Client does not support roots/list; workspace context will use server CWD fallback\n');
+        }
+        catch { }
     });
     (0, shutdown_hooks_js_1.wireStdinShutdown)();
     (0, shutdown_hooks_js_1.wireShutdownHooks)({
         onBeforeTerminate: async () => {
-            const port = ctx.httpServer?.getPort();
-            if (port != null) {
-                (0, primary_tombstone_js_1.writeTombstone)(port, process.pid);
-            }
             await ctx.httpServer?.stop();
         },
     });

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/mcp-server.d.ts

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
 export { startStdioServer } from './mcp/transports/stdio-entry.js';
 export { startHttpServer } from './mcp/transports/http-entry.js';
-export { startBridgeServer, detectHealthyPrimary } from './mcp/transports/bridge-entry.js';
 export { composeServer } from './mcp/server.js';
-export declare function waitForStdinReadable(timeoutMs: number, stdin?: NodeJS.ReadableStream): Promise<boolean>;

package/dist/mcp-server.js

@@ -1,60 +1,19 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeServer = exports.detectHealthyPrimary = exports.startBridgeServer = exports.startHttpServer = exports.startStdioServer = void 0;
-exports.waitForStdinReadable = waitForStdinReadable;
+exports.composeServer = exports.startHttpServer = exports.startStdioServer = void 0;
 const transport_mode_js_1 = require("./mcp/transports/transport-mode.js");
 const stdio_entry_js_1 = require("./mcp/transports/stdio-entry.js");
 const http_entry_js_1 = require("./mcp/transports/http-entry.js");
-const bridge_entry_js_1 = require("./mcp/transports/bridge-entry.js");
 const assert_never_js_1 = require("./runtime/assert-never.js");
 var stdio_entry_js_2 = require("./mcp/transports/stdio-entry.js");
 Object.defineProperty(exports, "startStdioServer", { enumerable: true, get: function () { return stdio_entry_js_2.startStdioServer; } });
 var http_entry_js_2 = require("./mcp/transports/http-entry.js");
 Object.defineProperty(exports, "startHttpServer", { enumerable: true, get: function () { return http_entry_js_2.startHttpServer; } });
-var bridge_entry_js_2 = require("./mcp/transports/bridge-entry.js");
-Object.defineProperty(exports, "startBridgeServer", { enumerable: true, get: function () { return bridge_entry_js_2.startBridgeServer; } });
-Object.defineProperty(exports, "detectHealthyPrimary", { enumerable: true, get: function () { return bridge_entry_js_2.detectHealthyPrimary; } });
 var server_js_1 = require("./mcp/server.js");
 Object.defineProperty(exports, "composeServer", { enumerable: true, get: function () { return server_js_1.composeServer; } });
-const DEFAULT_MCP_PORT = 3100;
-const STDIO_CLIENT_PROBE_MS = 150;
-function waitForStdinReadable(timeoutMs, stdin = process.stdin) {
-    return new Promise((resolve) => {
-        stdin.pause();
-        const timer = setTimeout(() => {
-            stdin.removeListener('readable', onReadable);
-            resolve(false);
-        }, timeoutMs);
-        const onReadable = () => {
-            clearTimeout(timer);
-            stdin.removeListener('readable', onReadable);
-            resolve(true);
-        };
-        stdin.once('readable', onReadable);
-    });
-}
 async function main() {
     const mode = (0, transport_mode_js_1.resolveTransportMode)(process.env);
-    if (mode.kind === 'stdio') {
-        const primaryDetected = await (0, bridge_entry_js_1.detectHealthyPrimary)(DEFAULT_MCP_PORT);
-        if (primaryDetected != null) {
-            const hasClient = await waitForStdinReadable(STDIO_CLIENT_PROBE_MS, process.stdin);
-            if (!hasClient) {
-                console.error(`[Startup] Primary on :${primaryDetected.port}, no stdio client within ${STDIO_CLIENT_PROBE_MS}ms — exiting`);
-                process.exit(0);
-            }
-            console.error(`[Startup] Primary detected on :${primaryDetected.port} — starting in bridge mode`);
-            try {
-                await (0, bridge_entry_js_1.startBridgeServer)(primaryDetected.port, undefined, { originalPrimaryPid: primaryDetected.pid });
-            }
-            catch (error) {
-                console.error('[Bridge] Fatal error, falling back to full stdio server:', error);
-                await (0, stdio_entry_js_1.startStdioServer)();
-            }
-            return;
-        }
-    }
     switch (mode.kind) {
         case 'stdio':
             await (0, stdio_entry_js_1.startStdioServer)();

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