@exaudeus/workrail 3.31.1 → 3.33.0

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

@@ -38,6 +38,7 @@ 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 bridge_events_js_1 = require("./bridge-events.js");
 const INITIAL_ROOTS_TIMEOUT_MS = 1000;
 async function fetchInitialRootsWithTimeout(server) {
     return Promise.race([
@@ -50,6 +51,7 @@ async function fetchInitialRootsWithTimeout(server) {
 async function startStdioServer() {
     (0, fatal_exit_js_1.registerFatalHandlers)('stdio');
     (0, fatal_exit_js_1.logStartup)('stdio');
+    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'primary_started', transport: '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(); });
@@ -59,27 +61,45 @@ 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)({

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/delivery-client.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from '../runtime/result.js';
 import type { WorkflowRunResult } from '../daemon/workflow-runner.js';
+import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
 export type DeliveryError = {
     readonly kind: 'http_error';
     readonly status: number;
@@ -8,4 +9,4 @@ export type DeliveryError = {
     readonly kind: 'network_error';
     readonly message: string;
 };
-export declare function post(callbackUrl: string, result: WorkflowRunResult): Promise<Result<void, DeliveryError>>;
+export declare function post(callbackUrl: string, result: WorkflowRunResult, emitter?: DaemonEventEmitter): Promise<Result<void, DeliveryError>>;

package/dist/trigger/delivery-client.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.post = post;
 const result_js_1 = require("../runtime/result.js");
-async function post(callbackUrl, result) {
+async function post(callbackUrl, result, emitter) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 30000);
     try {
@@ -14,11 +14,14 @@ async function post(callbackUrl, result) {
         });
         if (!res.ok) {
             const body = await res.text().catch(() => '');
+            emitter?.emit({ kind: 'delivery_attempted', callbackUrl, outcome: 'http_error', statusCode: res.status });
             return (0, result_js_1.err)({ kind: 'http_error', status: res.status, body });
         }
+        emitter?.emit({ kind: 'delivery_attempted', callbackUrl, outcome: 'success', statusCode: res.status });
         return (0, result_js_1.ok)(undefined);
     }
     catch (e) {
+        emitter?.emit({ kind: 'delivery_attempted', callbackUrl, outcome: 'network_error' });
         return (0, result_js_1.err)({ kind: 'network_error', message: String(e) });
     }
     finally {

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