@exaudeus/workrail 3.36.0 → 3.37.1

package/dist/manifest.json

@@ -430,8 +430,8 @@
       "bytes": 506
     },
     "config/config-file.js": {
-      "sha256": "8d7a93f6153442348c8ef52178a928a722b2c19581097b31bc7de19076096710",
-      "bytes": 7215
+      "sha256": "22006b77ef2c6094c86b97007371b96fbd8792accec652c49bdcccaa40ad327f",
+      "bytes": 7277
     },
     "config/feature-flags.d.ts": {
       "sha256": "49cdf81a9c4f31eca560af5257c569143d2138ec996468b949f9807b7ad7802e",
@@ -445,12 +445,12 @@
       "sha256": "cf9d09641f1c31fffe6c7835b30bbbad52572befec1acab7fb9a0c188431af36",
       "bytes": 60355
     },
-    "console-ui/assets/index-n8cJrS4v.js": {
-      "sha256": "a676f6e7685eebaf2edb1feaa6cfe382131ce9faaee8efe6974e4073d935af7b",
+    "console-ui/assets/index-t8Wi304z.js": {
+      "sha256": "d0e010095f9ab0dc8e88d61cd9b8cec4bee7537433854e0f192e73ad4cf2bd5a",
       "bytes": 754955
     },
     "console-ui/index.html": {
-      "sha256": "14f1536e9c93a887a2c7c2a30c8297a0ae537c20f0f552cc2d79d1ee07728b7f",
+      "sha256": "e4bd9c7cdc0070c4706e010726ad02d0d26d867e34132e543c2a149211dfd848",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -502,12 +502,12 @@
       "bytes": 1009
     },
     "daemon/workflow-runner.d.ts": {
-      "sha256": "0d6b407a188357fd00cc534f8af754e83d9f0f1a5f5f599d8b39f92ffeab8904",
-      "bytes": 4496
+      "sha256": "d62587e9c7da974ff986d2d9cb67f0b30f7f3cb98a469cf98daf1d6fd16fa897",
+      "bytes": 4593
     },
     "daemon/workflow-runner.js": {
-      "sha256": "d7a7781ac06354b73e3d8859aebd654986255f653ac8df49b2e4a68b3da2ae9b",
-      "bytes": 63759
+      "sha256": "e3784aa04ead526de3ac9103d40967b32e3095ae3021ac13237034290be4ba4c",
+      "bytes": 63597
     },
     "di/container.d.ts": {
       "sha256": "003bb7fb7478d627524b9b1e76bd0a963a243794a687ff233b96dc0e33a06d9f",
@@ -690,8 +690,8 @@
       "bytes": 2524
     },
     "infrastructure/session/SessionManager.js": {
-      "sha256": "7044259c881b35c72ccbfece31be867eb5315df1384417924ac49d4cee11aee6",
-      "bytes": 21110
+      "sha256": "b39366c0be96268e6dfeb6d081d68b3b284fea2e709accc9f2c799fb95b5cda8",
+      "bytes": 21438
     },
     "infrastructure/session/index.d.ts": {
       "sha256": "52957847da70fcece6a553334bd899efd8ede55cc31f3aa5eb5e3d4bb70e3862",
@@ -1557,6 +1557,14 @@
       "sha256": "b8668c607788d560b38cf203750395e84eaa3164fff5711cac8f87f469714592",
       "bytes": 1222
     },
+    "trigger/notification-service.d.ts": {
+      "sha256": "c78406d3748953548f7879df8ac60cecd5e42f2f3b283f777343168ce2470b8d",
+      "bytes": 1572
+    },
+    "trigger/notification-service.js": {
+      "sha256": "693f617adc30b3a4fcebeca6a78b0da1c58819001660c017a4d0901652d675b8",
+      "bytes": 6373
+    },
     "trigger/polled-event-store.d.ts": {
       "sha256": "2952a25804177b2389d4273bfc41192477d100bc26100683861dedf28520dec1",
       "bytes": 1011
@@ -1578,16 +1586,16 @@
       "bytes": 1529
     },
     "trigger/trigger-listener.js": {
-      "sha256": "f2de9f72a7ce75ee47d26c45b5d2e93f10def16098aa718ec69b145862e4b493",
-      "bytes": 10021
+      "sha256": "23f1eed165ae7ec03b2c46ff6d6fdf46f631319d5d58d3a993f710d2732e41f1",
+      "bytes": 10585
     },
     "trigger/trigger-router.d.ts": {
-      "sha256": "c60fa099ea236255d2a51799f3f8c550af1990d167565a976ecb9ec2eb42c6ae",
-      "bytes": 1855
+      "sha256": "5293a744ac4763380716ec7c0b31f16531b9a666d08a3524c6c7993486a728b6",
+      "bytes": 2010
     },
     "trigger/trigger-router.js": {
-      "sha256": "16241f6376d2b6718ee1df4d1873270fd3c0cac69bdeaf2cca9fdaad2ca2bd33",
-      "bytes": 15336
+      "sha256": "e7b620d2b23a5e74f6fd3b5a39a5299d19d38f745401c545277c399336ef5eaf",
+      "bytes": 15565
     },
     "trigger/trigger-store.d.ts": {
       "sha256": "7afb05127d55bc3757a550dd15d4b797766b3fff29d1bfe76b303764b93322e7",

package/dist/trigger/notification-service.d.ts

@@ -0,0 +1,42 @@
+import type { WorkflowRunResult } from '../daemon/workflow-runner.js';
+export type ExecFileNotifyFn = (file: string, args: readonly string[], options: {
+    timeout: number;
+}, callback: (error: Error | null) => void) => void;
+export type FetchNotifyFn = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+    signal: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+}>;
+export interface NotificationConfig {
+    readonly macOs: boolean;
+    readonly webhookUrl?: string;
+    readonly execFileFn?: ExecFileNotifyFn;
+    readonly fetchFn?: FetchNotifyFn;
+    readonly platformFn?: () => NodeJS.Platform;
+}
+export interface NotificationPayload {
+    readonly event: 'session_completed';
+    readonly workflowId: string;
+    readonly outcome: 'success' | 'error' | 'timeout' | 'delivery_failed';
+    readonly detail: string;
+    readonly goal: string;
+    readonly timestamp: string;
+}
+export declare function buildNotificationBody(result: WorkflowRunResult, goal: string): string;
+export declare function buildOutcome(result: WorkflowRunResult): NotificationPayload['outcome'];
+export declare function buildDetail(result: WorkflowRunResult): string;
+export declare class NotificationService {
+    private readonly _macOsEnabled;
+    private readonly _webhookUrl;
+    private readonly _execFileFn;
+    private readonly _fetchFn;
+    constructor(config: NotificationConfig);
+    notify(result: WorkflowRunResult, goal: string): void;
+    private _doNotify;
+    private _notifyMacOs;
+    private _notifyWebhook;
+}

package/dist/trigger/notification-service.js

@@ -0,0 +1,164 @@
+"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.NotificationService = void 0;
+exports.buildNotificationBody = buildNotificationBody;
+exports.buildOutcome = buildOutcome;
+exports.buildDetail = buildDetail;
+const childProcess = __importStar(require("node:child_process"));
+const os = __importStar(require("node:os"));
+function buildNotificationBody(result, goal) {
+    const truncated = goal.length > 60 ? `${goal.slice(0, 57)}...` : goal;
+    switch (result._tag) {
+        case 'success':
+            return `Session completed: ${truncated}`;
+        case 'error':
+            return `Session failed: ${truncated}`;
+        case 'timeout':
+            return `Session timed out: ${truncated}`;
+        case 'delivery_failed':
+            return `Session completed but result delivery failed: ${truncated}`;
+    }
+}
+function buildOutcome(result) {
+    return result._tag;
+}
+function buildDetail(result) {
+    switch (result._tag) {
+        case 'success':
+            return `stopReason: ${result.stopReason}`;
+        case 'error':
+            return result.message;
+        case 'timeout':
+            return result.message;
+        case 'delivery_failed':
+            return `stopReason: ${result.stopReason}; deliveryError: ${result.deliveryError}`;
+    }
+}
+class NotificationService {
+    constructor(config) {
+        const getPlatform = config.platformFn ?? os.platform.bind(os);
+        if (config.macOs && getPlatform() !== 'darwin') {
+            console.warn('[NotificationService] WORKTRAIN_NOTIFY_MACOS=true but platform is not darwin ' +
+                `(platform: ${getPlatform()}). macOS notifications are disabled.`);
+            this._macOsEnabled = false;
+        }
+        else {
+            this._macOsEnabled = config.macOs;
+        }
+        if (config.webhookUrl !== undefined && config.webhookUrl !== '') {
+            let valid = false;
+            try {
+                const parsed = new URL(config.webhookUrl);
+                valid = parsed.protocol === 'http:' || parsed.protocol === 'https:';
+            }
+            catch {
+                valid = false;
+            }
+            if (!valid) {
+                console.warn(`[NotificationService] WORKTRAIN_NOTIFY_WEBHOOK is not a valid http(s) URL ` +
+                    `("${config.webhookUrl}"). Webhook notifications are disabled.`);
+                this._webhookUrl = undefined;
+            }
+            else {
+                this._webhookUrl = config.webhookUrl;
+            }
+        }
+        else {
+            this._webhookUrl = undefined;
+        }
+        this._execFileFn = config.execFileFn ?? ((file, args, options, callback) => {
+            childProcess.execFile(file, args, options, callback);
+        });
+        this._fetchFn = config.fetchFn ?? ((url, init) => globalThis.fetch(url, init));
+    }
+    notify(result, goal) {
+        void this._doNotify(result, goal).catch(() => {
+        });
+    }
+    async _doNotify(result, goal) {
+        const body = buildNotificationBody(result, goal);
+        const deliveries = [];
+        if (this._macOsEnabled) {
+            deliveries.push(this._notifyMacOs(body, result.workflowId));
+        }
+        if (this._webhookUrl !== undefined) {
+            deliveries.push(this._notifyWebhook(result, goal));
+        }
+        await Promise.allSettled(deliveries);
+    }
+    _notifyMacOs(body, workflowId) {
+        const script = `display notification ${JSON.stringify(body)} with title "WorkTrain" subtitle ${JSON.stringify(workflowId)}`;
+        return new Promise((resolve) => {
+            this._execFileFn('osascript', ['-e', script], { timeout: 5000 }, (error) => {
+                if (error) {
+                    console.warn(`[NotificationService] macOS notification failed: ${error.message}`);
+                }
+                resolve();
+            });
+        });
+    }
+    async _notifyWebhook(result, goal) {
+        const url = this._webhookUrl;
+        const payload = {
+            event: 'session_completed',
+            workflowId: result.workflowId,
+            outcome: buildOutcome(result),
+            detail: buildDetail(result),
+            goal,
+            timestamp: new Date().toISOString(),
+        };
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 30000);
+        try {
+            const res = await this._fetchFn(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                console.warn(`[NotificationService] Webhook notification failed: HTTP ${res.status} from ${url}`);
+            }
+        }
+        catch (e) {
+            console.warn(`[NotificationService] Webhook notification error: ${String(e)}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.NotificationService = NotificationService;

package/dist/trigger/trigger-listener.js

@@ -44,6 +44,7 @@ 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 notification_service_js_1 = require("./notification-service.js");
 const workflow_runner_js_1 = require("../daemon/workflow-runner.js");
 const types_js_1 = require("./types.js");
 const polling_scheduler_js_1 = require("./polling-scheduler.js");
@@ -177,8 +178,13 @@ async function startTriggerListener(ctx, options) {
         : undefined;
     const parsed = parseInt(maxConcurrencyRaw ?? '', 10);
     const maxConcurrentSessions = !isNaN(parsed) ? parsed : undefined;
+    const notifyMacOs = (workrailConfig.kind === 'ok' && workrailConfig.value['WORKTRAIN_NOTIFY_MACOS'] === 'true');
+    const notifyWebhook = workrailConfig.kind === 'ok' ? workrailConfig.value['WORKTRAIN_NOTIFY_WEBHOOK'] : undefined;
+    const notificationService = (notifyMacOs || (notifyWebhook !== undefined && notifyWebhook !== ''))
+        ? new notification_service_js_1.NotificationService({ macOs: notifyMacOs, webhookUrl: notifyWebhook })
+        : undefined;
     const runWorkflowFn = options.runWorkflowFn ?? workflow_runner_js_1.runWorkflow;
-    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions, options.emitter);
+    const router = new trigger_router_js_1.TriggerRouter(triggerIndex, ctx, apiKey, runWorkflowFn, undefined, maxConcurrentSessions, options.emitter, notificationService);
     const app = createTriggerApp(router);
     const allTriggers = [...triggerIndex.values()];
     const polledEventStore = new polled_event_store_js_1.PolledEventStore(env);

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

@@ -3,6 +3,7 @@ import type { V2ToolContext } from '../mcp/types.js';
 import type { TriggerDefinition, WebhookEvent } from './types.js';
 import type { ExecFn } from './delivery-action.js';
 import type { DaemonEventEmitter } from '../daemon/daemon-events.js';
+import type { NotificationService } from './notification-service.js';
 export type RouteError = {
     readonly kind: 'not_found';
     readonly triggerId: string;
@@ -31,7 +32,8 @@ export declare class TriggerRouter {
     private readonly semaphore;
     private readonly _maxConcurrentSessions;
     private readonly emitter;
-    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number, emitter?: DaemonEventEmitter);
+    private readonly notificationService;
+    constructor(index: ReadonlyMap<string, TriggerDefinition>, ctx: V2ToolContext, apiKey: string, runWorkflowFn: RunWorkflowFn, execFn?: ExecFn, maxConcurrentSessions?: number, emitter?: DaemonEventEmitter, notificationService?: NotificationService);
     get activeSessions(): number;
     get maxConcurrentSessions(): number;
     route(event: WebhookEvent): RouteResult;

package/dist/trigger/trigger-router.js

@@ -182,7 +182,7 @@ class Semaphore {
 }
 const DEFAULT_MAX_CONCURRENT_SESSIONS = 3;
 class TriggerRouter {
-    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions, emitter) {
+    constructor(index, ctx, apiKey, runWorkflowFn, execFn, maxConcurrentSessions, emitter, notificationService) {
         this.index = index;
         this.ctx = ctx;
         this.apiKey = apiKey;
@@ -190,6 +190,7 @@ class TriggerRouter {
         this.queue = new index_js_1.KeyedAsyncQueue();
         this.execFn = execFn ?? execFileAsync;
         this.emitter = emitter;
+        this.notificationService = notificationService;
         const requested = maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
         const cap = Number.isNaN(requested) ? DEFAULT_MAX_CONCURRENT_SESSIONS : requested;
         if (cap < 1) {
@@ -301,6 +302,7 @@ class TriggerRouter {
                 console.log(`[TriggerRouter] Workflow failed: triggerId=${trigger.id} ` +
                     `workflowId=${trigger.workflowId} error=${result.message} stopReason=${result.stopReason}`);
             }
+            this.notificationService?.notify(result, workflowTrigger.goal);
             await maybeRunDelivery(trigger.id, trigger, originalResult, this.execFn);
         });
         return { _tag: 'enqueued', triggerId: trigger.id };
@@ -336,6 +338,7 @@ class TriggerRouter {
                 console.log(`[TriggerRouter] Dispatch failed: workflowId=${workflowTrigger.workflowId} ` +
                     `error=${result.message} stopReason=${result.stopReason}`);
             }
+            this.notificationService?.notify(result, workflowTrigger.goal);
         });
         return workflowTrigger.workflowId;
     }