@exaudeus/workrail 0.8.5 → 0.9.0

package/dist/index.js

@@ -1,28 +1,13 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWorkflowLookupServer = void 0;
-const container_1 = require("./container");
-async function main() {
-    try {
-        const { server } = (0, container_1.createAppContainer)();
-        await server.start();
-        console.log('Workflow Lookup MCP Server started successfully');
-        const shutdown = async (signal) => {
-            console.log(`Received ${signal}, shutting down...`);
-            await server.stop();
-            process.exit(0);
-        };
-        process.on('SIGINT', () => shutdown('SIGINT'));
-        process.on('SIGTERM', () => shutdown('SIGTERM'));
-    }
-    catch (error) {
-        console.error('Failed to start server:', error);
-        process.exit(1);
-    }
-}
-if (require.main === module) {
-    main();
-}
-var server_1 = require("./infrastructure/rpc/server");
-Object.defineProperty(exports, "createWorkflowLookupServer", { enumerable: true, get: function () { return server_1.createWorkflowLookupServer; } });
+exports.startServer = exports.DI = exports.resetContainer = exports.container = exports.initializeContainer = exports.bootstrap = void 0;
+var container_js_1 = require("./di/container.js");
+Object.defineProperty(exports, "bootstrap", { enumerable: true, get: function () { return container_js_1.bootstrap; } });
+Object.defineProperty(exports, "initializeContainer", { enumerable: true, get: function () { return container_js_1.initializeContainer; } });
+Object.defineProperty(exports, "container", { enumerable: true, get: function () { return container_js_1.container; } });
+Object.defineProperty(exports, "resetContainer", { enumerable: true, get: function () { return container_js_1.resetContainer; } });
+var tokens_js_1 = require("./di/tokens.js");
+Object.defineProperty(exports, "DI", { enumerable: true, get: function () { return tokens_js_1.DI; } });
+var server_js_1 = require("./mcp/server.js");
+Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return server_js_1.startServer; } });

package/dist/infrastructure/index.d.ts

@@ -1,2 +1 @@
 export * from './storage';
-export * from './rpc';

package/dist/infrastructure/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./storage"), exports);
-__exportStar(require("./rpc"), exports);

package/dist/infrastructure/session/DashboardHeartbeat.d.ts

@@ -0,0 +1,8 @@
+export declare class DashboardHeartbeat {
+    private readonly lockFile;
+    private readonly isPrimary;
+    private timer;
+    constructor(lockFile: string, isPrimary: () => boolean);
+    start(): void;
+    stop(): void;
+}

