@exaudeus/workrail 3.25.0 → 3.26.0

package/dist/trigger/trigger-listener.js

@@ -43,6 +43,7 @@ const express_1 = __importDefault(require("express"));
 const http = __importStar(require("node:http"));
 const trigger_store_js_1 = require("./trigger-store.js");
 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 DEFAULT_TRIGGER_PORT = 3200;
@@ -111,7 +112,10 @@ async function startTriggerListener(ctx, options) {
     if (!apiKey) {
         return { _kind: 'err', error: { kind: 'missing_api_key' } };
     }
-    const configResult = await (0, trigger_store_js_1.loadTriggerConfigFromFile)(options.workspacePath, env);
+    const workspaceResult = (0, config_file_js_1.loadWorkspacesFromConfigFile)();
+    const loadedWorkspaces = workspaceResult.kind === 'ok' ? workspaceResult.value : {};
+    const workspaces = options.workspaces ?? loadedWorkspaces;
+    const configResult = await (0, trigger_store_js_1.loadTriggerConfigFromFile)(options.workspacePath, env, workspaces);
     let triggerIndex;
     if (configResult.kind === 'err') {
         if (configResult.error.kind === 'file_not_found') {
@@ -132,8 +136,14 @@ async function startTriggerListener(ctx, options) {
         triggerIndex = indexResult.value;
         console.log(`[TriggerListener] Loaded ${configResult.value.triggers.length} trigger(s) from triggers.yml`);
     }
+    const workrailConfig = (0, config_file_js_1.loadWorkrailConfigFile)();
+    const maxConcurrencyRaw = workrailConfig.kind === 'ok'
+        ? workrailConfig.value['maxConcurrentSessions']
+        : undefined;
+    const parsed = parseInt(maxConcurrencyRaw ?? '', 10);
+    const maxConcurrentSessions = !isNaN(parsed) ? parsed : undefined;
     const runWorkflowFn = options.runWorkflowFn ?? workflow_runner_js_1.runWorkflow;
-    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn);
+    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions);
     const app = createTriggerApp(router);
     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));

package/dist/trigger/trigger-router.d.ts

@@ -1,6 +1,7 @@
 import type { WorkflowTrigger, WorkflowRunResult } from '../daemon/workflow-runner.js';
 import type { V2ToolContext } from '../mcp/types.js';
 import type { TriggerDefinition, WebhookEvent } from './types.js';
+import type { ExecFn } from './delivery-action.js';
 export type RouteError = {
     readonly kind: 'not_found';
     readonly triggerId: string;
@@ -18,14 +19,19 @@ export type RouteResult = {
     readonly error: RouteError;
 };
 export type RunWorkflowFn = (trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string) => Promise<WorkflowRunResult>;
-export declare function interpolateGoalTemplate(template: string, staticGoal: string, payload: Readonly<Record<string, unknown>>): string;
+export declare function interpolateGoalTemplate(template: string, staticGoal: string, payload: Readonly<Record<string, unknown>>, triggerId: string): string;
 export declare class TriggerRouter {
     private readonly index;
     private readonly ctx;
     private readonly apiKey;
     private readonly runWorkflowFn;
     private readonly queue;
-    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn);
+    private readonly execFn;
+    private readonly semaphore;
+    private readonly _maxConcurrentSessions;
+    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number);
+    get activeSessions(): number;
+    get maxConcurrentSessions(): number;
     route(event: WebhookEvent): RouteResult;
     dispatch(workflowTrigger: WorkflowTrigger): string;
     listTriggers(): readonly TriggerDefinition[];

package/dist/trigger/trigger-router.js

