@exaudeus/workrail 3.40.0 → 3.41.0

package/dist/infrastructure/session/HttpServer.js

@@ -1,912 +0,0 @@
-"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 };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpServer = void 0;
-const express_1 = __importDefault(require("express"));
-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");
-const _pkg = require(path_1.default.join(__dirname, '../../../package.json'));
-const CURRENT_VERSION = _pkg.version;
-let HttpServer = class HttpServer {
-    constructor(sessionManager, processLifecyclePolicy, processSignals, shutdownEvents, dashboardMode, browserBehavior) {
-        this.sessionManager = sessionManager;
-        this.processLifecyclePolicy = processLifecyclePolicy;
-        this.processSignals = processSignals;
-        this.shutdownEvents = shutdownEvents;
-        this.dashboardMode = dashboardMode;
-        this.browserBehavior = browserBehavior;
-        this.server = null;
-        this.baseUrl = '';
-        this.isPrimary = false;
-        this._stopPromise = null;
-        this.config = {};
-        this._routeDisposers = [];
-        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;
-        }
-        if (config.lockFilePath) {
-            this.lockFile = config.lockFilePath;
-            this.heartbeat = new DashboardHeartbeat_js_1.DashboardHeartbeat(this.lockFile, () => this.isPrimary);
-        }
-        return this;
-    }
-    setupMiddleware() {
-        this.app.use((0, cors_1.default)({
-            origin: '*',
-            methods: ['GET', 'HEAD', 'OPTIONS'],
-            allowedHeaders: ['Content-Type', 'If-None-Match']
-        }));
-        this.app.set('etag', 'strong');
-        this.app.use(express_1.default.json());
-        this.app.use((req, res, next) => {
-            const start = Date.now();
-            res.on('finish', () => {
-                const duration = Date.now() - start;
-                try {
-                    process.stderr.write(`[HTTP] ${req.method} ${req.path} ${res.statusCode} (${duration}ms)\n`);
-                }
-                catch { }
-            });
-            next();
-        });
-    }
-    setupRoutes() {
-        this.app.get('/', (_req, res) => {
-            res.redirect('/console');
-        });
-        this.app.get('/api/sessions', async (req, res) => {
-            try {
-                const sessions = this.isPrimary
-                    ? await this.sessionManager.listAllProjectsSessions()
-                    : await this.sessionManager.listAllSessions();
-                res.json({
-                    success: true,
-                    count: sessions.length,
-                    unified: this.isPrimary,
-                    sessions: sessions.map(s => ({
-                        id: s.id,
-                        workflowId: s.workflowId,
-                        projectId: s.projectId,
-                        projectPath: s.projectPath,
-                        createdAt: s.createdAt,
-                        updatedAt: s.updatedAt,
-                        url: `/api/sessions/${s.workflowId}/${s.id}`,
-                        data: {
-                            dashboard: s.data?.dashboard || {}
-                        }
-                    }))
-                });
-            }
-            catch (error) {
-                res.status(500).json({
-                    success: false,
-                    error: 'Failed to list sessions',
-                    message: error.message
-                });
-            }
-        });
-        this.app.get('/api/sessions/:workflow/:id', async (req, res) => {
-            try {
-                const { workflow, id } = req.params;
-                const session = await this.sessionManager.getSession(workflow, id);
-                if (!session) {
-                    return res.status(404).json({
-                        success: false,
-                        error: 'Session not found',
-                        workflowId: workflow,
-                        sessionId: id
-                    });
-                }
-                res.json({
-                    success: true,
-                    session
-                });
-            }
-            catch (error) {
-                res.status(500).json({
-                    success: false,
-                    error: 'Failed to get session',
-                    message: error.message
-                });
-            }
-        });
-        this.app.get('/api/current-project', async (req, res) => {
-            try {
-                const project = await this.sessionManager.getCurrentProject();
-                res.json({
-                    success: true,
-                    project
-                });
-            }
-            catch (error) {
-                res.status(500).json({
-                    success: false,
-                    error: 'Failed to get project info',
-                    message: error.message
-                });
-            }
-        });
-        this.app.get('/api/projects', async (req, res) => {
-            try {
-                const projects = await this.sessionManager.listProjects();
-                res.json({
-                    success: true,
-                    count: projects.length,
-                    projects
-                });
-            }
-            catch (error) {
-                res.status(500).json({
-                    success: false,
-                    error: 'Failed to list projects',
-                    message: error.message
-                });
-            }
-        });
-        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) {
-                    try {
-                        process.stderr.write(`[SSE] Write error for ${workflow}/${id}: ${error?.message ?? String(error)}\n`);
-                    }
-                    catch { }
-                    cleanup();
-                }
-            };
-            const safeWrite = (data) => {
-                if (isCleanedUp || res.writableEnded) {
-                    cleanup();
-                    return false;
-                }
-                try {
-                    res.write(data);
-                    return true;
-                }
-                catch (error) {
-                    try {
-                        process.stderr.write(`[SSE] Write error for ${workflow}/${id}: ${error?.message ?? String(error)}\n`);
-                    }
-                    catch { }
-                    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');
-            maxConnectionTimeout = setTimeout(() => {
-                try {
-                    process.stderr.write(`[SSE] Max connection time reached for ${workflow}/${id}, closing\n`);
-                }
-                catch { }
-                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 && !isCleanedUp) {
-                    safeWrite(`data: ${JSON.stringify({ type: 'update', session })}\n\n`);
-                }
-            }
-            catch (error) {
-            }
-            this.sessionManager.on('session:updated', onUpdate);
-            this.sessionManager.watchSession(workflow, id);
-            keepaliveInterval = setInterval(() => {
-                if (!safeWrite(`:keepalive\n\n`)) {
-                }
-            }, 30000);
-            req.on('close', cleanup);
-            req.on('error', (error) => {
-                try {
-                    process.stderr.write(`[SSE] Request error for ${workflow}/${id}: ${error?.message ?? String(error)}\n`);
-                }
-                catch { }
-                cleanup();
-            });
-            res.on('error', (error) => {
-                try {
-                    process.stderr.write(`[SSE] Response error for ${workflow}/${id}: ${error?.message ?? String(error)}\n`);
-                }
-                catch { }
-                cleanup();
-            });
-            res.on('finish', cleanup);
-        });
-        this.app.delete('/api/sessions/:workflow/:id', async (req, res) => {
-            try {
-                const { workflow, id } = req.params;
-                const result = await this.sessionManager.deleteSession(workflow, id);
-                if (result.isErr()) {
-                    const status = result.error.code === 'SESSION_NOT_FOUND' ? 404 : 500;
-                    res.status(status).json({ success: false, error: result.error.message });
-                    return;
-                }
-                res.json({
-                    success: true,
-                    message: `Session ${workflow}/${id} deleted successfully`
-                });
-            }
-            catch (error) {
-                try {
-                    process.stderr.write(`[HttpServer] Delete session error: ${error?.message ?? String(error)}\n`);
-                }
-                catch { }
-                res.status(500).json({
-                    success: false,
-                    error: error.message || 'Failed to delete session'
-                });
-            }
-        });
-        this.app.post('/api/sessions/bulk-delete', async (req, res) => {
-            try {
-                const { sessions } = req.body;
-                if (!Array.isArray(sessions)) {
-                    return res.status(400).json({
-                        success: false,
-                        error: 'Body must contain "sessions" array'
-                    });
-                }
-                await this.sessionManager.deleteSessions(sessions);
-                res.json({
-                    success: true,
-                    message: `Deleted ${sessions.length} session(s)`,
-                    count: sessions.length
-                });
-            }
-            catch (error) {
-                try {
-                    process.stderr.write(`[HttpServer] Bulk delete error: ${error?.message ?? String(error)}\n`);
-                }
-                catch { }
-                res.status(500).json({
-                    success: false,
-                    error: error.message || 'Failed to delete sessions'
-                });
-            }
-        });
-        this.app.get('/api/health', (_req, res) => {
-            res.json({
-                success: true,
-                status: 'healthy',
-                uptime: process.uptime(),
-                timestamp: new Date().toISOString(),
-                isPrimary: this.isPrimary,
-                pid: process.pid,
-                port: this.port,
-                version: CURRENT_VERSION
-            });
-        });
-    }
-    async start() {
-        this._stopPromise = null;
-        const mode = this.config.dashboardMode ?? this.dashboardMode;
-        if (mode.kind === 'legacy') {
-            try {
-                process.stderr.write('[Dashboard] Unified dashboard disabled, using legacy mode\n');
-            }
-            catch { }
-            return await this.startLegacyMode();
-        }
-        if (await this.tryBecomePrimary()) {
-            try {
-                await this.startAsPrimary();
-                return this.baseUrl;
-            }
-            catch (error) {
-                if (error.code === 'EADDRINUSE') {
-                    try {
-                        process.stderr.write(`[Dashboard] Port ${this.port} still held by previous instance -- ` +
-                            `running on next available port. Restart the old instance to move to ${this.port}.\n`);
-                    }
-                    catch { }
-                    await promises_1.default.unlink(this.lockFile).catch(() => { });
-                    return await this.startLegacyMode();
-                }
-                throw error;
-            }
-        }
-        else {
-            try {
-                process.stderr.write(`[Dashboard] Unified dashboard at http://localhost:${this.port}\n`);
-            }
-            catch { }
-            return null;
-        }
-    }
-    async tryBecomePrimary() {
-        try {
-            await promises_1.default.mkdir(path_1.default.dirname(this.lockFile), { recursive: true });
-            const lockData = {
-                pid: process.pid,
-                port: this.port,
-                startedAt: new Date().toISOString(),
-                lastHeartbeat: new Date().toISOString(),
-                projectId: this.sessionManager.getProjectId(),
-                projectPath: this.sessionManager.getProjectPath(),
-                version: CURRENT_VERSION
-            };
-            await promises_1.default.writeFile(this.lockFile, JSON.stringify(lockData, null, 2), { flag: 'wx' });
-            try {
-                process.stderr.write('[Dashboard] Primary elected\n');
-            }
-            catch { }
-            this.isPrimary = true;
-            this.setupPrimaryCleanup();
-            this.heartbeat.start();
-            return true;
-        }
-        catch (error) {
-            if (error.code === 'EEXIST') {
-                return await this.reclaimStaleLock();
-            }
-            else if (error.code === 'EACCES' || error.code === 'EPERM') {
-                try {
-                    process.stderr.write('[Dashboard] Cannot write lock file (permission denied)\n');
-                }
-                catch { }
-                return false;
-            }
-            throw error;
-        }
-    }
-    shouldReclaimLock(lockData) {
-        if (!lockData.pid || !lockData.port || !lockData.startedAt) {
-            return { reclaim: true, reason: 'invalid lock structure' };
-        }
-        if (lockData.projectId) {
-            const currentProjectId = this.sessionManager.getProjectId();
-            if (lockData.projectId !== currentProjectId) {
-                try {
-                    process.kill(lockData.pid, 0);
-                    return { reclaim: false, reason: `different project, primary alive (lock=${lockData.projectId}, current=${currentProjectId})` };
-                }
-                catch {
-                }
-            }
-        }
-        if (lockData.version !== CURRENT_VERSION) {
-            return { reclaim: true, reason: `version mismatch (lock=${lockData.version}, current=${CURRENT_VERSION})` };
-        }
-        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);
-            const { reclaim, reason } = this.shouldReclaimLock(lockData);
-            if (!reclaim) {
-                try {
-                    process.stderr.write(`[Dashboard] Secondary mode: primary lock valid (PID ${lockData.pid}), yielding\n`);
-                }
-                catch { }
-                return false;
-            }
-            else {
-                try {
-                    process.stderr.write(`[Dashboard] Lock reclaim needed: ${reason}\n`);
-                }
-                catch { }
-            }
-            const tempPath = `${this.lockFile}.${process.pid}.${Date.now()}`;
-            const newLockData = {
-                pid: process.pid,
-                port: this.port,
-                startedAt: new Date().toISOString(),
-                lastHeartbeat: new Date().toISOString(),
-                projectId: this.sessionManager.getProjectId(),
-                projectPath: this.sessionManager.getProjectPath(),
-                version: CURRENT_VERSION
-            };
-            try {
-                await promises_1.default.writeFile(tempPath, JSON.stringify(newLockData, null, 2));
-                let retries = 3;
-                let renamed = false;
-                while (retries > 0 && !renamed) {
-                    try {
-                        await promises_1.default.rename(tempPath, this.lockFile);
-                        renamed = true;
-                    }
-                    catch (err) {
-                        if (err.code === 'EPERM' && process.platform === 'win32' && retries > 1) {
-                            await new Promise(resolve => setTimeout(resolve, 10));
-                            retries--;
-                            continue;
-                        }
-                        throw err;
-                    }
-                }
-                try {
-                    const writtenContent = await promises_1.default.readFile(this.lockFile, 'utf-8');
-                    const writtenData = JSON.parse(writtenContent);
-                    if (writtenData.pid !== process.pid) {
-                        try {
-                            process.stderr.write(`[Dashboard] Lost lock election (winner PID ${writtenData.pid}), yielding\n`);
-                        }
-                        catch { }
-                        return false;
-                    }
-                }
-                catch {
-                    return await this.tryBecomePrimary();
-                }
-                try {
-                    process.stderr.write('[Dashboard] Lock reclaimed successfully\n');
-                }
-                catch { }
-                this.isPrimary = true;
-                this.setupPrimaryCleanup();
-                this.heartbeat.start();
-                return true;
-            }
-            catch (error) {
-                await promises_1.default.unlink(tempPath).catch(() => { });
-                if (error.code === 'ENOENT') {
-                    try {
-                        process.stderr.write('[Dashboard] Lock deleted during reclaim, trying fresh\n');
-                    }
-                    catch { }
-                    return await this.tryBecomePrimary();
-                }
-                try {
-                    process.stderr.write(`[Dashboard] Lock reclaim failed: ${error.message}\n`);
-                }
-                catch { }
-                return false;
-            }
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                return await this.tryBecomePrimary();
-            }
-            try {
-                process.stderr.write('[Dashboard] Lock file corrupted, attempting fresh claim\n');
-            }
-            catch { }
-            await promises_1.default.unlink(this.lockFile).catch(() => { });
-            return await this.tryBecomePrimary();
-        }
-    }
-    setupPrimaryCleanup() {
-        if (this.processLifecyclePolicy.kind === 'no_signal_handlers') {
-            return;
-        }
-        let isCleaningUp = false;
-        const cleanupSync = () => {
-            if (isCleaningUp || !this.isPrimary)
-                return;
-            isCleaningUp = true;
-            try {
-                process.stderr.write('[Dashboard] Primary shutting down (sync cleanup)\n');
-            }
-            catch { }
-            this.heartbeat.stop();
-            try {
-                (0, DashboardLockRelease_js_1.releaseLockFileSync)(this.lockFile);
-                try {
-                    process.stderr.write('[Dashboard] Lock file released\n');
-                }
-                catch { }
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT') {
-                    try {
-                        process.stderr.write(`[Dashboard] Failed to release lock file: ${error.message}\n`);
-                    }
-                    catch { }
-                }
-            }
-            this.isPrimary = false;
-        };
-        const signalHandler = (signal) => {
-            if (isCleaningUp)
-                return;
-            isCleaningUp = true;
-            try {
-                process.stderr.write(`[Dashboard] Received ${signal}\n`);
-            }
-            catch { }
-            this.stop()
-                .catch(err => { try {
-                process.stderr.write(`[Dashboard] Cleanup error: ${err.message}\n`);
-            }
-            catch { } })
-                .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) => {
-            this.server = (0, http_1.createServer)(this.app);
-            this.server.on('error', (error) => {
-                reject(error);
-            });
-            const listenPort = this.port;
-            this.server.listen(listenPort, '127.0.0.1', () => {
-                this.baseUrl = `http://localhost:${listenPort}`;
-                this.printBanner();
-                resolve();
-            });
-        });
-    }
-    async startLegacyMode() {
-        this.port = 3457;
-        while (this.port < 3500) {
-            try {
-                await new Promise((resolve, reject) => {
-                    this.server = (0, http_1.createServer)(this.app);
-                    this.server.on('error', (error) => {
-                        if (error.code === 'EADDRINUSE') {
-                            reject(new Error('Port in use'));
-                        }
-                        else {
-                            reject(error);
-                        }
-                    });
-                    this.server.listen(this.port, '127.0.0.1', () => {
-                        resolve();
-                    });
-                });
-                this.baseUrl = `http://localhost:${this.port}`;
-                try {
-                    process.stderr.write(`[Dashboard] Started in legacy mode on port ${this.port}\n`);
-                }
-                catch { }
-                this.printBanner();
-                return this.baseUrl;
-            }
-            catch (error) {
-                if (error.message === 'Port in use') {
-                    this.port++;
-                    continue;
-                }
-                throw error;
-            }
-        }
-        this.server = null;
-        throw new Error('No available ports in range 3457-3499');
-    }
-    printBanner() {
-        const line = '═'.repeat(60);
-        try {
-            process.stderr.write(`\n${line}\n`);
-        }
-        catch { }
-        try {
-            process.stderr.write(`🔧 Workrail MCP Server Started\n`);
-        }
-        catch { }
-        try {
-            process.stderr.write(`${line}\n`);
-        }
-        catch { }
-        try {
-            process.stderr.write(`📊 Dashboard: ${this.baseUrl} ${this.isPrimary ? '(PRIMARY - All Projects)' : '(Legacy Mode)'}\n`);
-        }
-        catch { }
-        try {
-            process.stderr.write(`💾 Sessions:  ${this.sessionManager.getSessionsRoot()}\n`);
-        }
-        catch { }
-        try {
-            process.stderr.write(`🏗️  Project:   ${this.sessionManager.getProjectId()}\n`);
-        }
-        catch { }
-        try {
-            process.stderr.write(`${line}\n\n`);
-        }
-        catch { }
-    }
-    async openDashboard(sessionId) {
-        if (!this.baseUrl) {
-            throw new Error('Dashboard is unavailable -- the HTTP server did not start successfully ' +
-                '(likely due to port exhaustion). MCP tools still work normally.');
-        }
-        let url = this.baseUrl;
-        if (sessionId) {
-            url += `?session=${sessionId}`;
-        }
-        const behavior = this.config.browserBehavior ?? this.browserBehavior;
-        if (behavior.kind === 'auto_open') {
-            try {
-                await (0, open_1.default)(url);
-                try {
-                    process.stderr.write(`Opened dashboard: ${url}\n`);
-                }
-                catch { }
-            }
-            catch (error) {
-                try {
-                    process.stderr.write(`Dashboard URL: ${url} (auto-open failed, please open manually)\n`);
-                }
-                catch { }
-            }
-        }
-        return url;
-    }
-    async stop() {
-        if (this._stopPromise !== null)
-            return this._stopPromise;
-        if (this.server === null)
-            return Promise.resolve();
-        this._stopPromise = this._runStop();
-        return this._stopPromise;
-    }
-    async _runStop() {
-        this.heartbeat.stop();
-        this.sessionManager.unwatchAll();
-        for (const dispose of this._routeDisposers) {
-            try {
-                dispose();
-            }
-            catch { }
-        }
-        this._routeDisposers.length = 0;
-        await new Promise((resolve) => {
-            if (!this.server)
-                return resolve();
-            const closeTimeout = setTimeout(() => {
-                try {
-                    process.stderr.write('[Dashboard] Server close timeout after 5s, forcing shutdown\n');
-                }
-                catch { }
-                resolve();
-            }, 5000);
-            this.server.close(() => {
-                clearTimeout(closeTimeout);
-                try {
-                    process.stderr.write('HTTP server stopped\n');
-                }
-                catch { }
-                resolve();
-            });
-        });
-        if (this.isPrimary) {
-            await (0, DashboardLockRelease_js_1.releaseLockFile)(this.lockFile).catch(() => { });
-            this.isPrimary = false;
-        }
-    }
-    mountRoutes(installer) {
-        const disposer = installer(this.app);
-        if (disposer != null) {
-            this._routeDisposers.push(disposer);
-        }
-    }
-    finalize() {
-        this.app.use((req, res) => {
-            res.status(404).json({
-                success: false,
-                error: 'Not found',
-                path: req.path,
-            });
-        });
-    }
-    getBaseUrl() {
-        return this.baseUrl;
-    }
-    getPort() {
-        return this.port;
-    }
-    async fullCleanup() {
-        try {
-            const busyPorts = await this.getWorkrailPorts();
-            if (busyPorts.length === 0) {
-                try {
-                    process.stderr.write('[Cleanup] No workrail processes found\n');
-                }
-                catch { }
-                return 0;
-            }
-            try {
-                process.stderr.write(`[Cleanup] Found ${busyPorts.length} workrail process(es), removing all...\n`);
-            }
-            catch { }
-            let cleanedCount = 0;
-            for (const { port, pid } of busyPorts) {
-                if (pid === process.pid) {
-                    try {
-                        process.stderr.write(`[Cleanup] Skipping current process ${pid}\n`);
-                    }
-                    catch { }
-                    continue;
-                }
-                try {
-                    process.stderr.write(`[Cleanup] Killing process ${pid} on port ${port}\n`);
-                }
-                catch { }
-                try {
-                    process.kill(pid, 'SIGTERM');
-                    await new Promise(r => setTimeout(r, 1000));
-                    try {
-                        process.kill(pid, 0);
-                        process.kill(pid, 'SIGKILL');
-                        try {
-                            process.stderr.write(`[Cleanup] Force killed process ${pid}\n`);
-                        }
-                        catch { }
-                    }
-                    catch {
-                        try {
-                            process.stderr.write(`[Cleanup] Process ${pid} terminated gracefully\n`);
-                        }
-                        catch { }
-                    }
-                    cleanedCount++;
-                }
-                catch (error) {
-                    try {
-                        process.stderr.write(`[Cleanup] Failed to kill process ${pid}: ${error?.message ?? String(error)}\n`);
-                    }
-                    catch { }
-                }
-            }
-            try {
-                process.stderr.write(`[Cleanup] Cleaned up ${cleanedCount} process(es)\n`);
-            }
-            catch { }
-            try {
-                await promises_1.default.unlink(this.lockFile);
-                try {
-                    process.stderr.write('[Cleanup] Removed lock file\n');
-                }
-                catch { }
-            }
-            catch {
-            }
-            return cleanedCount;
-        }
-        catch (error) {
-            try {
-                process.stderr.write(`[Cleanup] Full cleanup failed: ${error?.message ?? String(error)}\n`);
-            }
-            catch { }
-            throw error;
-        }
-    }
-    async getWorkrailPorts() {
-        try {
-            const platform = os_1.default.platform();
-            if (platform === 'darwin' || platform === 'linux') {
-                const output = (0, child_process_1.execSync)('lsof -i :3456-3499 -Pn 2>/dev/null | grep node || true', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-                if (!output)
-                    return [];
-                return output.split('\n').filter(Boolean).map(line => {
-                    const parts = line.trim().split(/\s+/);
-                    const pid = parseInt(parts[1]);
-                    const nameField = parts[8];
-                    const portMatch = nameField.match(/:(\d+)$/);
-                    const port = portMatch ? parseInt(portMatch[1]) : 0;
-                    return { port, pid };
-                }).filter(item => item.port >= 3456 && item.port < 3500 && !isNaN(item.pid));
-            }
-            else if (platform === 'win32') {
-                const output = (0, child_process_1.execSync)('netstat -ano | findstr "3456" || echo', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-                if (!output)
-                    return [];
-                return output.split('\n').filter(Boolean).map(line => {
-                    const parts = line.trim().split(/\s+/);
-                    const state = parts[3] || '';
-                    const address = parts[1] || '';
-                    const pid = parseInt(parts[4]);
-                    const portMatch = address.match(/:(\d+)$/);
-                    const port = portMatch ? parseInt(portMatch[1]) : 0;
-                    return { port, pid, state };
-                }).filter(item => item.state === 'LISTENING' &&
-                    item.port >= 3456 &&
-                    item.port < 3500 &&
-                    !isNaN(item.pid) &&
-                    item.pid > 0).map(({ port, pid }) => ({ port, pid }));
-            }
-            return [];
-        }
-        catch {
-            return [];
-        }
-    }
-};
-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);