package/dist/infrastructure/session/DashboardHeartbeat.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardHeartbeat = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+class DashboardHeartbeat {
+    constructor(lockFile, isPrimary) {
+        this.lockFile = lockFile;
+        this.isPrimary = isPrimary;
+        this.timer = null;
+    }
+    start() {
+        this.stop();
+        this.timer = setInterval(async () => {
+            if (!this.isPrimary())
+                return;
+            try {
+                const lockContent = await promises_1.default.readFile(this.lockFile, 'utf-8');
+                const lockData = JSON.parse(lockContent);
+                lockData.lastHeartbeat = new Date().toISOString();
+                await promises_1.default.writeFile(this.lockFile, JSON.stringify(lockData, null, 2));
+            }
+            catch {
+            }
+        }, 30000);
+        if (this.timer.unref) {
+            this.timer.unref();
+        }
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+}
+exports.DashboardHeartbeat = DashboardHeartbeat;

package/dist/infrastructure/session/DashboardLockRelease.d.ts

@@ -0,0 +1,2 @@
+export declare function releaseLockFileSync(lockFile: string): void;
+export declare function releaseLockFile(lockFile: string): Promise<void>;

package/dist/infrastructure/session/DashboardLockRelease.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseLockFileSync = releaseLockFileSync;
+exports.releaseLockFile = releaseLockFile;
+const promises_1 = __importDefault(require("fs/promises"));
+function releaseLockFileSync(lockFile) {
+    try {
+        const fsSync = require('fs');
+        fsSync.unlinkSync(lockFile);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+async function releaseLockFile(lockFile) {
+    try {
+        await promises_1.default.unlink(lockFile);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}

package/dist/infrastructure/session/HttpServer.d.ts

@@ -1,24 +1,44 @@
 import { SessionManager } from './SessionManager.js';
+import type { ProcessLifecyclePolicy } from '../../runtime/process-lifecycle-policy.js';
+import type { ProcessSignals } from '../../runtime/ports/process-signals.js';
+import type { ShutdownEvents } from '../../runtime/ports/shutdown-events.js';
+export type DashboardMode = {
+    kind: 'unified';
+} | {
+    kind: 'legacy';
+};
+export type BrowserBehavior = {
+    kind: 'auto_open';
+} | {
+    kind: 'manual';
+};
 export interface ServerConfig {
     port?: number;
-    autoOpen?: boolean;
-    disableUnifiedDashboard?: boolean;
+    browserBehavior?: BrowserBehavior;
+    dashboardMode?: DashboardMode;
 }
 export declare class HttpServer {
     private sessionManager;
-    private config;
+    private readonly processLifecyclePolicy;
+    private readonly processSignals;
+    private readonly shutdownEvents;
+    private readonly dashboardMode;
+    private readonly browserBehavior;
     private app;
     private server;
     private port;
     private baseUrl;
     private isPrimary;
     private lockFile;
-    private heartbeatInterval;
-    constructor(sessionManager: SessionManager, config?: ServerConfig);
+    private readonly heartbeat;
+    constructor(sessionManager: SessionManager, processLifecyclePolicy: ProcessLifecyclePolicy, processSignals: ProcessSignals, shutdownEvents: ShutdownEvents, dashboardMode: DashboardMode, browserBehavior: BrowserBehavior);
+    private config;
+    setConfig(config: ServerConfig): this;
     private setupMiddleware;
     private setupRoutes;
     start(): Promise<string | null>;
     private tryBecomePrimary;
+    private shouldReclaimLock;
     private reclaimStaleLock;
     private checkHealth;
     private setupPrimaryCleanup;
@@ -29,7 +49,6 @@ export declare class HttpServer {
     stop(): Promise<void>;
     getBaseUrl(): string;
     getPort(): number;
-    private startHeartbeat;
     private quickCleanup;
     private getWorkrailPorts;
     fullCleanup(): Promise<number>;

package/dist/infrastructure/session/HttpServer.js

@@ -1,4 +1,16 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,23 +21,40 @@ const http_1 = require("http");
 const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
+const tsyringe_1 = require("tsyringe");
+const tokens_js_1 = require("../../di/tokens.js");
+const SessionManager_js_1 = require("./SessionManager.js");
+const DashboardHeartbeat_js_1 = require("./DashboardHeartbeat.js");
+const DashboardLockRelease_js_1 = require("./DashboardLockRelease.js");
 const cors_1 = __importDefault(require("cors"));
 const open_1 = __importDefault(require("open"));
 const child_process_1 = require("child_process");
-class HttpServer {
-    constructor(sessionManager, config = {}) {
+let HttpServer = class HttpServer {
+    constructor(sessionManager, processLifecyclePolicy, processSignals, shutdownEvents, dashboardMode, browserBehavior) {
         this.sessionManager = sessionManager;
-        this.config = config;
+        this.processLifecyclePolicy = processLifecyclePolicy;
+        this.processSignals = processSignals;
+        this.shutdownEvents = shutdownEvents;
+        this.dashboardMode = dashboardMode;
+        this.browserBehavior = browserBehavior;
         this.server = null;
         this.baseUrl = '';
         this.isPrimary = false;
-        this.heartbeatInterval = null;
-        this.port = config.port || 3456;
+        this.config = {};
+        this.port = 3456;
         this.lockFile = path_1.default.join(os_1.default.homedir(), '.workrail', 'dashboard.lock');
+        this.heartbeat = new DashboardHeartbeat_js_1.DashboardHeartbeat(this.lockFile, () => this.isPrimary);
         this.app = (0, express_1.default)();
         this.setupMiddleware();
         this.setupRoutes();
     }
+    setConfig(config) {
+        this.config = config;
+        if (config.port) {
+            this.port = config.port;
+        }
+        return this;
+    }
     setupMiddleware() {
         this.app.use((0, cors_1.default)({
             origin: '*',
@@ -150,34 +179,102 @@ class HttpServer {
         });
         this.app.get('/api/sessions/:workflow/:id/stream', async (req, res) => {
             const { workflow, id } = req.params;
+            let isCleanedUp = false;
+            let keepaliveInterval = null;
+            let maxConnectionTimeout = null;
+            const cleanup = () => {
+                if (isCleanedUp)
+                    return;
+                isCleanedUp = true;
+                if (keepaliveInterval) {
+                    clearInterval(keepaliveInterval);
+                    keepaliveInterval = null;
+                }
+                if (maxConnectionTimeout) {
+                    clearTimeout(maxConnectionTimeout);
+                    maxConnectionTimeout = null;
+                }
+                try {
+                    this.sessionManager.off('session:updated', onUpdate);
+                }
+                catch { }
+                try {
+                    this.sessionManager.unwatchSession(workflow, id);
+                }
+                catch { }
+                try {
+                    if (!res.writableEnded) {
+                        res.end();
+                    }
+                }
+                catch { }
+            };
+            const onUpdate = (event) => {
+                if (isCleanedUp || event.workflowId !== workflow || event.sessionId !== id) {
+                    return;
+                }
+                if (res.writableEnded) {
+                    cleanup();
+                    return;
+                }
+                try {
+                    res.write(`data: ${JSON.stringify({ type: 'update', session: event.session })}\n\n`);
+                }
+                catch (error) {
+                    console.error(`[SSE] Write error for ${workflow}/${id}:`, error);
+                    cleanup();
+                }
+            };
+            const safeWrite = (data) => {
+                if (isCleanedUp || res.writableEnded) {
+                    cleanup();
+                    return false;
+                }
+                try {
+                    res.write(data);
+                    return true;
+                }
+                catch (error) {
+                    console.error(`[SSE] Write error for ${workflow}/${id}:`, error);
+                    cleanup();
+                    return false;
+                }
+            };
             res.setHeader('Content-Type', 'text/event-stream');
             res.setHeader('Cache-Control', 'no-cache');
             res.setHeader('Connection', 'keep-alive');
             res.setHeader('X-Accel-Buffering', 'no');
-            res.write(`data: ${JSON.stringify({ type: 'connected', workflowId: workflow, sessionId: id })}\n\n`);
+            maxConnectionTimeout = setTimeout(() => {
+                console.error(`[SSE] Max connection time reached for ${workflow}/${id}, closing`);
+                cleanup();
+            }, 30 * 60 * 1000);
+            if (!safeWrite(`data: ${JSON.stringify({ type: 'connected', workflowId: workflow, sessionId: id })}\n\n`)) {
+                return;
+            }
             try {
                 const session = await this.sessionManager.getSession(workflow, id);
-                if (session) {
-                    res.write(`data: ${JSON.stringify({ type: 'update', session })}\n\n`);
+                if (session && !isCleanedUp) {
+                    safeWrite(`data: ${JSON.stringify({ type: 'update', session })}\n\n`);
                 }
             }
             catch (error) {
             }
-            const onUpdate = (event) => {
-                if (event.workflowId === workflow && event.sessionId === id) {
-                    res.write(`data: ${JSON.stringify({ type: 'update', session: event.session })}\n\n`);
-                }
-            };
             this.sessionManager.on('session:updated', onUpdate);
             this.sessionManager.watchSession(workflow, id);
-            const keepalive = setInterval(() => {
-                res.write(`:keepalive\n\n`);
+            keepaliveInterval = setInterval(() => {
+                if (!safeWrite(`:keepalive\n\n`)) {
+                }
             }, 30000);
-            req.on('close', () => {
-                this.sessionManager.off('session:updated', onUpdate);
-                clearInterval(keepalive);
-                res.end();
+            req.on('close', cleanup);
+            req.on('error', (error) => {
+                console.error(`[SSE] Request error for ${workflow}/${id}:`, error);
+                cleanup();
+            });
+            res.on('error', (error) => {
+                console.error(`[SSE] Response error for ${workflow}/${id}:`, error);
+                cleanup();
             });
+            res.on('finish', cleanup);
         });
         this.app.delete('/api/sessions/:workflow/:id', async (req, res) => {
             try {
@@ -241,7 +338,8 @@ class HttpServer {
     }
     async start() {
         await this.quickCleanup();
-        if (this.config.disableUnifiedDashboard || process.env.WORKRAIL_DISABLE_UNIFIED_DASHBOARD === '1') {
+        const mode = this.config.dashboardMode ?? this.dashboardMode;
+        if (mode.kind === 'legacy') {
             console.error('[Dashboard] Unified dashboard disabled, using legacy mode');
             return await this.startLegacyMode();
         }
@@ -279,7 +377,7 @@ class HttpServer {
             console.error('[Dashboard] Primary elected');
             this.isPrimary = true;
             this.setupPrimaryCleanup();
-            this.startHeartbeat();
+            this.heartbeat.start();
             return true;
         }
         catch (error) {
@@ -293,50 +391,80 @@ class HttpServer {
             throw error;
         }
     }
+    shouldReclaimLock(lockData) {
+        if (!lockData.pid || !lockData.port || !lockData.startedAt) {
+            return { reclaim: true, reason: 'invalid lock structure' };
+        }
+        const lastHeartbeat = new Date(lockData.lastHeartbeat || lockData.startedAt);
+        const ageMinutes = (Date.now() - lastHeartbeat.getTime()) / 60000;
+        if (ageMinutes > 2) {
+            return { reclaim: true, reason: `stale (${ageMinutes.toFixed(1)}min old)` };
+        }
+        try {
+            process.kill(lockData.pid, 0);
+        }
+        catch {
+            return { reclaim: true, reason: `PID ${lockData.pid} dead` };
+        }
+        return { reclaim: false, reason: 'valid' };
+    }
     async reclaimStaleLock() {
         try {
             const lockContent = await promises_1.default.readFile(this.lockFile, 'utf-8');
             const lockData = JSON.parse(lockContent);
-            if (!lockData.pid || !lockData.port || !lockData.startedAt) {
-                console.error('[Dashboard] Invalid lock file, reclaiming');
-                await promises_1.default.unlink(this.lockFile);
-                return await this.tryBecomePrimary();
-            }
-            const lastHeartbeat = new Date(lockData.lastHeartbeat || lockData.startedAt);
-            const ageMinutes = (Date.now() - lastHeartbeat.getTime()) / 60000;
-            if (ageMinutes > 2) {
-                console.error(`[Dashboard] Stale lock detected (${ageMinutes.toFixed(1)}min old), reclaiming`);
-                await promises_1.default.unlink(this.lockFile);
-                return await this.tryBecomePrimary();
-            }
-            let processExists = false;
-            try {
-                process.kill(lockData.pid, 0);
-                processExists = true;
-            }
-            catch {
-                processExists = false;
-            }
-            if (!processExists) {
-                console.error(`[Dashboard] Stale lock detected (PID ${lockData.pid} dead), reclaiming`);
-                await promises_1.default.unlink(this.lockFile);
-                return await this.tryBecomePrimary();
-            }
-            const isHealthy = await this.checkHealth(lockData.port);
-            if (!isHealthy) {
-                console.error(`[Dashboard] Primary (PID ${lockData.pid}) not responding, reclaiming`);
+            const { reclaim, reason } = this.shouldReclaimLock(lockData);
+            if (!reclaim) {
+                const isHealthy = await this.checkHealth(lockData.port);
+                if (isHealthy) {
+                    return false;
+                }
+                console.error(`[Dashboard] Primary (PID ${lockData.pid}) not responding, attempting graceful shutdown`);
                 try {
                     process.kill(lockData.pid, 'SIGTERM');
                     await new Promise(resolve => setTimeout(resolve, 2000));
                 }
                 catch { }
-                await promises_1.default.unlink(this.lockFile);
-                return await this.tryBecomePrimary();
+                const stillHealthy = await this.checkHealth(lockData.port);
+                if (stillHealthy) {
+                    return false;
+                }
+            }
+            else {
+                console.error(`[Dashboard] Lock reclaim needed: ${reason}`);
+            }
+            const tempPath = `${this.lockFile}.${process.pid}.${Date.now()}`;
+            const newLockData = {
+                pid: process.pid,
+                port: 3456,
+                startedAt: new Date().toISOString(),
+                lastHeartbeat: new Date().toISOString(),
+                projectId: this.sessionManager.getProjectId(),
+                projectPath: this.sessionManager.getProjectPath()
+            };
+            try {
+                await promises_1.default.writeFile(tempPath, JSON.stringify(newLockData, null, 2));
+                await promises_1.default.rename(tempPath, this.lockFile);
+                console.error('[Dashboard] Lock reclaimed successfully');
+                this.isPrimary = true;
+                this.setupPrimaryCleanup();
+                this.heartbeat.start();
+                return true;
+            }
+            catch (error) {
+                await promises_1.default.unlink(tempPath).catch(() => { });
+                if (error.code === 'ENOENT') {
+                    console.error('[Dashboard] Lock deleted during reclaim, trying fresh');
+                    return await this.tryBecomePrimary();
+                }
+                console.error('[Dashboard] Lock reclaim failed:', error.message);
+                return false;
             }
-            return false;
         }
         catch (error) {
-            console.error('[Dashboard] Corrupted lock file, removing');
+            if (error.code === 'ENOENT') {
+                return await this.tryBecomePrimary();
+            }
+            console.error('[Dashboard] Lock file corrupted, attempting fresh claim');
             await promises_1.default.unlink(this.lockFile).catch(() => { });
             return await this.tryBecomePrimary();
         }
@@ -359,21 +487,44 @@ class HttpServer {
         }
     }
     setupPrimaryCleanup() {
-        const cleanup = async () => {
-            if (this.isPrimary) {
-                console.error('[Dashboard] Primary shutting down, releasing lock');
-                if (this.heartbeatInterval) {
-                    clearInterval(this.heartbeatInterval);
-                    this.heartbeatInterval = null;
+        if (this.processLifecyclePolicy.kind === 'no_signal_handlers') {
+            return;
+        }
+        let isCleaningUp = false;
+        const cleanupSync = () => {
+            if (isCleaningUp || !this.isPrimary)
+                return;
+            isCleaningUp = true;
+            console.error('[Dashboard] Primary shutting down (sync cleanup)');
+            this.heartbeat.stop();
+            try {
+                (0, DashboardLockRelease_js_1.releaseLockFileSync)(this.lockFile);
+                console.error('[Dashboard] Lock file released');
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error('[Dashboard] Failed to release lock file:', error.message);
                 }
-                await promises_1.default.unlink(this.lockFile).catch(() => { });
-                this.isPrimary = false;
             }
+            this.isPrimary = false;
         };
-        process.on('exit', cleanup);
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-        process.on('SIGHUP', cleanup);
+        const signalHandler = (signal) => {
+            if (isCleaningUp)
+                return;
+            isCleaningUp = true;
+            console.error(`[Dashboard] Received ${signal}`);
+            this.stop()
+                .catch(err => console.error('[Dashboard] Cleanup error:', err))
+                .finally(() => {
+                if (signal !== 'exit') {
+                    this.shutdownEvents.emit({ kind: 'shutdown_requested', signal });
+                }
+            });
+        };
+        this.processSignals.on('exit', cleanupSync);
+        this.processSignals.on('SIGINT', () => signalHandler('SIGINT'));
+        this.processSignals.on('SIGTERM', () => signalHandler('SIGTERM'));
+        this.processSignals.on('SIGHUP', () => signalHandler('SIGHUP'));
     }
     async startAsPrimary() {
         await new Promise((resolve, reject) => {
@@ -438,7 +589,8 @@ class HttpServer {
         if (sessionId) {
             url += `?session=${sessionId}`;
         }
-        if (this.config.autoOpen !== false) {
+        const behavior = this.config.browserBehavior ?? this.browserBehavior;
+        if (behavior.kind === 'auto_open') {
             try {
                 await (0, open_1.default)(url);
                 console.error(`🌐 Opened dashboard: ${url}`);
@@ -450,18 +602,25 @@ class HttpServer {
         return url;
     }
     async stop() {
+        this.heartbeat.stop();
         this.sessionManager.unwatchAll();
-        return new Promise((resolve) => {
-            if (this.server) {
-                this.server.close(() => {
-                    console.error('HTTP server stopped');
-                    resolve();
-                });
-            }
-            else {
+        await new Promise((resolve) => {
+            if (!this.server)
+                return resolve();
+            const closeTimeout = setTimeout(() => {
+                console.error('[Dashboard] Server close timeout after 5s, forcing shutdown');
                 resolve();
-            }
+            }, 5000);
+            this.server.close(() => {
+                clearTimeout(closeTimeout);
+                console.error('HTTP server stopped');
+                resolve();
+            });
         });
+        if (this.isPrimary) {
+            await (0, DashboardLockRelease_js_1.releaseLockFile)(this.lockFile).catch(() => { });
+            this.isPrimary = false;
+        }
     }
     getBaseUrl() {
         return this.baseUrl;
@@ -469,20 +628,6 @@ class HttpServer {
     getPort() {
         return this.port;
     }
-    startHeartbeat() {
-        this.heartbeatInterval = setInterval(async () => {
-            if (this.isPrimary) {
-                try {
-                    const lockContent = await promises_1.default.readFile(this.lockFile, 'utf-8');
-                    const lockData = JSON.parse(lockContent);
-                    lockData.lastHeartbeat = new Date().toISOString();
-                    await promises_1.default.writeFile(this.lockFile, JSON.stringify(lockData, null, 2));
-                }
-                catch (error) {
-                }
-            }
-        }, 30000);
-    }
     async quickCleanup() {
         try {
             const busyPorts = await this.getWorkrailPorts();
@@ -602,5 +747,15 @@ class HttpServer {
             throw error;
         }
     }
-}
+};
 exports.HttpServer = HttpServer;
+exports.HttpServer = HttpServer = __decorate([
+    (0, tsyringe_1.singleton)(),
+    __param(0, (0, tsyringe_1.inject)(SessionManager_js_1.SessionManager)),
+    __param(1, (0, tsyringe_1.inject)(tokens_js_1.DI.Runtime.ProcessLifecyclePolicy)),
+    __param(2, (0, tsyringe_1.inject)(tokens_js_1.DI.Runtime.ProcessSignals)),
+    __param(3, (0, tsyringe_1.inject)(tokens_js_1.DI.Runtime.ShutdownEvents)),
+    __param(4, (0, tsyringe_1.inject)(tokens_js_1.DI.Config.DashboardMode)),
+    __param(5, (0, tsyringe_1.inject)(tokens_js_1.DI.Config.BrowserBehavior)),
+    __metadata("design:paramtypes", [SessionManager_js_1.SessionManager, Object, Object, Object, Object, Object])
+], HttpServer);

package/dist/infrastructure/session/SessionDataNormalizer.js

@@ -1,7 +1,14 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionDataNormalizer = void 0;
-class SessionDataNormalizer {
+const tsyringe_1 = require("tsyringe");
+let SessionDataNormalizer = class SessionDataNormalizer {
     normalize(workflowId, data) {
         if (!data || typeof data !== 'object') {
             return {};
@@ -207,5 +214,8 @@ class SessionDataNormalizer {
                 return 'active';
         }
     }
-}
+};
 exports.SessionDataNormalizer = SessionDataNormalizer;
+exports.SessionDataNormalizer = SessionDataNormalizer = __decorate([
+    (0, tsyringe_1.singleton)()
+], SessionDataNormalizer);