@@ -36,8 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TriggerRouter = void 0;
 exports.interpolateGoalTemplate = interpolateGoalTemplate;
 const crypto = __importStar(require("node:crypto"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
 const index_js_1 = require("../v2/infra/in-memory/keyed-async-queue/index.js");
-function interpolateGoalTemplate(template, staticGoal, payload) {
+const delivery_client_js_1 = require("./delivery-client.js");
+const delivery_action_js_1 = require("./delivery-action.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function interpolateGoalTemplate(template, staticGoal, payload, triggerId) {
     const TOKEN_RE = /\{\{([^}]+)\}\}/g;
     const tokens = [];
     let match;
@@ -51,6 +56,8 @@ function interpolateGoalTemplate(template, staticGoal, payload) {
     for (const token of tokens) {
         const value = extractDotPath(payload, token);
         if (value === undefined || value === null) {
+            console.warn(`[TriggerRouter] goalTemplate variable '${token}' not found in payload ` +
+                `for trigger '${triggerId}' (template: '${template}'). Falling back to static goal.`);
             return staticGoal;
         }
         resolved.set(token, String(value));
@@ -108,13 +115,97 @@ function validateHmac(rawBody, secret, headerValue) {
     }
     return crypto.timingSafeEqual(Buffer.from(expected, 'utf8'), Buffer.from(received, 'utf8'));
 }
+async function maybeRunDelivery(triggerId, trigger, result, execFn) {
+    if (result._tag !== 'success')
+        return;
+    if (result.lastStepNotes === undefined) {
+        if (trigger.autoCommit === true) {
+            console.warn(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} -- ` +
+                `lastStepNotes is absent (agent did not provide notes on the final step). ` +
+                `Ensure the workflow produces a JSON handoff block in its final step notes.`);
+        }
+        return;
+    }
+    if (trigger.autoCommit !== true)
+        return;
+    const parseResult = (0, delivery_action_js_1.parseHandoffArtifact)(result.lastStepNotes);
+    if (parseResult.kind === 'err') {
+        console.warn(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} -- ` +
+            `handoff artifact not parseable: ${parseResult.error}. ` +
+            `Ensure the workflow's final step produces a JSON block with commitType, filesChanged, etc.`);
+        return;
+    }
+    const deliveryResult = await (0, delivery_action_js_1.runDelivery)(parseResult.value, trigger.workspacePath, { autoCommit: trigger.autoCommit, autoOpenPR: trigger.autoOpenPR }, execFn);
+    switch (deliveryResult._tag) {
+        case 'committed':
+            console.log(`[TriggerRouter] Delivery committed: triggerId=${triggerId} sha=${deliveryResult.sha}`);
+            break;
+        case 'pr_opened':
+            console.log(`[TriggerRouter] Delivery PR opened: triggerId=${triggerId} url=${deliveryResult.url}`);
+            break;
+        case 'skipped':
+            console.log(`[TriggerRouter] Delivery skipped: triggerId=${triggerId} reason=${deliveryResult.reason}`);
+            break;
+        case 'error':
+            console.warn(`[TriggerRouter] Delivery error: triggerId=${triggerId} phase=${deliveryResult.phase} ` +
+                `details=${deliveryResult.details}`);
+            break;
+    }
+}
+class Semaphore {
+    constructor(max) {
+        this.max = max;
+        this.active = 0;
+        this.waiters = [];
+    }
+    acquire() {
+        if (this.active < this.max) {
+            this.active++;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    release() {
+        const next = this.waiters.shift();
+        if (next !== undefined) {
+            next();
+        }
+        else {
+            this.active--;
+        }
+    }
+    get activeCount() {
+        return this.active;
+    }
+}
+const DEFAULT_MAX_CONCURRENT_SESSIONS = 3;
 class TriggerRouter {
-    constructor(index, ctx, apiKey, runWorkflowFn) {
+    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions) {
         this.index = index;
         this.ctx = ctx;
         this.apiKey = apiKey;
         this.runWorkflowFn = runWorkflowFn;
         this.queue = new index_js_1.KeyedAsyncQueue();
+        this.execFn = execFn ?? execFileAsync;
+        const requested = maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
+        const cap = Number.isNaN(requested) ? DEFAULT_MAX_CONCURRENT_SESSIONS : requested;
+        if (cap < 1) {
+            console.warn(`[TriggerRouter] maxConcurrentSessions must be >= 1; received ${cap}, clamping to 1.`);
+            this._maxConcurrentSessions = 1;
+        }
+        else {
+            this._maxConcurrentSessions = cap;
+        }
+        this.semaphore = new Semaphore(this._maxConcurrentSessions);
+        console.log(`[TriggerRouter] maxConcurrentSessions=${this._maxConcurrentSessions}`);
+    }
+    get activeSessions() {
+        return this.semaphore.activeCount;
+    }
+    get maxConcurrentSessions() {
+        return this._maxConcurrentSessions;
     }
     route(event) {
         const trigger = this.index.get(event.triggerId);
@@ -141,7 +232,7 @@ class TriggerRouter {
             workflowContext = { payload: event.payload };
         }
         const goal = trigger.goalTemplate
-            ? interpolateGoalTemplate(trigger.goalTemplate, trigger.goal, event.payload)
+            ? interpolateGoalTemplate(trigger.goalTemplate, trigger.goal, event.payload, trigger.id)
             : trigger.goal;
         const workflowTrigger = {
             workflowId: trigger.workflowId,
@@ -150,27 +241,94 @@ class TriggerRouter {
             context: workflowContext,
             ...(trigger.referenceUrls !== undefined ? { referenceUrls: trigger.referenceUrls } : {}),
             ...(trigger.agentConfig !== undefined ? { agentConfig: trigger.agentConfig } : {}),
+            ...(trigger.soulFile !== undefined ? { soulFile: trigger.soulFile } : {}),
         };
-        void this.queue.enqueue(trigger.id, async () => {
-            const result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+        const queueKey = trigger.concurrencyMode === 'parallel'
+            ? `${trigger.id}:${crypto.randomUUID()}`
+            : trigger.id;
+        void this.queue.enqueue(queueKey, async () => {
+            if (this.semaphore.activeCount >= this._maxConcurrentSessions) {
+                console.warn(`[TriggerRouter] Concurrency limit reached ` +
+                    `(${this.semaphore.activeCount}/${this._maxConcurrentSessions} active): ` +
+                    `queuing dispatch for triggerId=${trigger.id}`);
+            }
+            await this.semaphore.acquire();
+            let result;
+            try {
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+            }
+            finally {
+                this.semaphore.release();
+            }
+            const originalTag = result._tag;
+            const originalResult = result;
+            if (trigger.callbackUrl) {
+                const deliveryResult = await (0, delivery_client_js_1.post)(trigger.callbackUrl, result);
+                if (deliveryResult.kind === 'err') {
+                    const deliveryError = deliveryResult.error.kind === 'http_error'
+                        ? `HTTP ${deliveryResult.error.status}: ${deliveryResult.error.body}`
+                        : deliveryResult.error.message;
+                    console.error(`[TriggerRouter] Delivery failed: triggerId=${trigger.id} ` +
+                        `callbackUrl=${trigger.callbackUrl} error=${deliveryError}`);
+                    const deliveryFailed = {
+                        _tag: 'delivery_failed',
+                        workflowId: trigger.workflowId,
+                        stopReason: result.stopReason,
+                        deliveryError,
+                    };
+                    result = deliveryFailed;
+                }
+            }
             if (result._tag === 'success') {
                 console.log(`[TriggerRouter] Workflow completed: triggerId=${trigger.id} ` +
                     `workflowId=${trigger.workflowId} stopReason=${result.stopReason}`);
             }
+            else if (result._tag === 'delivery_failed') {
+                const outcomeLabel = originalTag === 'success'
+                    ? 'Workflow succeeded but delivery failed'
+                    : 'Workflow failed and delivery also failed';
+                console.log(`[TriggerRouter] ${outcomeLabel}: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} stopReason=${result.stopReason}`);
+            }
+            else if (result._tag === 'timeout') {
+                console.log(`[TriggerRouter] Workflow timed out: triggerId=${trigger.id} ` +
+                    `workflowId=${trigger.workflowId} reason=${result.reason} message=${result.message}`);
+            }
             else {
                 console.log(`[TriggerRouter] Workflow failed: triggerId=${trigger.id} ` +
                     `workflowId=${trigger.workflowId} error=${result.message} stopReason=${result.stopReason}`);
             }
+            await maybeRunDelivery(trigger.id, trigger, originalResult, this.execFn);
         });
         return { _tag: 'enqueued', triggerId: trigger.id };
     }
     dispatch(workflowTrigger) {
         void this.queue.enqueue(workflowTrigger.workflowId, async () => {
-            const result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+            if (this.semaphore.activeCount >= this._maxConcurrentSessions) {
+                console.warn(`[TriggerRouter] Concurrency limit reached ` +
+                    `(${this.semaphore.activeCount}/${this._maxConcurrentSessions} active): ` +
+                    `queuing dispatch for workflowId=${workflowTrigger.workflowId}`);
+            }
+            await this.semaphore.acquire();
+            let result;
+            try {
+                result = await this.runWorkflowFn(workflowTrigger, this.ctx, this.apiKey);
+            }
+            finally {
+                this.semaphore.release();
+            }
             if (result._tag === 'success') {
                 console.log(`[TriggerRouter] Dispatch completed: workflowId=${workflowTrigger.workflowId} ` +
                     `stopReason=${result.stopReason}`);
             }
+            else if (result._tag === 'delivery_failed') {
+                console.log(`[TriggerRouter] Dispatch delivery failed: workflowId=${workflowTrigger.workflowId} ` +
+                    `stopReason=${result.stopReason} deliveryError=${result.deliveryError}`);
+            }
+            else if (result._tag === 'timeout') {
+                console.log(`[TriggerRouter] Dispatch timed out: workflowId=${workflowTrigger.workflowId} ` +
+                    `reason=${result.reason} message=${result.message}`);
+            }
             else {
                 console.log(`[TriggerRouter] Dispatch failed: workflowId=${workflowTrigger.workflowId} ` +
                     `error=${result.message} stopReason=${result.stopReason}`);

package/dist/trigger/trigger-store.d.ts

@@ -1,5 +1,5 @@
 import type { Result } from '../runtime/result.js';
-import { type TriggerConfig, type TriggerDefinition } from './types.js';
+import { type TriggerConfig, type TriggerDefinition, type WorkspaceConfig } from './types.js';
 export type TriggerStoreError = {
     readonly kind: 'parse_error';
     readonly message: string;
@@ -12,10 +12,18 @@ export type TriggerStoreError = {
     readonly kind: 'missing_field';
     readonly field: string;
     readonly triggerId: string;
+} | {
+    readonly kind: 'invalid_field_value';
+    readonly field: string;
+    readonly triggerId: string;
 } | {
     readonly kind: 'unknown_provider';
     readonly provider: string;
     readonly triggerId: string;
+} | {
+    readonly kind: 'unknown_workspace';
+    readonly workspaceName: string;
+    readonly triggerId: string;
 } | {
     readonly kind: 'file_not_found';
     readonly filePath: string;
@@ -26,6 +34,6 @@ export type TriggerStoreError = {
     readonly kind: 'duplicate_id';
     readonly triggerId: string;
 };
-export declare function loadTriggerConfig(yamlContent: string, env?: Record<string, string | undefined>): Result<TriggerConfig, TriggerStoreError>;
-export declare function loadTriggerConfigFromFile(workspacePath: string, env?: Record<string, string | undefined>): Promise<Result<TriggerConfig, TriggerStoreError>>;
+export declare function loadTriggerConfig(yamlContent: string, env?: Record<string, string | undefined>, workspaces?: Readonly<Record<string, WorkspaceConfig>>): Result<TriggerConfig, TriggerStoreError>;
+export declare function loadTriggerConfigFromFile(workspacePath: string, env?: Record<string, string | undefined>, workspaces?: Readonly<Record<string, WorkspaceConfig>>): Promise<Result<TriggerConfig, TriggerStoreError>>;
 export declare function buildTriggerIndex(config: TriggerConfig): Result<Map<string, TriggerDefinition>, TriggerStoreError>;